| import Mathlib |
| import OAI.NumberTheory.CubicGauss.Cutoffs |
|
|
| namespace OAI |
|
|
| /-! Cube extraction for cubic operators and weighted sums over cube factors. -/ |
|
|
| noncomputable section |
| open scoped BigOperators |
| open Module Complex UniqueFactorizationMonoid |
| attribute [local instance] Classical.propDecidable |
|
|
| namespace CubicFirstMoment |
| open HeckeTheta |
|
|
| lemma norm_pow_eq (a : Eisenstein) (n : ℕ) : norm (a^n) = (norm a)^n := by |
| induction n with |
| | zero => simp |
| | succ n ih => rw [pow_succ,norm_mul_eq,ih,pow_succ] |
|
|
| def cubicRowEnergy (S : Finset Eisenstein) (u : Eisenstein → ℂ) (m : Eisenstein) : ℝ := |
| ‖∑ b ∈ S, u b * cubicSymbol b m‖^2 |
|
|
| lemma cubicRowEnergy_nonneg (S : Finset Eisenstein) (u : Eisenstein → ℂ) (m : Eisenstein) : |
| 0 ≤ cubicRowEnergy S u m := sq_nonneg _ |
|
|
| lemma cubic_cube_row_twist (S : Finset Eisenstein) (hS : ∀ b ∈ S,primary b) |
| (u : Eisenstein → ℂ) (w c t s : Eisenstein) : |
| cubicRowEnergy S u (w*s*t^2*c^3) = |
| cubicRowEnergy S (fun b => u b * cubicSymbol b (w*t^2*c^3)) s := by |
| unfold cubicRowEnergy |
| congr 2 |
| apply Finset.sum_congr rfl |
| intro b hb |
| rw [show w*s*t^2*c^3 = (w*t^2*c^3)*s by ring,cubicSymbol_mul_upper (hS b hb)] |
| ring |
|
|
| lemma cubic_cube_row_twist_conj (S : Finset Eisenstein) (hS : ∀ b ∈ S,primary b) |
| (u : Eisenstein → ℂ) (w c t s : Eisenstein) : |
| cubicRowEnergy S u (w*t*s^2*c^3) = |
| cubicRowEnergy S (fun b => star (u b * cubicSymbol b (w*t*c^3))) s := by |
| unfold cubicRowEnergy |
| have he : (∑ b ∈ S, u b * cubicSymbol b (w*t*s^2*c^3)) = |
| star (∑ b ∈ S, star (u b * cubicSymbol b (w*t*c^3)) * cubicSymbol b s) := by |
| rw [star_sum] |
| apply Finset.sum_congr rfl |
| intro b hb |
| rw [star_mul,star_star,show w*t*s^2*c^3 = (w*t*c^3)*s^2 by ring, |
| cubicSymbol_mul_upper (hS b hb),cubicSymbol_pow_upper (hS b hb),cubicSymbol_sq_eq_star (hS b hb)] |
| ring |
| rw [he,norm_star] |
|
|
| lemma cubic_twist_energy_le (S : Finset Eisenstein) (hS : ∀ b ∈ S,primary b) |
| (u : Eisenstein → ℂ) (m : Eisenstein) : |
| ∑ b ∈ S, ‖u b * cubicSymbol b m‖^2 ≤ ∑ b ∈ S, ‖u b‖^2 := by |
| apply Finset.sum_le_sum |
| intro b hb |
| rw [norm_mul,mul_pow] |
| exact mul_le_of_le_one_right (sq_nonneg _) (by |
| simpa using pow_le_pow_left₀ (_root_.norm_nonneg _) (norm_cubicSymbol_le_one (hS b hb) m) 2) |
|
|
| lemma cubic_cube_box_bound (S : Finset Eisenstein) (hS : ∀ b ∈ S,primary b) |
| (u : Eisenstein → ℂ) (w c t : Eisenstein) (Y K : ℝ) (hK : 0 ≤ K) |
| (hop : ∀ v : Eisenstein → ℂ, ∑ s ∈ squarefreePrimaryBall Y, |
| cubicRowEnergy S v s ≤ K * ∑ b ∈ S, ‖v b‖^2) : |
| (∑ s ∈ squarefreePrimaryBall Y, cubicRowEnergy S u (w*s*t^2*c^3)) + |
| (∑ s ∈ squarefreePrimaryBall Y, cubicRowEnergy S u (w*t*s^2*c^3)) ≤ |
| 2*K*∑ b ∈ S, ‖u b‖^2 := by |
| simp_rw [cubic_cube_row_twist S hS u w c t, |
| cubic_cube_row_twist_conj S hS u w c t] |
| have h1 := (hop (fun b => u b * cubicSymbol b (w*t^2*c^3))).trans |
| (mul_le_mul_of_nonneg_left (cubic_twist_energy_le S hS u _) hK) |
| have h2 := hop (fun b => star (u b * cubicSymbol b (w*t*c^3))) |
| simp only [norm_star] at h2 |
| have h2 := h2.trans (mul_le_mul_of_nonneg_left (cubic_twist_energy_le S hS u _) hK) |
| linarith |
|
|
| abbrev CubeIndex := Σ _w : Eisenstein, Σ _c : Eisenstein, Σ _t : Eisenstein, Eisenstein |
|
|
| def cubeIndices (X : ℝ) : Finset CubeIndex := |
| (nonzeroNormBall 9).sigma fun _w => |
| (nonzeroNormBall (X^(1/3:ℝ))).sigma fun c => |
| (squarefreePrimaryBall (X^(1/3:ℝ)/norm c)).sigma fun t => |
| squarefreePrimaryBall (X / ((norm t)^2*(norm c)^3)) |
|
|
| def cubeMap₁ (v : CubeIndex) : Eisenstein := v.1 * v.2.2.2 * v.2.2.1^2 * v.2.1^3 |
| def cubeMap₂ (v : CubeIndex) : Eisenstein := v.1 * v.2.2.1 * v.2.2.2^2 * v.2.1^3 |
|
|
| lemma cube_parameter_bounds {X a b c : ℝ} (hX : 0 ≤ X) (_ : 1 ≤ a) (hb : 1 ≤ b) |
| (hc : 1 ≤ c) (hab : b ≤ a) (hprod : a*b^2*c^3 ≤ X) : |
| c ≤ X^(1/3:ℝ) ∧ b ≤ X^(1/3:ℝ)/c ∧ a ≤ X/(b^2*c^3) := by |
| have hc0 : 0 < c := lt_of_lt_of_le zero_lt_one hc |
| have hb0 : 0 < b := lt_of_lt_of_le zero_lt_one hb |
| have hd : 0 < b^2*c^3 := by positivity |
| have hbc : (b*c)^3 ≤ X := by |
| calc |
| _ = b*b^2*c^3 := by ring |
| _ ≤ a*b^2*c^3 := by gcongr |
| _ ≤ X := hprod |
| have hrt : b*c ≤ X^(1/3:ℝ) := by |
| rw [one_div] |
| apply (Real.le_rpow_inv_iff_of_pos (by positivity : 0 ≤ b*c) hX (by norm_num : (0:ℝ)<3)).mpr |
| simpa only [show (3:ℝ) = (3:ℕ) by norm_num,Real.rpow_natCast] using hbc |
| exact ⟨(le_mul_of_one_le_left hc0.le hb).trans hrt, |
| (le_div_iff₀ hc0).mpr hrt,(le_div_iff₀ hd).mpr (by simpa [mul_assoc] using hprod)⟩ |
|
|
| lemma nonzero_ball_subset_cube_images {X : ℝ} (hX : 1 ≤ X) : |
| nonzeroNormBall X ⊆ (cubeIndices X).image cubeMap₁ ∪ (cubeIndices X).image cubeMap₂ := by |
| intro n hn |
| obtain ⟨hnX,hn0⟩ := mem_nonzeroNormBall.mp hn |
| obtain ⟨u,i,s,t,c,hi,hs,ht,hss,htt,hst,hc,he⟩ := full_cube_decomposition_unit hn0 |
| let w : Eisenstein := u * lambdaE^i |
| have hw0 : w ≠ 0 := mul_ne_zero u.ne_zero (pow_ne_zero _ lambdaE_prime.ne_zero) |
| have hnw : norm w = (3:ℝ)^i := by |
| rw [norm_mul_eq,norm_of_isUnit u.isUnit,norm_pow_eq,norm_lambdaE,one_mul] |
| have nw : w ∈ nonzeroNormBall 9 := mem_nonzeroNormBall.mpr ⟨by |
| rw [hnw]; interval_cases i <;> norm_num,hw0⟩ |
| have hnprod : norm s*(norm t)^2*(norm c)^3 ≤ X := by |
| have hnorm : norm n = norm w * (norm s*(norm t)^2*(norm c)^3) := by |
| rw [he] |
| simp only [norm_mul_eq,norm_pow_eq,w] |
| ring |
| have hle : norm s*(norm t)^2*(norm c)^3 ≤ norm n := by |
| rw [hnorm] |
| exact le_mul_of_one_le_left |
| (mul_nonneg (mul_nonneg (norm_nonneg s) (sq_nonneg _)) (pow_nonneg (norm_nonneg c) 3)) |
| (one_le_norm hw0) |
| exact hle.trans hnX |
| have hs1 := one_le_norm (primary_ne_zero hs) |
| have ht1 := one_le_norm (primary_ne_zero ht) |
| have hc1 := one_le_norm hc |
| by_cases hts : norm t ≤ norm s |
| · obtain ⟨hcX,htX,hsX⟩ := cube_parameter_bounds (by linarith) hs1 ht1 hc1 hts hnprod |
| apply Finset.mem_union_left |
| apply Finset.mem_image.mpr |
| refine ⟨⟨w,c,t,s⟩,?_,he.symm⟩ |
| simp only [cubeIndices,Finset.mem_sigma] |
| exact ⟨nw,mem_nonzeroNormBall.mpr ⟨hcX,hc⟩, |
| mem_squarefreePrimaryBall.mpr ⟨ht,htt,htX⟩, |
| mem_squarefreePrimaryBall.mpr ⟨hs,hss,hsX⟩⟩ |
| · have hst' : norm s ≤ norm t := (lt_of_not_ge hts).le |
| have hprod' : norm t*(norm s)^2*(norm c)^3 ≤ X := by |
| apply le_trans _ hnprod |
| have : norm s*norm t*(norm s) ≤ norm s*norm t*(norm t) := by gcongr |
| nlinarith [mul_le_mul_of_nonneg_right this (pow_nonneg (norm_nonneg c) 3)] |
| obtain ⟨hcX,hsX,htX⟩ := cube_parameter_bounds (by linarith) ht1 hs1 hc1 hst' hprod' |
| apply Finset.mem_union_right |
| apply Finset.mem_image.mpr |
| refine ⟨⟨w,c,s,t⟩,?_,he.symm⟩ |
| simp only [cubeIndices,Finset.mem_sigma] |
| exact ⟨nw,mem_nonzeroNormBall.mpr ⟨hcX,hc⟩, |
| mem_squarefreePrimaryBall.mpr ⟨hs,hss,hsX⟩, |
| mem_squarefreePrimaryBall.mpr ⟨ht,htt,htX⟩⟩ |
|
|
| lemma cubic_full_cube_sum_le {X : ℝ} (hX : 1 ≤ X) |
| (S : Finset Eisenstein) (u : Eisenstein → ℂ) : |
| ∑ m ∈ nonzeroNormBall X, cubicRowEnergy S u m ≤ |
| ∑ w ∈ nonzeroNormBall 9, ∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)), |
| ∑ t ∈ squarefreePrimaryBall (X^(1/3:ℝ)/norm c), |
| ((∑ s ∈ squarefreePrimaryBall (X/((norm t)^2*(norm c)^3)), |
| cubicRowEnergy S u (w*s*t^2*c^3)) + |
| (∑ s ∈ squarefreePrimaryBall (X/((norm t)^2*(norm c)^3)), |
| cubicRowEnergy S u (w*t*s^2*c^3))) := by |
| let f := cubicRowEnergy S u |
| let I := cubeIndices X |
| have hn (m : Eisenstein) : 0 ≤ f m := cubicRowEnergy_nonneg S u m |
| have h1 := Finset.sum_le_sum_of_subset_of_nonneg |
| (nonzero_ball_subset_cube_images hX) (fun m _ _ => hn m) |
| have h2 : ∑ m ∈ I.image cubeMap₁ ∪ I.image cubeMap₂, f m ≤ |
| (∑ m ∈ I.image cubeMap₁, f m) + (∑ m ∈ I.image cubeMap₂, f m) := by |
| rw [← Finset.sum_union_inter] |
| exact le_add_of_nonneg_right (Finset.sum_nonneg (fun m _ => hn m)) |
| have h3 := add_le_add |
| (Finset.sum_image_le_of_nonneg (s := I) (g := cubeMap₁) (fun m _ => hn m)) |
| (Finset.sum_image_le_of_nonneg (s := I) (g := cubeMap₂) (fun m _ => hn m)) |
| apply (h1.trans h2).trans |
| convert h3 using 1 |
| simp only [I,cubeIndices,Finset.sum_sigma,cubeMap₁,cubeMap₂,Finset.sum_add_distrib,f] |
|
|
| theorem cubic_full_cube_bound {X : ℝ} (hX : 1 ≤ X) |
| (S : Finset Eisenstein) (hS : ∀ b ∈ S,primary b) (u : Eisenstein → ℂ) |
| (K : ℝ → ℝ) (hK : ∀ Y, 0 ≤ K Y) |
| (hop : ∀ (Y : ℝ) (v : Eisenstein → ℂ), |
| ∑ s ∈ squarefreePrimaryBall Y, cubicRowEnergy S v s ≤ |
| K Y * ∑ b ∈ S, ‖v b‖^2) : |
| ∑ m ∈ nonzeroNormBall X, cubicRowEnergy S u m ≤ |
| 2 * ((nonzeroNormBall 9).card : ℝ) * |
| (∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)), |
| ∑ t ∈ squarefreePrimaryBall (X^(1/3:ℝ)/norm c), |
| K (X/((norm t)^2*(norm c)^3))) * ∑ b ∈ S, ‖u b‖^2 := by |
| apply (cubic_full_cube_sum_le hX S u).trans |
| have hb := Finset.sum_le_sum (s := nonzeroNormBall 9) (fun w _ => |
| Finset.sum_le_sum (s := nonzeroNormBall (X^(1/3:ℝ))) (fun c _ => |
| Finset.sum_le_sum (s := squarefreePrimaryBall (X^(1/3:ℝ)/norm c)) (fun t _ => |
| cubic_cube_box_bound S hS u w c t (X/((norm t)^2*(norm c)^3)) _ (hK _) (hop _)))) |
| convert hb using 1 |
| simp only [← Finset.mul_sum,← Finset.sum_mul,Finset.sum_const, nsmul_eq_mul] |
| ring |
|
|
| end CubicFirstMoment |
|
|
| namespace CubicFirstMoment |
|
|
| def latticeZeta (r : ℝ) : ℝ := ∑' a : Eisenstein,(norm a)^(-r) |
|
|
| lemma latticeZeta_nonneg (r : ℝ) : 0 ≤ latticeZeta r := |
| tsum_nonneg fun a => Real.rpow_nonneg (norm_nonneg a) _ |
|
|
| lemma latticeZeta_pos {r : ℝ} (hr : 1<r) : 0<latticeZeta r := by |
| have hs := HeckeTheta.lattice_norm_rpow_summable r hr |
| have hle := hs.le_tsum (1:Eisenstein) (fun a _ => Real.rpow_nonneg (norm_nonneg a) _) |
| have he : (norm (1:Eisenstein))^(-r) = 1 := by simp |
| change 0 < ∑' a : Eisenstein,(norm a)^(-r) |
| linarith |
|
|
| lemma norm_rpow_finset_le (S : Finset Eisenstein) {r : ℝ} (hr : 1<r) : |
| ∑ a ∈ S,(norm a)^(-r) ≤ latticeZeta r := |
| Summable.sum_le_tsum S (fun a _ => Real.rpow_nonneg (norm_nonneg a) _) |
| (HeckeTheta.lattice_norm_rpow_summable r hr) |
|
|
| lemma quotient_norm_rpow {X a b p : ℝ} (hX : 0≤X) (ha : 0<a) (hb : 0<b) : |
| (X/(a^2*b^3))^p = X^p*a^(-(2*p))*b^(-(3*p)) := by |
| rw [Real.div_rpow hX (by positivity),Real.mul_rpow (by positivity) (by positivity)] |
| have he2 : (a^2)^p = a^(2*p) := by |
| rw [← Real.rpow_natCast,← Real.rpow_mul ha.le] |
| norm_num |
| have he3 : (b^3)^p = b^(3*p) := by |
| rw [← Real.rpow_natCast,← Real.rpow_mul hb.le] |
| norm_num |
| rw [he2,he3,Real.rpow_neg ha.le,Real.rpow_neg hb.le] |
| simp only [div_eq_mul_inv,mul_inv_rev] |
| ring |
|
|
| lemma cube_rpow_sum_bound {X p : ℝ} (hX : 0≤X) (hp : (2/3:ℝ)≤p) : |
| (∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)), |
| ∑ t ∈ squarefreePrimaryBall (X^(1/3:ℝ)/norm c), |
| (X/((norm t)^2*(norm c)^3))^p) ≤ X^p*(latticeZeta (4/3))^2 := by |
| have hZ := latticeZeta_nonneg (4/3) |
| calc |
| _ ≤ ∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)), |
| ∑ t ∈ squarefreePrimaryBall (X^(1/3:ℝ)/norm c), |
| X^p*(norm t)^(-(4/3:ℝ))*(norm c)^(-(4/3:ℝ)) := by |
| apply Finset.sum_le_sum |
| intro c hc |
| have hc0 := (mem_nonzeroNormBall.mp hc).2 |
| have hc1 := one_le_norm hc0 |
| apply Finset.sum_le_sum |
| intro t ht |
| have ht0 := primary_ne_zero (mem_squarefreePrimaryBall.mp ht).1 |
| have ht1 := one_le_norm ht0 |
| rw [quotient_norm_rpow hX (norm_pos_of_ne_zero ht0) (norm_pos_of_ne_zero hc0)] |
| gcongr <;> linarith |
| _ ≤ ∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)), |
| X^p*latticeZeta (4/3)*(norm c)^(-(4/3:ℝ)) := by |
| apply Finset.sum_le_sum |
| intro c hc |
| rw [← Finset.sum_mul,← Finset.mul_sum] |
| exact mul_le_mul_of_nonneg_right |
| (mul_le_mul_of_nonneg_left (norm_rpow_finset_le _ (by norm_num : (1:ℝ)<4/3)) |
| (Real.rpow_nonneg hX _)) (Real.rpow_nonneg (norm_nonneg c) _) |
| _ ≤ _ := by |
| rw [← Finset.mul_sum] |
| apply (mul_le_mul_of_nonneg_left (norm_rpow_finset_le _ (by norm_num : (1:ℝ)<4/3)) |
| (mul_nonneg (Real.rpow_nonneg hX _) hZ)).trans_eq |
| ring |
|
|
| lemma squarefreePrimaryBall_card_le {Y : ℝ} (hY : 0≤Y) : |
| ((squarefreePrimaryBall Y).card:ℝ) ≤ 18*Y := by |
| apply le_trans _ (nonzeroNormBall_card_le hY) |
| exact_mod_cast Finset.card_le_card (Finset.filter_subset _ _) |
|
|
| lemma norm_reciprocal_sum_bound {R δ : ℝ} (hR : 0<R) (hδ : 0<δ) : |
| ∑ c ∈ nonzeroNormBall R,1/norm c ≤ R^δ*latticeZeta (1+δ) := by |
| calc |
| _ ≤ ∑ c ∈ nonzeroNormBall R,R^δ*(norm c)^(-(1+δ)) := by |
| apply Finset.sum_le_sum |
| intro c hc |
| obtain ⟨hcR,hc0⟩ := mem_nonzeroNormBall.mp hc |
| have hcpos := norm_pos_of_ne_zero hc0 |
| have he : 1/norm c = (norm c)^δ*(norm c)^(-(1+δ)) := by |
| rw [← Real.rpow_add hcpos] |
| rw [show δ+ -(1+δ) = (-1:ℝ) by ring,Real.rpow_neg_one] |
| exact one_div _ |
| rw [he] |
| exact mul_le_mul_of_nonneg_right (Real.rpow_le_rpow hcpos.le hcR hδ.le) |
| (Real.rpow_nonneg hcpos.le _) |
| _ ≤ _ := by |
| rw [← Finset.mul_sum] |
| exact mul_le_mul_of_nonneg_left (norm_rpow_finset_le _ (by linarith)) (Real.rpow_nonneg hR.le _) |
|
|
| lemma cube_pair_count_bound {X δ : ℝ} (hX : 1≤X) (hδ : 0<δ) : |
| (∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)), |
| ((squarefreePrimaryBall (X^(1/3:ℝ)/norm c)).card:ℝ)) ≤ |
| 18*latticeZeta (1+δ)*X^(1/3+δ) := by |
| have hX0 : 0<X := by linarith |
| have hR : 0<X^(1/3:ℝ) := Real.rpow_pos_of_pos hX0 _ |
| have hRX : X^(1/3:ℝ) ≤ X := Real.rpow_le_self_of_one_le hX (by norm_num) |
| calc |
| _ ≤ ∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)),18*X^(1/3:ℝ)*(1/norm c) := by |
| apply Finset.sum_le_sum |
| intro c hc |
| have hc0 := norm_pos_of_ne_zero (mem_nonzeroNormBall.mp hc).2 |
| simpa [div_eq_mul_inv,mul_assoc] using squarefreePrimaryBall_card_le |
| (div_nonneg hR.le hc0.le) |
| _ = 18*X^(1/3:ℝ)*∑ c ∈ nonzeroNormBall (X^(1/3:ℝ)),1/norm c := by rw [Finset.mul_sum] |
| _ ≤ 18*X^(1/3:ℝ)*((X^(1/3:ℝ))^δ*latticeZeta (1+δ)) := |
| mul_le_mul_of_nonneg_left (norm_reciprocal_sum_bound hR hδ) (by positivity) |
| _ ≤ 18*X^(1/3:ℝ)*(X^δ*latticeZeta (1+δ)) := by |
| have hZ := latticeZeta_nonneg (1+δ) |
| gcongr |
| _ = _ := by rw [Real.rpow_add hX0]; ring |
|
|
| end CubicFirstMoment |
| end |
|
|
| end OAI |
|
|
