Download data/lean/OAI/RepresentationTheory/VertexAlgebra/CutoffPowerControl.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 25.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/CutoffPowerControl.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/VertexAlgebra/CutoffPowerControl.lean
-
curl -L -o CutoffPowerControl.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/CutoffPowerControl.lean
25.1 kB
| import Mathlib | |
| import OAI.RepresentationTheory.VertexAlgebra.GeneratorSharpGrowth | |
| namespace OAI | |
| /-! Vertex algebra, energy bounds and closed smeared-field operators. -/ | |
| noncomputable section | |
| namespace StronglyRationalVOA | |
| universe u v | |
| def CutoffPowerControl (Y : β β β) (P : β) (f : β β β) : Prop := | |
| β C : β, 0 β€ C β§ β N, f N^P β€ C*Y N | |
| theorem cutoffPowerControl_add {Y f g : β β β} {P : β} | |
| (hf : β N, 0 β€ f N) (hg : β N, 0 β€ g N) | |
| (Hf : CutoffPowerControl Y P f) (Hg : CutoffPowerControl Y P g) : | |
| CutoffPowerControl Y P (fun N => f N+g N) := by | |
| obtain β¨C, hC, HCβ© := Hf | |
| obtain β¨D, hD, HDβ© := Hg | |
| refine β¨2^(P-1)*(C+D), by positivity, ?_β© | |
| intro N | |
| calc | |
| _ β€ 2^(P-1)*(f N^P+g N^P) := add_pow_le (hf N) (hg N) P | |
| _ β€ 2^(P-1)*(C*Y N+D*Y N) := by gcongr; exacts [HC N, HD N] | |
| _ = _ := by ring | |
| theorem cutoffPowerControl_sum {Y : β β β} {P : β} | |
| (hP : 1 β€ P) {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β β β β) | |
| (hf : β i β s, β N, 0 β€ f i N) | |
| (H : β i β s, CutoffPowerControl Y P (f i)) : | |
| CutoffPowerControl Y P (fun N => β i β s, f i N) := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => exact β¨0, le_rfl, by simp [show P β 0 by omega]β© | |
| | i s hi ih => | |
| have hsum := ih (fun j hj => hf j (Finset.mem_insert_of_mem hj)) | |
| (fun j hj => H j (Finset.mem_insert_of_mem hj)) | |
| have h := cutoffPowerControl_add (hf i (Finset.mem_insert_self _ _)) | |
| (fun N => Finset.sum_nonneg (fun j hj => hf j (Finset.mem_insert_of_mem hj) N)) | |
| (H i (Finset.mem_insert_self _ _)) hsum | |
| simpa only [Finset.sum_insert hi] using h | |
| theorem cutoffPowerControl_one {Y : β β β} (hY : β N, 1 β€ Y N) (P : β) : | |
| CutoffPowerControl Y P (fun _ => 1) := | |
| β¨1, zero_le_one, by simpa using hYβ© | |
| theorem root_lift_power_bound {q X C : β} {p P : β} (hq : 0 β€ q) (hX : 0 β€ X) | |
| (hC : 0 β€ C) (hp : 1 β€ p) (hpP : p β€ P) | |
| (hroot : q^((p : β)β»ΒΉ) β€ X) (H : q β€ C*X^(p-1)) : | |
| (q^((p : β)β»ΒΉ))^P β€ C*X^(P-1) := by | |
| have hqroot := Real.rpow_nonneg hq ((p : β)β»ΒΉ) | |
| calc | |
| _ = (q^((p : β)β»ΒΉ))^p * (q^((p : β)β»ΒΉ))^(P-p) := by | |
| rw [β pow_add, Nat.add_sub_of_le hpP] | |
| _ = q*(q^((p : β)β»ΒΉ))^(P-p) := by | |
| rw [Real.rpow_inv_natCast_pow hq (by omega)] | |
| _ β€ (C*X^(p-1))*X^(P-p) := by gcongr | |
| _ = _ := by rw [mul_assoc, β pow_add, show p-1+(P-p) = P-1 by omega] | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem sharpMajorant_power_contraction (D : β) (hD : 2 β€ D) (S : β β Finset V) | |
| (hS : β d, β a β S d, 1 β€ d β§ d β€ D β§ a β A.grade d β§ | |
| A.IsQuasiPrimary a β§ U.IsHermitian d a) | |
| (hp : A.PolynomialEnergyBounds) | |
| (H : β e, β b β A.grade e, A.SharpGrowth (A.sharpMajorant D S) b e) : | |
| β C : β, 1 β€ C β§ β N, | |
| A.sharpMajorant D S N^(2*D) β€ C*A.sharpMajorant D S (2*N)^(2*D-1) := by | |
| classical | |
| let X := A.sharpMajorant D S | |
| let Y : β β β := fun N => X (2*N)^(2*D-1) | |
| have hX := A.one_le_sharpMajorant D S | |
| have hm := A.sharpMajorant_mono D S | |
| have hpositive (d : β) (a : V) (N : β) : | |
| 0 β€ (A.sharpColumnQuantity a d N)^((2*d : β) : β)β»ΒΉ + | |
| (A.sharpZeroQuantity a d N)^((2*d : β) : β)β»ΒΉ := | |
| add_nonneg (Real.rpow_nonneg (A.sharpColumnQuantity_nonneg a d N) _) | |
| (Real.rpow_nonneg (A.sharpZeroQuantity_nonneg a d N) _) | |
| have Hsum : CutoffPowerControl Y (2*D) (fun N => | |
| β d β Finset.range (D+1), β a β S d, | |
| ((A.sharpColumnQuantity a d N)^((2*d : β) : β)β»ΒΉ + | |
| (A.sharpZeroQuantity a d N)^((2*d : β) : β)β»ΒΉ)) := by | |
| apply cutoffPowerControl_sum (by omega) | |
| (hf := fun d _ N => Finset.sum_nonneg (fun a _ => hpositive d a N)) | |
| intro d hd | |
| apply cutoffPowerControl_sum (by omega) (hf := fun a _ N => hpositive d a N) | |
| intro a haS | |
| obtain β¨hdpos, hdD, ha, hq, hhβ© := hS d a haS | |
| obtain β¨C, hC, HCβ© := U.generator_quantities_contraction hX hm hp H ha hdpos hq hh | |
| apply cutoffPowerControl_add | |
| (fun N => Real.rpow_nonneg (A.sharpColumnQuantity_nonneg a d N) _) | |
| (fun N => Real.rpow_nonneg (A.sharpZeroQuantity_nonneg a d N) _) | |
| Β· refine β¨C, hC, ?_β© | |
| intro N | |
| exact root_lift_power_bound (A.sharpColumnQuantity_nonneg a d N) | |
| (zero_le_one.trans (hX (2*N))) hC (by omega) (by omega) | |
| (((A.root_sharpQuantity_le D S hdD haS).1).trans (hm (by omega : N β€ 2*N))) (HC N).1 | |
| Β· refine β¨C, hC, ?_β© | |
| intro N | |
| exact root_lift_power_bound (A.sharpZeroQuantity_nonneg a d N) | |
| (zero_le_one.trans (hX (2*N))) hC (by omega) (by omega) | |
| (((A.root_sharpQuantity_le D S hdD haS).2).trans (hm (by omega : N β€ 2*N))) (HC N).2 | |
| have Hraw : CutoffPowerControl Y (2*D) (A.rawSharpMajorant D S) := | |
| cutoffPowerControl_add (fun _ => zero_le_one) | |
| (fun N => Finset.sum_nonneg (fun d _ => Finset.sum_nonneg (fun a _ => hpositive d a N))) | |
| (cutoffPowerControl_one (fun N => one_le_powβ (hX (2*N))) (2*D)) Hsum | |
| obtain β¨C, hC, HCβ© := Hraw | |
| refine β¨C+1, by linarith, ?_β© | |
| intro N | |
| obtain β¨n, hn, heβ© := Finset.exists_mem_eq_sup' (s := Finset.range (N+1)) | |
| (by simp) (A.rawSharpMajorant D S) | |
| change ((Finset.range (N+1)).sup' (by simp) (A.rawSharpMajorant D S))^(2*D) β€ _ | |
| rw [he] | |
| apply (HC n).trans | |
| have hXn := zero_le_one.trans (hX (2*n)) | |
| have hnN : n β€ N := by have := Finset.mem_range.mp hn; omega | |
| change C*X (2*n)^(2*D-1) β€ (C+1)*X (2*N)^(2*D-1) | |
| gcongr | |
| Β· exact le_add_of_nonneg_right zero_le_one | |
| Β· exact hm (by omega) | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| def PolynomialCutoffControl (f : β β β) : Prop := | |
| β C : β, 0 β€ C β§ β p : β, β N, f N β€ C*(N+1 : β)^p | |
| theorem polynomialCutoffControl_add {f g : β β β} | |
| (Hf : PolynomialCutoffControl f) (Hg : PolynomialCutoffControl g) : | |
| PolynomialCutoffControl (fun N => f N+g N) := by | |
| obtain β¨C, hC, p, HCβ© := Hf | |
| obtain β¨D, hD, q, HDβ© := Hg | |
| refine β¨C+D, add_nonneg hC hD, p+q, ?_β© | |
| intro N | |
| have hN : 1 β€ (N+1 : β) := by linarith [Nat.cast_nonneg (Ξ± := β) N] | |
| have Hp := pow_le_pow_rightβ hN (show p β€ p+q by omega) | |
| have Hq := pow_le_pow_rightβ hN (show q β€ p+q by omega) | |
| calc | |
| _ β€ C*(N+1 : β)^p+D*(N+1 : β)^q := add_le_add (HC N) (HD N) | |
| _ β€ C*(N+1 : β)^(p+q)+D*(N+1 : β)^(p+q) := by gcongr | |
| _ = _ := by ring | |
| theorem polynomialCutoffControl_sum {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β β β β) | |
| (H : β i β s, PolynomialCutoffControl (f i)) : | |
| PolynomialCutoffControl (fun N => β i β s, f i N) := by | |
| classical | |
| induction s using Finset.induction_on with | |
| | empty => exact β¨0, le_rfl, 0, by simpβ© | |
| | i s hi ih => | |
| have h := polynomialCutoffControl_add (H i (Finset.mem_insert_self _ _)) | |
| (ih (fun j hj => H j (Finset.mem_insert_of_mem hj))) | |
| simpa only [Finset.sum_insert hi] using h | |
| theorem polynomialCutoffControl_one : PolynomialCutoffControl (fun _ => 1) := | |
| β¨1, zero_le_one, 0, by simpβ© | |
| theorem rpow_inv_nat_le_one_add {q : β} (hq : 0 β€ q) {p : β} (hp : 1 β€ p) : | |
| q^((p : β)β»ΒΉ) β€ 1+q := by | |
| have hpR : 1 β€ (p : β) := by exact_mod_cast hp | |
| have hp0 : (0 : β) < p := by linarith | |
| rcases le_total q 1 with hq1 | hq1 | |
| Β· exact (Real.rpow_le_one hq hq1 (by positivity)).trans (le_add_of_nonneg_right hq) | |
| Β· apply (Real.rpow_le_self_of_one_le hq1 ((inv_le_oneβ hp0).mpr hpR)).trans | |
| linarith | |
| theorem polynomialCutoffControl_root {f : β β β} (hf : β N, 0 β€ f N) | |
| (H : PolynomialCutoffControl f) {p : β} (hp : 1 β€ p) : | |
| PolynomialCutoffControl (fun N => f N^((p : β)β»ΒΉ)) := by | |
| obtain β¨C, hC, k, HCβ© := polynomialCutoffControl_add polynomialCutoffControl_one H | |
| exact β¨C, hC, k, fun N => (rpow_inv_nat_le_one_add (hf N) hp).trans (HC N)β© | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem positiveColumnNorm_sq_polynomial {a : V} (hp : A.PolynomialEnergyBound a) | |
| (d : β) (hd : 1 β€ d) : PolynomialCutoffControl (fun N => A.positiveColumnNorm a d N^2) := by | |
| obtain β¨C, hC, p, k, HCβ© := hp | |
| let B := C*(d+2 : β)^p | |
| have hB : 0 β€ B := by dsimp [B]; positivity | |
| have Hmode (N m : β) (hm : m β€ N) (v : V) (hv : v β A.energyCutoff N) : | |
| βA.physicalMode a d m vβ β€ B*(N+1 : β)^(p+k)*βvβ := by | |
| have hmR : (m : β) β€ N := by exact_mod_cast hm | |
| have hdR : 1 β€ (d : β) := by exact_mod_cast hd | |
| have hcoef : 1+|(((m : β€)+d-1 : β€) : β)| β€ (d+2 : β)*(N+1 : β) := by | |
| push_cast | |
| rw [abs_of_nonneg (by linarith [Nat.cast_nonneg (Ξ± := β) m])] | |
| nlinarith [Nat.cast_nonneg (Ξ± := β) N] | |
| have HK := U.energyShift_pow_norm_on_cutoff hv k | |
| change βmode A.fields a ((m : β€)+d-1) vβ β€ _ | |
| calc | |
| _ β€ C*(1+|(((m : β€)+d-1 : β€) : β)|)^p*β(A.energyShift^k) vβ := HC _ _ | |
| _ β€ C*((d+2 : β)*(N+1 : β))^p*((N+1 : β)^k*βvβ) := by | |
| have HK' : β(A.energyShift^k) vβ β€ (N+1 : β)^k*βvβ := by simpa only [add_comm] using HK | |
| gcongr | |
| _ = _ := by dsimp [B]; rw [mul_pow, pow_add]; ring | |
| refine β¨B^2, sq_nonneg _, 2*(p+k)+1, ?_β© | |
| intro N | |
| apply positiveColumnNorm_sq_le (by positivity) | |
| intro v hv | |
| calc | |
| _ β€ β m β Finset.range (N+1), (B*(N+1 : β)^(p+k)*βvβ)^2 := by | |
| apply Finset.sum_le_sum | |
| intro m hm | |
| exact pow_le_pow_leftβ (norm_nonneg _) (Hmode N m (by have := Finset.mem_range.mp hm; omega) v hv) 2 | |
| _ = (N+1 : β)*(B*(N+1 : β)^(p+k)*βvβ)^2 := by | |
| simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul, Nat.cast_add, Nat.cast_one] | |
| _ = (B^2*(N+1 : β)^(2*(p+k)+1))*βvβ^2 := by rw [pow_succ]; ring | |
| theorem sharpQuantities_polynomial {a : V} (hp : A.PolynomialEnergyBound a) | |
| (d : β) (hd : 1 β€ d) : | |
| PolynomialCutoffControl (A.sharpColumnQuantity a d) β§ | |
| PolynomialCutoffControl (A.sharpZeroQuantity a d) := by | |
| obtain β¨C, hC, p, HCβ© := U.positiveColumnNorm_sq_polynomial hp d hd | |
| constructor | |
| Β· refine β¨C, hC, p, ?_β© | |
| intro N | |
| apply le_trans _ (HC N) | |
| exact div_le_self (sq_nonneg _) (one_le_powβ (by linarith [Nat.cast_nonneg (Ξ± := β) N])) | |
| Β· refine β¨C, hC, p, ?_β© | |
| intro N | |
| apply le_trans _ (HC N) | |
| apply le_trans (div_le_self (sq_nonneg _) (one_le_powβ (by linarith [Nat.cast_nonneg (Ξ± := β) N]))) | |
| exact pow_le_pow_leftβ (norm_nonneg (A.zeroModeOnCutoff a d N)) | |
| (A.zeroModeCutoffNorm_le_column a d N) 2 | |
| theorem sharpMajorant_polynomial (D : β) (S : β β Finset V) | |
| (hS : β d, β a β S d, 1 β€ d) (hp : A.PolynomialEnergyBounds) : | |
| PolynomialCutoffControl (A.sharpMajorant D S) := by | |
| classical | |
| have Hraw : PolynomialCutoffControl (A.rawSharpMajorant D S) := by | |
| apply polynomialCutoffControl_add polynomialCutoffControl_one | |
| apply polynomialCutoffControl_sum | |
| intro d hd | |
| apply polynomialCutoffControl_sum | |
| intro a ha | |
| have HQ := U.sharpQuantities_polynomial (hp a) d (hS d a ha) | |
| exact polynomialCutoffControl_add | |
| (polynomialCutoffControl_root (A.sharpColumnQuantity_nonneg a d) HQ.1 (by have := hS d a ha; omega)) | |
| (polynomialCutoffControl_root (A.sharpZeroQuantity_nonneg a d) HQ.2 (by have := hS d a ha; omega)) | |
| obtain β¨C, hC, p, HCβ© := Hraw | |
| refine β¨C, hC, p, ?_β© | |
| intro N | |
| apply Finset.sup'_le | |
| intro n hn | |
| apply (HC n).trans | |
| have hnN : (n : β) β€ N := by exact_mod_cast (show n β€ N by have := Finset.mem_range.mp hn; omega) | |
| gcongr | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| open Filter | |
| theorem multiplicative_cutoff_log_bound (b : β β β) (K : β) (hK : 1 β€ K) | |
| (Ο c C s : β) (hΟ0 : 0 β€ Ο) (hΟ1 : Ο < 1) (hc : 0 β€ c) | |
| (hstart : β N, 1 β€ N β b N β€ C + s * Real.log N) | |
| (hstep : β N, 1 β€ N β b N β€ c + Ο * b (K * N)) : | |
| β N, 1 β€ N β b N β€ c / (1 - Ο) := by | |
| let B := c / (1 - Ο) | |
| have hden : 0 < 1 - Ο := sub_pos.mpr hΟ1 | |
| have hB0 : 0 β€ B := div_nonneg hc hden.le | |
| have hB : c + Ο * B = B := by dsimp [B]; field_simp; ring | |
| have hit (j : β) : β N, 1 β€ N β b N - B β€ Ο ^ j * b (K ^ j * N) := by | |
| induction j with | |
| | zero => intro N hN; simpa using sub_le_self (b N) hB0 | |
| | succ j ih => | |
| intro N hN | |
| have hKN : 1 β€ K * N := by nlinarith | |
| calc | |
| _ β€ Ο * (b (K * N) - B) := by nlinarith [hstep N hN] | |
| _ β€ Ο * (Ο^j * b (K^j * (K * N))) := | |
| mul_le_mul_of_nonneg_left (ih _ hKN) hΟ0 | |
| _ = _ := by | |
| rw [show K^j * (K * N) = K^(j+1) * N by rw [pow_succ]; ring, pow_succ] | |
| ring | |
| intro N hN | |
| have hKpos : (0 : β) < K := by exact_mod_cast (by omega : 0 < K) | |
| have hNpos : (0 : β) < N := by exact_mod_cast (by omega : 0 < N) | |
| have hb (j : β) : b N - B β€ | |
| Ο ^ j * (C + s * Real.log N + s * (j : β) * Real.log K) := by | |
| apply (hit j N hN).trans | |
| have hp : 1 β€ K^j * N := Nat.one_le_iff_ne_zero.mpr (Nat.mul_ne_zero | |
| (pow_ne_zero _ (by omega)) (by omega)) | |
| have he : Real.log ((K^j * N : β) : β) = (j : β) * Real.log K + Real.log N := by | |
| push_cast | |
| rw [Real.log_mul (pow_ne_zero _ hKpos.ne') hNpos.ne', Real.log_pow] | |
| have h := mul_le_mul_of_nonneg_left (hstart _ hp) (pow_nonneg hΟ0 j) | |
| rw [he] at h | |
| convert h using 1 | |
| ring | |
| have ht : Tendsto (fun j : β => | |
| Ο ^ j * (C + s * Real.log N + s * (j : β) * Real.log K)) atTop (nhds 0) := by | |
| have hβ := tendsto_pow_atTop_nhds_zero_of_lt_one hΟ0 hΟ1 | |
| have hβ := tendsto_pow_const_mul_const_pow_of_lt_one 1 hΟ0 hΟ1 | |
| have h := (hβ.const_mul (C + s * Real.log N)).add (hβ.const_mul (s * Real.log K)) | |
| convert h using 1 | |
| Β· ext j; ring | |
| Β· simp | |
| have hlast : b N - B β€ 0 := ge_of_tendsto' ht hb | |
| exact sub_nonpos.mp hlast | |
| theorem polynomial_power_contraction_bounded (X : β β β) (hX : β N, 1 β€ X N) | |
| (hm : Monotone X) (hp : PolynomialCutoffControl X) | |
| (K P : β) (hK : 1 β€ K) (hP : 1 β€ P) (C : β) (hC : 1 β€ C) | |
| (H : β N, X N^P β€ C*X (K*N)^(P-1)) : | |
| β B : β, 1 β€ B β§ β N, X N β€ B := by | |
| obtain β¨D, hD, p, HDβ© := hp | |
| let A := (D+1)*2^p | |
| have hA : 0 < A := by dsimp [A]; positivity | |
| have hPR : 0 < (P : β) := by exact_mod_cast (by omega : 0 < P) | |
| have hPR1 : 1 β€ (P : β) := by exact_mod_cast hP | |
| let Ο : β := 1-(P : β)β»ΒΉ | |
| have hΟ0 : 0 β€ Ο := by dsimp [Ο]; linarith [(inv_le_oneβ hPR).mpr hPR1] | |
| have hΟ1 : Ο < 1 := by dsimp [Ο]; linarith [inv_pos.mpr hPR] | |
| let c := Real.log C/(P : β) | |
| have hc : 0 β€ c := div_nonneg (Real.log_nonneg hC) hPR.le | |
| have hstart (N : β) (hN : 1 β€ N) : Real.log (X N) β€ Real.log A + (p : β)*Real.log N := by | |
| have hNR1 : (1 : β) β€ N := by exact_mod_cast hN | |
| have hNR : (0 : β) < N := by linarith | |
| have HX : X N β€ A*(N : β)^p := by | |
| apply (HD N).trans | |
| calc | |
| _ β€ (D+1)*(2*(N : β))^p := by gcongr <;> linarith | |
| _ = _ := by dsimp [A]; rw [mul_pow]; ring | |
| have HH := Real.log_le_log (by linarith [hX N] : 0 < X N) HX | |
| rwa [Real.log_mul hA.ne' (pow_pos hNR p).ne', Real.log_pow] at HH | |
| have hstep (N : β) (_hN : 1 β€ N) : Real.log (X N) β€ c+Ο*Real.log (X (K*N)) := by | |
| have hx : 0 < X N := by linarith [hX N] | |
| have hy : 0 < X (K*N) := by linarith [hX (K*N)] | |
| have HL := Real.log_le_log (pow_pos hx P) (H N) | |
| rw [Real.log_mul (by linarith : C β 0) (pow_ne_zero _ hy.ne'), Real.log_pow, | |
| Real.log_pow, Nat.cast_sub hP, Nat.cast_one] at HL | |
| have he : c+Ο*Real.log (X (K*N)) = | |
| (Real.log C+((P : β)-1)*Real.log (X (K*N)))/(P : β) := by | |
| dsimp [c, Ο] | |
| field_simp | |
| rw [he] | |
| exact (le_div_iffβ hPR).mpr (by simpa only [mul_comm] using HL) | |
| have HB := multiplicative_cutoff_log_bound (fun N => Real.log (X N)) K hK | |
| Ο c (Real.log A) p hΟ0 hΟ1 hc hstart hstep | |
| let B := Real.exp (c/(1-Ο)) | |
| have HB1 : 1 β€ B := Real.one_le_exp_iff.mpr (div_nonneg hc (by linarith)) | |
| have HBN (N : β) (hN : 1 β€ N) : X N β€ B := by | |
| have hx : 0 < X N := by linarith [hX N] | |
| simpa [B, Real.exp_log hx] using Real.exp_le_exp.mpr (HB N hN) | |
| exact β¨B, HB1, fun N => if hN : 1 β€ N then HBN N hN else | |
| (hm (show N β€ 1 by omega)).trans (HBN 1 le_rfl)β© | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| include U | |
| theorem exists_bounded_sharpGrowth (hc : A.toVertexAlgebra.C2Cofinite) : | |
| β X : β β β, (β N, 1 β€ X N) β§ Monotone X β§ | |
| (β B : β, 1 β€ B β§ β N, X N β€ B) β§ | |
| (β e, β b β A.grade e, A.SharpGrowth X b e) := by | |
| obtain β¨D, hD, S, _hSzero, hS, _hspan, _hcut, Hβ© := U.exists_sharpMajorant hc | |
| have hp := U.polynomialEnergyBounds hc | |
| obtain β¨C, hC, HCβ© := U.sharpMajorant_power_contraction D hD S hS hp H | |
| have HB := polynomial_power_contraction_bounded (A.sharpMajorant D S) | |
| (A.one_le_sharpMajorant D S) (A.sharpMajorant_mono D S) | |
| (U.sharpMajorant_polynomial D S (fun d a ha => (hS d a ha).1) hp) | |
| 2 (2*D) (by decide) (by omega) C hC HC | |
| exact β¨A.sharpMajorant D S, A.one_le_sharpMajorant D S, A.sharpMajorant_mono D S, HB, Hβ© | |
| theorem optimal_quasiPrimary_cutoff (hc : A.toVertexAlgebra.C2Cofinite) | |
| {a : V} {d : β} (ha : a β A.grade d) (hq : A.IsQuasiPrimary a) | |
| (hh : U.IsHermitian d a) (hd : 2 β€ d) : | |
| β C : β, 0 < C β§ β N (m : β€) v, v β A.energyCutoff N β | |
| βA.physicalMode a d m vβ β€ C*(1+|(m : β)|)^(2*d)*(N+1 : β)^(d-1)*βvβ := by | |
| obtain β¨X, hX, hm, β¨B, hB, HBβ©, Hβ© := U.exists_bounded_sharpGrowth hc | |
| obtain β¨C, hC, HCβ© := U.nonzeroModes_sharp_bound hX ha hq hh hd (fun e _ b hb => H e b hb) | |
| obtain β¨D, hD, HDβ© := U.zeroMode_sharpGrowth hX hm (U.polynomialEnergyBounds hc a) | |
| ha hq hh hd (fun e _ b hb => H e b hb) | |
| let K := (C+D+2)*B^(d-1) | |
| have hK : 0 < K := by dsimp [K]; positivity | |
| have Hzero (N : β) (v : V) (hv : v β A.energyCutoff N) : | |
| βA.physicalMode a d 0 vβ β€ K*(N+1 : β)^(d-1)*βvβ := by | |
| have Hn := norm_of_sharp_square (zero_le_one.trans (hX (2*N))) hD N (d-1) (d-1) v _ (HD N v hv) | |
| apply Hn.trans | |
| calc | |
| _ β€ (C+D+2)*(N+1 : β)^(d-1)*B^(d-1)*βvβ := by | |
| have hhX := zero_le_one.trans (hX (2*N)) | |
| gcongr <;> linarith [HB (2*N)] | |
| _ = _ := by dsimp [K]; ring | |
| have Hpos (N m : β) (hm : 0 < m) (v : V) (hv : v β A.energyCutoff N) : | |
| βA.physicalMode a d m vβ β€ K*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*βvβ β§ | |
| βA.physicalMode a d (-(m : β€)) vβ β€ K*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*βvβ := by | |
| have Hn := HC N m hm v hv | |
| have hbound : C*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*X N^(d-1)*βvβ β€ | |
| K*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*βvβ := by | |
| have hhX := zero_le_one.trans (hX N) | |
| calc | |
| _ β€ (C+D+2)*(m+1 : β)^(2*d)*(N+1 : β)^(d-1)*B^(d-1)*βvβ := by | |
| gcongr | |
| Β· linarith | |
| Β· exact HB N | |
| _ = _ := by dsimp [K]; ring | |
| exact β¨Hn.1.trans hbound, Hn.2.trans hboundβ© | |
| refine β¨K, hK, ?_β© | |
| intro N m v hv | |
| rcases m with m | m | |
| Β· by_cases hm0 : m = 0 | |
| Β· subst m | |
| simpa using Hzero N v hv | |
| Β· simpa only [Int.ofNat_eq_natCast, Int.cast_natCast, | |
| abs_of_nonneg (show (0 : β) β€ (m : β) from Nat.cast_nonneg m), add_comm 1 (m : β)] using | |
| (Hpos N m (by omega) v hv).1 | |
| Β· have he : Int.negSucc m = -((m+1 : β) : β€) := by omega | |
| rw [he] | |
| simpa only [Int.cast_neg, abs_neg, Int.cast_natCast, | |
| abs_of_nonneg (show (0 : β) β€ ((m+1 : β) : β) from Nat.cast_nonneg (m+1)), | |
| add_comm 1 ((m+1 : β) : β)] using (Hpos N (m+1) (by omega) v hv).2 | |
| theorem physical_energyBound_of_cutoffs {a : V} {d p k : β} {C : β} | |
| (ha : a β A.grade d) (hC : 0 β€ C) | |
| (H : β N (m : β€) v, v β A.energyCutoff N β | |
| βA.physicalMode a d m vβ β€ C*(1+|(m : β)|)^p*(N+1 : β)^k*βvβ) : | |
| β (m : β€) v, βA.physicalMode a d m vβ β€ | |
| C*(1+|(m : β)|)^p*β(A.energyShift^k) vβ := by | |
| classical | |
| intro m v | |
| let L := C*(1+|(m : β)|)^p | |
| have hL : 0 β€ L := by dsimp [L]; positivity | |
| apply (sq_le_sqβ (norm_nonneg _) (mul_nonneg hL (norm_nonneg _))).mp | |
| change βA.physicalMode a d m vβ^2 β€ (L*β(A.energyShift^k) vβ)^2 | |
| rw [physicalMode, U.mode_norm_sq_eq_sum_grades ha] | |
| calc | |
| _ β€ β h β A.gradeSupport v, (L*(1+(h : β))^k*βA.gradeComponent h vβ)^2 := by | |
| apply Finset.sum_le_sum | |
| intro h _ | |
| apply (sq_le_sqβ (norm_nonneg _) (by positivity)).mpr | |
| simpa only [L, physicalMode, add_comm (h : β) 1] using H h m (A.gradeComponent h v) | |
| (A.grade_le_energyCutoff le_rfl (A.gradeComponent_mem h v)) | |
| _ = L^2 * β h β A.gradeSupport v, ((1+(h : β))^k*βA.gradeComponent h vβ)^2 := by | |
| rw [Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro h _ | |
| ring | |
| _ = _ := by rw [β U.energy_norm_sq_eq_sum_grades]; ring | |
| theorem optimal_quasiPrimary_energyBound (hc : A.toVertexAlgebra.C2Cofinite) | |
| {a : V} {d : β} (ha : a β A.grade d) (hq : A.IsQuasiPrimary a) | |
| (hh : U.IsHermitian d a) (hd : 2 β€ d) : | |
| β C : β, 0 < C β§ β (m : β€) v, βA.physicalMode a d m vβ β€ | |
| C*(1+|(m : β)|)^(2*d)*β(A.energyShift^(d-1)) vβ := by | |
| obtain β¨C, hC, Hβ© := U.optimal_quasiPrimary_cutoff hc ha hq hh hd | |
| exact β¨C, hC, U.physical_energyBound_of_cutoffs ha hC.le Hβ© | |
| theorem current_linear_energyBound (hc : A.toVertexAlgebra.C2Cofinite) | |
| {a : V} (ha : a β A.grade 1) (hq : A.IsQuasiPrimary a) (hh : U.IsHermitian 1 a) : | |
| β C : β, 0 < C β§ β (m : β€) v, βA.physicalMode a 1 m vβ β€ | |
| C*(1+|(m : β)|)*βA.energyShift vβ := by | |
| obtain β¨X, hX, _hm, β¨B, hB, HBβ©, Hβ© := U.exists_bounded_sharpGrowth hc | |
| obtain β¨C, hC, HCβ© := (H 1 a ha).1 | |
| have HR (N : β) : A.positiveColumnNorm a 1 N β€ (C+1)*B*(N+1 : β) := by | |
| have Hsq := positiveColumnNorm_sq_le (by positivity : 0 β€ C*(N+1 : β)*X N^2) | |
| (by simpa only [ColumnControl, show 2*1-1=1 by decide, show 2*1=2 by decide, pow_one] using HC N) | |
| have hXN := zero_le_one.trans (hX N) | |
| have hCX : C*(N+1 : β)*X N^2 β€ C*(N+1 : β)*B^2 := by gcongr; exact HB N | |
| apply (sq_le_sqβ (A.positiveColumnNorm_nonneg a 1 N) (by positivity)).mp | |
| apply Hsq.trans (hCX.trans _) | |
| have hN : 1 β€ (N+1 : β) := by linarith [Nat.cast_nonneg (Ξ± := β) N] | |
| have hcc : C β€ (C+1)^2 := by nlinarith | |
| calc | |
| _ β€ (C+1)^2*(N+1 : β)^2*B^2 := by gcongr; nlinarith | |
| _ = _ := by ring | |
| let K := (C+1)*B | |
| have hK : 0 < K := by dsimp [K]; positivity | |
| have Hcut (N : β) (m : β€) v (hv : v β A.energyCutoff N) : | |
| βA.physicalMode a 1 m vβ β€ K*(1+|(m : β)|)^1*(N+1 : β)^1*βvβ := by | |
| have HR' (n : β) : A.positiveColumnNorm a 1 n β€ K*(n+1 : β) := HR n | |
| rcases m with m | m | |
| Β· apply (A.positive_mode_norm_le_column ha hv m).trans | |
| simp only [Int.ofNat_eq_natCast, Int.cast_natCast, | |
| abs_of_nonneg (show (0 : β) β€ m from Nat.cast_nonneg m), pow_one] | |
| calc | |
| _ β€ K*(N+1 : β)*βvβ := mul_le_mul_of_nonneg_right (HR' N) (norm_nonneg _) | |
| _ β€ _ := by nlinarith [mul_nonneg (mul_nonneg hK.le (by positivity : 0 β€ (N+1 : β))) (norm_nonneg v), | |
| mul_nonneg (Nat.cast_nonneg (Ξ± := β) m) (mul_nonneg (mul_nonneg hK.le (by positivity : 0 β€ (N+1 : β))) (norm_nonneg v))] | |
| Β· have he : Int.negSucc m = -((m+1 : β) : β€) := by omega | |
| rw [he] | |
| apply (U.negative_mode_norm_le_column ha hq hh hv (m+1)).trans | |
| simp only [Int.cast_neg, abs_neg, Int.cast_natCast, | |
| abs_of_nonneg (show (0 : β) β€ ((m+1 : β) : β) from Nat.cast_nonneg (m+1)), pow_one] | |
| calc | |
| _ β€ K*((N+(m+1) : β)+1 : β)*βvβ := mul_le_mul_of_nonneg_right (HR' (N+(m+1))) (norm_nonneg _) | |
| _ β€ _ := by | |
| have hbase : (((N+(m+1) : β) : β)+1) β€ (1+((m+1 : β) : β))*(N+1 : β) := by | |
| push_cast | |
| have hh := mul_nonneg (Nat.cast_nonneg (Ξ± := β) m) (Nat.cast_nonneg (Ξ± := β) N) | |
| nlinarith [Nat.cast_nonneg (Ξ± := β) N] | |
| calc | |
| _ β€ K*((1+((m+1 : β) : β))*(N+1 : β))*βvβ := by gcongr | |
| _ = _ := by ring | |
| refine β¨K, hK, ?_β© | |
| simpa only [pow_one] using U.physical_energyBound_of_cutoffs ha hK.le Hcut | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace HilbertCore | |
| open UniformSpace | |
| variable {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| end HilbertCore | |
| end StronglyRationalVOA | |
| end | |
| end OAI | |