Download data/lean/OAI/RepresentationTheory/VertexAlgebra/GeneratorSharpGrowth.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 23 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/GeneratorSharpGrowth.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/VertexAlgebra/GeneratorSharpGrowth.lean
-
curl -L -o GeneratorSharpGrowth.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/GeneratorSharpGrowth.lean
23 kB
| import Mathlib | |
| import OAI.RepresentationTheory.VertexAlgebra.AdjointMass | |
| namespace OAI | |
| /-! Vertex algebra, energy bounds and closed smeared-field operators. -/ | |
| noncomputable section | |
| namespace StronglyRationalVOA | |
| universe u v | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| theorem generator_sharpGrowth (D : β) (S : β β Finset V) {d : β} {a : V} | |
| (hd : 0 < d) (hD : d β€ D) (ha : a β S d) : | |
| A.SharpGrowth (A.sharpMajorant D S) a d := by | |
| have hquant (N : β) : A.sharpColumnQuantity a d N β€ A.sharpMajorant D S N^(2*d) β§ | |
| A.sharpZeroQuantity a d N β€ A.sharpMajorant D S N^(2*d) := by | |
| obtain β¨H, Kβ© := A.root_sharpQuantity_le D S hD ha (N := N) | |
| have H' := pow_le_pow_leftβ (Real.rpow_nonneg (A.sharpColumnQuantity_nonneg a d N) _) H (2*d) | |
| have K' := pow_le_pow_leftβ (Real.rpow_nonneg (A.sharpZeroQuantity_nonneg a d N) _) K (2*d) | |
| rw [Real.rpow_inv_natCast_pow (A.sharpColumnQuantity_nonneg a d N) (by omega)] at H' | |
| rw [Real.rpow_inv_natCast_pow (A.sharpZeroQuantity_nonneg a d N) (by omega)] at K' | |
| exact β¨H', K'β© | |
| constructor | |
| Β· refine β¨1, zero_le_one, ?_β© | |
| intro N v hv | |
| have H := (div_le_iffβ (by positivity : 0 < (N+1 : β)^(2*d-1))).mp (hquant N).1 | |
| apply (A.sum_positive_modes_sq_le a d hv).trans | |
| simpa only [one_mul, mul_comm (A.sharpMajorant D S N^(2*d))] using | |
| mul_le_mul_of_nonneg_right H (sq_nonneg βvβ) | |
| Β· refine β¨1, zero_le_one, ?_β© | |
| intro N v hv | |
| have H := (div_le_iffβ (by positivity : 0 < (N+1 : β)^(max 1 (2*d-2)))).mp (hquant N).2 | |
| have Z := pow_le_pow_leftβ (norm_nonneg _) (A.zeroMode_norm_le a d hv) 2 | |
| rw [mul_pow] at Z | |
| apply Z.trans | |
| simpa only [one_mul, mul_comm (A.sharpMajorant D S N^(2*d))] using | |
| mul_le_mul_of_nonneg_right H (sq_nonneg βvβ) | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem exists_sharpMajorant (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.IsQuasiPrimary a β§ U.IsHermitian d a) β§ | |
| (β d, 1 β€ d β d β€ D β β a β A.grade d, A.IsQuasiPrimary a β | |
| a β Submodule.span β (S d : Set V)) β§ | |
| (β d, D < d β A.grade d β€ A.toVertexAlgebra.c2) β§ | |
| (β w, β a β A.grade w, A.SharpGrowth (A.sharpMajorant D S) a w) := by | |
| classical | |
| obtain β¨D, hD, hcutβ© := A.exists_c2_weight_cutoff hc | |
| choose R hR hspan using U.exists_hermitian_quasiPrimary_spanning | |
| let S : β β Finset V := fun d => if 1 β€ d β§ d β€ D then R d else β | |
| have hS (d : β) (a : V) (ha : a β S d) : | |
| 1 β€ d β§ d β€ D β§ a β A.grade d β§ A.IsQuasiPrimary a β§ U.IsHermitian d a := by | |
| dsimp only [S] at ha | |
| split_ifs at ha with hd | |
| Β· exact β¨hd.1, hd.2, hR d a haβ© | |
| Β· simp at ha | |
| have hspanS (d : β) (hd : 1 β€ d) (hdD : d β€ D) (a : V) (ha : a β A.grade d) | |
| (hq : A.IsQuasiPrimary a) : a β Submodule.span β (S d : Set V) := by | |
| have he : S d = R d := by dsimp [S]; rw [ite_eq_left β¨hd, hdDβ©] | |
| rw [he] | |
| exact hspan d a ha hq | |
| refine β¨D, hD, S, ?_, hS, hspanS, hcut, ?_β© | |
| Β· intro d hd | |
| dsimp [S] | |
| rw [ite_eq_right] | |
| omega | |
| Β· apply U.grade_sharpGrowth (A.one_le_sharpMajorant D S) D _ hcut | |
| intro d hd hdD a ha hq | |
| have hle : Submodule.span β (S d : Set V) β€ | |
| A.sharpGrowthSubmodule (A.sharpMajorant D S) d := by | |
| apply Submodule.span_le.mpr | |
| intro b hb | |
| exact A.generator_sharpGrowth D S (by omega) hdD hb | |
| exact hle (hspanS d hd hdD a ha hq) | |
| theorem physicalMode_cutoff_sq_of_grades {a : V} {d N : β} (ha : a β A.grade d) | |
| (m : β€) (K : β) | |
| (H : β h β€ N, β v β A.grade h, βA.physicalMode a d m vβ^2 β€ K*βvβ^2) | |
| {v : V} (hv : v β A.energyCutoff N) : βA.physicalMode a d m vβ^2 β€ K*βvβ^2 := by | |
| classical | |
| rw [physicalMode, U.mode_norm_sq_eq_sum_grades ha, U.norm_sq_eq_sum_grades v, Finset.mul_sum] | |
| apply Finset.sum_le_sum | |
| intro h hh | |
| have hhN : h β€ N := by | |
| by_contra hnot | |
| have hz := hv h (by omega) | |
| have hne : A.gradingEquiv v h β 0 := DFinsupp.mem_support_iff.mp hh | |
| exact hne (Subtype.ext hz) | |
| exact H h hhN _ (A.gradeComponent_mem h v) | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| theorem finite_zeroGrowth_uniform {X : β β β} (hX : β N, 1 β€ X N) {ΞΉ : Type*} | |
| (s : Finset ΞΉ) (a : ΞΉ β V) (d : ΞΉ β β) (p q : β) | |
| (H : β i β s, A.ZeroGrowth X (a i) (d i) p q) : | |
| β C : β, 0 β€ C β§ β i β s, β N v, v β A.energyCutoff N β | |
| βA.physicalMode (a i) (d i) 0 vβ^2 β€ C*(N+1 : β)^p*X N^q*βvβ^2 := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => exact β¨0, le_rfl, by simpβ© | |
| | @insert i s hi ih => | |
| obtain β¨C, hC, HCβ© := H i (Finset.mem_insert_self _ _) | |
| obtain β¨D, hD, HDβ© := ih (fun j hj => H j (Finset.mem_insert_of_mem hj)) | |
| refine β¨C + D, add_nonneg hC hD, ?_β© | |
| intro j hj N v hv | |
| have hXN := zero_le_one.trans (hX N) | |
| rcases Finset.mem_insert.mp hj with rfl | hj | |
| Β· apply (HC N v hv).trans | |
| gcongr | |
| exact le_add_of_nonneg_right hD | |
| Β· apply (HD j hj N v hv).trans | |
| gcongr | |
| exact le_add_of_nonneg_left hC | |
| omit [InnerProductSpace β V] in | |
| theorem norm_of_sharp_square {X : β} (hX : 0 β€ X) {C : β} (hC : 0 β€ C) | |
| (N r s : β) (v w : V) | |
| (H : βwβ^2 β€ C * (N+1 : β)^(2*r) * X^(2*s) * βvβ^2) : | |
| βwβ β€ (C+1) * (N+1 : β)^r * X^s * βvβ := by | |
| apply (sq_le_sqβ (norm_nonneg _) (by positivity)).mp | |
| calc | |
| _ β€ C * (N+1 : β)^(2*r) * X^(2*s) * βvβ^2 := H | |
| _ β€ (C+1)^2 * (N+1 : β)^(2*r) * X^(2*s) * βvβ^2 := by | |
| gcongr | |
| nlinarith [sq_nonneg C] | |
| _ = _ := by simp only [mul_pow, pow_mul, mul_comm 2 r, mul_comm 2 s] | |
| theorem reduced_commutator_coefficient_bound {d : β} (hd : 1 β€ d) (m j : β) | |
| (hj : j < 2*d-1) : | |
| β((m+d-1).choose (j+1) : β) - ((d-1).choose (j+1) : β)β β€ | |
| (2 : β)*(d+1 : β)^(2*d)*(m+1 : β)^(2*d) := by | |
| have hchoose (n : β) (hn : n β€ (d+1)*(m+1)) : | |
| (n.choose (j+1) : β) β€ (d+1 : β)^(2*d)*(m+1 : β)^(2*d) := by | |
| have H : n.choose (j+1) β€ ((d+1)*(m+1))^(2*d) := | |
| (Nat.choose_le_pow n (j+1)).trans | |
| ((Nat.pow_le_pow_left hn (j+1)).trans (Nat.pow_le_pow_right (by positivity) (by omega))) | |
| simpa only [Nat.cast_pow, Nat.cast_mul, Nat.cast_add, Nat.cast_one, mul_pow] using | |
| (show (n.choose (j+1) : β) β€ (((d+1)*(m+1) : β) : β)^(2*d) from by exact_mod_cast H) | |
| have H := hchoose (m+d-1) (by nlinarith [Nat.sub_le (m+d) 1]) | |
| have K := hchoose (d-1) (by nlinarith [Nat.sub_le d 1]) | |
| calc | |
| _ β€ β((m+d-1).choose (j+1) : β)β + β((d-1).choose (j+1) : β)β := norm_sub_le _ _ | |
| _ β€ _ := by simp only [Complex.norm_natCast]; linarith | |
| theorem selfCommutator_sharp_bound {X : β β β} (hX : β N, 1 β€ X N) | |
| {a : V} {d : β} (ha : a β A.grade d) (hd : 2 β€ d) | |
| (H : β e β€ 2*d-2, β b β A.grade e, A.SharpGrowth X b e) : | |
| β C : β, 0 β€ C β§ β (N m : β) (v : V), v β A.energyCutoff N β | |
| βA.selfCommutator a d m vβ β€ | |
| C*(m+1 : β)^(2*d)*(N+1 : β)^(2*d-3)*X N^(2*d-2)*βvβ := by | |
| have HS (j : β) (hj : j β Finset.range (2*d-1)) : | |
| A.ZeroGrowth X (mode A.fields a (j+1) a) (2*d-j-2) (2*(2*d-3)) (2*(2*d-2)) := by | |
| have hgrade := A.mode_mem_grade ha ha ((j+1 : β) : β€) | |
| (k := 2*d-j-2) (by have := Finset.mem_range.mp hj; omega) | |
| have h := (H (2*d-j-2) (by omega) _ hgrade).2 | |
| apply A.zeroGrowth_mono hX h <;> omega | |
| obtain β¨C, hC, HCβ© := A.finite_zeroGrowth_uniform hX (Finset.range (2*d-1)) | |
| (fun j => mode A.fields a (j+1) a) (fun j => 2*d-j-2) (2*(2*d-3)) (2*(2*d-2)) HS | |
| refine β¨(2*d-1 : β)* (2*(d+1 : β)^(2*d))*(C+1), by positivity, ?_β© | |
| intro N m v hv | |
| have hXN := zero_le_one.trans (hX N) | |
| rw [A.selfCommutator_eq_sum_reduced ha (by omega)] | |
| calc | |
| _ β€ β j β Finset.range (2*d-1), | |
| β((m+d-1).choose (j+1) : β) - ((d-1).choose (j+1) : β)β * | |
| βA.physicalMode (mode A.fields a (j+1) a) (2*d-j-2) 0 vβ := by | |
| simpa only [norm_smul] using norm_sum_le (Finset.range (2*d-1)) | |
| (fun j => (((m+d-1).choose (j+1) : β) - ((d-1).choose (j+1) : β)) β’ | |
| A.physicalMode (mode A.fields a (j+1) a) (2*d-j-2) 0 v) | |
| _ β€ β _j β Finset.range (2*d-1), | |
| (2*(d+1 : β)^(2*d)*(m+1 : β)^(2*d)) * | |
| ((C+1)*(N+1 : β)^(2*d-3)*X N^(2*d-2)*βvβ) := by | |
| apply Finset.sum_le_sum | |
| intro j hj | |
| apply mul_le_mul (reduced_commutator_coefficient_bound (by omega) m j (Finset.mem_range.mp hj)) | |
| (norm_of_sharp_square hXN hC N (2*d-3) (2*d-2) v _ (HC j hj N v hv)) | |
| (norm_nonneg _) (by positivity) | |
| _ = _ := by simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul]; ring | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem nonzeroModes_sharp_bound {X : β β β} (hX : β N, 1 β€ X N) | |
| {a : V} {d : β} (ha : a β A.grade d) (hq : A.IsQuasiPrimary a) | |
| (hh : U.IsHermitian d a) (hd : 2 β€ d) | |
| (H : β e β€ 2*d-2, β b β A.grade e, A.SharpGrowth X b e) : | |
| β C : β, 0 β€ C β§ β (N m : β), 0 < m β β v β A.energyCutoff N, | |
| βA.physicalMode a d m vβ β€ C*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*X N^(d-1)*βvβ β§ | |
| βA.physicalMode a d (-(m : β€)) vβ β€ C*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*X N^(d-1)*βvβ := by | |
| obtain β¨C, hC, HCβ© := A.selfCommutator_sharp_bound hX ha hd H | |
| refine β¨C+1, by positivity, ?_β© | |
| intro N m hm v hv | |
| have hXN := zero_le_one.trans (hX N) | |
| let R := C*(m+1 : β)^(2*d)*(N+1 : β)^(2*d-3)*X N^(2*d-2) | |
| have hR : 0 β€ R := by dsimp [R]; positivity | |
| have HR (h : β) (hhN : h β€ N) (w : V) (hw : w β A.grade h) : | |
| βA.selfCommutator a d m wβ β€ R*βwβ := HC N m w (A.grade_le_energyCutoff hhN hw) | |
| have HE : (N+1 : β)*R = C*(m+1 : β)^(2*d)*(N+1 : β)^(2*(d-1))*X N^(2*(d-1)) := by | |
| have hp : 2*(d-1) = (2*d-3)+1 := by omega | |
| have hq : 2*(d-1) = 2*d-2 := by omega | |
| dsimp [R] | |
| conv_rhs => arg 1; arg 2; rw [hp, pow_succ] | |
| rw [hq] | |
| ring | |
| have step (n : β€) | |
| (HN : β h β€ N, β w β A.grade h, βA.physicalMode a d n wβ^2 β€ (h+1 : β)*R*βwβ^2) : | |
| βA.physicalMode a d n vβ β€ (C+1)*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*X N^(d-1)*βvβ := by | |
| have Hsq : βA.physicalMode a d n vβ^2 β€ ((N+1 : β)*R)*βvβ^2 := by | |
| apply U.physicalMode_cutoff_sq_of_grades ha n _ _ hv | |
| intro h hhN w hw | |
| apply (HN h hhN w hw).trans | |
| have hhR : (h : β) β€ N := by exact_mod_cast hhN | |
| gcongr | |
| rw [HE] at Hsq | |
| have Hnorm := norm_of_sharp_square hXN (show 0 β€ C*(m+1 : β)^(2*d) by positivity) | |
| N (d-1) (d-1) v _ Hsq | |
| apply Hnorm.trans | |
| have hM : 1 β€ (m+1 : β)^(2*d) := one_le_powβ (by linarith [Nat.cast_nonneg (Ξ± := β) m]) | |
| have hcoef : C*(m+1 : β)^(2*d)+1 β€ (C+1)*(m+1 : β)^(2*d) := by nlinarith | |
| gcongr | |
| constructor | |
| Β· apply step m | |
| intro h hhN w hw | |
| have Hlower := U.lowering_norm_sq_of_commutator ha hq hh hm hR HR h hhN w hw | |
| apply Hlower.trans | |
| gcongr | |
| linarith | |
| Β· apply step (-(m : β€)) | |
| intro h hhN w hw | |
| exact U.raising_norm_sq_of_commutator ha hq hh hm hR HR hhN hw | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem zeroMode_sharpGrowth {X : β β β} (hX : β N, 1 β€ X N) (hmono : Monotone X) | |
| {a : V} {d : β} (hp : A.PolynomialEnergyBound a) (ha : a β A.grade d) | |
| (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian d a) (hd : 2 β€ d) | |
| (H : β e β€ 2*d-2, β b β A.grade e, A.SharpGrowth X b e) : | |
| A.ZeroGrowth (fun N => X (2*N)) a d (2*(d-1)) (2*(d-1)) := by | |
| obtain β¨C, hC, HCβ© := U.nonzeroModes_sharp_bound hX ha hq hh hd H | |
| let F : β β β := fun N => (C+1)*2^(2*d)*(N+1 : β)^(d-1)*X N^(d-1) | |
| have hF (N : β) : 1 β€ F N := by | |
| dsimp [F] | |
| exact one_le_mul_of_one_le_of_one_le (one_le_mul_of_one_le_of_one_le (one_le_mul_of_one_le_of_one_le (by linarith) (one_le_powβ (by norm_num))) | |
| (one_le_powβ (by linarith [Nat.cast_nonneg (Ξ± := β) N]))) (one_le_powβ (hX N)) | |
| have HF (N : β) (v : V) (hv : v β A.energyCutoff N) : | |
| βA.physicalMode a d 1 vβ β€ F N * βvβ := by | |
| have H' := (HC N 1 (by decide) v hv).1 | |
| apply H'.trans | |
| dsimp [F] | |
| have hXN := zero_le_one.trans (hX N) | |
| norm_num only [Nat.cast_one, show (1 : β)+1 = 2 by norm_num] | |
| gcongr | |
| linarith | |
| obtain β¨B, hB, HBβ© := U.zeroMode_transfer hp ha hq hd | |
| let K := B*(C+1)*2^(2*d)*2^(d-1) | |
| have hK : 0 β€ K := by dsimp [K]; positivity | |
| have HR (N h : β) (hhN : h β€ N) : | |
| B * F (2*h) β€ K * (N+1 : β)^(d-1)*X (2*N)^(d-1) := by | |
| have hx := zero_le_one.trans (hX (2*h)) | |
| have hx' := zero_le_one.trans (hX (2*N)) | |
| have hnR : (2*h+1 : β) β€ 2*(N+1 : β) := by | |
| have hn : (h : β) β€ N := by exact_mod_cast hhN | |
| linarith | |
| have hXm : X (2*h) β€ X (2*N) := hmono (by omega) | |
| calc | |
| _ β€ B * ((C+1)*2^(2*d)*(2*(N+1 : β))^(d-1)*X (2*N)^(d-1)) := by | |
| dsimp [F] | |
| push_cast | |
| gcongr | |
| _ = _ := by dsimp [K]; rw [mul_pow]; ring | |
| refine β¨K^2, sq_nonneg _, ?_β© | |
| intro N v hv | |
| have hXN := zero_le_one.trans (hX (2*N)) | |
| have HK : βA.physicalMode a d 0 vβ^2 β€ | |
| (K*(N+1 : β)^(d-1)*X (2*N)^(d-1))^2 * βvβ^2 := by | |
| apply U.physicalMode_cutoff_sq_of_grades ha 0 _ _ hv | |
| intro h hhN w hw | |
| have Hnorm : βA.physicalMode a d 0 wβ β€ | |
| (K*(N+1 : β)^(d-1)*X (2*N)^(d-1))*βwβ := | |
| (HB F hF HF h w hw).trans (mul_le_mul_of_nonneg_right (HR N h hhN) (norm_nonneg _)) | |
| simpa only [mul_pow] using pow_le_pow_leftβ (norm_nonneg _) Hnorm 2 | |
| simpa only [mul_pow, β pow_mul, Nat.mul_comm (d-1) 2] using HK | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| def zeroGrowthSubmodule (X : β β β) (d p q : β) : Submodule β V where | |
| carrier := {a | A.ZeroGrowth X a d p q} | |
| zero_mem' := A.zeroGrowth_zero X d p q | |
| add_mem' := A.zeroGrowth_add | |
| smul_mem' z _ H := A.zeroGrowth_smul H z | |
| theorem zeroGrowth_changeControl {X Y : β β β} (hX : β N, 0 β€ X N) | |
| (hXY : β N, X N β€ Y N) {a : V} {d p q : β} (H : A.ZeroGrowth X a d p q) : | |
| A.ZeroGrowth Y a d p q := by | |
| obtain β¨C, hC, HCβ© := H | |
| refine β¨C, hC, ?_β© | |
| intro N v hv | |
| apply (HC N v hv).trans | |
| gcongr | |
| Β· exact hX N | |
| Β· exact hXY N | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem grade_improved_zeroGrowth {X : β β β} (hX : β N, 1 β€ X N) | |
| (hmono : Monotone X) (hp : A.PolynomialEnergyBounds) | |
| (H : β e, β b β A.grade e, A.SharpGrowth X b e) | |
| {a : V} {d : β} (ha : a β A.grade d) (hd : 2 β€ d) : | |
| A.ZeroGrowth (fun N => X (2*N)) a d (2*(d-1)) (2*(d-1)) := by | |
| classical | |
| obtain β¨e, rflβ© := Nat.exists_eq_succ_of_ne_zero (show d β 0 by omega) | |
| obtain β¨q, hq, hqq, b, hb, habβ© := U.quasiPrimary_decomposition ha | |
| obtain β¨S, hS, hspanβ© := U.exists_hermitian_quasiPrimary_spanning (e+1) | |
| have Hq : A.ZeroGrowth (fun N => X (2*N)) q (e+1) (2*e) (2*e) := by | |
| have hle : Submodule.span β (S : Set V) β€ | |
| A.zeroGrowthSubmodule (fun N => X (2*N)) (e+1) (2*e) (2*e) := by | |
| apply Submodule.span_le.mpr | |
| intro c hc | |
| obtain β¨hcg, hcq, hchβ© := hS c hc | |
| change A.ZeroGrowth (fun N => X (2*N)) c (e+1) (2*e) (2*e) | |
| simpa only [Nat.add_sub_cancel] using | |
| U.zeroMode_sharpGrowth hX hmono (hp c) hcg hcq hch hd | |
| (fun f _ c hcf => H f c hcf) | |
| exact hle (hspan q hq hqq) | |
| have Hb := A.translation_zeroGrowth (H e b hb).2 | |
| have Hb' := A.zeroGrowth_changeControl (fun N => zero_le_one.trans (hX N)) | |
| (fun N => hmono (by omega : N β€ 2*N)) Hb | |
| have Hb'' := A.zeroGrowth_mono (fun N => hX (2*N)) Hb' (p' := 2*e) (q' := 2*e) | |
| (by omega) le_rfl | |
| rw [hab, A.virasoro_neg_one_eq_translation] | |
| simpa only [Nat.succ_eq_add_one, Nat.add_sub_cancel] using A.zeroGrowth_add Hq Hb'' | |
| omit U in | |
| theorem positiveColumnNorm_sq_le {a : V} {d N : β} {K : β} (hK : 0 β€ K) | |
| (H : β v β A.energyCutoff N, | |
| (β m β Finset.range (N+1), βA.physicalMode a d m vβ^2) β€ K*βvβ^2) : | |
| A.positiveColumnNorm a d N^2 β€ K := by | |
| have HB : A.positiveColumnNorm a d N β€ Real.sqrt K := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ (Real.sqrt_nonneg _) | |
| intro v | |
| apply (sq_le_sqβ (norm_nonneg _) (by positivity)).mp | |
| rw [mul_pow, Real.sq_sqrt hK, A.positiveColumn_norm_sq] | |
| exact H v v.property | |
| exact (pow_le_pow_leftβ (A.positiveColumnNorm_nonneg a d N) HB 2).trans_eq (Real.sq_sqrt hK) | |
| theorem generator_column_contraction {X : β β β} (hX : β N, 1 β€ X N) | |
| (hmono : Monotone X) (hp : A.PolynomialEnergyBounds) | |
| (H : β e, β b β A.grade e, A.SharpGrowth X b e) | |
| {a : V} {d : β} (ha : a β A.grade d) (hd : 1 β€ d) | |
| (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian d a) : | |
| β C : β, 0 β€ C β§ β N, | |
| A.positiveColumnNorm a d N^2 β€ C*(N+1 : β)^(2*d-1)*X (2*N)^(2*d-1) := by | |
| have hs : mode A.fields a (-1) a β A.grade (2*d) := A.normalProduct_mem_grade ha | |
| obtain β¨C, hC, HCβ© := U.grade_improved_zeroGrowth hX hmono hp H hs (by omega) | |
| refine β¨C+1, by linarith, ?_β© | |
| intro N | |
| have hXN := zero_le_one.trans (hX (2*N)) | |
| apply positiveColumnNorm_sq_le (by positivity) | |
| intro v hv | |
| have Hs := norm_of_sharp_square hXN hC N (2*d-1) (2*d-1) v _ (HC N v hv) | |
| have Hpos := U.positive_column hd ha hq hh v | |
| have Hfin : (β m β Finset.range (N+1), βA.physicalMode a d m vβ^2) β€ | |
| βαΆ m : β, βA.physicalMode a d m vβ^2 := | |
| (A.finsum_positive_modes_sq_eq ha hv).symm.le | |
| have HE : A.physicalMode (mode A.fields a (-1) a) (2*d) 0 v = | |
| mode A.fields (mode A.fields a (-1) a) (2*(d : β€)-1) v := by | |
| simp only [physicalMode, zero_add, Nat.cast_mul, Nat.cast_ofNat] | |
| rw [HE] at Hs | |
| calc | |
| _ β€ _ := Hfin.trans Hpos | |
| _ β€ βmode A.fields (mode A.fields a (-1) a) (2*(d : β€)-1) vβ*βvβ := re_inner_le_norm (π := β) _ _ | |
| _ β€ ((C+1)*(N+1 : β)^(2*d-1)*X (2*N)^(2*d-1)*βvβ)*βvβ := | |
| mul_le_mul_of_nonneg_right Hs (norm_nonneg _) | |
| _ = _ := by ring | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| theorem zeroModeCutoffNorm_le_column (a : V) (d N : β) : | |
| A.zeroModeCutoffNorm a d N β€ A.positiveColumnNorm a d N := by | |
| have hR := A.positiveColumnNorm_nonneg a d N | |
| apply ContinuousLinearMap.opNorm_le_bound _ hR | |
| intro v | |
| change βA.physicalMode a d 0 vβ β€ A.positiveColumnNorm a d N * βvβ | |
| apply (sq_le_sqβ (norm_nonneg _) (by positivity)).mp | |
| rw [mul_pow] | |
| apply le_trans _ (A.sum_positive_modes_sq_le a d v.property) | |
| exact Finset.single_le_sum (s := Finset.range (N+1)) (a := 0) | |
| (f := fun m : β => βA.physicalMode a d m vβ^2) (fun m _ => sq_nonneg _) | |
| (Finset.mem_range.mpr (show 0 < N+1 by omega)) | |
| theorem zeroModeCutoffNorm_sq_le {a : V} {d N : β} {K : β} (hK : 0 β€ K) | |
| (H : β v β A.energyCutoff N, βA.physicalMode a d 0 vβ^2 β€ K*βvβ^2) : | |
| A.zeroModeCutoffNorm a d N^2 β€ K := by | |
| have HB : A.zeroModeCutoffNorm a d N β€ Real.sqrt K := by | |
| apply ContinuousLinearMap.opNorm_le_bound _ (Real.sqrt_nonneg _) | |
| intro v | |
| apply (sq_le_sqβ (norm_nonneg _) (by positivity)).mp | |
| rw [mul_pow, Real.sq_sqrt hK] | |
| exact H v v.property | |
| exact (pow_le_pow_leftβ (norm_nonneg (A.zeroModeOnCutoff a d N)) HB 2).trans_eq (Real.sq_sqrt hK) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem generator_quantities_contraction {X : β β β} (hX : β N, 1 β€ X N) | |
| (hmono : Monotone X) (hp : A.PolynomialEnergyBounds) | |
| (H : β e, β b β A.grade e, A.SharpGrowth X b e) | |
| {a : V} {d : β} (ha : a β A.grade d) (hd : 1 β€ d) | |
| (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian d a) : | |
| β C : β, 0 β€ C β§ β N, | |
| A.sharpColumnQuantity a d N β€ C*X (2*N)^(2*d-1) β§ | |
| A.sharpZeroQuantity a d N β€ C*X (2*N)^(2*d-1) := by | |
| obtain β¨C, hC, HCβ© := U.generator_column_contraction hX hmono hp H ha hd hq hh | |
| have HC' (N : β) : A.sharpColumnQuantity a d N β€ C*X (2*N)^(2*d-1) := by | |
| apply (div_le_iffβ (by positivity : 0 < (N+1 : β)^(2*d-1))).mpr | |
| simpa only [mul_assoc, mul_comm ((N+1 : β)^(2*d-1)), mul_left_comm] using HC N | |
| by_cases hd1 : d = 1 | |
| Β· subst d | |
| refine β¨C, hC, fun N => β¨HC' N, ?_β©β© | |
| apply le_trans _ (HC' N) | |
| unfold sharpZeroQuantity sharpColumnQuantity | |
| norm_num only | |
| apply div_le_div_of_nonneg_right _ (by positivity) | |
| exact pow_le_pow_leftβ (norm_nonneg (A.zeroModeOnCutoff a 1 N)) | |
| (A.zeroModeCutoffNorm_le_column a 1 N) 2 | |
| Β· obtain β¨B, hB, HBβ© := U.zeroMode_sharpGrowth hX hmono (hp a) ha hq hh | |
| (by omega) (fun e _ b hb => H e b hb) | |
| have HB' (N : β) : A.sharpZeroQuantity a d N β€ B*X (2*N)^(2*d-1) := by | |
| have hXN := zero_le_one.trans (hX (2*N)) | |
| have HB'' := A.zeroModeCutoffNorm_sq_le (a := a) (d := d) (N := N) | |
| (K := B*(N+1 : β)^(2*(d-1))*X (2*N)^(2*(d-1))) (by positivity) (HB N) | |
| have he : max 1 (2*d-2) = 2*(d-1) := by omega | |
| unfold sharpZeroQuantity | |
| rw [he] | |
| apply (div_le_iffβ (by positivity : 0 < (N+1 : β)^(2*(d-1)))).mpr | |
| apply HB''.trans | |
| calc | |
| _ β€ B*(N+1 : β)^(2*(d-1))*X (2*N)^(2*d-1) := by | |
| gcongr | |
| Β· exact hX (2*N) | |
| Β· omega | |
| _ = _ := by ring | |
| refine β¨C+B, add_nonneg hC hB, fun N => β¨?_, ?_β©β© | |
| Β· apply (HC' N).trans | |
| gcongr | |
| Β· exact pow_nonneg (zero_le_one.trans (hX (2*N))) _ | |
| Β· exact le_add_of_nonneg_right hB | |
| Β· apply (HB' N).trans | |
| gcongr | |
| Β· exact pow_nonneg (zero_le_one.trans (hX (2*N))) _ | |
| Β· exact le_add_of_nonneg_left hC | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| end StronglyRationalVOA | |
| end | |
| end OAI | |