| 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 |
|
|
