Download data/lean/OAI/RepresentationTheory/VertexAlgebra/ColumnControl.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 24.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/ColumnControl.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/VertexAlgebra/ColumnControl.lean
-
curl -L -o ColumnControl.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/VertexAlgebra/ColumnControl.lean
24.6 kB
| import Mathlib | |
| import OAI.RepresentationTheory.VertexAlgebra.ConstrainedSquareBound | |
| 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) | |
| def ColumnControl (a : V) (d N : β) (K : β) : Prop := | |
| β v β A.energyCutoff N, | |
| (β m β Finset.range (N + 1), βA.physicalMode a d m vβ^2) β€ K * βvβ^2 | |
| theorem columnControl_subset {a : V} {d N : β} {K : β} (ha : a β A.grade d) | |
| (H : A.ColumnControl a d N K) {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β β) | |
| (hf : Set.InjOn f s) {v : V} (hv : v β A.energyCutoff N) : | |
| (β i β s, βA.physicalMode a d (f i) vβ^2) β€ K * βvβ^2 := by | |
| apply (SharpColumns.sum_injective_le s f hf (fun m => βA.physicalMode a d m vβ^2) | |
| (fun _ => sq_nonneg _) N ?_).trans (H v hv) | |
| intro m hm | |
| rw [A.physicalMode_zero_above_cutoff ha hv m (by exact_mod_cast hm)] | |
| simp | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| def AdjointColumnControl (a : V) (d N : β) (K : β) : Prop := | |
| β v β A.energyCutoff N, | |
| (β m β Finset.range (N + 1), βU.adjointPhysicalMode a d (-(m : β€)) vβ^2) β€ K * βvβ^2 | |
| theorem adjointColumnControl_subset {a : V} {d N : β} {K : β} (ha : a β A.grade d) | |
| (H : U.AdjointColumnControl a d N K) {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β β) | |
| (hf : Set.InjOn f s) {v : V} (hv : v β A.energyCutoff N) : | |
| (β i β s, βU.adjointPhysicalMode a d (-(f i : β€)) vβ^2) β€ K * βvβ^2 := by | |
| apply (SharpColumns.sum_injective_le s f hf | |
| (fun m => βU.adjointPhysicalMode a d (-(m : β€)) vβ^2) | |
| (fun _ => sq_nonneg _) N ?_).trans (H v hv) | |
| intro m hm | |
| rw [U.adjointPhysicalMode_zero_above_cutoff ha hv m (by exact_mod_cast hm)] | |
| simp | |
| end UnitaryStructure | |
| def normalLeft (a b v : V) (d e N m : β) : V := | |
| β j β Finset.range (N + 1), A.physicalMode a d (-1 - j) | |
| (A.physicalMode b e (m + 1 + j) v) | |
| def normalRightHigh (a b v : V) (d e N m : β) : V := | |
| β j β Finset.range (N + 1) with m β€ j, A.physicalMode b e ((m : β€) - j) | |
| (A.physicalMode a d j v) | |
| def normalRightLow (a b v : V) (d e N m : β) : V := | |
| β j β Finset.range (N + 1) with j < m, A.physicalMode b e ((m : β€) - j) | |
| (A.physicalMode a d j v) | |
| theorem normalLeft_mem_cutoff {a b v : V} {d e N m : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hv : v β A.energyCutoff N) : | |
| A.normalLeft a b v d e N m β A.energyCutoff N := by | |
| apply Submodule.sum_mem | |
| intro j _ | |
| by_cases hj : N < m + 1 + j | |
| Β· rw [A.physicalMode_zero_above_cutoff hb hv (m + 1 + j) (by exact_mod_cast hj), map_zero] | |
| exact Submodule.zero_mem _ | |
| Β· have hinner := A.physicalMode_mem_cutoff hb hv (m + 1 + j) (M := N - (m + 1 + j)) (by omega) | |
| exact A.physicalMode_mem_cutoff ha hinner (-1 - j) (by omega) | |
| theorem normalRightHigh_mem_cutoff {a b v : V} {d e N m : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hv : v β A.energyCutoff N) : | |
| A.normalRightHigh a b v d e N m β A.energyCutoff N := by | |
| apply Submodule.sum_mem | |
| intro j hj | |
| have hjN := Finset.mem_range.mp (Finset.mem_filter.mp hj).1 | |
| have hinner := A.physicalMode_mem_cutoff ha hv j (M := N - j) (by omega) | |
| exact A.physicalMode_mem_cutoff hb hinner ((m : β€) - j) (by omega) | |
| theorem normalRightLow_mem_cutoff {a b v : V} {d e N m : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hv : v β A.energyCutoff N) : | |
| A.normalRightLow a b v d e N m β A.energyCutoff N := by | |
| apply Submodule.sum_mem | |
| intro j hj | |
| have hjN := Finset.mem_range.mp (Finset.mem_filter.mp hj).1 | |
| have hinner := A.physicalMode_mem_cutoff ha hv j (M := N - j) (by omega) | |
| exact A.physicalMode_mem_cutoff hb hinner ((m : β€) - j) (by omega) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| theorem normalLeft_sq_le {a b v : V} {d e N m : β} {K L : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hv : v β A.energyCutoff N) | |
| (hK : 0 β€ K) (Ha : U.AdjointColumnControl a d N K) (Hb : A.ColumnControl b e N L) : | |
| βA.normalLeft a b v d e N mβ^2 β€ K * L * βvβ^2 := by | |
| have H := SharpColumns.row_sq_le (Finset.range (N + 1)) | |
| (fun j => A.physicalMode a d (-1 - j)) | |
| (fun j => U.adjointPhysicalMode a d (-1 - j)) | |
| (A.energyCutoff N) K hK (fun j _ x y => U.adjointPhysicalMode_inner ha _ x y) | |
| (fun w hw => by | |
| have HH := U.adjointColumnControl_subset ha Ha (Finset.range (N + 1)) | |
| (fun j => j + 1) (by intro i _ j _ he; dsimp only at he; omega) hw | |
| simpa only [Nat.cast_add, Nat.cast_one, neg_add_rev, sub_eq_add_neg] using HH) | |
| (fun j => A.physicalMode b e (m + 1 + j) v) (fun _ => 1) 1 (by norm_num) | |
| (by intro j _; simp) (by simpa only [one_smul, normalLeft] using A.normalLeft_mem_cutoff ha hb hv (m := m)) | |
| simp only [one_pow, one_mul, one_smul] at H | |
| apply H.trans | |
| have HH := A.columnControl_subset hb Hb (Finset.range (N + 1)) | |
| (fun j => m + 1 + j) (by intro i _ j _ he; dsimp only at he; omega) hv | |
| push_cast at HH | |
| simpa only [mul_assoc] using mul_le_mul_of_nonneg_left HH hK | |
| theorem normalRightHigh_sq_le {a b v : V} {d e N m : β} {K L : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hv : v β A.energyCutoff N) | |
| (hL : 0 β€ L) (Ha : A.ColumnControl a d N K) (Hb : U.AdjointColumnControl b e N L) : | |
| βA.normalRightHigh a b v d e N mβ^2 β€ K * L * βvβ^2 := by | |
| let s := (Finset.range (N + 1)).filter (fun j => m β€ j) | |
| have H := SharpColumns.row_sq_le s | |
| (fun j => A.physicalMode b e ((m : β€) - j)) | |
| (fun j => U.adjointPhysicalMode b e ((m : β€) - j)) | |
| (A.energyCutoff N) L hL (fun j _ x y => U.adjointPhysicalMode_inner hb _ x y) | |
| (fun w hw => by | |
| have HH := U.adjointColumnControl_subset hb Hb s | |
| (fun j => j - m) (by | |
| intro i hi j hj he | |
| dsimp only at he | |
| have hi := (Finset.mem_filter.mp hi).2 | |
| have hj := (Finset.mem_filter.mp hj).2 | |
| omega) hw | |
| calc | |
| _ = β j β s, βU.adjointPhysicalMode b e (-((j - m : β) : β€)) wβ^2 := by | |
| apply Finset.sum_congr rfl | |
| intro j hj | |
| have hj := (Finset.mem_filter.mp hj).2 | |
| rw [show (m : β€) - j = -((j - m : β) : β€) by omega] | |
| _ β€ _ := HH) | |
| (fun j => A.physicalMode a d j v) (fun _ => 1) 1 (by norm_num) | |
| (by intro j _; simp) (by simpa only [one_smul, normalRightHigh, s] using A.normalRightHigh_mem_cutoff ha hb hv (m := m)) | |
| simp only [one_pow, one_mul, one_smul] at H | |
| apply H.trans | |
| have HH := A.columnControl_subset ha Ha s id (by intro i _ j _ h; exact h) hv | |
| calc | |
| _ β€ L * (K * βvβ^2) := mul_le_mul_of_nonneg_left HH hL | |
| _ = _ := by ring | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace SharpColumns | |
| variable {V : Type*} [NormedAddCommGroup V] | |
| theorem norm_add_add_sub_sq_le (x y z t : V) : | |
| βx + y + z - tβ^2 β€ 4 * (βxβ^2 + βyβ^2 + βzβ^2 + βtβ^2) := by | |
| have h := finite_sum_sq_le_card (Finset.univ : Finset (Fin 4)) ![x, y, z, -t] | |
| simpa [Fin.sum_univ_succ, sub_eq_add_neg, add_assoc] using h | |
| theorem sum_columns_sq_le {ΞΉ ΞΊ : Type*} (s : Finset ΞΉ) (t : Finset ΞΊ) | |
| (f : ΞΉ β ΞΊ β V) (K : ΞΉ β β) | |
| (H : β i β s, β k β t, βf i kβ^2 β€ K i) : | |
| (β k β t, ββ i β s, f i kβ^2) β€ (s.card : β) * β i β s, K i := by | |
| calc | |
| _ β€ β k β t, (s.card : β) * β i β s, βf i kβ^2 := | |
| Finset.sum_le_sum fun k _ => finite_sum_sq_le_card s (fun i => f i k) | |
| _ = (s.card : β) * β i β s, β k β t, βf i kβ^2 := by | |
| rw [β Finset.mul_sum, Finset.sum_comm] | |
| _ β€ _ := mul_le_mul_of_nonneg_left (Finset.sum_le_sum H) (Nat.cast_nonneg _) | |
| end SharpColumns | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| theorem normalRightLow_column_sq_le {a b v : V} {d e N : β} {K L : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hv : v β A.energyCutoff N) | |
| (hL : 0 β€ L) (Ha : A.ColumnControl a d N K) (Hb : A.ColumnControl b e N L) : | |
| (β m β Finset.range (N + 1), βA.normalRightLow a b v d e N mβ^2) β€ | |
| (N + 1 : β) * K * L * βvβ^2 := by | |
| classical | |
| have H := SharpColumns.triangular_column_sq_le (Finset.range (N + 1)) (Finset.range (N + 1)) | |
| (fun j => A.physicalMode a d j v) (fun m j => A.physicalMode b e ((m : β€) - j)) | |
| (fun m j => j < m) (fun _ _ => 1) 1 L | |
| (by intro m _ j _ _; simp) | |
| (by | |
| intro j hj | |
| have hmem := A.physicalMode_mem_cutoff ha hv j (M := N) (by omega) | |
| have HH := A.columnControl_subset hb Hb ((Finset.range (N + 1)).filter (fun m => j < m)) | |
| (fun m => m - j) (by | |
| intro r hr s hs he | |
| dsimp only at he | |
| have hr := (Finset.mem_filter.mp hr).2 | |
| have hs := (Finset.mem_filter.mp hs).2 | |
| omega) hmem | |
| calc | |
| _ = β m β Finset.range (N + 1) with j < m, | |
| βA.physicalMode b e ((m - j : β) : β€) (A.physicalMode a d j v)β^2 := by | |
| apply Finset.sum_congr rfl | |
| intro m hm | |
| rw [Nat.cast_sub (Nat.le_of_lt (Finset.mem_filter.mp hm).2)] | |
| _ β€ _ := HH) | |
| simp only [one_smul, one_pow, mul_one, Finset.card_range, Nat.cast_add, Nat.cast_one] at H | |
| apply H.trans | |
| have HH := mul_le_mul_of_nonneg_left (Ha v hv) | |
| (mul_nonneg (by positivity : 0 β€ (N + 1 : β)) hL) | |
| simpa only [normalRightLow, mul_assoc, mul_comm K L, mul_left_comm L K] using HH | |
| theorem normal_product_cutoff_split {a b v : V} {d e N : β} | |
| (hb : b β A.grade e) (ha : a β A.grade d) (hv : v β A.energyCutoff N) | |
| (hd : 1 β€ d) (m : β) : | |
| A.physicalMode (mode A.fields a (-1) b) (d + e) m v = | |
| A.normalLeft a b v d e N m + A.normalRightHigh a b v d e N m + | |
| A.normalRightLow a b v d e N m - | |
| β i β Finset.range (d - 1), β j β Finset.range (i + 1), | |
| (i.choose j : β) β’ mode A.fields (mode A.fields a j b) | |
| (m + d + e - 2 - j) v := by | |
| classical | |
| rw [A.physical_normal_product_resplit a b v d e hd m] | |
| have hL : Function.support (fun j : β => A.physicalMode a d (-1 - j) | |
| (A.physicalMode b e (m + 1 + j) v)) β (Finset.range (N + 1) : Set β) := by | |
| intro j hj | |
| simp only [Finset.coe_range, Set.mem_Iio] | |
| by_contra h | |
| apply hj | |
| change A.physicalMode a d (-1 - j) (A.physicalMode b e (m + 1 + j) v) = 0 | |
| rw [A.physicalMode_zero_above_cutoff hb hv (m + 1 + j) (by omega), map_zero] | |
| have hR : Function.support (fun j : β => A.physicalMode b e ((m : β€) - j) | |
| (A.physicalMode a d j v)) β (Finset.range (N + 1) : Set β) := by | |
| intro j hj | |
| simp only [Finset.coe_range, Set.mem_Iio] | |
| by_contra h | |
| apply hj | |
| change A.physicalMode b e ((m : β€) - j) (A.physicalMode a d j v) = 0 | |
| rw [A.physicalMode_zero_above_cutoff ha hv j (by omega), map_zero] | |
| rw [finsum_eq_sum_of_support_subset _ hL, finsum_eq_sum_of_support_subset _ hR] | |
| have hs := Finset.sum_filter_add_sum_filter_not (Finset.range (N + 1)) | |
| (fun j => m β€ j) (fun j => A.physicalMode b e ((m : β€) - j) (A.physicalMode a d j v)) | |
| simp only [not_le] at hs | |
| dsimp only [normalLeft, normalRightHigh, normalRightLow] | |
| rw [β hs] | |
| simp only [add_assoc] | |
| def sharpCorrectionMass (d : β) : β := | |
| (d - 1 : β) * β i β Finset.range (d - 1), (i + 1 : β) * | |
| β j β Finset.range (i + 1), (i.choose j : β)^2 | |
| theorem sharpCorrectionMass_nonneg (d : β) : 0 β€ sharpCorrectionMass d := by | |
| unfold sharpCorrectionMass | |
| positivity | |
| theorem singular_correction_column_sq_le {a b v : V} {d e N : β} {R : β} | |
| (hd : 1 β€ d) (Hsing : β j < d - 1, | |
| A.ColumnControl (mode A.fields a j b) (d + e - j - 1) N R) | |
| (hv : v β A.energyCutoff N) : | |
| (β m β Finset.range (N + 1), ββ i β Finset.range (d - 1), β j β Finset.range (i + 1), | |
| (i.choose j : β) β’ mode A.fields (mode A.fields a j b) (m + d + e - 2 - j) vβ^2) β€ | |
| sharpCorrectionMass d * R * βvβ^2 := by | |
| classical | |
| let T := fun (i j m : β) => (i.choose j : β) β’ | |
| mode A.fields (mode A.fields a j b) (m + d + e - 2 - j) v | |
| have hinner (i : β) (hi : i β Finset.range (d - 1)) (j : β) | |
| (hj : j β Finset.range (i + 1)) : | |
| (β m β Finset.range (N + 1), βT i j mβ^2) β€ (i.choose j : β)^2 * R * βvβ^2 := by | |
| have hjd : j < d - 1 := by have := Finset.mem_range.mp hi; have := Finset.mem_range.mp hj; omega | |
| have he : β m : β, (m : β€) + d + e - 2 - j = m + (d + e - j - 1 : β) - 1 := by | |
| intro m | |
| omega | |
| simp only [T, norm_smul, Complex.norm_natCast, mul_pow, he, | |
| β Finset.mul_sum] | |
| simpa only [mul_assoc, physicalMode] using mul_le_mul_of_nonneg_left (Hsing j hjd v hv) (sq_nonneg (i.choose j : β)) | |
| have hi (i : β) (hi : i β Finset.range (d - 1)) : | |
| (β m β Finset.range (N + 1), ββ j β Finset.range (i + 1), T i j mβ^2) β€ | |
| (i + 1 : β) * β j β Finset.range (i + 1), (i.choose j : β)^2 * R * βvβ^2 := by | |
| simpa only [Finset.card_range, Nat.cast_add, Nat.cast_one] using | |
| SharpColumns.sum_columns_sq_le (Finset.range (i + 1)) (Finset.range (N + 1)) | |
| (T i) (fun j => (i.choose j : β)^2 * R * βvβ^2) (hinner i hi) | |
| have H := SharpColumns.sum_columns_sq_le (Finset.range (d - 1)) (Finset.range (N + 1)) | |
| (fun i m => β j β Finset.range (i + 1), T i j m) | |
| (fun i => (i + 1 : β) * β j β Finset.range (i + 1), (i.choose j : β)^2 * R * βvβ^2) hi | |
| simpa only [Finset.card_range, sharpCorrectionMass, Finset.sum_mul, mul_assoc, T] using H | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| theorem columnControl_mono {a : V} {d N : β} {K L : β} | |
| (H : A.ColumnControl a d N K) (hKL : K β€ L) : A.ColumnControl a d N L := by | |
| intro v hv | |
| exact (H v hv).trans (mul_le_mul_of_nonneg_right hKL (sq_nonneg _)) | |
| theorem columnControl_mode_sq_le {a v : V} {d N m : β} {K : β} | |
| (ha : a β A.grade d) (H : A.ColumnControl a d N K) (hv : v β A.energyCutoff N) : | |
| βA.physicalMode a d m vβ^2 β€ K * βvβ^2 := by | |
| simpa using A.columnControl_subset ha H {m} id (by intro i _ j _ h; exact h) hv | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| theorem normalProduct_columnControl {a b : V} {d e N : β} {K L R : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hd : 1 β€ d) | |
| (hK : 0 β€ K) (hL : 0 β€ L) | |
| (Ha : A.ColumnControl a d N K) (Ha' : U.AdjointColumnControl a d N K) | |
| (Hb : A.ColumnControl b e N L) (Hb' : U.AdjointColumnControl b e N L) | |
| (Hsing : β j < d - 1, | |
| A.ColumnControl (mode A.fields a j b) (d + e - j - 1) N R) : | |
| A.ColumnControl (mode A.fields a (-1) b) (d + e) N | |
| (12 * (N + 1 : β) * K * L + 4 * sharpCorrectionMass d * R) := by | |
| intro v hv | |
| let T := fun m : β => β i β Finset.range (d - 1), β j β Finset.range (i + 1), | |
| (i.choose j : β) β’ mode A.fields (mode A.fields a j b) (m + d + e - 2 - j) v | |
| have hleft : (β m β Finset.range (N + 1), βA.normalLeft a b v d e N mβ^2) β€ | |
| (N + 1 : β) * K * L * βvβ^2 := by | |
| calc | |
| _ β€ β _m β Finset.range (N + 1), K * L * βvβ^2 := | |
| Finset.sum_le_sum fun _ _ => U.normalLeft_sq_le ha hb hv hK Ha' Hb | |
| _ = _ := by simp [mul_assoc] | |
| have hhigh : (β m β Finset.range (N + 1), βA.normalRightHigh a b v d e N mβ^2) β€ | |
| (N + 1 : β) * K * L * βvβ^2 := by | |
| calc | |
| _ β€ β _m β Finset.range (N + 1), K * L * βvβ^2 := | |
| Finset.sum_le_sum fun _ _ => U.normalRightHigh_sq_le ha hb hv hL Ha Hb' | |
| _ = _ := by simp [mul_assoc] | |
| have hlow := A.normalRightLow_column_sq_le ha hb hv hL Ha Hb | |
| have hsing := A.singular_correction_column_sq_le hd Hsing hv | |
| calc | |
| _ β€ β m β Finset.range (N + 1), 4 * (βA.normalLeft a b v d e N mβ^2 + | |
| βA.normalRightHigh a b v d e N mβ^2 + βA.normalRightLow a b v d e N mβ^2 + βT mβ^2) := by | |
| apply Finset.sum_le_sum | |
| intro m _ | |
| rw [A.normal_product_cutoff_split hb ha hv hd] | |
| exact SharpColumns.norm_add_add_sub_sq_le _ _ _ _ | |
| _ = 4 * ((β m β Finset.range (N + 1), βA.normalLeft a b v d e N mβ^2) + | |
| (β m β Finset.range (N + 1), βA.normalRightHigh a b v d e N mβ^2) + | |
| (β m β Finset.range (N + 1), βA.normalRightLow a b v d e N mβ^2) + | |
| (β m β Finset.range (N + 1), βT mβ^2)) := by rw [β Finset.mul_sum]; simp only [Finset.sum_add_distrib] | |
| _ β€ _ := by dsimp only [T] at *; nlinarith | |
| theorem normalProduct_zero_sq_le {a b v : V} {d e N : β} {K L R : β} | |
| (ha : a β A.grade d) (hb : b β A.grade e) (hd : 1 β€ d) | |
| (hv : v β A.energyCutoff N) (hK : 0 β€ K) (hL : 0 β€ L) | |
| (Ha : A.ColumnControl a d N K) (Ha' : U.AdjointColumnControl a d N K) | |
| (Hb : A.ColumnControl b e N L) (Hb' : U.AdjointColumnControl b e N L) | |
| (Hsing : β j < d - 1, | |
| A.ColumnControl (mode A.fields a j b) (d + e - j - 1) N R) : | |
| βA.physicalMode (mode A.fields a (-1) b) (d + e) 0 vβ^2 β€ | |
| (8 * K * L + 4 * sharpCorrectionMass d * R) * βvβ^2 := by | |
| let T := fun m : β => β i β Finset.range (d - 1), β j β Finset.range (i + 1), | |
| (i.choose j : β) β’ mode A.fields (mode A.fields a j b) (m + d + e - 2 - j) v | |
| have hleft := U.normalLeft_sq_le (m := 0) ha hb hv hK Ha' Hb | |
| have hhigh := U.normalRightHigh_sq_le (m := 0) ha hb hv hL Ha Hb' | |
| have hlow : A.normalRightLow a b v d e N 0 = 0 := by simp [normalRightLow] | |
| have hsing : βT 0β^2 β€ sharpCorrectionMass d * R * βvβ^2 := by | |
| apply (Finset.single_le_sum (f := fun m => βT mβ^2) (fun _ _ => sq_nonneg _) (by simp : 0 β Finset.range (N + 1))).trans | |
| exact A.singular_correction_column_sq_le hd Hsing hv | |
| calc | |
| _ β€ 4 * (βA.normalLeft a b v d e N 0β^2 + βA.normalRightHigh a b v d e N 0β^2 + | |
| βA.normalRightLow a b v d e N 0β^2 + βT 0β^2) := by | |
| rw [show (0 : β€) = (0 : β) by rfl, A.normal_product_cutoff_split hb ha hv hd] | |
| exact SharpColumns.norm_add_add_sub_sq_le _ _ _ _ | |
| _ β€ _ := by rw [hlow, norm_zero, zero_pow (by decide : 2 β 0)]; nlinarith | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| namespace SharpColumns | |
| variable {V : Type*} [NormedAddCommGroup V] | |
| theorem norm_add_sq_le_two (x y : V) : βx + yβ^2 β€ 2 * (βxβ^2 + βyβ^2) := by | |
| have h := pow_le_pow_leftβ (norm_nonneg _) (norm_add_le x y) 2 | |
| nlinarith [sq_nonneg (βxβ - βyβ)] | |
| end SharpColumns | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| def ColumnGrowth (X : β β β) (a : V) (d p q : β) : Prop := | |
| β C : β, 0 β€ C β§ β N, A.ColumnControl a d N (C * (N + 1 : β)^p * X N^q) | |
| def ZeroGrowth (X : β β β) (a : V) (d p q : β) : Prop := | |
| β C : β, 0 β€ C β§ β N v, v β A.energyCutoff N β | |
| βA.physicalMode a d 0 vβ^2 β€ C * (N + 1 : β)^p * X N^q * βvβ^2 | |
| theorem columnGrowth_zero (X : β β β) (d p q : β) : A.ColumnGrowth X 0 d p q := by | |
| refine β¨0, le_rfl, ?_β© | |
| intro N v hv | |
| simp [physicalMode, mode_zero] | |
| theorem zeroGrowth_zero (X : β β β) (d p q : β) : A.ZeroGrowth X 0 d p q := by | |
| refine β¨0, le_rfl, ?_β© | |
| intro N v hv | |
| simp [physicalMode, mode_zero] | |
| theorem columnGrowth_add {X : β β β} {a b : V} {d p q : β} | |
| (Ha : A.ColumnGrowth X a d p q) (Hb : A.ColumnGrowth X b d p q) : | |
| A.ColumnGrowth X (a + b) d p q := by | |
| obtain β¨C, hC, HCβ© := Ha | |
| obtain β¨D, hD, HDβ© := Hb | |
| refine β¨2 * (C + D), by positivity, ?_β© | |
| intro N v hv | |
| calc | |
| _ β€ β m β Finset.range (N + 1), 2 * (βA.physicalMode a d m vβ^2 + βA.physicalMode b d m vβ^2) := by | |
| apply Finset.sum_le_sum | |
| intro m _ | |
| simp only [physicalMode, mode_add, LinearMap.add_apply] | |
| exact SharpColumns.norm_add_sq_le_two _ _ | |
| _ = 2 * ((β m β Finset.range (N + 1), βA.physicalMode a d m vβ^2) + | |
| β m β Finset.range (N + 1), βA.physicalMode b d m vβ^2) := by rw [β Finset.mul_sum, Finset.sum_add_distrib] | |
| _ β€ _ := by nlinarith [HC N v hv, HD N v hv] | |
| theorem zeroGrowth_add {X : β β β} {a b : V} {d p q : β} | |
| (Ha : A.ZeroGrowth X a d p q) (Hb : A.ZeroGrowth X b d p q) : | |
| A.ZeroGrowth X (a + b) d p q := by | |
| obtain β¨C, hC, HCβ© := Ha | |
| obtain β¨D, hD, HDβ© := Hb | |
| refine β¨2 * (C + D), by positivity, ?_β© | |
| intro N v hv | |
| have h := SharpColumns.norm_add_sq_le_two (A.physicalMode a d 0 v) (A.physicalMode b d 0 v) | |
| simp only [physicalMode, mode_add, LinearMap.add_apply] | |
| dsimp only [physicalMode] at h HC HD | |
| nlinarith [HC N v hv, HD N v hv] | |
| theorem columnGrowth_smul {X : β β β} {a : V} {d p q : β} | |
| (Ha : A.ColumnGrowth X a d p q) (z : β) : A.ColumnGrowth X (z β’ a) d p q := by | |
| obtain β¨C, hC, HCβ© := Ha | |
| refine β¨βzβ^2 * C, by positivity, ?_β© | |
| intro N v hv | |
| simpa only [physicalMode, mode_smul, LinearMap.smul_apply, norm_smul, mul_pow, | |
| β Finset.mul_sum, mul_assoc] using mul_le_mul_of_nonneg_left (HC N v hv) (sq_nonneg βzβ) | |
| theorem zeroGrowth_smul {X : β β β} {a : V} {d p q : β} | |
| (Ha : A.ZeroGrowth X a d p q) (z : β) : A.ZeroGrowth X (z β’ a) d p q := by | |
| obtain β¨C, hC, HCβ© := Ha | |
| refine β¨βzβ^2 * C, by positivity, ?_β© | |
| intro N v hv | |
| simpa only [physicalMode, mode_smul, LinearMap.smul_apply, norm_smul, mul_pow, | |
| mul_assoc] using mul_le_mul_of_nonneg_left (HC N v hv) (sq_nonneg βzβ) | |
| theorem columnGrowth_mono {X : β β β} (hX : β N, 1 β€ X N) {a : V} {d p q p' q' : β} | |
| (H : A.ColumnGrowth X a d p q) (hp : p β€ p') (hq : q β€ q') : | |
| A.ColumnGrowth X a d p' q' := by | |
| obtain β¨C, hC, HCβ© := H | |
| refine β¨C, hC, fun N => A.columnControl_mono (HC N) ?_β© | |
| have hXN := zero_le_one.trans (hX N) | |
| gcongr | |
| Β· linarith [Nat.cast_nonneg (Ξ± := β) N] | |
| Β· exact hX N | |
| theorem zeroGrowth_mono {X : β β β} (hX : β N, 1 β€ X N) {a : V} {d p q p' q' : β} | |
| (H : A.ZeroGrowth X a d p q) (hp : p β€ p') (hq : q β€ q') : | |
| A.ZeroGrowth X a d p' q' := by | |
| obtain β¨C, hC, HCβ© := H | |
| refine β¨C, hC, ?_β© | |
| intro N v hv | |
| apply (HC N v hv).trans | |
| have hXN := zero_le_one.trans (hX N) | |
| gcongr | |
| Β· linarith [Nat.cast_nonneg (Ξ± := β) N] | |
| Β· exact hX N | |
| theorem zeroGrowth_of_columnGrowth {X : β β β} {a : V} {d p q : β} | |
| (ha : a β A.grade d) (H : A.ColumnGrowth X a d p q) : A.ZeroGrowth X a d p q := by | |
| obtain β¨C, hC, HCβ© := H | |
| exact β¨C, hC, fun N v hv => A.columnControl_mode_sq_le ha (HC N) hv (m := 0)β© | |
| def SharpDegreeGrowth (X : β β β) (a : V) (d w : β) : Prop := | |
| A.ColumnGrowth X a d (2*d-1) (2*w) β§ A.ZeroGrowth X a d (max 1 (2*d-2)) (2*w) | |
| def SharpGrowth (X : β β β) (a : V) (d : β) : Prop := | |
| A.SharpDegreeGrowth X a d d | |
| def sharpGrowthSubmodule (X : β β β) (d : β) : Submodule β V where | |
| carrier := {a | A.SharpGrowth X a d} | |
| zero_mem' := β¨A.columnGrowth_zero X d _ _, A.zeroGrowth_zero X d _ _β© | |
| add_mem' h k := β¨A.columnGrowth_add h.1 k.1, A.zeroGrowth_add h.2 k.2β© | |
| smul_mem' z _ h := β¨A.columnGrowth_smul h.1 z, A.zeroGrowth_smul h.2 zβ© | |
| theorem finite_columnGrowth_uniform {X : β β β} (hX : β N, 1 β€ X N) | |
| {ΞΉ : Type*} (s : Finset ΞΉ) (a : ΞΉ β V) (d : ΞΉ β β) (p q : β) | |
| (H : β i β s, A.ColumnGrowth X (a i) (d i) p q) : | |
| β C : β, 0 β€ C β§ β i β s, β N, | |
| A.ColumnControl (a i) (d i) N (C * (N + 1 : β)^p * X N^q) := 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 | |
| have hXN := zero_le_one.trans (hX N) | |
| rcases Finset.mem_insert.mp hj with rfl | hj | |
| Β· apply A.columnControl_mono (HC N) | |
| gcongr | |
| exact le_add_of_nonneg_right hD | |
| Β· apply A.columnControl_mono (HD j hj N) | |
| gcongr | |
| exact le_add_of_nonneg_left hC | |
| end CFTTypeVOA | |
| namespace CFTTypeVOA | |
| variable {V : Type u} [NormedAddCommGroup V] [InnerProductSpace β V] | |
| (A : CFTTypeVOA V) | |
| namespace UnitaryStructure | |
| variable {A} (U : A.UnitaryStructure) | |
| end UnitaryStructure | |
| end CFTTypeVOA | |
| end StronglyRationalVOA | |
| end | |
| end OAI | |