diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Basic.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Basic.lean new file mode 100644 index 0000000000000000000000000000000000000000..c44c5e3fa1ba2f17b962b15945a55d8b5a9f0558 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Basic.lean @@ -0,0 +1,170 @@ +import Mathlib.Basic.Real.Basic +import Mathlib.Tactic.Linarith +import Mathlib.Tactic.Ring +import Mathlib.Tactic.Positivity + +namespace OAI + +namespace SevenEighths.InverseMoment + +def MarkedMargins (m r z c : ℝ) : Prop := + r + 2 * z ≤ m - c ∧ 2 * r + 8 * z ≤ 3 * m - c + +def CanonicalMargins (F M Q z c : ℝ) : Prop := + c ≤ F - M - Q - z ∧ c ≤ 4 * F - 3 * M - 6 * z + +theorem markedMargins_of_strict {m r z : ℝ} + (h₁ : r + 2 * z < m) (h₂ : 2 * r + 8 * z < 3 * m) : + ∃ c > 0, MarkedMargins m r z c := by + refine ⟨min (m - r - 2 * z) (3 * m - 2 * r - 8 * z), ?_, ?_⟩ + · exact lt_min (by linarith) (by linarith) + · constructor + · have := min_le_left (m - r - 2 * z) (3 * m - 2 * r - 8 * z) + linarith + · have := min_le_right (m - r - 2 * z) (3 * m - 2 * r - 8 * z) + linarith + +theorem markedMargins_subcollection {m r z z' c : ℝ} + (h : MarkedMargins m r z c) (hz : z' ≤ z) : + MarkedMargins m r z' c := by + obtain ⟨h₁, h₂⟩ := h + constructor <;> linarith + +theorem canonicalMargins_subcollection {F M Q z z' c : ℝ} + (h : CanonicalMargins F M Q z c) (hz : z' ≤ z) : + CanonicalMargins F M Q z' c := by + obtain ⟨h₁, h₂⟩ := h + constructor <;> linarith + +theorem canonicalMargins_weaken {F M Q z c c' : ℝ} + (h : CanonicalMargins F M Q z c) (hc : c' ≤ c) : + CanonicalMargins F M Q z c' := by + exact ⟨hc.trans h.1, hc.trans h.2⟩ + +def decrease (ell A t g theta V : ℝ) : ℝ := ell + A + t + g - theta + V + +def childF (F ell A t g theta V j delta : ℝ) : ℝ := + F - decrease ell A t g theta V - 2 * ell + j + delta + +def childM (M ell A t g theta V j eta : ℝ) : ℝ := + M - 2 * decrease ell A t g theta V - 2 * ell + j + eta + +theorem canonical_transition (F M ell A t g theta V j : ℝ) : + childF F ell A t g theta V j 0 - childM M ell A t g theta V j 0 = + F - M + decrease ell A t g theta V ∧ + 4 * childF F ell A t g theta V j 0 - + 3 * childM M ell A t g theta V j 0 = + 4 * F - 3 * M + 2 * (A + t + g - theta + V) + j := by + constructor <;> unfold childF childM decrease <;> ring + +theorem child_margins_sharp {F M Q Q' z c ell A t g theta V j delta eta : ℝ} + (h : CanonicalMargins F M Q z c) + (hA : 0 ≤ A) (ht : 0 ≤ t) (hV : 0 ≤ V) (hj : 0 ≤ j) + (hgt : -2 * eta ≤ g - theta) + (hQ : Q' ≤ Q + decrease ell A t g theta V + 4 * eta) : + c + delta - 5 * eta ≤ + childF F ell A t g theta V j delta - + childM M ell A t g theta V j eta - Q' - z ∧ + c + 4 * delta - 7 * eta ≤ + 4 * childF F ell A t g theta V j delta - + 3 * childM M ell A t g theta V j eta - 6 * z := by + obtain ⟨h₁, h₂⟩ := h + unfold childF childM decrease at * + constructor <;> linarith + +theorem child_margins {F M Q Q' z c ell A t g theta V j delta eta : ℝ} + (h : CanonicalMargins F M Q z c) + (hA : 0 ≤ A) (ht : 0 ≤ t) (hV : 0 ≤ V) (hj : 0 ≤ j) + (hgt : -2 * eta ≤ g - theta) (hdelta : 0 ≤ delta) (heta : 0 ≤ eta) + (hQ : Q' ≤ Q + decrease ell A t g theta V + 4 * eta) : + CanonicalMargins (childF F ell A t g theta V j delta) + (childM M ell A t g theta V j eta) Q' z (c - 7 * eta) := by + obtain ⟨h₁, h₂⟩ := child_margins_sharp (delta := delta) h hA ht hV hj hgt hQ + constructor <;> linarith + +theorem child_row_decrease {M ell A t g theta V j eta d : ℝ} + (hA : 0 ≤ A) (ht : 0 ≤ t) (hgt : -2 * eta ≤ g - theta) + (hj : j ≤ 2 * ell + 3 * eta) (hterminal : d ≤ ell + V) + (heta : eta ≤ d / 16) : + 3 * d / 2 ≤ M - childM M ell A t g theta V j eta := by + unfold childM decrease + linarith + +theorem childF_upper {F ell A t g theta V j delta eta : ℝ} + (hA : 0 ≤ A) (ht : 0 ≤ t) (hell : 0 ≤ ell) (hV : 0 ≤ V) + (hgt : -2 * eta ≤ g - theta) (hj : j ≤ 2 * ell + 3 * eta) + (hdelta : delta ≤ 6 * eta) : + childF F ell A t g theta V j delta ≤ F + 11 * eta := by + unfold childF decrease + linarith + +theorem clipping_bounds {N eta : ℝ} (heta : 0 ≤ eta) (hN : -6 * eta ≤ N) : + 0 ≤ max 0 N - N ∧ max 0 N - N ≤ 6 * eta := by + constructor + · exact sub_nonneg.mpr (le_max_right 0 N) + · rcases le_total 0 N with h | h + · rw [max_eq_right h]; linarith + · rw [max_eq_left h]; linarith + +theorem step_energy_exponent {F Fc kappa lambda count delta eta tau pi eps : ℝ} + (hid : kappa + lambda + count + 2 * Fc = F) + (hdelta : delta ≤ 6 * eta) : + kappa + lambda + count + 2 * (Fc + delta) + + (9 / 2 + 18 + 11 / 2) * eta + tau + pi + eps ≤ + F + 40 * eta + tau + pi + eps := by + linarith + +def initialF (r z G P delta : ℝ) : ℝ := r + z - 2 * G - P + delta + +def initialM (m r z G P eta tau : ℝ) : ℝ := + 2 * (r + z - 2 * G) - m - 2 * P + 6 * eta + tau + +theorem initial_margins_sharp {m r z G P delta eta tau Q c₁ c₂ : ℝ} + (h₁ : r + 2 * z ≤ m - c₁) (h₂ : 2 * r + 8 * z ≤ 3 * m - c₂) + (hG : 0 ≤ G) (hP : -2 * eta ≤ P) (hQ : Q ≤ P + G + 3 * eta) : + c₁ + delta - 9 * eta - tau ≤ + initialF r z G P delta - initialM m r z G P eta tau - Q - (z - G) ∧ + c₂ + 4 * delta - 22 * eta - 3 * tau ≤ + 4 * initialF r z G P delta - 3 * initialM m r z G P eta tau - + 6 * (z - G) := by + unfold initialF initialM + constructor <;> linarith + +theorem initial_margins {m r z G P delta eta tau Q c₁ c₂ : ℝ} + (h₁ : r + 2 * z ≤ m - c₁) (h₂ : 2 * r + 8 * z ≤ 3 * m - c₂) + (hG : 0 ≤ G) (hP : -2 * eta ≤ P) (hQ : Q ≤ P + G + 3 * eta) + (hc : 0 ≤ min c₁ c₂) (hdelta : 0 ≤ delta) (heta : eta ≤ min c₁ c₂ / 100) + (htau : tau ≤ min c₁ c₂ / 100) : + CanonicalMargins (initialF r z G P delta) + (initialM m r z G P eta tau) Q (z - G) (3 * min c₁ c₂ / 4) := by + obtain ⟨ha, hb⟩ := initial_margins_sharp (delta := delta) (tau := tau) h₁ h₂ hG hP hQ + have hc₁ := min_le_left c₁ c₂ + have hc₂ := min_le_right c₁ c₂ + constructor <;> linarith + +theorem initial_prefactor_identity (m r z G P : ℝ) : + (m - 2 * (r + z - 2 * G) + P) + P + + 2 * initialF r z G P 0 = m := by + unfold initialF + ring + +theorem initial_energy_exponent {m delta eta pi eps : ℝ} + (hdelta : delta ≤ 3 * eta) : + m + 3 * eta + 2 * eta + 2 * delta + pi + eps ≤ + m + 11 * eta + pi + eps := by + linarith + +theorem total_step_loss {D eta tau pi eps : ℝ} + (h₁ : D * eta ≤ eps / 160) (h₂ : D * tau ≤ eps / 4) + (h₃ : D * pi ≤ eps / 4) : + D * (40 * eta + tau + pi) ≤ 3 * eps / 4 := by + nlinarith + +theorem depth_margin {c D h eta : ℝ} (heta : 0 ≤ eta) (hh : h ≤ D) + (hbudget : D * eta ≤ c / 14) : c / 2 ≤ c - 7 * h * eta := by + have := mul_le_mul_of_nonneg_right hh heta + nlinarith + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Canonical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Canonical.lean new file mode 100644 index 0000000000000000000000000000000000000000..16013292cba84bde03cd66e35cdf64e4b8a287af --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Canonical.lean @@ -0,0 +1,130 @@ +import OAI.NumberTheory.DirichletL.Descent.Poisson +import OAI.NumberTheory.DirichletL.Descent.Completion + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic CompletedGauss FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def finiteCanonicalMarkedRow (pool : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : ℂ := + fixedChildRow p hp hcop hg pool Ψ m + (fun U => primeMark slots lists a U * W (primeProductNorm p U / X)) f k + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_actual_columns + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda ^ 2 ∣ p i - 1) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X = + ∑ U ∈ pool.powerset, + columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) + (Ideal.span {∏ i ∈ U, p i}) * + (primeMark slots lists a U * W (primeProductNorm p U / X)) := by + unfold finiteCanonicalMarkedRow fixedChildRow + apply Finset.sum_congr rfl + intro U hU + have he := CanonicalRowCompletion.columnWeight_finset p hp hcop hg hpr U Ψ m f k + (fun U => primeMark slots lists a U * W (primeProductNorm p U / X)) + symm + convert he using 1 ; simp only [secondChildColumn, canonicalSourceCoefficient] ; ring + +theorem secondChildSum_marked_canonical + (F V A : Finset ι) (Ψ : Eis →* ℂ) (m r c d e k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : + secondChildSum p hp hcop hg F V Ψ m r c d e k + (fun U => primeMark slots lists a (A ∪ U) * W (primeProductNorm p U / X)) = + ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ V) * + finiteCanonicalMarkedRow p hp hcop hg (F \ V) Ψ (m * r) + (c * e * ∏ i ∈ V, p i) (d * e * k) + (slots \ J) (fun i => lists i \ (A ∪ V)) a W (X / primeProductNorm p V) := by + unfold secondChildSum finiteCanonicalMarkedRow fixedChildRow + simp only [Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro N hN + have hd : Disjoint V N := Finset.disjoint_left.mpr (fun i hi hn => + (Finset.mem_sdiff.mp (Finset.mem_powerset.mp hN hn)).2 hi) + have hn : primeProductNorm p (V ∪ N) / X = primeProductNorm p N / (X / primeProductNorm p V) := by + rw [primeProductNorm_union p V N hd] + simp only [div_div_eq_mul_div] + ring + have hmark := primeMark_priority slots lists a (A ∪ V) N + simp only [primeMark_residual_lists] at hmark + simp only [secondChildColumn, ← Finset.union_assoc, hn] + rw [hmark] + simp only [Finset.sum_mul, Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + ring + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_restore_pool + (pool B : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) + (hB : ∀ i ∈ B, m * f ∈ Ideal.span {p i}) : + finiteCanonicalMarkedRow p hp hcop hg (pool \ B) Ψ m f k slots lists a W X = + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X := + fixedChildRow_restore_killed_pool p hp hcop hg pool B Ψ m f k _ hB + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_restore_lists + (pool B : Finset ι) (Ψ : Eis →* ℂ) (m f k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) + (hB : ∀ i ∈ B, m * f ∈ Ideal.span {p i}) : + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots (fun i => lists i \ B) a W X = + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X := by + unfold finiteCanonicalMarkedRow fixedChildRow + apply Finset.sum_congr rfl + intro U hU + by_cases hd : Disjoint B U + · have he : U \ B = U := Finset.sdiff_eq_self_of_disjoint hd.symm + simp only [secondChildColumn, ← primeMark_residual_lists, he] + · obtain ⟨i, hiB, hiU⟩ := Finset.not_disjoint_iff.mp hd + rw [secondChildColumn_zero_of_mask_label_mem p hp hcop hg Ψ m f k _ U i hiU (hB i hiB), + secondChildColumn_zero_of_mask_label_mem p hp hcop hg Ψ m f k _ U i hiU (hB i hiB)] + +theorem secondChildSum_marked_fixed_pool + (F V A : Finset ι) (Ψ : Eis →* ℂ) (m r c d e k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : + secondChildSum p hp hcop hg F V Ψ m r c d e k + (fun U => primeMark slots lists a (A ∪ U) * W (primeProductNorm p U / X)) = + ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ V) * + finiteCanonicalMarkedRow p hp hcop hg F Ψ (m * r) + (c * e * ∏ i ∈ V, p i) (d * e * k) + (slots \ J) (fun i => lists i \ A) a W (X / primeProductNorm p V) := by + rw [secondChildSum_marked_canonical] + apply Finset.sum_congr rfl + intro J hJ + congr 1 + have hV (i : ι) (hi : i ∈ V) : (m * r) * (c * e * ∏ j ∈ V, p j) ∈ Ideal.span {p i} := + Ideal.mem_span_singleton.mpr (dvd_mul_of_dvd_right + (dvd_mul_of_dvd_right (Finset.dvd_prod_of_mem p hi) (c * e)) (m * r)) + rw [finiteCanonicalMarkedRow_restore_pool p hp hcop hg F V Ψ (m * r) + (c * e * ∏ i ∈ V, p i) (d * e * k) _ _ _ _ _ hV] + have hlists : (fun i => lists i \ (A ∪ V)) = (fun i => (lists i \ A) \ V) := by + funext i + ext x + simp only [Finset.mem_sdiff, Finset.mem_union] + tauto + rw [hlists] + exact finiteCanonicalMarkedRow_restore_lists p hp hcop hg F V Ψ (m * r) + (c * e * ∏ i ∈ V, p i) (d * e * k) _ _ _ _ _ hV + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalChildSupport.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalChildSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..c025acc970b5b178d33110c24425aec3e469dfdb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalChildSupport.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCanonicalChildren + +namespace OAI + +noncomputable section +open scoped Classical BigOperators + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve +open InverseInitialArithmetic InverseSecondSourceBlocks InverseSecondFibers +local notation "O"=>ActualEisensteinCubic.O +variable {ι:Type*}[DecidableEq ι](p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] +variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) +variable (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + +include hp hg hc in +omit [DecidableEq ι] in +lemma canonical_source_prime_supported (i:ι):Supported (Ideal.span {p i}) :=by + have hn:(Ideal.span {p i}:Ideal O)≠0:=Ideal.span_singleton_eq_bot.not.mpr (hp i) + refine ⟨hn,?_⟩ + intro P hP + obtain ⟨hprime,hle⟩:=(Ideal.mem_normalizedFactors_iff hn).mp hP + have he:Ideal.span {p i}=P:=(inferInstance:(Ideal.span {p i}:Ideal O).IsMaximal).eq_of_le hprime.ne_top hle + subst P + exact ⟨hg i,hc i⟩ + +lemma canonical_supported_prod {α:Type*}(S:Finset α)(f:α→Ideal O) + (hf:∀i∈S,Supported (f i)):Supported (∏i∈S,f i) :=by + classical + induction S using Finset.induction_on with + | empty => + change Supported (1:Ideal O) + refine ⟨one_ne_zero,?_⟩ + intro P hP + rw [UniqueFactorizationMonoid.normalizedFactors_one] at hP + exact (Multiset.notMem_zero P hP).elim + | @insert i S hi ih => + rw [Finset.prod_insert hi,supported_mul_iff] + exact ⟨hf i (Finset.mem_insert_self _ _),ih (fun j hj=>hf j (Finset.mem_insert_of_mem hj))⟩ + +include hp hg hc in +omit [DecidableEq ι] in +lemma canonical_source_ideal_supported (S:Finset ι):Supported (sourceIdeal p S) :=by + rw [sourceIdeal,FiniteGaussPhase.span_finset_prod] + exact canonical_supported_prod S (fun i=>Ideal.span {p i}) (fun i _=>canonical_source_prime_supported p hp hg hc i) + +include hp hg hc in +omit [DecidableEq ι] in +lemma canonical_prime_product_supported (S:Finset ι)(v:ι→ℕ):Supported (Ideal.span {primeProduct p S v}) :=by + rw [primeProduct,FiniteGaussPhase.span_finset_prod] + apply canonical_supported_prod + intro i hi + rw [←Ideal.span_singleton_pow] + exact supported_pow (canonical_source_prime_supported p hp hg hc i) _ + +include hp hg hc in +lemma actual_second_label_supported {Jo Jn:ℕ}(x:MarkedSecondSource ι Jo Jn): + Supported (actualSecondChild p 1 1 x).2.1 :=by + change Supported ((Ideal.span {jLabel p x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit})* + sourceIdeal p x.firstCommon*sourceIdeal p x.second.divisor*sourceIdeal p x.second.overlap) + simp only [supported_mul_iff] + exact ⟨⟨⟨canonical_prime_product_supported p hp hg hc _ _,canonical_source_ideal_supported p hp hg hc _⟩, + canonical_source_ideal_supported p hp hg hc _⟩,canonical_source_ideal_supported p hp hg hc _⟩ + +include hp hg hc in +theorem actual_cell_labels_supported {Jo Jn:ℕ}(S:Finset (MarkedSecondSource ι Jo Jn))(d:BlockIndex): + ∀I∈actualCellLabels p S d,Supported I :=by + intro I hI + obtain ⟨x,hx,rfl⟩:=Finset.mem_image.mp hI + exact actual_second_label_supported p hp hg hc x + +include hp hg hc in +theorem actual_cell_labels_admissible {Jo Jn:ℕ}(S:Finset (MarkedSecondSource ι Jo Jn))(d:BlockIndex): + ∀I∈(actualCellLabels p S d).filter Squarefree,CanonicalQuadraticSieve.Admissible I :=by + intro I hI + obtain ⟨hm,hs⟩:=Finset.mem_filter.mp hI + have hh:=actual_cell_labels_supported p hp hg hc S d I hm + exact ⟨hh.1,hs,hh.2⟩ + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..ac09ca6b3a54249853a79792f6317ea9f72e4548 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteBudget.lean @@ -0,0 +1,54 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCosts +import OAI.NumberTheory.DirichletL.Descent.RecursionParameters + +namespace OAI + +noncomputable section + +namespace SevenEighths.InverseMoment + +theorem actual_complete_step_cost (L eta epsChild:ℝ)(hL:0≤L)(heta:0 nlinarith + +theorem actual_complete_height_merge (dshort dlong:ℕ)(Z F cstar loss Cs Cb A theta:ℝ) + (hZ:1≤Z)(hcstar:0≤cstar)(hloss:0≤loss)(hCs:0≤Cs)(hCb:0≤Cb)(hA:0≤A): + Cs*(1+‖theta‖)^dshort*Z^(F-cstar/256)+ + Cb*(1+A)*(1+‖theta‖)^dlong*Z^(F+loss)≤ + (Cs+Cb)*(1+A)*(1+‖theta‖)^(max dshort dlong)*Z^(F+loss) := by + have hp:1≤1+‖theta‖:=by linarith [norm_nonneg theta] + have hshort:(1+‖theta‖)^dshort≤(1+‖theta‖)^(max dshort dlong):= + pow_le_pow_right₀ hp (le_max_left _ _) + have hlong:(1+‖theta‖)^dlong≤(1+‖theta‖)^(max dshort dlong):= + pow_le_pow_right₀ hp (le_max_right _ _) + have hz:0ActualEisensteinCubic.O + +theorem actual_complete_state_from_children + (lo hi:ℝ)(hlo:0by rw [poolPrimary_span F hF i];infer_instance; + let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox; + (∀j∈cubeLogRange hi (Z^N), + let ell:=actualCubeLength Z j; + let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j); + Q.Nonempty → ∀ξ:ℝ,∀k∈actualLongSourceKeys (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists a om Z M (N-3*ell) ell V (Z^(cutoff-V)) ξ L eta tau, + ChildBounds (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Q k.1 k.2.1 k.2.2 true Ψ m slots lists a ω₁₁ ω₁₂ + Z M (N-3*ell) ell V eta tau window bw epschild A K degree) → + (∀j∈cubeLogRange hi (Z^N), + let ell:=actualCubeLength Z j; + let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j); + Q.Nonempty → ∀ξ:ℝ,∀k∈actualLongSourceKeys (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists a om Z M (N-3*ell) ell V (Z^(cutoff-V)) ξ L eta tau, + ChildBounds (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Q k.1 k.2.1 k.2.2 false Ψ m slots lists a ω₂₁ ω₂₂ + Z M (N-3*ell) ell V eta tau window bw epschild A K degree) → + Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M), + ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) z + slots lists a (normTwistedSource W theta) (Z^N)‖^2)≤ + Cs*(1+‖theta‖)^shortDegree*Z^(N+V-cstar/256)+ + Cb*(1+A)*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower))* + Z^(N+V+lossFinal+2*L*epsFirst+eps) := by + have hL0:0≤L:=by linarith + obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ha1,hab1,ha2,hab2, + hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hbin⟩:= + actual_marked_bin_height lo hi hlo hhi W hsW hW Vlog Alog hbox hone L eta tau saving em ed + hL0 heta.le heta1 htau htau1 hem hed K + obtain ⟨ds,hstate⟩:=actual_complete_state_from_live_bins lo hi hlo hhi W hsW hW L cstar eta eps + hL0 hcstar heta heta1 hetac heps K K + refine ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2, + hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,?_⟩ + intro epsFirst epsSecond heF heS degree q hq + obtain ⟨Ccoef,C,hcoef,hC,hbin⟩:=hbin epsFirst epsSecond heF heS degree + obtain ⟨Cs,Z₀,hCs,hZ₀,hstate⟩:=hstate q hq + let Cb:=C*Ccoef^2*Real.exp (2*epsFirst) + refine ⟨Cs,Cs*Cb,Z₀,hCs,by dsimp [Cb];positivity,hZ₀,?_⟩ + intro σ _ m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog + hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hmN hmargin hreserve + hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA + labels hlabels D hD slots hcard lists H hdis hH1 hH hprod Ψ hΨ hperiod a ha + dsimp only + intro hleft hright + have hz:0markedReopenedCubeBin (reflectionExcludedPrimes q) D + (progressingCubes (reflectionExcludedPrimes q) D (Z^(cutoff-V)) + (activeCubeLogBin (reflectionExcludedPrimes q) D hi (Z^N) j)) + Ψ m (idealGenerator I) z (normTwistedSource W theta) (Z^N) (Z^(cutoff-V)) slots lists a) (Z^M)≤E := by + intro j hj hne + let ell:=actualCubeLength Z j + let S:=reflectionExcludedPrimes q + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q) + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance + let Q:=progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j) + obtain ⟨hel,hr,hrL,helL,hFL,hgap,hqn⟩:=actual_long_bin_geometry S D (reflectionExcludedPrimes_bad q) + hi Z N V cutoff eta L j (by linarith) hL heta1 hV hFcap hbZ hlog hne + have hsN:(N-3*ell)+3*ell=N:=by ring + have hpr:3*eta+epsFirst*(5*ell+2*(N-3*ell)+7*eta)≤lossFinal:=by + have hNL:N≤L:=by linarith + nlinarith + have hh:=hbin theta S D (reflectionExcludedPrimes_bad q) (reflectionExcludedPrimes_prime q) + Q labels Ψ m slots lists a Z M (N-3*ell) ell V (Z^(cutoff-V)) pi epschild A loss lossFinal + hZ2 h2 hExp hM hFL (by linarith) hel hV hr hAZ + (by intro v hv;rw [←cubeIdeal_primeProduct_norm F hF];exact (hqn v hv).1) + (by intro v hv;rw [←cubeIdeal_primeProduct_norm F hF];exact (hqn v hv).2) + hrL helL (by linarith) hwin hpi hpieta hemc hedc hechild (by linarith) hloss hcard + (by linarith) hpr hretained (by linarith) hΨ hA + (fun I hI=>(hlabels I hI).2.1) (fun I hI=>(hlabels I hI).1.1) + (fun I hI=>((hlabels I hI).2.2).trans (Real.rpow_le_rpow_of_exponent_le hZ1 (by linarith))) + hdis ha (by simpa only [hsN] using hD) (hleft j hj hne) (hright j hj hne) + rw [hsN] at hh + apply hh.trans + have hc:=mul_le_mul_of_nonneg_right + (actual_long_uniform_parent_cost Z ell N V L epsFirst Ccoef C A lossFinal hZ1 helL heF.le hC hA) + (show 0≤(1+‖theta‖)^d by positivity) + simpa only [hsN] using hc + have hs:=hstate m hm Z N V M z₀ margin cutoff hZ hN (by linarith) hV (by linarith) hM (by linarith) + hzcap hcut hcutL hcutc hmN hmargin hreserve labels hlabels D hD slots hcard lists H + hdis hH1 hH hprod Ψ hΨ hperiod theta a ha E hE hbins + apply hs.trans_eq + dsimp [E,d] + rw [Real.rpow_add hz (N+V+lossFinal+2*L*epsFirst) eps] + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteNormalized.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteNormalized.lean new file mode 100644 index 0000000000000000000000000000000000000000..cfae6449ff2ef9a16328f7ece7c31ce8cb0eaeed --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteNormalized.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongNormalization +import OAI.NumberTheory.DirichletL.Descent.CanonicalPunctureMaskEnergy +import OAI.NumberTheory.DirichletL.Descent.CompletedReopening + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic InverseInitialClippedColumns +local notation "O"=>ActualEisensteinCubic.O + +theorem normalizedColumnEnergy_eq_generator_sum {ι σ:Type*}[DecidableEq ι][DecidableEq σ] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(hlabels:∀I∈labels,primaryGenerator I≠0) + (weight:Ideal O→ℝ)(W:ℝ→ℂ)(X Z F R:ℝ)(hZ:0by rw [poolPrimary_span F hF i];infer_instance + Z^(-Fexp)*(∑I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 R, + ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) k slots lists a W X‖^2)= + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels + (nonzeroChildFrequencyBall 1 R) weight W X Z Fexp := by + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + exact (normalizedColumnEnergy_eq_generator_sum (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels + (fun I hI=>supported_primaryGenerator_ne_zero I (hlabels I hI)) weight W X Z Fexp R hZ).symm + +theorem reflection_complete_normalized_energy {σ:Type*}[DecidableEq σ] + (q D:ℕ)(Ψ:O→*ℂ)(m:O)(slots:Finset σ) + (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D))) + (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ) + (labels:Finset (Ideal O))(hlabels:∀I∈labels,Supported I) + (weight:Ideal O→ℝ)(W:ℝ→ℂ)(X Z Fexp R:ℝ)(hZ:0by rw [poolPrimary_span F hF i];infer_instance + Z^(-Fexp)*(∑I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 R, + ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) k + slots lists a W X‖^2)= + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ + (ActualFiber.maskElement q m) slots lists a labels + (nonzeroChildFrequencyBall 1 R) weight W X Z Fexp := by + have h:=outside_complete_normalized_energy (reflectionExcludedPrimes q) D + (reflectionExcludedPrimes_bad q) Ψ m slots lists a labels hlabels weight W X Z Fexp R hZ + exact h.trans (reflection_pool_mask_energy q D Finset.univ Ψ m slots lists a labels + (nonzeroChildFrequencyBall 1 R) weight W X Z Fexp).symm + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRank.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRank.lean new file mode 100644 index 0000000000000000000000000000000000000000..dbfc8b1c7054890ff2a8320d76075cfc41a4f274 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRank.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteChildren +import OAI.NumberTheory.DirichletL.Descent.CanonicalLiveBinRank + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace SevenEighths.InverseMoment +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight +open FourierBridge JointLogSeparation InverseReflectedPhase InverseTerminalWidths InverseSecondFibers +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_complete_state_from_rank_moments + (lo hi:ℝ)(hlo:0by rw [poolPrimary_span F hF i];infer_instance; + let _om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox; + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₁ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₂ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₁ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₂ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M), + ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) z + slots lists a (normTwistedSource W theta) (Z^N)‖^2)≤ + Cs*(1+‖theta‖)^shortDegree*Z^(N+V-cstar/256)+ + Cb*(1+A)*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower))* + Z^(N+V+lossFinal+2*L*epsFirst+eps) := by + obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2, + hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hstep⟩:= + actual_complete_state_from_children lo hi hlo hhi W hsW hW Vlog Alog hbox hone + L cstar eta tau saving em ed eps hL hcstar heta heta1 hetac htau htau1 hem hed heps K + refine ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2, + hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,?_⟩ + intro epsFirst epsSecond heF heS degree q hq + obtain ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,hstep⟩:=hstep epsFirst epsSecond heF heS degree q hq + refine ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,?_⟩ + intro σ _ m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog + hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hsmall hmN hmargin hreserve hpuncture + hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA + labels hlabels D hD slots hcard lists H hdis hH1 hH hprod base Ψ hbase hΨ hperiod a ha + dsimp only + intro h11 h12 h21 h22 + apply hstep m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog + hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut.le hcutL hcutc hmN hmargin hreserve + hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA + labels hlabels D hD slots hcard lists H hdis hH1 hH hprod Ψ hΨ hperiod a ha + · intro j hj + dsimp only + intro hne ξ k hk + exact actual_live_bin_rank_children (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q) + Z N V M cutoff eta L bw window hi (normWidth Z (Ideal.span {m})) z₀ margin epschild A + (M-3*(cutoff/2)/2) (N+V+15*eta) (margin-7*eta) tau + j (by linarith) hL heta.le heta1 hcut hsmall hV hFcap hbZ hlog hExp h2 hbw + (by rw [hbexp]; exact hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith))) + (hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith))) hne + base Ψ hbase m hm hmargin hpuncture le_rfl le_rfl le_rfl slots lists a w11 w12 K degree h11 h12 k.1 k.2.1 k.2.2 true + + · intro j hj + dsimp only + intro hne ξ k hk + exact actual_live_bin_rank_children (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q) + Z N V M cutoff eta L bw window hi (normWidth Z (Ideal.span {m})) z₀ margin epschild A + (M-3*(cutoff/2)/2) (N+V+15*eta) (margin-7*eta) tau + j (by linarith) hL heta.le heta1 hcut hsmall hV hFcap hbZ hlog hExp h2 hbw + (by rw [hbexp]; exact hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith))) + (hwin.trans (Real.rpow_le_rpow_of_exponent_le (by linarith) (by linarith))) hne + base Ψ hbase m hm hmargin hpuncture le_rfl le_rfl le_rfl slots lists a w21 w22 K degree h21 h22 k.1 k.2.1 k.2.2 false + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRankNormalized.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRankNormalized.lean new file mode 100644 index 0000000000000000000000000000000000000000..933d04931340d5a699c46af796f590300d0c50b8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteRankNormalized.lean @@ -0,0 +1,109 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteRank +import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteNormalized + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace SevenEighths.InverseMoment +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight +open InverseInitialClippedColumns FourierBridge JointLogSeparation InverseReflectedPhase InverseTerminalWidths InverseSecondFibers +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_complete_normalized_rank_step + (lo hi:ℝ)(hlo:0by rw [poolPrimary_span F hF i];infer_instance; + let _om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox; + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₁ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₁₂ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₁ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₂₂ + Z (M-3*(cutoff/2)/2) (N+V+15*eta) z₀ (margin-7*eta) epschild A K degree → + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels + (nonzeroChildFrequencyBall 1 (Z^M)) (secondLabelWeight K) (normTwistedSource W theta) + (Z^N) Z (N+V)≤ + Cs*(1+‖theta‖)^shortDegree*Z^(N+V-cstar/256)+ + Cb*(1+A)*(1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower))* + Z^(N+V+lossFinal+2*L*epsFirst+eps) := by + obtain ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2, + hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,hstep⟩:= + actual_complete_state_from_rank_moments lo hi hlo hhi W hsW hW Vlog Alog hbox hone + L cstar eta tau saving em ed eps hL hcstar heta heta1 hetac htau htau1 hem hed heps K + refine ⟨w11,w12,w21,w22,af1,bf1,af2,bf2,window,bw,ds,ha1,hab1,ha2,hab2, + hw11,hw12,hw21,hw22,hs11,hs12,hs21,hs22,hbw,hbA,hbexp,?_⟩ + intro epsFirst epsSecond heF heS degree q hq + obtain ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,hstep⟩:=hstep epsFirst epsSecond heF heS degree q hq + refine ⟨Cs,Cb,Z₀,hCs,hCb,hZ₀,?_⟩ + intro σ _ m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog + hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hsmall hmN hmargin hreserve hpuncture + hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA + labels hlabels D hD slots hcard lists H hdis hH1 hH hprod base Ψ hbase hΨ hperiod a ha + dsimp only + intro h11 h12 h21 h22 + have hh:=hstep m hm Z N V M z₀ margin cutoff pi epschild A loss lossFinal theta hZ hZ2 h2 hExp hlog + hN hV hM hFcap hMF hzcap hbZ hAZ hwin hcut hcutL hcutc hsmall hmN hmargin hreserve hpuncture + hpi hpieta hemc hedc hechild hsave hloss hprincipal hretained htail hA + labels hlabels D hD slots hcard lists H hdis hH1 hH hprod base Ψ hbase hΨ hperiod a ha h11 h12 h21 h22 + rw [outside_complete_normalized_energy (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q) + Ψ m slots lists a labels (fun I hI=>(hlabels I hI).1) (secondLabelWeight K) + (normTwistedSource W theta) (Z^N) Z (N+V) (Z^M) (by linarith)] at hh + exact hh + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteState.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteState.lean new file mode 100644 index 0000000000000000000000000000000000000000..ca96b719a71c664917a67979817b724fe6e94428 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalCompleteState.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalShortFinite +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongTotal + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical ContDiff +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve InverseReflectedPhase InverseTerminalWidths CompletedHeight +open InverseCanonicalShortAttachment InverseSecondFibers FirstPassCubeLabels SecondPassArithmetic +local notation "O"=>ActualEisensteinCubic.O +universe v + +theorem actual_complete_state_from_live_bins + (lo hi:ℝ)(hlo:0Disjoint (lists i) (lists j)) → + (∀i∈slots,1≤H i) → (∀i∈slots,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i) → (∏i∈slots,H i)≤Z^z₀ → + ∀(Ψ:O→*ℂ),(∀u,‖Ψ u‖≤1) → + CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ → + ∀(theta:ℝ)(a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ), + (∀i∈slots,∀P∈lists i,‖a i P‖≤1) → ∀E:ℝ,0≤E → + let S:=reflectionExcludedPrimes q; + let test:=normTwistedSource W theta; + (∀j∈cubeLogRange hi (Z^N), + (progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j)).Nonempty → + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D hi (Z^N) j)) + Ψ m (idealGenerator I) z test (Z^N) (Z^(cutoff-V)) slots lists a) (Z^M)≤E) → + Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M), + ‖outsideCanonicalMarkedRow S D (reflectionExcludedPrimes_bad q) Ψ m (idealGenerator I) z + slots lists a test (Z^N)‖^2)≤ + C*((1+‖theta‖)^degree*Z^(N+V-cstar/256)+Z^eps*E) := by + obtain ⟨degree,hs⟩:=actual_complete_short_finite_uniform_degree lo hi hlo W hWs hW L cstar eta + hL hcstar heta heta1 hetac rmax K + obtain ⟨Cl,hCl,hl⟩:=actual_complete_energy_from_live_bins K hi L eps hhi hL heps + refine ⟨degree,?_⟩ + intro q hq + obtain ⟨Cs,Z₀,hCs,hZ₀,hshort⟩:=hs q hq + refine ⟨2*Cs+Cl,Z₀,by positivity,hZ₀,?_⟩ + intro σ _ m hm Z N V M z₀ margin cutoff hZ hN hNL hV hVL hM hML hzL hcut hcutL hcutc + hmN hmargin hreserve labels hlabels D hD slots hcard lists H hdis hH1 hH hprod Ψ hΨ hperiod theta a ha E hE + dsimp only + intro hbins + have hz:0i.val) slots lists a + have htest:HasCompactSupport test:=HasCompactSupport.of_support_subset_isCompact isCompact_Icc + ((normTwistedSource_support W theta).trans hWs) + have hupper:∀x,test x≠0 → x≤hi:=fun x hx=>(hWs (normTwistedSource_support W theta hx)).2 + have hT:∀z∈nonzeroChildFrequencyBall 1 (Z^M),z≠0 ∧ (Ideal.absNorm (Ideal.span {z}):ℝ)≤Z^M := by + intro z hz + have hh:=(mem_nonzeroChildFrequencyBall 1 one_ne_zero (Z^M) z).mp hz + constructor + · intro he + simp only [he,mul_zero,map_zero,norm_zero,pow_succ,lt_self_iff_false] at hh + exact hh.1 + · rw [←eisEmbedding_norm_sq_eq_absNorm_span] + simpa only [one_mul] using hh.2 + have hshortbound:Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 (Z^M), + ‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) + test (Z^N) (Z^(cutoff-V)) mark‖^2)≤Cs*(1+‖theta‖)^degree*Z^(N+V-cstar/256) := by + by_cases hbig:cutoff≤V + · have he (I:Ideal O)(z:O):markedShortCompletedSum + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) test (Z^N) (Z^(cutoff-V)) mark=0:= + short_sum_zero_of_label_large _ _ _ _ _ _ _ hZ1 hbig + simp only [he,norm_zero,zero_pow (by decide:2≠0),Finset.sum_const_zero,mul_zero] + positivity + · exact hshort m hm Z N V M z₀ margin (cutoff-V) cutoff hZ hN hV hM hML hVL hzL + (by linarith) (by linarith) hmN hmargin hreserve (by linarith) (by linarith) hcutc + labels hlabels (nonzeroChildFrequencyBall 1 (Z^M)) hT D hD slots hcard lists H + hdis hH1 hH hprod Ψ hΨ hperiod theta a ha + have hb:=hl S D (reflectionExcludedPrimes_bad q) (reflectionExcludedPrimes_prime q) labels + (fun I hI=>(hlabels I hI).1.1) Ψ m slots lists a test htest Z N V (Z^M) + (Z^(cutoff-V)) (Cs*(1+‖theta‖)^degree*Z^(N+V-cstar/256)) E + hZ1 (Real.rpow_pos_of_pos hz _) hNL hVL (fun I hI=>(hlabels I hI).2.2) + hupper hD hE hshortbound hbins + apply hb.trans + have hA:0≤(1+‖theta‖)^degree*Z^(N+V-cstar/256):=by positivity + have hB:0≤Z^eps*E:=by positivity + nlinarith + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalEnergyExistenceData.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalEnergyExistenceData.lean new file mode 100644 index 0000000000000000000000000000000000000000..1f10fbc31f4e1e9dc97be89b3a248ead18c257e8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalEnergyExistenceData.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankEnergyMonotone + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalQuadraticSieve +open CanonicalRowCompletion InverseReflectedPhase +local notation "O"=>ActualEisensteinCubic.O + +def CanonicalEnergyExists (Mcap Fcap c eps L:ℝ)(K:ℕ)(W:𝓢(ℝ,ℂ)):Prop := + ∃degree:ℕ,∃B:ℝ,1≤B ∧ + ∀q:ℕ,q≠0→∃C Z₀:ℝ,0by rw [poolPrimary_span F hFa i];infer_instance + apply canonical_rank_loss_le (poolPrimary F) (poolPrimary_ne_zero F hFa) (poolPrimary_coprime F hFa) + (poolPrimary_good F hFa) Finset.univ base slots lists a W Z Mcap Fcap z c (rankLoss n eta) eps C K degree + (by linarith) hC.le he + exact canonical_rank_restrict (poolPrimary F) (poolPrimary_ne_zero F hFa) (poolPrimary_coprime F hFa) + (poolPrimary_good F hFa) Finset.univ base slots lists a W Z Mcap (rankRowCap n cutoff) + Fcap (rankTotalCap n L eta) z c (rankMargin n cstar eta) (rankLoss n eta) C K degree hM hF hc hmom + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLiveBinRank.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLiveBinRank.lean new file mode 100644 index 0000000000000000000000000000000000000000..d5d0a6c40674804b44a7cf10eb7e19c1622b14d4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLiveBinRank.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankCapChildren +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongGeometry + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalQuadraticSieve +open CanonicalRowCompletion FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstLabelCell InverseMomentFirstChildWindows +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_live_bin_rank_children + (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S) + (Z N V M cutoff eta L b window bW Qwidth z c eps A Mnext Fnext cnext tau:ℝ) + (j:ℕ)(hZ:1by rw [poolPrimary_span F hF i];infer_instance; + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₁ Z Mnext Fnext z cnext eps A K degree → + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a ω₂ Z Mnext Fnext z cnext eps A K degree → + ∀k:SourceIndex,∀l jj:ℕ,∀negative:Bool, + ChildBounds (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ + (progressingCubes S D (Z^(cutoff-V)) (activeCubeLogBin S D bW (Z^N) j)) + k l jj negative Ψ m slots lists a ω₁ ω₂ + Z M (N-3*actualCubeLength Z j) (actualCubeLength Z j) V eta tau window b eps A K degree :=by + dsimp only + intro h₁ h₂ k l jj negative + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance + obtain ⟨hel,hr,hrL,helL,hFL,hgap,hqn⟩:=actual_long_bin_geometry S D hbad bW Z N V cutoff eta L j + hZ hL heta1 hV hparentcap hbW hlog hne + have hs:(N-3*actualCubeLength Z j)+3*actualCubeLength Z j+V=N+V:=by ring + apply canonical_rank_cap_children (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) (poolPrimary_odd F hF) + (fun i=>(primaryPrime_spec i.val (poolPrimary_ne_zero F hF i)).2.2.2) + Finset.univ _ k l jj negative base Ψ hΨ m hm slots lists a ω₁ ω₂ + Z M _ _ V eta tau window b (cutoff/2) Qwidth z c eps A Mnext Fnext cnext K degree + hZ heta hbin hel hV hb hbt hwindow (by linarith) (by linarith) (by linarith) + (by simpa only [hs] using hparent) hpuncture ?_ hMc (by simpa only [hs] using hFc) hcc h₁ h₂ + intro v hv + apply (hqn v hv).2.trans + calc + _≤Z^eta*Z^(actualCubeLength Z j):=mul_le_mul_of_nonneg_right hexp (Real.rpow_nonneg (by linarith) _) + _=Z^(actualCubeLength Z j+eta):=by rw [Real.rpow_add (by linarith : 0ActualEisensteinCubic.O + + theorem actual_marked_bin_empty + {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ) + (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)) + (Ψ:O→*ℂ)(m f z:O)(W:ℝ→ℂ)(X H₀:ℝ)(slots:Finset σ) + (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) + (he:¬(progressingCubes S D H₀ Q).Nonempty) : + markedReopenedCubeBin S D Q Ψ m f z W X H₀ slots lists a=0 := by + rw [marked_long_filter,Finset.not_nonempty_iff_eq_empty.mp he] + simp only [markedReopenedCubeBin,Finset.sum_empty] + +theorem actual_large_bins_aggregate + {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ) + (labels:Finset (Ideal O))(Ψ:O→*ℂ)(m:O)(W:ℝ→ℂ)(b X H₀ R Z V E:ℝ) + (slots:Finset σ)(lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) + (hbin:∀j∈cubeLogRange b X, + (progressingCubes S D H₀ (activeCubeLogBin S D b X j)).Nonempty→ + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a) R≤E) + (hE:0≤E) : + Z^(-V)*((cubeLogRange b X).card*∑j∈cubeLogRange b X, + rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a) R)≤ + ((cubeLogRange b X).card:ℝ)^2*E := by + have hj (j:ℕ)(hj:j∈cubeLogRange b X) : + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a) R≤E := by + by_cases hn:(progressingCubes S D H₀ (activeCubeLogBin S D b X j)).Nonempty + · exact hbin j hj hn + · rw [Finset.not_nonempty_iff_eq_empty.mp hn] + simpa only [markedReopenedCubeBin,Finset.sum_empty,rowFamilyEnergy, + nonzeroRowMajorantSum,norm_zero,zero_pow (by decide:2≠0),Complex.ofReal_zero, + mul_zero,ite_self,tsum_zero,Finset.sum_const_zero,Complex.zero_re] using hE + calc + _=(cubeLogRange b X).card*∑j∈cubeLogRange b X, + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a) R := by rw [←Finset.mul_sum];ring + _≤(cubeLogRange b X).card*∑_j∈cubeLogRange b X,E := by + gcongr + exact hj _ ‹_› + _=_ := by rw [Finset.sum_const,nsmul_eq_mul];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongBins.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongBins.lean new file mode 100644 index 0000000000000000000000000000000000000000..c26fa6c84a6c71e99d1aa2fcd2c548cda5c695b6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongBins.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongNormalization + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic +open InverseSecondFibers InverseInitialClippedColumns +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_marked_family_binned + {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ) + (hbad:fixedBadPrimes⊆S)(hSp:∀P∈S,Prime P) + (labels:Finset (Ideal O))(Ψ:O→*ℂ)(m:O)(W:ℝ→ℂ)(hWc:HasCompactSupport W) + (b X H₀ K:ℝ)(hX:0outsideCanonicalMarkedRow S D hbad Ψ m + (idealGenerator I) z slots lists a W X) K ≤ + 2*X*(rowFamilyEnergy labels (fun I z=> + markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W X H₀ + (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)) K+ + (cubeLogRange b X).card*∑j∈cubeLogRange b X, + rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a) K) := by + simp only [rowFamilyEnergy_eq_sum _ _ K hK] + have he:∀I z, + ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W X‖^2 ≤ + 2*X*(‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W X H₀ + (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)‖^2+ + (cubeLogRange b X).card*∑j∈cubeLogRange b X, + ‖markedReopenedCubeBin S D (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2) := by + intro I z + have hh:=original_marked_binned_energy S D Ψ m (idealGenerator I) z W b X H₀ slots lists a + hbad hSp hWc hX hW hD + have hs:(∑j∈cubeLogRange b X, + ‖markedReopenedCubeBin S D (activeCubeLogBin S D b X j) Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2)= + ∑j∈cubeLogRange b X, + ‖markedReopenedCubeBin S D (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2 := by + apply Finset.sum_congr rfl + intro j hj + rw [marked_long_filter S D (activeCubeLogBin S D b X j) Ψ m (idealGenerator I) z W X H₀ slots lists a] + rw [hs] at hh + exact hh + calc + _≤∑I∈labels,∑z∈(firstFrequencyDisk (2*K)).erase 0, + (rowMajorant (‖ConcreteTraceCRT.eisEmbedding z‖^2/K)).re * + (2*X*(‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W X H₀ + (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)‖^2+ + (cubeLogRange b X).card*∑j∈cubeLogRange b X, + ‖markedReopenedCubeBin S D (progressingCubes S D H₀ (activeCubeLogBin S D b X j)) + Ψ m (idealGenerator I) z W X H₀ slots lists a‖^2)) := by + apply Finset.sum_le_sum + intro I hI + apply Finset.sum_le_sum + intro z hz + exact mul_le_mul_of_nonneg_left (he I z) (rowMajorant_nonneg _) + _=_ := by + simp only [mul_add,Finset.sum_add_distrib,Finset.mul_sum] + congr 1 + · apply Finset.sum_congr rfl + intro I hI + apply Finset.sum_congr rfl + intro z hz + exact mul_left_comm _ _ _ + · simp_rw [Finset.sum_comm (s:=(firstFrequencyDisk (2*K)).erase 0) (t:=cubeLogRange b X)] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro j hj + apply Finset.sum_congr rfl + intro I hI + apply Finset.sum_congr rfl + intro z hz + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCaller.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCaller.lean new file mode 100644 index 0000000000000000000000000000000000000000..b150bb608a5ea1b3fd11fd914641a56221ea0cc3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCaller.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongWeight +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCount +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongIntegral + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic +open InverseSecondFibers InverseInitialClippedColumns IdealMobiusDivisorSum +local notation "O"=>ActualEisensteinCubic.O + +theorem normalized_complete_marked_split (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0by rw [poolPrimary_span F hF i];infer_instance; + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m slots lists a labels + (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) W (Z^N) Z (N+V)≤ + 2*C*Z^(-V+eps)*( + rowFamilyEnergy labels (fun I z=>markedShortCompletedSum + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) W (Z^N) H₀ + (indexedIdealMark (fun i:primePool F=>i.val) slots lists a)) R+ + (cubeLogRange b (Z^N)).card*∑j∈cubeLogRange b (Z^N), + rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)) + Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R) := by + obtain ⟨C,hC,hh⟩:=normalized_second_energy_le_actual_family K L eps hL heps + refine ⟨C,hC,?_⟩ + intro σ _ S D hbad hSp labels hlabels Ψ m slots lists a W hWc b Z N V R H₀ + hZ hR hV hnorm hW hD + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + have hz:0ActualEisensteinCubic.O + +def actualLongCoefficient {ι:Type*}(p:ι→O)(Ψ:O→*ℂ)(m:O)(H₀ B ξ:ℝ) + (I:Ideal O)(v:ι→₀ℕ) : ℂ := + separatedCubeCoefficient + (fun u:ι→₀ℕ=>reopenedCubeCoefficient H₀ (rowTwist Ψ m (idealGenerator I) 1) + (Ideal.span {primeProduct p u.support u})) + (fun u:ι→₀ℕ=>(Ideal.absNorm (Ideal.span {primeProduct p u.support u}):ℝ)) B ξ v + +theorem actualLongCoefficient_uniform (eps:ℝ)(heps:0pow_ne_zero _ (hp i)) + rw [eisEmbedding_norm_sq_eq_absNorm_span] at hlo hhi + have hh:=hbound H₀ (rowTwist Ψ m (idealGenerator I) 1) + (rowTwist_norm Ψ hΨ m (idealGenerator I) 1) _ hne + have hb:‖reopenedCubeCoefficient H₀ (rowTwist Ψ m (idealGenerator I) 1) + (Ideal.span {primeProduct p v.support v})‖≤C*(Real.exp 1*B)^eps := + hh.trans (mul_le_mul_of_nonneg_left (Real.rpow_le_rpow (by positivity) hhi heps.le) hC.le) + have hs:=separatedCubeCoefficient_bound + (fun u:ι→₀ℕ=>reopenedCubeCoefficient H₀ (rowTwist Ψ m (idealGenerator I) 1) + (Ideal.span {primeProduct p u.support u})) + (fun u:ι→₀ℕ=>(Ideal.absNorm (Ideal.span {primeProduct p u.support u}):ℝ)) B ξ + (C*(Real.exp 1*B)^eps) hB (by positivity) v hlo hhi hb + unfold actualLongCoefficient + convert hs using 1 ; ring + +theorem actualLongCoefficient_complete + (S:Finset (Ideal O))(D:ℕ)(hbad:fixedBadPrimes⊆S) + (Ψ:O→*ℂ)(m:O)(H₀ B ξ:ℝ)(I:Ideal O) + (v:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ) : + actualLongCoefficient (poolPrimary (InitialMeanSquare.outsideSquarefreeIdeals S D)) + Ψ (m*excludedGenerator S) H₀ B ξ I v= + separatedCubeCoefficient + (fun u=>reopenedCubeCoefficient H₀ (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) + (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) u)) + (fun u=>(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) u):ℝ)) B ξ v := by + simp only [actualLongCoefficient,cubeIdeal_eq_primeProduct_span _ + (InitialMeanSquare.outsideSquarefree_admissible S D hbad)] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCosts.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCosts.lean new file mode 100644 index 0000000000000000000000000000000000000000..6c840626e7ddfde2dac06691533b559db39d1742 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongCosts.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalCompleteState +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongGeometry + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment + +theorem actual_long_coefficient_cost (Z ell L epsilon Ccoef:ℝ) + (hZ:1≤Z)(hell:ell≤L)(heps:0≤epsilon): + (Ccoef*(Real.exp 1*Z^ell)^epsilon)^2≤ + Ccoef^2*Real.exp (2*epsilon)*Z^(2*L*epsilon) := by + have hz:0ActualEisensteinCubic.O + +theorem actual_complete_finite_split (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0i.val) + slots lists a)‖^2))+ + 2*C*Z^(-V+eps)*(cubeLogRange b (Z^N)).card*∑j∈cubeLogRange b (Z^N), + rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)) + Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R := by + obtain ⟨C,hC,hweight⟩:=second_label_weight_uniform K L eps hL heps + refine ⟨C,hC,?_⟩ + intro σ _ S D hbad hSp labels hlabels Ψ m slots lists a W hWc b Z N V R H₀ hZ hR hV hnorm hW hD + have hz:0markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) z) + W (Z^N) H₀ (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a) + let long:=fun j I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)) + Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a + let ball:=nonzeroChildFrequencyBall 1 R + have hpoint (I:Ideal O)(z:O): + ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W (Z^N)‖^2≤ + 2*Z^N*(‖short I z‖^2+bins.card*∑j∈bins,‖long j I z‖^2) := by + have hh:=original_marked_binned_energy S D Ψ m (idealGenerator I) z W b (Z^N) H₀ slots lists a + hbad hSp hWc (Real.rpow_pos_of_pos hz _) hW hD + convert hh using 1 + congr 2 + apply congrArg (fun x:ℝ=>(bins.card:ℝ)*x) + apply Finset.sum_congr rfl + intro j hj + rw [marked_long_filter S D (activeCubeLogBin S D b (Z^N) j) Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a] + have hlong (j:ℕ): + (∑I∈labels,secondLabelWeight K I*∑z∈ball,‖long j I z‖^2)≤ + C*Z^eps*rowFamilyEnergy labels (long j) R := by + rw [rowFamilyEnergy,Complex.re_sum,Finset.mul_sum] + apply Finset.sum_le_sum + intro I hI + have hb:=finite_nonzero_row_energy_le_majorant (long j I) ball R hR + (by intro z hz;rw [←eisEmbedding_norm_sq_eq_absNorm_span] + simpa only [one_mul] using ((mem_nonzeroChildFrequencyBall 1 one_ne_zero R z).mp hz).2) + (by intro z hz he + have hn:=((mem_nonzeroChildFrequencyBall 1 one_ne_zero R z).mp hz).1 + simp only [he,mul_zero,map_zero,norm_zero,pow_succ,lt_self_iff_false] at hn) + exact (mul_le_mul_of_nonneg_right (hweight Z V hZ hV I (hlabels I hI) (hnorm I hI)) + (Finset.sum_nonneg (fun _ _=>sq_nonneg _))).trans (mul_le_mul_of_nonneg_left hb (by positivity)) + have hsum:=Finset.sum_le_sum (s:=labels) (fun I hI=> + mul_le_mul_of_nonneg_left (Finset.sum_le_sum (s:=ball) (fun z hz=>hpoint I z)) + (show 0≤secondLabelWeight K I by unfold secondLabelWeight;positivity)) + have he:=mul_le_mul_of_nonneg_left hsum (Real.rpow_nonneg hz.le (-(N+V))) + have hc:Z^(-(N+V))*Z^N=Z^(-V):=by rw [←Real.rpow_add hz];congr 1;ring + have rearrange: + Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈ball, + 2*Z^N*(‖short I z‖^2+bins.card*∑j∈bins,‖long j I z‖^2))= + 2*Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈ball,‖short I z‖^2)+ + 2*Z^(-V)*bins.card*∑j∈bins,∑I∈labels,secondLabelWeight K I*∑z∈ball,‖long j I z‖^2 := by + simp only [mul_add,Finset.sum_add_distrib,Finset.mul_sum] + simp_rw [Finset.sum_comm (s:=ball) (t:=bins)] + rw [Finset.sum_comm (s:=labels) (t:=bins)] + simp only [←Finset.mul_sum,mul_assoc,mul_left_comm] + rw [←hc] + ring + rw [rearrange] at he + apply he.trans + have hj:=mul_le_mul_of_nonneg_left (Finset.sum_le_sum (s:=bins) (fun j hj=>hlong j)) + (show 0≤2*Z^(-V)*(bins.card:ℝ) by positivity) + rw [←Finset.mul_sum] at hj + have hpow:Z^(-V)*Z^eps=Z^(-V+eps):=(Real.rpow_add hz _ _).symm + convert add_le_add_left hj (2*Z^(-V)*(∑I∈labels,secondLabelWeight K I*∑z∈ball,‖short I z‖^2)) using 1 <;> + dsimp [bins,short,long,ball] <;> (try rw [←hpow]) <;> ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongFull.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongFull.lean new file mode 100644 index 0000000000000000000000000000000000000000..15b473abd753d6e1578bfc6c6740374b3a9f53e4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongFull.lean @@ -0,0 +1,112 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicPriorityBudget +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCoefficient + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_long_dyadic_full_energy + (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (Ψ:O→*ℂ)(m mCoef:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V H₀ ξ Benergy:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hbinExp:Real.exp 1≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Mmax)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r) + (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool) + (_hQlo:∀v∈Q,Z^ell≤‖eisEmbedding (primeProduct p v.support v)‖^2) + (_hQhi:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Real.exp 1*Z^ell) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap) + + (_hΨ:∀u,‖Ψ u‖≤1)(_hB:0≤Benergy) + (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0) + (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) + (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1), + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Lcap+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om ξ (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) cutoff Ψ m mark W rowMajorant (Z^M)); + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 0)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.rightExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + true Ψ m slots lists weights omega₁ + ((physicalScales (Z^r) k.1 k.2.1) 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.leftExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + false Ψ m slots lists weights omega₂ + ((physicalScales (Z^r) k.1 k.2.1) 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=> + varyingReopenedRow p hp hcop hg pool Q ((actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) I) Ψ m (ConcretePrimeRowBridge.idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤ + Czero*(Ccoef*(Real.exp 1*Z^ell)^eps)^2*Z^(M-ell+3*eta+eps*(5*ell+2*r+7*eta))+ + C*(Ccoef*(Real.exp 1*Z^ell)^eps)^2*Benergy*(1+‖ξ‖)^(2*InverseClippingProfiles.momentOrder J)* + Z^((2*Lcap+15*eta+tau)*eps+eps)+Ctail*(Ccoef*(Real.exp 1*Z^ell)^eps)^2*Z^(-saving) := by + obtain ⟨omega₁,omega₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,he⟩:= + original_dyadic_full_energy om a b ha hs Lcap Mmax eta tau saving hcap hMmax hb heta heta1 htau htau1 + refine ⟨omega₁,omega₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro eps heps J + obtain ⟨Ccoef,hCcoef,hcoef⟩:=actualLongCoefficient_uniform eps heps + obtain ⟨C,Czero,Ctail,hC,hCzero,hCtail,hfull⟩:=he eps heps J + refine ⟨Ccoef,C,Czero,Ctail,hCcoef,hC,hCzero,hCtail,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels Ψ m mCoef slots lists weights + Z M r ell V H₀ ξ Benergy hZ hbin hbinExp hM hF hMcap hell hV hr hbZ hQpool hQlo hQhi + hrcap hellcap hΨ hB hsf hn hlabels hslots hweights mark Y cutoff W source keys hleft hright + have hz:0ActualEisensteinCubic.O + +def actualCubeLength (Z:ℝ)(j:ℕ):ℝ:=Real.logb Z (normLogScale j) + +theorem actualCubeLength_power (Z:ℝ)(hZ:1(hnorm v hv).2) + refine ⟨hel,by linarith,by linarith,by linarith,by linarith,hprogress,?_⟩ + intro u hu + rw [cubeIdeal_primeProduct_norm _ (InitialMeanSquare.outsideSquarefree_admissible S D hbad)] + exact hnorm u (Finset.mem_filter.mp hu).1 + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongHeightBin.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongHeightBin.lean new file mode 100644 index 0000000000000000000000000000000000000000..b5728a707d6e672f6debaa0aa40bf018e617ca60 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongHeightBin.lean @@ -0,0 +1,115 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongUniformTestBin +import OAI.NumberTheory.DirichletL.Descent.CanonicalReopeningHeight + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace SevenEighths.InverseMoment +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight +open FourierBridge JointLogSeparation +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_marked_bin_height + (a₀ b₀:ℝ)(ha₀:0by rw [poolPrimary_span F hF i];infer_instance; + let p:=poolPrimary F; + let hp:=poolPrimary_ne_zero F hF; + let hcop:=poolPrimary_coprime F hF; + let hg:=poolPrimary_good F hF; + let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox; + ∀(Q:Finset (primePool F →₀ ℕ))(labels:Finset (Ideal O))(Ψ:O →* ℂ)(m:O) + (slots:Finset σ)(lists:σ → Finset (primePool F))(weights:σ → primePool F → ℂ) + (Z M r ell V H₀ pi epschild A loss lossFinal:ℝ), + 2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 0≤M → r+3*ell+V≤Lcap → M≤Lcap → + 0≤ell → 0≤V → -eta≤r → Real.exp Alog≤Z^eta → + (∀v∈Q,Z^ell≤(Ideal.absNorm (cubeIdeal F v):ℝ)) → + (∀v∈Q,(Ideal.absNorm (cubeIdeal F v):ℝ)≤Real.exp 1*Z^ell) → + r≤Lcap → ell≤Lcap → V≤Lcap → Real.exp window≤Z^eta → 0≤pi → 6*eta≤pi → + em*(20*(3*Lcap+16)+30)≤pi/4 → ed*(20*(3*Lcap+16)+30)≤pi/4 → + 0≤epschild → -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond → + 48*eta+tau+pi+epschild+epsSecond≤loss → slots.card≤K → + M-ell≤r+3*ell+V → 3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal → + loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤r+3*ell+V+lossFinal → + (∀u,‖Ψ u‖≤1) → 0≤A → (∀I∈labels,Squarefree I) → (∀I∈labels,I≠0) → + (∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) → + (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀q∈lists i,‖weights i q‖≤1) → + b₀*Z^(r+3*ell)≤D → + (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists weights om Z M r ell V H₀ ξ Lcap eta tau, + ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂ + Z M r ell V eta tau window bw epschild A K degree) → + (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists weights om Z M r ell V H₀ ξ Lcap eta tau, + ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂ + Z M r ell V eta tau window bw epschild A K degree) → + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z + (normTwistedSource W theta) (Z^(r+3*ell)) H₀ slots lists weights) (Z^M)≤ + C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*Z^(r+3*ell+V+lossFinal)* + (1+‖theta‖)^(2*(InverseClippingProfiles.momentOrder (firstDegree degree)+(volume:Measure ℝ).integrablePower)) := by + obtain ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw, + haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,he⟩:= + actual_marked_bin_uniform_test a₀ b₀ ha₀ hb₀ Vlog Alog hbox hone + Lcap eta tau saving em ed hcap heta heta1 htau htau1 hem hed K + refine ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw, + haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,?_⟩ + intro epsFirst epsSecond hepsF hepsS degree + obtain ⟨Ccoef,C,hCcoef,hC,hbin⟩:=he epsFirst epsSecond hepsF hepsS degree + obtain ⟨Cm,hCm,hmoment⟩:=reopening_twisted_moment_squared W a₀ b₀ ha₀ hsW hW + (InverseClippingProfiles.momentOrder (firstDegree degree)) + refine ⟨Ccoef,C*Cm,hCcoef,mul_nonneg hC hCm,?_⟩ + intro theta σ _ S D hbad hSp + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + intro Q labels Ψ m slots lists weights Z M r ell V H₀ pi epschild A loss lossFinal + hZ hbins hbinExp hM hFcap hMcap hell hV hr hbZ hQlo hQhi hrcap hellcap hVcap hwin + hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail + hΨ hA hsf hn hlabels hslots hweights hD hleft hright + have hT:=CanonicalRowCompletion.normTwistedSource_contDiff W a₀ b₀ ha₀ hsW hW theta + have hsT:Function.support (normTwistedSource W theta)⊆Set.Icc a₀ b₀:= + (normTwistedSource_support W theta).trans hsW + have hbnd:=hbin (normTwistedSource W theta) hsT hT S D hbad hSp + Q labels Ψ m slots lists weights Z M r ell V H₀ pi epschild A loss lossFinal + hZ hbins hbinExp hM hFcap hMcap hell hV hr hbZ hQlo hQhi hrcap hellcap hVcap hwin + hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail + hΨ hA hsf hn hlabels hslots hweights hD hleft hright + have hz:0 ActualEisensteinCubic.O + +theorem actual_long_bin_normalized_energy + {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes ⊆ S) (hSp : ∀P∈S,Prime P) + (Q : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D) →₀ ℕ)) + (labels : Finset (Ideal O)) (Ψ : O →* ℂ) (m : O) (W : ℝ → ℂ) + (a b : ℝ) (ha : 0 < a) (hb : 0≤b) (hs : Function.support W ⊆ Set.Icc a b) + (hW : ContDiff ℝ ∞ W) (V : 𝓢(ℝ,ℂ)) + (hV : ∀ u, |u| ≤ columnWindowRadius a b → V u = 1) + (Z r cubeLength Vheight H₀ K E : ℝ) (d : ℕ) + (hZ : 0 < Z) (hD : b*(Z^(r+3*cubeLength))≤D) (hK : 0 < K) (hE : 0 ≤ E) + (hn : ∀ v ∈ Q, (Z^cubeLength) ≤ (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v) : ℝ)) + (hn' : ∀ v ∈ Q, (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v) : ℝ) ≤ Real.exp 1*(Z^cubeLength)) + (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (weights : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) : + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + let hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + letI : ∀ i : primePool F, (Ideal.span {poolPrimary F i}).IsMaximal := + fun i => by rw [poolPrimary_span F hF i]; infer_instance + let β := fun I v => reopenedCubeCoefficient H₀ + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n := fun v => (Ideal.absNorm (cubeIdeal F v) : ℝ) + (∀ ξ : ℝ, Z^(-r-2*cubeLength-Vheight)*rowFamilyEnergy labels (fun I z => + varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q + (separatedCubeCoefficient (β I) n (Z^cubeLength) ξ) Ψ m (idealGenerator I) + (fun v T => primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) (Z^r) T)) z) K ≤ + E*(1+|ξ|)^(2*d)) → + Z^(-Vheight)*rowFamilyEnergy labels (fun I z => + markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z W (Z^(r+3*cubeLength)) H₀ slots lists weights) K ≤ + E * + (∫ ξ : ℝ, ‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^d)^2 := by + dsimp only + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + let β:=fun I v=>reopenedCubeCoefficient H₀ (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n:=fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ) + intro hsource + have hcancel:Z^(r+2*cubeLength+Vheight)*Z^(-r-2*cubeLength-Vheight)=1 := by + rw [←Real.rpow_add hZ] + convert Real.rpow_zero Z using 2 ; ring + have hpoint:∀ξ:ℝ,rowFamilyEnergy labels (fun I z=> + varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Q (separatedCubeCoefficient (β I) n (Z^cubeLength) ξ) + Ψ m (idealGenerator I) + (fun v T=>primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) (Z^r) T)) z) K≤ + (Z^(r+2*cubeLength+Vheight)*E)*(1+|ξ|)^(2*d) := by + intro ξ + have hh:=mul_le_mul_of_nonneg_left (hsource ξ) (Real.rpow_nonneg hZ.le (r+2*cubeLength+Vheight)) + rw [←mul_assoc,hcancel,one_mul] at hh + simpa only [mul_assoc] using hh + have hX:Z^(r+3*cubeLength)=(Z^cubeLength)^3*Z^r := by + rw [←Real.rpow_mul_natCast hZ.le,←Real.rpow_add hZ] + congr 1 + ring + have hbnd:=markedReopenedCubeBin_energy S D hbad hSp Q labels Ψ m W a b ha hb hs hW V hV + (Z^cubeLength) (Z^r) (Z^(r+3*cubeLength)) H₀ K (Z^(r+2*cubeLength+Vheight)*E) d + (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) hX hD hK (by positivity) + hn hn' slots lists weights hpoint + have hc:Z^(-Vheight)*((Z^cubeLength)^2*Z^r)⁻¹*Z^(r+2*cubeLength+Vheight)=1 := by + rw [←Real.rpow_mul_natCast hZ.le,←Real.rpow_add hZ,←Real.rpow_neg hZ.le, + ←Real.rpow_add hZ,←Real.rpow_add hZ] + convert Real.rpow_zero Z using 2 ; ring + have hh:=mul_le_mul_of_nonneg_left hbnd (Real.rpow_nonneg hZ.le (-Vheight)) + apply hh.trans_eq + calc + _=(Z^(-Vheight)*((Z^cubeLength)^2*Z^r)⁻¹*Z^(r+2*cubeLength+Vheight))* + E*(∫ξ:ℝ,‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^d)^2 := by ring + _=_:=by rw [hc,one_mul] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongKeys.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongKeys.lean new file mode 100644 index 0000000000000000000000000000000000000000..23188f1bd13431d3af902fd70a458543324138d3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongKeys.lean @@ -0,0 +1,34 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongParent + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks +open InverseMomentFirstOriginalProfile CompletedHeight +local notation "O"=>ActualEisensteinCubic.O + +def actualLongSourceKeys {ι σ:Type}[DecidableEq ι][DecidableEq σ] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))(Ψ:O→*ℂ)(m mCoef:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ)(om:ℝ→ℂ) + (Z M r ell V H₀ ξ Lcap eta tau:ℝ) := + let mark:=fun v U=>primeMark slots lists weights (v.support∪U) + let cutoff:=fun (q:CubeCoordinates ι)(C:Finset ι)(_I:Ideal O)(D:Finset ι)=> + firstDyadicRadius p q C D Z M r ell V eta tau + let W:=fun y=>normTwistedSource om ξ (y/Z^r) + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) + (fun x=>x.1) (Z^(2*Lcap+15*eta+tau)) + liveJointKeys p source pool (sourceSummand p hp hcop hg + (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) cutoff Ψ m mark W rowMajorant (Z^M)) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongNormalization.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..b1fced708c5ad1156014ce35aa89f1f301194b12 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongNormalization.lean @@ -0,0 +1,106 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongSource +import OAI.NumberTheory.DirichletL.Descent.GeneratorTransport +import OAI.NumberTheory.DirichletL.Descent.SecondNormalizedEnergy + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic +open InverseSecondFibers IdealMobiusDivisorSum InverseInitialClippedColumns +local notation "O"=>ActualEisensteinCubic.O + +theorem child_ball_unit_mem (u:Oˣ)(R:ℝ)(k:O) : + (u:O)*k∈nonzeroChildFrequencyBall 1 R ↔ k∈nonzeroChildFrequencyBall 1 R := by + simp only [mem_nonzeroChildFrequencyBall 1 one_ne_zero,one_mul, + GaussGeneratorTransport.norm_eisEmbedding_unit_mul] + +theorem child_ball_unit_sum {A:Type*}[AddCommMonoid A](u:Oˣ)(R:ℝ)(f:O→A) : + ∑k∈nonzeroChildFrequencyBall 1 R,f ((u:O)*k)= + ∑k∈nonzeroChildFrequencyBall 1 R,f k := by + apply Finset.sum_bij (fun k _=>(u:O)*k) + · intro k hk + exact (child_ball_unit_mem u R k).mpr hk + · intro x hx y hy he + exact mul_left_cancel₀ u.ne_zero he + · intro y hy + refine ⟨((u⁻¹:Oˣ):O)*y,(child_ball_unit_mem u⁻¹ R y).mpr hy,?_⟩ + rw [←mul_assoc,←Units.val_mul,mul_inv_cancel,Units.val_one,one_mul] + · intros + rfl + +variable {ι σ:Type*}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,goodLambda∉Ideal.span {p i}) + +theorem canonical_ball_generator_energy + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(I:Ideal O)(hI:primaryGenerator I≠0) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(W:ℝ→ℂ)(X K:ℝ) : + (∑k∈nonzeroChildFrequencyBall 1 K, + ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2)= + ∑k∈nonzeroChildFrequencyBall 1 K, + ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X‖^2 := by + obtain ⟨u,hu⟩:=generator_eq_unit_primary I (idealGenerator I) (span_idealGenerator I) hI + let P:O→ℝ:=fun k=> + ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2 + have hrot:=child_ball_unit_sum (u^4) K P + have he (k:O): + ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X‖^2= + P (((u^4:Oˣ):O)*k) := by + rw [hu,finiteCanonicalMarkedRow_label_transfer] + rfl + simp only [he] + exact hrot.symm + +theorem normalized_energy_le_actual_family + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(hlabels:∀I∈labels,primaryGenerator I≠0) + (weight:Ideal O→ℝ)(C:ℝ)(hC:0≤C)(hw:∀I∈labels,0≤weight I ∧ weight I≤C) + (W:ℝ→ℂ)(X Z F K:ℝ)(hZ:0 + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X) K := by + have hn:‖((Z^(-F/2):ℝ):ℂ)‖^2=Z^(-F) := by + rw [Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.rpow_pos_of_pos hZ _), + ←Real.rpow_mul_natCast hZ.le] + congr 1 + ring + unfold normalizedColumnEnergy + simp only [norm_mul,mul_pow,hn,←Finset.mul_sum] + have he : (∑ I∈labels,weight I*(Z^(-F)*∑k∈nonzeroChildFrequencyBall 1 K, + ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2))= + Z^(-F)*(∑ I∈labels,weight I*∑k∈nonzeroChildFrequencyBall 1 K, + ‖finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator I) k slots lists a W X‖^2) := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intros + ring + rw [he] + rw [mul_assoc] + apply mul_le_mul_of_nonneg_left _ (Real.rpow_nonneg hZ.le _) + rw [rowFamilyEnergy,Complex.re_sum,Finset.mul_sum] + apply Finset.sum_le_sum + intro I hI + rw [canonical_ball_generator_energy p hp hcop hg pool Ψ m I (hlabels I hI)] + have hball:=finite_nonzero_row_energy_le_majorant + (fun k=>finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X) + (nonzeroChildFrequencyBall 1 K) K hK + (by intro k hk + rw [←eisEmbedding_norm_sq_eq_absNorm_span] + simpa only [one_mul] using ((mem_nonzeroChildFrequencyBall 1 one_ne_zero K k).mp hk).2) + (by intro k hk hn + have hh:=((mem_nonzeroChildFrequencyBall 1 one_ne_zero K k).mp hk).1 + simp only [hn,mul_zero,map_zero,norm_zero,pow_succ,lt_self_iff_false] at hh) + exact (mul_le_mul_of_nonneg_right (hw I hI).2 (Finset.sum_nonneg (fun _ _=>sq_nonneg _))).trans + (mul_le_mul_of_nonneg_left hball hC) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongParent.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongParent.lean new file mode 100644 index 0000000000000000000000000000000000000000..b5aa20488bc824c17396b73a3da4d3af9dda5626 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongParent.lean @@ -0,0 +1,115 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstTwoPassParentEnergy +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongCoefficient +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicFullEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform InverseMomentFirstLabelCell +open InverseMomentFirstSecondHeightCost +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_long_parent_energy + (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (Ψ:O→*ℂ)(m mCoef:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V H₀ ξ pi epschild A loss lossFinal:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hbinExp:Real.exp 1≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Lcap)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r) + (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool) + (_hQlo:∀v∈Q,Z^ell≤‖eisEmbedding (primeProduct p v.support v)‖^2) + (_hQhi:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Real.exp 1*Z^ell) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap) + + (_hVcap:V≤Lcap)(_hwin:Real.exp window≤Z^eta)(_hpi:0≤pi)(_hpieta:6*eta≤pi) + (_hemcost:em*(20*(3*Lcap+16)+30)≤pi/4)(_hedcost:ed*(20*(3*Lcap+16)+30)≤pi/4) + (_hechild:0≤epschild)(_hsave: -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond) + (_hloss:48*eta+tau+pi+epschild+epsSecond≤loss)(_hcard:slots.card≤K) + (_hparent:M-ell≤r+3*ell+V) + (_hprincipal:3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal) + (_hretained:loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal) + (_htail: -saving≤r+3*ell+V+lossFinal) + (_hΨ:∀u,‖Ψ u‖≤1)(_hA:0≤A) + (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0) + (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) + (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1), + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Lcap+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om ξ (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg (actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) cutoff Ψ m mark W rowMajorant (Z^M)); + (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂ + Z M r ell V eta tau window bw epschild A K degree)→ + (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂ + Z M r ell V eta tau window bw epschild A K degree)→ + Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=> + varyingReopenedRow p hp hcop hg pool Q ((actualLongCoefficient p Ψ mCoef H₀ (Z^ell) ξ) I) Ψ m (ConcretePrimeRowBridge.idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤ + C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*(1+‖ξ‖)^(2*InverseClippingProfiles.momentOrder (firstDegree degree))* + Z^(r+3*ell+V+lossFinal) := by + obtain ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw, + haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,he⟩:= + original_two_pass_parent_energy om a b ha hs Lcap eta tau saving em ed hcap hb heta heta1 htau htau1 hem hed K + refine ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw, + haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,?_⟩ + intro epsFirst epsSecond hepsF hepsS degree + obtain ⟨Ccoef,hCcoef,hcoef⟩:=actualLongCoefficient_uniform epsFirst hepsF + obtain ⟨C,hC,hfull⟩:=he epsFirst epsSecond hepsF hepsS degree + refine ⟨Ccoef,C,hCcoef,hC,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels Ψ m mCoef slots lists weights + Z M r ell V H₀ ξ pi epschild A loss lossFinal hZ hbin hbinExp hM hF hMcap hell hV hr hbZ hQpool hQlo hQhi + hrcap hellcap hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hparent hprincipal hretained htail + hΨ hA hsf hn hlabels hslots hweights mark Y cutoff W source keys hleft hright + have hz:0ActualEisensteinCubic.O + +theorem long_frequency_profile + {ι:Type*}(p:ι→O)(hp:∀i,p i≠0) + (V:𝓢(ℝ,ℂ))(A:ℝ)(hV:∀s,V s≠0→|s|≤A) + (Z r ξ:ℝ)(hZ:0Ideal.span {p i}))) + (hg:∀i,goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(β:(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m f z:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (V:𝓢(ℝ,ℂ))(A:ℝ)(hV:∀s,V s≠0→|s|≤A)(Z r ξ:ℝ)(hZ:0primeMark slots lists weights (T∪v.support)* + frequencyTwist V ξ (columnLog p (Z^r) T)) z = + varyingReopenedRow p hp hcop hg pool Q β Ψ m f + (fun v T=>primeMark slots lists weights (v.support∪T)* + normTwistedSource (radialFromLog V (V.smooth ⊤) A hV) ξ + (primeProductNorm p T/Z^r)) z := by + congr 1 + funext v T + rw [long_frequency_profile p hp V A hV Z r ξ hZ T,Finset.union_comm T v.support] + +theorem marked_long_filter + {σ:Type*}[DecidableEq σ](S:Finset (Ideal O))(D:ℕ) + (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)) + (Ψ:O→*ℂ)(m f z:O)(W:ℝ→ℂ)(X H₀:ℝ)(slots:Finset σ) + (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (weights:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) : + markedReopenedCubeBin S D Q Ψ m f z W X H₀ slots lists weights= + markedReopenedCubeBin S D (progressingCubes S D H₀ Q) Ψ m f z W X H₀ slots lists weights := by + unfold markedReopenedCubeBin progressingCubes + dsimp only + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro v hv hn + have hz:largeCubeCoefficient H₀ (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v)=0 := by + by_contra hh + exact hn (Finset.mem_filter.mpr ⟨hv,(largeCubeCoefficient_support H₀ _ hh).2⟩) + simp only [hz,zero_mul] + +theorem long_cube_progress + (S:Finset (Ideal O))(D:ℕ) + (Q:Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)) + (Z cutoff V ell:ℝ)(hZ:1ActualEisensteinCubic.O + +theorem actual_complete_energy_from_live_bins (K:ℕ)(b L eps:ℝ) + (hb:0≤b)(hL:0≤L)(heps:0i.val) + slots lists a)‖^2)≤Eshort → + (∀j∈cubeLogRange b (Z^N), + (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)).Nonempty → + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)) + Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R≤Elong) → + Z^(-(N+V))*(∑I∈labels,secondLabelWeight K I*∑z∈nonzeroChildFrequencyBall 1 R, + ‖outsideCanonicalMarkedRow S D hbad Ψ m (idealGenerator I) z slots lists a W (Z^N)‖^2)≤ + 2*Eshort+C*Z^eps*Elong := by + obtain ⟨Cw,hCw,hw⟩:=actual_complete_finite_split K L (eps/2) hL (by positivity) + obtain ⟨Cb,hCb,hbnd⟩:=actual_cube_bin_count b L (eps/2) hb hL (by positivity) + refine ⟨2*Cw*Cb,by positivity,?_⟩ + intro σ _ S D hbad hSp labels hlabels Ψ m slots lists a W hWc Z N V R H₀ Eshort Elong + hZ hR hN hV hnorm hW hD hE hshort hlong + have hz:0markedReopenedCubeBin S D + (progressingCubes S D H₀ (activeCubeLogBin S D b (Z^N) j)) + Ψ m (idealGenerator I) z W (Z^N) H₀ slots lists a) R≤ + (2*Cw*Cb)*Z^eps*Elong := by + have h1:=mul_le_mul_of_nonneg_left ha (show 0≤2*Cw*Z^(eps/2) by positivity) + have h2:=mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right hc hE) + (show 0≤2*Cw*Z^(eps/2) by positivity) + have ht:=h1.trans h2 + rw [hp] + convert ht using 1 + · ring + · rw [←hh];ring + exact hs.trans (add_le_add (mul_le_mul_of_nonneg_left hshort (by norm_num:0≤(2:ℝ))) ha') + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongUniformTestBin.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongUniformTestBin.lean new file mode 100644 index 0000000000000000000000000000000000000000..335b48cb5ad72554bfe62169c0d5d55676f3e5c8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongUniformTestBin.lean @@ -0,0 +1,151 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongKeys +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongIntegral + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace SevenEighths.InverseMoment +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve CanonicalCubeSeparation FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstLabelCell InverseMomentFirstSecondHeightCost CompletedHeight +open FourierBridge JointLogSeparation +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_marked_bin_uniform_test + (a₀ b₀:ℝ)(ha₀:0by rw [poolPrimary_span F hF i];infer_instance; + let p:=poolPrimary F; + let hp:=poolPrimary_ne_zero F hF; + let hcop:=poolPrimary_coprime F hF; + let hg:=poolPrimary_good F hF; + let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox; + ∀(Q:Finset (primePool F →₀ ℕ))(labels:Finset (Ideal O))(Ψ:O →* ℂ)(m:O) + (slots:Finset σ)(lists:σ → Finset (primePool F))(weights:σ → primePool F → ℂ) + (Z M r ell V H₀ pi epschild A loss lossFinal:ℝ), + 2≤Z → 2≤Z^eta → Real.exp 1≤Z^eta → 0≤M → r+3*ell+V≤Lcap → M≤Lcap → + 0≤ell → 0≤V → -eta≤r → Real.exp Alog≤Z^eta → + (∀v∈Q,Z^ell≤(Ideal.absNorm (cubeIdeal F v):ℝ)) → + (∀v∈Q,(Ideal.absNorm (cubeIdeal F v):ℝ)≤Real.exp 1*Z^ell) → + r≤Lcap → ell≤Lcap → V≤Lcap → Real.exp window≤Z^eta → 0≤pi → 6*eta≤pi → + em*(20*(3*Lcap+16)+30)≤pi/4 → ed*(20*(3*Lcap+16)+30)≤pi/4 → + 0≤epschild → -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond → + 48*eta+tau+pi+epschild+epsSecond≤loss → slots.card≤K → + M-ell≤r+3*ell+V → 3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal → + loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal → -saving≤r+3*ell+V+lossFinal → + (∀u,‖Ψ u‖≤1) → 0≤A → (∀I∈labels,Squarefree I) → (∀I∈labels,I≠0) → + (∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) → + (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀q∈lists i,‖weights i q‖≤1) → + b₀*Z^(r+3*ell)≤D → + (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists weights om Z M r ell V H₀ ξ Lcap eta tau, + ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂ + Z M r ell V eta tau window bw epschild A K degree) → + (∀ξ:ℝ,∀k∈actualLongSourceKeys p hp hcop hg Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists weights om Z M r ell V H₀ ξ Lcap eta tau, + ChildBounds p hp hcop hg Finset.univ Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂ + Z M r ell V eta tau window bw epschild A K degree) → + Z^(-V)*rowFamilyEnergy labels (fun I z=>markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z + test (Z^(r+3*ell)) H₀ slots lists weights) (Z^M)≤ + C*(Ccoef*(Real.exp 1*Z^ell)^epsFirst)^2*(1+A)*Z^(r+3*ell+V+lossFinal)* + (∫ξ:ℝ,‖reopeningCoefficient test a₀ b₀ ha₀ hs₀ hTest ξ‖*(1+|ξ|)^(InverseClippingProfiles.momentOrder (firstDegree degree)))^2 := by + let om:=radialFromLog Vlog (Vlog.smooth ⊤) Alog hbox + have hs:Function.support om⊆Set.Icc (Real.exp (-Alog)) (Real.exp Alog):= + fun x hx=>radialFromLog_support Vlog (Vlog.smooth ⊤) Alog hbox x hx + obtain ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw, + haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,he⟩:= + actual_long_parent_energy om (Real.exp (-Alog)) (Real.exp Alog) (Real.exp_pos _) hs + Lcap eta tau saving em ed hcap (Real.exp_pos _).le heta heta1 htau htau1 hem hed K + refine ⟨ω₁₁,ω₁₂,ω₂₁,ω₂₂,af₁,bf₁,af₂,bf₂,window,bw, + haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hbwexp,?_⟩ + intro epsFirst epsSecond hepsF hepsS degree + obtain ⟨Ccoef,C,hCcoef,hC,hparent⟩:=he epsFirst epsSecond hepsF hepsS degree + let d:=InverseClippingProfiles.momentOrder (firstDegree degree) + refine ⟨Ccoef,C,hCcoef,hC,?_⟩ + intro test hs₀ hTest + let moment:ℝ:=∫ξ:ℝ,‖reopeningCoefficient test a₀ b₀ ha₀ hs₀ hTest ξ‖*(1+|ξ|)^d + intro σ _ S D hbad hSp + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + intro Q labels Ψ m slots lists weights Z M r ell V H₀ pi epschild A loss lossFinal + hZ hbin hbinExp hM hFcap hMcap hell hV hr hbZ hQlo hQhi hrcap hellcap hVcap hwin + hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail + hΨ hA hsf hn hlabels hslots hweights hD hleft hright + have hz:0Ideal.span {poolPrimary F i}) := by + intro i j hij + exact Subtype.ext (by simpa only [poolPrimary_span F hF] using hij) + have hpr (i:primePool F):goodLambda^2∣poolPrimary F i-1:= + (primaryPrime_spec i.val (poolPrimary_ne_zero F hF i)).2.2.2 + let Gamma:=Ccoef*(Real.exp 1*Z^ell)^epsFirst + let E:=C*Gamma^2*(1+A)*Z^(r+3*ell+V+lossFinal) + have hE:0≤E:=by dsimp [E];positivity + refine (actual_long_bin_normalized_energy S D hbad hSp Q labels Ψ m test a₀ b₀ ha₀ hb₀ hs₀ hTest + Vlog hone Z r ell V H₀ (Z^M) E d hz hD (Real.rpow_pos_of_pos hz _) hE hQlo hQhi slots lists weights ?_).trans_eq ?_ + · intro ξ + have hbnd:=hparent (poolPrimary F) (poolPrimary_ne_zero F hF) hg' hinj + (poolPrimary_coprime F hF) (poolPrimary_odd F hF) hpr Finset.univ Q labels Ψ m (m*excludedGenerator S) + slots lists weights Z M r ell V H₀ ξ pi epschild A loss lossFinal + hZ hbin hbinExp hM hFcap hMcap hell hV hr hbZ (fun _ _=>Finset.subset_univ _) + (by intro v hv;rw [cubeIdeal_primeProduct_norm F hF];exact hQlo v hv) + (by intro v hv;rw [cubeIdeal_primeProduct_norm F hF];exact hQhi v hv) + hrcap hellcap hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hpar hprincipal hretained htail + hΨ hA hsf hn hlabels hslots hweights (hleft ξ) (hright ξ) + have hc (I:Ideal O) := funext (actualLongCoefficient_complete S D hbad Ψ m H₀ (Z^ell) ξ I) + have hrow: (fun I z=>varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) hg' Finset.univ Q + (separatedCubeCoefficient (fun v=>reopenedCubeCoefficient H₀ + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v)) + (fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ)) (Z^ell) ξ) Ψ m (idealGenerator I) + (fun v T=>primeMark slots lists weights (T∪v.support)*frequencyTwist Vlog ξ (columnLog (poolPrimary F) (Z^r) T)) z)= + (fun I z=>varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) hg' Finset.univ Q + (separatedCubeCoefficient (fun v=>reopenedCubeCoefficient H₀ + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v)) + (fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ)) (Z^ell) ξ) Ψ m (idealGenerator I) + (fun v T=>primeMark slots lists weights (v.support∪T)*normTwistedSource om ξ (primeProductNorm (poolPrimary F) T/Z^r)) z) := by + funext I z + exact long_marked_source_eq (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + hg' Finset.univ Q _ Ψ m (idealGenerator I) z slots lists weights Vlog Alog hbox Z r ξ hz + rw [hrow] + convert hbnd using 1 + · apply congrArg (fun f => Z^(-r-2*ell-V)*rowFamilyEnergy labels f (Z^M)) + funext I z + exact congrArg (fun coeff => varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) hg' Finset.univ Q coeff Ψ m (idealGenerator I) + (fun v T => primeMark slots lists weights (v.support∪T)*normTwistedSource om ξ + (primeProductNorm (poolPrimary F) T/Z^r)) z) (hc I).symm + · dsimp [E,Gamma,d] + try simp only [Real.norm_eq_abs] + ring + · dsimp [E,Gamma,moment] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongWeight.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongWeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..a942ab0d9298b75784ee5224188f57ce50cfa2b7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLongWeight.lean @@ -0,0 +1,65 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLongNormalization +import OAI.NumberTheory.DirichletL.Descent.TripleMass + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve FirstPassCubeLabels SecondPassArithmetic +open InverseSecondFibers InverseInitialClippedColumns IdealMobiusDivisorSum +local notation "O"=>ActualEisensteinCubic.O + +theorem second_label_weight_uniform (K:ℕ)(L eps:ℝ)(hL:0≤L)(heps:0Ideal.span {p i}))) + (hg:∀i,goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(_hlabels:∀I∈labels,Admissible I) + (W:ℝ→ℂ)(X Z F V R:ℝ),1≤Z→0 + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (idealGenerator I) k slots lists a W X) R := by + obtain ⟨C,hC,hh⟩:=second_label_weight_uniform K L eps hL heps + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg pool Ψ m slots lists a labels hlabels W X Z F V R hZ hR hV hnorm + have hz:0supported_primaryGenerator_ne_zero I (admissible_supported (hlabels I hI))) + (secondLabelWeight K) (C*Z^eps) (by positivity) + (fun I hI=>⟨by unfold secondLabelWeight;positivity, + hh Z V hZ hV I (hlabels I hI).1 (hnorm I hI)⟩) W X Z F R hz hR + convert hb using 1 + rw [Real.rpow_add hz] + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLowerMoments.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLowerMoments.lean new file mode 100644 index 0000000000000000000000000000000000000000..6f605a3c041e5ee3bc63bb45f7caf307f31eee9d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalLowerMoments.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalChildSupport +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStep + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve +open InverseInitialClippedColumns InverseSecondFibers InverseSecondSourceBlocks +open CanonicalCoefficientClass InverseMomentFirstLabelCell InverseMomentFirstChildWindows InverseFirstGlobalCaps +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ] +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def CanonicalLowerMoments (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ):Prop := + ∀(Ψ:O→*ℂ),IsBaseRayTwist base Ψ→∀(m:O),m≠0→∀N V M Qwidth:ℝ, + 0≤N→0≤V→0≤M→0≤Qwidth→M ActualEisensteinCubic.O + +section General +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,goodLambda∉Ideal.span {p i}) + +omit [DecidableEq ι] in +theorem rowCoprimeMask_redundant_mul (S : Finset ι) (m c : Eis) + (hc : ∀ i∈S,c∈Ideal.span {p i}→m∈Ideal.span {p i}) : + rowCoprimeMask (fun i=>Ideal.span {p i}) S (m*c)= + rowCoprimeMask (fun i=>Ideal.span {p i}) S m := by + have he : (∃i∈S,m*c∈Ideal.span {p i}) ↔ ∃i∈S,m∈Ideal.span {p i} := by + constructor + · rintro ⟨i,hi,hm⟩ + exact ⟨i,hi,((inferInstance : (Ideal.span {p i}).IsPrime).mem_or_mem hm).elim id (hc i hi)⟩ + · rintro ⟨i,hi,hm⟩ + exact ⟨i,hi,Ideal.mul_mem_right _ _ hm⟩ + simp only [rowCoprimeMask,he] + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_redundant_puncture + (pool : Finset ι) (Ψ : Eis →* ℂ) (m c f k : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) (W : ℝ→ℂ) (X : ℝ) + (hc : ∀ i∈pool,c∈Ideal.span {p i}→m∈Ideal.span {p i}) : + finiteCanonicalMarkedRow p hp hcop hg pool Ψ (m*c) f k slots lists a W X= + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a W X := by + unfold finiteCanonicalMarkedRow fixedChildRow + apply Finset.sum_congr rfl + intro S hS + have hm := rowCoprimeMask_redundant_mul p S m c + (fun i hi=>hc i (Finset.mem_powerset.mp hS hi)) + simp only [secondChildColumn,hm] + +omit [DecidableEq σ] in +theorem normalizedColumnEnergy_redundant_puncture + (pool : Finset ι) (Ψ : Eis →* ℂ) (m c : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (D : Ideal Eis→ℝ) + (W : ℝ→ℂ) (X Z F : ℝ) + (hc : ∀ i∈pool,c∈Ideal.span {p i}→m∈Ideal.span {p i}) : + normalizedColumnEnergy p hp hcop hg pool Ψ (m*c) slots lists a labels rows D W X Z F= + normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D W X Z F := by + simp only [normalizedColumnEnergy,finiteCanonicalMarkedRow_redundant_puncture + p hp hcop hg pool Ψ m c _ _ slots lists a W X hc] + +omit [DecidableEq ι] in +theorem puncture_mem_of_radical_dvd (m c : Eis) + (hc : (Ideal.span {c}:Ideal Eis).radical∣(Ideal.span {m}:Ideal Eis).radical) + (i : ι) (hi : c∈Ideal.span {p i}) : m∈Ideal.span {p i} := by + rw [←Ideal.span_singleton_le_iff_mem] + apply Ideal.le_radical.trans + apply (Ideal.dvd_iff_le.mp hc).trans + exact (inferInstance : (Ideal.span {p i}).IsPrime).radical_le_iff.mpr + (by rwa [Ideal.span_singleton_le_iff_mem]) + +omit [DecidableEq ι] in +theorem inherited_puncture_redundant_mem (m c : Eis) + (γ : InverseSecondFibers.OuterTriple) + (hc : (Ideal.span {c}:Ideal Eis).radical∣Ideal.span {m}) + (i : ι) (hi : c∈Ideal.span {p i}) : + actualSecondInheritedRadicalPuncture m γ∈Ideal.span {p i} := by + have hd := actual_inherited_radical_preserves_fixed m γ (Ideal.span {c}).radical + (Ideal.radical_idem _) hc + apply puncture_mem_of_radical_dvd p _ c _ i hi + rw [actual_inherited_radical_is_radical] + exact hd + +end General + +theorem outside_pool_redundant_puncture {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal Eis)) (D : ℕ) (hbad : fixedBadPrimes⊆S) + (hSp : ∀P∈S,Prime P) + (pool : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (Ψ : Eis →* ℂ) (m f k : Eis) (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) + (W : ℝ→ℂ) (X : ℝ) : + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + finiteCanonicalMarkedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ + (m*excludedGenerator S) f k slots lists a W X= + finiteCanonicalMarkedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ m f k slots lists a W X := by + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + apply finiteCanonicalMarkedRow_redundant_puncture + intro i hi hc + rw [poolPrimary_span _ (InitialMeanSquare.outsideSquarefree_admissible S D hbad)] at hc + exact False.elim (excludedGenerator_not_mem_pool S D hSp i hc) + +end SevenEighths.InverseMoment +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalPunctureMaskEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalPunctureMaskEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..0168f031df0c80b190c71913729f5537caed9f70 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalPunctureMaskEnergy.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalPunctureMask + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve InverseInitialClippedColumns +local notation "Eis" => ActualEisensteinCubic.O + +theorem outside_pool_redundant_energy {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal Eis)) (D : ℕ) (hbad : fixedBadPrimes⊆S) + (hSp : ∀P∈S,Prime P) + (pool : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (Ψ : Eis →* ℂ) (m : Eis) (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (weight : Ideal Eis→ℝ) + (W : ℝ→ℂ) (X Z Fexp : ℝ) : + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + let hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ + (m*excludedGenerator S) slots lists a labels rows weight W X Z Fexp= + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ + m slots lists a labels rows weight W X Z Fexp := by + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + apply normalizedColumnEnergy_redundant_puncture + intro i hi hc + rw [poolPrimary_span F hF i] at hc + exact False.elim (excludedGenerator_not_mem_pool S D hSp i hc) + +theorem reflection_pool_mask_energy {σ : Type*} [DecidableEq σ] + (q D : ℕ) + (pool : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D))) + (Ψ : Eis →* ℂ) (m : Eis) (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D))) + (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (weight : Ideal Eis→ℝ) + (W : ℝ→ℂ) (X Z Fexp : ℝ) : + let S:=reflectionExcludedPrimes q + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + let hF:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q) + letI : ∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ + (ActualFiber.maskElement q m) slots lists a labels rows weight W X Z Fexp= + normalizedColumnEnergy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) pool Ψ + m slots lists a labels rows weight W X Z Fexp := + outside_pool_redundant_energy (reflectionExcludedPrimes q) D + (reflectionExcludedPrimes_bad q) (reflectionExcludedPrimes_prime q) + pool Ψ m slots lists a labels rows weight W X Z Fexp + +theorem inherited_radical_mask_energy {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→Eis) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Ψ : Eis→*ℂ) (m c : Eis) (γ : InverseSecondFibers.OuterTriple) + (hc : (Ideal.span {c}:Ideal Eis).radical∣Ideal.span {m}) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (weight : Ideal Eis→ℝ) + (W : ℝ→ℂ) (X Z Fexp : ℝ) : + normalizedColumnEnergy p hp hcop hg pool Ψ + (actualSecondInheritedRadicalPuncture m γ*c) slots lists a labels rows weight W X Z Fexp= + normalizedColumnEnergy p hp hcop hg pool Ψ + (actualSecondInheritedRadicalPuncture m γ) slots lists a labels rows weight W X Z Fexp := + normalizedColumnEnergy_redundant_puncture p hp hcop hg pool Ψ _ c + slots lists a labels rows weight W X Z Fexp + (fun i _=>inherited_puncture_redundant_mem p m c γ hc i) + +end SevenEighths.InverseMoment +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankCapChildren.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankCapChildren.lean new file mode 100644 index 0000000000000000000000000000000000000000..9e7b578194f420716f2bd43e26ebc7f634493a11 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankCapChildren.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankMonotone + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve +open InverseMomentFirstLabelCell InverseMomentFirstChildWindows InverseFirstGlobalCaps +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ] +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem canonical_rank_cap_children + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(k:SourceIndex)(l j:ℕ)(negative:Bool) + (base Ψ:O→*ℂ)(hΨ:CanonicalCoefficientClass.IsBaseRayTwist base Ψ)(m:O)(hm:m≠0) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ω₁ ω₂:𝓢(ℝ,ℂ)) + (Z M r ell V eta tau window b cutoff Qwidth z c eps A Mnext Fnext cnext:ℝ)(K degree:ℕ) + (hZ:1 linarith + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankDepthParameters.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankDepthParameters.lean new file mode 100644 index 0000000000000000000000000000000000000000..623cd09692b029947332c9bedc00e7ca2690e71b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankDepthParameters.lean @@ -0,0 +1,66 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceData +import OAI.NumberTheory.DirichletL.Descent.RecursionParameters + +namespace OAI + +noncomputable section + +namespace SevenEighths.InverseMoment + +theorem actual_rank_depth_covers (Mmax cutoff:ℝ)(hcut:0 nlinarith + +theorem actual_rank_top_parameters (Mmax Fmax c eps:ℝ) + (hM:0≤Mmax)(hF:0≤Fmax)(hc:0ActualEisensteinCubic.O + +theorem canonical_rank_loss_le {ι σ:Type}[DecidableEq ι][DecidableEq σ] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z M F z c eps eps' A:ℝ)(K degree:ℕ) + (hZ:1≤Z)(hA:0≤A)(he:eps≤eps') + (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps A K degree): + CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps' A K degree :=by + intro Ψ hΨ m hm N V Mr Q hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels s + apply (h Ψ hΨ m hm N V Mr Q hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels s).trans + apply mul_le_mul_of_nonneg_right _ (by positivity) + exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hZ (by linarith)) hA + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistence.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistence.lean new file mode 100644 index 0000000000000000000000000000000000000000..0a495a14109e5a09f39865116f1a9b73f6ec1b96 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistence.lean @@ -0,0 +1,44 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceInduction +import OAI.NumberTheory.DirichletL.Inversion.CanonicalReferenceThreshold + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMoment + +theorem actual_rank_reference_cutoffs : RankReferenceCutoffs :=by + intro lo hi hlo hhi + obtain ⟨Vlog,Alog,hA,hAe,hcompact,hsupport,hbox,hone,hzero⟩:= + exists_canonical_reference_cutoff lo hi + exact ⟨Vlog,Alog,hbox,hone⟩ + +theorem actual_rank_reference_thresholds : RankReferenceThresholds :=by + intro eta heta hi Alog window + exact eventually_canonical_reference_gates hi Alog window eta heta + +theorem canonical_rank_energy_exists + (L cstar cutoff eta:ℝ)(K:ℕ) + (hL:1≤L)(hcstar:0ActualEisensteinCubic.O + +def CompletePoolRankMoments (q D:ℕ) {σ:Type}[DecidableEq σ] + (slots:Finset σ) + (lists:σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D))) + (a:σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ) + (base:O→*ℂ)(W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ):Prop := + let F:=InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D; + let hF:=InitialMeanSquare.outsideSquarefree_admissible (reflectionExcludedPrimes q) D (reflectionExcludedPrimes_bad q); + letI:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance; + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ base slots lists a W + Z Mmax Fcap z c eps A K degree + +def rankRowCap (n:ℕ)(cutoff:ℝ):ℝ:=3*((n:ℝ)-1)*cutoff/4 + +def rankTotalCap (n:ℕ)(L eta:ℝ):ℝ:=L-15*(n:ℝ)*eta + +def rankMargin (n:ℕ)(cstar eta:ℝ):ℝ:=cstar/2+7*(n:ℝ)*eta + +def rankLoss (n:ℕ)(eta:ℝ):ℝ:=62*(n:ℝ)*eta + +def RankEnergyExists (n:ℕ)(L cstar cutoff eta:ℝ)(K:ℕ)(W:𝓢(ℝ,ℂ)):Prop := + ∃degree:ℕ,∃B:ℝ,1≤B ∧ + ∀q:ℕ,q≠0→∃C Z₀:ℝ,0by rw [poolPrimary_span F hF i];infer_instance + apply canonical_rank_negative + simp only [rankRowCap,Nat.cast_zero] + linarith + +theorem actual_rank_successor_caps (n:ℕ)(L cstar cutoff eta M F c:ℝ) + (hM:M≤rankRowCap (n+1) cutoff)(hF:F≤rankTotalCap (n+1) L eta) + (hc:rankMargin (n+1) cstar eta≤c): + M-3*cutoff/4≤rankRowCap n cutoff ∧ F+15*eta≤rankTotalCap n L eta ∧ + rankMargin n cstar eta≤c-7*eta :=by + unfold rankRowCap rankTotalCap rankMargin at * + push_cast at * + constructor <;> first | linarith | constructor <;> linarith + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistenceInduction.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistenceInduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..a3c07bb654848a4a776ee264e64ef957911cb945 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankExistenceInduction.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankExistenceSuccessor +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankDepthParameters +import OAI.NumberTheory.DirichletL.Descent.CanonicalEnergyExistenceData + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMoment +open CanonicalCubeSeparation + +def RankReferenceCutoffs:Prop := + ∀lo hi:ℝ,0 + intro W lo hi hlo hhi hsW + exact rank_energy_exists_zero L cstar cutoff eta hcut K W + | succ n ih => + intro W lo hi hlo hhi hsW + obtain ⟨Vlog,Alog,hbox,hone⟩:=href lo hi hlo hhi + exact rank_energy_exists_succ_of_reference n L cstar cutoff eta K hL hcstar hcut hcutL + hcutc heta heta1 hetac hetad ih W lo hi hlo hhi hsW Vlog Alog hbox hone + (fun window=>hthreshold eta heta hi Alog window) + +theorem canonical_energy_exists_of_references + (href:RankReferenceCutoffs)(hthreshold:RankReferenceThresholds) + (Mcap Fcap c eps:ℝ)(hM:0≤Mcap)(hF:0≤Fcap)(hc:0ActualEisensteinCubic.O + +theorem rank_energy_exists_succ_of_reference + (n:ℕ)(L cstar cutoff eta:ℝ)(K:ℕ) + (hL:1≤L)(hcstar:0by rw [poolPrimary_span F hF i];infer_instance + dsimp only [CompletePoolRankMoments] at m11 m12 m21 m22 ⊢ + intro Ψ hΨ m hm N V M Qwidth hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels theta + have hcap:N+V≤L:=by + unfold rankTotalCap at hFc + have hh:0≤15*((n+1:ℕ):ℝ)*eta:=by positivity + linarith + have hcm:0≤rankMargin (n+1) cstar eta:=by unfold rankMargin;positivity + obtain ⟨hNL,hVL,hMF,hQL,hzL,hwidth,hmargin',hmL,hpuncture⟩:= + actual_rank_state_gates m hm Z N V M Qwidth z (rankMargin (n+1) cstar eta) L + hZ1 hN hV hM hQ hz hcm hcap hmargin hnorm + obtain ⟨hΨnorm,hΨperiod⟩:=actual_rank_family_gates q base hbase hperiod Ψ hΨ + have hDparent:hi*Z^N≤D:=by + calc + _≤B*Z^L:=mul_le_mul hhiB (Real.rpow_le_rpow_of_exponent_le hZ1.le hNL) + (Real.rpow_nonneg hZ0.le _) hb0 + _≤D:=hD + have hsscard:ss.card≤K:=(Finset.card_le_card hss).trans hslots + have hssdis:(ss:Set σ).PairwiseDisjoint lists:=by + intro i hi j hj hij + exact hdis (hss hi) (hss hj) hij + have hssH:∀i∈ss,1≤H i:=fun i hi=>hH i (hss hi) + have hssP:∀i∈ss,∀P∈lists i,(Ideal.absNorm P.val:ℝ)≤H i:=fun i hi=>hP i (hss hi) + have hssa:∀i∈ss,∀P∈lists i,‖a i P‖≤1:=fun i hi=>ha i (hss hi) + have hssprod:(∏i∈ss,H i)≤Z^z:=canonical_rank_subslot_cap slots ss H Z z hss hH hprod + obtain ⟨hsmallM,hsmallF,hsmallc⟩:=actual_rank_successor_caps n L cstar cutoff eta M (N+V) + (rankMargin (n+1) cstar eta) hMc hFc le_rfl + have lift (w:𝓢(ℝ,ℂ))(Cw:ℝ)(Jw:ℕ)(hCw:0≤Cw)(hCwA:Cw≤A)(hJw:Jw≤J) + (mw:CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a w Z (rankRowCap n cutoff) + (rankTotalCap n L eta) z (rankMargin n cstar eta) (rankLoss n eta) Cw K Jw): + CanonicalRankMoments (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base ss lists a w Z (M-3*(cutoff/2)/2) + (N+V+15*eta) z (rankMargin (n+1) cstar eta-7*eta) (rankLoss n eta) A K J:=by + apply canonical_rank_subslots (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots ss lists a w Z _ _ z _ _ A K J hss + apply canonical_rank_restrict (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a w Z + (M-3*(cutoff/2)/2) (rankRowCap n cutoff) (N+V+15*eta) (rankTotalCap n L eta) + z (rankMargin (n+1) cstar eta-7*eta) (rankMargin n cstar eta) (rankLoss n eta) A K J + (by linarith) hsmallF hsmallc + exact canonical_rank_height_constant (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ base slots lists a w Z _ _ z _ _ Cw A K Jw J + hZ0 hCw hCwA hJw mw + have hechild:0≤rankLoss n eta:=by unfold rankLoss;positivity + obtain ⟨_,_,hpieta,hmass,hret,hprincipal0,hcost⟩:=actual_step_parameters L eta 0 0 (rankLoss n eta) + hL0 heta heta1 (by linarith) (by linarith) hechild + obtain ⟨hprincipal,hFirst,hFinal⟩:=actual_complete_step_cost L eta (rankLoss n eta) hL0 heta heta1 hechild + have hreserve:cstar/2≤rankMargin (n+1) cstar eta:=by + unfold rankMargin + exact le_add_of_nonneg_right (by positivity) + have hbound:=hstep m hm Z N V M z (rankMargin (n+1) cstar eta) cutoff (8*eta) + (rankLoss n eta) A (rankLoss n eta+58*eta) (rankLoss n eta+60*eta) theta + hZs' hZ2 h2 hExp hlog hN hV hM hcap hMF hzL hhiZ hAZ hwin hcut hcutL hcutc hetad hmL hmargin' + hreserve (by simpa only [hwidth] using hpuncture) (by positivity) hpieta hmass hmass hechild + (by linarith) hret hprincipal hcost (by linarith) hA + labels (fun I hI=>⟨⟨(hlabels I hI).1.1,(hlabels I hI).1.2.2⟩,(hlabels I hI).1.2.1,(hlabels I hI).2⟩) + D hDparent ss hsscard lists H hssdis hssH hssP hssprod base Ψ hΨ hΨnorm hΨperiod a hssa + (lift w11 C11 J11 hC11.le hCA11 hj11 m11) (lift w12 C12 J12 hC12.le hCA12 hj12 m12) + (lift w21 C21 J21 hC21.le hCA21 hj21 m21) (lift w22 C22 J22 hC22.le hCA22 hj22 m22) + have hnextLoss:rankLoss n eta+62*eta=rankLoss (n+1) eta:=by unfold rankLoss;push_cast;ring + have hlongexp:(rankLoss n eta+60*eta)+2*L*firstPassEpsilon L eta+eta≤rankLoss (n+1) eta:=by + simpa only [hnextLoss] using hFinal + have hloss0:0≤rankLoss (n+1) eta:=by unfold rankLoss;positivity + have hlong:Cb*(1+A)*(1+‖theta‖)^dl* + Z^(N+V+(rankLoss n eta+60*eta)+2*L*firstPassEpsilon L eta+eta)≤ + Cb*(1+A)*(1+‖theta‖)^dl*Z^(N+V+rankLoss (n+1) eta):=by + apply mul_le_mul_of_nonneg_left _ (by positivity) + apply Real.rpow_le_rpow_of_exponent_le hZ1.le + linarith + have hh:=hbound.trans (add_le_add le_rfl hlong) + have hmrg:=actual_complete_height_merge ds dl Z (N+V) cstar (rankLoss (n+1) eta) Cs Cb A theta + hZ1.le hcstar.le hloss0 hCs.le hCb hA + have hpow:(1+‖theta‖)^Jout≤(1+‖theta‖)^(2*Jout):= + pow_le_pow_right₀ (by linarith [norm_nonneg theta]) (by omega) + have hf:childLogTest W theta=normTwistedSource W theta:=by + funext y + simp only [childLogTest,normTwistedSource,mul_comm] + rw [hf] + apply (hh.trans hmrg).trans + dsimp only [C,Jout] + have hx:=mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left hpow (show 0≤(Cs+Cb)*(1+A) by positivity)) + (Real.rpow_nonneg hZ0.le (N+V+rankLoss (n+1) eta)) + convert hx using 1 ; ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankFamilyGates.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankFamilyGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..722df4affd74cc376bf6c79dec8569f10aef1e2f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankFamilyGates.lean @@ -0,0 +1,89 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankPuncture +import OAI.NumberTheory.DirichletL.Descent.CanonicalRankMonotone + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CanonicalCoefficientClass InverseTerminalWidths +open ConcretePrimeRowBridge CompletedGauss +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_rank_family_period (q:ℕ)(base Ψ:O→*ℂ) + (hbase:FactorsModulo (fixedBaseConductor q) base) + (hΨ:IsBaseRayTwist base Ψ): + FactorsModulo (fixedBaseConductor q) Ψ := by + intro x y hxy + rcases hΨ with rfl|⟨χ,rfl⟩ + · exact hbase x y hxy + · simp only [MonoidHom.mul_apply] + rw [hbase x y hxy] + congr 1 + exact RayFourExpansion.rayCharacter_eq_of_mod_four χ x y + (Ideal.mem_span_singleton.mp (Ideal.mul_le_right hxy)) + +theorem actual_rank_family_gates (q:ℕ)(base:O→*ℂ) + (hbase:∀x,‖base x‖≤1)(hperiod:FactorsModulo (fixedBaseConductor q) base): + ∀Ψ:O→*ℂ,IsBaseRayTwist base Ψ→ + (∀x,‖Ψ x‖≤1) ∧ FactorsModulo (fixedBaseConductor q) Ψ := by + intro Ψ hΨ + exact ⟨hΨ.norm_le hbase,actual_rank_family_period q base Ψ hperiod hΨ⟩ + +theorem actual_rank_norm_width (m:O)(Z Q:ℝ)(hZ:1Ideal.span {p i}))) + (hg:∀i,goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(base:O→*ℂ)(slots subslots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z M F z c eps A:ℝ)(K degree:ℕ)(hsub:subslots⊆slots) + (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M F z c eps A K degree): + CanonicalRankMoments p hp hcop hg pool base subslots lists a W Z M F z c eps A K degree := by + intro Ψ hΨ m hm N V Mr Qwidth hN hV hM hQ hMc hFc hmargin hnorm ss hss labels hlabels s + exact h Ψ hΨ m hm N V Mr Qwidth hN hV hM hQ hMc hFc hmargin hnorm ss + (hss.trans hsub) labels hlabels s + +theorem canonical_rank_subslot_product {σ:Type*}[DecidableEq σ] + (slots subslots:Finset σ)(H:σ→ℝ)(hsub:subslots⊆slots) + (hH:∀i∈slots,1≤H i): + (∏i∈subslots,H i)≤∏i∈slots,H i := + Finset.prod_le_prod_of_subset_of_one_le₀ hsub + (fun i hi=>(zero_le_one: (0:ℝ)≤1).trans (hH i (hsub hi))) + (fun i hi _=>hH i hi) + +theorem canonical_rank_subslot_cap {σ:Type*}[DecidableEq σ] + (slots subslots:Finset σ)(H:σ→ℝ)(Z z:ℝ)(hsub:subslots⊆slots) + (hH:∀i∈slots,1≤H i)(hcap:(∏i∈slots,H i)≤Z^z): + (∏i∈subslots,H i)≤Z^z := + (canonical_rank_subslot_product slots subslots H hsub hH).trans hcap + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankMoments.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankMoments.lean new file mode 100644 index 0000000000000000000000000000000000000000..e261516c4eb755a914f5012d5c93d8fc509f5b58 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalRankMoments.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalChildSupport +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStep + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CanonicalQuadraticSieve +open InverseInitialClippedColumns InverseSecondFibers InverseSecondSourceBlocks +open CanonicalCoefficientClass InverseMomentFirstLabelCell InverseMomentFirstChildWindows InverseFirstGlobalCaps +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ] +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def CanonicalRankMoments (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ):Prop := + ∀(Ψ:O→*ℂ),IsBaseRayTwist base Ψ→∀(m:O),m≠0→∀N V M Qwidth:ℝ, + 0≤N→0≤V→0≤M→0≤Qwidth→M≤Mmax→N+V≤Fcap→ + CanonicalMargins (N+V) M Qwidth z c→ + ‖ConcreteTraceCRT.eisEmbedding m‖^2=Z^Qwidth→ + ∀(subslots:Finset σ),subslots⊆slots→∀labels:Finset (Ideal O), + (∀I∈labels,Admissible I ∧ (Ideal.absNorm I:ℝ)≤Z^V)→∀s:ℝ, + normalizedColumnEnergy p hp hcop hg pool Ψ m subslots lists a labels + (nonzeroChildFrequencyBall 1 (Z^M)) (secondLabelWeight K) (childLogTest W s) (Z^N) Z (N+V)≤ + A*Z^(N+V+eps)*(1+‖s‖)^(2*degree) + +include hp in +theorem canonical_rank_moments_children + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(k:SourceIndex)(l j:ℕ)(negative:Bool) + (base Ψ:O→*ℂ)(hΨ:IsBaseRayTwist base Ψ)(m:O)(hm:m≠0) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ω₁ ω₂:𝓢(ℝ,ℂ)) + (Z M r ell V eta tau window b cutoff Qwidth z c eps A:ℝ)(K degree:ℕ) + (hZ:1ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ] +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +omit [DecidableEq σ] in +theorem canonical_rank_negative (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z Mmax Fcap z c eps A:ℝ)(K degree:ℕ)(hM:Mmax<0): + CanonicalRankMoments p hp hcop hg pool base slots lists a W Z Mmax Fcap z c eps A K degree :=by + intro Ψ hΨ m hm N V M Qwidth hN hV hM0 hQ hMc + exfalso + linarith + +omit [DecidableEq σ] in +theorem canonical_rank_restrict (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z M₁ M₂ F₁ F₂ z c₁ c₂ eps A:ℝ)(K degree:ℕ) + (hM:M₁≤M₂)(hF:F₁≤F₂)(hc:c₂≤c₁) + (h:CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M₂ F₂ z c₂ eps A K degree): + CanonicalRankMoments p hp hcop hg pool base slots lists a W Z M₁ F₁ z c₁ eps A K degree :=by + intro Ψ hΨ m hm N V M Qwidth hN hV hM0 hQ hMc hFc hmargin hnorm ss hss labels hlabels s + have hmarg:CanonicalMargins (N+V) M Qwidth z c₂:=by + unfold CanonicalMargins at * + constructor <;> linarith [hmargin.1,hmargin.2] + exact h Ψ hΨ m hm N V M Qwidth hN hV hM0 hQ (hMc.trans hM) (hFc.trans hF) hmarg hnorm ss hss labels hlabels s + +omit [DecidableEq σ] in +theorem canonical_rank_height_constant (pool:Finset ι)(base:O→*ℂ)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:𝓢(ℝ,ℂ))(Z M F z c eps A B:ℝ)(K degree J:ℕ) + (hZ:0ActualEisensteinCubic.O + +theorem actual_rank_parent_puncture (m:O)(hm:m≠0)(Z:ℝ)(hZ:1by positivity)) (he theta hT) 2 + simpa only [mul_pow,←pow_mul,Nat.mul_comm] using hh + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalShortFinite.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalShortFinite.lean new file mode 100644 index 0000000000000000000000000000000000000000..4a052d302d1ec6e066497319aee994864d15fcb4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CanonicalShortFinite.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Inversion.CanonicalShortAttachment +import OAI.NumberTheory.DirichletL.Inversion.ReflectedShortNormalizedUniformDegree + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical ContDiff +namespace SevenEighths.InverseCanonicalShortAttachment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalQuadraticSieve InverseMoment InverseReflectedPhase InverseTerminalWidths CompletedHeight +local notation "Eis"=>ActualEisensteinCubic.O +universe u v +theorem actual_complete_short_finite_uniform_degree + (lo hi : ℝ) (hlo : 0Disjoint (lists j) (lists k)) → + (∀j∈slots,1≤H j) → (∀j∈slots,∀i∈lists j,(Ideal.absNorm i.val:ℝ)≤H j) → + (∏j∈slots,H j)≤Z^z₀ → + ∀ (Ψ : Eis→*ℂ),(∀n,‖Ψ n‖≤1) → + CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ → + ∀ (θ : ℝ) + (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals (reflectionExcludedPrimes q) D)→ℂ), + (∀j∈slots,∀i∈lists j,‖a j i‖≤1) → + let S:=reflectionExcludedPrimes q + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + let mark:=indexedIdealMark (fun i:primePool F=>i.val) slots lists a + Z^(-V)*(∑f∈labels,secondLabelWeight K f*∑k∈T, + ‖markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) (idealGenerator f) k) + (normTwistedSource W θ) (Z^N) (Z^hcut) mark‖^2)≤ + C*(1+‖θ‖)^degree*Z^(N+V-cstar/256) := by + obtain ⟨degree,hu⟩:=InverseShortCanonicalNormalization.canonical_short_normalized_energy_uniform_degree + lo hi hlo W hWs hW L cstar eta hL hcstar heta heta1 hetac rmax K + refine ⟨degree,?_⟩ + intro q hq + obtain ⟨C,Z₀,hC,hZ₀,he⟩:=hu q hq + refine ⟨C,Z₀,hC,hZ₀,?_⟩ + intro σ _ m hm Z N V M z₀ margin hcut d hZ hN hV hM hMc hVc hzc hcut0 hcutc + hRn hmargin hreserve hVd hcutd hd labels hlabels T hT D hD slots hcard lists H hdis hH1 hH hprod + Ψ hΨ hperiod θ a ha + dsimp only + let S:=reflectionExcludedPrimes q + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF : ∀I∈F,Admissible I:=InitialMeanSquare.outsideSquarefree_admissible S D (reflectionExcludedPrimes_bad q) + let ilists:slots→Finset (Ideal Eis):=fun j=>idealLists F lists j.val + let iw:∀j,ilists j→ℂ:=fun j=>idealWeights F lists a j.val + have hp (j:slots) (P:Ideal Eis) (hP:P∈ilists j) := idealLists_prime_data F hF lists j.val P hP + have hcap : ∀j:slots,∀P∈ilists j,(Ideal.absNorm P:ℝ)≤H j.val := by + intro j P hP + obtain ⟨i,hi,rfl⟩:=Finset.mem_image.mp hP + exact hH j.val j.property i hi + have hw : ∀j:slots,∀P:ilists j,‖iw j P‖≤1 := by + intro j P + obtain ⟨i,hi,hh⟩:=Finset.mem_image.mp P.property + change ‖transportCoeff F a j.val P.val‖≤1 + rw [←hh,transportCoeff_val] + exact ha j.val j.property i hi + have henergy:=he (σ:=slots) m hm Z N V M z₀ margin hcut d hZ hN hV hM hMc hVc hzc hcut0 hcutc + hRn hmargin hreserve hVd hcutd hd labels (fun f hf=>(hlabels f hf).2) T hT (by simpa using hcard) + ilists (fun j:slots=>H j.val) (idealLists_disjoint F slots lists hdis) + (fun j P hP=>(hp j P hP).1) (fun j P hP=>(hp j P hP).2.1) + (fun j P hP=>(hp j P hP).2.2.1) (fun j P hP=>(hp j P hP).2.2.2) + (fun j=>hH1 j.val j.property) hcap (by simpa only [Finset.prod_coe_sort] using hprod) + Ψ hΨ hperiod θ iw hw + have hz:0i.val) slots lists a=tupleDivisibilityMark ilists iw:= + funext (indexed_mark_eq_tuple F slots lists a) + rw [hmark] + change Z^(-V)*(∑f∈labels,secondLabelWeight K f*∑k∈T, + ‖markedShortCompletedSum (rowTwist Ψ (ActualFiber.maskElement q m) (idealGenerator f) k) + (normTwistedSource W θ) (Z^N) (Z^hcut) (tupleDivisibilityMark ilists iw)‖^2)≤_ + simp only [norm_mul,mul_pow] at henergy + have hn':‖((Z^(-(N+V)/2):ℝ):ℂ)‖^2*‖((Real.sqrt (Z^N):ℝ):ℂ)‖^2=Z^(-V):=by + simpa only [norm_mul,mul_pow] using hn + simp only [←mul_assoc,hn',←Finset.mul_sum] at henergy + convert henergy using 1 + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intros + ring + +end SevenEighths.InverseCanonicalShortAttachment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ChildCutoff.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ChildCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..2c0fb6d568916346c5b2f3608bdd804ceb9c776f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ChildCutoff.lean @@ -0,0 +1,165 @@ +import OAI.NumberTheory.DirichletL.Descent.PoissonTails + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def childFrequencyBall (a : Eis) (R : ℝ) : Finset Eis := + (secondFrequencyCutoff (‖eisEmbedding a‖^2) R).filter + (fun k => ‖eisEmbedding (a*k)‖^2 ≤ R) + +lemma mem_childFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (k : Eis) : + k ∈ childFrequencyBall a R ↔ ‖eisEmbedding (a*k)‖^2 ≤ R := by + have hn : 0 < ‖eisEmbedding a‖^2 := sq_pos_of_pos + (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero ha)) + simp only [childFrequencyBall, Finset.mem_filter] + refine ⟨fun h => h.2, fun h => ⟨?_,h⟩⟩ + apply mem_secondFrequencyCutoff + apply (le_div_iff₀ hn).mpr + simpa only [map_mul, norm_mul, mul_pow, mul_comm] using h + +lemma outside_childFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (k : Eis) + (hk : k ∉ childFrequencyBall a R) : R < ‖eisEmbedding (a*k)‖^2 := + lt_of_not_ge (fun h => hk ((mem_childFrequencyBall a ha R k).mpr h)) + +def nonzeroChildFrequencyBall (a : Eis) (R : ℝ) : Finset Eis := + (childFrequencyBall a R).erase 0 + +lemma mem_nonzeroChildFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (k : Eis) : + k ∈ nonzeroChildFrequencyBall a R ↔ + 0 < ‖eisEmbedding (a*k)‖^2 ∧ ‖eisEmbedding (a*k)‖^2 ≤ R := by + have hn : 0 < ‖eisEmbedding (a*k)‖^2 ↔ k ≠ 0 := by + rw [sq_pos_iff, norm_ne_zero_iff] + constructor + · intro h hk; apply h; simp [hk] + · intro hk; exact ConcreteTraceCRT.eisEmbedding_ne_zero (mul_ne_zero ha hk) + simp only [nonzeroChildFrequencyBall, Finset.mem_erase, + mem_childFrequencyBall a ha, hn] + +lemma nonzeroChildFrequencyBall_empty (a : Eis) (ha : a ≠ 0) (R : ℝ) (hR : R < 1) : + nonzeroChildFrequencyBall a R = ∅ := by + apply Finset.eq_empty_iff_forall_notMem.mpr + intro k hk + have hm := (mem_nonzeroChildFrequencyBall a ha R k).mp hk + have hk0 : k ≠ 0 := by intro hk; simp [hk] at hm + exact (not_le_of_gt hR) ((EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq + (a*k) (mul_ne_zero ha hk0)).trans hm.2) + +def childOuterRadius (Y A E X₁ X₂ H : ℝ) : ℝ := A*E*X₁*X₂*H/Y + +theorem childFrequencyBall_raw_tail {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) (Y A E X₁ X₂ H : ℝ) + (hY : 0 < Y) (hA : 0 < A) (hE : 0 < E) + (hX₁ : 0 < X₁) (_hX₂ : 0 < X₂) (hH : 0 ≤ H) + (a e : Eis) (ha : a ≠ 0) (he : e ≠ 0) + (haA : ‖eisEmbedding a‖^2 ≤ A) (heE : ‖eisEmbedding e‖^2 ≤ E) + (S T : Finset ι) (hd : Disjoint S T) + (hS : primeProductNorm p S ≤ X₁) (hT : primeProductNorm p T ≤ X₂) + (k : Eis) (hk : k ∉ childFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)) : + H ≤ (Y / (‖eisEmbedding e‖^2 * + ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2)) * ‖eisEmbedding k‖^2 := by + have haN : 0 < ‖eisEmbedding a‖^2 := sq_pos_of_pos + (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero ha)) + have heN : 0 < ‖eisEmbedding e‖^2 := sq_pos_of_pos + (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero he)) + have hden : ‖eisEmbedding a‖^2 * ‖eisEmbedding e‖^2 * + primeProductNorm p S * primeProductNorm p T ≤ A*E*X₁*X₂ := by + exact mul_le_mul (mul_le_mul (mul_le_mul haA heE heN.le hA.le) + hS (primeProductNorm_pos p hp S).le (mul_pos hA hE).le) + hT (primeProductNorm_pos p hp T).le (by positivity) + have hchild := (outside_childFrequencyBall a ha _ k hk).le + simp only [map_mul,norm_mul,mul_pow,childOuterRadius] at hchild + have hbound : H * (‖eisEmbedding a‖^2 * ‖eisEmbedding e‖^2 * + primeProductNorm p S * primeProductNorm p T) ≤ + Y * (‖eisEmbedding a‖^2 * ‖eisEmbedding k‖^2) := by + calc + _ ≤ H*(A*E*X₁*X₂) := mul_le_mul_of_nonneg_left hden hH + _ ≤ _ := by nlinarith [(div_le_iff₀ hY).mp hchild] + have hcancel : H * (‖eisEmbedding e‖^2 * primeProductNorm p S * + primeProductNorm p T) ≤ Y * ‖eisEmbedding k‖^2 := by + apply (mul_le_mul_iff_right₀ haN).mp + nlinarith [hbound] + rw [active_norm_sq_disjoint p S T hd] + have hdpos : 0 < ‖eisEmbedding e‖^2 * (primeProductNorm p S * primeProductNorm p T) := + mul_pos heN (mul_pos (primeProductNorm_pos p hp S) (primeProductNorm_pos p hp T)) + rw [div_mul_eq_mul_div, le_div_iff₀ hdpos] + simpa only [mul_assoc] using hcancel + +theorem childFrequencyBall_remainder {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(ℝ, ℂ)) (Y A E X₁ X₂ H : ℝ), + 0 < Y → 0 < A → 0 < E → 0 < X₁ → 0 < X₂ → 0 ≤ H → + ∀ (a e : Eis), a ≠ 0 → e ≠ 0 → + ‖eisEmbedding a‖^2 ≤ A → ‖eisEmbedding e‖^2 ≤ E → + ∀ (S T : Finset ι), Disjoint S T → + primeProductNorm p S ≤ X₁ → primeProductNorm p T ≤ X₂ → + let n := ∏ i : activeSupport T S, p i.val + let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2) + ‖∑' k : {k : Eis // k ∉ childFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)}, + secondPairRadialMode p hp hg hinj S T e k.val W Y‖ ≤ + (Y / ‖eisEmbedding n‖) * + ((C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / + ((min 1 scale)^2 * (1+H)^order)) := by + obtain ⟨s,C,hC,hb⟩ := secondPairRadialMode_remainder p hp hg hinj hc order + refine ⟨s,C,hC,?_⟩ + intro W Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH a e ha he haA heE S T hd hS hT + exact hb S T e he W Y H hY hH _ + (fun k hk => childFrequencyBall_raw_tail p hp Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH + a e ha he haA heE S T hd hS hT k hk) + +theorem nonzeroChildFrequencyBall_absolute_tail {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(ℝ, ℂ)) (Y A E X₁ X₂ H : ℝ), + 0 < Y → 0 < A → 0 < E → 0 < X₁ → 0 < X₂ → 0 ≤ H → + ∀ (a e : Eis), a ≠ 0 → e ≠ 0 → + ‖eisEmbedding a‖^2 ≤ A → ‖eisEmbedding e‖^2 ≤ E → + ∀ (S T : Finset ι), Disjoint S T → + primeProductNorm p S ≤ X₁ → primeProductNorm p T ≤ X₂ → + let n := ∏ i : activeSupport T S, p i.val + let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2) + (∑' k : {k : Eis // k ≠ 0 ∧ k ∉ nonzeroChildFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)}, + ‖secondPairRadialMode p hp hg hinj S T e k.val W Y‖) ≤ + (Y / ‖eisEmbedding n‖) * + ((C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / + ((min 1 scale)^2 * (1+H)^order)) := by + obtain ⟨s,C,hC,hb⟩ := secondPairRadialMode_tail p hp hg hinj hc order + refine ⟨s,C,hC,?_⟩ + intro W Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH a e ha he haA heE S T hd hS hT + dsimp only + let n := ∏ i : activeSupport T S, p i.val + let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2) + let small : Set Eis := {k | k ≠ 0 ∧ k ∉ nonzeroChildFrequencyBall a (childOuterRadius Y A E X₁ X₂ H)} + let large : Set Eis := {k | H ≤ scale * ‖eisEmbedding k‖^2} + have hmap : ∀ k : small, k.val ∈ large := by + intro k + apply childFrequencyBall_raw_tail p hp Y A E X₁ X₂ H hY hA hE hX₁ hX₂ hH + a e ha he haA heE S T hd hS hT k.val + intro hk + exact k.property.2 (Finset.mem_erase.mpr ⟨k.property.1,hk⟩) + let f : small → large := fun k => ⟨k.val,hmap k⟩ + have hi : Function.Injective f := by + intro x y h; exact Subtype.ext (congrArg (fun z : large => z.val) h) + have hs := secondPairRadialMode_summable_norm p hp hg hinj hc S T e he W Y hY + calc + _ ≤ ∑' k : large, ‖secondPairRadialMode p hp hg hinj S T e k.val W Y‖ := + (hs.subtype small).tsum_le_tsum_of_inj f hi (fun _ _ => norm_nonneg _) + (fun _ => le_rfl) (hs.subtype large) + _ ≤ _ := hb S T e he W Y H hY hH + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ClippedChild.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ClippedChild.lean new file mode 100644 index 0000000000000000000000000000000000000000..682ac74fb616922a165dfb260298a5df9dc301be --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ClippedChild.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Descent.ClippedUniform +import OAI.NumberTheory.DirichletL.Descent.SecondCellPhysical +import OAI.NumberTheory.DirichletL.Inversion.AmbientProfileTower + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge + +namespace SevenEighths.InverseMoment +open InverseInitialClippedColumns JointLogSeparation InverseAmbientProfileTower +open InverseSecondSourceBlocks +local notation "O"=>ActualEisensteinCubic.O + +def secondChildHeight (right:Bool)(t:Ambient (Fin 6)):ℝ := + if right then profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2 5 + else -profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2 4 + +theorem second_child_height_budget (J:ℕ)(right:Bool)(t:Ambient (Fin 6)): + (1+‖secondChildHeight right t‖)^J≤tripleHeight J t.1*coordinateHeight J t.2:=by + cases right + · have h:=pow_le_pow_left₀ (by positivity : 0≤1+‖inheritedLeft 4 t‖) (inheritedLeft_bound 4 t) J + rw [←ambientWeight_eq_pow] at h + simpa only [secondChildHeight,Bool.false_eq_true,ite_false,norm_neg, + second_inherited_left_eq,ambientWeight,tripleHeight,coordinateHeight] using h + · have h:=pow_le_pow_left₀ (by positivity : 0≤1+‖inheritedRight 5 t‖) (inheritedRight_bound 5 t) J + rw [←ambientWeight_eq_pow] at h + simpa only [secondChildHeight,ite_true,second_inherited_right_eq,norm_neg, + ambientWeight,tripleHeight,coordinateHeight] using h + +theorem canonical_actual_child_uniform + (W:ℝ→ℂ)(lo hi b:ℝ)(hlo:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(_hD:∀f∈labels,0≤D f) + (Z X F E:ℝ)(d:BlockIndex)(right:Bool)(t:Ambient (Fin 6)), + 1ActualEisensteinCubic.O +variable {ι σ:Type*}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem normalized_energy_vector + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(hD:∀f∈labels,0≤D f) + (W:ℝ→ℂ)(X Z F:ℝ): + (∑v:labels×rows,‖(Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)* + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator v.1) v.2 slots lists a W X‖^2)= + normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D W X Z F:=by + unfold normalizedColumnEnergy + rw [Fintype.sum_prod_type,←Finset.sum_coe_sort labels] + apply Finset.sum_congr rfl + intro f hf + rw [←Finset.sum_coe_sort rows,Finset.mul_sum] + apply Finset.sum_congr rfl + intro k hk + simp only [mul_assoc,norm_mul,mul_pow,Complex.norm_real, + Real.norm_of_nonneg (Real.sqrt_nonneg _),Real.sq_sqrt (hD f f.property)] + +theorem canonical_clipped_energy + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(hD:∀f∈labels,0≤D f) + (W:ℝ→ℂ)(lo hi:ℝ)(hlo:0(Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)* + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator v.1) v.2 slots lists a + (childLogTest wFresh (θ+t)) X + have hint(v:labels×rows):Integrable (fun t:ℝ=>b t*phi v t):=by + convert (canonical_clipped_mode_integrable p hp hcop hg hpr pool Ψ m (primaryGenerator v.1) v.2 + slots lists a g wFresh c θ X).const_mul ((Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)) using 1 + funext t + dsimp [b,phi] + ring + have hbound(t:ℝ):(∑v:labels×rows,‖phi v t‖^2)≤ + (E*(1+‖θ‖)^(2*J))*((1+‖t‖)^J)^2:=by + dsimp only [phi] + rw [normalized_energy_vector p hp hcop hg pool Ψ m slots lists a labels rows D hD] + apply (he (θ+t)).trans + have hb:1+‖θ+t‖≤(1+‖θ‖)*(1+‖t‖):=by + have hh:=norm_add_le θ t + nlinarith [mul_nonneg (norm_nonneg θ) (norm_nonneg t)] + calc + _≤E*((1+‖θ‖)*(1+‖t‖))^(2*J):=mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (by positivity) hb _) hE + _= _:=by rw [mul_pow,pow_mul];ring + have hden:Integrable (fun t:ℝ=>(1+‖t‖)^J*‖b t‖):=by + simpa only [b,density_norm] using AnalyticBridge.schwartz_fourier_one_plus_integrable g J + have hh:=CenteredMomentHeckeWindowEnergy.finite_weighted_integral_energy b phi + (fun t:ℝ=>(1+‖t‖)^J) (by intro t;positivity) + (E*(1+‖θ‖)^(2*J)) (by positivity) hden hint hbound + have heq(v:labels×rows): (∫t:ℝ,b t*phi v t)= + (Real.sqrt (D v.1):ℂ)*((Z^(-F/2):ℝ):ℂ)* + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m (primaryGenerator v.1) v.2 slots lists a + (clippedTest W c θ) X:=by + rw [canonical_clipped_fourier p hp hcop hg hpr pool Ψ m (primaryGenerator v.1) v.2 + slots lists a W lo hi hlo hs hW wFresh c θ X hc hX hw,←integral_const_mul] + apply integral_congr_ae + filter_upwards with t + dsimp [b,phi,g] + ring + simp_rw [heq] at hh + rw [normalized_energy_vector p hp hcop hg pool Ψ m slots lists a labels rows D hD] at hh + simpa only [b,density_norm,g] using hh + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ClippedFourier.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ClippedFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..0f8a71fb4305f9f4c300e0a41b4ee1628ed6edd5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ClippedFourier.lean @@ -0,0 +1,126 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialOverlapFourier +import OAI.NumberTheory.DirichletL.Inversion.InitialClippedColumns +import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge + +namespace SevenEighths.InverseMoment +open InverseInitialClippedColumns InverseInitialOverlapFourier SecondPassIntegration JointLogSeparation +open ActualEisensteinCubic FirstPassCubeLabels CompletedGauss +local notation "O"=>ActualEisensteinCubic.O + +theorem clipped_fixed_window (W:ℝ→ℂ) (lo hi b:ℝ) (hlo:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem canonical_clipped_mode_integrable + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Ψ:O→*ℂ)(m f k:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (g:𝓢(ℝ,ℂ))(wFresh:ℝ→ℂ)(c θ X:ℝ): + Integrable (fun t:ℝ=>density g (Real.log c) t* + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a (childLogTest wFresh (θ+t)) X):=by + simp_rw [finiteCanonicalMarkedRow_actual_columns p hp hcop hg hpr] + simp only [Finset.mul_sum] + apply integrable_finsetSum + intro U hU + convert fourier_phase_integrable g (Real.log c+Real.log (primeProductNorm p U/X)) + (columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) (Ideal.span {∏i∈U,p i})* + primeMark slots lists a U*wFresh (primeProductNorm p U/X)*logPhase θ (Real.log (primeProductNorm p U/X))) using 1 + funext t + simp only [density,childLogTest,logPhase_add_frequency,logPhase_add] + ring + +theorem canonical_clipped_fourier + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Ψ:O→*ℂ)(m f k:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (W:ℝ→ℂ)(lo hi:ℝ)(hlo:0 + density (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) (Real.log c) t* + (columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) (Ideal.span {∏i∈U,p i})* + (primeMark slots lists a U*childLogTest wFresh (θ+t) (primeProductNorm p U/X)))):=by + convert fourier_phase_integrable (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) + (Real.log c+Real.log (primeProductNorm p U/X)) + (columnWeight (CanonicalRowCompletion.rowTwist Ψ m f k) (Ideal.span {∏i∈U,p i})* + primeMark slots lists a U*wFresh (primeProductNorm p U/X)*logPhase θ (Real.log (primeProductNorm p U/X))) using 1 + funext t + simp only [density,childLogTest,logPhase_add_frequency,logPhase_add] + ring + rw [integral_finsetSum _ (fun U _=>hints U)] + apply Finset.sum_congr rfl + intro U hU + rw [clipped_test_fourier W lo hi hlo hs hW wFresh c θ _ hc + (div_pos (FirstPassCubeLabels.primeProductNorm_pos p hp U) hX) (hwFresh _ (div_pos (FirstPassCubeLabels.primeProductNorm_pos p hp U) hX))] + rw [←integral_const_mul,←integral_const_mul] + apply integral_congr_ae + filter_upwards with t + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ClippedUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ClippedUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..7f8646e8a9874416668e7c9719d604e5ad0b2aa4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ClippedUniform.lean @@ -0,0 +1,48 @@ +import OAI.NumberTheory.DirichletL.Descent.ClippedEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge + +namespace SevenEighths.InverseMoment +open InverseInitialClippedColumns +local notation "O"=>ActualEisensteinCubic.O + +theorem canonical_clipped_uniform + (W:ℝ→ℂ)(lo hi b:ℝ)(hlo:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (labels:Finset (Ideal O))(rows:Finset O)(D:Ideal O→ℝ)(_hD:∀f∈labels,0≤D f) + (c θ X Z F E:ℝ),1≤c→c≤b→0 ActualEisensteinCubic.O + +theorem common_measure_energy {Ω κ : Type*} [MeasurableSpace Ω] [Fintype κ] + (μ : Measure Ω) (b : Ω → ℂ) (φ : κ → Ω → ℂ) (E : ℝ) (hE : 0 ≤ E) + (hb : Integrable (fun t => ‖b t‖) μ) + (hφ : ∀ k, Integrable (fun t => b t * φ k t) μ) + (hbound : ∀ t, (∑ k, ‖φ k t‖ ^ 2) ≤ E) : + (∑ k, ‖∫ t, b t * φ k t ∂μ‖ ^ 2) ≤ E * (∫ t, ‖b t‖ ∂μ) ^ 2 := by + let e := PiLp.continuousLinearEquiv 2 ℂ (fun _ : κ => ℂ) + let F : Ω → EuclideanSpace ℂ κ := fun t => e.symm (fun k => b t * φ k t) + have hF (t : Ω) : ‖F t‖ ≤ ‖b t‖ * Real.sqrt E := by + apply (sq_le_sq₀ (norm_nonneg _) (by positivity)).mp + rw [EuclideanSpace.norm_sq_eq, mul_pow, Real.sq_sqrt hE] + change (∑ k, ‖b t * φ k t‖ ^ 2) ≤ ‖b t‖ ^ 2 * E + simp only [norm_mul, mul_pow, ← Finset.mul_sum] + exact mul_le_mul_of_nonneg_left (hbound t) (sq_nonneg _) + have he : (∫ t, F t ∂μ) = e.symm (fun k => ∫ t, b t * φ k t ∂μ) := by + rw [show F = (fun t => e.symm (fun k => b t * φ k t)) from rfl, + e.symm.integral_comp_comm] + congr 1 + funext k + exact eval_integral hφ k + have hn : ‖e.symm (fun k => ∫ t, b t * φ k t ∂μ)‖ ≤ + (∫ t, ‖b t‖ ∂μ) * Real.sqrt E := by + rw [← he, ← integral_mul_const] + exact norm_integral_le_of_norm_le (hb.mul_const _) (Filter.Eventually.of_forall hF) + have hs := pow_le_pow_left₀ (norm_nonneg _) hn 2 + rw [EuclideanSpace.norm_sq_eq, mul_pow, Real.sq_sqrt hE] at hs + simpa [e, mul_comm] using hs + +theorem integrated_hybridRow_energy {Ω : Type*} [MeasurableSpace Ω] + (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → + ∀ (rows nset bset Pset : Finset (Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ v ∈ bset, primaryGenerator v ≠ 0 ∧ (Ideal.absNorm v : ℝ) ≤ B) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + ∀ (μ : Measure Ω) (b : Ω → ℂ) + (a : Ω → Ideal Eis → ℂ) (beta : Ω → Ideal Eis → Ideal Eis → ℂ) + (rowPhase : Ideal Eis → Ω → ℂ) (m : ℂ), + Integrable b μ → + (∀ P ∈ Pset, AEStronglyMeasurable (fun t => a t P) μ) → + (∀ n ∈ nset, ∀ v ∈ bset, AEStronglyMeasurable (fun t => beta t n v) μ) → + (∀ k ∈ rows, AEStronglyMeasurable (rowPhase k) μ) → + (∀ t, ∀ P ∈ Pset, ‖a t P‖ ≤ 1) → + (∀ t, ∀ n ∈ nset, ∀ v ∈ bset, ‖beta t n v‖ ≤ 1) → + (∀ k ∈ rows, ∀ t, ‖rowPhase k t‖ ≤ 1) → + (∑ k ∈ rows, ‖m * ∫ t, b t * (rowPhase k t * + hybridRow Pset nset bset (a t) (beta t) k) ∂μ‖ ^ 2) ≤ + ‖m‖ ^ 2 * (C * (K * N * B) ^ ε * (K + N * B) * B * + CubicSieve.sieveNorm N (2 * L)) * (∫ t, ‖b t‖ ∂μ) ^ 2 := by + obtain ⟨C, hC, he⟩ := hybridRow_energy_sieve_norm ε hε + refine ⟨C, hC, ?_⟩ + intro K N B L hK hN hB rows nset bset Pset hrows hn hv hP μ b a beta phase m + hb haM hbetaM hphaseM ha hbeta hphase + let E := C * (K * N * B) ^ ε * (K + N * B) * B * CubicSieve.sieveNorm N (2 * L) + have hE : 0 ≤ E := by + have hs : 0 ≤ CubicSieve.sieveNorm N (2 * L) := sq_nonneg _ + dsimp only [E] + positivity + let φ : rows → Ω → ℂ := fun k t => phase k t * hybridRow Pset nset bset (a t) (beta t) k + have hbound (t : Ω) : (∑ k, ‖φ k t‖ ^ 2) ≤ E := by + calc + _ ≤ ∑ k : rows, ‖hybridRow Pset nset bset (a t) (beta t) k‖ ^ 2 := by + apply Finset.sum_le_sum + intro k hk + apply pow_le_pow_left₀ (norm_nonneg _) + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (hphase k k.property t) + _ = ∑ k ∈ rows, ‖hybridRow Pset nset bset (a t) (beta t) k‖ ^ 2 := by + exact Finset.sum_coe_sort rows (fun k : Ideal Eis => ‖hybridRow Pset nset bset (a t) (beta t) k‖ ^ 2) + _ ≤ E := he K N B L hK hN hB rows nset bset Pset (a t) (beta t) + hrows hn hv hP (ha t) (hbeta t) + have hφM (k : rows) : AEStronglyMeasurable (φ k) μ := by + apply (hphaseM k k.property).mul + unfold hybridRow + apply Finset.aestronglyMeasurable_fun_sum + intro P hPS + simp only [div_eq_mul_inv] + apply ((haM P hPS).mul_const _ |>.mul_const _).mul + unfold hybridInner + apply Finset.aestronglyMeasurable_fun_sum + intro n hns + apply Finset.aestronglyMeasurable_fun_sum + intro v hvs + exact (((hbetaM n hns v hvs).mul_const _).mul_const _).mul_const _ + have hpoint (k : rows) (t : Ω) : ‖φ k t‖ ≤ Real.sqrt E := by + apply (Real.le_sqrt (norm_nonneg _) hE).mpr + exact (Finset.single_le_sum (fun j _ => sq_nonneg ‖φ j t‖) + (Finset.mem_univ k)).trans (hbound t) + have hint (k : rows) : Integrable (fun t => b t * φ k t) μ := + hb.mul_bdd (hφM k) (Filter.Eventually.of_forall (hpoint k)) + have hm := mul_le_mul_of_nonneg_left + (common_measure_energy μ b φ E hE hb.norm hint hbound) (sq_nonneg ‖m‖) + simp only [norm_mul, mul_pow, ← Finset.mul_sum] at hm ⊢ + rw [mul_assoc] + rw [show (∑ k : rows, ‖∫ t, b t * φ k t ∂μ‖ ^ 2) = + ∑ k ∈ rows, ‖∫ t, b t * (phase k t * hybridRow Pset nset bset (a t) (beta t) k) ∂μ‖ ^ 2 from + Finset.sum_coe_sort rows (fun k : Ideal Eis => + ‖∫ t, b t * (phase k t * hybridRow Pset nset bset (a t) (beta t) k) ∂μ‖ ^ 2)] at hm + exact hm + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CompleteMarkedPool.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CompleteMarkedPool.lean new file mode 100644 index 0000000000000000000000000000000000000000..efdb7e407a50924d08cfb0694ef8d793b302dcc0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CompleteMarkedPool.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Descent.CompletePool +import OAI.NumberTheory.DirichletL.Descent.ReopenedMarks + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +local notation "O" => ActualEisensteinCubic.O + +def indexedIdealMark {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (primes : ι→Ideal O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (I : Ideal O) : ℂ := + ∏j∈slots,∑i∈lists j,if primes i∣I then a j i else 0 + +theorem complete_pool_mark {σ : Type*} [DecidableEq σ] + (F : Finset (Ideal O)) (hF : ∀ I∈F,Admissible I) + (slots : Finset σ) (lists : σ→Finset (primePool F)) (a : σ→primePool F→ℂ) + (T : Finset (primePool F)) : + indexedIdealMark (fun i:primePool F=>i.val) slots lists a (∏i∈T,i.val) = + primeMark slots lists a T := by + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + have hinj : Function.Injective (fun i:primePool F=>Ideal.span {poolPrimary F i}) := by + intro i j h + dsimp only at h + rw [poolPrimary_span F hF i,poolPrimary_span F hF j] at h + exact Subtype.ext h + have he := reopened_whole_mark_divisibility (poolPrimary F) hinj slots lists a T 0 + simp only [Finsupp.support_zero,Finset.union_empty,primeProduct,Finset.prod_empty, + Ideal.span_singleton_one,←Ideal.one_eq_top,one_pow,mul_one] at he + have hspan : Ideal.span {∏i∈T,poolPrimary F i}=∏i∈T,i.val := by + rw [FiniteGaussPhase.span_finset_prod] + exact Finset.prod_congr rfl (fun i _=>poolPrimary_span F hF i) + rw [hspan] at he + simpa only [indexedIdealMark,poolPrimary_span F hF] using he.symm + +theorem finiteCanonicalMarkedRow_complete_global {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Ψ : O →* ℂ) (m f z : O) (W : ℝ→ℂ) (b X : ℝ) (hX : 0by rw [poolPrimary_span F hF i];infer_instance + finiteCanonicalMarkedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m f z slots lists a W X = + ∑' I:Ideal O,columnWeight (rowTwist Ψ (m*excludedGenerator S) f z) I* + indexedIdealMark (fun i:primePool F=>i.val) slots lists a I*W ((Ideal.absNorm I:ℝ)/X) := by + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + have hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + have he := marked_complete_pool_eq_global S D hbad hSp Ψ m f z W b X hX hW hD + (indexedIdealMark (fun i:primePool F=>i.val) slots lists a) + dsimp only at he + have hmark : (fun T:Finset (primePool F)=>W (primeProductNorm (poolPrimary F) T/X)* + indexedIdealMark (fun i:primePool F=>i.val) slots lists a (∏i∈T,i.val)) = + (fun T=>primeMark slots lists a T*W (primeProductNorm (poolPrimary F) T/X)) := by + funext T + rw [complete_pool_mark F hF slots lists a T,mul_comm] + rw [hmark] at he + unfold finiteCanonicalMarkedRow + calc + _ = _ := he + _ = _ := tsum_congr (fun I=>by ring) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CompletePool.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CompletePool.lean new file mode 100644 index 0000000000000000000000000000000000000000..c28e657c77d6892856c50465fcfe429f5be25a46 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CompletePool.lean @@ -0,0 +1,100 @@ +import OAI.NumberTheory.DirichletL.Descent.CompletionSupport +import OAI.NumberTheory.DirichletL.Descent.Canonical + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +local notation "O" => ActualEisensteinCubic.O + +theorem marked_selected_column_sum (F : Finset (Ideal O)) + (hF : ∀I∈F,CanonicalQuadraticSieve.Admissible I) + (Ψ : O →* ℂ) (m f z : O) (W : ℕ → ℂ) (d : Ideal O → ℂ) : + let p := CanonicalQuadraticSieve.poolPrimary F + let hp := CanonicalQuadraticSieve.poolPrimary_ne_zero F hF + letI : ∀i:ConcretePrimeRowBridge.primePool F,(Ideal.span {p i}).IsMaximal := + fun i=>by rw [CanonicalQuadraticSieve.poolPrimary_span F hF i]; infer_instance + let hcop := CanonicalQuadraticSieve.poolPrimary_coprime F hF + let hg := CanonicalQuadraticSieve.poolPrimary_good F hF + (∑I∈F,columnWeight (rowTwist Ψ m f z) I * W (Ideal.absNorm I)*d I) = + ∑S∈(Finset.univ:Finset (ConcretePrimeRowBridge.primePool F)).powerset, + canonicalSourceCoefficient p hp hcop hg Ψ m f (fun T=>InitialMeanSquare.selectedIdealTest F W T*d (∏i∈T,i.val)) S * + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z := by + dsimp only + let : ∀i:ConcretePrimeRowBridge.primePool F, + (Ideal.span {CanonicalQuadraticSieve.poolPrimary F i}).IsMaximal := + fun i=>by rw [CanonicalQuadraticSieve.poolPrimary_span F hF i]; infer_instance + rw [InitialMeanSquare.sum_selected_ideals F (fun I hI=>(hF I hI).2.1)] + apply Finset.sum_congr rfl + intro S hS + have hspan : (Ideal.span {∏i∈S,CanonicalQuadraticSieve.poolPrimary F i}) = ∏i∈S,i.val := by + rw [FiniteGaussPhase.span_finset_prod] + exact Finset.prod_congr rfl (fun i _=>CanonicalQuadraticSieve.poolPrimary_span F hF i) + have hpr (i:ConcretePrimeRowBridge.primePool F) : + ConcretePrimeRowBridge.goodLambda^2∣CanonicalQuadraticSieve.poolPrimary F i-1 := + (primaryPrime_spec i.val (CanonicalQuadraticSieve.poolPrimary_ne_zero F hF i)).2.2.2 + have h := columnWeight_finset (CanonicalQuadraticSieve.poolPrimary F) + (CanonicalQuadraticSieve.poolPrimary_ne_zero F hF) + (CanonicalQuadraticSieve.poolPrimary_coprime F hF) + (CanonicalQuadraticSieve.poolPrimary_good F hF) hpr S Ψ m f z + (fun T=>InitialMeanSquare.selectedIdealTest F W T*d (∏i∈T,i.val)) + rw [hspan] at h + rw [←h] + unfold InitialMeanSquare.selectedIdealTest + split_ifs <;> simp ; ring + +theorem marked_weighted_column_tsum_eq (S : Finset (Ideal O)) (D : ℕ) + (hSp : ∀ P∈S,Prime P) (Ψ : O →* ℂ) (m f z : O) (hm : ∀ P∈S,m∈P) + (W : ℝ → ℂ) (b X : ℝ) (hX : 0by rw [poolPrimary_span F hF i];infer_instance + fixedChildRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Ψ m + (fun T=>W (primeProductNorm (poolPrimary F) T/X)*d (∏i∈T,i.val)) f z = + ∑' I:Ideal O,columnWeight (rowTwist Ψ (m*excludedGenerator S) f z) I* + W ((Ideal.absNorm I:ℝ)/X)*d I := by + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + have hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + symm + rw [marked_weighted_column_tsum_eq S D hSp Ψ (m*excludedGenerator S) f z + (fun P hP=>P.mul_mem_left m (excludedGenerator_mem S hP)) W b X hX hW hD d] + have he := marked_selected_column_sum F hF Ψ (m*excludedGenerator S) f z (fun n=>W (n/X)) d + dsimp only at he + rw [he] + unfold fixedChildRow + apply Finset.sum_congr rfl + intro T hT + rw [canonicalSourceCoefficient_fixed_mask _ _ _ _ Ψ m (excludedGenerator S) f _ T + (outside_pool_fixed_mask S D hbad hSp T)] + have ht := InitialMeanSquare.selectedIdealTest_outside S D hbad hSp W b X hX hW hD T + simp only [canonicalSourceCoefficient,secondChildColumn] + rw [ht] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CompletedReopening.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CompletedReopening.lean new file mode 100644 index 0000000000000000000000000000000000000000..5e0f9e7b737524049a171bdead345a29ebf74023 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CompletedReopening.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Descent.CompleteMarkedPool + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +local notation "O" => ActualEisensteinCubic.O + +def outsideCanonicalMarkedRow {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) + (Ψ : O →* ℂ) (m f z : O) (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) + (W : ℝ→ℂ) (X : ℝ) : ℂ := + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + let hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + letI : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + finiteCanonicalMarkedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Ψ m f z slots lists a W X + +theorem outsideCanonicalMarkedRow_cube_split {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Ψ : O →* ℂ) (m f z : O) (W : ℝ→ℂ) (hWc : HasCompactSupport W) + (b X H₀ : ℝ) (hX : 0i.val) slots lists a + (Real.sqrt X:ℂ)⁻¹*outsideCanonicalMarkedRow S D hbad Ψ m f z slots lists a W X = + (∑' H:Ideal O,if (Ideal.absNorm H:ℝ)mark (H^3*I)) else 0) + + ∑ B∈outsideIdealsUpTo S D,largeCubeCoefficient H₀ B* + ∑' I:Ideal O,summand Ψrow W X I B*mark (I*B^3) := by + dsimp only + unfold outsideCanonicalMarkedRow + rw [finiteCanonicalMarkedRow_complete_global S D hbad hSp Ψ m f z W b X hX hW hD] + rw [marked_completed_cube_inverse_split _ W hWc X H₀ hX] + rw [marked_large_cube_sum_finite S D hSp Ψ (m*excludedGenerator S) f z + (fun P hP=>P.mul_mem_left m (excludedGenerator_mem S hP)) W hWc b X H₀ hX hW hD] + +theorem outsideCanonicalMarkedRow_reopened {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Ψ : O →* ℂ) (m f z : O) (W : ℝ→ℂ) (hWc : HasCompactSupport W) + (b X H₀ : ℝ) (hX : 0i.val) slots lists a + (Real.sqrt X:ℂ)⁻¹*outsideCanonicalMarkedRow S D hbad Ψ m f z slots lists a W X = + (∑' H:Ideal O,if (Ideal.absNorm H:ℝ)mark (H^3*I)) else 0) + + ∑ B∈outsideIdealsUpTo S D, + (largeCubeCoefficient H₀ B*cubeWeight Ψrow B* + (Real.sqrt (X/(Ideal.absNorm B:ℝ)^3):ℂ)⁻¹)* + ∑' I:Ideal O,columnWeight Ψrow I*W ((Ideal.absNorm I:ℝ)/(X/(Ideal.absNorm B:ℝ)^3))*mark (I*B^3) := by + rw [outsideCanonicalMarkedRow_cube_split S D hbad hSp Ψ m f z W hWc b X H₀ hX hW hD] + dsimp only + congr 1 + apply Finset.sum_congr rfl + intro B hB + rw [marked_inner_completed_sum _ W X hX B (outsideIdealsUpTo_ne_bot S D B hB)] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Completion.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Completion.lean new file mode 100644 index 0000000000000000000000000000000000000000..17f1f38b6485d1960f07b9a622757d48db6680d1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Completion.lean @@ -0,0 +1,196 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Descent.IdealMasks + +namespace OAI + +namespace SevenEighths.InverseMoment + +noncomputable section + +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss + +local notation "Eis" => ActualEisensteinCubic.O + +def markedCompletedT (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (d : Ideal Eis → ℂ) : ℂ := + ∑' I : Ideal Eis, ∑' J : Ideal Eis, summand Ψ W X I J * d (I * J ^ 3) + +theorem markedCompletedT_one (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) : + markedCompletedT Ψ W X (fun _ => 1) = completedT Ψ W X := by + simp only [markedCompletedT, mul_one, completedT] + +theorem markedCompletedT_congr_nonzero (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (d e : Ideal Eis → ℂ) (h : ∀ A ≠ 0, d A = e A) : + markedCompletedT Ψ W X d = markedCompletedT Ψ W X e := by + apply tsum_congr + intro I + apply tsum_congr + intro J + by_cases hI : I = 0 + · simp only [hI, summand_zero_left, zero_mul] + by_cases hJ : J = 0 + · simp only [hJ, summand_zero_right, zero_mul] + rw [h (I * J ^ 3) (mul_ne_zero hI (pow_ne_zero 3 hJ))] + +theorem markedCompletedT_summable (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) (d : Ideal Eis → ℂ) : + Summable (fun p : Ideal Eis × Ideal Eis => + summand Ψ W X p.1 p.2 * d (p.1 * p.2 ^ 3)) := by + apply summable_of_hasFiniteSupport + apply (completedT_finite_support Ψ W hW X hX).subset + intro p hp hz + exact hp (by simp only [hz, zero_mul]) + +theorem markedCompletedT_eq_tsum (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) (d : Ideal Eis → ℂ) : + markedCompletedT Ψ W X d = ∑' p : Ideal Eis × Ideal Eis, + summand Ψ W X p.1 p.2 * d (p.1 * p.2 ^ 3) := + (markedCompletedT_summable Ψ W hW X hX d).tsum_prod.symm + +theorem markedCompletedT_const_mul (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (c : ℂ) (d : Ideal Eis → ℂ) : + markedCompletedT Ψ W X (fun A => c * d A) = c * markedCompletedT Ψ W X d := by + simp only [markedCompletedT, mul_left_comm _ c, tsum_mul_left] + +theorem markedCompletedT_finset_sum {ι : Type*} (s : Finset ι) + (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) + (X : ℝ) (hX : 0 < X) (d : ι → Ideal Eis → ℂ) : + markedCompletedT Ψ W X (fun A => ∑ i ∈ s, d i A) = + ∑ i ∈ s, markedCompletedT Ψ W X (d i) := by + simp only [markedCompletedT_eq_tsum Ψ W hW X hX, Finset.mul_sum] + exact Summable.tsum_finsetSum (fun i _ => markedCompletedT_summable Ψ W hW X hX (d i)) + +theorem markedCompletedT_prime_priority {σ : Type*} [DecidableEq σ] + (slots : Finset σ) (L : σ → Finset (Ideal Eis)) + (a : σ → Ideal Eis → ℂ) (H : Ideal Eis) (hH : H ≠ 0) + (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) + (X : ℝ) (hX : 0 < X) : + markedCompletedT Ψ W X + (fun A => primeMark slots L a (IdealMobiusDivisorSum.primeSupport (H ^ 3 * A))) = + ∑ J ∈ slots.powerset, + primeMark J L a (IdealMobiusDivisorSum.primeSupport H) * + markedCompletedT Ψ W X (fun A => + primeMark (slots \ J) + (fun i => L i \ IdealMobiusDivisorSum.primeSupport H) a + (IdealMobiusDivisorSum.primeSupport A)) := by + have hmark (A : Ideal Eis) (hA : A ≠ 0) : + primeMark slots L a (IdealMobiusDivisorSum.primeSupport (H ^ 3 * A)) = + ∑ J ∈ slots.powerset, + primeMark J L a (IdealMobiusDivisorSum.primeSupport H) * + primeMark (slots \ J) + (fun i => L i \ IdealMobiusDivisorSum.primeSupport H) a + (IdealMobiusDivisorSum.primeSupport A) := by + rw [mul_comm (H ^ 3) A, ideal_primeSupport_mul_cube A H hA hH, + Finset.union_comm, primeMark_priority] + simp only [primeMark_residual_lists] + rw [markedCompletedT_congr_nonzero Ψ W X _ _ hmark, + markedCompletedT_finset_sum slots.powerset Ψ W hW X hX] + simp only [markedCompletedT_const_mul] + +def markedExpandedTerm (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (d : Ideal Eis → ℂ) (I H J : Ideal Eis) : ℂ := + expandedTerm Ψ W X I H J * d (I * (H * J) ^ 3) + +theorem markedExpandedTerm_finite_support (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) (d : Ideal Eis → ℂ) : + (Function.support (fun p : Ideal Eis × Ideal Eis × Ideal Eis => + markedExpandedTerm Ψ W X d p.1 p.2.1 p.2.2)).Finite := by + apply (finite_support_expandedTerm Ψ W hW X hX).subset + intro p hp hz + apply hp + simp only [markedExpandedTerm, hz, zero_mul] + +theorem markedExpandedTerm_scale (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (d : Ideal Eis → ℂ) (I H J : Ideal Eis) : + (UniqueFactorizationMonoid.moebius H : ℂ) * cubeWeight Ψ H * + (summand Ψ W (X / (Ideal.absNorm H : ℝ) ^ 3) I J * d (H ^ 3 * (I * J ^ 3))) = + markedExpandedTerm Ψ W X d I H J := by + rw [← mul_assoc, expandedTerm_scale] + unfold markedExpandedTerm + congr 2 + ring + +theorem weighted_markedCompletedT_reopen (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (d : Ideal Eis → ℂ) (H : Ideal Eis) : + (UniqueFactorizationMonoid.moebius H : ℂ) * cubeWeight Ψ H * + markedCompletedT Ψ W (X / (Ideal.absNorm H : ℝ) ^ 3) (fun A => d (H ^ 3 * A)) = + ∑' I : Ideal Eis, ∑' J : Ideal Eis, markedExpandedTerm Ψ W X d I H J := by + simp only [markedCompletedT, ← tsum_mul_left, markedExpandedTerm_scale] + +theorem marked_cube_inner_inverse (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) + (d : Ideal Eis → ℂ) (I : Ideal Eis) : + (∑' H : Ideal Eis, ∑' J : Ideal Eis, markedExpandedTerm Ψ W X d I H J) = + (columnWeight Ψ I / (Real.sqrt (Ideal.absNorm I : ℝ) : ℂ) * + Vstar W ((Ideal.absNorm I : ℝ) / X)) * d I := by + let f : Ideal Eis → ℂ := fun B => + columnWeight Ψ I / (Real.sqrt (Ideal.absNorm I : ℝ) : ℂ) * + Vstar W ((Ideal.absNorm I : ℝ) * (Ideal.absNorm B : ℝ) ^ 3 / X) * d (I * B ^ 3) + have heq (H J : Ideal Eis) : + (UniqueFactorizationMonoid.moebius H : ℂ) * cubeWeight Ψ (H * J) * f (H * J) = + markedExpandedTerm Ψ W X d I H J := by + simp only [f, markedExpandedTerm, expandedTerm, map_mul, Nat.cast_mul, mul_pow, + mul_assoc] + have hf := markedExpandedTerm_finite_support Ψ W hW X hX d + have hp : (Function.support (fun p : Ideal Eis × Ideal Eis => + markedExpandedTerm Ψ W X d I p.1 p.2)).Finite := by + change ((fun p : Ideal Eis × Ideal Eis => (I, p)) ⁻¹' + Function.support (fun p : Ideal Eis × Ideal Eis × Ideal Eis => + markedExpandedTerm Ψ W X d p.1 p.2.1 p.2.2)).Finite + exact Set.Finite.preimage (fun a _ b _ hab => (Prod.mk.inj hab).2) hf + have hgeneric := ideal_cube_convolution (cubeWeight Ψ) (cubeWeight_zero Ψ) f + (by simpa only [heq] using hp) + simpa only [heq, f, map_one, Nat.cast_one, one_pow, mul_one] using hgeneric + +theorem marked_cube_inverse_vstar (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) (d : Ideal Eis → ℂ) : + (∑' H : Ideal Eis, (UniqueFactorizationMonoid.moebius H : ℂ) * cubeWeight Ψ H * + markedCompletedT Ψ W (X / (Ideal.absNorm H : ℝ) ^ 3) (fun A => d (H ^ 3 * A))) = + ∑' I : Ideal Eis, (columnWeight Ψ I / (Real.sqrt (Ideal.absNorm I : ℝ) : ℂ) * + Vstar W ((Ideal.absNorm I : ℝ) / X)) * d I := by + let F : Ideal Eis × Ideal Eis × Ideal Eis → ℂ := + fun p => markedExpandedTerm Ψ W X d p.1 p.2.1 p.2.2 + have hF : Summable F := + summable_of_hasFiniteSupport (markedExpandedTerm_finite_support Ψ W hW X hX d) + let e : (Ideal Eis × Ideal Eis × Ideal Eis) ≃ (Ideal Eis × Ideal Eis × Ideal Eis) := { + toFun := fun p => (p.2.1, p.1, p.2.2) + invFun := fun p => (p.2.1, p.1, p.2.2) + left_inv := by rintro ⟨I, H, J⟩; rfl + right_inv := by rintro ⟨I, H, J⟩; rfl } + have hswap : Summable (fun p => F (e p)) := e.summable_iff.mpr hF + calc + _ = ∑' H : Ideal Eis, ∑' I : Ideal Eis, ∑' J : Ideal Eis, + markedExpandedTerm Ψ W X d I H J := by + simp only [weighted_markedCompletedT_reopen] + _ = ∑' p : Ideal Eis × Ideal Eis × Ideal Eis, F (e p) := by + rw [hswap.tsum_prod] + apply tsum_congr + intro H + exact (hswap.prod_factor H).tsum_prod.symm + _ = ∑' p : Ideal Eis × Ideal Eis × Ideal Eis, F p := e.tsum_eq F + _ = ∑' I : Ideal Eis, ∑' H : Ideal Eis, ∑' J : Ideal Eis, + markedExpandedTerm Ψ W X d I H J := by + rw [hF.tsum_prod] + apply tsum_congr + intro I + exact (hF.prod_factor I).tsum_prod + _ = _ := tsum_congr (marked_cube_inner_inverse Ψ W hW X hX d) + +theorem marked_cube_inverse (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) (d : Ideal Eis → ℂ) : + (Real.sqrt X : ℂ)⁻¹ * + (∑' I : Ideal Eis, columnWeight Ψ I * d I * W ((Ideal.absNorm I : ℝ) / X)) = + ∑' H : Ideal Eis, (UniqueFactorizationMonoid.moebius H : ℂ) * cubeWeight Ψ H * + markedCompletedT Ψ W (X / (Ideal.absNorm H : ℝ) ^ 3) (fun A => d (H ^ 3 * A)) := by + rw [marked_cube_inverse_vstar Ψ W hW X hX d, ← tsum_mul_left] + apply tsum_congr + intro I + rw [vstar_source_normalization Ψ W X hX I] + ring + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CompletionSplit.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CompletionSplit.lean new file mode 100644 index 0000000000000000000000000000000000000000..ac5a4dbe4a76b32c5a333074b088353aea30fa67 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CompletionSplit.lean @@ -0,0 +1,131 @@ +import OAI.NumberTheory.DirichletL.Descent.Completion + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss +local notation "O" => ActualEisensteinCubic.O + +theorem marked_cube_inverse_finite_support (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) (d : Ideal O → ℂ) : + (Function.support (fun H : Ideal O => + (UniqueFactorizationMonoid.moebius H : ℂ) * cubeWeight Ψ H * + markedCompletedT Ψ W (X / (Ideal.absNorm H : ℝ) ^ 3) (fun A => d (H^3*A)))).Finite := by + have hf := markedExpandedTerm_finite_support Ψ W hW X hX d + apply (hf.image (fun p => p.2.1)).subset + intro H hH + by_contra hn + have hzero : ∀ I J, markedExpandedTerm Ψ W X d I H J = 0 := by + intro I J + by_contra hz + exact hn ⟨(I, H, J), hz, rfl⟩ + apply hH + dsimp only + rw [weighted_markedCompletedT_reopen] + simp only [hzero, tsum_zero] + +theorem marked_large_cube_inner_reopen (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0 < X) (d : Ideal O → ℂ) (I : Ideal O) : + (∑' H : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then markedExpandedTerm Ψ W X d I H J else 0) = + ∑' B : Ideal O,largeCubeCoefficient H₀ B*summand Ψ W X I B*d (I*B^3) := by + let f : Ideal O → ℂ := fun B => + columnWeight Ψ I/(Real.sqrt (Ideal.absNorm I : ℝ) : ℂ)* + Vstar W ((Ideal.absNorm I : ℝ)*(Ideal.absNorm B : ℝ)^3/X)*d (I*B^3) + have heq (H J : Ideal O) : + (UniqueFactorizationMonoid.moebius H : ℂ)*cubeWeight Ψ (H*J)*f (H*J)=markedExpandedTerm Ψ W X d I H J := by + simp only [f,markedExpandedTerm,expandedTerm,map_mul,Nat.cast_mul,mul_pow,mul_assoc] + have hf := markedExpandedTerm_finite_support Ψ W hW X hX d + have hp : (Function.support (fun p : Ideal O × Ideal O => markedExpandedTerm Ψ W X d I p.1 p.2)).Finite := by + change ((fun p : Ideal O × Ideal O => (I,p)) ⁻¹' + Function.support (fun p : Ideal O × Ideal O × Ideal O => markedExpandedTerm Ψ W X d p.1 p.2.1 p.2.2)).Finite + exact Set.Finite.preimage (fun a _ b _ hab => (Prod.mk.inj hab).2) hf + have hg := large_cube_convolution H₀ (cubeWeight Ψ) (cubeWeight_zero Ψ) f (by simpa only [heq] using hp) + rw [show (∑' H : Ideal O, ∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then markedExpandedTerm Ψ W X d I H J else 0)= + ∑' B : Ideal O,largeCubeCoefficient H₀ B*cubeWeight Ψ B*f B by simpa only [heq] using hg] + apply tsum_congr + intro B + dsimp [f,summand] + ring + +theorem marked_large_cube_reopen (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0 < X) (d : Ideal O → ℂ) : + (∑' H : Ideal O, if H₀ ≤ (Ideal.absNorm H : ℝ) then + (UniqueFactorizationMonoid.moebius H : ℂ)*cubeWeight Ψ H* + markedCompletedT Ψ W (X/(Ideal.absNorm H : ℝ)^3) (fun A => d (H^3*A)) else 0) = + ∑' I : Ideal O,∑' B : Ideal O,largeCubeCoefficient H₀ B*summand Ψ W X I B*d (I*B^3) := by + let F : Ideal O × Ideal O × Ideal O → ℂ := fun p => + if H₀ ≤ (Ideal.absNorm p.2.1 : ℝ) then markedExpandedTerm Ψ W X d p.1 p.2.1 p.2.2 else 0 + have hF : Summable F := summable_of_hasFiniteSupport + ((markedExpandedTerm_finite_support Ψ W hW X hX d).subset (by + intro p hp + by_contra hn + have he : markedExpandedTerm Ψ W X d p.1 p.2.1 p.2.2=0 := not_ne_iff.mp hn + exact hp (by simp [F,he]))) + let e : (Ideal O × Ideal O × Ideal O) ≃ (Ideal O × Ideal O × Ideal O) := { + toFun := fun p => (p.2.1,p.1,p.2.2) + invFun := fun p => (p.2.1,p.1,p.2.2) + left_inv := by rintro ⟨I,H,J⟩;rfl + right_inv := by rintro ⟨I,H,J⟩;rfl } + have hswap : Summable (fun p => F (e p)) := e.summable_iff.mpr hF + calc + _ = ∑' H : Ideal O,∑' I : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then markedExpandedTerm Ψ W X d I H J else 0 := by + apply tsum_congr + intro H + by_cases h : H₀ ≤ (Ideal.absNorm H : ℝ) + · simp only [ite_eq_left h,weighted_markedCompletedT_reopen] + · simp only [ite_eq_right h,tsum_zero] + _ = ∑' p : Ideal O × Ideal O × Ideal O,F (e p) := by + rw [hswap.tsum_prod] + apply tsum_congr + intro H + exact (hswap.prod_factor H).tsum_prod.symm + _ = ∑' p : Ideal O × Ideal O × Ideal O,F p := e.tsum_eq F + _ = ∑' I : Ideal O,∑' H : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then markedExpandedTerm Ψ W X d I H J else 0 := by + rw [hF.tsum_prod] + apply tsum_congr + intro I + exact (hF.prod_factor I).tsum_prod + _ = _ := tsum_congr (marked_large_cube_inner_reopen Ψ W hW X H₀ hX d) + +theorem marked_completed_cube_inverse_split (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0 < X) (d : Ideal O → ℂ) : + (Real.sqrt X : ℂ)⁻¹*(∑' I : Ideal O,columnWeight Ψ I*d I*W ((Ideal.absNorm I : ℝ)/X)) = + (∑' H : Ideal O, if (Ideal.absNorm H : ℝ) d (H^3*A)) else 0) + + ∑' I : Ideal O,∑' B : Ideal O,largeCubeCoefficient H₀ B*summand Ψ W X I B*d (I*B^3) := by + let f := fun H : Ideal O => (UniqueFactorizationMonoid.moebius H : ℂ)*cubeWeight Ψ H* + markedCompletedT Ψ W (X/(Ideal.absNorm H : ℝ)^3) (fun A => d (H^3*A)) + have hf := marked_cube_inverse_finite_support Ψ W hW X hX d + have hs : Summable (fun H : Ideal O => if (Ideal.absNorm H : ℝ) if H₀ ≤ (Ideal.absNorm H : ℝ) then f H else 0) := + summable_of_hasFiniteSupport (hf.subset (by + intro H hH + by_contra hn + have he : f H=0 := not_ne_iff.mp hn + exact hH (by simp only [he,ite_self]))) + rw [marked_cube_inverse Ψ W hW X hX d,←marked_large_cube_reopen Ψ W hW X H₀ hX d] + change (∑' H,f H)=(∑' H,if (Ideal.absNorm H : ℝ) ActualEisensteinCubic.O + +theorem marked_large_cube_sum_comm (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0largeCubeCoefficient H₀ p.2*summand Ψ W X p.1 p.2*d (p.1*p.2^3) + have hf : (Function.support a).Finite := + (completedT_finite_support Ψ W hW X hX).subset (by + intro p hp + exact fun h=>hp (by simp only [a,h,mul_zero,zero_mul])) + have hs : Summable a := summable_of_hasFiniteSupport hf + let e := Equiv.prodComm (Ideal O) (Ideal O) + have ht : Summable (fun p=>a (e p)) := e.summable_iff.mpr hs + calc + _ = ∑'p:Ideal O×Ideal O,a p := hs.tsum_prod.symm + _ = ∑'p:Ideal O×Ideal O,a (e p) := (e.tsum_eq a).symm + _ = _ := ht.tsum_prod + +theorem marked_large_cube_sum_finite (S : Finset (Ideal O)) (D : ℕ) + (hSp : ∀P∈S,Prime P) (Ψ : O →* ℂ) (m f z : O) (hm : ∀P∈S,m∈P) + (W : ℝ → ℂ) (hWc : HasCompactSupport W) (b X H₀ : ℝ) (hX : 0 ActualEisensteinCubic.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +noncomputable local instance controlledField (P : Ideal Eis) [P.IsMaximal] : + Field (Eis ⧸ P) := Ideal.Quotient.field _ +noncomputable local instance controlledFintype (P : Ideal Eis) [P.IsMaximal] : + Fintype (Eis ⧸ P) := Fintype.ofFinite _ +variable {ι : Type*} [Fintype ι] {p : ι → Eis} {N a0 c0 : Eis} {mode : Bool} + +theorem controlled_phase_product (D : ControlledStratumArithmetic p N a0 c0 mode) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hN : (9 : Eis) * c0 ∣ N) (hr : λ₀ ^ 2 ∣ (∏ i, p i) - 1) + (hbase : if mode then λ₀ ^ 2 ∣ a0 - 1 else λ₀ ^ 2 ∣ c0 - 1) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ) (x : Eis) : + star (complexCharacter (D.relativeGamma hN hr hbase v)) * + ShortDraftTrace.breveE (-(eisEmbedding (D.matrix v 1 1) * (eisEmbedding x / eisLam ^ 4)) / + (eisEmbedding c0 * eisEmbedding (∏ i, p i))) = + (star D.fixedFactor * A4BadPhase c0 hc0 (D.matrix (fun _ => 1) 1 1) D.U x) * + ∏ i, frequencyMultiplier (actualSextic (Ideal.span {p i}) (hg i)) + (quotientTrace (p i) (hp i)) (D.sigma i) (D.epsilon i) (Ideal.Quotient.mk _ x) (v i) := by + have hbad : A4BadPhase c0 hc0 (D.matrix v 1 1) D.U x = + A4BadPhase c0 hc0 (D.matrix (fun _ => 1) 1 1) D.U x := by + apply A4BadPhase_eq_of_residue + convert dvd_mul_of_dvd_left (D.inverse_fixed hN v) D.U using 1 ; ring + have hlocal := A3_A4_frequency_product p hp hcop hg (D.matrix v 0 0) (D.matrix v 0 1) + c0 (D.matrix v 1 1) D.U D.w x hc0 (D.determinant v) D.bezout D.sigma D.epsilon + (fun i => (v i : Eis ⧸ Ideal.span {p i})) (D.frequency_congruence v) D.epsilon_value + rw [D.relative_character hN hr hbase v, star_mul] + calc + _ = star D.fixedFactor * (star (eisEmbedding (symbol (D.matrix v 0 0) (∏ i, p i))) * + ShortDraftTrace.breveE (-(eisEmbedding (D.matrix v 1 1) * (eisEmbedding x / eisLam ^ 4)) / + (eisEmbedding c0 * eisEmbedding (∏ i, p i)))) := by ring + _ = _ := by rw [hlocal, hbad]; ring + +def fullLocalFourierWeight [∀ i, (Ideal.span {p i}).IsMaximal] + (hp : ∀ i, p i ≠ 0) (F : ∀ i, (Eis ⧸ Ideal.span {p i}) → ℂ) + (v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ) : ℂ := + ∏ i, finiteAdditiveFourierCoeff (quotientTrace (p i) (hp i)) (F i) (v i) + +theorem controlled_local_multiplier (D : ControlledStratumArithmetic p N a0 c0 mode) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hN : (9 : Eis) * c0 ∣ N) (hr : λ₀ ^ 2 ∣ (∏ i, p i) - 1) + (hbase : if mode then λ₀ ^ 2 ∣ a0 - 1 else λ₀ ^ 2 ∣ c0 - 1) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (F : ∀ i, (Eis ⧸ Ideal.span {p i}) → ℂ) (x : Eis) : + (∑ v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ, fullLocalFourierWeight hp F v * + star (complexCharacter (D.relativeGamma hN hr hbase v)) * + ShortDraftTrace.breveE (-(eisEmbedding (D.matrix v 1 1) * (eisEmbedding x / eisLam ^ 4)) / + (eisEmbedding c0 * eisEmbedding (∏ i, p i)))) = + (star D.fixedFactor * A4BadPhase c0 hc0 (D.matrix (fun _ => 1) 1 1) D.U x) * + ∏ i, ∑ v : (Eis ⧸ Ideal.span {p i})ˣ, + finiteAdditiveFourierCoeff (quotientTrace (p i) (hp i)) (F i) v * + frequencyMultiplier (actualSextic (Ideal.span {p i}) (hg i)) + (quotientTrace (p i) (hp i)) (D.sigma i) (D.epsilon i) (Ideal.Quotient.mk _ x) v := by + rw [Fintype.prod_sum, Finset.mul_sum] + apply Finset.sum_congr rfl + intro v hv + rw [mul_assoc, controlled_phase_product D hN hr hbase hp hc0 hcop hg v x] + simp only [fullLocalFourierWeight, Finset.prod_mul_distrib] + ring + +def mixedActiveBracket [∀ i, (Ideal.span {p i}).IsMaximal] + (hp : ∀ i, p i ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (D : ControlledStratumArithmetic p N a0 c0 mode) + (i : ι) (x : Eis) : ℂ := + if i ∈ S then + (rootCard (Eis ⧸ Ideal.span {p i}) : ℂ)⁻¹ * + tau (actualSextic (Ideal.span {p i}) (hg i)) (quotientTrace (p i) (hp i)) 2 * + (((actualSextic (Ideal.span {p i}) (hg i)) ^ 2)⁻¹) + ((D.sigma i : Eis ⧸ Ideal.span {p i}) * (D.epsilon i : Eis ⧸ Ideal.span {p i}) * + Ideal.Quotient.mk _ x) + else (((actualSextic (Ideal.span {p i}) (hg i))⁻¹) ^ 2) (D.sigma i) * + phase (actualSextic (Ideal.span {p i}) (hg i)) (quotientTrace (p i) (hp i)) (j i) (D.epsilon i) * + bracket (actualSextic (Ideal.span {p i}) (hg i)) (j i) (Ideal.Quotient.mk _ x) + +theorem mixedActiveBracket_eq_units [∀ i, (Ideal.span {p i}).IsMaximal] + (hp : ∀ i, p i ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (j : ι → ℕ) (hj : ∀ i, j i < 6) (S : Finset ι) + (D : ControlledStratumArithmetic p N a0 c0 mode) (i : ι) (x : Eis) : + (∑ v : (Eis ⧸ Ideal.span {p i})ˣ, + finiteAdditiveFourierCoeff (quotientTrace (p i) (hp i)) (mixedPrimeFunction p hg j S i) v * + frequencyMultiplier (actualSextic (Ideal.span {p i}) (hg i)) + (quotientTrace (p i) (hp i)) (D.sigma i) (D.epsilon i) (Ideal.Quotient.mk _ x) v) = + mixedActiveBracket hp hg j S D i x := by + have hh := actual_mixed_frequency_units (Ideal.span {p i}) (hg i) (hc i) + (quotientTrace (p i) (hp i)) + (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive (p i) (hp i)) + (decide (i ∈ S)) (j i) (hj i) (D.sigma i) (D.epsilon i) (Ideal.Quotient.mk _ x) + have hfun : mixedPrimeFunction p hg j S i = fun t => + if i ∈ S then zeroMark t else (actualSextic (Ideal.span {p i}) (hg i) ^ j i) t := rfl + rw [hfun] + by_cases hi : i ∈ S + · simpa only [hi, decide_true, mixedFrequencyRow, mixedPrimeFunction, mixedActiveBracket, + ite_true, markedFrequencyRow] using hh + · simpa only [hi, decide_false, mixedFrequencyRow, mixedPrimeFunction, mixedActiveBracket, + Bool.false_eq_true, ite_false, frequencyRow] using hh + +theorem controlled_mixed_multiplier (D : ControlledStratumArithmetic p N a0 c0 mode) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hN : (9 : Eis) * c0 ∣ N) (hr : λ₀ ^ 2 ∣ (∏ i, p i) - 1) + (hbase : if mode then λ₀ ^ 2 ∣ a0 - 1 else λ₀ ^ 2 ∣ c0 - 1) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (j : ι → ℕ) (hj : ∀ i, j i < 6) (S : Finset ι) (x : Eis) : + (∑ v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ, + fullLocalFourierWeight hp (mixedPrimeFunction p hg j S) v * + star (complexCharacter (D.relativeGamma hN hr hbase v)) * + ShortDraftTrace.breveE (-(eisEmbedding (D.matrix v 1 1) * (eisEmbedding x / eisLam ^ 4)) / + (eisEmbedding c0 * eisEmbedding (∏ i, p i)))) = + (star D.fixedFactor * A4BadPhase c0 hc0 (D.matrix (fun _ => 1) 1 1) D.U x) * + ∏ i, mixedActiveBracket hp hg j S D i x := by + rw [controlled_local_multiplier D hN hr hbase hp hc0 hcop hg] + congr 1 + apply Finset.prod_congr rfl + intro i hi + exact mixedActiveBracket_eq_units hp hg hc j hj S D i x + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CubeSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CubeSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..6f98d4b1f5202b3594480d839535bf20cf03ceec --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CubeSource.lean @@ -0,0 +1,154 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceTuples + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseSecondFibers +open InverseInitialArithmetic (sourceIdeal sourceIdeal_gen sourceIdeal_ne_zero sourceIdeal_union sourceIdeal_injective sourcePrime source_prime_dvd) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) + [∀ i, (Ideal.span {p i}).IsMaximal] + +lemma sourceIdeal_isRadical + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) (S : Finset ι) : + (sourceIdeal p S).IsRadical := by + change (Ideal.span {∏ i ∈ S,p i}).IsRadical + rw [FiniteGaussPhase.span_finset_prod] + induction S using Finset.induction_on with + | empty => simp only [Finset.prod_empty]; exact fun _ _ => by simp + | @insert a S ha ih => + rw [Finset.prod_insert ha,Ideal.mul_eq_inf_of_isCoprime] + · exact (inferInstance : (Ideal.span {p a}).IsPrime).isRadical.inf ih + · apply IsCoprime.prod_right + intro b hb + exact hcop (fun he => ha (he.symm ▸ hb)) + +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma cubeRadical_span_dvd_product (B : Finset ι) (v : ι → ℕ) + (hv : ∀ i ∈ B, 0 < v i) : + sourceIdeal p B ∣ Ideal.span {primeProduct p B v} := by + apply span_dvd_of_element_dvd + change (∏ i ∈ B,p i) ∣ primeProduct p B v + unfold primeProduct + apply Finset.prod_dvd_prod_of_dvd + intro i hi + exact dvd_pow_self _ (Nat.ne_of_gt (hv i hi)) + +theorem cubeSupport_dvd_radical + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (B : Finset ι) (v₁ v₂ : ι → ℕ) (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) : + sourceIdeal p B ∣ + (Ideal.span {primeProduct p B v₁}*Ideal.span {primeProduct p B v₂}).radical := by + apply Ideal.dvd_iff_le.mpr + apply (sourceIdeal_isRadical p hcop B).radical_le_iff.mpr + apply Ideal.dvd_iff_le.mp + rw [Ideal.span_singleton_mul_span_singleton,←primeProduct_add] + exact cubeRadical_span_dvd_product p B _ hv + +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma aLabel_dvd_cubeSupport (B : Finset ι) (ε : ι → Bool) : + Ideal.span {aLabel p B ε} ∣ sourceIdeal p B := by + apply span_dvd_of_element_dvd + unfold aLabel primeProduct + change (∏ i ∈ B,p i^bit (ε i)) ∣ ∏ i ∈ B,p i + apply Finset.prod_dvd_prod_of_dvd + intro i hi + cases hh : ε i <;> simp [bit] + +theorem firstMask_dvd_cube_radical + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (B C D : Finset ι) (hCB : Disjoint C B) (hD : D ⊆ C∪B) + (v₁ v₂ : ι → ℕ) (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) : + sourceIdeal p D ∣ sourceIdeal p C * + (Ideal.span {primeProduct p B v₁}*Ideal.span {primeProduct p B v₂}).radical := by + have hd := InverseInitialArithmetic.sourceIdeal_dvd p D (C∪B) hD + rw [sourceIdeal_union p C B hCB] at hd + exact hd.trans (mul_dvd_mul_left _ (cubeSupport_dvd_radical p hcop B v₁ v₂ hv)) + +def cubeSecondSource {Jo Jn : ℕ} (B C D G E V : Finset ι) + (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) (t : Ideal Eis) (k : Eis) + (oldAssigned : Fin Jo → SmoothMobiusCorrection.PrimeIdeal) (newAssigned : Fin Jn → ι) : + SecondOriginalSource ι Jo Jn where + q0 := Ideal.span {b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂} + quotient := t + J := Ideal.span {jLabel p B (fun i => v₁ i+v₂ i) ε₁ ε₂} + C := sourceIdeal p C + s := Ideal.span {squarefreeLabel p B (fun i => v₁ i+v₂ i)} + b1 := Ideal.span {primeProduct p B v₁} + A1 := Ideal.span {aLabel p B ε₁} + A2 := Ideal.span {aLabel p B ε₂} + dK := sourceIdeal p D + J2 := Ideal.span {j2Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂} + b2 := Ideal.span {primeProduct p B v₂} + common := G + divisor := E + overlap := V + frequency := k + oldAssigned := oldAssigned + newAssigned := newAssigned + +theorem cubeSecondSource_valid (hp : ∀ i, p i ≠ 0) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + {Jo Jn : ℕ} (B C D G E V : Finset ι) (hCB : Disjoint C B) + (hD : D ⊆ C∪B) (hE : E ⊆ G) + (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) + (t : Ideal Eis) (k : Eis) + (oldAssigned : Fin Jo → SmoothMobiusCorrection.PrimeIdeal) (newAssigned : Fin Jn → ι) + (hold : ∀ i, (oldAssigned i).val ∣ + Ideal.span {b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂} * + Ideal.span {jLabel p B (fun i => v₁ i+v₂ i) ε₁ ε₂} * sourceIdeal p C * t) + (hnew : ∀ i, newAssigned i ∈ G∪V) : + SecondOriginalValid (cubeSecondSource p B C D G E V v₁ v₂ ε₁ ε₂ t k oldAssigned newAssigned) := by + constructor + · change Ideal.span {squarefreeLabel p B (fun i => v₁ i+v₂ i)} * + Ideal.span {j2Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂} = _ + rw [Ideal.span_singleton_mul_span_singleton,←jLabel_eq_squarefree_mul_j2] + rfl + · have hb := congrArg (fun a : Eis => (Ideal.span {a} : Ideal Eis)) + (cube_pair_product_decomposition p B v₁ v₂ ε₁ ε₂ hv) + simpa only [cubeSecondSource,pow_two,←Ideal.span_singleton_mul_span_singleton] using hb + · exact (aLabel_dvd_cubeSupport p B ε₁).trans (cubeSupport_dvd_radical p hcop B v₁ v₂ hv) + · exact (aLabel_dvd_cubeSupport p B ε₂).trans (cubeSupport_dvd_radical p hcop B v₁ v₂ hv) + · exact firstMask_dvd_cube_radical p hcop B C D hCB hD v₁ v₂ hv + · change primaryGenerator (sourceIdeal p D) ≠ 0 + rw [sourceIdeal_gen p hp hpr] + exact Finset.prod_ne_zero_iff.mpr (fun i _ => hp i) + · exact hE + · exact hold + · exact hnew + +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem oldSlot_dvd_reconstructed_support + (B C : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ i ∈ B, 0 < v i) (P t : Ideal Eis) + (hP : P ∣ sourceIdeal p B*sourceIdeal p C*t) : + P ∣ Ideal.span {b0Label p B v ε₁ ε₂}* + Ideal.span {jLabel p B v ε₁ ε₂}*sourceIdeal p C*t := by + have hb := span_dvd_of_element_dvd (cubeRadical_dvd_jLabel_b0 p B v ε₁ ε₂ hv) + change sourceIdeal p B ∣ Ideal.span {jLabel p B v ε₁ ε₂*b0Label p B v ε₁ ε₂} at hb + rw [←Ideal.span_singleton_mul_span_singleton,mul_comm (Ideal.span {jLabel p B v ε₁ ε₂})] at hb + exact hP.trans (mul_dvd_mul_right (mul_dvd_mul_right hb _) _) + +theorem cubeSecondSource_valid_original_slots (hp : ∀ i, p i ≠ 0) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + {Jo Jn : ℕ} (B C D G E V : Finset ι) (hCB : Disjoint C B) + (hD : D ⊆ C∪B) (hE : E ⊆ G) + (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) + (t : Ideal Eis) (k : Eis) + (oldAssigned : Fin Jo → SmoothMobiusCorrection.PrimeIdeal) (newAssigned : Fin Jn → ι) + (hold : ∀ i, (oldAssigned i).val ∣ sourceIdeal p B*sourceIdeal p C*t) + (hnew : ∀ i, newAssigned i ∈ G∪V) : + SecondOriginalValid (cubeSecondSource p B C D G E V v₁ v₂ ε₁ ε₂ t k oldAssigned newAssigned) := + cubeSecondSource_valid p hp hpr hcop B C D G E V hCB hD hE v₁ v₂ ε₁ ε₂ hv t k + oldAssigned newAssigned + (fun i => oldSlot_dvd_reconstructed_support p B C _ ε₁ ε₂ hv _ t (hold i)) hnew + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CubeSupportNorm.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CubeSupportNorm.lean new file mode 100644 index 0000000000000000000000000000000000000000..65b5d312bdf7335e7c4220f1f1982c82ead55517 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CubeSupportNorm.lean @@ -0,0 +1,46 @@ +import OAI.NumberTheory.DirichletL.Descent.CubeSource +import OAI.NumberTheory.DirichletL.Descent.FirstWholeMarkedColumns + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseInitialArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀ i,p i≠0) + +include hp in +theorem cube_whole_support_norm (b : CubeCoordinates ι) : + primeProductNorm p b.support≤ + ‖eisEmbedding (primeProduct p b.support b.leftExponent)‖^2* + ‖eisEmbedding (primeProduct p b.support b.rightExponent)‖^2 := by + have hd := cubeRadical_span_dvd_product p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.support_pos + have hne : (Ideal.span {primeProduct p b.support (fun i=>b.leftExponent i+b.rightExponent i)}:Ideal O)≠0 := + Ideal.span_singleton_eq_bot.not.mpr (primeProduct_ne_zero p hp _ _) + have hn := Nat.le_of_dvd (Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hne)) + (Ideal.absNorm_dvd_absNorm_of_le (Ideal.dvd_iff_le.mp hd)) + have he : (Ideal.absNorm (sourceIdeal p b.support):ℝ)=primeProductNorm p b.support := by + simpa only [sourceIdeal,primeProductNorm,map_prod] using + (eisEmbedding_norm_sq_eq_absNorm_span (∏i∈b.support,p i)).symm + have hh : primeProductNorm p b.support≤ + ‖eisEmbedding (primeProduct p b.support (fun i=>b.leftExponent i+b.rightExponent i))‖^2 := by + rw [eisEmbedding_norm_sq_eq_absNorm_span,←he] + exact_mod_cast hn + simpa only [primeProduct_add,map_mul,norm_mul,mul_pow] using hh + +include hp in +theorem cube_whole_support_dyad (b : CubeCoordinates ι) (B : ℝ) (hB : 0≤B) + (hl : ‖eisEmbedding (primeProduct p b.support b.leftExponent)‖^2≤B) + (hr : ‖eisEmbedding (primeProduct p b.support b.rightExponent)‖^2≤B) : + primeProductNorm p b.support≤B^2 := + (cube_whole_support_norm p hp b).trans ((mul_le_mul hl hr (sq_nonneg _) hB).trans_eq (pow_two B).symm) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/CuspCongruence.lean b/lean/OAI/NumberTheory/DirichletL/Descent/CuspCongruence.lean new file mode 100644 index 0000000000000000000000000000000000000000..261d49633150e6e7cccc2b3d745c09acd6a50b1d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/CuspCongruence.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Descent.MarkedReflection + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open MeasureTheory CompletedGauss CubicEisenstein +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +private theorem cusp_sum_kernel_integral {ι : Type*} [Fintype ι] + (d : ι → SourceCuspDatum) (w : ι → ℂ) (F : ℝ → ℂ) + (hF : ∀ v : ℝ, 0 < v → F v = ∑ i, w i * cuspBarProfile cubicSourceConjugateFunction (d i).point v) + (W : ℝ → ℂ) (lo hi : ℝ) (hlo : 0 < lo) + (hsupp : Function.support W ⊆ Set.Icc lo hi) (hW : ContDiff ℝ ∞ W) + (X : ℝ) (hX : 0 < X) : + (∑ i, w i * (d i).smoothedKernel W X) = + (1 / (2 * Real.pi) : ℂ) * ∫ t : ℝ, + besselSmoothingIntegrand F thetaBesselScale (Vstar W) X ((-1 : ℂ) + t * Complex.I) := by + let : Countable Eis := ActualEisensteinCubic.latticeCoordEquiv.injective.countable + let G : ι → ℝ → ℂ := fun i => cuspBarProfile cubicSourceConjugateFunction (d i).point + let J : ι → ℝ → ℂ := fun i t => + besselSmoothingIntegrand (G i) thetaBesselScale (Vstar W) X ((-1 : ℂ) + t * Complex.I) + have hVs := Vstar_support W lo hi hsupp + have hV := Vstar_contDiff W lo hi hlo hsupp hW + have hint (i : ι) : Integrable (J i) := + besselSmoothingIntegrand_reflected_integrable (G i) sourceCuspRadialLength + sourceCuspRadialLength_pos (sourceCuspRadialCoefficient (d i).index (d i).dualPoint) + thetaBesselScale (sourceCuspRadialScale (d i).index) (d i).heightScale + thetaBesselScale_pos (sourceCuspRadialScale_pos _) (d i).heightScale_pos + (d i).multiplier (d i).reflection_radial + (sourceCuspRadialCoefficient_weighted_summable _ _) (Vstar W) lo hi hlo hVs hV X hX + have hline (i : ι) : (1 / (2 * Real.pi) : ℂ) * (∫ t : ℝ, J i t) = + (d i).smoothedKernel W X := + besselSmoothingIntegral_reflected_kernel (G i) sourceCuspRadialLength + sourceCuspRadialLength_pos (sourceCuspRadialCoefficient (d i).index (d i).dualPoint) + thetaBesselScale (sourceCuspRadialScale (d i).index) (d i).heightScale + thetaBesselScale_pos (sourceCuspRadialScale_pos _) (d i).heightScale_pos + (d i).multiplier (d i).reflection_radial + (sourceCuspRadialCoefficient_weighted_summable _ _) (Vstar W) lo hi hlo hVs hV X hX + have hexpand (t : ℝ) : + besselSmoothingIntegrand F thetaBesselScale (Vstar W) X ((-1 : ℂ) + t * Complex.I) = + ∑ i, w i * J i t := + besselSmoothingIntegrand_finite_sum F G w hF thetaBesselScale (Vstar W) X _ + (fun i => (d i).cuspBarProfile_mellin_entire.1 _) + simp_rw [hexpand] + rw [integral_finsetSum Finset.univ (fun i _ => (hint i).const_mul (w i)), Finset.mul_sum] + apply Finset.sum_congr rfl + intro i hi + rw [integral_const_mul, ← hline] + ring + +theorem cusp_kernel_sum_congr {ι κ : Type*} [Fintype ι] [Fintype κ] + (d : ι → SourceCuspDatum) (w : ι → ℂ) + (e : κ → SourceCuspDatum) (z : κ → ℂ) + (hmult : ∀ n : Eis, + (∑ i, w i * ShortDraftTrace.breveE (-cuspFrequency n * (d i).point)) = + ∑ k, z k * ShortDraftTrace.breveE (-cuspFrequency n * (e k).point)) + (W : ℝ → ℂ) (lo hi : ℝ) (hlo : 0 < lo) + (hsupp : Function.support W ⊆ Set.Icc lo hi) (hW : ContDiff ℝ ∞ W) + (X : ℝ) (hX : 0 < X) : + (∑ i, w i * (d i).smoothedKernel W X) = ∑ k, z k * (e k).smoothedKernel W X := by + let F : ℝ → ℂ := fun v => ∑ i, w i * cuspBarProfile cubicSourceConjugateFunction (d i).point v + have hprofile (v : ℝ) (hv : 0 < v) : + F v = ∑ k, z k * cuspBarProfile cubicSourceConjugateFunction (e k).point v := by + rw [show F v = ∑ i, w i * cuspBarProfile cubicSourceConjugateFunction (d i).point v from rfl, + ← finiteConjugateSource_wirtingerBar_sum _ _ v hv, + ← finiteConjugateSource_wirtingerBar_sum _ _ v hv, + finiteConjugateSource_wirtingerBar, finiteConjugateSource_wirtingerBar] + simp_rw [hmult] + rw [cusp_sum_kernel_integral d w F (fun _ _ => rfl) W lo hi hlo hsupp hW X hX, + cusp_sum_kernel_integral e z F hprofile W lo hi hlo hsupp hW X hX] + +theorem markedCompletedT_of_cusp_multiplier {ι κ : Type*} [Fintype κ] + (p : ι → Eis) (S : Finset ι) (hp : ∀ i ∈ S, Prime (p i)) + (Ψ : Eis →* ℂ) (hΨ : ∀ x, ‖Ψ x‖ ≤ 1) + (Q : Ideal Eis) (hperiod : CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c : Eis) (hc : c ≠ 0) [Fintype (Eis ⧸ Ideal.span {c})] + (hcQ : Ideal.span {c} ≤ Ideal.span {(9 : Eis)} * (Q * Ideal.span {∏ i ∈ S, p i})) + (d : κ → SourceCuspDatum) (w : κ → ℂ) + (hmult : ∀ n : Eis, (∑ k, w k * ShortDraftTrace.breveE (-cuspFrequency n * (d k).point)) = + markedThetaQuotient p S Ψ c (Ideal.Quotient.mk _ n)) + (W : ℝ → ℂ) (hWcompact : HasCompactSupport W) + (lo hi : ℝ) (hlo : 0 < lo) (hsupp : Function.support W ⊆ Set.Icc lo hi) + (hW : ContDiff ℝ ∞ W) (X : ℝ) (hX : 0 < X) : + markedCompletedT Ψ W X (fun A => ∏ i ∈ S, if Ideal.span {p i} ∣ A then 1 else 0) = + thetaDerivativeScalar⁻¹ * ∑ k, w k * (d k).smoothedKernel W X := by + rw [markedCompletedT_canonical_reflection p S hp Ψ hΨ Q hperiod c hc hcQ + W hWcompact lo hi hlo hsupp hW X hX] + congr 1 + apply cusp_kernel_sum_congr (finiteTwistCusp c hc) + (finiteAdditiveFourierCoeff (quotientTrace c hc) + (markedThetaQuotient p S Ψ c)) d w ?_ W lo hi hlo hsupp hW X hX + intro n + simp_rw [finiteTwistCusp_point] + rw [thetaFourierTranslation_inversion c hc, hmult] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Decomposition.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Decomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..ea937fb67f82ae14e8a30cb19ee14337d2ac0498 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Decomposition.lean @@ -0,0 +1,184 @@ +import OAI.NumberTheory.DirichletL.Descent.IdealMasks +import Mathlib.Algebra.BigOperators.Group.Finset.Preimage + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +structure HybridColumnData where + common : Ideal Eis + residualN : Ideal Eis + residualB : Ideal Eis + square : Ideal Eis + n_squarefree : Squarefree (common * residualN) + g_squarefree : Squarefree (common * residualB) + residual_coprime : IsCoprime residualN residualB + square_ne_zero : square ≠ 0 + +def HybridColumnData.reconstruct (d : HybridColumnData) : Ideal Eis × Ideal Eis := + (d.common * d.residualN, (d.common * d.residualB) * d.square ^ 2) + +theorem HybridColumnData.common_ne_zero (d : HybridColumnData) : d.common ≠ 0 := + ne_zero_of_dvd_ne_zero d.n_squarefree.ne_zero (dvd_mul_right _ _) + +theorem HybridColumnData.common_eq_gcd (d : HybridColumnData) : + d.common = gcd (d.common * d.residualN) (d.common * d.residualB) := by + rw [gcd_mul_left, normalize_eq, Ideal.isCoprime_iff_gcd.mp d.residual_coprime, mul_one] + +theorem HybridColumnData.residual_product_squarefree (d : HybridColumnData) : + Squarefree (d.residualN * d.residualB) := by + have hm := (squarefree_mul_iff.mp d.n_squarefree).2.2 + have hh := (squarefree_mul_iff.mp d.g_squarefree).2.2 + exact squarefree_mul_iff.mpr ⟨d.residual_coprime.isRelPrime, hm, hh⟩ + +theorem HybridColumnData.primary_factors (d : HybridColumnData) + (hn : CompletedGauss.primaryGenerator (d.common * d.residualN) ≠ 0) + (hb : CompletedGauss.primaryGenerator ((d.common * d.residualB) * d.square ^ 2) ≠ 0) : + CompletedGauss.primaryGenerator d.common ≠ 0 ∧ + CompletedGauss.primaryGenerator d.residualN ≠ 0 ∧ + CompletedGauss.primaryGenerator d.residualB ≠ 0 ∧ + CompletedGauss.primaryGenerator d.square ≠ 0 ∧ + CompletedGauss.primaryGenerator (d.common * d.square) ≠ 0 := by + rw [CompletedGauss.primaryGenerator_mul] at hn + have hpow : CompletedGauss.primaryGenerator (d.square ^ 2) = + CompletedGauss.primaryGenerator d.square ^ 2 := + map_pow CompletedGauss.primaryGeneratorHom d.square 2 + rw [CompletedGauss.primaryGenerator_mul, CompletedGauss.primaryGenerator_mul, hpow] at hb + have hc := (mul_ne_zero_iff.mp hn).1 + have hm := (mul_ne_zero_iff.mp hn).2 + have hch := (mul_ne_zero_iff.mp hb).1 + have hh := (mul_ne_zero_iff.mp hch).2 + have ht : CompletedGauss.primaryGenerator d.square ≠ 0 := by + intro hz + apply (mul_ne_zero_iff.mp hb).2 + simp [hz] + refine ⟨hc, hm, hh, ht, ?_⟩ + rw [CompletedGauss.primaryGenerator_mul] + exact mul_ne_zero hc ht + +theorem HybridColumnData.residual_norm_identity (d : HybridColumnData) : + (Ideal.absNorm (d.residualN * d.residualB) : ℝ) = + ((Ideal.absNorm (d.common * d.residualN) : ℝ) * + (Ideal.absNorm ((d.common * d.residualB) * d.square ^ 2) : ℝ)) / + ((Ideal.absNorm d.common : ℝ) ^ 2 * (Ideal.absNorm d.square : ℝ) ^ 2) := by + have hc : (Ideal.absNorm d.common : ℝ) ≠ 0 := by + exact_mod_cast (fun hz => d.common_ne_zero (Ideal.absNorm_eq_zero_iff.mp hz)) + have ht : (Ideal.absNorm d.square : ℝ) ≠ 0 := by + exact_mod_cast (fun hz => d.square_ne_zero (Ideal.absNorm_eq_zero_iff.mp hz)) + simp only [map_mul, map_pow, Nat.cast_mul, Nat.cast_pow] + field_simp + +theorem HybridColumnData.residual_norm_bounds (d : HybridColumnData) + (N B C T : ℝ) (hN : 0 ≤ N) (_hB : 0 ≤ B) (hC : 0 < C) (hT : 0 < T) + (hn : (Ideal.absNorm (d.common * d.residualN) : ℝ) ≤ N) + (hb : (Ideal.absNorm ((d.common * d.residualB) * d.square ^ 2) : ℝ) ≤ B) + (hc : C ≤ (Ideal.absNorm d.common : ℝ)) + (ht : T ≤ (Ideal.absNorm d.square : ℝ)) : + (Ideal.absNorm d.residualN : ℝ) ≤ N / C ∧ + (Ideal.absNorm d.residualB : ℝ) ≤ B / (C * T ^ 2) ∧ + (Ideal.absNorm (d.residualN * d.residualB) : ℝ) ≤ N * B / (C ^ 2 * T ^ 2) := by + have hn' := hn + have hb' := hb + simp only [map_mul, map_pow, Nat.cast_mul, Nat.cast_pow] at hn' hb' + have hm : (Ideal.absNorm d.residualN : ℝ) ≤ N / C := by + apply (le_div_iff₀ hC).mpr + calc + _ ≤ (Ideal.absNorm d.common : ℝ) * (Ideal.absNorm d.residualN : ℝ) := by + simpa only [mul_comm] using mul_le_mul_of_nonneg_right hc + (Nat.cast_nonneg (Ideal.absNorm d.residualN)) + _ ≤ N := hn' + have hh : (Ideal.absNorm d.residualB : ℝ) ≤ B / (C * T ^ 2) := by + apply (le_div_iff₀ (mul_pos hC (sq_pos_of_pos hT))).mpr + calc + _ ≤ (Ideal.absNorm d.common : ℝ) * (Ideal.absNorm d.residualB : ℝ) * + (Ideal.absNorm d.square : ℝ) ^ 2 := by + calc + _ = C * (Ideal.absNorm d.residualB : ℝ) * T ^ 2 := by ring + _ ≤ _ := by gcongr + _ ≤ B := hb' + refine ⟨hm, hh, ?_⟩ + calc + _ = (Ideal.absNorm d.residualN : ℝ) * (Ideal.absNorm d.residualB : ℝ) := by + rw [map_mul, Nat.cast_mul] + _ ≤ (N / C) * (B / (C * T ^ 2)) := + mul_le_mul hm hh (Nat.cast_nonneg _) (div_nonneg hN hC.le) + _ = N * B / (C ^ 2 * T ^ 2) := by ring + +theorem HybridColumnData.reconstruct_injective : + Function.Injective HybridColumnData.reconstruct := by + intro d e he + have hn : d.common * d.residualN = e.common * e.residualN := congrArg Prod.fst he + have hb : d.square ^ 2 * (d.common * d.residualB) = + e.square ^ 2 * (e.common * e.residualB) := by + simpa only [HybridColumnData.reconstruct, mul_comm] using congrArg Prod.snd he + obtain ⟨ht, hg⟩ := QuadraticSquarefreeKernel.squarefree_decomposition_unique + d.square_ne_zero e.square_ne_zero d.g_squarefree e.g_squarefree hb + have hc : d.common = e.common := by + calc + _ = gcd (d.common * d.residualN) (d.common * d.residualB) := d.common_eq_gcd + _ = gcd (e.common * e.residualN) (e.common * e.residualB) := by rw [hn, hg] + _ = e.common := e.common_eq_gcd.symm + rw [hc] at hn hg + have hm := mul_left_cancel₀ e.common_ne_zero hn + have hh := mul_left_cancel₀ e.common_ne_zero hg + cases d + cases e + cases hc + cases hm + cases hh + cases ht + rfl + +def HybridColumnData.toOriginal (d : HybridColumnData) : + {p : Ideal Eis × Ideal Eis // Squarefree p.1 ∧ p.2 ≠ 0} := + ⟨d.reconstruct, d.n_squarefree, + mul_ne_zero d.g_squarefree.ne_zero (pow_ne_zero 2 d.square_ne_zero)⟩ + +theorem HybridColumnData.toOriginal_bijective : Function.Bijective HybridColumnData.toOriginal := by + constructor + · intro d e he + exact reconstruct_injective (congrArg Subtype.val he) + · intro p + obtain ⟨c, m, h, t, hn, hb, hcs, hms, hhs, hcm, hch, hmh, ht⟩ := + hybrid_column_decomposition p.val.1 p.val.2 p.property.1 p.property.2 + refine ⟨⟨c, m, h, t, ?_, ?_, hmh, ht⟩, ?_⟩ + · exact hn ▸ p.property.1 + · exact squarefree_mul_iff.mpr ⟨hch, hcs, hhs⟩ + · apply Subtype.ext + exact Prod.ext hn.symm hb.symm + +def hybridColumnEquiv : HybridColumnData ≃ + {p : Ideal Eis × Ideal Eis // Squarefree p.1 ∧ p.2 ≠ 0} := + Equiv.ofBijective HybridColumnData.toOriginal HybridColumnData.toOriginal_bijective + +theorem hybrid_column_reindex (f : Ideal Eis → Ideal Eis → ℂ) : + (∑' p : {p : Ideal Eis × Ideal Eis // Squarefree p.1 ∧ p.2 ≠ 0}, f p.val.1 p.val.2) = + ∑' d : HybridColumnData, + f (d.common * d.residualN) ((d.common * d.residualB) * d.square ^ 2) := by + exact (hybridColumnEquiv.tsum_eq (fun p => f p.val.1 p.val.2)).symm + +def hybridColumnSupport (S : Finset (Ideal Eis × Ideal Eis)) : Finset HybridColumnData := + S.preimage HybridColumnData.reconstruct HybridColumnData.reconstruct_injective.injOn + +@[simp] theorem mem_hybridColumnSupport (S : Finset (Ideal Eis × Ideal Eis)) + (d : HybridColumnData) : + d ∈ hybridColumnSupport S ↔ d.reconstruct ∈ S := Finset.mem_preimage + +theorem hybrid_finite_column_reindex {A : Type*} [AddCommMonoid A] + (S : Finset (Ideal Eis × Ideal Eis)) + (hS : ∀ p ∈ S, Squarefree p.1 ∧ p.2 ≠ 0) + (f : Ideal Eis × Ideal Eis → A) : + (∑ p ∈ S, f p) = ∑ d ∈ hybridColumnSupport S, f d.reconstruct := by + symm + apply Finset.sum_preimage + intro p hp hn + obtain ⟨d, hd⟩ := HybridColumnData.toOriginal_bijective.surjective ⟨p, hS p hp⟩ + exact (hn ⟨d, congrArg Subtype.val hd⟩).elim + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/DensityAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Descent/DensityAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..a982d6dfe9e9166f73c5e43ed8662924f7b9a543 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/DensityAssembly.lean @@ -0,0 +1,37 @@ +import OAI.NumberTheory.DirichletL.Descent.ProfileIntegral + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section + +theorem integrable_density_mode {ι : Type*} [Fintype ι] + (D : Frequency × (ι → ℝ) → ℂ) (hD : Integrable D) (a₁ a₂ ak y : ι → ℝ) : + Integrable (fun z : Frequency × (ι → ℝ) => D z * + pureProfileMode a₁ a₂ ak y z.1 z.2) := by + have hc : Continuous (fun z : Frequency × (ι → ℝ) => pureProfileMode a₁ a₂ ak y z.1 z.2) := by + unfold pureProfileMode logPhase + fun_prop + exact hD.mul_bdd hc.aestronglyMeasurable + (Filter.Eventually.of_forall (fun z => (pureProfileMode_norm a₁ a₂ ak y z.1 z.2).le)) + +theorem density_finite_sum {ι κ : Type*} [Fintype ι] (s : Finset κ) + (D : Frequency × (ι → ℝ) → ℂ) (hD : Integrable D) (a₁ a₂ ak : ι → ℝ) + (c : κ → ℂ) (y : κ → ι → ℝ) : + (∑ k ∈ s,c k * ∫ z : Frequency × (ι → ℝ),D z*pureProfileMode a₁ a₂ ak (y k) z.1 z.2) = + ∫ z : Frequency × (ι → ℝ),D z * ∑ k ∈ s,c k*pureProfileMode a₁ a₂ ak (y k) z.1 z.2 := by + simp only [← integral_const_mul] + rw [← integral_finsetSum s (fun k hk => (integrable_density_mode D hD a₁ a₂ ak (y k)).const_mul (c k))] + apply integral_congr_ae + filter_upwards with z + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro k hk + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/DescentHeight.lean b/lean/OAI/NumberTheory/DirichletL/Descent/DescentHeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..f7e59ce815e8e7c740f52880920d13077924ca76 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/DescentHeight.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Descent.DescentProfiles + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation EisensteinSchwartzPoisson +noncomputable section + +theorem frequencyTwist_fourier_moment (J : ℕ) (g : 𝓢(ℝ, ℂ)) : + ∃ C : ℝ, 0 ≤ C ∧ ∀ θ : ℝ, + (∫ t : ℝ, (1 + ‖t‖)^J * ‖(𝓕 (frequencyTwist g θ)) t‖) ≤ + C * (1 + ‖θ‖)^(J + (volume : Measure ℝ).integrablePower) := by + let K := J + (volume : Measure ℝ).integrablePower + let D := twistSourceBound g K + have hD : 0 ≤ D := twistSourceBound_nonneg g K + let C := (2 : ℝ)^J * (coefficientMomentBound 0 D + coefficientMomentBound J D) + have hC : 0 ≤ C := mul_nonneg (by positivity) (add_nonneg + (coefficientMomentBound_nonneg 0 D hD) (coefficientMomentBound_nonneg J D hD)) + refine ⟨C, hC, ?_⟩ + intro θ + let H := (1 + ‖θ‖)^K + have hH : 0 ≤ H := by dsimp only [H]; positivity + have hs : ∀ i ≤ K, + (SchwartzMap.seminorm ℝ 0 i) (frequencyTwist g θ) + + (SchwartzMap.seminorm ℝ (volume : Measure ℝ).integrablePower i) (frequencyTwist g θ) ≤ D * H := by + intro i hi + exact (source_le_profileSourceBound (frequencyTwist g θ) K i hi).trans + (profileSourceBound_frequencyTwist g θ K) + have hh := uniform_fourier_one_plus_moment (frequencyTwist g θ) J 1 (D * H) + (by norm_num) (mul_nonneg hD hH) (fun i hi => by simpa only [one_mul] using hs i hi) + have hlin (j : ℕ) : coefficientMomentBound j (D * H) = coefficientMomentBound j D * H := by + unfold coefficientMomentBound + ring + simpa only [one_mul, hlin, add_mul, C, H, K, mul_assoc, mul_add] using hh + +theorem twisted_descent_profile_separation {ι : Type*} [Fintype ι] + (g₁ g₂ Φ : 𝓢(ℝ, ℂ)) (V : ι → ℝ → ℂ) (a₁ a₂ ak M : ι → ℝ) + (hM : ∀ i, 0 ≤ M i) (hV : ∀ i y, V i y ≠ 0 → |y| ≤ M i) + (A J : ℕ) : + ∃ C : ℝ, 0 ≤ C ∧ ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + ∀ θ₁ θ₂ : ℝ, + (∀ y : ι → ℝ, + (∏ i, V i (y i)) * frequencyTwist g₁ θ₁ (∑ i, a₁ i * y i) * + frequencyTwist g₂ θ₂ (∑ i, a₂ i * y i) * + paperRadialFourier Φ (R * Real.exp (∑ i, ak i * y i)) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, + tripleCoefficient (𝓕 (frequencyTwist g₁ θ₁)) (𝓕 (frequencyTwist g₂ θ₂)) b₃ (t₁,t₂,t₃) * + (∏ i, V i (y i) * logPhase t₁ (a₁ i * y i) * + logPhase t₂ (a₂ i * y i) * logPhase t₃ (ak i * y i))) ∧ + Integrable (fun t : Frequency => + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient (𝓕 (frequencyTwist g₁ θ₁)) (𝓕 (frequencyTwist g₂ θ₂)) b₃ t‖) ∧ + (1 + R)^A * (∫ t : Frequency, + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient (𝓕 (frequencyTwist g₁ θ₁)) (𝓕 (frequencyTwist g₂ θ₂)) b₃ t‖) ≤ + C * (1 + ‖θ₁‖)^(J + (volume : Measure ℝ).integrablePower) * + (1 + ‖θ₂‖)^(J + (volume : Measure ℝ).integrablePower) := by + obtain ⟨Ck, hCk, hk⟩ := paperRadialFourier_log_separation_envelope Φ V ak M hM hV A J + obtain ⟨C₁, hC₁, h₁⟩ := frequencyTwist_fourier_moment J g₁ + obtain ⟨C₂, hC₂, h₂⟩ := frequencyTwist_fourier_moment J g₂ + refine ⟨C₁ * C₂ * Ck, by positivity, ?_⟩ + intro R hR + obtain ⟨b₃, he, hi, hb, hp⟩ := hk R hR + refine ⟨b₃, ?_⟩ + intro θ₁ θ₂ + refine ⟨descent_profile_identity _ _ Φ V a₁ a₂ ak R b₃ he, + tripleCoefficient_weighted_integrable _ _ _ J, ?_⟩ + rw [tripleCoefficient_weighted_integral] + have hh := mul_le_mul (mul_le_mul (h₁ θ₁) (h₂ θ₂) + (integral_nonneg (fun t => by positivity)) (by positivity)) hb + (by positivity : 0 ≤ (1 + R)^A * ∫ t : ℝ, (1 + ‖t‖)^J * ‖b₃ t‖) (by positivity) + convert hh using 1 <;> ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/DescentProfiles.lean b/lean/OAI/NumberTheory/DirichletL/Descent/DescentProfiles.lean new file mode 100644 index 0000000000000000000000000000000000000000..ebc78eef8112c6c89aea74d5e44b493b4a0815e6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/DescentProfiles.lean @@ -0,0 +1,173 @@ +import OAI.NumberTheory.DirichletL.Foundation + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge EisensteinSchwartzPoisson JointLogSeparation +noncomputable section + +lemma schwartz_logPhase_inversion (g : 𝓢(ℝ, ℂ)) (x : ℝ) : + g x = ∫ t : ℝ, logPhase t x * (𝓕 g) t := by + convert schwartz_log_inversion g x using 1 + apply integral_congr_ae + filter_upwards with t + congr 1 + simp only [logPhase, Real.inner_apply] + congr 1 + push_cast + ring + +theorem descent_profile_identity {ι : Type*} [Fintype ι] + (g₁ g₂ W : 𝓢(ℝ, ℂ)) (V : ι → ℝ → ℂ) (a₁ a₂ ak : ι → ℝ) + (R : ℝ) (b : 𝓢(ℝ, ℂ)) + (he : ∀ y : ι → ℝ, + (∏ i, V i (y i)) * paperRadialFourier W (R * Real.exp (∑ i, ak i * y i)) = + ∫ t : ℝ, (∏ i, V i (y i) * logPhase t (ak i * y i)) * b t) : + ∀ y : ι → ℝ, + (∏ i, V i (y i)) * g₁ (∑ i, a₁ i * y i) * g₂ (∑ i, a₂ i * y i) * + paperRadialFourier W (R * Real.exp (∑ i, ak i * y i)) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, + tripleCoefficient (𝓕 g₁) (𝓕 g₂) b (t₁, t₂, t₃) * + (∏ i, V i (y i) * logPhase t₁ (a₁ i * y i) * + logPhase t₂ (a₂ i * y i) * logPhase t₃ (ak i * y i)) := by + intro y + let P : ℂ := ∏ i, V i (y i) + let x₁ : ℝ := ∑ i, a₁ i * y i + let x₂ : ℝ := ∑ i, a₂ i * y i + let xk : ℝ := ∑ i, ak i * y i + have hphase (t : ℝ) (a : ι → ℝ) : + (∏ i, logPhase t (a i * y i)) = logPhase t (∑ i, a i * y i) := + (logPhase_sum Finset.univ t (fun i => a i * y i)).symm + have hk' : P * paperRadialFourier W (R * Real.exp xk) = + ∫ t : ℝ, P * logPhase t xk * b t := by + simpa only [Finset.prod_mul_distrib, hphase, P, xk] using he y + have hprod (t₁ t₂ t₃ : ℝ) : + (∏ i, V i (y i) * logPhase t₁ (a₁ i * y i) * + logPhase t₂ (a₂ i * y i) * logPhase t₃ (ak i * y i)) = + P * logPhase t₁ x₁ * logPhase t₂ x₂ * logPhase t₃ xk := by + simp only [Finset.prod_mul_distrib, hphase, P, x₁, x₂, xk] + simp only [hprod, tripleCoefficient] + have hinner (t₁ t₂ : ℝ) : + (∫ t₃ : ℝ, (𝓕 g₁) t₁ * ((𝓕 g₂) t₂ * b t₃) * + (P * logPhase t₁ x₁ * logPhase t₂ x₂ * logPhase t₃ xk)) = + ((𝓕 g₁) t₁ * (𝓕 g₂) t₂ * logPhase t₁ x₁ * logPhase t₂ x₂) * + (P * paperRadialFourier W (R * Real.exp xk)) := by + rw [hk', ← integral_const_mul] + apply integral_congr_ae + filter_upwards with t₃ + ring + simp_rw [hinner] + have hmid (t₁ : ℝ) : + (∫ t₂ : ℝ, ((𝓕 g₁) t₁ * (𝓕 g₂) t₂ * logPhase t₁ x₁ * logPhase t₂ x₂) * + (P * paperRadialFourier W (R * Real.exp xk))) = + (logPhase t₁ x₁ * (𝓕 g₁) t₁) * g₂ x₂ * + (P * paperRadialFourier W (R * Real.exp xk)) := by + rw [schwartz_logPhase_inversion g₂ x₂, ← integral_const_mul, ← integral_mul_const] + apply integral_congr_ae + filter_upwards with t₂ + ring + simp_rw [hmid] + rw [integral_mul_const, integral_mul_const, ← schwartz_logPhase_inversion] + dsimp only [P, x₁, x₂, xk] + ring + +theorem descent_profile_separation {ι : Type*} [Fintype ι] + (g₁ g₂ W : 𝓢(ℝ, ℂ)) (V : ι → ℝ → ℂ) (a₁ a₂ ak M : ι → ℝ) + (hM : ∀ i, 0 ≤ M i) (hV : ∀ i y, V i y ≠ 0 → |y| ≤ M i) + (A J : ℕ) : + ∃ C : ℝ, 0 ≤ C ∧ ∀ R : ℝ, 0 < R → ∃ b : 𝓢(ℝ, ℂ), + (∀ y : ι → ℝ, + (∏ i, V i (y i)) * g₁ (∑ i, a₁ i * y i) * g₂ (∑ i, a₂ i * y i) * + paperRadialFourier W (R * Real.exp (∑ i, ak i * y i)) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, + tripleCoefficient (𝓕 g₁) (𝓕 g₂) b (t₁, t₂, t₃) * + (∏ i, V i (y i) * logPhase t₁ (a₁ i * y i) * + logPhase t₂ (a₂ i * y i) * logPhase t₃ (ak i * y i))) ∧ + Integrable (fun t : ℝ => (1 + ‖t‖) ^ J * ‖b t‖) ∧ + (1 + R) ^ A * (∫ t : ℝ, (1 + ‖t‖) ^ J * ‖b t‖) ≤ C ∧ + (∀ t : ℝ, (1 + R) ^ A * (1 + ‖t‖) ^ J * ‖b t‖ ≤ C) := by + obtain ⟨C, hC, hk⟩ := paperRadialFourier_log_separation_envelope W V ak M hM hV A J + refine ⟨C, hC, ?_⟩ + intro R hR + obtain ⟨b, he, hi, hb, hp⟩ := hk R hR + refine ⟨b, ?_, hi, hb, hp⟩ + exact descent_profile_identity g₁ g₂ W V a₁ a₂ ak R b he + +theorem tripleCoefficient_weighted_integrable (b₁ b₂ b₃ : 𝓢(ℝ, ℂ)) (J : ℕ) : + Integrable (fun t : Frequency => + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient b₁ b₂ b₃ t‖) := by + have hi (b : 𝓢(ℝ, ℂ)) : Integrable (fun t : ℝ => (1 + ‖t‖)^J * ‖b t‖) := by + have he : (𝓕 (𝓕⁻ b) : 𝓢(ℝ, ℂ)) = b := by simp + simpa only [he] using AnalyticBridge.schwartz_fourier_one_plus_integrable (𝓕⁻ b) J + convert (hi b₁).mul_prod ((hi b₂).mul_prod (hi b₃)) using 1 + funext t + simp only [tripleCoefficient, norm_mul] + ring + +theorem tripleCoefficient_weighted_integral (b₁ b₂ b₃ : 𝓢(ℝ, ℂ)) (J : ℕ) : + (∫ t : Frequency, + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient b₁ b₂ b₃ t‖) = + (∫ t : ℝ, (1 + ‖t‖)^J * ‖b₁ t‖) * + (∫ t : ℝ, (1 + ‖t‖)^J * ‖b₂ t‖) * + (∫ t : ℝ, (1 + ‖t‖)^J * ‖b₃ t‖) := by + have he (t : Frequency) : + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient b₁ b₂ b₃ t‖ = + ((1 + ‖t.1‖)^J * ‖b₁ t.1‖) * + (((1 + ‖t.2.1‖)^J * ‖b₂ t.2.1‖) * ((1 + ‖t.2.2‖)^J * ‖b₃ t.2.2‖)) := by + simp only [tripleCoefficient, norm_mul] + ring + simp_rw [he] + simp only [Measure.volume_eq_prod] + rw [MeasureTheory.integral_prod_mul + (fun t : ℝ => (1 + ‖t‖)^J * ‖b₁ t‖) + (fun t : ℝ × ℝ => ((1 + ‖t.1‖)^J * ‖b₂ t.1‖) * ((1 + ‖t.2‖)^J * ‖b₃ t.2‖))] + rw [MeasureTheory.integral_prod_mul + (fun t : ℝ => (1 + ‖t‖)^J * ‖b₂ t‖) (fun t : ℝ => (1 + ‖t‖)^J * ‖b₃ t‖)] + ring + +theorem source_descent_profile_separation {ι : Type*} [Fintype ι] + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (V : ι → ℝ → ℂ) (a₁ a₂ ak M : ι → ℝ) + (hM : ∀ i, 0 ≤ M i) (hV : ∀ i y, V i y ≠ 0 → |y| ≤ M i) + (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ y : ι → ℝ, + (∏ i, V i (y i)) * W₁ (Real.exp (∑ i, a₁ i * y i)) * + W₂ (Real.exp (∑ i, a₂ i * y i)) * paperRadialFourier Φ (R * Real.exp (∑ i, ak i * y i)) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, + tripleCoefficient b₁ b₂ b₃ (t₁, t₂, t₃) * + (∏ i, V i (y i) * logPhase t₁ (a₁ i * y i) * + logPhase t₂ (a₂ i * y i) * logPhase t₃ (ak i * y i))) ∧ + Integrable (fun t : Frequency => + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient b₁ b₂ b₃ t‖) ∧ + (1 + R)^A * (∫ t : Frequency, + ((1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J) * + ‖tripleCoefficient b₁ b₂ b₃ t‖) ≤ C := by + let g₁ := CubicReflectionKernel.logSchwartz W₁ a b ha hs₁ hW₁ + let g₂ := CubicReflectionKernel.logSchwartz W₂ a b ha hs₂ hW₂ + obtain ⟨C, hC, hsep⟩ := descent_profile_separation g₁ g₂ Φ V a₁ a₂ ak M hM hV A J + let I₁ := ∫ t : ℝ, (1 + ‖t‖)^J * ‖(𝓕 g₁) t‖ + let I₂ := ∫ t : ℝ, (1 + ‖t‖)^J * ‖(𝓕 g₂) t‖ + have hI₁ : 0 ≤ I₁ := integral_nonneg (fun t => by positivity) + have hI₂ : 0 ≤ I₂ := integral_nonneg (fun t => by positivity) + refine ⟨𝓕 g₁, 𝓕 g₂, I₁ * I₂ * C, by positivity, ?_⟩ + intro R hR + obtain ⟨b₃, heq, hi, hb, hp⟩ := hsep R hR + refine ⟨b₃, ?_, tripleCoefficient_weighted_integrable _ _ _ J, ?_⟩ + · simpa only [g₁, g₂, CubicReflectionKernel.logSchwartz_apply] using heq + · rw [tripleCoefficient_weighted_integral] + have hh := mul_le_mul_of_nonneg_left hb (mul_nonneg hI₁ hI₂) + convert hh using 1 ; dsimp only [I₁, I₂] ; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/DivisorExtraction.lean b/lean/OAI/NumberTheory/DirichletL/Descent/DivisorExtraction.lean new file mode 100644 index 0000000000000000000000000000000000000000..46b5409f5ad429cb95fe064a2b7e52c52893dfd1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/DivisorExtraction.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Descent.Quotients + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss IdealMobiusDivisorSum +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem inverseCubicKernel_divisor_overlap_zero (R r P c m : Ideal Eis) + (hP : primaryGenerator P ≠ 0) (hcm : primaryGenerator (c * m) ≠ 0) + (hRP : R ∣ P) (hrc : r ∣ c) (hRr : ¬ IsCoprime R r) : + inverseCubicKernel P (c * m) = 0 := by + apply inverseCubicKernel_eq_zero_of_not_coprime P (c * m) hP hcm + intro hcop + have hPc := hcop.of_isCoprime_of_dvd_right (dvd_mul_right c m) + exact hRr ((hPc.of_isCoprime_of_dvd_left hRP).of_isCoprime_of_dvd_right hrc) + +theorem double_divisor_row_reindex {A : Type*} [AddCommMonoid A] + (rows : Finset (Ideal Eis)) (hrows : ∀ k ∈ rows, k ≠ 0) + (R r : Ideal Eis) (hRr : IsCoprime R r) (F : Ideal Eis → A) : + (∑ k ∈ rows, if (R, r) ∈ (idealDivisors k) ×ˢ (idealDivisors k) then F k else 0) = + ∑ k ∈ quotientSupport (R * r) rows, F ((R * r) * k) := by + have hsel (k : Ideal Eis) (hk : k ∈ rows) : + ((R, r) ∈ (idealDivisors k) ×ˢ (idealDivisors k)) ↔ R * r ∣ k := by + rw [Finset.mem_product, mem_idealDivisors (hrows k hk), mem_idealDivisors (hrows k hk)] + exact ⟨fun h => hRr.mul_dvd h.1 h.2, + fun h => ⟨dvd_trans (dvd_mul_right R r) h, dvd_trans (dvd_mul_left r R) h⟩⟩ + calc + _ = ∑ k ∈ rows, if R * r ∣ k then F k else 0 := by + apply Finset.sum_congr rfl + intro k hk + simp only [hsel k hk] + _ = ∑ k ∈ rows with R * r ∣ k, F k := (Finset.sum_filter _ _).symm + _ = _ := sum_quotientSupport (R * r) rows F + +theorem double_column_divisor_reindex {A : Type*} [AddCommMonoid A] + (Pset cset : Finset (Ideal Eis)) (R r : Ideal Eis) + (F : Ideal Eis → Ideal Eis → A) : + (∑ P ∈ Pset, ∑ c ∈ cset, if R ∣ P ∧ r ∣ c then F P c else 0) = + ∑ P ∈ quotientSupport R Pset, ∑ c ∈ quotientSupport r cset, F (R * P) (r * c) := by + calc + _ = ∑ P ∈ Pset with R ∣ P, ∑ c ∈ cset with r ∣ c, F P c := by + simp only [Finset.sum_filter] + apply Finset.sum_congr rfl + intro P hP + by_cases hd : R ∣ P + · simp only [hd, true_and, ite_true] + · simp [hd] + _ = ∑ P ∈ quotientSupport R Pset, ∑ c ∈ cset with r ∣ c, F (R * P) c := + sum_quotientSupport R Pset (fun P => ∑ c ∈ cset with r ∣ c, F P c) + _ = _ := by + apply Finset.sum_congr rfl + intro P hP + exact sum_quotientSupport r cset (F (R * P)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/DivisorSum.lean b/lean/OAI/NumberTheory/DirichletL/Descent/DivisorSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..6f05a147c256cc645dfa7f091042a2945d38d1d4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/DivisorSum.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Descent.DivisorExtraction + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve IdealMobiusDivisorSum +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def hybridDivisorPool (rows : Finset (Ideal Eis)) : Finset (Ideal Eis) := + rows.biUnion idealDivisors + +def hybridDivisorPairPool (rows : Finset (Ideal Eis)) : Finset (Ideal Eis × Ideal Eis) := + rows.biUnion fun k => (idealDivisors k) ×ˢ (idealDivisors k) + +theorem hybridDivisorPool_bounds (rows : Finset (Ideal Eis)) (K : ℝ) + (hrows : ∀ k ∈ rows, k ≠ 0 ∧ (Ideal.absNorm k : ℝ) ≤ K) + (D : Ideal Eis) (hD : D ∈ hybridDivisorPool rows) : + D ≠ 0 ∧ (Ideal.absNorm D : ℝ) ≤ K := by + obtain ⟨k, hk, hDk⟩ := Finset.mem_biUnion.mp hD + have hdiv := (mem_idealDivisors (hrows k hk).1).mp hDk + exact ⟨ne_zero_of_dvd_ne_zero (hrows k hk).1 hdiv, + (QuadraticMainBoundary.norm_le_of_dvd (hrows k hk).1 hdiv).trans (hrows k hk).2⟩ + +theorem hybridDivisorPairPool_subset (rows : Finset (Ideal Eis)) : + hybridDivisorPairPool rows ⊆ (hybridDivisorPool rows) ×ˢ (hybridDivisorPool rows) := by + intro D hD + obtain ⟨k, hk, hDk⟩ := Finset.mem_biUnion.mp hD + exact Finset.mem_product.mpr + ⟨Finset.mem_biUnion.mpr ⟨k, hk, (Finset.mem_product.mp hDk).1⟩, + Finset.mem_biUnion.mpr ⟨k, hk, (Finset.mem_product.mp hDk).2⟩⟩ + +theorem hybrid_divisor_pair_inverse_norm_sum + (rows : Finset (Ideal Eis)) (K : ℝ) + (hrows : ∀ k ∈ rows, k ≠ 0 ∧ (Ideal.absNorm k : ℝ) ≤ K) : + (∑ D ∈ hybridDivisorPairPool rows, + 1 / ((Ideal.absNorm D.1 : ℝ) * (Ideal.absNorm D.2 : ℝ))) ≤ + (256 * (columnDyadicLength K + 1 : ℝ)) ^ 2 := by + have hb := hybridDivisorPool_bounds rows K hrows + have hsum := finite_inverse_norm_sum (hybridDivisorPool rows) K + (fun D hD => (hb D hD).1) (fun D hD => (hb D hD).2) + calc + _ ≤ ∑ D ∈ (hybridDivisorPool rows) ×ˢ (hybridDivisorPool rows), + 1 / ((Ideal.absNorm D.1 : ℝ) * (Ideal.absNorm D.2 : ℝ)) := by + apply Finset.sum_le_sum_of_subset_of_nonneg (hybridDivisorPairPool_subset rows) + intro D hD hn + positivity + _ = (∑ D ∈ hybridDivisorPool rows, 1 / (Ideal.absNorm D : ℝ)) ^ 2 := by + rw [Finset.sum_product, pow_two, Finset.sum_mul_sum] + apply Finset.sum_congr rfl + intro R hR + apply Finset.sum_congr rfl + intro r hr + ring + _ ≤ _ := pow_le_pow_left₀ (Finset.sum_nonneg fun _ _ => by positivity) hsum 2 + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Dyadic.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Dyadic.lean new file mode 100644 index 0000000000000000000000000000000000000000..ec2df96b3df13f5f0c0026f03e2b56bf04f1e505 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Dyadic.lean @@ -0,0 +1,131 @@ +import OAI.NumberTheory.DirichletL.Descent.Reconstruction +import OAI.NumberTheory.DirichletL.Descent.SieveComposition + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def hybridSquarePool (S : Finset (Ideal Eis × Ideal Eis)) : Finset (Ideal Eis) := + (hybridColumnSupport S).image HybridColumnData.square + +def hybridCommonBlock (S : Finset (Ideal Eis × Ideal Eis)) (N : ℝ) + (i : Fin (columnDyadicLength N + 1)) (t : Ideal Eis) : Finset HybridColumnData := + (hybridColumnSupport S).filter fun d => + d.square = t ∧ divisorDyadicLabel N d.common = i + +theorem hybrid_dyadic_reindex {A : Type*} [AddCommMonoid A] + (S : Finset (Ideal Eis × Ideal Eis)) (N B : ℝ) (f : HybridColumnData → A) : + (∑ d ∈ hybridColumnSupport S, f d) = + ∑ j : Fin (columnDyadicLength B + 1), + ∑ i : Fin (columnDyadicLength N + 1), + ∑ t ∈ divisorDyadicBin (hybridSquarePool S) B j, + ∑ d ∈ hybridCommonBlock S N i t, f d := by + have ht : (∑ d ∈ hybridColumnSupport S, f d) = + ∑ t ∈ hybridSquarePool S, ∑ d ∈ hybridColumnSupport S with d.square = t, f d := by + symm + exact Finset.sum_fiberwise_of_maps_to + (fun d hd => Finset.mem_image.mpr ⟨d, hd, rfl⟩) f + rw [ht, sum_divisorDyadicBins (hybridSquarePool S) B] + apply Finset.sum_congr rfl + intro j hj + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro t ht + have hi := Finset.sum_fiberwise + ((hybridColumnSupport S).filter fun d => d.square = t) + (fun d => divisorDyadicLabel N d.common) f + simpa only [Finset.filter_filter, hybridCommonBlock] using hi.symm + +theorem hybridSquarePool_bounds (S : Finset (Ideal Eis × Ideal Eis)) (B : ℝ) + (hS : ∀ p ∈ S, (Ideal.absNorm p.2 : ℝ) ≤ B) + (t : Ideal Eis) (ht : t ∈ hybridSquarePool S) : + 1 ≤ (Ideal.absNorm t : ℝ) ∧ (Ideal.absNorm t : ℝ) ≤ B := by + obtain ⟨d, hd, rfl⟩ := Finset.mem_image.mp ht + have hb0 : (d.common * d.residualB) * d.square ^ 2 ≠ 0 := + mul_ne_zero d.g_squarefree.ne_zero (pow_ne_zero _ d.square_ne_zero) + refine ⟨QuadraticMainBoundary.norm_one_le d.square_ne_zero, ?_⟩ + apply (QuadraticMainBoundary.norm_le_of_dvd hb0 ?_).trans + (hS d.reconstruct ((mem_hybridColumnSupport S d).mp hd)) + exact dvd_mul_of_dvd_right (dvd_pow_self d.square (by norm_num : 2 ≠ 0)) _ + +theorem hybridSquarePool_bin_count (S : Finset (Ideal Eis × Ideal Eis)) (B : ℝ) + (hS : ∀ p ∈ S, (Ideal.absNorm p.2 : ℝ) ≤ B) + (j : Fin (columnDyadicLength B + 1)) : + ((divisorDyadicBin (hybridSquarePool S) B j).card : ℝ) ≤ + 256 * divisorDyadicScale j.val := by + have hscale := divisorDyadicScale_ge_one j.val + have hb := divisorDyadicBin_bounds (hybridSquarePool S) B + (hybridSquarePool_bounds S B hS) j + have hc := DescentFiberCost.finite_ideal_count_real + (divisorDyadicBin (hybridSquarePool S) B j) (2 * divisorDyadicScale j.val) + (by linarith) (fun t ht hz => by + have hp := (hb t ht).1 + simp [hz] at hp + linarith) (fun t ht => (hb t ht).2) + linarith + +theorem hybridCommonBlock_bounds + (S : Finset (Ideal Eis × Ideal Eis)) (N B : ℝ) (hN : 0 ≤ N) (hB : 0 ≤ B) + (hS : ∀ p ∈ S, (Ideal.absNorm p.1 : ℝ) ≤ N ∧ (Ideal.absNorm p.2 : ℝ) ≤ B) + (i : Fin (columnDyadicLength N + 1)) (j : Fin (columnDyadicLength B + 1)) + (t : Ideal Eis) (ht : t ∈ divisorDyadicBin (hybridSquarePool S) B j) + (d : HybridColumnData) (hd : d ∈ hybridCommonBlock S N i t) : + let C := divisorDyadicScale i.val + let T := divisorDyadicScale j.val + C ≤ (Ideal.absNorm d.common : ℝ) ∧ (Ideal.absNorm d.common : ℝ) ≤ 2 * C ∧ + (Ideal.absNorm d.residualN : ℝ) ≤ N / C ∧ + (Ideal.absNorm d.residualB : ℝ) ≤ B / (C * T ^ 2) ∧ + (Ideal.absNorm (d.residualN * d.residualB) : ℝ) ≤ N * B / (C ^ 2 * T ^ 2) := by + obtain ⟨hdS, hdt, hdi⟩ := Finset.mem_filter.mp hd + have hs := hS d.reconstruct ((mem_hybridColumnSupport S d).mp hdS) + have hc1 := QuadraticMainBoundary.norm_one_le d.common_ne_zero + have hcn : (Ideal.absNorm d.common : ℝ) ≤ N := + (QuadraticMainBoundary.norm_le_of_dvd d.n_squarefree.ne_zero (dvd_mul_right _ _)).trans hs.1 + have hcb := divisorDyadicLabel_bounds N d.common hc1 hcn + rw [hdi] at hcb + have hcLow : divisorDyadicScale i.val ≤ (Ideal.absNorm d.common : ℝ) := + max_le hc1 hcb.1.le + have hcHigh : (Ideal.absNorm d.common : ℝ) ≤ 2 * divisorDyadicScale i.val := by + have hh : (2 : ℝ) ^ i.val / 2 ≤ divisorDyadicScale i.val := le_max_right _ _ + linarith [hcb.2] + have htLow := (divisorDyadicBin_bounds (hybridSquarePool S) B + (hybridSquarePool_bounds S B (fun p hp => (hS p hp).2)) j t ht).1 + rw [← hdt] at htLow + refine ⟨hcLow, hcHigh, ?_⟩ + exact d.residual_norm_bounds N B (divisorDyadicScale i.val) (divisorDyadicScale j.val) + hN hB (by linarith [divisorDyadicScale_ge_one i.val]) + (by linarith [divisorDyadicScale_ge_one j.val]) hs.1 hs.2 hcLow htLow + +theorem hybrid_square_dyad_energy + (S : Finset (Ideal Eis × Ideal Eis)) (B : ℝ) + (hS : ∀ p ∈ S, (Ideal.absNorm p.2 : ℝ) ≤ B) + (j : Fin (columnDyadicLength B + 1)) (rows : Finset (Ideal Eis)) + (F : Ideal Eis → Ideal Eis → ℂ) (E : ℝ) (hE : 0 ≤ E) + (hF : ∀ t ∈ divisorDyadicBin (hybridSquarePool S) B j, + (∑ k ∈ rows, ‖F t k‖ ^ 2) ≤ E) : + (∑ k ∈ rows, ‖∑ t ∈ divisorDyadicBin (hybridSquarePool S) B j, F t k‖ ^ 2) ≤ + (256 * divisorDyadicScale j.val) ^ 2 * E := by + let Tset := divisorDyadicBin (hybridSquarePool S) B j + have hc := hybridSquarePool_bin_count S B hS j + calc + _ ≤ (Tset.card : ℝ) * ∑ t ∈ Tset, ∑ k ∈ rows, ‖F t k‖ ^ 2 := by + calc + _ ≤ ∑ k ∈ rows, (Tset.card : ℝ) * ∑ t ∈ Tset, ‖F t k‖ ^ 2 := by + apply Finset.sum_le_sum + intro k hk + simpa using bounded_finset_coefficient_sum_sq Tset (fun _ => 1) (fun t => F t k) + (by simp) + _ = _ := by rw [← Finset.mul_sum, Finset.sum_comm] + _ ≤ (Tset.card : ℝ) * ∑ _t ∈ Tset, E := + mul_le_mul_of_nonneg_left (Finset.sum_le_sum hF) (Nat.cast_nonneg _) + _ = (Tset.card : ℝ) ^ 2 * E := by simp; ring + _ ≤ _ := mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (Nat.cast_nonneg _) hc 2) hE + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/DyadicBlock.lean b/lean/OAI/NumberTheory/DirichletL/Descent/DyadicBlock.lean new file mode 100644 index 0000000000000000000000000000000000000000..cf3d65e5c99e3cc8f572b89f6d9d288e69a6bc98 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/DyadicBlock.lean @@ -0,0 +1,165 @@ +import OAI.NumberTheory.DirichletL.Descent.ExtractedGrid +import OAI.NumberTheory.DirichletL.Descent.OriginalBlock + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem hybrid_extracted_dyadic_block_nonempty (ε : ℝ) (hε : 0 < ε) : + ∃ C₀ : ℝ, 0 < C₀ ∧ ∀ K N B L C T : ℝ, + 1 ≤ K → 1 ≤ N → 1 ≤ B → 1 ≤ C → 1 ≤ T → + ∀ (R r t : Ideal Eis), R ≠ 0 → r ≠ 0 → T ≤ (Ideal.absNorm t : ℝ) → + ∀ (rows nset Pset : Finset (Ideal Eis)) (D : Finset HybridColumnData) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → + (∀ d ∈ D, d.square = t ∧ C ≤ (Ideal.absNorm d.common : ℝ) ∧ + (Ideal.absNorm d.common : ℝ) ≤ 2 * C ∧ d.common * d.residualN ∈ nset ∧ + (Ideal.absNorm ((d.common * d.residualB) * d.square ^ 2) : ℝ) ≤ B) → + (∀ d ∈ D, ‖beta d.common d.residualN d.residualB‖ ≤ 1) → + (quotientGridSupport r (hybridGridSupport D)).Nonempty → + (∑ k ∈ quotientSupport (R * r) rows, + ‖gridDivisorHybridBlock (hybridGridSupport D) Pset a beta t ((R * r) * k) R r‖ ^ 2) ≤ + C₀ * (K * (N * B) * N) ^ ε * (K + N * B) * B / + ((Ideal.absNorm R : ℝ) * (Ideal.absNorm r : ℝ) * T ^ 2) * + CubicSieve.sieveNorm N (2 * L) := by + obtain ⟨C₁, hC₁, hblock⟩ := hybrid_original_quotient_block ε hε + refine ⟨2 * C₁, by positivity, ?_⟩ + intro K N B L C T hK hN hB hC hT R r t hR hr ht rows nset Pset D a beta + hrows hn hP ha hD hbeta hQ + let Q := quotientGridSupport r (hybridGridSupport D) + let X := N * B / (C ^ 2 * T ^ 2) + let A := 2 * C / (Ideal.absNorm r : ℝ) + let H := B / (C * T ^ 2) + have hC0 : 0 < C := by linarith + have hT0 : 0 < T := by linarith + have hnr : 0 < (Ideal.absNorm r : ℝ) := QuadraticMainBoundary.norm_pos hr + have hnorm (d : HybridColumnData) (hd : d ∈ D) : + (Ideal.absNorm d.residualN : ℝ) ≤ N / C ∧ + (Ideal.absNorm d.residualB : ℝ) ≤ H ∧ + (Ideal.absNorm (d.residualN * d.residualB) : ℝ) ≤ X := by + have hd' := hD d hd + apply d.residual_norm_bounds N B C T (by linarith) (by linarith) hC0 hT0 + (hn _ hd'.2.2.2.1).2 hd'.2.2.2.2 hd'.2.1 + simpa only [hd'.1] using ht + have hcBound (d : HybridColumnData) (hd : d ∈ D) (c : Ideal Eis) + (hdc : d.common = r * c) : c ≠ 0 ∧ (Ideal.absNorm c : ℝ) ≤ A := by + have hcz : c ≠ 0 := by + intro hz + apply d.common_ne_zero + simp [hdc, hz] + refine ⟨hcz, (le_div_iff₀ hnr).mpr ?_⟩ + have hdcN := (hD d hd).2.2.1 + rw [hdc, map_mul, Nat.cast_mul] at hdcN + simpa only [mul_comm] using hdcN + have hpair (p : Ideal Eis × Ideal Eis) (hp : p ∈ Q.image Prod.fst) : + Squarefree (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X ∧ + p.2 ≠ 0 ∧ (Ideal.absNorm p.2 : ℝ) ≤ H := by + obtain ⟨u, hu, hup⟩ := Finset.mem_image.mp hp + obtain ⟨d, hd, he, hdc⟩ := quotientGridSupport_origin r hr D u.1 u.2 hu + have he' : (d.residualN, d.residualB) = p := he.trans hup + have hm := congrArg Prod.fst he' + have hh := congrArg Prod.snd he' + have hdB : d.residualB ≠ 0 := + ne_zero_of_dvd_ne_zero d.g_squarefree.ne_zero (dvd_mul_left _ _) + exact ⟨by simpa only [← hm, ← hh] using d.residual_product_squarefree, + by simpa only [← hm, ← hh] using (hnorm d hd).2.2, + by simpa only [← hh] using hdB, + by simpa only [← hh] using (hnorm d hd).2.1⟩ + have hcset (p : Ideal Eis × Ideal Eis) (hp : p ∈ Q.image Prod.fst) + (c : Ideal Eis) (hc : c ∈ gridCommonSupport Q p.1) : + c ≠ 0 ∧ (Ideal.absNorm c : ℝ) ≤ A ∧ (r * c) * p.1 ∈ nset := by + obtain ⟨d, hd, hm, hdc⟩ := quotientGridCommonSupport_origin r hr D p.1 c hc + have hc' := hcBound d hd c hdc + exact ⟨hc'.1, hc'.2, by simpa only [hdc, hm] using (hD d hd).2.2.2.1⟩ + obtain ⟨u₀, hu₀⟩ := hQ + have hp₀ : u₀.1 ∈ Q.image Prod.fst := Finset.mem_image.mpr ⟨u₀, hu₀, rfl⟩ + have hc₀ : u₀.2 ∈ gridCommonSupport Q u₀.1.1 := + Finset.mem_image.mpr ⟨u₀, Finset.mem_filter.mpr ⟨hu₀, rfl⟩, rfl⟩ + have hX : 1 ≤ X := + (QuadraticMainBoundary.norm_one_le (hpair u₀.1 hp₀).1.ne_zero).trans (hpair u₀.1 hp₀).2.1 + have hH : 1 ≤ H := + (QuadraticMainBoundary.norm_one_le (hpair u₀.1 hp₀).2.2.1).trans (hpair u₀.1 hp₀).2.2.2 + have hA : 1 ≤ A := + (QuadraticMainBoundary.norm_one_le (hcset u₀.1 hp₀ u₀.2 hc₀).1).trans + (hcset u₀.1 hp₀ u₀.2 hc₀).2.1 + have hbGrid : ∀ u ∈ hybridGridSupport D, ‖beta u.2 u.1.1 u.1.2‖ ≤ 1 := by + intro u hu + obtain ⟨d, hd, rfl⟩ := Finset.mem_image.mp hu + exact hbeta d hd + have he := hblock K X N L A H hK hX hN hA hH R r t hR hr rows nset Pset + (Q.image Prod.fst) (gridCommonSupport Q) a + (extractedGridCoefficient (hybridGridSupport D) R t beta) + hrows hn hP ha (fun p hp => ⟨(hpair p hp).1, (hpair p hp).2.1⟩) + (fun p hp => (hpair p hp).2.2) hcset + (fun p _ c _ => extractedGridCoefficient_norm_le_one _ R t beta hbGrid (r * c) p.1 p.2) + have hrow (k : Ideal Eis) (hk : k ∈ quotientSupport (R * r) rows) := + gridDivisorHybridBlock_extract (hybridGridSupport D) Pset a beta t k R r hR hr + (hrows _ ((mem_quotientSupport (R * r) k (mul_ne_zero hR hr) rows).mp hk)).1 + (fun P hP' => (hP P hP').1) + have he' : (∑ k ∈ quotientSupport (R * r) rows, + ‖gridDivisorHybridBlock (hybridGridSupport D) Pset a beta t ((R * r) * k) R r‖ ^ 2) ≤ + C₁ * (K * X * N) ^ ε * (K + X) * A * H / + (Ideal.absNorm R : ℝ) * CubicSieve.sieveNorm N (2 * L) := by + calc + _ = _ := Finset.sum_congr rfl (fun k hk => congrArg (fun z : ℂ => ‖z‖ ^ 2) (hrow k hk)) + _ ≤ _ := he + have hXupper : X ≤ N * B := by + apply div_le_self (by positivity : 0 ≤ N * B) + have hC2 : 1 ≤ C ^ 2 := one_le_pow₀ hC + have hT2 : 1 ≤ T ^ 2 := one_le_pow₀ hT + exact one_le_mul_of_one_le_of_one_le hC2 hT2 + apply he'.trans + calc + _ ≤ C₁ * (K * (N * B) * N) ^ ε * (K + N * B) * A * H / + (Ideal.absNorm R : ℝ) * CubicSieve.sieveNorm N (2 * L) := by + have hs : 0 ≤ CubicSieve.sieveNorm N (2 * L) := sq_nonneg _ + gcongr + _ = _ := by + dsimp only [A, H] + field_simp + +theorem hybrid_extracted_dyadic_block (ε : ℝ) (hε : 0 < ε) : + ∃ C₀ : ℝ, 0 < C₀ ∧ ∀ K N B L C T : ℝ, + 1 ≤ K → 1 ≤ N → 1 ≤ B → 1 ≤ C → 1 ≤ T → + ∀ (R r t : Ideal Eis), R ≠ 0 → r ≠ 0 → T ≤ (Ideal.absNorm t : ℝ) → + ∀ (rows nset Pset : Finset (Ideal Eis)) (D : Finset HybridColumnData) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → + (∀ d ∈ D, d.square = t ∧ C ≤ (Ideal.absNorm d.common : ℝ) ∧ + (Ideal.absNorm d.common : ℝ) ≤ 2 * C ∧ d.common * d.residualN ∈ nset ∧ + (Ideal.absNorm ((d.common * d.residualB) * d.square ^ 2) : ℝ) ≤ B) → + (∀ d ∈ D, ‖beta d.common d.residualN d.residualB‖ ≤ 1) → + (∑ k ∈ quotientSupport (R * r) rows, + ‖gridDivisorHybridBlock (hybridGridSupport D) Pset a beta t ((R * r) * k) R r‖ ^ 2) ≤ + C₀ * (K * (N * B) * N) ^ ε * (K + N * B) * B / + ((Ideal.absNorm R : ℝ) * (Ideal.absNorm r : ℝ) * T ^ 2) * + CubicSieve.sieveNorm N (2 * L) := by + obtain ⟨C₀, hC₀, he⟩ := hybrid_extracted_dyadic_block_nonempty ε hε + refine ⟨C₀, hC₀, ?_⟩ + intro K N B L C T hK hN hB hC hT R r t hR hr ht rows nset Pset D a beta + hrows hn hP ha hD hbeta + by_cases hQ : (quotientGridSupport r (hybridGridSupport D)).Nonempty + · exact he K N B L C T hK hN hB hC hT R r t hR hr ht + rows nset Pset D a beta hrows hn hP ha hD hbeta hQ + · have hQ' := Finset.not_nonempty_iff_eq_empty.mp hQ + simp only [gridDivisorHybridBlock_eq_zero_of_quotientGrid_empty _ _ _ _ _ _ _ _ hQ', + norm_zero, zero_pow (by norm_num : 2 ≠ 0), Finset.sum_const_zero] + have hs : 0 ≤ CubicSieve.sieveNorm N (2 * L) := sq_nonneg _ + positivity + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ExtractedGrid.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ExtractedGrid.lean new file mode 100644 index 0000000000000000000000000000000000000000..49c6e501cbd2f90bff5b60fa5bcb07c27e949fee --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ExtractedGrid.lean @@ -0,0 +1,161 @@ +import OAI.NumberTheory.DirichletL.Descent.Grid +import OAI.NumberTheory.DirichletL.Descent.DivisorExtraction + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local notation "Grid" => Finset ((Ideal Eis × Ideal Eis) × Ideal Eis) + +def quotientGridSupport (r : Ideal Eis) (T : Grid) : Grid := + (T.filter fun u => r ∣ u.2).image fun u => (u.1, idealQuotient r u.2) + +@[simp] theorem mem_quotientGridSupport (r : Ideal Eis) (hr : r ≠ 0) + (T : Grid) (p : Ideal Eis × Ideal Eis) (c : Ideal Eis) : + (p, c) ∈ quotientGridSupport r T ↔ (p, r * c) ∈ T := by + constructor + · intro hu + obtain ⟨u, hu, he⟩ := Finset.mem_image.mp hu + obtain ⟨huT, hru⟩ := Finset.mem_filter.mp hu + have hp : u.1 = p := congrArg Prod.fst he + have hc : idealQuotient r u.2 = c := congrArg Prod.snd he + have hec : r * c = u.2 := by rw [← hc, idealQuotient_mul hru] + simpa only [← hp, hec, Prod.eta] using huT + · intro hu + refine Finset.mem_image.mpr ⟨(p, r * c), Finset.mem_filter.mpr ⟨hu, dvd_mul_right _ _⟩, ?_⟩ + refine Prod.ext (show p = p from rfl) ?_ + exact mul_left_cancel₀ hr (idealQuotient_mul (dvd_mul_right r c)) + +theorem sum_quotientGridSupport {A : Type*} [AddCommMonoid A] + (r : Ideal Eis) (T : Grid) (f : (Ideal Eis × Ideal Eis) × Ideal Eis → A) : + (∑ u ∈ T, if r ∣ u.2 then f u else 0) = + ∑ u ∈ quotientGridSupport r T, f (u.1, r * u.2) := by + rw [← Finset.sum_filter, quotientGridSupport, Finset.sum_image] + · apply Finset.sum_congr rfl + intro u hu + rw [idealQuotient_mul (Finset.mem_filter.mp hu).2] + · intro u hu v hv he + apply Prod.ext + · simpa only using congrArg Prod.fst he + · exact idealQuotient_injective_on r (Finset.mem_filter.mp hu).2 + (Finset.mem_filter.mp hv).2 (congrArg Prod.snd he) + +theorem quotientGridSupport_origin (r : Ideal Eis) (hr : r ≠ 0) + (D : Finset HybridColumnData) (p : Ideal Eis × Ideal Eis) (c : Ideal Eis) + (hu : (p, c) ∈ quotientGridSupport r (hybridGridSupport D)) : + ∃ d ∈ D, (d.residualN, d.residualB) = p ∧ d.common = r * c := by + have hm := (mem_quotientGridSupport r hr (hybridGridSupport D) p c).mp hu + obtain ⟨d, hd, he⟩ := Finset.mem_image.mp hm + exact ⟨d, hd, congrArg Prod.fst he, congrArg Prod.snd he⟩ + +theorem quotientGridCommonSupport_origin (r : Ideal Eis) (hr : r ≠ 0) + (D : Finset HybridColumnData) (m c : Ideal Eis) + (hc : c ∈ gridCommonSupport (quotientGridSupport r (hybridGridSupport D)) m) : + ∃ d ∈ D, d.residualN = m ∧ d.common = r * c := by + obtain ⟨u, hu, he⟩ := Finset.mem_image.mp hc + obtain ⟨huQ, hum⟩ := Finset.mem_filter.mp hu + obtain ⟨d, hd, hp, hdc⟩ := quotientGridSupport_origin r hr D u.1 u.2 huQ + refine ⟨d, hd, (congrArg Prod.fst hp).trans hum, ?_⟩ + simpa only [he] using hdc + +def extractedGridCoefficient (T : Grid) (R t : Ideal Eis) + (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (c m h : Ideal Eis) : ℂ := + if ((m, h), c) ∈ T then beta c m h * (if IsCoprime R (h * t) then 1 else 0) else 0 + +theorem extractedGridCoefficient_norm_le_one (T : Grid) (R t : Ideal Eis) + (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (hb : ∀ u ∈ T, ‖beta u.2 u.1.1 u.1.2‖ ≤ 1) + (c m h : Ideal Eis) : ‖extractedGridCoefficient T R t beta c m h‖ ≤ 1 := by + unfold extractedGridCoefficient + split_ifs with hu hcop + · simpa using hb ((m, h), c) hu + · simp + · simp + +def gridDivisorHybridBlock (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (t k R r : Ideal Eis) : ℂ := + ∑ u ∈ T, if r ∣ u.2 then ∑ P ∈ Pset, if R ∣ P then + a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * beta u.2 u.1.1 u.1.2 * + (quadraticRow k (primaryGenerator (u.1.1 * u.1.2)) * inverseCubicKernel P (u.2 * u.1.1)) * + (if IsCoprime P (u.1.2 * t) then 1 else 0) + else 0 else 0 + +theorem gridDivisorHybridBlock_eq_zero_of_quotientGrid_empty + (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (t k R r : Ideal Eis) (hQ : quotientGridSupport r T = ∅) : + gridDivisorHybridBlock T Pset a beta t k R r = 0 := by + unfold gridDivisorHybridBlock + rw [sum_quotientGridSupport, hQ] + exact Finset.sum_empty + +theorem gridDivisorHybridBlock_extract + (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (t k R r : Ideal Eis) (hR : R ≠ 0) (hr : r ≠ 0) + (hk : Admissible ((R * r) * k)) + (hP : ∀ P ∈ Pset, CubicSieve.Admissible P) : + gridDivisorHybridBlock T Pset a beta t ((R * r) * k) R r = + (Real.sqrt (Ideal.absNorm R : ℝ) : ℂ)⁻¹ * + ∑ p ∈ (quotientGridSupport r T).image Prod.fst, + quadraticRow k (primaryGenerator (p.1 * p.2)) * + ∑ c ∈ gridCommonSupport (quotientGridSupport r T) p.1, + hybridColumnCoefficient R r (extractedGridCoefficient T R t beta) c p.1 p.2 * + ∑ P ∈ quotientSupport R Pset, + hybridCubicCoefficient R r p.2 t a P * inverseCubicKernel P (c * p.1) := by + have hmask (P h : Ideal Eis) : + (if IsCoprime (R * P) (h * t) then (1 : ℂ) else 0) = + (if IsCoprime R (h * t) then 1 else 0) * + (if IsCoprime P (h * t) then 1 else 0) := by + simp only [IsCoprime.mul_left_iff] + split_ifs <;> simp_all + unfold gridDivisorHybridBlock + rw [sum_quotientGridSupport] + have hinner (u : (Ideal Eis × Ideal Eis) × Ideal Eis) : + (∑ P ∈ Pset, if R ∣ P then + a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * beta (r * u.2) u.1.1 u.1.2 * + (quadraticRow ((R * r) * k) (primaryGenerator (u.1.1 * u.1.2)) * + inverseCubicKernel P ((r * u.2) * u.1.1)) * + (if IsCoprime P (u.1.2 * t) then 1 else 0) else 0) = + ∑ P ∈ quotientSupport R Pset, + a (R * P) / (Real.sqrt (Ideal.absNorm (R * P) : ℝ) : ℂ) * beta (r * u.2) u.1.1 u.1.2 * + (quadraticRow ((R * r) * k) (primaryGenerator (u.1.1 * u.1.2)) * + inverseCubicKernel (R * P) ((r * u.2) * u.1.1)) * + (if IsCoprime (R * P) (u.1.2 * t) then 1 else 0) := by + rw [← Finset.sum_filter] + exact sum_quotientSupport R Pset _ + simp_rw [hinner] + rw [finite_triple_support_reindex] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro p hp + apply Finset.sum_congr rfl + intro c hc + by_cases hu : (p, c) ∈ quotientGridSupport r T + · have huc := (mem_quotientGridSupport r hr T p c).mp hu + simp only [hu, ite_true] + apply Finset.sum_congr rfl + intro P hPP + have hpgen := (quotientSupport_cubic_admissible R hR Pset hP P hPP).2 + have hid := hybrid_extracted_block_identity R r k P c p.1 p.2 t hk hpgen a + (extractedGridCoefficient T R t beta) + simp only [extractedGridCoefficient, huc, ite_true] at hid + rw [hmask] + calc + _ = a (R * P) / (Real.sqrt (Ideal.absNorm (R * P) : ℝ) : ℂ) * + (beta (r * c) p.1 p.2 * (if IsCoprime R (p.2 * t) then 1 else 0)) * + (quadraticRow ((R * r) * k) (primaryGenerator (p.1 * p.2)) * + inverseCubicKernel (R * P) ((r * c) * p.1)) * + (if IsCoprime P (p.2 * t) then 1 else 0) := by ring + _ = _ := by rw [hid]; ring + · have huc : (p, r * c) ∉ T := (mem_quotientGridSupport r hr T p c).not.mp hu + simp [hu, hybridColumnCoefficient, extractedGridCoefficient, huc] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Fibers.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Fibers.lean new file mode 100644 index 0000000000000000000000000000000000000000..d12ed340736ddb88545711679fd0aa1e697be4db --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Fibers.lean @@ -0,0 +1,140 @@ +import Mathlib.Analysis.Complex.Basic +import Mathlib.Analysis.Real.Sqrt +import Mathlib.Tactic.Linarith +import Mathlib.Tactic.Ring + +namespace OAI + +namespace SevenEighths.InverseMoment + +open scoped BigOperators + +noncomputable section + +def weightedEnergy {ι : Type*} (s : Finset ι) (w : ι → ℝ) (f : ι → ℂ) : ℝ := + ∑ i ∈ s, w i * ‖f i‖ ^ 2 + +theorem weightedEnergy_nonneg {ι : Type*} (s : Finset ι) (w : ι → ℝ) + (f : ι → ℂ) (hw : ∀ i ∈ s, 0 ≤ w i) : 0 ≤ weightedEnergy s w f := by + exact Finset.sum_nonneg fun i hi => mul_nonneg (hw i hi) (sq_nonneg _) + +theorem weighted_cauchy {ι : Type*} (s : Finset ι) (w : ι → ℝ) + (f g : ι → ℂ) (hw : ∀ i ∈ s, 0 ≤ w i) : + ‖∑ i ∈ s, (w i : ℂ) * f i * star (g i)‖ ≤ + Real.sqrt (weightedEnergy s w f) * Real.sqrt (weightedEnergy s w g) := by + have hf : ∑ i ∈ s, (Real.sqrt (w i) * ‖f i‖) ^ 2 = weightedEnergy s w f := by + apply Finset.sum_congr rfl + intro i hi + rw [mul_pow, Real.sq_sqrt (hw i hi)] + have hg : ∑ i ∈ s, (Real.sqrt (w i) * ‖g i‖) ^ 2 = weightedEnergy s w g := by + apply Finset.sum_congr rfl + intro i hi + rw [mul_pow, Real.sq_sqrt (hw i hi)] + calc + ‖∑ i ∈ s, (w i : ℂ) * f i * star (g i)‖ ≤ + ∑ i ∈ s, ‖(w i : ℂ) * f i * star (g i)‖ := norm_sum_le _ _ + _ = ∑ i ∈ s, (Real.sqrt (w i) * ‖f i‖) * (Real.sqrt (w i) * ‖g i‖) := by + apply Finset.sum_congr rfl + intro i hi + simp only [norm_mul, norm_star, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (hw i hi)] + calc + w i * ‖f i‖ * ‖g i‖ = + (Real.sqrt (w i) * Real.sqrt (w i)) * ‖f i‖ * ‖g i‖ := by + rw [Real.mul_self_sqrt (hw i hi)] + _ = _ := by ring + _ ≤ Real.sqrt (weightedEnergy s w f) * Real.sqrt (weightedEnergy s w g) := by + simpa only [hf, hg] using Real.sum_mul_le_sqrt_mul_sqrt s + (fun i => Real.sqrt (w i) * ‖f i‖) (fun i => Real.sqrt (w i) * ‖g i‖) + +theorem fiber_energy_bound {ι κ : Type*} [DecidableEq κ] + (s : Finset ι) (t : Finset κ) (p : ι → κ) (w : ι → ℝ) + (D E : κ → ℝ) (hp : ∀ i ∈ s, p i ∈ t) + (hE : ∀ j ∈ t, 0 ≤ E j) + (hD : ∀ j ∈ t, ∑ i ∈ s with p i = j, w i ≤ D j) : + ∑ i ∈ s, w i * E (p i) ≤ ∑ j ∈ t, D j * E j := by + calc + ∑ i ∈ s, w i * E (p i) = + ∑ j ∈ t, ∑ i ∈ s with p i = j, w i * E (p i) := + (Finset.sum_fiberwise_of_maps_to hp _).symm + _ = ∑ j ∈ t, (∑ i ∈ s with p i = j, w i) * E j := by + apply Finset.sum_congr rfl + intro j hj + rw [Finset.sum_mul] + apply Finset.sum_congr rfl + intro i hi + rw [(Finset.mem_filter.mp hi).2] + _ ≤ ∑ j ∈ t, D j * E j := + Finset.sum_le_sum fun j hj => mul_le_mul_of_nonneg_right (hD j hj) (hE j hj) + +theorem weightedEnergy_fiber_bound {ι κ : Type*} [DecidableEq κ] + (s : Finset ι) (t : Finset κ) (p : ι → κ) (w : ι → ℝ) + (D : κ → ℝ) (f : κ → ℂ) (hp : ∀ i ∈ s, p i ∈ t) + (hD : ∀ j ∈ t, ∑ i ∈ s with p i = j, w i ≤ D j) : + weightedEnergy s w (f ∘ p) ≤ weightedEnergy t D f := by + exact fiber_energy_bound s t p w D (fun j => ‖f j‖ ^ 2) hp + (fun j _ => sq_nonneg _) hD + +theorem weighted_cauchy_fiber {ι κ : Type*} [DecidableEq κ] + (s : Finset ι) (t : Finset κ) (p : ι → κ) (w : ι → ℝ) + (D : κ → ℝ) (f g : κ → ℂ) (hp : ∀ i ∈ s, p i ∈ t) + (hw : ∀ i ∈ s, 0 ≤ w i) + (hD : ∀ j ∈ t, ∑ i ∈ s with p i = j, w i ≤ D j) : + ‖∑ i ∈ s, (w i : ℂ) * f (p i) * star (g (p i))‖ ≤ + Real.sqrt (weightedEnergy t D f) * Real.sqrt (weightedEnergy t D g) := by + apply (weighted_cauchy s w (f ∘ p) (g ∘ p) hw).trans + exact mul_le_mul + (Real.sqrt_le_sqrt (weightedEnergy_fiber_bound s t p w D f hp hD)) + (Real.sqrt_le_sqrt (weightedEnergy_fiber_bound s t p w D g hp hD)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + +theorem finite_expansion_energy {κ ι : Type*} [DecidableEq ι] + (rows : Finset κ) (terms : Finset ι) (active : κ → Finset ι) + (w F : κ → ι → ℂ) (C : ℝ) + (hsub : ∀ k ∈ rows, active k ⊆ terms) + (hw : ∀ k ∈ rows, ∀ i ∈ active k, ‖w k i‖ ≤ 1) + (hcard : ∀ k ∈ rows, ((active k).card : ℝ) ≤ C) : + (∑ k ∈ rows, ‖∑ i ∈ active k, w k i * F k i‖ ^ 2) ≤ + C * ∑ i ∈ terms, ∑ k ∈ rows, if i ∈ active k then ‖F k i‖ ^ 2 else 0 := by + have hlocal (k : κ) (hk : k ∈ rows) : + ‖∑ i ∈ active k, w k i * F k i‖ ^ 2 ≤ + C * ∑ i ∈ active k, ‖F k i‖ ^ 2 := by + have hb : ‖∑ i ∈ active k, w k i * F k i‖ ^ 2 ≤ + ((active k).card : ℝ) * ∑ i ∈ active k, ‖w k i * F k i‖ ^ 2 := by + calc + _ ≤ (∑ i ∈ active k, ‖w k i * F k i‖) ^ 2 := + pow_le_pow_left₀ (norm_nonneg _) (norm_sum_le _ _) 2 + _ ≤ _ := by + simpa only [one_mul, one_pow, Finset.sum_const, nsmul_eq_mul, mul_one] using + Finset.sum_mul_sq_le_sq_mul_sq (active k) (fun _ => (1 : ℝ)) + (fun i => ‖w k i * F k i‖) + have hsum : (∑ i ∈ active k, ‖w k i * F k i‖ ^ 2) ≤ + ∑ i ∈ active k, ‖F k i‖ ^ 2 := by + apply Finset.sum_le_sum + intro i hi + apply pow_le_pow_left₀ (norm_nonneg _) + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (hw k hk i hi) + exact hb.trans (mul_le_mul (hcard k hk) hsum + (Finset.sum_nonneg fun _ _ => sq_nonneg _) + (le_trans (Nat.cast_nonneg _) (hcard k hk))) + calc + _ ≤ ∑ k ∈ rows, C * ∑ i ∈ active k, ‖F k i‖ ^ 2 := + Finset.sum_le_sum hlocal + _ = C * ∑ k ∈ rows, ∑ i ∈ active k, ‖F k i‖ ^ 2 := by rw [Finset.mul_sum] + _ = C * ∑ k ∈ rows, ∑ i ∈ terms, if i ∈ active k then ‖F k i‖ ^ 2 else 0 := by + congr 1 + apply Finset.sum_congr rfl + intro k hk + rw [← Finset.sum_filter] + congr 1 + ext i + simp only [Finset.mem_filter] + exact ⟨fun hi => ⟨hsub k hk hi, hi⟩, And.right⟩ + _ = _ := by rw [Finset.sum_comm] + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..0b4a9da052ae06eed21cd83363fbe93403314fec --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualEnergy.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory JointLogSeparation FourierBridge ActualEisensteinCubic FirstPassCubeLabels +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstModeEnergyCoefficient (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (y : Finset ι → ℝ) (d : Eis) + (z : Frequency × (Fin 9 → ℝ)) : Finset ι → ℂ := + firstModeCubeCoefficient p hp hcop hg B v ε₁ ε₂ negative C y + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 (if negative then 7 else 8)) d + +theorem firstModeEnergyCoefficient_continuous (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (y : Finset ι → ℝ) (d : Eis) (S : Finset ι) : + Continuous (fun z => firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ negative C y d z S) := by + simp only [firstModeEnergyCoefficient,firstModeCubeCoefficient_eq] + apply (cubeLogCoefficient_continuous p hp hcop hg B v ε₁ ε₂ negative C (fun _ => 1) y d S).comp + unfold profileHeight + fun_prop + +theorem firstModeEnergyCoefficient_norm (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (y : Finset ι → ℝ) (d : Eis) + (z : Frequency × (Fin 9 → ℝ)) (S : Finset ι) : + ‖firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ negative C y d z S‖ = + ‖firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ negative C y d 0 S‖ := by + simp only [firstModeEnergyCoefficient,firstModeCubeCoefficient_eq] + exact (norm_cubeLogCoefficient_eq_zero p hp hcop hg B v ε₁ ε₂ negative C (fun _ => 1) y _ d S).trans + (norm_cubeLogCoefficient_eq_zero p hp hcop hg B v ε₁ ε₂ negative C (fun _ => 1) y _ d S).symm + +theorem firstOuterPhase_norm (h : Fin 9 → ℝ) (a : Fin 7 → ℝ) : + ‖firstOuterPhase h a‖ = 1 := by + simp [firstOuterPhase,norm_prod,logPhase_norm] + +theorem actual_first_common_energy (F B : Finset ι) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (d h : Eis) (a : Fin 7 → ℝ) (y₁ y₂ : Finset ι → ℝ) + (g : Fin 9 → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) : + ‖∫ z : Frequency × (Fin 9 → ℝ), fullProfileDensity g b₁ b₂ b₃ z * + firstModeIdealRows p hp hcop hg F B v ε₁ ε₂ C₁ C₂ d h a y₁ y₂ z‖ ≤ + Real.sqrt (∫ z : Frequency × (Fin 9 → ℝ), ‖fullProfileDensity g b₁ b₂ b₃ z‖ * + ‖cubeBaseFactor p hp hg B v ε₁ ε₂ d h‖ * + rayIdealEnergy p hg F (firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ true C₁ y₁ d z) true h) * + Real.sqrt (∫ z : Frequency × (Fin 9 → ℝ), ‖fullProfileDensity g b₁ b₂ b₃ z‖ * + ‖cubeBaseFactor p hp hg B v ε₁ ε₂ d h‖ * + rayIdealEnergy p hg F (firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ false C₂ y₂ d z) false h) := by + let b := fun z : Frequency × (Fin 9 → ℝ) => fullProfileDensity g b₁ b₂ b₃ z * + firstOuterPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2) a + have hphase : Continuous (fun z : Frequency × (Fin 9 → ℝ) => + firstOuterPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2) a) := by + unfold firstOuterPhase profileHeight logPhase + fun_prop + have hb : Integrable b := (full_density_integrable g b₁ b₂ b₃).mul_bdd + hphase.aestronglyMeasurable (Filter.Eventually.of_forall (fun z => (firstOuterPhase_norm _ _).le)) + have hbc : Continuous b := by + apply Continuous.mul _ hphase + unfold fullProfileDensity coordinateDensity tripleCoefficient + fun_prop + have hbn (z : Frequency × (Fin 9 → ℝ)) : ‖b z‖ = ‖fullProfileDensity g b₁ b₂ b₃ z‖ := by + simp only [b,norm_mul,firstOuterPhase_norm,mul_one] + have hh := full_cube_integral_norm_le_energy p hg F + (firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ true C₁ y₁ d) + (firstModeEnergyCoefficient p hp hcop hg B v ε₁ ε₂ false C₂ y₂ d) + (firstModeEnergyCoefficient_continuous p hp hcop hg B v ε₁ ε₂ true C₁ y₁ d) + (firstModeEnergyCoefficient_continuous p hp hcop hg B v ε₁ ε₂ false C₂ y₂ d) + (firstModeEnergyCoefficient_norm p hp hcop hg B v ε₁ ε₂ true C₁ y₁ d) + (firstModeEnergyCoefficient_norm p hp hcop hg B v ε₁ ε₂ false C₂ y₂ d) + h b hb hbc (cubeBaseFactor p hp hg B v ε₁ ε₂ d h) + simp only [hbn] at hh + convert hh using 1 + congr 1 + apply integral_congr_ae + filter_upwards with z + simp only [firstModeIdealRows,firstModeEnergyCoefficient,firstModeCubeCoefficient, + Bool.false_eq_true,ite_false,ite_true,b] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualPriorityEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualPriorityEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..f1d64d134c5d456a08233c50f06773310a26cb5d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualPriorityEnergy.lean @@ -0,0 +1,67 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstActualSecondEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstPrioritySecondEnergy (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (F : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m d : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (selector : Finset ι→ℂ) (ω : ℝ→ℂ) (X t Y : ℝ) : ℝ := + let A := (if negative then b.rightDivisor else b.leftDivisor)∪C + (32*512)*(2:ℝ)^slots.card * ∑ r : RayCharacter×RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑ core : FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative Ψ m D core‖ * + ∑ J∈slots.powerset,‖primeMark J lists a (A∪D)‖^2 * + (firstFreshSecondPoisson p hp hg hinj F D b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative (if negative then r.1 else r.2) Ψ m + (fun U=>primeMark (slots\J) (fun i=>lists i\(A∪D)) a U) + ω X (∏i∈C,p i) d core t Y).re + +theorem first_actual_second_prime_priority + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (F : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m d : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (selector : Finset ι→ℂ) (ω : ℝ→ℂ) (X t Y : ℝ) (hY : 0b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative + (if negative then r.1 else r.2) Ψ m slots lists a (fun _=>1) + ω X (∏i∈C,p i) d core t Y hY + simp only [mul_one] at hb + unfold firstCanonicalSecondEnergy firstPrioritySecondEnergy + simp only [Finset.mul_sum] + apply Finset.sum_le_sum + intro r hr + apply Finset.sum_le_sum + intro D hD + apply Finset.sum_le_sum + intro core hcore + have h := mul_le_mul_of_nonneg_left (hb r D core) + (show 0≤(32*512:ℝ)*(‖crossCoeff r.1 r.2‖*‖selector D‖)* + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative Ψ m D core‖ from by positivity) + convert h using 1 + · dsimp only [A] + ring + · simp only [A,Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualSecondEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualSecondEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..6bbca9153010fdfc137010166e8a269d5fea16b6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstActualSecondEnergy.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstRetainedFamily +import OAI.NumberTheory.DirichletL.Descent.FirstPriorityEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstCanonicalSecondEnergy (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (F : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m d : O) (H selector : Finset ι→ℂ) (ω : ℝ→ℂ) (X t Y : ℝ) : ℝ := + (32*512)*∑ r : RayCharacter×RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑ core : FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative Ψ m D core‖ * + (firstFreshSecondPoisson p hp hg hinj F D b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative (if negative then r.1 else r.2) Ψ m + (fun U=>H (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪U)) ω X (∏i∈C,p i) d core t Y).re + +theorem firstCanonicalSecondEnergy_nonneg (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (F : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m d : O) (H selector : Finset ι→ℂ) (ω : ℝ→ℂ) (X t Y : ℝ) (hY : 0b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative + (if negative then r.1 else r.2) Ψ m _ ω X (∏i∈C,p i) d core t Y hY] + exact Finset.sum_nonneg (fun z hz=>mul_nonneg (rowMajorant_nonneg _) (sq_nonneg _)) + +theorem first_retained_actual_second_energy (ε : ℝ) (hε : 0<ε) : + ∃ K : ℝ,0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ),(∀ u,‖Ψ₁ u‖≤1) → (∀ u,‖Ψ₂ u‖≤1) → + ∀ (m₁ m₂ d : O) (labels : Finset (Ideal O)) (a : Ideal O×O→ℂ) (Γ Y : ℝ),0≤Γ → 0selector) + (firstCanonicalCoefficient p hp hcop hg b C negative + (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) d H) + (retainedCubeWeight p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ d a) negative ω X t Prod.snd ≤ + Γ*K*Y^ε * firstCanonicalSecondEnergy p hp hg hinj F b C negative + (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) d H selector ω X t Y := by + obtain ⟨K,hK,hstep⟩ := retained_cube_energy_to_second ε hε + refine ⟨K,hK,?_⟩ + intro ι _ p hp _ hinj hcop hg hc hpr F b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ d labels a Γ Y hΓ hY + hlabels hn ha negative H selector ω X t hX + have he := hstep p hp hinj hcop hg hc hpr F b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ d a + (firstRetainedSource p labels b Y) Γ Y hΓ hY + (fun x hx=>hlabels x.1 ((mem_firstRetainedSource p labels b Y x).mp hx).1) + (fun x hx=>hn x.1 ((mem_firstRetainedSource p labels b Y x).mp hx).1) ha + (fun x hx=>((mem_firstRetainedSource p labels b Y x).mp hx).2) + negative H selector ω X t hX + have hcoef : firstCanonicalCoefficient p hp hcop hg b C negative + (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) d H = + fun x=>firstOldLabelCoefficient p hp hcop hg b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative + (multiplicativeCoreColumn p (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) + (fun U=>H (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪U))) + (∏i∈C,p i) d x.1 := by + funext x + exact firstCanonicalCoefficient_old p hp hcop hg b C negative _ _ d H x + rw [hcoef] + exact he + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstBalancedSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstBalancedSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..d0641afc71ce487dc45e828e6ec7dd659954a347 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstBalancedSource.lean @@ -0,0 +1,147 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstBlocks +import OAI.NumberTheory.DirichletL.Descent.FirstProfileUniform + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open JointLogSeparation MeasureTheory +noncomputable section + +theorem first_fresh_physical_profile + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (V : Fin 9 → ℝ → ℂ) + (s q : Fin 9 → ℝ) (hspos : ∀ i, 0 < s i) (hq : ∀ i, 0 < q i) (K : ℝ) + (density : Frequency × (Fin 9 → ℝ) → ℂ) (normalization : ℂ) + (he : ∀ y : Fin 9 → ℝ, normalization * firstPoissonProfile W₁ W₂ Φ V + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) y = + ∫ z : Frequency × (Fin 9 → ℝ),density z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y z.1 z.2) + (hω₁ : W₁ (q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7)) ≠ 0 → ω₁ (q 7/s 7) = 1) + (hω₂ : W₂ (q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8)) ≠ 0 → ω₂ (q 8/s 8) = 1) + (hcut : ω₁ (q 7/s 7) ≠ 0 → ω₂ (q 8/s 8) ≠ 0 → ∀ i, V i (firstRelativeLog q s i) = 1) : + normalization * firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K q = + (firstRootScale s:ℂ)⁻¹*(ω₁ (q 7/s 7)*ω₂ (q 8/s 8))* + ∫ z : Frequency × (Fin 9 → ℝ),density z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (firstRelativeLog q s) z.1 z.2 := by + by_cases hw₁ : ω₁ (q 7/s 7) = 0 + · have hh : W₁ (q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7)) = 0 := by + by_contra hn + have := hω₁ hn + simp only [hw₁,zero_ne_one] at this + simp only [firstNormProfile,hh,hw₁,mul_zero,zero_mul,zero_div] + by_cases hw₂ : ω₂ (q 8/s 8) = 0 + · have hh : W₂ (q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8)) = 0 := by + by_contra hn + have := hω₂ hn + simp only [hw₂,zero_ne_one] at this + simp only [firstNormProfile,hh,hw₂,mul_zero,zero_mul,zero_div] + have hcut' := hcut hw₁ hw₂ + have hnom := firstNormProfile_nominal W₁ W₂ Φ (fun _ _ => 1) s q hspos hq K + have hfull : normalization * firstNormProfile W₁ W₂ Φ (fun _ _ => 1) + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (fun i => q i/s i) = + ∫ z : Frequency × (Fin 9 → ℝ), density z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (firstRelativeLog q s) z.1 z.2 := by + have hp := firstPoissonProfile_log W₁ W₂ Φ V + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (fun i => q i/s i) + (fun i => div_pos (hq i) (hspos i)) + have hc : firstPoissonProfile W₁ W₂ Φ V + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (firstRelativeLog q s) = + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (fun i => q i/s i) := by + unfold firstRelativeLog + rw [hp] + simp only [firstRelativeLog] at hcut' + simp only [firstNormProfile,hcut',Finset.prod_const_one] + rw [← hc] + exact he (firstRelativeLog q s) + have hm : firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K q = + (ω₁ (q 7/s 7)*ω₂ (q 8/s 8)) * + firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K q := by + by_cases h1 : W₁ (q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7)) = 0 + · simp only [firstNormProfile,h1,mul_zero,zero_mul,zero_div] + by_cases h2 : W₂ (q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8)) = 0 + · simp only [firstNormProfile,h2,mul_zero,zero_mul,zero_div] + simp only [hω₁ h1,hω₂ h2,one_mul] + calc + _ = (firstRootScale s:ℂ)⁻¹*(ω₁ (q 7/s 7)*ω₂ (q 8/s 8))* + (normalization * firstNormProfile W₁ W₂ Φ (fun _ _ => 1) + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (fun i => q i/s i)) := by + conv_lhs => rw [hm,hnom] + ring + _ = _ := by rw [hfull] + +theorem first_balanced_density_integrable (g : Fin 9 → 𝓢(ℝ,ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ,ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) : + Integrable (InverseMomentFirstProfileUniform.density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L) := by + exact (full_density_integrable _ _ _ _).const_mul _ + +open ActualEisensteinCubic FirstPassCubeLabels +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +include hp in +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem firstCommonNorms_pos (A₁ A₂ C R : ℝ) (hA₁ : 0 < A₁) (hA₂ : 0 < A₂) + (hC : 0 < C) (hR : 0 < R) (d h : Eis) (hd : d ≠ 0) (hh : h ≠ 0) + (j : FirstCommonIndex ι) : ∀ i,0 < firstCommonNorms p A₁ A₂ C R d h j i := by + intro i + fin_cases i <;> simp only [firstCommonNorms] + · exact hA₁ + · exact hA₂ + · exact hC + · exact sq_pos_of_pos (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero hd)) + · exact hR + · exact primeProductNorm_pos p hp _ + · exact sq_pos_of_pos (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero hh)) + · exact primeProductNorm_pos p hp _ + · exact primeProductNorm_pos p hp _ + +include hp in + +theorem actual_first_balanced_block (F : Finset ι) (selector : Finset ι → ℂ) + (C₁ C₂ : Finset ι → ℂ) (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 9 → ℝ → ℂ) (A₁ A₂ C R K L : ℝ) + (hA₁ : 0 < A₁) (hA₂ : 0 < A₂) (hC : 0 < C) (hR : 0 < R) + (d h : Eis) (hd : d ≠ 0) (hh : h ≠ 0) (s : Fin 9 → ℝ) (hs : ∀ i,0 < s i) + (density : Frequency × (Fin 9 → ℝ) → ℂ) (hDensity : Integrable density) + (hsep : ∀ y : Fin 9 → ℝ, + (Real.exp (-(9/2:ℝ)*L):ℂ)*firstPoissonProfile W₁ W₂ Φ V + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) y = + ∫ z : Frequency × (Fin 9 → ℝ),density z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y z.1 z.2) + (hω₁ : ∀ j ∈ firstCommonIndices F, + selector j.2.1*firstCommonWeight p hg C₁ C₂ h j ≠ 0 → + W₁ (A₁*C*primeProductNorm p j.2.1*primeProductNorm p j.2.2.1/(s 0*s 2*s 5*s 7)) ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) = 1) + (hω₂ : ∀ j ∈ firstCommonIndices F, + selector j.2.1*firstCommonWeight p hg C₁ C₂ h j ≠ 0 → + W₂ (A₂*C*primeProductNorm p j.2.1*primeProductNorm p j.2.2.2/(s 1*s 2*s 5*s 8)) ≠ 0 → + ω₂ (primeProductNorm p j.2.2.2/s 8) = 1) + (hcut : ∀ j ∈ firstCommonIndices F, + selector j.2.1*firstCommonWeight p hg C₁ C₂ h j ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) ≠ 0 → ω₂ (primeProductNorm p j.2.2.2/s 8) ≠ 0 → + ∀ i,V i (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s i) = 1) : + (Real.exp (-(9/2:ℝ)*L):ℂ)*firstBlockedPhysicalRows p hg F selector C₁ C₂ + (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) + Φ A₁ A₂ C R K d h = + (firstRootScale s:ℂ)⁻¹*∫ z : Frequency × (Fin 9 → ℝ),density z* + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z := by + apply first_block_normalized_density p hg F selector C₁ C₂ _ _ ω₁ ω₂ Φ A₁ A₂ C R K d h s density hDensity + intro j hj hn + exact first_fresh_physical_profile W₁ W₂ ω₁ ω₂ Φ V s + (firstCommonNorms p A₁ A₂ C R d h j) hs + (firstCommonNorms_pos p hp A₁ A₂ C R hA₁ hA₂ hC hR d h hd hh j) K density + (Real.exp (-(9/2:ℝ)*L):ℂ) hsep + (by simpa [firstCommonNorms] using hω₁ j hj hn) + (by simpa [firstCommonNorms] using hω₂ j hj hn) + (by simpa [firstCommonNorms] using hcut j hj hn) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstBlockEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstBlockEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..21545aaa0a3d863cf91479b247c7a47597734bdc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstBlockEnergy.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstBlocks +import OAI.NumberTheory.DirichletL.Descent.FirstActualEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstBlockOuterWeight (selector : Finset ι → ℂ) + (r : RayCharacter × RayCharacter) (D : Finset ι) (h : Eis) : ℂ := + crossCoeff r.1 r.2 * selector D * supportMobius (fun i => Ideal.span {p i}) D * + rowCoprimeMask (fun i => Ideal.span {p i}) D h + +def firstBlockEnergy (F : Finset ι) (selector : Finset ι → ℂ) + (C : Finset ι → ℂ) (negative : Bool) (ω : ℝ → ℂ) (X t : ℝ) (h : Eis) : ℝ := + ∑ r : RayCharacter × RayCharacter, ∑ D ∈ F.powerset, + ‖firstBlockOuterWeight p selector r D h‖ * + ‖firstCommonColumn p hg F D C negative (if negative then r.1 else r.2) ω X t h‖^2 + +theorem firstBlockEnergy_nonneg (F : Finset ι) (selector : Finset ι → ℂ) + (C : Finset ι → ℂ) (negative : Bool) (ω : ℝ → ℂ) (X t : ℝ) (h : Eis) : + 0 ≤ firstBlockEnergy p hg F selector C negative ω X t h := by + unfold firstBlockEnergy + positivity + +theorem first_block_energy (F : Finset ι) (selector : Finset ι → ℂ) + (C₁ C₂ : Finset ι → ℂ) (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) + (d h : Eis) (s : Fin 9 → ℝ) (z : Frequency × (Fin 9 → ℝ)) : + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + ‖firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + Real.sqrt (firstBlockEnergy p hg F selector C₁ true ω₁ (s 7) (H 7) h) * + Real.sqrt (firstBlockEnergy p hg F selector C₂ false ω₂ (s 8) (H 8) h) := by + dsimp only + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + let w := fun j : (RayCharacter × RayCharacter) × Finset ι => + firstBlockOuterWeight p selector j.1 j.2 h * + firstOuterPhase H (firstCommonOuterLog p A₁ A₂ C R d h j.2 s) + have hn (j : (RayCharacter × RayCharacter) × Finset ι) : + ‖w j‖ = ‖firstBlockOuterWeight p selector j.1 j.2 h‖ := by + simp only [w,norm_mul,firstOuterPhase_norm,mul_one] + have hc := DescentWeightedCauchy.weighted_cauchy + ((Finset.univ : Finset (RayCharacter × RayCharacter)) ×ˢ F.powerset) w + (fun j => firstCommonColumn p hg F j.2 C₂ false j.1.2 ω₂ (s 8) (H 8) h) + (fun j => firstCommonColumn p hg F j.2 C₁ true j.1.1 ω₁ (s 7) (H 7) h) + simp only [hn,Finset.sum_product] at hc + have he : (∑ r : RayCharacter × RayCharacter, ∑ D ∈ F.powerset, + w (r,D) * firstCommonColumn p hg F D C₂ false r.2 ω₂ (s 8) (H 8) h * + star (firstCommonColumn p hg F D C₁ true r.1 ω₁ (s 7) (H 7) h)) = + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z := by + simp only [firstBlockedSeparatedRow,Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + dsimp only [w,firstBlockOuterWeight,H] + ring + rw [he] at hc + change ‖firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + Real.sqrt (firstBlockEnergy p hg F selector C₂ false ω₂ (s 8) (H 8) h) * + Real.sqrt (firstBlockEnergy p hg F selector C₁ true ω₁ (s 7) (H 7) h) at hc + exact hc.trans_eq (mul_comm _ _) + +theorem first_block_integral_of_energy (F : Finset ι) (selector : Finset ι → ℂ) + (C₁ C₂ : Finset ι → ℂ) (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) + (d h : Eis) (s : Fin 9 → ℝ) (density : Frequency × (Fin 9 → ℝ) → ℂ) + (J : ℕ) (B : ℝ) (hB : 0 ≤ B) + (hDensity : Integrable (fun z : Frequency × (Fin 9 → ℝ) => + tripleHeight J z.1*coordinateHeight J z.2*‖density z‖)) + (hleft : ∀ z : Frequency × (Fin 9 → ℝ), + firstBlockEnergy p hg F selector C₁ true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) h ≤ + B*(tripleHeight J z.1*coordinateHeight J z.2)) + (hright : ∀ z : Frequency × (Fin 9 → ℝ), + firstBlockEnergy p hg F selector C₂ false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) h ≤ + B*(tripleHeight J z.1*coordinateHeight J z.2)) : + ‖∫ z : Frequency × (Fin 9 → ℝ),density z * + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + B*∫ z : Frequency × (Fin 9 → ℝ),tripleHeight J z.1*coordinateHeight J z.2*‖density z‖ := by + have hb (z : Frequency × (Fin 9 → ℝ)) : + ‖firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + B*(tripleHeight J z.1*coordinateHeight J z.2) := by + apply (first_block_energy p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z).trans + have h := mul_le_mul (Real.sqrt_le_sqrt (hleft z)) (Real.sqrt_le_sqrt (hright z)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + exact h.trans_eq (by rw [← sq,Real.sq_sqrt]; unfold tripleHeight coordinateHeight; positivity) + calc + _ ≤ ∫ z : Frequency × (Fin 9 → ℝ),B*(tripleHeight J z.1*coordinateHeight J z.2*‖density z‖) := by + apply norm_integral_le_of_norm_le (hDensity.const_mul B) + filter_upwards with z + rw [norm_mul] + exact (mul_le_mul_of_nonneg_left (hb z) (norm_nonneg _)).trans_eq (by ring) + _ = _ := integral_const_mul _ _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstBlocks.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstBlocks.lean new file mode 100644 index 0000000000000000000000000000000000000000..a54abd8d7f04912f9b00f5fee268cc32186ea916 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstBlocks.lean @@ -0,0 +1,143 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCommonColumns +import OAI.NumberTheory.DirichletL.Descent.DensityAssembly + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstBlockedPhysicalRows (F : Finset ι) (selector : Finset ι → ℂ) + (C₁ C₂ : Finset ι → ℂ) (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (A₁ A₂ C R K : ℝ) (d h : Eis) : ℂ := + ∑ j ∈ firstCommonIndices F, selector j.2.1 * firstCommonWeight p hg C₁ C₂ h j * + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K (firstCommonNorms p A₁ A₂ C R d h j) + +def firstBlockedSeparatedRow (F : Finset ι) (selector : Finset ι → ℂ) + (C₁ C₂ : Finset ι → ℂ) (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) + (d h : Eis) (s : Fin 9 → ℝ) (z : Frequency × (Fin 9 → ℝ)) : ℂ := + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2 * + ∑ D ∈ F.powerset, selector D * supportMobius (fun i => Ideal.span {p i}) D * + rowCoprimeMask (fun i => Ideal.span {p i}) D h * + firstOuterPhase H (firstCommonOuterLog p A₁ A₂ C R d h D s) * + star (firstCommonColumn p hg F D C₁ true r.1 ω₁ (s 7) (H 7) h) * + firstCommonColumn p hg F D C₂ false r.2 ω₂ (s 8) (H 8) h + +theorem first_block_modes_eq_columns (F : Finset ι) (selector : Finset ι → ℂ) (C₁ C₂ : Finset ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) (d h : Eis) (s : Fin 9 → ℝ) + (z : Frequency × (Fin 9 → ℝ)) : + (∑ j ∈ firstCommonIndices F,(selector j.2.1 * firstCommonWeight p hg C₁ C₂ h j) * + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8)) * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2) = + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z := by + simp only [firstCommonIndices,Finset.sum_product,Finset.sum_sigma, + firstCommonWeight,firstBlockedSeparatedRow,Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + calc + _ = crossCoeff r.1 r.2 * + (selector D * supportMobius (fun i => Ideal.span {p i}) D * rowCoprimeMask (fun i => Ideal.span {p i}) D h * + firstOuterPhase H (firstCommonOuterLog p A₁ A₂ C R d h D s)) * + (∑ U ∈ (F\D).powerset, ∑ V ∈ (F\D).powerset, + firstCommonCoefficient p hg C₁ C₂ r D U V h * + (ω₁ (primeProductNorm p U/s 7)*ω₂ (primeProductNorm p V/s 8)) * + logPhase (H 7) (Real.log (primeProductNorm p U/s 7)) * + logPhase (H 8) (Real.log (primeProductNorm p V/s 8))) := by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro U hU + apply Finset.sum_congr rfl + intro V hV + rw [first_common_source_mode] + dsimp only [H] + ring + _ = _ := by + rw [firstCommonColumn_pair] + dsimp only [H] + ring + +theorem first_blocks_reconstruct {κ : Type*} (blocks : Finset κ) + (F : Finset ι) (selector : κ → Finset ι → ℂ) + (hpartition : ∀ D ∈ F.powerset, ∑ a ∈ blocks, selector a D = 1) + (C₁ C₂ : Finset ι → ℂ) (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (A₁ A₂ C R K : ℝ) (d h : Eis) : + (∑ a ∈ blocks, firstBlockedPhysicalRows p hg F (selector a) C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h) = + firstPhysicalCommonRows p hg F C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h := by + rw [firstPhysicalCommonRows_indexed] + unfold firstBlockedPhysicalRows + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro j hj + have hDj : j.2.1 ∈ F.powerset := (Finset.mem_sigma.mp (Finset.mem_product.mp hj).2).1 + rw [← Finset.sum_mul, ← Finset.sum_mul, hpartition j.2.1 hDj, one_mul] + +def firstCommonBlockSelector {κ : Type*} [DecidableEq κ] + (label : Finset ι → κ) (a : κ) (D : Finset ι) : ℂ := + if label D = a then 1 else 0 + +theorem first_source_blocks_reconstruct {κ : Type*} [DecidableEq κ] + (F : Finset ι) (label : Finset ι → κ) + (C₁ C₂ : Finset ι → ℂ) (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (A₁ A₂ C R K : ℝ) (d h : Eis) : + (∑ a ∈ F.powerset.image label, + firstBlockedPhysicalRows p hg F (firstCommonBlockSelector label a) + C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h) = + firstPhysicalCommonRows p hg F C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h := by + apply first_blocks_reconstruct + intro D hD + have hm : label D ∈ F.powerset.image label := Finset.mem_image_of_mem label hD + simp [firstCommonBlockSelector,hm] + +theorem first_block_nonzero_label {κ : Type*} [DecidableEq κ] + (label : Finset ι → κ) (a : κ) (C₁ C₂ : Finset ι → ℂ) (h : Eis) + (j : FirstCommonIndex ι) + (hn : firstCommonBlockSelector label a j.2.1 * firstCommonWeight p hg C₁ C₂ h j ≠ 0) : + label j.2.1 = a := by + by_contra he + simp [firstCommonBlockSelector,he] at hn + +theorem first_block_normalized_density (F : Finset ι) (selector : Finset ι → ℂ) + (C₁ C₂ : Finset ι → ℂ) (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (A₁ A₂ C R K : ℝ) (d h : Eis) (s : Fin 9 → ℝ) + (density : Frequency × (Fin 9 → ℝ) → ℂ) (hDensity : Integrable density) + (normalization : ℂ) + (he : ∀ j ∈ firstCommonIndices F, + selector j.2.1 * firstCommonWeight p hg C₁ C₂ h j ≠ 0 → + normalization * firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + (firstCommonNorms p A₁ A₂ C R d h j) = + (firstRootScale s:ℂ)⁻¹ * + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8)) * + ∫ z : Frequency × (Fin 9 → ℝ),density z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2) : + normalization * firstBlockedPhysicalRows p hg F selector C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h = + (firstRootScale s:ℂ)⁻¹ * ∫ z : Frequency × (Fin 9 → ℝ),density z * + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z := by + simp_rw [← first_block_modes_eq_columns] + rw [← density_finite_sum _ density hDensity] + simp only [firstBlockedPhysicalRows,Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + by_cases hz : selector j.2.1 * firstCommonWeight p hg C₁ C₂ h j = 0 + · simp only [hz,zero_mul,mul_zero] + · calc + _ = (selector j.2.1 * firstCommonWeight p hg C₁ C₂ h j) * + (normalization * firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + (firstCommonNorms p A₁ A₂ C R d h j)) := by ring + _ = _ := by rw [he j hj hz]; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalChildren.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalChildren.lean new file mode 100644 index 0000000000000000000000000000000000000000..cb58f2fbd128ca8863d5a72b6cfb1d749ef64b07 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalChildren.lean @@ -0,0 +1,65 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStepChildren +import OAI.NumberTheory.DirichletL.Descent.ActualDepthBudget + +namespace OAI + +noncomputable section +open scoped Classical BigOperators + +namespace SevenEighths.InverseMomentFirstLabelCell +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstGlobalCaps InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ:Type*}[DecidableEq ι][DecidableEq σ] +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem source_total_cap (pool:Finset ι)(Q:Finset (ι→₀ℕ))(k:SourceIndex)(l j:ℕ) + (negative:Bool)(J:Finset σ)(lists:σ→Finset ι)(Z M r ell V eta tau window b:ℝ) + (hZ:1 ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def retainedCubeWeight (b : CubeCoordinates ι) (C : Finset ι) (Ψ₁ Ψ₂ : O→*ℂ) + (m₁ m₂ d : O) (a : Ideal O×O→ℂ) (x : Ideal O×O) : ℂ := + a x * canonicalCubeOuter p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ (ConcretePrimeRowBridge.idealGenerator x.1) * + cubeBaseFactor p hp hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit d x.2 + +theorem retainedCubeWeight_norm + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (b : CubeCoordinates ι) (C : Finset ι) (Ψ₁ Ψ₂ : O→*ℂ) + (hΨ₁ : ∀ u,‖Ψ₁ u‖≤1) (hΨ₂ : ∀ u,‖Ψ₂ u‖≤1) + (m₁ m₂ d : O) (a : Ideal O×O→ℂ) (x : Ideal O×O) : + ‖retainedCubeWeight p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ d a x‖≤‖a x‖ := by + simp only [retainedCubeWeight,norm_mul] + calc + _ ≤ ‖a x‖*1*1 := by + exact mul_le_mul + (mul_le_mul_of_nonneg_left + (canonicalCubeOuter_norm_le_one p hp hcop hg hc b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ _) (norm_nonneg _)) + (cubeBaseFactor_norm_le_one p hp hcop hg hc _ _ _ _ _ _) + (norm_nonneg _) (by positivity) + _ = _ := by ring + +include hp in +theorem retained_physical_row_support (b : CubeCoordinates ι) (x : Ideal O×O) (hx : x.1≠0) + (Y : ℝ) (hcut : x.2∈nonzeroChildFrequencyBall + (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit x.1) Y) : + DescentWeightedCauchy.firstElementRowMap + (dilationLabel p b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit) x ∈ + nonzeroChildFrequencyBall 1 Y := by + have hh := (mem_nonzeroChildFrequencyBall _ + (firstPhysicalMultiplier_ne_zero p hp _ _ _ _ _ x.1 hx) _ _).mp hcut + apply (mem_nonzeroChildFrequencyBall 1 one_ne_zero _ _).mpr + simpa only [one_mul,firstPhysicalMultiplier_row] using hh + +theorem retained_cube_energy_to_second (ε : ℝ) (hε : 0<ε) : + ∃ K : ℝ,0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ),(∀ u,‖Ψ₁ u‖≤1) → (∀ u,‖Ψ₂ u‖≤1) → + ∀ (m₁ m₂ d : O) (a : Ideal O×O→ℂ) (source : Finset (Ideal O×O)) (Γ Y : ℝ),0≤Γ → 0H (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪U) + let w := retainedCubeWeight p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ d a + firstFamilyEnergy p hg source F (fun _=>selector) + (fun x=>firstOldLabelCoefficient p hp hcop hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative (multiplicativeCoreColumn p Ψ m Hshift) + (∏i∈C,p i) d x.1) w negative ω X t Prod.snd ≤ + Γ*K*Y^ε*((32*512)*∑ r : RayCharacter×RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑ core : FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative Ψ m D core‖ * + (firstFreshSecondPoisson p hp hg hinj F D b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative (if negative then r.1 else r.2) Ψ m Hshift ω X (∏i∈C,p i) d core t Y).re) := by + obtain ⟨K,hK,hstep⟩ := first_family_original_to_second ε hε + refine ⟨K,hK,?_⟩ + intro ι _ p hp _ hinj hcop hg hc hpr F b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ d a source Γ Y hΓ hY + hs hn ha hcut negative H selector ω X t hX Ψ m Hshift w + apply hstep p hp hinj hcop hg hc hpr F b.support selector _ _ _ b.support_pos negative Ψ m + (by intro u; cases negative + · exact hΨ₂ u + · exact hΨ₁ u) Hshift ω X t hX (∏i∈C,p i) d source + (nonzeroChildFrequencyBall 1 Y) w Γ Y hΓ hY hs + · intro x hx + exact retained_physical_row_support p hp b x (hn x hx) Y (hcut x hx) + · intro z hz + exact (Finset.mem_erase.mp hz).1 + · intro z hz + have hb := ((mem_nonzeroChildFrequencyBall 1 one_ne_zero Y z).mp hz).2 + simpa only [one_mul,eisEmbedding_norm_sq_eq_absNorm_span] using hb + · intro x hx + exact (retainedCubeWeight_norm p hp hcop hg hc b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ d a x).trans (ha x hx) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..8c23ba7afc88755c2c580ccc4911353725305f3f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalPhysical.lean @@ -0,0 +1,95 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstMarkedColumns +import OAI.NumberTheory.DirichletL.Descent.FirstPhysicalCommon + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem canonical_residual_mul_test (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m f : O) (H test : Finset ι→ℂ) (N : Finset ι) : + canonicalCubeResidual p hg b C negative Ψ m f (fun U=>H U*test U) N = + canonicalCubeResidual p hg b C negative Ψ m f H N * + test (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪N) := by + simp only [canonicalCubeResidual,originalLabelColumn,multiplicativeCoreColumn] + ring + +theorem actual_first_kernel_window_transport + (F B : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (C₁ C₂ A₁ A₂ : Finset ι→ℂ) (V₁ V₂ : ℝ→ℂ) + (hC₁ : ∀ N∈F.powerset,C₁ N=A₁ N*star (V₁ (columnLog p 1 N))) + (hC₂ : ∀ N∈F.powerset,C₂ N=A₂ N*V₂ (columnLog p 1 N)) + (W : 𝓢(ℝ,ℂ)) (K : ℝ) (d h : O) : + actualFirstKernel p hp hcop hg F B v ε₁ ε₂ C₁ C₂ W (fun _=>1) (fun _=>1) 1 1 K d h = + ∑ N∈F.powerset,∑ Q∈F.powerset,if Disjoint N Q then + canonicalPairMode p hp hcop hg N Q B v ε₁ ε₂ A₁ A₂ W V₁ V₂ 1 1 K d h else 0 := by + unfold actualFirstKernel + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro Q hQ + by_cases hd : Disjoint N Q + · simp only [hd,ite_true,canonicalPairMode,threeGaussRowFactor,hC₁ N hN,hC₂ Q hQ,star_mul,star_star] + ring + · simp only [hd,ite_false] + +theorem canonical_first_kernel_physical + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (b : CubeCoordinates ι) (hb : b.Admissible) + (C : Finset ι) (hC : Disjoint C b.support) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ f : O) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) (d h : O) : + let F := pool\(b.support∪C) + let A₁ := ‖eisEmbedding (aLabel p b.support b.rightBit)‖^2 + let A₂ := ‖eisEmbedding (aLabel p b.support b.leftBit)‖^2 + let B₁ := canonicalCubeResidual p hg b C true Ψ₁ m₁ f H₁ + let B₂ := canonicalCubeResidual p hg b C false Ψ₂ m₂ f H₂ + (‖eisEmbedding d‖^2:ℂ)⁻¹ * actualFirstKernel p hp hcop hg F b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + (canonicalCubeResidual p hg b C true Ψ₁ m₁ f (fun U=>H₁ U*W₁ (primeProductNorm p U))) + (canonicalCubeResidual p hg b C false Ψ₂ m₂ f (fun U=>H₂ U*W₂ (primeProductNorm p U))) + Φ (fun _=>1) (fun _=>1) 1 1 K d h = + (K:ℂ)*cubeBaseFactor p hp hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit d h * + firstPhysicalCommonRows p hg F + (cubeMinusCoefficient p hp hcop hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit B₁ d) + (cubePlusCoefficient p hp hcop hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit B₂ d) + (fun x=>star (W₁ x)) W₂ Φ A₁ A₂ (primeProductNorm p C) + (primeProductNorm p (cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)) K d h := by + intro F A₁ A₂ B₁ B₂ + have hdis : Disjoint F (b.support∪C) := by + apply Finset.disjoint_left.mpr + intro i hi hi2 + exact (Finset.mem_sdiff.mp hi).2 hi2 + have hwindow (negative : Bool) (Ψ : O→*ℂ) (m : O) (H : Finset ι→ℂ) (W : ℝ→ℂ) + (N : Finset ι) (hN : N∈F.powerset) : + canonicalCubeResidual p hg b C negative Ψ m f (fun U=>H U*W (primeProductNorm p U)) N = + canonicalCubeResidual p hg b C negative Ψ m f H N * + W (‖eisEmbedding (aLabel p b.support (if negative then b.rightBit else b.leftBit))‖^2 * + primeProductNorm p C*Real.exp (columnLog p 1 N)) := by + rw [canonical_residual_mul_test p hg, cube_whole_column_norm p b hb C N hC + (hdis.mono_left (Finset.mem_powerset.mp hN)) negative] + simp only [columnLog,div_one,Real.exp_log (primeProductNorm_pos p hp N)] + rw [actual_first_kernel_window_transport p hp hcop hg F b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit _ _ B₁ B₂ + (fun y=>star (W₁ (A₁*primeProductNorm p C*Real.exp y))) + (fun y=>W₂ (A₂*primeProductNorm p C*Real.exp y)) + (fun N hN=>by simpa only [star_star,ite_true,A₁,B₁] using hwindow true Ψ₁ m₁ H₁ W₁ N hN) + (fun N hN=>by simpa only [Bool.false_eq_true,ite_false,A₂,B₂] using hwindow false Ψ₂ m₂ H₂ W₂ N hN)] + exact actual_first_physical_common p hp hcop hg hinj hc hpr F b.support + (hdis.mono_right Finset.subset_union_left) _ _ _ B₁ B₂ + (fun x=>star (W₁ x)) W₂ Φ A₁ A₂ (primeProductNorm p C) K d h + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..4836efa1c745f6cb0aea8d256259c56075cb0d5c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCanonicalTail.lean @@ -0,0 +1,93 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstMarkedColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem first_canonical_marked_tail (ε : ℝ) (hε : 0<ε) (order : ℕ) : + ∃ (s : Finset (ℕ×ℕ)) (Ct Cm : ℝ),0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hchar : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (pool : Finset ι) (b : CubeCoordinates ι),b.Admissible → + ∀ (common divisor : Finset ι),Disjoint common b.support → + ∀ (f : Ideal O),f≠0 → + ∀ (Ψ₁ Ψ₂ : O→*ℂ),(∀ u,‖Ψ₁ u‖≤1) → (∀ u,‖Ψ₂ u‖≤1) → + ∀ (m₁ m₂ : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → (∀ i∈slots,∀ k∈lists i,‖a i k‖≤1) → + ∀ (test₁ test₂ : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) + (G₁ G₂ Z M r ell V delta B j eta tau : ℝ),0≤G₁ → 0≤G₂ → 0b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit)‖^2 → + let residualPool := pool\(b.support∪common) + let C₁ := canonicalCubeResidual p hg b common true Ψ₁ m₁ (ConcretePrimeRowBridge.idealGenerator f) + (wholeMarkedTest slots lists a test₁) + let C₂ := canonicalCubeResidual p hg b common false Ψ₂ m₂ (ConcretePrimeRowBridge.idealGenerator f) + (wholeMarkedTest slots lists a test₂) + let U₁ := Z^(r+eta)/(‖eisEmbedding (aLabel p b.support b.rightBit)‖^2*primeProductNorm p common) + let U₂ := Z^(r+eta)/(‖eisEmbedding (aLabel p b.support b.leftBit)‖^2*primeProductNorm p common) + let G₁' := Cm*(Z^(r+eta))^ε*G₁ + let G₂' := Cm*(Z^(r+eta))^ε*G₂ + let active := cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + let slow := Z^M/(primeProductNorm p divisor*primeProductNorm p active*U₁*U₂) + let T := childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) + (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)) + ‖∑' h : {h : O // h∉T},actualFirstKernel p hp hcop hg residualPool b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit C₁ C₂ W + (fun _=>1) (fun _=>1) 1 1 (Z^M) + (primeSubsetGenerator (fun i=>Ideal.span {p i}) divisor) h.val‖ ≤ + (128*U₁)*(128*U₂)*(G₁'*G₂'*Z^M)* + ((Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)/((min 1 slow)^2*(1+Z^tau)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_first_physical_tail order + obtain ⟨Cm,hCm,hmark⟩ := whole_marked_test_uniform ε hε + refine ⟨s,Ct,Cm,hCt,hCm,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hchar pool b hb common divisor hcommon f hf0 Ψ₁ Ψ₂ hΨ₁ hΨ₂ + m₁ m₂ slots lists a hslots ha test₁ test₂ W G₁ G₂ Z M r ell V delta B j eta tau hG₁ hG₂ hZ + htest₁ htest₂ hs₁ hs₂ hb₁ hb₂ hf hd hc hj residualPool C₁ C₂ U₁ U₂ G₁' G₂' active slow T + have hdis : Disjoint residualPool (b.support∪common) := by + apply Finset.disjoint_left.mpr + intro i hi hi2 + exact (Finset.mem_sdiff.mp hi).2 hi2 + apply htail p hp hinj hcop hg hchar residualPool b.support common divisor b.leftExponent b.rightExponent + b.leftBit b.rightBit b.support_pos (hdis.mono_right Finset.subset_union_left) f hf0 C₁ C₂ W + G₁' G₂' Z M r ell V delta B j eta tau (by dsimp [G₁']; positivity) (by dsimp [G₂']; positivity) hZ + · intro N hN + exact (canonical_residual_norm p hg b common true Ψ₁ hΨ₁ m₁ _ _ N).trans + (hmark p hp hcop slots lists a hslots ha test₁ G₁ (Z^(r+eta)) hG₁ + (Real.rpow_pos_of_pos hZ _).le htest₁ hs₁ _) + · intro N hN + exact (canonical_residual_norm p hg b common false Ψ₂ hΨ₂ m₂ _ _ N).trans + (hmark p hp hcop slots lists a hslots ha test₂ G₂ (Z^(r+eta)) hG₂ + (Real.rpow_pos_of_pos hZ _).le htest₂ hs₂ _) + · exact hb₁ + · exact hb₂ + · exact hf + · exact hd + · exact hc + · exact hj + · intro N hN hn + exact canonical_marked_residual_support p hg b hb common N hcommon + (hdis.mono_left (Finset.mem_powerset.mp hN)) true Ψ₁ m₁ _ slots lists a test₁ _ hs₁ hn + · intro N hN hn + exact canonical_marked_residual_support p hg b hb common N hcommon + (hdis.mono_left (Finset.mem_powerset.mp hN)) false Ψ₂ m₂ _ slots lists a test₂ _ hs₂ hn + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindows.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindows.lean new file mode 100644 index 0000000000000000000000000000000000000000..896c5e01120f90b1e13a71c3c3c7b2485fe09916 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindows.lean @@ -0,0 +1,126 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows +import OAI.NumberTheory.DirichletL.Descent.FirstUnequalRetainedEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff +namespace SevenEighths.InverseMomentFirstChildWindows +open InverseMoment InverseMomentFirstProfileUniform +open InverseSecondChildWindows + +theorem fresh_three_window (g : 𝓢(ℝ,ℂ)) (m bcap : ℝ) + (lo hi : Fin 3→ℝ) (hm : 0≤m) + (hg : Function.support g⊆Set.Icc (-m) m) + (hlo : ∀i,0hlo (left i)) (fun i=>hhi (left i)) + obtain ⟨w₂,a₂,b₂,ha₂,hab₂,hwc₂,hws₂,hfresh₂⟩ := fresh_three_window g₂ m₂ bcap + (lo ∘ right) (hi ∘ right) hm₂ hg₂ (fun i=>hlo (right i)) (fun i=>hhi (right i)) + let l : Fin 9→ℝ := ![lo 0,lo 1,lo 2,lo 3,lo 4,lo 5,lo 6,a₁,a₂] + let u : Fin 9→ℝ := ![hi 0,hi 1,hi 2,hi 3,hi 4,hi 5,hi 6,b₁,b₂] + have hl (i : Fin 9) : 0FourierBridge.exists_complex_smooth_cutoff (H i) (hH i) + let U (i : Fin 9) : 𝓢(ℝ,ℂ) := (hVc i).toSchwartzMap (hVs i) + refine ⟨w₁,w₂,U,(fun i=>H i+1),min a₁ a₂,max b₁ b₂,lt_min ha₁ ha₂, + (min_le_left _ _).trans (hab₁.trans (le_max_left _ _)),hwc₁,hwc₂,?_,?_, + (fun i=>by linarith [hH i]),hVc,(fun i=>(subset_tsupport _).trans (hVsupport i)),hfresh₁,hfresh₂,?_⟩ + · intro x hx + exact ⟨(min_le_left _ _).trans (hws₁ hx).1,(hws₁ hx).2.trans (le_max_left _ _)⟩ + · intro x hx + exact ⟨(min_le_right _ _).trans (hws₂ hx).1,(hws₂ hx).2.trans (le_max_right _ _)⟩ + · intro q ρ hρ hblock hw₁ hw₂ i + have hq (k : Fin 9) : q k∈Set.Icc (l k) (u k) := by + fin_cases k + · exact hblock 0 + · exact hblock 1 + · exact hblock 2 + · exact hblock 3 + · exact hblock 4 + · exact hblock 5 + · exact hblock 6 + · exact hws₁ (subset_tsupport _ hw₁) + · exact hws₂ (subset_tsupport _ hw₂) + exact hVone i _ (translated_log_bound _ _ _ _ _ (hl i) (hq i) (hρ i)) + +end SevenEighths.InverseMomentFirstChildWindows +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsActual.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsActual.lean new file mode 100644 index 0000000000000000000000000000000000000000..2a201f599ece571b1123b6121208efb202200e6a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsActual.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstChildWindows + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstChildWindows +open InverseMoment InverseMomentFirstProfileUniform ActualEisensteinCubic +open FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +local notation "O" => ActualEisensteinCubic.O + +def actualOuterRatios {ι : Type*} (p : ι→O) (A₁ A₂ C R : ℝ) (d h : O) + (j : FirstCommonIndex ι) (s : Fin 9→ℝ) (i : Fin 7) : ℝ := + firstCommonNorms p A₁ A₂ C R d h j (outerIndex i)/s (outerIndex i) + +theorem actual_first_child_windows (g₁ g₂ : 𝓢(ℝ,ℂ)) (m₁ m₂ bcap : ℝ) + (lo hi : Fin 7→ℝ) (Bρ : Fin 9→ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) + (hg₁ : Function.support g₁⊆Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂⊆Set.Icc (-m₂) m₂) + (hlo : ∀i,0firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j i/s i) + ρ hρ (hblock x hx j hj hn) hw₁ hw₂ i + +end SevenEighths.InverseMomentFirstChildWindows +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsCells.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsCells.lean new file mode 100644 index 0000000000000000000000000000000000000000..8a51ec29d151d8f40f92d85820d571bf070359e8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsCells.lean @@ -0,0 +1,130 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstChildWindowsActual +import OAI.NumberTheory.DirichletL.Inversion.SecondSourceBlocks + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstChildWindows +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels +open InverseSecondSourceBlocks (dyadIndex dyadScale dyadScale_pos dyadIndex_bounds) +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +abbrev SourceIndex := Fin 6→ℕ + +def sourceNorms {κ : Type*} (A₁ A₂ C R : κ→ℝ) (d h : κ→O) (x : κ) : Fin 6→ℝ := + ![A₁ x,A₂ x,C x,‖eisEmbedding (d x)‖^2,R x,‖eisEmbedding (h x)‖^2] + +def sourceIndex {κ : Type*} (q : κ→Fin 6→ℝ) (x : κ) : SourceIndex := fun i=>dyadIndex (q x i) +def sourceKeys {κ : Type*} [DecidableEq κ] (q : κ→Fin 6→ℝ) (S : Finset κ) := S.image (sourceIndex q) +def sourceCell {κ : Type*} [DecidableEq κ] (q : κ→Fin 6→ℝ) (S : Finset κ) (k : SourceIndex) := + S.filter (fun x=>sourceIndex q x=k) + +def commonKeys {ι : Type*} [DecidableEq ι] (p : ι→O) (F : Finset ι) : Finset ℕ := + F.powerset.image (fun D=>dyadIndex (primeProductNorm p D)) + +def commonSelector {ι : Type*} [DecidableEq ι] (p : ι→O) (selector : Finset ι→ℂ) (l : ℕ) (D : Finset ι) : ℂ := + if dyadIndex (primeProductNorm p D)=l then selector D else 0 + +def rawScales (k : SourceIndex) (l : ℕ) (T₁ T₂ : ℝ) : Fin 9→ℝ := + ![dyadScale (k 0),dyadScale (k 1),dyadScale (k 2),dyadScale (k 3),dyadScale (k 4), + dyadScale l,dyadScale (k 5),T₁,T₂] + +lemma rawScales_pos (k : SourceIndex) (l : ℕ) (T₁ T₂ : ℝ) (h₁ : 0 first | exact dyadScale_pos _ | exact h₁ | exact h₂ + +lemma sourceNorms_ge_one {κ : Type*} (A₁ A₂ C R : κ→ℝ) (d h : κ→O) (x : κ) + (hA₁ : 1≤A₁ x) (hA₂ : 1≤A₂ x) (hC : 1≤C x) (hR : 1≤R x) + (hd : d x≠0) (hh : h x≠0) : ∀i,1≤sourceNorms A₁ A₂ C R d h x i := by + intro i + fin_cases i + · exact hA₁ + · exact hA₂ + · exact hC + · exact EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq _ hd + · exact hR + · exact EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq _ hh + +lemma sourceCell_ratios {κ : Type*} [DecidableEq κ] (q : κ→Fin 6→ℝ) (S : Finset κ) + (hq : ∀x∈S,∀i,1≤q x i) (k : SourceIndex) (x : κ) (hx : x∈sourceCell q S k) (i : Fin 6) : + q x i/dyadScale (k i)∈Set.Icc 1 2 := by + obtain ⟨hxs,hindex⟩ := Finset.mem_filter.mp hx + have hh := dyadIndex_bounds (q x i) (hq x hxs i) + have he : dyadIndex (q x i)=k i := congrFun hindex i + rw [he] at hh + exact ⟨(le_div_iff₀ (dyadScale_pos _)).mpr (by simpa using hh.1), + (div_le_iff₀ (dyadScale_pos _)).mpr hh.2.le⟩ + +theorem actual_original_cell_ratios {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (S : Finset κ) (selector C₁ C₂ : κ→Finset ι→ℂ) + (A₁ A₂ C R : κ→ℝ) (d h : κ→O) + (hq : ∀x∈S,∀i,1≤sourceNorms A₁ A₂ C R d h x i) + (k : SourceIndex) (l : ℕ) (T₁ T₂ : ℝ) (x : κ) + (hx : x∈sourceCell (sourceNorms A₁ A₂ C R d h) S k) (j : FirstCommonIndex ι) + (hn : commonSelector p (selector x) l j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j≠0) : + ∀i,actualOuterRatios p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j (rawScales k l T₁ T₂) i∈Set.Icc 1 2 := by + have hl : dyadIndex (primeProductNorm p j.2.1)=l := by + by_contra he + exact hn (by simp [commonSelector,he]) + have hh := dyadIndex_bounds _ (SecondPassArithmetic.primeProductNorm_ge_one p hp j.2.1) + rw [hl] at hh + have hD : primeProductNorm p j.2.1/dyadScale l∈Set.Icc 1 2 := + ⟨(le_div_iff₀ (dyadScale_pos _)).mpr (by simpa using hh.1), + (div_le_iff₀ (dyadScale_pos _)).mpr hh.2.le⟩ + intro i + fin_cases i + · exact sourceCell_ratios _ S hq k x hx 0 + · exact sourceCell_ratios _ S hq k x hx 1 + · exact sourceCell_ratios _ S hq k x hx 2 + · exact sourceCell_ratios _ S hq k x hx 3 + · exact sourceCell_ratios _ S hq k x hx 4 + · exact hD + · exact sourceCell_ratios _ S hq k x hx 5 + +lemma sum_source_cells {κ β : Type*} [DecidableEq κ] [AddCommMonoid β] + (q : κ→Fin 6→ℝ) (S : Finset κ) (f : κ→β) : + (∑x∈S,f x)=∑k∈sourceKeys q S,∑x∈sourceCell q S k,f x := by + exact (Finset.sum_fiberwise_of_maps_to (fun x hx=>Finset.mem_image_of_mem (sourceIndex q) hx) f).symm + +lemma common_key_of_index {ι : Type*} [DecidableEq ι] (p : ι→O) (F : Finset ι) + (j : FirstCommonIndex ι) (hj : j∈firstCommonIndices F) : + dyadIndex (primeProductNorm p j.2.1)∈commonKeys p F := by + apply Finset.mem_image_of_mem + exact (Finset.mem_sigma.mp (Finset.mem_product.mp hj).2).1 + +lemma sum_common_cells {ι : Type*} [DecidableEq ι] (p : ι→O) (F : Finset ι) + (selector : Finset ι→ℂ) (G : FirstCommonIndex ι→ℂ) : + (∑j∈firstCommonIndices F,selector j.2.1*G j)= + ∑l∈commonKeys p F,∑j∈firstCommonIndices F,commonSelector p selector l j.2.1*G j := by + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro j hj + have hkey := common_key_of_index p F j hj + simp [commonSelector,ite_mul,hkey] + +theorem original_signed_partition {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (F : Finset ι) (S : Finset κ) (q : κ→Fin 6→ℝ) + (selector : κ→Finset ι→ℂ) (G : κ→FirstCommonIndex ι→ℂ) : + (∑x∈S,∑j∈firstCommonIndices F,selector x j.2.1*G x j)= + ∑k∈sourceKeys q S,∑l∈commonKeys p F,∑x∈sourceCell q S k, + ∑j∈firstCommonIndices F,commonSelector p (selector x) l j.2.1*G x j := by + rw [sum_source_cells q S] + apply Finset.sum_congr rfl + intro k hk + calc + _ = ∑x∈sourceCell q S k,∑l∈commonKeys p F, + ∑j∈firstCommonIndices F,commonSelector p (selector x) l j.2.1*G x j := by + apply Finset.sum_congr rfl + intro x hx + exact sum_common_cells p F (selector x) (G x) + _ = _ := Finset.sum_comm + +end SevenEighths.InverseMomentFirstChildWindows +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsLive.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsLive.lean new file mode 100644 index 0000000000000000000000000000000000000000..ae171c43b5d47948eab61dcb8ae359ae7852ca9c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsLive.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstChildWindowsCells + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstChildWindows +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels +open InverseSecondSourceBlocks (dyadIndex) +local notation "O" => ActualEisensteinCubic.O + +def liveCommonKeys {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (F : Finset ι) (S : Finset κ) + (selector : κ→Finset ι→ℂ) (G : κ→FirstCommonIndex ι→ℂ) : Finset ℕ := + (((S×ˢfirstCommonIndices F).filter (fun x=>selector x.1 x.2.2.1*G x.1 x.2≠0)).image + (fun x=>dyadIndex (primeProductNorm p x.2.2.1))) + +lemma sum_live_common_cells {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (F : Finset ι) (S : Finset κ) + (selector : κ→Finset ι→ℂ) (G : κ→FirstCommonIndex ι→ℂ) (x : κ) (hx : x∈S) : + (∑j∈firstCommonIndices F,selector x j.2.1*G x j)= + ∑l∈liveCommonKeys p F S selector G,∑j∈firstCommonIndices F,commonSelector p (selector x) l j.2.1*G x j := by + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro j hj + by_cases hz : selector x j.2.1*G x j=0 + · rw [hz] + symm + apply Finset.sum_eq_zero + intro l hl + by_cases he : dyadIndex (primeProductNorm p j.2.1)=l + · simpa only [commonSelector,he,ite_true] using hz + · simp only [commonSelector,he,ite_false,zero_mul] + · have hkey : dyadIndex (primeProductNorm p j.2.1)∈liveCommonKeys p F S selector G := by + exact Finset.mem_image.mpr ⟨(x,j), + Finset.mem_filter.mpr ⟨Finset.mem_product.mpr ⟨hx,hj⟩,hz⟩,rfl⟩ + simp [commonSelector,ite_mul,hkey] + +theorem original_live_signed_partition {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (F : Finset ι) (S : Finset κ) (q : κ→Fin 6→ℝ) + (selector : κ→Finset ι→ℂ) (G : κ→FirstCommonIndex ι→ℂ) : + (∑x∈S,∑j∈firstCommonIndices F,selector x j.2.1*G x j)= + ∑k∈sourceKeys q S,∑l∈liveCommonKeys p F S selector G,∑x∈sourceCell q S k, + ∑j∈firstCommonIndices F,commonSelector p (selector x) l j.2.1*G x j := by + rw [sum_source_cells q S] + apply Finset.sum_congr rfl + intro k hk + calc + _ = ∑x∈sourceCell q S k,∑l∈liveCommonKeys p F S selector G, + ∑j∈firstCommonIndices F,commonSelector p (selector x) l j.2.1*G x j := by + apply Finset.sum_congr rfl + intro x hx + exact sum_live_common_cells p F S selector G x (Finset.mem_filter.mp hx).1 + _ = _ := Finset.sum_comm + +theorem liveCommonKeys_card {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (F : Finset ι) (S : Finset κ) (selector : κ→Finset ι→ℂ) + (G : κ→FirstCommonIndex ι→ℂ) (R : ℝ) + (hcap : ∀x∈S,∀j∈firstCommonIndices F,selector x j.2.1*G x j≠0 → primeProductNorm p j.2.1≤R) : + (liveCommonKeys p F S selector G).card≤dyadIndex R+1 := by + have hsub : liveCommonKeys p F S selector G⊆Finset.range (dyadIndex R+1) := by + intro l hl + obtain ⟨⟨x,j⟩,hmem,rfl⟩ := Finset.mem_image.mp hl + obtain ⟨hxj,hn⟩ := Finset.mem_filter.mp hmem + obtain ⟨hx,hj⟩ := Finset.mem_product.mp hxj + apply Finset.mem_range.mpr + apply Nat.lt_succ_of_le + exact Nat.floor_mono (Real.logb_le_logb_of_le (by norm_num : (1:ℝ)<2) + (primeProductNorm_pos p hp _) (hcap x hx j hj hn)) + simpa only [Finset.card_range] using Finset.card_le_card hsub + +theorem original_live_norm_bound {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) (F : Finset ι) (S : Finset κ) (q : κ→Fin 6→ℝ) + (selector : κ→Finset ι→ℂ) (G : κ→FirstCommonIndex ι→ℂ) : + ‖∑x∈S,∑j∈firstCommonIndices F,selector x j.2.1*G x j‖≤ + ∑k∈sourceKeys q S,∑l∈liveCommonKeys p F S selector G, + ‖∑x∈sourceCell q S k,∑j∈firstCommonIndices F,commonSelector p (selector x) l j.2.1*G x j‖ := by + rw [original_live_signed_partition p F S q selector G] + exact (norm_sum_le _ _).trans (Finset.sum_le_sum (fun k hk=>norm_sum_le _ _)) + +end SevenEighths.InverseMomentFirstChildWindows +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..31b34106b18d0d8ad3309b368d0ee7f9ac4e27cb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstChildWindowsPhysical.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstChildWindowsCells + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstChildWindows +open InverseMoment InverseMomentFirstProfileUniform ActualEisensteinCubic FirstPassCubeLabels +open InverseSecondSourceBlocks (dyadScale dyadScale_pos) +local notation "O" => ActualEisensteinCubic.O + +def columnScales (k : SourceIndex) (l : ℕ) (X₁ X₂ : ℝ) : Fin 9→ℝ := + rawScales k l (X₁/(dyadScale (k 0)*dyadScale (k 2)*dyadScale l)) + (X₂/(dyadScale (k 1)*dyadScale (k 2)*dyadScale l)) + +lemma columnScales_pos (k : SourceIndex) (l : ℕ) (X₁ X₂ : ℝ) (h₁ : 0commonSelector p (selector x) l) C₁ C₂ w W₁ W₂ Φ A₁ A₂ C R K d h s := by + let G (x : κ) (j : FirstCommonIndex ι) := w x*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j* + firstNormProfile (fun y=>W₁ (y/(s 0*s 2*s 5*s 7))) + (fun y=>W₂ (y/(s 1*s 2*s 5*s 8))) Φ (fun _ _=>1) K + (firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j) + have rows (T : Finset κ) (sel : κ → Finset ι → ℂ) : + firstFamilyPhysicalRows p hg T F sel C₁ C₂ w W₁ W₂ Φ A₁ A₂ C R K d h s = + ∑ x ∈ T, ∑ j ∈ firstCommonIndices F, sel x j.2.1 * G x j := by + unfold firstFamilyPhysicalRows firstBlockedPhysicalRows + apply Finset.sum_congr rfl + intro x hx + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + dsimp only [G] + ring + have he := original_signed_partition p F S (sourceNorms A₁ A₂ C R d h) selector G + simpa only [rows] using he + +theorem original_physical_partition_raw {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] + (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (S : Finset κ) (F : Finset ι) (selector C₁ C₂ : κ→Finset ι→ℂ) (w : κ→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R : κ→ℝ) (K : ℝ) + (d h : κ→O) (s : Fin 9→ℝ) : + firstFamilyPhysicalRows p hg S F selector C₁ C₂ w W₁ W₂ Φ A₁ A₂ C R K d h s= + ∑k∈sourceKeys (sourceNorms A₁ A₂ C R d h) S,∑l∈commonKeys p F, + firstFamilyPhysicalRows p hg (sourceCell (sourceNorms A₁ A₂ C R d h) S k) F + (fun x=>commonSelector p (selector x) l) C₁ C₂ w W₁ W₂ Φ A₁ A₂ C R K d h + (columnScales k l (s 0*s 2*s 5*s 7) (s 1*s 2*s 5*s 8)) := by + rw [original_physical_partition p hg S F selector C₁ C₂ w W₁ W₂ Φ A₁ A₂ C R K d h s] + apply Finset.sum_congr rfl + intro k hk + apply Finset.sum_congr rfl + intro l hl + apply physical_scales_congr + · exact (columnScales_left k l _ _).symm + · exact (columnScales_right k l _ _).symm + +end SevenEighths.InverseMomentFirstChildWindows +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonChild.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonChild.lean new file mode 100644 index 0000000000000000000000000000000000000000..8a99d03b1bb10f5cba0463baba916f9fd72eda8e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonChild.lean @@ -0,0 +1,124 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCommonColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open SecondPassArithmetic FourierBridge +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +include hp in +theorem firstCommonColumn_eq_rayIdealRow + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (F D : Finset ι) (C : Finset ι → ℂ) (negative : Bool) (χ : RayCharacter) + (ω : ℝ → ℂ) (X t : ℝ) (hX : 0 < X) (h : Eis) : + firstCommonColumn p hg F D C negative χ ω X t h = + (if negative then star (supportRay p χ D) else supportRay p χ D) * + rayIdealRow p hg F + (fun S => C S * if negative then + star (ω (Real.exp (columnLog p (primeProductNorm p D*X) S)) * + logPhase t (columnLog p (primeProductNorm p D*X) S)) else + ω (Real.exp (columnLog p (primeProductNorm p D*X) S)) * + logPhase t (columnLog p (primeProductNorm p D*X) S)) negative χ D h := by + rw [rayIdealRow_eq_supportRow p hinj hg F D + (fun S => C S * if negative then + star (ω (Real.exp (columnLog p (primeProductNorm p D*X) S)) * + logPhase t (columnLog p (primeProductNorm p D*X) S)) else + ω (Real.exp (columnLog p (primeProductNorm p D*X) S)) * + logPhase t (columnLog p (primeProductNorm p D*X) S)) negative χ h] + simp only [firstCommonColumn,supportConjugateSum,Finset.mul_sum] + apply Finset.sum_congr rfl + intro U hU + have hdU : Disjoint D U := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hU) disjoint_sdiff_self_right + have hy : columnLog p (primeProductNorm p D*X) (D∪U) = + Real.log (primeProductNorm p U/X) := by + unfold columnLog + rw [primeProductNorm_union p D U hdU,mul_div_mul_left _ _ (primeProductNorm_pos p hp D).ne'] + have hR : supportRay p χ (D∪U) = supportRay p χ D*supportRay p χ U := by + rw [supportRay,Finset.prod_union hdU,rayCharacter_mul] + rfl + rw [hy,Real.exp_log (div_pos (primeProductNorm_pos p hp U) hX),hR] + cases negative <;> simp only [Bool.false_eq_true,ite_false,ite_true,star_mul] <;> ring + +variable (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + +def firstBareCubeCoefficient (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (d : Eis) : Finset ι → ℂ := + if negative then cubeMinusCoefficient p hp hcop hg B v ε₁ ε₂ C d + else cubePlusCoefficient p hp hcop hg B v ε₁ ε₂ C d + +theorem firstBareCubeCoefficient_window (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (V : ℝ → ℂ) (y : Finset ι → ℝ) (t : ℝ) (d : Eis) : + (fun S => firstBareCubeCoefficient p hp hg hcop B v ε₁ ε₂ negative C d S * + if negative then star (V (y S)*logPhase t (y S)) else V (y S)*logPhase t (y S)) = + cubeLogCoefficient p hp hcop hg B v ε₁ ε₂ negative C V y (-t) d := by + funext S + have ht : logPhase (-t) (-(y S)) = logPhase t (y S) := by + unfold logPhase + congr 1 + push_cast + ring + cases negative <;> + simp only [firstBareCubeCoefficient,cubeLogCoefficient,cubeMinusCoefficient,cubePlusCoefficient, + firstPassColumnMinus,firstPassColumnPlus,logTwistMinus,logTwistPlus, + Bool.false_eq_true,ite_false,ite_true,ht] <;> ring + +theorem firstCommonColumn_original_labels + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ j ∈ B,0 < v j) + (negative : Bool) (χ : RayCharacter) (C : Finset ι → ℂ) + (ω : ℝ → ℂ) (X t : ℝ) (hX : 0 < X) (c d f h : Eis) : + firstCommonColumn p hg F D + (firstBareCubeCoefficient p hp hg hcop B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative C c f) d) negative χ ω X t h = + (if negative then star (supportRay p χ D) else supportRay p χ D) * + (beforeDilationLabel (fun i => Ideal.span {p i}) hg p B v ε₁ ε₂ negative c d f D * + dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative χ C + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d (-t) + (h*f^2*dilationLabel p B v ε₁ ε₂)) := by + rw [firstCommonColumn_eq_rayIdealRow p hp hg hinj F D _ negative χ ω X t hX h, + firstBareCubeCoefficient_window p hp hg hcop B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative C c f) + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) t d, + rayIdealRow_cube_labels p hp hinj hcop hg F D B v ε₁ ε₂ hv] + rfl + +theorem firstCommonColumn_marked_priority {σ : Type*} [DecidableEq σ] + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F D B A : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ j ∈ B,0 < v j) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) (H : Finset ι → ℂ) + (ω : ℝ → ℂ) (X t : ℝ) (hX : 0 < X) (c d f h : Eis) : + firstCommonColumn p hg F D + (firstBareCubeCoefficient p hp hg hcop B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative + (multiplicativeCoreColumn p Ψ m (fun U => primeMark slots lists a (A∪U)*H U)) c f) d) + negative χ ω X t h = + (if negative then star (supportRay p χ D) else supportRay p χ D) * + (beforeDilationLabel (fun i => Ideal.span {p i}) hg p B v ε₁ ε₂ negative c d f D * + ∑ r : FirstCoreIndex,firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r * + ∑ J ∈ slots.powerset,primeMark J lists a (A∪D) * + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U => primeMark (slots\J) (fun i => lists i\(A∪D)) a U*H U) + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d r (-t) + (h*f^2*dilationLabel p B v ε₁ ε₂)) := by + rw [firstCommonColumn_original_labels p hp hg hcop hinj F D B v ε₁ ε₂ hv + negative χ (multiplicativeCoreColumn p Ψ m (fun U => primeMark slots lists a (A∪U)*H U)) + ω X t hX c d f h] + rw [marked_dilatedCoreRow_eq_input_family p hp hcop hg hc hpr F D B A v ε₁ ε₂ + negative χ Ψ m slots lists a H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) c d (-t)] + simp_rw [firstCoreInputRow_marked_priority] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonColumns.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonColumns.lean new file mode 100644 index 0000000000000000000000000000000000000000..0d5a2fdf3beb683e2fb899656ad9d2368a0c98e6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonColumns.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCommonMeasure + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstCommonColumn (F D : Finset ι) (C : Finset ι → ℂ) (negative : Bool) + (χ : RayCharacter) (ω : ℝ → ℂ) (X t : ℝ) (h : Eis) : ℂ := + supportConjugateSum (fun i => Ideal.span {p i}) hg (F\D) + (fun U => (if negative then star (supportRay p χ (D∪U)) else supportRay p χ (D∪U)) * + C (D∪U) * (if negative then star (ω (primeProductNorm p U/X)* + logPhase t (Real.log (primeProductNorm p U/X))) else + ω (primeProductNorm p U/X)*logPhase t (Real.log (primeProductNorm p U/X)))) h + +theorem firstCommonColumn_pair (F D : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (r : RayCharacter × RayCharacter) (ω₁ ω₂ : ℝ → ℂ) (X₁ X₂ t₁ t₂ : ℝ) (h : Eis) : + (∑ U ∈ (F\D).powerset, ∑ V ∈ (F\D).powerset, + firstCommonCoefficient p hg C₁ C₂ r D U V h * + (ω₁ (primeProductNorm p U/X₁)*ω₂ (primeProductNorm p V/X₂)) * + logPhase t₁ (Real.log (primeProductNorm p U/X₁)) * + logPhase t₂ (Real.log (primeProductNorm p V/X₂))) = + star (firstCommonColumn p hg F D C₁ true r.1 ω₁ X₁ t₁ h) * + firstCommonColumn p hg F D C₂ false r.2 ω₂ X₂ t₂ h := by + simp only [firstCommonColumn,supportConjugateSum,star_sum,Finset.sum_mul_sum] + apply Finset.sum_congr rfl + intro U hU + apply Finset.sum_congr rfl + intro V hV + simp only [firstCommonCoefficient,Bool.false_eq_true,ite_false,ite_true,star_mul,star_star] + ring + +def firstCommonOuterLog (A₁ A₂ C R : ℝ) (d h : Eis) (D : Finset ι) (s : Fin 9 → ℝ) : Fin 7 → ℝ := + ![Real.log (A₁/s 0),Real.log (A₂/s 1),Real.log (C/s 2),Real.log (‖eisEmbedding d‖^2/s 3), + Real.log (R/s 4),Real.log (primeProductNorm p D/s 5),Real.log (‖eisEmbedding h‖^2/s 6)] + +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem first_common_source_mode (A₁ A₂ C R : ℝ) (d h : Eis) (s : Fin 9 → ℝ) + (j : FirstCommonIndex ι) (z : Frequency × (Fin 9 → ℝ)) : + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2 = + firstOuterPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2) + (firstCommonOuterLog p A₁ A₂ C R d h j.2.1 s) * + logPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (Real.log (primeProductNorm p j.2.2.1/s 7)) * + logPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (Real.log (primeProductNorm p j.2.2.2/s 8)) := by + have hy : firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s = + firstCoordinates (firstCommonOuterLog p A₁ A₂ C R d h j.2.1 s) + (Real.log (primeProductNorm p j.2.2.1/s 7)) + (Real.log (primeProductNorm p j.2.2.2/s 8)) := by + funext i + fin_cases i <;> rfl + rw [hy,first_mode_split] + +def firstCommonSeparatedRow (F : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) (d h : Eis) (s : Fin 9 → ℝ) + (z : Frequency × (Fin 9 → ℝ)) : ℂ := + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2 * + ∑ D ∈ F.powerset, supportMobius (fun i => Ideal.span {p i}) D * rowCoprimeMask (fun i => Ideal.span {p i}) D h * + firstOuterPhase H (firstCommonOuterLog p A₁ A₂ C R d h D s) * + star (firstCommonColumn p hg F D C₁ true r.1 ω₁ (s 7) (H 7) h) * + firstCommonColumn p hg F D C₂ false r.2 ω₂ (s 8) (H 8) h + +theorem first_common_modes_eq_columns (F : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) (d h : Eis) (s : Fin 9 → ℝ) + (z : Frequency × (Fin 9 → ℝ)) : + (∑ j ∈ firstCommonIndices F,firstCommonWeight p hg C₁ C₂ h j * + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8)) * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2) = + firstCommonSeparatedRow p hg F C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z := by + simp only [firstCommonIndices,Finset.sum_product,Finset.sum_sigma, + firstCommonWeight,firstCommonSeparatedRow,Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + calc + _ = crossCoeff r.1 r.2 * + (supportMobius (fun i => Ideal.span {p i}) D * rowCoprimeMask (fun i => Ideal.span {p i}) D h * + firstOuterPhase H (firstCommonOuterLog p A₁ A₂ C R d h D s)) * + (∑ U ∈ (F\D).powerset, ∑ V ∈ (F\D).powerset, + firstCommonCoefficient p hg C₁ C₂ r D U V h * + (ω₁ (primeProductNorm p U/s 7)*ω₂ (primeProductNorm p V/s 8)) * + logPhase (H 7) (Real.log (primeProductNorm p U/s 7)) * + logPhase (H 8) (Real.log (primeProductNorm p V/s 8))) := by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro U hU + apply Finset.sum_congr rfl + intro V hV + rw [first_common_source_mode] + dsimp only [H] + ring + _ = _ := by + rw [firstCommonColumn_pair] + dsimp only [H] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonMeasure.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonMeasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..d0ec55713a8214df87f600244888cc887882b491 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonMeasure.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstPhysicalCommon +import OAI.NumberTheory.DirichletL.Descent.FirstFreshMeasure + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation MeasureTheory +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +abbrev FirstCommonIndex (ι : Type*) := + (RayCharacter × RayCharacter) × (Σ _ : Finset ι, Finset ι × Finset ι) + +def firstCommonIndices {ι : Type*} [DecidableEq ι] (F : Finset ι) : Finset (FirstCommonIndex ι) := + Finset.univ ×ˢ F.powerset.sigma (fun D => (F\D).powerset ×ˢ (F\D).powerset) + +def firstCommonNorms {ι : Type*} (p : ι → Eis) (A₁ A₂ C R : ℝ) (d h : Eis) + (j : FirstCommonIndex ι) : Fin 9 → ℝ := + ![A₁,A₂,C,‖eisEmbedding d‖^2,R,primeProductNorm p j.2.1, + ‖eisEmbedding h‖^2,primeProductNorm p j.2.2.1,primeProductNorm p j.2.2.2] + +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstCommonWeight (C₁ C₂ : Finset ι → ℂ) (h : Eis) (j : FirstCommonIndex ι) : ℂ := + crossCoeff j.1.1 j.1.2 * supportMobius (fun i => Ideal.span {p i}) j.2.1 * + rowCoprimeMask (fun i => Ideal.span {p i}) j.2.1 h * + firstCommonCoefficient p hg C₁ C₂ j.1 j.2.1 j.2.2.1 j.2.2.2 h + +theorem firstPhysicalCommonRows_indexed (F : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R K : ℝ) (d h : Eis) : + firstPhysicalCommonRows p hg F C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h = + ∑ j ∈ firstCommonIndices F, firstCommonWeight p hg C₁ C₂ h j * + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K (firstCommonNorms p A₁ A₂ C R d h j) := by + simp only [firstPhysicalCommonRows,firstCommonIndices,Finset.sum_product,Finset.sum_sigma, + firstCommonWeight,firstCommonNorms,Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + apply Finset.sum_congr rfl + intro U hU + apply Finset.sum_congr rfl + intro V hV + ring + +theorem firstPhysicalCommonRows_integral (F : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R K : ℝ) (d h : Eis) + (s : Fin 9 → ℝ) (g : Fin 9 → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) + (he : ∀ j ∈ firstCommonIndices F, + firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K + (firstCommonNorms p A₁ A₂ C R d h j) = + (firstRootScale s:ℂ)⁻¹ * + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8)) * + ∫ z : Frequency × (Fin 9 → ℝ),fullProfileDensity g b₁ b₂ b₃ z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2) : + firstPhysicalCommonRows p hg F C₁ C₂ + (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) + Φ A₁ A₂ C R K d h = + (firstRootScale s:ℂ)⁻¹ * ∫ z : Frequency × (Fin 9 → ℝ),fullProfileDensity g b₁ b₂ b₃ z * + ∑ j ∈ firstCommonIndices F,firstCommonWeight p hg C₁ C₂ h j * + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8)) * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2 := by + rw [firstPhysicalCommonRows_indexed] + calc + _ = (firstRootScale s:ℂ)⁻¹ * ∑ j ∈ firstCommonIndices F, + (firstCommonWeight p hg C₁ C₂ h j * + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8))) * + ∫ z : Frequency × (Fin 9 → ℝ),fullProfileDensity g b₁ b₂ b₃ z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2 := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + rw [he j hj] + ring + _ = _ := by + rw [full_density_finite_sum] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonProfile.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..31ff6c1c57d6442da2a3fd65479e4c0d507897ad --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCommonProfile.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstNominal +import OAI.NumberTheory.DirichletL.Descent.FirstCoupledReindex + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem firstNormProfile_common_support (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (A₁ A₂ C D R T H X₁ X₂ K : ℝ) (hT : 0 ≤ T) : + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K ![A₁,A₂,C,D,R,1,H,T*X₁,T*X₂] = + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K ![A₁,A₂,C,D,R,T,H,X₁,X₂] := by + have hroot : Real.sqrt (T*X₁)*Real.sqrt (T*X₂) = + T*Real.sqrt X₁*Real.sqrt X₂ := by + rw [Real.sqrt_mul hT,Real.sqrt_mul hT] + calc + _ = (Real.sqrt T)^2*Real.sqrt X₁*Real.sqrt X₂ := by ring + _ = _ := by rw [Real.sq_sqrt hT] + unfold firstNormProfile + simp only [Finset.prod_const_one,one_mul,Matrix.cons_val_zero, + Fin.isValue,] + change W₁ (A₁*C*1*(T*X₁))*W₂ (A₂*C*1*(T*X₂))* + EisensteinSchwartzPoisson.paperRadialFourier Φ (K*H/(D*R*1^2*(T*X₁)*(T*X₂))) / + ((D:ℂ)*(Real.sqrt R:ℂ)*(1:ℂ)*(Real.sqrt (T*X₁):ℂ)*(Real.sqrt (T*X₂):ℂ)) = + W₁ (A₁*C*T*X₁)*W₂ (A₂*C*T*X₂)* + EisensteinSchwartzPoisson.paperRadialFourier Φ (K*H/(D*R*T^2*X₁*X₂)) / + ((D:ℂ)*(Real.sqrt R:ℂ)*(T:ℂ)*(Real.sqrt X₁:ℂ)*(Real.sqrt X₂:ℂ)) + simp only [mul_one,one_pow] + rw [show A₁*C*(T*X₁) = A₁*C*T*X₁ from by ring, + show A₂*C*(T*X₂) = A₂*C*T*X₂ from by ring, + show K*H/(D*R*(T*X₁)*(T*X₂)) = K*H/(D*R*T^2*X₁*X₂) from by ring] + have hc : (Real.sqrt (T*X₁):ℂ)*(Real.sqrt (T*X₂):ℂ) = + (T:ℂ)*(Real.sqrt X₁:ℂ)*(Real.sqrt X₂:ℂ) := by exact_mod_cast hroot + rw [show (D:ℂ)*(Real.sqrt R:ℂ)*(Real.sqrt (T*X₁):ℂ)*(Real.sqrt (T*X₂):ℂ) = + (D:ℂ)*(Real.sqrt R:ℂ)*((Real.sqrt (T*X₁):ℂ)*(Real.sqrt (T*X₂):ℂ)) from by ring,hc] + ring + +theorem firstNormProfile_actual_common {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) (D U V : Finset ι) + (hDU : Disjoint D U) (hDV : Disjoint D V) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C E R H K : ℝ) : + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + ![A₁,A₂,C,E,R,1,H,primeProductNorm p (D∪U),primeProductNorm p (D∪V)] = + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + ![A₁,A₂,C,E,R,primeProductNorm p D,H,primeProductNorm p U,primeProductNorm p V] := by + rw [primeProductNorm_union p D U hDU,primeProductNorm_union p D V hDV] + exact firstNormProfile_common_support W₁ W₂ Φ A₁ A₂ C E R _ H _ _ K + (primeProductNorm_pos p hp D).le + +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstCoupledRayColumns (F : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (H : Finset ι → Finset ι → ℂ) (h : Eis) : ℂ := + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2 * + ∑ D ∈ F.powerset, supportMobius (fun i => Ideal.span {p i}) D * rowCoprimeMask (fun i => Ideal.span {p i}) D h * + ∑ U ∈ (F \ D).powerset, ∑ V ∈ (F \ D).powerset, + H (D ∪ U) (D ∪ V) * + star (supportMobius (fun i => Ideal.span {p i}) U * + (star (supportRay p r.1 (D ∪ U))*C₁ (D ∪ U)) * star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg U h)) * + (supportMobius (fun i => Ideal.span {p i}) V * + (supportRay p r.2 (D ∪ V)*C₂ (D ∪ V)) * star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg V h)) + +theorem actual_first_gauss_coupled_reindex + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F B : Finset ι) (hFB : Disjoint F B) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (H : Finset ι → Finset ι → ℂ) (d h : Eis) : + (∑ N ∈ F.powerset, ∑ P ∈ F.powerset, if Disjoint N P then + H N P * threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h else 0) = + cubeBaseFactor p hp hg B v ε₁ ε₂ d h * + firstCoupledRayColumns p hg F + (cubeMinusCoefficient p hp hcop hg B v ε₁ ε₂ C₁ d) + (cubePlusCoefficient p hp hcop hg B v ε₁ ε₂ C₂ d) H h := by + rw [firstCoupledRayColumns, ← first_quadratic_coupled_reindex p hp hinj hg hc] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro P hP + by_cases hd : Disjoint N P + · simp only [hd,ite_true] + rw [threeGaussRowFactor_eq_ray_columns p hp hcop hg hc hpr N P B hd + (hFB.mono_left (Finset.mem_powerset.mp hN)) (hFB.mono_left (Finset.mem_powerset.mp hP))] + ring + · simp [hd] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCoupledReindex.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCoupledReindex.lean new file mode 100644 index 0000000000000000000000000000000000000000..7f12009c9507fcf61294e13fa032000b0f2b0ebc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCoupledReindex.lean @@ -0,0 +1,126 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstActualEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic CoprimeMobiusExtension +open RayFourExpansion MixedCrossSeparation +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem first_coprime_coupled_reindex {ι : Type*} [DecidableEq ι] + (P : ι → Ideal Eis) [∀ i, (P i).IsMaximal] + (hprime : ∀ i, Prime (P i)) (hinj : Function.Injective P) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ P i) (B : Finset ι) + (C₁ C₂ : Finset ι → ℂ) (H : Finset ι → Finset ι → ℂ) (h : Eis) : + (∑ S ∈ B.powerset, ∑ T ∈ B.powerset, if Disjoint S T then + H S T * star (supportMobius P S * C₁ S * star (finiteSquarefreeRow P hg S h)) * + (supportMobius P T * C₂ T * star (finiteSquarefreeRow P hg T h)) else 0) = + ∑ D ∈ B.powerset, supportMobius P D * rowCoprimeMask P D h * + ∑ U ∈ (B \ D).powerset, ∑ V ∈ (B \ D).powerset, + H (D ∪ U) (D ∪ V) * + star (supportMobius P U * C₁ (D ∪ U) * star (finiteSquarefreeRow P hg U h)) * + (supportMobius P V * C₂ (D ∪ V) * star (finiteSquarefreeRow P hg V h)) := by + rw [double_sum_disjoint_reindexed] + apply Finset.sum_congr rfl + intro D hD + rw [← prime_product_moebius P hprime hinj D] + change supportMobius P D * _ = _ + rw [mul_assoc] + congr 1 + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro U hU + apply Finset.sum_congr rfl + intro V hV + have hdU : Disjoint D U := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hU) disjoint_sdiff_self_right + have hdV : Disjoint D V := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hV) disjoint_sdiff_self_right + have hmu (S T : Finset ι) (hd : Disjoint S T) : + supportMobius P (S ∪ T) = supportMobius P S * supportMobius P T := by + simp only [supportMobius,prime_product_moebius P hprime hinj, + Finset.card_union_of_disjoint hd,pow_add] + have hrow (S T : Finset ι) (hd : Disjoint S T) : + finiteSquarefreeRow P hg (S ∪ T) h = + finiteSquarefreeRow P hg S h * finiteSquarefreeRow P hg T h := Finset.prod_union hd + rw [hmu D U hdU,hmu D V hdV,hrow D U hdU,hrow D V hdV] + simp only [star_mul,star_star,star_supportMobius] + have hm := supportMobius_sq P hprime hinj D + have hz := finiteSquarefreeRow_self_pair P hg D h + calc + _ = (supportMobius P D * supportMobius P D) * + (star (finiteSquarefreeRow P hg D h)*finiteSquarefreeRow P hg D h) * + (H (D ∪ U) (D ∪ V) * + (supportMobius P U * star (C₁ (D ∪ U)) * finiteSquarefreeRow P hg U h) * + (supportMobius P V * C₂ (D ∪ V) * star (finiteSquarefreeRow P hg V h))) := by ring + _ = _ := by rw [hm,hz]; ring + +theorem first_quadratic_coupled_reindex {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) (B : Finset ι) + (C₁ C₂ : Finset ι → ℂ) (H : Finset ι → Finset ι → ℂ) (h : Eis) : + (∑ S ∈ B.powerset, ∑ T ∈ B.powerset, if Disjoint S T then + H S T * quadraticCrossPhase p hg S T * + star (supportMobius (fun i => Ideal.span {p i}) S * C₁ S * star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg S h)) * + (supportMobius (fun i => Ideal.span {p i}) T * C₂ T * star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg T h)) else 0) = + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2 * + ∑ D ∈ B.powerset, supportMobius (fun i => Ideal.span {p i}) D * rowCoprimeMask (fun i => Ideal.span {p i}) D h * + ∑ U ∈ (B \ D).powerset, ∑ V ∈ (B \ D).powerset, + H (D ∪ U) (D ∪ V) * + star (supportMobius (fun i => Ideal.span {p i}) U * + (star (supportRay p r.1 (D ∪ U))*C₁ (D ∪ U)) * star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg U h)) * + (supportMobius (fun i => Ideal.span {p i}) V * + (supportRay p r.2 (D ∪ V)*C₂ (D ∪ V)) * star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg V h)) := by + let P := fun i => Ideal.span {p i} + have hcop : Pairwise (Function.onFun IsCoprime P) := by + intro i j hij + exact Ideal.isCoprime_of_isMaximal (hinj.ne hij) + have hprime (i : ι) : Prime (P i) := Ideal.prime_of_isPrime (NeZero.ne (P i)) inferInstance + let T := fun (r : RayCharacter × RayCharacter) (S V : Finset ι) => if Disjoint S V then + H S V * star (supportMobius P S * (star (supportRay p r.1 S)*C₁ S) * star (finiteSquarefreeRow P hg S h)) * + (supportMobius P V * (supportRay p r.2 V*C₂ V) * star (finiteSquarefreeRow P hg V h)) else 0 + have he (S V : Finset ι) : + (if Disjoint S V then H S V * quadraticCrossPhase p hg S V * + star (supportMobius P S*C₁ S*star (finiteSquarefreeRow P hg S h)) * + (supportMobius P V*C₂ V*star (finiteSquarefreeRow P hg V h)) else 0) = + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2*T r S V := by + by_cases hd : Disjoint S V + · rw [ite_eq_left hd,quadraticCrossPhase_character_expansion p hp hcop hg hc S V hd] + simp only [Fintype.sum_prod_type,T,ite_eq_left hd,Finset.sum_mul,Finset.mul_sum] + apply Finset.sum_congr rfl + intro χ hχ + apply Finset.sum_congr rfl + intro η hη + simp only [supportRay,star_mul,star_star] + ring + · simp [T,hd] + calc + _ = ∑ S ∈ B.powerset, ∑ V ∈ B.powerset, + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2*T r S V := by + apply Finset.sum_congr rfl + intro S hS + exact Finset.sum_congr rfl (fun V hV => he S V) + _ = ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2 * + ∑ S ∈ B.powerset, ∑ V ∈ B.powerset, T r S V := by + simp only [Finset.mul_sum] + calc + _ = ∑ S ∈ B.powerset, ∑ r : RayCharacter × RayCharacter, + ∑ V ∈ B.powerset, crossCoeff r.1 r.2*T r S V := by + apply Finset.sum_congr rfl + intro S hS + exact Finset.sum_comm + _ = _ := Finset.sum_comm + _ = _ := by + apply Finset.sum_congr rfl + intro r hr + congr 1 + exact first_coprime_coupled_reindex P hprime hinj hg B _ _ H h + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstCutoffScale.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCutoffScale.lean new file mode 100644 index 0000000000000000000000000000000000000000..3adc7876aca52ad0f29042a850020ed85451ebac --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstCutoffScale.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstRowGeometry + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem first_physical_row_scale_bound + (Z M r ell V delta B j eta tau dn cn jn : ℝ) (hZ : 0v₁ i+v₂ i) ε₁ ε₂)‖^2) + (hcol₁ : ‖eisEmbedding (aLabel p S ε₁)‖^2*primeProductNorm p common*primeProductNorm p N≤Z^(r+eta)) + (hcol₂ : ‖eisEmbedding (aLabel p S ε₂)‖^2*primeProductNorm p common*primeProductNorm p Q≤Z^(r+eta)) + (hratio : (Z^M/(primeProductNorm p divisor * + primeProductNorm p ((N∪Q)∪cubeActiveSupport S (fun i=>v₁ i+v₂ i) ε₁ ε₂)))*‖eisEmbedding h‖^2≤Z^tau) : + ‖eisEmbedding (DescentWeightedCauchy.firstElementRowMap + (dilationLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂) (f,h))‖^2 ≤ + Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau) := by + have hrow := first_ratio_actual_row p hp S N Q v₁ v₂ ε₁ ε₂ hv hNQ hNS hQS common divisor f h + (Z^M) (Z^tau) (Z^(r+eta)) (Z^(ell+eta)) (Z^(V+eta)) + (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) + (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) hb₁ hb₂ hf hcol₁ hcol₂ hratio + exact hrow.trans (first_physical_row_scale_bound Z M r ell V delta B j eta tau + (primeProductNorm p divisor) (primeProductNorm p common) + (‖eisEmbedding (jLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂)‖^2) hZ + (primeProductNorm_pos p hp _).le (primeProductNorm_pos p hp _) + (SecondPassIntegration.elementNorm_pos _ (primeProduct_ne_zero p hp _ _)) hd hc hj) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicCell.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicCell.lean new file mode 100644 index 0000000000000000000000000000000000000000..c545b416d927245c7ee9aa8734b7c6dd2a8b2814 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicCell.lean @@ -0,0 +1,54 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicRadius +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents + +namespace OAI + +noncomputable section +open scoped Classical BigOperators + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O +variable {ι:Type*}[DecidableEq ι] +variable (p:ι→O) + +def firstCellRadius (Z M r ell V eta tau:ℝ)(k:SourceIndex)(j:ℕ):ℝ:= + Z^(firstPhysicalHeight M r ell V (dyadicExponent Z (k 3)) + (dyadicExponent Z (k 2)) (dyadicExponent Z j)+12*eta+tau) + +theorem first_dyadic_radius_cell (pool:Finset ι)(Q:Finset (ι→₀ℕ)) + (k:SourceIndex)(j:ℕ)(x:FirstOriginalOuter ι) + (hx:x∈refinedOuter p pool Q k (labelGate p j)) + (Z M r ell V eta tau:ℝ): + firstDyadicRadius p x.1 x.2.1 x.2.2 Z M r ell V eta tau= + firstCellRadius Z M r ell V eta tau k j:=by + rw [refinedOuter_label] at hx + obtain ⟨hx,hj⟩:=Finset.mem_filter.mp hx + have hg:outerGate p k x:=(Finset.mem_filter.mp hx).2 + have hC:=hg 2 + have hD:=hg 3 + change dyadIndex (primeProductNorm p x.2.1)=k 2 at hC + change dyadIndex (‖eisEmbedding (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.2.2)‖^2)=k 3 at hD + rw [primeSubsetGenerator_norm_eq_productNorm] at hD + unfold firstDyadicRadius firstCellRadius firstDyadicExponent + rw [hD,hC] + change dyadIndex (‖eisEmbedding (jLabel p x.1.support + (fun i=>x.1.leftExponent i+x.1.rightExponent i) x.1.leftBit x.1.rightBit)‖^2)=j at hj + rw [hj] + +theorem first_dyadic_refined_cutoff (pool:Finset ι)(Q:Finset (ι→₀ℕ)) + (k:SourceIndex)(j:ℕ)(Z M r ell V eta tau:ℝ): + ∀x∈refinedOuter p pool Q k (labelGate p j),∀_I:Ideal O, + firstDyadicRadius p x.1 x.2.1 x.2.2 Z M r ell V eta tau≤ + firstCellRadius Z M r ell V eta tau k j:=by + intro x hx I + exact (first_dyadic_radius_cell p pool Q k j x hx Z M r ell V eta tau).le + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicFullEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicFullEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..0361a8c8067a15f4dde21715235a5529e45cd740 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicFullEnergy.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicPriorityBudget +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_dyadic_full_energy + (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V Γ theta Benergy:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Mmax)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r) + (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool) + (_hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap) + + (_hΨ:∀u,‖Ψ u‖≤1)(_hΓ:0≤Γ)(_hB:0≤Benergy) + (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0)(_hβ:∀I∈labels,∀v∈Q,‖β I v‖≤Γ) + (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) + (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1), + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Lcap+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W rowMajorant (Z^M)); + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 0)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.rightExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + true Ψ m slots lists weights omega₁ + ((physicalScales (Z^r) k.1 k.2.1) 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.leftExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + false Ψ m slots lists weights omega₂ + ((physicalScales (Z^r) k.1 k.2.1) 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=> + varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (ConcretePrimeRowBridge.idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤ + Czero*Γ^2*Z^(M-ell+3*eta+eps*(5*ell+2*r+7*eta))+ + C*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)* + Z^((2*Lcap+15*eta+tau)*eps+eps)+Ctail*Γ^2*Z^(-saving) :=by + obtain ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,he⟩:=original_dyadic_priority_budget om rowMajorant a b ha hs Lcap hcap hb + refine ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro eps heps J + obtain ⟨C,hC,hret⟩:=he eps heps J + obtain ⟨Cz,Ct,hCz,hCt,hbranches⟩:=original_dyadic_zero_tail om b Mmax Lcap eta tau (saving+eta) eps + (fun y hy=>(hs hy).2) hMmax hcap heta htau heps + refine ⟨C,Cz,Ct,hC,hCz,hCt,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights Z M r ell V Γ theta Benergy + hZ hbin hM hF hMcap hell hV hr hbZ hQpool hQ hrcap hellcap hΨ hΓ hB hsf hn hβ hlabels hslots hweights + mark Y cutoff W source keys hleft hright + have hz:0Real.rpow_nonneg hz.le _) + (fun x hx _ _=>first_dyadic_original_cap p hp pool Q Z M r ell V eta tau Lcap hZ1 hbin hM hF hQ x hx) + (fun _=>1) (by intro i;norm_num) + have hret':=hret p hp hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights Z M r ell V eta tau Lcap Γ + (Z^M) theta Benergy hZ hbin hM hF hQ hrcap hellcap hcap le_rfl heta heta1 htau.le htau1 hΨ hΓ hK hB hsf hn hβ hleft hright + obtain ⟨hz',ht'⟩:=hbranches p hp hcop hg hinj hc pool Q labels β Ψ m slots lists weights Z M r ell V Γ theta + hZ1 hbin hM hMcap hell hV hr hF hΓ hbZ hΨ hQ hn hlabels hβ hslots hweights + have hfactor:Z^(-r-2*ell-V)≤Z^eta:=Real.rpow_le_rpow_of_exponent_le hZ1.le (by linarith) + have htail:Z^(-r-2*ell-V)*‖reopenedPhysicalSourceSum pool Q labels β (fun q D I=> + canonicalCubeDualTail p hp hcop hg pool q D Ψ Ψ m m (ConcretePrimeRowBridge.idealGenerator I) + (fun U=>mark q.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark q.leftExponent U*W (primeProductNorm p U)) rowMajorant (Z^M) + (reopenedPhysicalCutoff p q I (cutoff q D I)))‖≤Ct*Γ^2*Z^(-saving):=by + have ht'':_≤Ct*Γ^2*Z^(-(saving+eta)):=ht' + apply (mul_le_mul hfactor ht'' (norm_nonneg _) (Real.rpow_nonneg hz.le _)).trans + apply le_of_eq + rw [show Z^eta*(Ct*Γ^2*Z^(-(saving+eta)))=(Ct*Γ^2)*(Z^eta*Z^(-(saving+eta))) by ring, + ←Real.rpow_add hz] + congr 2 + ring + have hall:=mul_le_mul_of_nonneg_left he' (Real.rpow_nonneg hz.le (-r-2*ell-V)) + simp only [mul_add] at hall + apply hall.trans + have hr':Z^(-r-2*ell-V)*((Z^M)*‖originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W rowMajorant (Z^M) Y cutoff (fun _=>1)‖)≤ + C*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)*Z^((2*Lcap+15*eta+tau)*eps+eps):=by + simpa only [mul_assoc] using hret' + exact add_le_add (add_le_add hz' hr') htail + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicLiveRadius.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicLiveRadius.lean new file mode 100644 index 0000000000000000000000000000000000000000..c1911e1da06e2d64c5a8881f7c11e33b17a5363c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicLiveRadius.lean @@ -0,0 +1,58 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicCell +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLivePartition + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O +variable {ι:Type*}[DecidableEq ι] +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem first_dyadic_original_cap (pool:Finset ι)(Q:Finset (ι→₀ℕ)) + (Z M r ell V eta tau Fmax:ℝ)(hZ:1labels) (fun x=>x.1) Y) pool term): + firstCellRadius Z M r ell V eta tau k.1 k.2.2≤Z^(2*Fmax+15*eta+tau):=by + obtain ⟨⟨x,j⟩,hx,rfl⟩:=Finset.mem_image.mp hk + have hm:=Finset.mem_product.mp (Finset.mem_filter.mp hx).1 + have ho: x.1∈firstOriginalOuter pool Q:=(Finset.mem_sigma.mp hm.1).1 + have href:x.1∈refinedOuter p pool Q (sourceIndex (InverseMomentFirstOriginalProfile.originalNorms p) x) + (labelGate p (dyadIndex (InverseFirstGlobalCaps.jNorm p x.1))):=by + rw [refinedOuter_label] + apply Finset.mem_filter.mpr + refine ⟨?_,rfl⟩ + apply InverseFirstGlobalCaps.sourceCell_outer p pool Q labels Y + exact Finset.mem_filter.mpr ⟨hm.1,rfl⟩ + change firstCellRadius Z M r ell V eta tau (sourceIndex (InverseMomentFirstOriginalProfile.originalNorms p) x) + (dyadIndex (InverseFirstGlobalCaps.jNorm p x.1))≤_ + rw [←first_dyadic_radius_cell p pool Q _ _ x.1 href] + exact first_dyadic_original_cap p hp pool Q Z M r ell V eta tau Fmax hZ hbin hM hF hQ x.1 ho + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicOriginalBranches.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicOriginalBranches.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e2b3f0df78611db318ad9f90f8c9786831ff81c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicOriginalBranches.lean @@ -0,0 +1,89 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicTail +import OAI.NumberTheory.DirichletL.Descent.OriginalZeroPhysical + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +open CompletedHeight SecondPassIntegration FourierBridge +local notation "O"=>ActualEisensteinCubic.O + +theorem original_dyadic_zero_tail + (om:𝓢(ℝ,ℂ))(b Mmax Fmax eta tau saving eps:ℝ) + (hs:∀y,om y≠0→y≤b)(hMm:0≤Mmax)(hFm:0≤Fmax)(heta:0≤eta)(htau:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V Γ theta:ℝ), + 1normTwistedSource om theta (y/Z^r); + let mark:=fun (v:ι→₀ℕ) U=>primeMark slots lists weights (v.support∪U); + Z^(-r-2*ell-V)*‖reopenedPhysicalSourceSum pool Q labels β (fun q C I=> + canonicalCubeDualZero p hp hcop hg pool q C Ψ Ψ m m (ConcretePrimeRowBridge.idealGenerator I) + (fun U=>mark q.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark q.leftExponent U*W (primeProductNorm p U)) rowMajorant (Z^M))‖≤ + Czero*Γ^2*Z^(M-ell+3*eta+eps*(5*ell+2*r+7*eta)) ∧ + ‖reopenedPhysicalSourceSum pool Q labels β (fun q C I=> + canonicalCubeDualTail p hp hcop hg pool q C Ψ Ψ m m (ConcretePrimeRowBridge.idealGenerator I) + (fun U=>mark q.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark q.leftExponent U*W (primeProductNorm p U)) rowMajorant (Z^M) + (firstDyadicPhysicalCutoff p q C I Z M r ell V eta tau))‖≤Ctail*Γ^2*Z^(-saving):=by + obtain ⟨Cz,hCz,hzero⟩:=original_first_zero_physical eps heps + obtain ⟨s,Ct,hCt,htail⟩:=full_first_dyadic_marked_rapid_tail Mmax Fmax eta tau saving hMm hFm heta htau + let G:=SchwartzMap.seminorm ℝ 0 0 om + let Cz':=Cz*G^2*‖paperRadialFourier rowMajorant 0‖ + let Ct':=Ct*G^2*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant) + refine ⟨Cz',Ct',by dsimp [Cz'];positivity,by dsimp [Ct'];positivity,?_⟩ + intro ι σ _ _ p hp _ hcop hg hinj hc pool Q labels β Ψ m slots lists weights Z M r ell V Γ theta + hZ hbin hM hMmax hell hV hr hF hΓ hb hΨ hQ hn hlabels hβ hslots hw W mark + have hz:0q.rightExponent.support) (fun q=>q.leftExponent.support) + (fun _ U=>W (primeProductNorm p U)) (fun _ U=>W (primeProductNorm p U)) rowMajorant Z M r ell V + (Γ^2) G G hZ hbin hM hMmax hell hV hr hF (sq_nonneg _) hG hG hΨ hΨ + (reopenedCubeFamily_admissible Q) (fun q hq=>(hcb q hq).1) (fun q hq=>(hcb q hq).2) + hn hlabels (fun q hq C _ I hI=>reopenedPairCoefficient_bound Q labels β Γ hΓ hβ q hq C I hI) + hslots hw (fun _ _=>Finset.subset_union_right) (fun _ _=>Finset.subset_union_left) + (fun _ _=>hW) (fun _ _=>hW) (fun _ _=>hsupport) (fun _ _=>hsupport) + constructor + · simpa only [mark,Finset.union_comm,Cz',G,mul_assoc,mul_left_comm,mul_comm] using hzero' + · simpa only [mark,reopenedPhysicalSourceSum,Ct',pow_two,mul_assoc,mul_left_comm,mul_comm] using htail' + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicPriorityBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicPriorityBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..b335cb7304eeede3f7869bebd6893994e65244ce --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicPriorityBudget.lean @@ -0,0 +1,99 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicRetainedBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_dyadic_priority_budget + (om Φ:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V eta tau Fmax Γ K theta Benergy:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Fmax) + (_hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap)(_hF0:0≤Fmax)(_hFcap:Fmax≤Lcap) + (_heta:0≤eta)(_heta1:eta≤1)(_htau:0≤tau)(_htau1:tau≤1) + (_hΨ:∀u,‖Ψ u‖≤1)(_hΓ:0≤Γ)(_hK:0primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Fmax+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K); + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 0)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.rightExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + true Ψ m slots lists weights omega₁ + ((physicalScales (Z^r) k.1 k.2.1) 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.leftExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + false Ψ m slots lists weights omega₂ + ((physicalScales (Z^r) k.1 k.2.1) 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (Z^(-r-2*ell-V)*Z^M)*‖originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W Φ K Y cutoff (fun _=>1)‖≤ + C*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)* + Z^((2*Fmax+15*eta+tau)*eps+eps) :=by + obtain ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,he⟩:=original_dyadic_retained_budget om Φ a b ha hs Lcap hcap hb + refine ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro eps heps J + obtain ⟨C,hC,henergy⟩:=he eps heps J + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights Z M r ell V eta tau Fmax Γ K theta Benergy + hZ hbin hM hF hQ hrcap hellcap hF0 hFcap heta heta1 htau htau1 hΨ hΓ hK hB hsf hn hβ + mark Y cutoff W source keys hleft hright + have hz:0ActualEisensteinCubic.O +variable {ι:Type*}[DecidableEq ι] + +def firstDyadicExponent (Z x:ℝ):ℝ:=dyadicExponent Z (dyadIndex x) + +theorem first_dyadic_bounds (Z eta x:ℝ)(hZ:1b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2))+12*eta+tau) + +def firstDyadicPhysicalCutoff (p:ι→O)(b:CubeCoordinates ι)(C:Finset ι)(I:Ideal O) + (Z M r ell V eta tau:ℝ)(D:Finset ι):Finset O:= + childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit I) + (firstDyadicRadius p b C D Z M r ell V eta tau) + +theorem first_dyadic_radius_global_cap + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (b:CubeCoordinates ι)(C D:Finset ι) + (hD:D⊆C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit) + (Z M r ell V eta tau Fmax:ℝ)(hZ:1b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2) hZ hbin + (EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq _ (primeProduct_ne_zero p hp _ _)) + have hs:=cube_whole_support_dyad p hp b (Z^(ell+eta)) (Real.rpow_nonneg hz.le _) h₁ h₂ + have hn:primeProductNorm p D≤Z^(firstDyadicExponent Z (primeProductNorm p C)+2*ell+3*eta):=by + calc + _≤primeProductNorm p (C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit):= + primeProductNorm_mono p hp hD + _≤primeProductNorm p C*primeProductNorm p b.support:= + (primeProductNorm_union_le_mul p hp _ _).trans + (mul_le_mul_of_nonneg_left (primeProductNorm_mono p hp (Finset.filter_subset _ _)) (primeProductNorm_pos p hp _).le) + _≤Z^(firstDyadicExponent Z (primeProductNorm p C)+eta)*(Z^(ell+eta))^2:= + mul_le_mul hC.2.2 hs (primeProductNorm_pos p hp _).le (Real.rpow_nonneg hz.le _) + _=_:=by + rw [←Real.rpow_natCast,←Real.rpow_mul hz.le,←Real.rpow_add hz] + congr 1 + norm_num + ring + have hde:= (Real.rpow_le_rpow_left_iff hZ).mp (hd.2.1.trans hn) + unfold firstDyadicRadius firstPhysicalHeight + apply Real.rpow_le_rpow_of_exponent_le hZ.le + linarith [hC.1,hj.1] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicRetainedBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicRetainedBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..eff10248378546034b1f1d239eaf96896ea2f5d0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicRetainedBudget.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicRetainedEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_dyadic_retained_budget + (om Φ:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ) + (Z M r ell V eta tau Fmax Γ K theta Benergy:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Fmax) + (_hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap)(_hF0:0≤Fmax)(_hFcap:Fmax≤Lcap) + (_heta:0≤eta)(_heta1:eta≤1)(_htau:0≤tau)(_htau1:tau≤1) + (_hΨ:∀u,‖Ψ u‖≤1)(_hΓ:0≤Γ)(_hK:0firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K); + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 0)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + refinedChildEnergy p hp hg hinj pool Q k.1 k.2.1 (labelGate p k.2.2) true Ψ m mark omega₁ + ((physicalScales (Z^r) k.1 k.2.1) 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + refinedChildEnergy p hp hg hinj pool Q k.1 k.2.1 (labelGate p k.2.2) false Ψ m mark omega₂ + ((physicalScales (Z^r) k.1 k.2.1) 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (Z^(-r-2*ell-V)*Z^M)*‖originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W Φ K Y cutoff (fun _=>1)‖≤ + C*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)* + Z^((2*Fmax+15*eta+tau)*eps+eps) :=by + obtain ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,he⟩:=original_dyadic_retained_energy om Φ a b ha hs + refine ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro eps heps J + obtain ⟨C,hC,henergy⟩:=he eps heps J + obtain ⟨Cc,hCc,hcount⟩:=original_live_joint_small_power b Lcap eps hb hcap heps + refine ⟨C*Cc,mul_nonneg hC hCc.le,?_⟩ + intro ι _ p hp _ hg hinj hcop hc hpr pool Q labels β Ψ m mark Z M r ell V eta tau Fmax Γ K theta Benergy + hZ hbin hM hF hQ hrcap hellcap hF0 hFcap heta heta1 htau htau1 hΨ hΓ hK hB hsf hn hβ + Y cutoff W source keys hleft hright + have hz:0(hs hy).2) + apply he'.trans + calc + _≤C*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)* + Z^((2*Fmax+15*eta+tau)*eps)*(Cc*Z^eps):= + mul_le_mul_of_nonneg_left hnkey (by positivity) + _=_:=by rw [Real.rpow_add hz];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicRetainedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicRetainedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..7144a1fc67f42d31152e0fb15be66d59fb28cc96 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicRetainedEnergy.lean @@ -0,0 +1,122 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicLiveRadius +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_dyadic_retained_energy + (om Φ:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ) + (Z M r ell V eta tau Fmax Γ K theta Benergy:ℝ) + (_hZ:1firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K); + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 0)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + refinedChildEnergy p hp hg hinj pool Q k.1 k.2.1 (labelGate p k.2.2) true Ψ m mark omega₁ + ((physicalScales (Z^r) k.1 k.2.1) 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + refinedChildEnergy p hp hg hinj pool Q k.1 k.2.1 (labelGate p k.2.2) false Ψ m mark omega₂ + ((physicalScales (Z^r) k.1 k.2.1) 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Benergy*(tripleHeight J z.1*coordinateHeight J z.2))→ + (Z^(-r-2*ell-V)*Z^M)*‖originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W Φ K Y cutoff (fun _=>1)‖≤ + C*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)* + Z^((2*Fmax+15*eta+tau)*eps)*(keys.card:ℝ):=by + let g₁:=priorityLogWindow om a b ha hs true + let g₂:=priorityLogWindow om a b ha hs false + let M₀:=|Real.log a|+|Real.log b| + have hm:0≤M₀:=by dsimp [M₀];positivity + obtain ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,he⟩:=original_refined_cell_physical_budget + g₁ g₂ Φ M₀ M₀ hm hm (priorityLogWindow_support om a b ha hs true) (priorityLogWindow_support om a b ha hs false) + refine ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro eps heps J + obtain ⟨Cp,Kp,hCp,hKp,hcell⟩:=he eps heps 0 J + refine ⟨Cp*Kp,mul_nonneg hCp hKp.le,?_⟩ + intro ι _ p hp _ hg hinj hcop hc hpr pool Q labels β Ψ m mark Z M r ell V eta tau Fmax Γ K theta Benergy + hZ hbin hM hF hQ hΨ hΓ hK hB hsf hn hβ Y cutoff W source keys hleft hright + have hz:01) (by intro i;norm_num) + have hnrm:0≤Z^(-r-2*ell-V)*Z^M:=mul_nonneg (Real.rpow_nonneg hz.le _) (Real.rpow_nonneg hz.le _) + apply (mul_le_mul_of_nonneg_left hsum hnrm).trans + rw [Finset.mul_sum] + have hpoint:∀k∈keys, + (Z^(-r-2*ell-V)*Z^M)*‖refinedCellRows p hp hcop hg pool Q labels β cutoff Ψ m mark k.1 k.2.1 (labelGate p k.2.2) + (positiveSource g₁ 1 (-theta)) (positiveSource g₂ 1 theta) Φ K Y (physicalScales (Z^r) k.1 k.2.1)‖≤ + (Cp*Kp)*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)*Z^((2*Fmax+15*eta+tau)*eps):=by + intro k hk + let T₁:=(physicalScales (Z^r) k.1 k.2.1) 7 + let T₂:=(physicalScales (Z^r) k.1 k.2.1) 8 + have hT₁:0first_dyadic_refined_cutoff p pool Q k.1 k.2.2 Z M r ell V eta tau x hx I) + T₁ T₂ K theta (eta*Real.log Z) hT₁ hT₂ hK hL Benergy Z M r ell V (dyadicExponent Z (k.1 3)) + (dyadicExponent Z (k.1 0)) (dyadicExponent Z (k.1 1)) (dyadicExponent Z (k.1 2)) + (dyadicExponent Z (k.1 4)) (dyadicExponent Z k.2.1) (dyadicExponent Z (k.1 5)) eta + hB hz (physicalScales_rpow Z r hZ k.1 k.2.1) rfl hl hr + have hrad:=first_live_cell_radius_cap p hp pool Q labels Y _ Z M r ell V eta tau Fmax hZ hbin hM hF hQ k hk + have hpow:=Real.rpow_le_rpow hY.le hrad heps.le + rw [←Real.rpow_mul hz.le] at hpow + simp only [pow_zero,div_one,norm_neg] at he' + calc + _≤(Γ^2*Kp*(firstCellRadius Z M r ell V eta tau k.1 k.2.2)^eps*Benergy)* + (Cp*((1+‖theta‖)^InverseClippingProfiles.momentOrder J*(1+‖theta‖)^InverseClippingProfiles.momentOrder J)):=he' + _≤(Γ^2*Kp*Z^((2*Fmax+15*eta+tau)*eps)*Benergy)* + (Cp*((1+‖theta‖)^InverseClippingProfiles.momentOrder J*(1+‖theta‖)^InverseClippingProfiles.momentOrder J)):=by + apply mul_le_mul_of_nonneg_right _ (by positivity) + exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hpow (by positivity)) hB + _=_:=by rw [show 2*InverseClippingProfiles.momentOrder J=InverseClippingProfiles.momentOrder J+InverseClippingProfiles.momentOrder J by omega,pow_add];ring + calc + _≤∑_k∈keys,(Cp*Kp)*Γ^2*Benergy*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder J)*Z^((2*Fmax+15*eta+tau)*eps):= + Finset.sum_le_sum hpoint + _=_:=by simp [mul_comm] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..0b0a3f339a6ffac74a3e22b754092fd743a0b6b2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstDyadicTail.lean @@ -0,0 +1,123 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicRadius + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem full_first_dyadic_marked_rapid_tail (Mmax Fmax eta tau saving:ℝ) + (hMm:0≤Mmax) (hFm:0≤Fmax) (heta:0≤eta) (htau:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (bs:Finset (CubeCoordinates ι)) (labels:Finset (Ideal O)) + (a:CubeCoordinates ι→Finset ι→Ideal O→ℂ) (Ψ₁ Ψ₂:O→*ℂ) (m₁ m₂:O) + (slots:Finset σ) (lists:σ→Finset ι) (weights:σ→ι→ℂ) + (extra₁ extra₂:CubeCoordinates ι→Finset ι) + (test₁ test₂:CubeCoordinates ι→Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) + (Z M r ell V Γ G₁ G₂:ℝ), + 1primeMark slots lists weights (extra₁ b∪U)*test₁ b U) + (fun U=>primeMark slots lists weights (extra₂ b∪U)*test₂ b U) W (Z^M) + (firstDyadicPhysicalCutoff p b C I Z M r ell V eta tau)‖≤ + Ctail*Γ*G₁*G₂*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)*Z^(-saving) := by + let saving':=saving+4*Fmax+14*eta + obtain ⟨s,Ct,Cm,hCt,hCm,hloc⟩:=first_whole_cube_rapid_physical_tail 1 (by norm_num) + Mmax Fmax eta tau saving' hMm hFm heta htau + obtain ⟨Ca,hCa,hagg⟩:=full_first_tail_from_local 1 (by norm_num) + refine ⟨s,Ca*65536*Cm^2*Ct,by positivity,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hc pool bs labels a Ψ₁ Ψ₂ m₁ m₂ slots lists weights extra₁ extra₂ + test₁ test₂ W Z M r ell V Γ G₁ G₂ hZ hbin hM hMmax hell hV hr hwhole hΓ hG₁ hG₂ hΨ₁ hΨ₂ + hadm hb₁ hb₂ hI0 hIF ha hslots hw he₁ he₂ ht₁ ht₂ hs₁ hs₂ + have hz:0primeMark slots lists weights (extra₁ b∪U)*test₁ b U) + (fun U=>primeMark slots lists weights (extra₂ b∪U)*test₂ b U) W (Z^M) + (firstDyadicPhysicalCutoff p b C I Z M r ell V eta tau) D‖≤E:=by + have hCB:Disjoint C b.support:=Finset.disjoint_left.mpr (fun i hi hib=> + (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp (Finset.mem_filter.mp hC).1) hi)).2 hib) + have hupper (x:ℝ) (hx:1≤x):x≤Z^(firstDyadicExponent Z x+eta):= + (first_dyadic_bounds Z eta x hZ hbin hx).2.2 + have hlower (x:ℝ) (hx:1≤x):Z^(firstDyadicExponent Z x-eta)≤x:=by + exact (Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith : firstDyadicExponent Z x-eta≤firstDyadicExponent Z x)).trans + (first_dyadic_bounds Z eta x hZ hbin hx).2.1 + have hjpos:0<‖eisEmbedding (jLabel p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2:= + SecondPassIntegration.elementNorm_pos _ (primeProduct_ne_zero p hp _ _) + have he:=hloc p hp hinj hcop hg hc pool b C D (extra₁ b) (extra₂ b) I Ψ₁ Ψ₂ m₁ m₂ + slots lists weights (test₁ b) (test₂ b) W (B^2) G₁ G₂ Z M r ell V + (firstDyadicExponent Z (primeProductNorm p C)) + (firstDyadicExponent Z (‖eisEmbedding (jLabel p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2)) + (fun D=>firstDyadicExponent Z (primeProductNorm p D)) + (hadm b hb) hCB (Finset.mem_powerset.mp hD) (hI0 I hI) (sq_nonneg _) hG₁ hG₂ hZ.le hM hMmax + hell hV hr hwhole (Finset.mem_filter.mp hC).2 (hextra extra₁ he₁ b hb) (hextra extra₂ he₂ b hb) + hΨ₁ hΨ₂ hslots hw (ht₁ b hb) (ht₂ b hb) (hs₁ b hb) (hs₂ b hb) (hb₁ b hb) (hb₂ b hb) (hIF I hI) + (hupper _ (primeProductNorm_ge_one p hp D)) (hlower _ (primeProductNorm_ge_one p hp C)) + (hlower _ (EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq _ (primeProduct_ne_zero p hp _ _))) + simpa only [firstLocalPhysicalTail,firstDyadicPhysicalCutoff,firstDyadicRadius,Real.rpow_one,E,L] using he + have he:=hagg p hp hinj hcop hg hc pool bs labels a Ψ₁ Ψ₂ m₁ m₂ + (fun b U=>primeMark slots lists weights (extra₁ b∪U)*test₁ b U) + (fun b U=>primeMark slots lists weights (extra₂ b∪U)*test₂ b U) W (Z^M) B L (Z^(V+eta)) Γ E + (fun b C I=>firstDyadicPhysicalCutoff p b C I Z M r ell V eta tau) + hB hL (Real.one_le_rpow hZ.le (by linarith)) hΓ hE hΨ₁ hΨ₂ hadm hb₁ hb₂ hI0 hIF ha + (fun b hb U hU=>hs₁ b hb U (mul_ne_zero_iff.mp hU).2) hlocal + apply he.trans + have hexp:B^9*L^4*Z^(V+eta)*Z^(-saving')≤Z^(-saving):=by + dsimp [B,L] + rw [←Real.rpow_mul_natCast hz.le,←Real.rpow_mul_natCast hz.le, + ←Real.rpow_add hz,←Real.rpow_add hz,←Real.rpow_add hz] + apply Real.rpow_le_rpow_of_exponent_le hZ.le + dsimp [saving'] + norm_num + linarith + have hm:=mul_le_mul_of_nonneg_left hexp + (show 0≤Ca*65536*Cm^2*Ct*Γ*G₁*G₂*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) from by positivity) + convert hm using 1 + · dsimp only [E] + norm_num + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..5fc767d75e032328491e3133a67684aa85c9d7d7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstEnergy.lean @@ -0,0 +1,158 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstModeAssembly +import OAI.NumberTheory.DirichletL.Descent.FirstModeChild + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels +open FirstCauchyArithmetic (supportIdealFamily supportIdealFamily_pos supportIdealFamily_good recoveredSupport supportRay) +open RayFourExpansion (RayCharacter) +noncomputable section +local notation "O" => ActualEisensteinCubic.O +local notation "lambda" => ConcretePrimeRowBridge.goodLambda +theorem full_rayIdealRow_continuous {ι : Type*} [DecidableEq ι] (p : ι → O) + [∀ i, (Ideal.span {p i}).IsMaximal] (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (F : Finset ι) (C : (Frequency × (Fin 9 → ℝ)) → Finset ι → ℂ) (hC : ∀ S, Continuous (fun t => C t S)) + (negative : Bool) (χ : RayCharacter) (D : Finset ι) (h : O) : + Continuous (fun t => rayIdealRow p hg F (C t) negative χ D h) := by + simp only [rayIdealRow, ConcretePrimeRowBridge.conjugateIdealRowSum, + ConcretePrimeRowBridge.mobiusIdealColumn] + fun_prop + +theorem full_rayIdealRow_uniform_bound {ι : Type*} [DecidableEq ι] (p : ι → O) + [∀ i, (Ideal.span {p i}).IsMaximal] (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (F : Finset ι) (C : (Frequency × (Fin 9 → ℝ)) → Finset ι → ℂ) (hC : ∀ t S, ‖C t S‖ = ‖C 0 S‖) + (negative : Bool) (χ : RayCharacter) (D : Finset ι) (h : O) : + ∃ M : ℝ, 0 ≤ M ∧ ∀ t, ‖rayIdealRow p hg F (C t) negative χ D h‖ ≤ M := by + let P := fun i => Ideal.span {p i} + let s := supportIdealFamily P (F \ D) + let T := fun (t : Frequency × (Fin 9 → ℝ)) (I : Ideal O) => + ConcretePrimeRowBridge.mobiusIdealColumn + (fun I => (if negative then star (supportRay p χ (recoveredSupport P (F \ D) I)) + else supportRay p χ (recoveredSupport P (F \ D) I)) * + C t (D ∪ recoveredSupport P (F \ D) I)) I * + star (ConcretePrimeRowBridge.idealSexticRow s (supportIdealFamily_pos P (F \ D)) + (supportIdealFamily_good P hg (F \ D)) I h) + refine ⟨∑ I ∈ s, ‖T 0 I‖, Finset.sum_nonneg (fun _ _ => norm_nonneg _), ?_⟩ + intro t + change ‖∑ I ∈ s, T t I‖ ≤ _ + apply (norm_sum_le s (T t)).trans_eq + apply Finset.sum_congr rfl + intro I hI + simp only [T, ConcretePrimeRowBridge.mobiusIdealColumn, norm_mul, hC] + +theorem full_rayIdealEnergy_continuous {ι : Type*} [DecidableEq ι] (p : ι → O) + [∀ i, (Ideal.span {p i}).IsMaximal] (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (F : Finset ι) (C : (Frequency × (Fin 9 → ℝ)) → Finset ι → ℂ) (hC : ∀ S, Continuous (fun t => C t S)) + (negative : Bool) (h : O) : + Continuous (fun t => rayIdealEnergy p hg F (C t) negative h) := by + unfold rayIdealEnergy + apply continuous_finsetSum _ + intro r hr + apply continuous_finsetSum _ + intro D hD + exact continuous_const.mul ((full_rayIdealRow_continuous p hg F C hC negative _ D h).norm.pow 2) + +theorem full_rayIdealEnergy_uniform_bound {ι : Type*} [DecidableEq ι] (p : ι → O) + [∀ i, (Ideal.span {p i}).IsMaximal] (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (F : Finset ι) (C : (Frequency × (Fin 9 → ℝ)) → Finset ι → ℂ) (hC : ∀ t S, ‖C t S‖ = ‖C 0 S‖) + (negative : Bool) (h : O) : + ∃ M : ℝ, 0 ≤ M ∧ ∀ t, rayIdealEnergy p hg F (C t) negative h ≤ M := by + choose M hM hbound using fun (r : RayCharacter × RayCharacter) (D : Finset ι) => + full_rayIdealRow_uniform_bound p hg F C hC negative (if negative then r.1 else r.2) D h + refine ⟨∑ r : RayCharacter × RayCharacter, ∑ D ∈ F.powerset, + ‖rayPairWeight p r D h‖ * (M r D)^2, by positivity, ?_⟩ + intro t + apply Finset.sum_le_sum + intro r hr + apply Finset.sum_le_sum + intro D hD + exact mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (norm_nonneg _) (hbound r D t) 2) + (norm_nonneg _) + +theorem full_integrable_rayIdealEnergy {ι : Type*} [DecidableEq ι] (p : ι → O) + [∀ i, (Ideal.span {p i}).IsMaximal] (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (F : Finset ι) (C : (Frequency × (Fin 9 → ℝ)) → Finset ι → ℂ) (hc : ∀ S, Continuous (fun t => C t S)) + (hn : ∀ t S, ‖C t S‖ = ‖C 0 S‖) (negative : Bool) (h : O) (b : (Frequency × (Fin 9 → ℝ)) → ℂ) (hb : Integrable b) : + Integrable (fun t : Frequency × (Fin 9 → ℝ) => ‖b t‖ * rayIdealEnergy p hg F (C t) negative h) volume := by + obtain ⟨M, hM, hbnd⟩ := full_rayIdealEnergy_uniform_bound p hg F C hn negative h + apply hb.norm.mul_bdd (c := M) + · exact (full_rayIdealEnergy_continuous p hg F C hc negative h).aestronglyMeasurable + · exact Filter.Eventually.of_forall (fun t => by + rw [Real.norm_of_nonneg (rayIdealEnergy_nonneg p hg F (C t) negative h)] + exact hbnd t) + +theorem full_cube_integral_norm_le_energy {ι : Type*} [DecidableEq ι] + (p : ι → O) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, lambda ∉ Ideal.span {p i}) (F : Finset ι) + (C₁ C₂ : (Frequency × (Fin 9 → ℝ)) → Finset ι → ℂ) + (hc₁ : ∀ S, Continuous (fun t => C₁ t S)) + (hc₂ : ∀ S, Continuous (fun t => C₂ t S)) + (hn₁ : ∀ t S, ‖C₁ t S‖ = ‖C₁ 0 S‖) + (hn₂ : ∀ t S, ‖C₂ t S‖ = ‖C₂ 0 S‖) + (h : O) (b : (Frequency × (Fin 9 → ℝ)) → ℂ) + (hb : Integrable b) (hbc : Continuous b) (a : ℂ) : + ‖∫ t : Frequency × (Fin 9 → ℝ), b t * a * idealPairReindex p hg F (C₁ t) (C₂ t) h‖ ≤ + Real.sqrt (∫ t : Frequency × (Fin 9 → ℝ), ‖b t‖ * ‖a‖ * rayIdealEnergy p hg F (C₁ t) true h) * + Real.sqrt (∫ t : Frequency × (Fin 9 → ℝ), ‖b t‖ * ‖a‖ * rayIdealEnergy p hg F (C₂ t) false h) := by + let E₁ := fun t => rayIdealEnergy p hg F (C₁ t) true h + let E₂ := fun t => rayIdealEnergy p hg F (C₂ t) false h + let w := fun t : Frequency × (Fin 9 → ℝ) => ‖b t‖ * ‖a‖ + have hE₁ : ∀ t, 0 ≤ E₁ t := fun t => rayIdealEnergy_nonneg p hg F (C₁ t) true h + have hE₂ : ∀ t, 0 ≤ E₂ t := fun t => rayIdealEnergy_nonneg p hg F (C₂ t) false h + have hw : ∀ t, 0 ≤ w t := fun t => mul_nonneg (norm_nonneg _) (norm_nonneg _) + have i₁ : Integrable (fun t => w t * E₁ t) volume := by + convert (full_integrable_rayIdealEnergy p hg F C₁ hc₁ hn₁ true h b hb).mul_const ‖a‖ using 1 + funext t + dsimp only [w, E₁] + ring + have i₂ : Integrable (fun t => w t * E₂ t) volume := by + convert (full_integrable_rayIdealEnergy p hg F C₂ hc₂ hn₂ false h b hb).mul_const ‖a‖ using 1 + funext t + dsimp only [w, E₂] + ring + let f := fun t => Real.sqrt (w t * E₁ t) + let g := fun t => Real.sqrt (w t * E₂ t) + have hf : Continuous f := + Real.continuous_sqrt.comp (((hbc.norm.mul_const ‖a‖).mul + (full_rayIdealEnergy_continuous p hg F C₁ hc₁ true h))) + have hg' : Continuous g := + Real.continuous_sqrt.comp (((hbc.norm.mul_const ‖a‖).mul + (full_rayIdealEnergy_continuous p hg F C₂ hc₂ false h))) + have hfsq (t : Frequency × (Fin 9 → ℝ)) : f t ^ 2 = w t * E₁ t := Real.sq_sqrt (mul_nonneg (hw t) (hE₁ t)) + have hgsq (t : Frequency × (Fin 9 → ℝ)) : g t ^ 2 = w t * E₂ t := Real.sq_sqrt (mul_nonneg (hw t) (hE₂ t)) + have mf : MemLp f 2 volume := (memLp_two_iff_integrable_sq hf.aestronglyMeasurable).mpr + (by simpa only [hfsq] using i₁) + have mg : MemLp g 2 volume := (memLp_two_iff_integrable_sq hg'.aestronglyMeasurable).mpr + (by simpa only [hgsq] using i₂) + have hfg (t : Frequency × (Fin 9 → ℝ)) : f t * g t = w t * (Real.sqrt (E₁ t) * Real.sqrt (E₂ t)) := by + dsimp only [f, g] + rw [Real.sqrt_mul (hw t), Real.sqrt_mul (hw t)] + calc + _ = (Real.sqrt (w t))^2 * (Real.sqrt (E₁ t) * Real.sqrt (E₂ t)) := by ring + _ = _ := by rw [Real.sq_sqrt (hw t)] + have hnorm : ‖∫ t : Frequency × (Fin 9 → ℝ), b t * a * idealPairReindex p hg F (C₁ t) (C₂ t) h‖ ≤ + ∫ t : Frequency × (Fin 9 → ℝ), f t * g t := by + apply norm_integral_le_of_norm_le (mf.integrable_mul mg) + exact Filter.Eventually.of_forall (fun t => by + simp only [Pi.mul_apply] + rw [hfg, norm_mul, norm_mul] + exact mul_le_mul_of_nonneg_left (idealPairReindex_norm_le p hg F (C₁ t) (C₂ t) h) (hw t)) + have hh := integral_mul_le_Lp_mul_Lq_of_nonneg Real.HolderConjugate.two_two + (Filter.Eventually.of_forall (fun t => Real.sqrt_nonneg (w t * E₁ t))) + (Filter.Eventually.of_forall (fun t => Real.sqrt_nonneg (w t * E₂ t))) + (show MemLp f (ENNReal.ofReal (2 : ℝ)) volume by simpa using mf) + (show MemLp g (ENNReal.ofReal (2 : ℝ)) volume by simpa using mg) + have hfinal : (∫ t : Frequency × (Fin 9 → ℝ), f t * g t) ≤ + Real.sqrt (∫ t : Frequency × (Fin 9 → ℝ), w t * E₁ t) * Real.sqrt (∫ t : Frequency × (Fin 9 → ℝ), w t * E₂ t) := by + simp only [Real.rpow_two, ← Real.sqrt_eq_rpow] at hh + change (∫ t : Frequency × (Fin 9 → ℝ), f t * g t) ≤ + Real.sqrt (∫ t : Frequency × (Fin 9 → ℝ), f t ^ 2) * Real.sqrt (∫ t : Frequency × (Fin 9 → ℝ), g t ^ 2) at hh + simpa only [hfsq, hgsq] using hh + exact hnorm.trans hfinal + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilyEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilyEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..0079999632900df5a571878942336036ed0fc719 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilyEnergy.lean @@ -0,0 +1,119 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstBlockEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι κ : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstFamilySeparatedRow (source : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : κ → ℝ) (d h : κ → Eis) + (s : Fin 9 → ℝ) (z : Frequency × (Fin 9 → ℝ)) : ℂ := + ∑ x∈source,w x*firstBlockedSeparatedRow p hg F (selector x) (C₁ x) (C₂ x) + ω₁ ω₂ (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) s z + +def firstFamilyEnergy (source : Finset κ) (F : Finset ι) + (selector C : κ → Finset ι → ℂ) (w : κ → ℂ) + (negative : Bool) (ω : ℝ → ℂ) (X t : ℝ) (h : κ → Eis) : ℝ := + ∑ x∈source,‖w x‖*firstBlockEnergy p hg F (selector x) (C x) negative ω X t (h x) + +theorem firstFamilyEnergy_nonneg (source : Finset κ) (F : Finset ι) + (selector C : κ → Finset ι → ℂ) (w : κ → ℂ) + (negative : Bool) (ω : ℝ → ℂ) (X t : ℝ) (h : κ → Eis) : + 0 ≤ firstFamilyEnergy p hg source F selector C w negative ω X t h := + Finset.sum_nonneg (fun x _ => mul_nonneg (norm_nonneg _) + (firstBlockEnergy_nonneg p hg F (selector x) (C x) negative ω X t (h x))) + +theorem first_family_cauchy (source : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : κ → ℝ) (d h : κ → Eis) + (s : Fin 9 → ℝ) (z : Frequency × (Fin 9 → ℝ)) : + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + ‖firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + Real.sqrt (firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) (H 7) h)* + Real.sqrt (firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) (H 8) h) := by + dsimp only + let H := profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 + let weight (j : κ × (RayCharacter × RayCharacter) × Finset ι) : ℂ := + w j.1*firstBlockOuterWeight p (selector j.1) j.2.1 j.2.2 (h j.1)* + firstOuterPhase H (firstCommonOuterLog p (A₁ j.1) (A₂ j.1) (C j.1) (R j.1) + (d j.1) (h j.1) j.2.2 s) + have hn (j : κ × (RayCharacter × RayCharacter) × Finset ι) : + ‖weight j‖ = ‖w j.1‖*‖firstBlockOuterWeight p (selector j.1) j.2.1 j.2.2 (h j.1)‖ := by + simp only [weight,norm_mul,firstOuterPhase_norm,mul_one] + have hc := DescentWeightedCauchy.weighted_cauchy + (source ×ˢ ((Finset.univ : Finset (RayCharacter × RayCharacter)) ×ˢ F.powerset)) weight + (fun j => firstCommonColumn p hg F j.2.2 (C₂ j.1) false j.2.1.2 ω₂ (s 8) (H 8) (h j.1)) + (fun j => firstCommonColumn p hg F j.2.2 (C₁ j.1) true j.2.1.1 ω₁ (s 7) (H 7) (h j.1)) + simp only [hn,Finset.sum_product] at hc + have he : (∑ x∈source,∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset, + weight (x,r,D)*firstCommonColumn p hg F D (C₂ x) false r.2 ω₂ (s 8) (H 8) (h x)* + star (firstCommonColumn p hg F D (C₁ x) true r.1 ω₁ (s 7) (H 7) (h x))) = + firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z := by + simp only [firstFamilySeparatedRow,firstBlockedSeparatedRow,Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + dsimp only [weight,firstBlockOuterWeight,H] + ring + rw [he] at hc + have hleft : (∑ x∈source,∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset, + ‖w x‖*‖firstBlockOuterWeight p (selector x) r D (h x)‖* + ‖firstCommonColumn p hg F D (C₁ x) true r.1 ω₁ (s 7) (H 7) (h x)‖^2) = + firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) (H 7) h := by + simp only [firstFamilyEnergy,firstBlockEnergy,Finset.mul_sum,mul_assoc,ite_true] + have hright : (∑ x∈source,∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset, + ‖w x‖*‖firstBlockOuterWeight p (selector x) r D (h x)‖* + ‖firstCommonColumn p hg F D (C₂ x) false r.2 ω₂ (s 8) (H 8) (h x)‖^2) = + firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) (H 8) h := by + simp only [firstFamilyEnergy,firstBlockEnergy,Finset.mul_sum,mul_assoc,Bool.false_eq_true,ite_false] + rw [hleft,hright] at hc + exact hc.trans_eq (mul_comm _ _) + +theorem first_family_integral_of_energy (source : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : κ → ℝ) (d h : κ → Eis) + (s : Fin 9 → ℝ) (density : Frequency × (Fin 9 → ℝ) → ℂ) + (J : ℕ) (B : ℝ) (hB : 0 ≤ B) + (hDensity : Integrable (fun z : Frequency × (Fin 9 → ℝ) => + tripleHeight J z.1*coordinateHeight J z.2*‖density z‖)) + (hleft : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) h ≤ + B*(tripleHeight J z.1*coordinateHeight J z.2)) + (hright : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) h ≤ + B*(tripleHeight J z.1*coordinateHeight J z.2)) : + ‖∫ z : Frequency × (Fin 9 → ℝ),density z * + firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + B*∫ z : Frequency × (Fin 9 → ℝ),tripleHeight J z.1*coordinateHeight J z.2*‖density z‖ := by + have hb (z : Frequency × (Fin 9 → ℝ)) : + ‖firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + B*(tripleHeight J z.1*coordinateHeight J z.2) := by + apply (first_family_cauchy p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z).trans + have hh := mul_le_mul (Real.sqrt_le_sqrt (hleft z)) (Real.sqrt_le_sqrt (hright z)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + exact hh.trans_eq (by rw [←sq,Real.sq_sqrt]; unfold tripleHeight coordinateHeight; positivity) + calc + _ ≤ ∫ z : Frequency × (Fin 9 → ℝ),B*(tripleHeight J z.1*coordinateHeight J z.2*‖density z‖) := by + apply norm_integral_le_of_norm_le (hDensity.const_mul B) + filter_upwards with z + rw [norm_mul] + exact (mul_le_mul_of_nonneg_left (hb z) (norm_nonneg _)).trans_eq (by ring) + _ = _ := integral_const_mul _ _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilySource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilySource.lean new file mode 100644 index 0000000000000000000000000000000000000000..e338285b688d47269377ffabe6da30256270ebb8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilySource.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstFamilyEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι κ : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem integrable_first_block_density (F : Finset ι) (selector C₁ C₂ : Finset ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : ℝ) (d h : Eis) (s : Fin 9 → ℝ) + (density : Frequency × (Fin 9 → ℝ) → ℂ) (hDensity : Integrable density) : + Integrable (fun z : Frequency × (Fin 9 → ℝ) => density z* + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z) := by + let coef (j : FirstCommonIndex ι) := + (selector j.2.1*firstCommonWeight p hg C₁ C₂ h j)* + (ω₁ (primeProductNorm p j.2.2.1/s 7)*ω₂ (primeProductNorm p j.2.2.2/s 8)) + have he : (fun z : Frequency × (Fin 9 → ℝ) => density z* + firstBlockedSeparatedRow p hg F selector C₁ C₂ ω₁ ω₂ A₁ A₂ C R d h s z) = + fun z => ∑ j∈firstCommonIndices F,coef j*(density z* + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s) z.1 z.2) := by + funext z + rw [←first_block_modes_eq_columns] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + dsimp only [coef] + ring + rw [he] + exact integrable_finsetSum _ (fun j hj => (integrable_density_mode density hDensity + firstLeftSlope firstRightSlope firstKernelSlope + (firstRelativeLog (firstCommonNorms p A₁ A₂ C R d h j) s)).const_mul (coef j)) + +theorem first_family_density_sum (source : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : κ → ℝ) (d h : κ → Eis) (s : Fin 9 → ℝ) + (density : Frequency × (Fin 9 → ℝ) → ℂ) (hDensity : Integrable density) : + (∑ x∈source,w x*∫ z : Frequency × (Fin 9 → ℝ),density z* + firstBlockedSeparatedRow p hg F (selector x) (C₁ x) (C₂ x) ω₁ ω₂ + (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) s z) = + ∫ z : Frequency × (Fin 9 → ℝ),density z* + firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z := by + simp only [←integral_const_mul] + rw [←integral_finsetSum source (fun x hx => + (integrable_first_block_density p hg F (selector x) (C₁ x) (C₂ x) ω₁ ω₂ + (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) s density hDensity).const_mul (w x))] + apply integral_congr_ae + filter_upwards with z + simp only [firstFamilySeparatedRow,Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + ring + +def firstFamilyPhysicalRows (source : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R : κ → ℝ) (K : ℝ) + (d h : κ → Eis) (s : Fin 9 → ℝ) : ℂ := + ∑ x∈source,w x*firstBlockedPhysicalRows p hg F (selector x) (C₁ x) (C₂ x) + (fun y => W₁ (y/(s 0*s 2*s 5*s 7))) (fun y => W₂ (y/(s 1*s 2*s 5*s 8))) + Φ (A₁ x) (A₂ x) (C x) (R x) K (d x) (h x) + +theorem actual_first_balanced_family (hp : ∀ i,p i ≠ 0) + (source : Finset κ) (F : Finset ι) (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (V : Fin 9 → ℝ → ℂ) + (A₁ A₂ C R : κ → ℝ) (K L : ℝ) (d h : κ → Eis) (s : Fin 9 → ℝ) + (hpos : ∀ x∈source,0 < A₁ x ∧ 0 < A₂ x ∧ 0 < C x ∧ 0 < R x ∧ d x ≠ 0 ∧ h x ≠ 0) + (hs : ∀ i,0 < s i) (density : Frequency × (Fin 9 → ℝ) → ℂ) (hDensity : Integrable density) + (hsep : ∀ y : Fin 9 → ℝ, + (Real.exp (-(9/2:ℝ)*L):ℂ)*firstPoissonProfile W₁ W₂ Φ V + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) y = + ∫ z : Frequency × (Fin 9 → ℝ),density z* + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y z.1 z.2) + (hω₁ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + W₁ (A₁ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.1/(s 0*s 2*s 5*s 7)) ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) = 1) + (hω₂ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + W₂ (A₂ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.2/(s 1*s 2*s 5*s 8)) ≠ 0 → + ω₂ (primeProductNorm p j.2.2.2/s 8) = 1) + (hcut : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) ≠ 0 → ω₂ (primeProductNorm p j.2.2.2/s 8) ≠ 0 → + ∀ i,V i (firstRelativeLog (firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j) s i) = 1) : + (Real.exp (-(9/2:ℝ)*L):ℂ)*firstFamilyPhysicalRows p hg source F selector C₁ C₂ w + W₁ W₂ Φ A₁ A₂ C R K d h s = + (firstRootScale s:ℂ)⁻¹*∫ z : Frequency × (Fin 9 → ℝ),density z* + firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z := by + have hb (x : κ) (hx : x∈source) := actual_first_balanced_block p hp hg F (selector x) (C₁ x) (C₂ x) + W₁ W₂ ω₁ ω₂ Φ V (A₁ x) (A₂ x) (C x) (R x) K L + (hpos x hx).1 (hpos x hx).2.1 (hpos x hx).2.2.1 (hpos x hx).2.2.2.1 + (d x) (h x) (hpos x hx).2.2.2.2.1 (hpos x hx).2.2.2.2.2 s hs density hDensity hsep + (hω₁ x hx) (hω₂ x hx) (hcut x hx) + rw [←first_family_density_sum p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s density hDensity] + simp only [firstFamilyPhysicalRows,Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + calc + _ = w x*((Real.exp (-(9/2:ℝ)*L):ℂ)*firstBlockedPhysicalRows p hg F (selector x) (C₁ x) (C₂ x) + (fun y => W₁ (y/(s 0*s 2*s 5*s 7))) (fun y => W₂ (y/(s 1*s 2*s 5*s 8))) + Φ (A₁ x) (A₂ x) (C x) (R x) K (d x) (h x)) := by ring + _ = _ := by rw [hb x hx]; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilyToSecond.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilyToSecond.lean new file mode 100644 index 0000000000000000000000000000000000000000..aad69122b8e8a98cde7b3e10952aabe17b07d120 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFamilyToSecond.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstFamilyEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstOldEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstToSecond + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem first_family_original_to_second (ε : ℝ) (hε : 0 < ε) : + ∃ K : ℝ,0 < K ∧ ∀ {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}), + (∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) → + (∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) → + ∀ (F B : Finset ι) (selector : Finset ι → ℂ) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool), + (∀ i∈B,0 < v i) → ∀ (negative : Bool) (Ψ : Eis →* ℂ) (m : Eis), + (∀ a,‖Ψ a‖ ≤ 1) → ∀ (H : Finset ι → ℂ) (ω : ℝ → ℂ) (X t : ℝ),0 < X → + ∀ (c d : Eis) (source : Finset (Ideal Eis × Eis)) (rows : Finset Eis) + (w : Ideal Eis × Eis → ℂ) (M Y : ℝ),0 ≤ M → 0 < Y → + (∀ x∈source,Squarefree x.1) → + (∀ x∈source,DescentWeightedCauchy.firstElementRowMap (dilationLabel p B v ε₁ ε₂) x∈rows) → + (∀ z∈rows,z ≠ 0) → (∀ z∈rows,(Ideal.absNorm (Ideal.span {z}):ℝ) ≤ Y) → + (∀ x∈source,‖w x‖ ≤ M) → + firstFamilyEnergy p hg source F (fun _ => selector) + (fun x => firstOldLabelCoefficient p hp hcop hg B v ε₁ ε₂ negative + (multiplicativeCoreColumn p Ψ m H) c d x.1) w negative ω X t Prod.snd ≤ + M*K*Y^ε * ((32*512)* + ∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)* + ∑ core : FirstCoreIndex,‖firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D core‖ * + (firstFreshSecondPoisson p hp hg hinj F D B v ε₁ ε₂ negative + (if negative then r.1 else r.2) Ψ m H ω X c d core t Y).re) := by + obtain ⟨K,hK,hpush⟩ := first_block_old_label_energy ε hε + refine ⟨K,hK,?_⟩ + intro ι _ p hp _ hinj hcop hg hc hpr F B selector v ε₁ ε₂ hv negative Ψ m hΨ + H ω X t hX c d source rows w M Y hM hY hs hmap hrows hnorm hw + have h := hpush p hp hinj hcop hg F B selector v ε₁ ε₂ hv negative + (multiplicativeCoreColumn p Ψ m H) ω X t hX c d source rows w M Y hM hY.le + hs hmap hrows hnorm hw + apply h.trans + apply mul_le_mul_of_nonneg_left _ (by positivity) + calc + _ ≤ ∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)* + ((32*512)*∑ core : FirstCoreIndex,‖firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D core‖ * + (firstFreshSecondPoisson p hp hg hinj F D B v ε₁ ε₂ negative + (if negative then r.1 else r.2) Ψ m H ω X c d core t Y).re) := by + apply Finset.sum_le_sum + intro r hr + apply Finset.sum_le_sum + intro D hD + exact mul_le_mul_of_nonneg_left + (first_fresh_core_energy_to_second p hp hcop hg hinj hc hpr F D B v ε₁ ε₂ negative + (if negative then r.1 else r.2) Ψ m H ω X c d t rows Y hY hnorm (hΨ _)) (by positivity) + _ = _ := by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + apply Finset.sum_congr rfl + intro core hcore + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstFreshEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFreshEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ab9f3540e62cd400d43a886ef7a3c4798346420 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFreshEnergy.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCommonChild + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem first_fresh_energy_small_power (ε : ℝ) (hε : 0 < ε) : + ∃ K : ℝ,0 < K ∧ ∀ {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (_hv : ∀ j ∈ B,0 < v j) + (negative : Bool) (χ : RayCharacter) (C : Finset ι → ℂ) + (ω : ℝ → ℂ) (X t : ℝ),0 < X → ∀ (c d : Eis) + (source : Finset (Ideal Eis × Eis)) (rows : Finset Eis) (w : Ideal Eis × Eis → ℂ) (M Y : ℝ), + 0 ≤ M → 0 ≤ Y → (∀ x ∈ source,Squarefree x.1) → + (∀ x ∈ source,DescentWeightedCauchy.firstElementRowMap (dilationLabel p B v ε₁ ε₂) x ∈ rows) → + (∀ z ∈ rows,z ≠ 0) → (∀ z ∈ rows,(Ideal.absNorm (Ideal.span {z}):ℝ) ≤ Y) → + (∀ x ∈ source,‖w x‖ ≤ M) → + (∑ x ∈ source,‖w x‖ * ‖firstCommonColumn p hg F D + (firstBareCubeCoefficient p hp hg hcop B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative C c (ConcretePrimeRowBridge.idealGenerator x.1)) d) + negative χ ω X t x.2‖^2) ≤ + M*K*Y^ε * ∑ z ∈ rows,‖dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative χ C + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d (-t) z‖^2 := by + obtain ⟨K,hK,hpush⟩ := SquarefreeDivisorBound.first_element_energy_small_power ε hε + refine ⟨K,hK,?_⟩ + intro ι _ p hp _ hinj hcop hg F D B v ε₁ ε₂ hv negative χ C ω X t hX c d source rows w M Y hM hY hs hmap hrows hnorm hw + apply le_trans _ (hpush source rows (dilationLabel p B v ε₁ ε₂) w + (dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative χ C + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d (-t)) M Y hM hY hs hmap hrows hnorm hw) + apply Finset.sum_le_sum + intro x hx + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + apply pow_le_pow_left₀ (norm_nonneg _) + rw [firstCommonColumn_original_labels p hp hg hcop hinj F D B v ε₁ ε₂ hv + negative χ C ω X t hX c d (ConcretePrimeRowBridge.idealGenerator x.1) x.2] + simp only [norm_mul] + have hr0 : ‖supportRay p χ D‖ ≤ 1 := FiniteRayExpansion.norm_char_le_one χ _ + have hr : ‖if negative then star (supportRay p χ D) else supportRay p χ D‖ ≤ 1 := by + cases negative <;> simpa only [Bool.false_eq_true,ite_false,ite_true,norm_star] + using hr0 + have hb := beforeDilationLabel_norm_le_one (fun i => Ideal.span {p i}) hg p B v ε₁ ε₂ + negative c d (ConcretePrimeRowBridge.idealGenerator x.1) D + calc + _ ≤ ‖beforeDilationLabel (fun i => Ideal.span {p i}) hg p B v ε₁ ε₂ negative c d + (ConcretePrimeRowBridge.idealGenerator x.1) D‖ * + ‖dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative χ C + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d (-t) + (x.2*(ConcretePrimeRowBridge.idealGenerator x.1)^2*dilationLabel p B v ε₁ ε₂)‖ := + mul_le_of_le_one_left (mul_nonneg (norm_nonneg _) (norm_nonneg _)) hr + _ ≤ _ := mul_le_of_le_one_left (norm_nonneg _) hb + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstFreshMeasure.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFreshMeasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..fc15b4b307482549ddfb75d6da2af5e98b49f5fc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFreshMeasure.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstNominal +import OAI.NumberTheory.DirichletL.Descent.ProfileIntegral + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory JointLogSeparation +noncomputable section + +def firstRelativeLog (q s : Fin 9 → ℝ) (i : Fin 9) : ℝ := Real.log (q i/s i) + +theorem first_fresh_kernel_common_measure + (W₁ W₂ : ℝ → ℂ) (lo hi : ℝ) (hlo : 0 < lo) + (hs₁ : Function.support W₁ ⊆ Set.Icc lo hi) (hs₂ : Function.support W₂ ⊆ Set.Icc lo hi) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ,ℂ)) (V : Fin 9 → ℝ → ℂ) (M : Fin 9 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ,ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ s : Fin 9 → ℝ, (∀ i, 0 < s i) → ∀ K : ℝ, 0 < K → ∃ b₃ : 𝓢(ℝ,ℂ), + (∀ (ω₁ ω₂ : ℝ → ℂ) (q : Fin 9 → ℝ), (∀ i, 0 < q i) → + (W₁ (q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7)) ≠ 0 → ω₁ (q 7/s 7) = 1) → + (W₂ (q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8)) ≠ 0 → ω₂ (q 8/s 8) = 1) → + (ω₁ (q 7/s 7) ≠ 0 → ω₂ (q 8/s 8) ≠ 0 → ∀ i, V i (firstRelativeLog q s i) = 1) → + firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K q = + (firstRootScale s:ℂ)⁻¹ * (ω₁ (q 7/s 7)*ω₂ (q 8/s 8)) * + ∫ z : Frequency × (Fin 9 → ℝ), + fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (firstRelativeLog q s) z.1 z.2) ∧ + Integrable (fun z : Frequency × (Fin 9 → ℝ) => tripleHeight J z.1*coordinateHeight J z.2* + ‖fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z‖) ∧ + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^A * + (∫ z : Frequency × (Fin 9 → ℝ), tripleHeight J z.1*coordinateHeight J z.2* + ‖fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z‖) ≤ C := by + obtain ⟨b₁,b₂,C,hC,hs⟩ := first_full_profile_common_measure + W₁ W₂ lo hi hlo hs₁ hs₂ hW₁ hW₂ Φ V M hV hS hM hbox A J + refine ⟨b₁,b₂,C,hC,?_⟩ + intro s hspos K hK + obtain ⟨b₃,he,hI,hB⟩ := hs (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) + (div_pos (mul_pos hK (hspos 6)) + (mul_pos (mul_pos (mul_pos (mul_pos (hspos 3) (hspos 4)) + (sq_pos_of_pos (hspos 5))) (hspos 7)) (hspos 8))) + refine ⟨b₃,?_,hI,hB⟩ + intro ω₁ ω₂ q hq hω₁ hω₂ hcut + by_cases hw₁ : ω₁ (q 7/s 7) = 0 + · have hh : W₁ (q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7)) = 0 := by + by_contra hn + have := hω₁ hn + simp only [hw₁,zero_ne_one] at this + simp only [firstNormProfile,hh,hw₁,mul_zero,zero_mul,zero_div] + by_cases hw₂ : ω₂ (q 8/s 8) = 0 + · have hh : W₂ (q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8)) = 0 := by + by_contra hn + have := hω₂ hn + simp only [hw₂,zero_ne_one] at this + simp only [firstNormProfile,hh,hw₂,mul_zero,zero_mul,zero_div] + have hcut' := hcut hw₁ hw₂ + have hnom := firstNormProfile_nominal W₁ W₂ Φ (fun _ _ => 1) s q hspos hq K + have hfull : firstNormProfile W₁ W₂ Φ (fun _ _ => 1) + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (fun i => q i/s i) = + ∫ z : Frequency × (Fin 9 → ℝ), fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (firstRelativeLog q s) z.1 z.2 := by + rw [full_density_mode_fubini] + rw [show firstNormProfile W₁ W₂ Φ (fun _ _ => 1) + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (fun i => q i/s i) = + firstPoissonProfile W₁ W₂ Φ V (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) (firstRelativeLog q s) from by + unfold firstRelativeLog + rw [firstPoissonProfile_log W₁ W₂ Φ V _ _ (fun i => div_pos (hq i) (hspos i))] + simp only [firstRelativeLog] at hcut' + simp only [firstNormProfile,hcut',Finset.prod_const_one]] + simpa only [pureProfileMode_height] using he (firstRelativeLog q s) + have hm : firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K q = + (ω₁ (q 7/s 7)*ω₂ (q 8/s 8)) * + firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ (fun _ _ => 1) K q := by + by_cases h1 : W₁ (q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7)) = 0 + · simp only [firstNormProfile,h1,mul_zero,zero_mul,zero_div] + by_cases h2 : W₂ (q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8)) = 0 + · simp only [firstNormProfile,h2,mul_zero,zero_mul,zero_div] + simp only [hω₁ h1,hω₂ h2,one_mul] + rw [hm,hnom,hfull] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstFullRapidTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFullRapidTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..81e6775de08cb5ba7d32662f2b50d6b4967aede1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstFullRapidTail.lean @@ -0,0 +1,131 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstRapidPhysicalTail + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +def firstExactPhysicalCutoff {ι:Type*} [DecidableEq ι] (p:ι→O) + (b:CubeCoordinates ι) (C:Finset ι) (I:Ideal O) (Z M r ell V eta tau:ℝ) (D:Finset ι):Finset O := + childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit I) + (Z^(firstPhysicalHeight M r ell V (Real.logb Z (primeProductNorm p D)) + (Real.logb Z (primeProductNorm p C)) + (Real.logb Z (‖eisEmbedding (jLabel p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2))+12*eta+tau)) + +theorem full_first_whole_marked_rapid_tail (Mmax Fmax eta tau saving:ℝ) + (hMm:0≤Mmax) (hFm:0≤Fmax) (heta:0≤eta) (htau:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (bs:Finset (CubeCoordinates ι)) (labels:Finset (Ideal O)) + (a:CubeCoordinates ι→Finset ι→Ideal O→ℂ) (Ψ₁ Ψ₂:O→*ℂ) (m₁ m₂:O) + (slots:Finset σ) (lists:σ→Finset ι) (weights:σ→ι→ℂ) + (extra₁ extra₂:CubeCoordinates ι→Finset ι) + (test₁ test₂:CubeCoordinates ι→Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) + (Z M r ell V Γ G₁ G₂:ℝ), + 1primeMark slots lists weights (extra₁ b∪U)*test₁ b U) + (fun U=>primeMark slots lists weights (extra₂ b∪U)*test₂ b U) W (Z^M) + (firstExactPhysicalCutoff p b C I Z M r ell V eta tau)‖≤ + Ctail*Γ*G₁*G₂*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)*Z^(-saving) := by + let saving':=saving+4*Fmax+14*eta + obtain ⟨s,Ct,Cm,hCt,hCm,hloc⟩:=first_whole_cube_rapid_physical_tail 1 (by norm_num) + Mmax Fmax eta tau saving' hMm hFm heta htau + obtain ⟨Ca,hCa,hagg⟩:=full_first_tail_from_local 1 (by norm_num) + refine ⟨s,Ca*65536*Cm^2*Ct,by positivity,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hc pool bs labels a Ψ₁ Ψ₂ m₁ m₂ slots lists weights extra₁ extra₂ + test₁ test₂ W Z M r ell V Γ G₁ G₂ hZ hM hMmax hell hV hr hwhole hΓ hG₁ hG₂ hΨ₁ hΨ₂ + hadm hb₁ hb₂ hI0 hIF ha hslots hw he₁ he₂ ht₁ ht₂ hs₁ hs₂ + have hz:0primeMark slots lists weights (extra₁ b∪U)*test₁ b U) + (fun U=>primeMark slots lists weights (extra₂ b∪U)*test₂ b U) W (Z^M) + (firstExactPhysicalCutoff p b C I Z M r ell V eta tau) D‖≤E:=by + have hCB:Disjoint C b.support:=Finset.disjoint_left.mpr (fun i hi hib=> + (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp (Finset.mem_filter.mp hC).1) hi)).2 hib) + have hupper (x:ℝ) (hx:0rw [←Real.rpow_logb hz (ne_of_gt hZ) hx] + exact Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith) + have hlower (x:ℝ) (hx:0rw [←Real.rpow_logb hz (ne_of_gt hZ) hx] + exact Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith) + have hjpos:0<‖eisEmbedding (jLabel p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2:= + SecondPassIntegration.elementNorm_pos _ (primeProduct_ne_zero p hp _ _) + have he:=hloc p hp hinj hcop hg hc pool b C D (extra₁ b) (extra₂ b) I Ψ₁ Ψ₂ m₁ m₂ + slots lists weights (test₁ b) (test₂ b) W (B^2) G₁ G₂ Z M r ell V + (Real.logb Z (primeProductNorm p C)) + (Real.logb Z (‖eisEmbedding (jLabel p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2)) + (fun D=>Real.logb Z (primeProductNorm p D)) + (hadm b hb) hCB (Finset.mem_powerset.mp hD) (hI0 I hI) (sq_nonneg _) hG₁ hG₂ hZ.le hM hMmax + hell hV hr hwhole (Finset.mem_filter.mp hC).2 (hextra extra₁ he₁ b hb) (hextra extra₂ he₂ b hb) + hΨ₁ hΨ₂ hslots hw (ht₁ b hb) (ht₂ b hb) (hs₁ b hb) (hs₂ b hb) (hb₁ b hb) (hb₂ b hb) (hIF I hI) + (hupper _ (primeProductNorm_pos p hp D)) (hlower _ (primeProductNorm_pos p hp C)) (hlower _ hjpos) + simpa only [firstLocalPhysicalTail,firstExactPhysicalCutoff,Real.rpow_one,E,L] using he + have he:=hagg p hp hinj hcop hg hc pool bs labels a Ψ₁ Ψ₂ m₁ m₂ + (fun b U=>primeMark slots lists weights (extra₁ b∪U)*test₁ b U) + (fun b U=>primeMark slots lists weights (extra₂ b∪U)*test₂ b U) W (Z^M) B L (Z^(V+eta)) Γ E + (fun b C I=>firstExactPhysicalCutoff p b C I Z M r ell V eta tau) + hB hL (Real.one_le_rpow hZ.le (by linarith)) hΓ hE hΨ₁ hΨ₂ hadm hb₁ hb₂ hI0 hIF ha + (fun b hb U hU=>hs₁ b hb U (mul_ne_zero_iff.mp hU).2) hlocal + apply he.trans + have hexp:B^9*L^4*Z^(V+eta)*Z^(-saving')≤Z^(-saving):=by + dsimp [B,L] + rw [←Real.rpow_mul_natCast hz.le,←Real.rpow_mul_natCast hz.le, + ←Real.rpow_add hz,←Real.rpow_add hz,←Real.rpow_add hz] + apply Real.rpow_le_rpow_of_exponent_le hZ.le + dsimp [saving'] + norm_num + linarith + have hm:=mul_le_mul_of_nonneg_left hexp + (show 0≤Ca*65536*Cm^2*Ct*Γ*G₁*G₂*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) from by positivity) + convert hm using 1 + · dsimp only [E] + norm_num + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalPush.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalPush.lean new file mode 100644 index 0000000000000000000000000000000000000000..c0e8153219938247c9d03cbb77d41bb4e2854d08 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalPush.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstActualSecondEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι κ:Type*} [DecidableEq ι] [DecidableEq κ] + +def firstGlobalRetainedSource (p:ι→Eis) (outer:Finset κ) + (labels:κ→Finset (Ideal Eis)) (cube:κ→CubeCoordinates ι) (Y:ℝ): + Finset (Σ _ : κ,Ideal Eis×Eis):= + outer.sigma (fun k=>firstRetainedSource p (labels k) (cube k) Y) + +omit [DecidableEq κ] in +theorem first_global_retained_push (ε:ℝ)(hε:0<ε): + ∃ K:ℝ,0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F:Finset ι)(outer:Finset κ)(cube:κ→CubeCoordinates ι)(common:κ→Finset ι) + (Ψ₁ Ψ₂:Eis→*ℂ)(m₁ m₂:Eis)(d:κ→Eis) + (labels:κ→Finset (Ideal Eis))(a:κ→Ideal Eis×Eis→ℂ)(Γ Y:ℝ), + (∀u,‖Ψ₁ u‖≤1)→(∀u,‖Ψ₂ u‖≤1)→0≤Γ→0selector x.1) + (fun x=>firstCanonicalCoefficient p hp hcop hg (cube x.1) (common x.1) negative + (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) (d x.1) (H x.1) x.2) + (fun x=>retainedCubeWeight p hp hcop hg (cube x.1) (common x.1) Ψ₁ Ψ₂ m₁ m₂ + (d x.1) (a x.1) x.2) + negative ω X t (fun x=>x.2.2) ≤ + Γ*K*Y^ε*∑k∈outer,firstCanonicalSecondEnergy p hp hg hinj F (cube k) (common k) + negative (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) (d k) + (H k) (selector k) ω X t Y := by + obtain ⟨K,hK,hpush⟩:=first_retained_actual_second_energy ε hε + refine ⟨K,hK,?_⟩ + intro p hp _ hinj hcop hg hc hpr F outer cube common Ψ₁ Ψ₂ m₁ m₂ d labels a Γ Y + hΨ₁ hΨ₂ hΓ hY hs hn ha negative H selector ω X t hX + simp only [firstFamilyEnergy,firstGlobalRetainedSource,Finset.sum_sigma] + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro k hk + exact hpush p hp hinj hcop hg hc hpr F (cube k) (common k) Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ + (d k) (labels k) (a k) Γ Y hΓ hY (hs k hk) (hn k hk) (ha k hk) + negative (H k) (selector k) ω X t hX + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..702a0ccd58145981f8c9e751ab401ebbe4557c49 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceEnergy.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstGlobalSourcePhysical +import OAI.NumberTheory.DirichletL.Descent.ReopenedPhysicalEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +open ConcretePrimeRowBridge (idealGenerator) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def originalRetainedFamily + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) (s : Fin 9→ℝ) : ℂ := + firstFamilyPhysicalRows p hg + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun k=>k.1) Y) pool + (fun _ _=>1) + (fun x=>firstCanonicalCoefficient p hp hcop hg x.1.1 x.1.2.1 true Ψ m + (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (mark x.1.1.rightExponent) x.2) + (fun x=>firstCanonicalCoefficient p hp hcop hg x.1.1 x.1.2.1 false Ψ m + (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (mark x.1.1.leftExponent) x.2) + (fun x=>retainedCubeWeight p hp hcop hg x.1.1 x.1.2.1 Ψ Ψ m m + (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (firstOriginalWeight p β R x.1) x.2) + (fun y=>star (W ((s 0*s 2*s 5*s 7)*y))) (fun y=>W ((s 1*s 2*s 5*s 8)*y)) Φ + (fun x=>‖eisEmbedding (aLabel p x.1.1.support x.1.1.rightBit)‖^2) + (fun x=>‖eisEmbedding (aLabel p x.1.1.support x.1.1.leftBit)‖^2) + (fun x=>primeProductNorm p x.1.2.1) + (fun x=>primeProductNorm p (cubeActiveSupport x.1.1.support + (fun i=>x.1.1.leftExponent i+x.1.1.rightExponent i) x.1.1.leftBit x.1.1.rightBit)) K + (fun x=>primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (fun x=>x.2.2) s + +theorem original_global_physical_energy + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (hQ : ∀v∈Q,v.support⊆pool) + (labels : Finset (Ideal O)) (hlabels : ∀I∈labels,I≠0) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (K Y : ℝ) (hK : 0 + varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) K ≤ + ‖reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + canonicalCubeDualZero p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (fun U=>mark b.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark b.leftExponent U*W (primeProductNorm p U)) rowMajorant K)‖ + + K*‖originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W rowMajorant K Y R s‖ + + ‖reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + canonicalCubeDualTail p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (fun U=>mark b.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark b.leftExponent U*W (primeProductNorm p U)) rowMajorant K + (reopenedPhysicalCutoff p b I (R b C I)))‖ := by + have he := original_reopened_physical_energy p hp hcop hg hinj hc hpr pool Q hQ labels hlabels + β Ψ m (fun _=>mark) W K hK R hR + rw [original_retained_global_family p hp hcop hg pool Q labels hlabels β Ψ m mark W rowMajorant K Y R hRY s hs] at he + simpa only [originalRetainedFamily,norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hK] using he + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceIndex.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..2be3249df6cf3bc4918a3dc231277cc8a4345701 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceIndex.lean @@ -0,0 +1,106 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedPhysicalSplit +import OAI.NumberTheory.DirichletL.Descent.FirstGlobalPush + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + +abbrev FirstOriginalOuter (ι : Type*) := Σ _ : CubeCoordinates ι,Σ _ : Finset ι,Finset ι + +def firstOriginalOuter (pool : Finset ι) (Q : Finset (ι→₀ℕ)) : Finset (FirstOriginalOuter ι) := + (reopenedCubeFamily Q).sigma (fun b=>(pool\b.support).powerset.sigma + (fun C=>(C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset)) + +lemma mem_firstOriginalOuter (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : FirstOriginalOuter ι) : + k∈firstOriginalOuter pool Q ↔ k.1∈reopenedCubeFamily Q ∧ k.2.1∈(pool\k.1.support).powerset ∧ + k.2.2∈(k.2.1∪cubePrincipalSupport k.1.support k.1.leftExponent k.1.rightExponent k.1.leftBit k.1.rightBit).powerset := by + simp [firstOriginalOuter] + +lemma retained_cutoff_enlargement (E : O) (hE : E≠0) (R Y : ℝ) (hRY : R≤Y) (f : O→ℂ) : + (∑h∈(childFrequencyBall E R).erase 0,f h)= + ∑h∈nonzeroChildFrequencyBall E Y,(if h∈childFrequencyBall E R then (1:ℂ) else 0)*f h := by + have hsub : (childFrequencyBall E R).erase 0⊆nonzeroChildFrequencyBall E Y := by + intro h hh + rcases Finset.mem_erase.mp hh with ⟨hn,hm⟩ + exact Finset.mem_erase.mpr ⟨hn,(mem_childFrequencyBall E hE Y h).mpr + (((mem_childFrequencyBall E hE R h).mp hm).trans hRY)⟩ + calc + _=∑h∈(childFrequencyBall E R).erase 0,(if h∈childFrequencyBall E R then (1:ℂ) else 0)*f h := by + apply Finset.sum_congr rfl + intro h hh + simp [(Finset.mem_erase.mp hh).2] + _=_ := Finset.sum_subset hsub (by + intro h hh hn + have hne := (Finset.mem_erase.mp hh).1 + have hout : h∉childFrequencyBall E R := fun hm=>hn (Finset.mem_erase.mpr ⟨hne,hm⟩) + simp [hout]) + +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstOriginalWeight (β : Ideal O→(ι→₀ℕ)→ℂ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (k : FirstOriginalOuter ι) (x : Ideal O×O) : ℂ := + reopenedPairCoefficient β k.1 k.2.1 x.1 * + (UniqueFactorizationMonoid.moebius (∏i∈k.2.2,Ideal.span {p i}):ℂ) * + (if x.2∈reopenedPhysicalCutoff p k.1 x.1 (R k.1 k.2.1 x.1) k.2.2 then 1 else 0) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma firstOriginalWeight_norm_le (β : Ideal O→(ι→₀ℕ)→ℂ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (k : FirstOriginalOuter ι) (x : Ideal O×O) : + ‖firstOriginalWeight p β R k x‖≤‖reopenedPairCoefficient β k.1 k.2.1 x.1‖ := by + unfold firstOriginalWeight + split_ifs + · simp only [mul_one,norm_mul] + exact mul_le_of_le_one_right (norm_nonneg _) + (CubicEisenstein.norm_ideal_moebius_le_one _) + · simp + +theorem original_retained_global_index + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) (hlabels : ∀I∈labels,I≠0) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (hRY : ∀k∈firstOriginalOuter pool Q,∀f∈labels,R k.1 k.2.1 f k.2.2≤Y) : + reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + reopenedPhysicalRetained p hp hcop hg pool b C Ψ m I mark W Φ K (R b C I)) = + ∑x∈firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun k=>k.1) Y, + firstOriginalWeight p β R x.1 x.2 * + canonicalCubeOuter p hp hcop hg x.1.1 x.1.2.1 Ψ Ψ m m (ConcretePrimeRowBridge.idealGenerator x.2.1)* + firstCubePhysicalMode p hp hcop hg pool x.1.1 x.1.2.1 Ψ Ψ m m + (ConcretePrimeRowBridge.idealGenerator x.2.1) (mark x.1.1.rightExponent) (mark x.1.1.leftExponent) + W W Φ K (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) x.2.2 := by + simp only [firstGlobalRetainedSource,firstOriginalOuter,Finset.sum_sigma,sum_firstRetainedSource] + unfold reopenedPhysicalSourceSum reopenedPhysicalRetained + apply Finset.sum_congr rfl + intro b hb + apply Finset.sum_congr rfl + intro C hC + simp only [Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro D hD + apply Finset.sum_congr rfl + intro f hf + have hE := firstPhysicalMultiplier_ne_zero p hp b.support b.leftExponent b.rightExponent + b.leftBit b.rightBit f (hlabels f hf) + have hRY' := hRY ⟨b,⟨C,D⟩⟩ ((mem_firstOriginalOuter pool Q _).mpr ⟨hb,hC,hD⟩) f hf + rw [show reopenedPhysicalCutoff p b f (R b C f) D= + childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) (R b C f D) from rfl] + rw [retained_cutoff_enlargement _ hE _ Y hRY'] + apply Finset.sum_congr rfl + intro h hh + simp only [firstOriginalWeight,reopenedPhysicalCutoff] + ac_rfl + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourcePhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourcePhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..222e1d7b9ea7d275e3c4b72c7d32af76af51c1b6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourcePhysical.lean @@ -0,0 +1,95 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstGlobalSourceSupport +import OAI.NumberTheory.DirichletL.Descent.FirstGlobalSourceIndex + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem firstCubePhysicalMode_fixed_pool (pool : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ d : O) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) (x : Ideal O×O) : + firstCubePhysicalMode p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator x.1) H₁ H₂ W₁ W₂ Φ K d x.2= + (K:ℂ)*cubeBaseFactor p hp hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit d x.2 * + firstPhysicalCommonRows p hg pool + (firstCanonicalCoefficient p hp hcop hg b C true Ψ₁ m₁ d H₁ x) + (firstCanonicalCoefficient p hp hcop hg b C false Ψ₂ m₂ d H₂ x) + (fun y=>star (W₁ y)) W₂ Φ + (‖eisEmbedding (aLabel p b.support b.rightBit)‖^2) + (‖eisEmbedding (aLabel p b.support b.leftBit)‖^2) + (primeProductNorm p C) + (primeProductNorm p (cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)) K d x.2 := by + change _*firstPhysicalCommonRows p hg (pool\(b.support∪C)) + (firstCanonicalCoefficient p hp hcop hg b C true Ψ₁ m₁ d H₁ x) + (firstCanonicalCoefficient p hp hcop hg b C false Ψ₂ m₂ d H₂ x) _ _ _ _ _ _ _ _ _ _ = _ + apply congrArg (fun z : ℂ => + (K : ℂ) * cubeBaseFactor p hp hg b.support + (fun i => b.leftExponent i + b.rightExponent i) b.leftBit b.rightBit d x.2 * z) + apply firstPhysicalCommonRows_fixed_pool p hg _ pool Finset.sdiff_subset + · intro U hU hn + apply firstCanonicalCoefficient_zero_overlap p hp hcop hg + intro hd + apply hn + intro i hi + exact Finset.mem_sdiff.mpr ⟨hU hi,fun he=>Finset.disjoint_left.mp hd hi he⟩ + · intro U hU hn + apply firstCanonicalCoefficient_zero_overlap p hp hcop hg + intro hd + apply hn + intro i hi + exact Finset.mem_sdiff.mpr ⟨hU hi,fun he=>Finset.disjoint_left.mp hd hi he⟩ + +theorem original_retained_global_family + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) (hlabels : ∀I∈labels,I≠0) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (hRY : ∀k∈firstOriginalOuter pool Q,∀f∈labels,R k.1 k.2.1 f k.2.2≤Y) + (s : Fin 9→ℝ) (hs : ∀i,0 + reopenedPhysicalRetained p hp hcop hg pool b C Ψ m I mark W Φ K (R b C I)) = + (K:ℂ)*firstFamilyPhysicalRows p hg + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun k=>k.1) Y) pool + (fun _ _=>1) + (fun x=>firstCanonicalCoefficient p hp hcop hg x.1.1 x.1.2.1 true Ψ m + (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (mark x.1.1.rightExponent) x.2) + (fun x=>firstCanonicalCoefficient p hp hcop hg x.1.1 x.1.2.1 false Ψ m + (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (mark x.1.1.leftExponent) x.2) + (fun x=>retainedCubeWeight p hp hcop hg x.1.1 x.1.2.1 Ψ Ψ m m + (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (firstOriginalWeight p β R x.1) x.2) + (fun y=>star (W ((s 0*s 2*s 5*s 7)*y))) (fun y=>W ((s 1*s 2*s 5*s 8)*y)) Φ + (fun x=>‖eisEmbedding (aLabel p x.1.1.support x.1.1.rightBit)‖^2) + (fun x=>‖eisEmbedding (aLabel p x.1.1.support x.1.1.leftBit)‖^2) + (fun x=>primeProductNorm p x.1.2.1) + (fun x=>primeProductNorm p (cubeActiveSupport x.1.1.support + (fun i=>x.1.1.leftExponent i+x.1.1.rightExponent i) x.1.1.leftBit x.1.1.rightBit)) K + (fun x=>primeSubsetGenerator (fun i=>Ideal.span {p i}) x.1.2.2) (fun x=>x.2.2) s := by + rw [original_retained_global_index p hp hcop hg pool Q labels hlabels β Ψ m mark W Φ K Y R hRY] + have hleft : s 0*s 2*s 5*s 7≠0 := mul_ne_zero (mul_ne_zero (mul_ne_zero (ne_of_gt (hs 0)) (ne_of_gt (hs 2))) (ne_of_gt (hs 5))) (ne_of_gt (hs 7)) + have hright : s 1*s 2*s 5*s 8≠0 := mul_ne_zero (mul_ne_zero (mul_ne_zero (ne_of_gt (hs 1)) (ne_of_gt (hs 2))) (ne_of_gt (hs 5))) (ne_of_gt (hs 8)) + have hw₁ : (fun y=>star (W ((s 0*s 2*s 5*s 7)*(y/(s 0*s 2*s 5*s 7)))))=fun y=>star (W y) := by + funext y + rw [mul_div_cancel₀ _ hleft] + have hw₂ : (fun y=>W ((s 1*s 2*s 5*s 8)*(y/(s 1*s 2*s 5*s 8))))=W := by + funext y + rw [mul_div_cancel₀ _ hright] + simp only [firstFamilyPhysicalRows,Finset.mul_sum,hw₁,hw₂] + apply Finset.sum_congr rfl + intro x hx + rw [first_unblocked_physical,firstCubePhysicalMode_fixed_pool p hp hcop hg] + unfold retainedCubeWeight + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceSupport.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..9ebb1860f62342a440e52d19142a32d60a2f8d47 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstGlobalSourceSupport.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstPhysicalFamily + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +omit [DecidableEq ι] in +lemma first_squarefree_row_zero_mem (U : Finset ι) (i : ι) (hi : i∈U) (n : O) + (hn : n∈Ideal.span {p i}) : finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg U n=0 := by + unfold finiteSquarefreeRow + apply Finset.prod_eq_zero hi + rw [Ideal.Quotient.eq_zero_iff_mem.mpr hn,MulChar.map_zero] + +lemma canonicalCubeResidual_zero_overlap (b : CubeCoordinates ι) (C U : Finset ι) + (negative : Bool) (Ψ : O→*ℂ) (m f : O) (H : Finset ι→ℂ) + (hn : ¬Disjoint U (b.support∪C)) : canonicalCubeResidual p hg b C negative Ψ m f H U=0 := by + obtain ⟨i,hi,hib⟩ := Finset.not_disjoint_iff.mp hn + rcases Finset.mem_union.mp hib with hib|hiC + · have hm : cubeRadical p b.support∈Ideal.span {p i} := + Ideal.mem_span_singleton.mpr (Finset.dvd_prod_of_mem p hib) + have hz : rowCoprimeMask (fun i=>Ideal.span {p i}) U (cubeRadical p b.support)=0 := by + simp only [rowCoprimeMask,ite_eq_left_iff] + intro hh + exact False.elim (hh ⟨i,hi,hm⟩) + simp only [canonicalCubeResidual,originalLabelColumn,hz,mul_zero,zero_mul] + · have hm : aLabel p b.support (if negative then b.rightBit else b.leftBit)*(∏j∈C,p j)∈Ideal.span {p i} := + Ideal.mem_span_singleton.mpr (dvd_mul_of_dvd_right (Finset.dvd_prod_of_mem p hiC) _) + have hz := first_squarefree_row_zero_mem p hg U i hi _ hm + simp only [canonicalCubeResidual,originalLabelColumn,hz,zero_pow (by norm_num : 4≠0),mul_zero,zero_mul] + +lemma firstCanonicalCoefficient_zero_overlap (b : CubeCoordinates ι) (C U : Finset ι) + (negative : Bool) (Ψ : O→*ℂ) (m d : O) (H : Finset ι→ℂ) (x : Ideal O×O) + (hn : ¬Disjoint U (b.support∪C)) : firstCanonicalCoefficient p hp hcop hg b C negative Ψ m d H x U=0 := by + have hz := canonicalCubeResidual_zero_overlap p hg b C U negative Ψ m + (ConcretePrimeRowBridge.idealGenerator x.1) H hn + cases negative <;> + simp only [firstCanonicalCoefficient,firstBareCubeCoefficient,Bool.false_eq_true,ite_false,ite_true, + cubeMinusCoefficient,cubePlusCoefficient,firstPassColumnMinus,firstPassColumnPlus,hz,mul_zero] + +lemma firstCommonIndices_membership (F : Finset ι) (j : FirstCommonIndex ι) : + j∈firstCommonIndices F ↔ j.2.1⊆F ∧ j.2.2.1⊆F\j.2.1 ∧ j.2.2.2⊆F\j.2.1 := by + simp [firstCommonIndices] + +lemma firstCommonIndices_mono {F G : Finset ι} (h : F⊆G) : firstCommonIndices F⊆firstCommonIndices G := by + intro j hj + rcases (firstCommonIndices_membership F j).mp hj with ⟨hd,hu,hv⟩ + exact (firstCommonIndices_membership G j).mpr ⟨hd.trans h, + hu.trans (Finset.sdiff_subset_sdiff h le_rfl),hv.trans (Finset.sdiff_subset_sdiff h le_rfl)⟩ + +lemma firstCommonWeight_zero_outside (F G : Finset ι) (C₁ C₂ : Finset ι→ℂ) (h : O) + (hC₁ : ∀U,U⊆G → ¬U⊆F → C₁ U=0) (hC₂ : ∀U,U⊆G → ¬U⊆F → C₂ U=0) + (j : FirstCommonIndex ι) (hj : j∈firstCommonIndices G) (hjF : j∉firstCommonIndices F) : + firstCommonWeight p hg C₁ C₂ h j=0 := by + rcases (firstCommonIndices_membership G j).mp hj with ⟨hd,hu,hv⟩ + by_cases hleft : j.2.1∪j.2.2.1⊆F + · have hright : ¬j.2.1∪j.2.2.2⊆F := by + intro hr + apply hjF + apply (firstCommonIndices_membership F j).mpr + refine ⟨Finset.Subset.trans Finset.subset_union_left hleft,?_,?_⟩ + · intro i hi + exact Finset.mem_sdiff.mpr ⟨hleft (Finset.mem_union_right _ hi),(Finset.mem_sdiff.mp (hu hi)).2⟩ + · intro i hi + exact Finset.mem_sdiff.mpr ⟨hr (Finset.mem_union_right _ hi),(Finset.mem_sdiff.mp (hv hi)).2⟩ + have hz := hC₂ _ (Finset.union_subset hd (hv.trans Finset.sdiff_subset)) hright + simp only [firstCommonWeight,firstCommonCoefficient,hz,mul_zero,zero_mul] + · have hz := hC₁ _ (Finset.union_subset hd (hu.trans Finset.sdiff_subset)) hleft + simp only [firstCommonWeight,firstCommonCoefficient,hz,mul_zero,zero_mul,star_zero] + +theorem firstPhysicalCommonRows_fixed_pool (F G : Finset ι) (hFG : F⊆G) + (C₁ C₂ : Finset ι→ℂ) (hC₁ : ∀U,U⊆G → ¬U⊆F → C₁ U=0) + (hC₂ : ∀U,U⊆G → ¬U⊆F → C₂ U=0) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R K : ℝ) (d h : O) : + firstPhysicalCommonRows p hg F C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h= + firstPhysicalCommonRows p hg G C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h := by + rw [firstPhysicalCommonRows_indexed,firstPhysicalCommonRows_indexed] + exact Finset.sum_subset (firstCommonIndices_mono hFG) (fun j hj hn=>by + rw [firstCommonWeight_zero_outside p hg F G C₁ C₂ h hC₁ hC₂ j hj hn,zero_mul]) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstHeightBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstHeightBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..d5f582629b224e4bee58509f45c39ade7dc129f5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstHeightBudget.lean @@ -0,0 +1,45 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstUnequalRetainedEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open JointLogSeparation InverseAmbientProfileTower + +theorem first_left_height_budget (J:ℕ)(p:Ambient (Fin 9)): + (1+‖profileHeight firstLeftSlope firstRightSlope firstKernelSlope p.1 p.2 7‖)^J≤ + tripleHeight J p.1*coordinateHeight J p.2:=by + have h:=pow_le_pow_left₀ (by positivity : 0≤1+‖inheritedLeft 7 p‖) (inheritedLeft_bound 7 p) J + rw [←ambientWeight_eq_pow] at h + simpa only [first_inherited_left_eq,ambientWeight,tripleHeight,coordinateHeight] using h + +theorem first_right_height_budget (J:ℕ)(p:Ambient (Fin 9)): + (1+‖profileHeight firstLeftSlope firstRightSlope firstKernelSlope p.1 p.2 8‖)^J≤ + tripleHeight J p.1*coordinateHeight J p.2:=by + have h:=pow_le_pow_left₀ (by positivity : 0≤1+‖inheritedRight 8 p‖) (inheritedRight_bound 8 p) J + rw [←ambientWeight_eq_pow] at h + simpa only [first_inherited_right_eq,norm_neg,ambientWeight,tripleHeight,coordinateHeight] using h + +theorem first_unequal_prefactor (Z:ℝ)(hZ:0Z^(![A₁,A₂,B,delta,R,t,h,r-A₁-B-t,r-A₂-B-t] i)))* + Real.exp ((9/2:ℝ)*(eta*Real.log Z))* + (Real.sqrt ((Z^(firstKappa M r ell V delta A₁ B R)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))⁻¹)* + Real.sqrt ((Z^(firstKappa M r ell V delta A₂ B R)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))⁻¹))=1:=by + rw [first_physical_scalar Z hZ] + have he:Real.exp ((9/2:ℝ)*(eta*Real.log Z))=Z^((9/2:ℝ)*eta):=by + rw [Real.rpow_def_of_pos hZ];congr 1;ring + rw [he,←Real.rpow_add hZ,←Real.rpow_add hZ,←Real.rpow_add hZ] + rw [←Real.rpow_neg hZ.le,←Real.rpow_neg hZ.le,Real.sqrt_eq_rpow,Real.sqrt_eq_rpow, + ←Real.rpow_mul hZ.le,←Real.rpow_mul hZ.le,←Real.rpow_add hZ,←Real.rpow_add hZ] + convert Real.rpow_zero Z using 1 + congr 1 + ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStep.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStep.lean new file mode 100644 index 0000000000000000000000000000000000000000..e26b3516e81f11122b2204806ba5b0f6ab09d3f8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStep.lean @@ -0,0 +1,167 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStepPhysicalGates +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFixedChildStepUniform + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstLabelCell +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstPriorityParents InverseFirstGlobalParents +open InverseMomentGlobalRetainedGates InverseInitialArithmetic InverseSecondSourceBlocks +open InverseSecondFibers InverseInitialClippedColumns RayFourExpansion FirstCauchyArithmetic +open InverseWholePriorityRetainedSource +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +def ChildBounds {ι σ : Type} [DecidableEq ι] [DecidableEq σ] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) (negative : Bool) + (Ψ : O→*ℂ) (m : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (ω₁ ω₂ : 𝓢(ℝ,ℂ)) (Z M r ell V eta tau window b epschild A : ℝ) (K degree : ℕ) : Prop := + ∀(ray : RayCharacter×RayCharacter)(core : FirstCoreIndex)(assigned : Finset σ),assigned⊆slots→ + let S := source p pool Q k l j negative assigned lists Z M r ell V eta tau window b + let Ψ₀ := firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + (∀z : SecondRayIndex,∀d∈keys p S,∀s : ℝ,∀J₁∈(slots\assigned).powerset,∀γ∈actualSecondTriples p 1 1 (cell p S d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((actualCellLabels p S d).filter Squarefree) + (nonzeroChildFrequencyBall 1 (actualCellRowRadius Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d)) + (secondLabelWeight K) (childLogTest ω₁ s) + (Z^(max 0 (secondCellColumnExponent Z (columnScale Z r k l negative) d))) Z + (actualCellTotalExponent Z (columnScale Z r k l negative) (exponent Z (k 2)) (exponent Z j) eta d)≤ + A*Z^(actualCellTotalExponent Z (columnScale Z r k l negative) (exponent Z (k 2)) (exponent Z j) eta d+epschild)* + (1+‖s‖)^(2*degree)) ∧ + (∀z : SecondRayIndex,∀d∈keys p S,∀s : ℝ,∀J₂∈(slots\assigned).powerset,∀γ∈actualSecondTriples p 1 1 (cell p S d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((actualCellLabels p S d).filter Squarefree) + (nonzeroChildFrequencyBall 1 (actualCellRowRadius Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d)) + (secondLabelWeight K) (childLogTest ω₂ s) + (Z^(max 0 (secondCellColumnExponent Z (columnScale Z r k l negative) d))) Z + (actualCellTotalExponent Z (columnScale Z r k l negative) (exponent Z (k 2)) (exponent Z j) eta d)≤ + A*Z^(actualCellTotalExponent Z (columnScale Z r k l negative) (exponent Z (k 2)) (exponent Z j) eta d+epschild)* + (1+‖s‖)^(2*degree)) + +theorem actual_label_cell_step (om : 𝓢(ℝ,ℂ)) (lo hi : ℝ) (hlo : 0Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool : Finset ι)(Q : Finset (ι→₀ℕ))(k : SourceIndex)(l j : ℕ) + (Ψ : O→*ℂ)(m : O)(slots : Finset σ)(lists : σ→Finset ι)(a : σ→ι→ℂ) + (Z M r ell V eta pi b Lcol LY epschild A t : ℝ)(ρ : Fin 6→ℝ), + 2≤Z→0≤eta→2≤Z^eta→0≤ell+eta→ + (∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta))→ + (slots:Set σ).PairwiseDisjoint lists→slots.card≤K→(∀i∈slots,∀q∈lists i,‖a i q‖≤1)→ + (∀u,‖Ψ u‖≤1)→(∀i,|ρ i|≤B₀ i)→hi≤b→b≤bcap→1≤b→b≤Z^(6*eta)→ + Real.exp window≤Z^(4*eta)→0≤A→ + columnScale Z r k l negative*Real.exp window≤Z^Lcol→ + (firstCellRadius Z M r ell V eta tau k j)⁻¹≤Z^LY→ + b*columnScale Z r k l negative≤Z^Lgate→exponent Z (k 3)+eta+2*Lcol+tau+LY≤Lgate→ + epsmass*(ell+exponent Z (k 4)/2+exponent Z l+Lgate+11*eta/2)≤pi→ + epsmass*(r-columnA Z k negative-exponent Z (k 2)-exponent Z l)+7*eta/2+ + dsmall*(3*ell+exponent Z (k 2)+exponent Z l+5*eta)+ + 2*epsmass*(2*ell+exponent Z (k 2)+exponent Z l+4*eta)≤pi+eta/2→ + 1≤firstCellRadius Z M r ell V eta tau k j→1≤columnScale Z r k l negative*Real.exp window→ + firstCellRadius Z M r ell V eta tau k j≤Z^Ltail→ + (firstCellRadius Z M r ell V eta tau k j)⁻¹≤Z^Ltail→ + columnScale Z r k l negative*Real.exp window≤Z^Ltail→ + firstKappa M r ell V (exponent Z (k 3)) (columnA Z k negative) (exponent Z (k 2)) (exponent Z (k 4))+ + (9/2:ℝ)*eta≤Ltail→ + ell+eta≤Ltail→exponent Z (k 4)+eta≤Ltail→exponent Z (k 2)+eta≤Ltail→exponent Z l+eta≤Ltail→ + ChildBounds p hp hcop hg pool Q k l j negative Ψ m slots lists a ω₁ ω₂ + Z M r ell V eta tau window b epschild A K degree→ + (Z^(firstKappa M r ell V (exponent Z (k 3)) (columnA Z k negative) (exponent Z (k 2)) (exponent Z (k 4)))* + Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (extra negative) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k l j) (parentWeight p l) + negative Ψ m slots lists a om (columnScale Z r k l negative) t (firstCellRadius Z M r ell V eta tau k j)≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder (2*degree))*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+epschild)+Ctail*Z^(-saving) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hw₁,hw₂,hs₁,hs₂,hstep⟩ := global_priority_fixed_child_step_uniform_types + om lo hi hlo hsupport negative window Ltail tau saving hhi hLtail htau bcap hbcap + 0 dsmall hdsmall (fun _=>Lgate) (fun _=>hLgate) B₀ hB₀ K epsmass hepsmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro degree + obtain ⟨C,Cbin,Czero,Ctail,hC,hCbin,hCzero,hCtail,he⟩ := hstep degree + refine ⟨C,Cbin,Czero,Ctail,hC,hCbin,hCzero,hCtail,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc pool Q k l j Ψ m slots lists a + Z M r ell V eta pi b Lcol LY epschild A t ρ hZ2 heta hbin hell hQ hdisj hslots ha hΨ hρ hhib hbb hb1 hb6 + hwindow hA hcol hYi hgeom hphysical hbudget hcost hY1 hX1 hYcap hYicap hXcap hPcap hellcap hactivecap hcommoncap hquotcap hchild + have hZ : 11) k l j) + (label_parent_valid p pool Q k l j) (fun y hy=>extra_subset negative y.cube) + (parentWeight p l) (fun y hy=>parentWeight_norm p l y) Ψ m slots lists a + (secondCutoff p Z M r ell V eta tau window k l j negative) + (firstCellRadius Z M r ell V eta tau k j) + (fun _ d=>actualCellRowRadius Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta d) + (eta*Real.log Z) Z (columnScale Z r k l negative) epschild + (actualCellLabelExponent Z (exponent Z (k 2)) (exponent Z j) eta) + ell (exponent Z (k 4)) (exponent Z j) (exponent Z l) eta M r V + (exponent Z (k 3)) (columnA Z k negative) (exponent Z (k 2)) pi b ρ t + (fun assigned d=>actualCellLabels p (source p pool Q k l j negative assigned lists Z M r ell V eta tau window b) d) A + hhib hbb hdisj hslots hA + · intro ray core assigned hassigned + obtain ⟨_,_,hrows,_,hn,hlabels,_,hcaps,hgeometry,hmass⟩ := source_step_arithmetic p hp pool Q k l j + negative assigned lists Z M r ell V eta tau window b Lcol LY Lgate epsmass pi + hZ heta hbin hepsmass.le hwindow hQ hcol hYi hgeom hphysical hbudget + have hJ : assigned.card≤K := (Finset.card_le_card hassigned).trans hslots + have hrest : (slots\assigned).card≤K := (Finset.card_le_card Finset.sdiff_subset).trans hslots + have hbchild := hchild ray core assigned hassigned + refine ⟨(fun i hi q hq=>ha i (hassigned hi) q hq),hρ,mul_nonneg heta (Real.log_nonneg hZ.le),hZ,hX,hY,heta,hbin, + hrows,(fun x hx=>(hn x hx).1),(fun x hx=>(hn x hx).2.1),(fun x hx=>(hn x hx).2.2.1), + (fun x hx=>(hn x hx).2.2.2.2.2.1),(fun x hx=>(hn x hx).2.2.2.2.1),hΨ, + (fun i hi q hq=>ha i (Finset.mem_sdiff.mp hi).1 q hq), + (fun i hi q hq=>ha i (Finset.mem_sdiff.mp hi).1 q hq), + (fun d hd x hx=>hlabels d x hx),by omega,hrest,hrest,hA,rfl,rfl,rfl,(fun _=>rfl),hZ2,hb1,hb6, + hcaps,hgeometry,hmass,hbchild.1,hbchild.2⟩ + · exact Nat.zero_le _ + · exact hell + · exact dyadic_exponent_nonneg Z hZ _ + · exact dyadic_exponent_nonneg Z hZ _ + · exact hcost + · exact fun y hy=>(hparent y hy).1 + · exact fun y hy=>(hparent y hy).2.1 + · exact fun y hy=>(hparent y hy).2.2.1 + · exact fun y hy=>(hparent y hy).2.2.2.1 + · exact fun y hy=>(hparent y hy).2.2.2.2.1 + · exact hY1 + · exact hX1 + · exact hYcap + · exact hYicap + · exact hXcap + · exact hPcap + · exact fun y hy=>(htail y hy).1 + · exact fun y hy=>(htail y hy).2.1 + · exact fun y hy=>(htail y hy).2.2.1 + · exact fun y hy=>(htail y hy).2.2.2.1 + · exact fun y hy=>(htail y hy).2.2.2.2 + · exact fun G E=>secondCutoff_nonneg p Z M r ell V eta tau window k l j negative hz G E + · exact fun y hy G hG E=>secondCutoff_dominates p hp pool Q k l j negative Z M r ell V eta tau window hZ hbin y hy G E.val + +end SevenEighths.InverseMomentFirstLabelCell +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepChildren.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepChildren.lean new file mode 100644 index 0000000000000000000000000000000000000000..f1fcb5a437f7483d09c995991e0ada4a14164ce9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepChildren.lean @@ -0,0 +1,99 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStepSource + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstLabelCell +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstPriorityParents InverseFirstGlobalParents +open InverseMomentGlobalRetainedGates InverseInitialArithmetic InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem source_labels (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) + (hZ : 1(hb y hy).2.2.2.1) (fun y hy=>(hb y hy).2.2.2.2.2.2.1) + +include hp in +theorem source_child_margins + (hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) + (m : O) (hm : m≠0) (Qwidth z c : ℝ) + (hZ : 1extra_subset negative y.cube) negative J lists pool _ b m hm + Z r ell V M Qwidth z c (columnA Z k negative) (exponent Z (k 2)) (exponent Z l) (exponent Z j) eta + hZ hparent (dyadic_exponent_nonneg Z hZ _) (dyadic_exponent_nonneg Z hZ _) hV + (dyadic_exponent_nonneg Z hZ _) heta hbin hpuncture + (fun y hy=>(hb y hy).1) (fun y hy=>(hb y hy).2.1) (fun y hy=>(hb y hy).2.2.2.2.1) + +include hp in +theorem source_row_decrease (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b short : ℝ) + (hZ : 1extra_subset negative y.cube) negative J lists pool _ b (columnScale Z r k l negative) + Z M ell (columnA Z k negative) (exponent Z l) V (exponent Z j) eta short hZ + (dyadic_exponent_nonneg Z hZ _) (dyadic_exponent_nonneg Z hZ _) heta hbin hterminal hsmall + (fun y hy=>(hb y hy).1) (fun y hy=>(hb y hy).2.1) (fun y hy=>(hb y hy).2.2.2.2.2.1) + +include hp in +theorem source_mass_gate (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b Lcol LY Lcap eps pi : ℝ) + (hZ : 1 ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem source_step_arithmetic (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b Lcol LY Lcap eps pi : ℝ) + (hZ : 1x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) + ≤Z^(exponent Z (k 4)+eta) ∧ + primeProductNorm p x.firstCommon≤Z^(exponent Z (k 2)+eta) ∧ + (Ideal.absNorm x.quotient:ℝ)≤Z^(exponent Z l+eta) ∧ + Z^(exponent Z j-eta)≤ + ‖eisEmbedding (jLabel p x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2 ∧ + ‖eisEmbedding (jLabel p x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2≤Z^(exponent Z j+eta) ∧ + primeProductNorm p x.firstDivisor≤Z^(exponent Z (k 3)+eta)) ∧ + (∀d,∀x∈cell p S d,(actualSecondChild p 1 1 x).2.1∈actualCellLabels p S d) ∧ + (∀d,∀I∈(actualCellLabels p S d).filter Squarefree, + Squarefree I ∧ I≠0 ∧ (Ideal.absNorm I:ℝ)≤Z^(actualCellLabelExponent Z (exponent Z (k 2)) (exponent Z j) eta d)) ∧ + (∀x∈S,∀i,outerNorms p x i≤Z^Lcap) ∧ + (∀x∈S,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*columnScale Z r k l negative) ∧ + (∀d∈keys p S,eps*(secondCount ell (exponent Z (k 4)) (exponent Z j) (exponent Z l) + (secondCellExponent Z d 0) (secondCellExponent Z d 1)+11*eta/2)≤pi) := by + intro S + have hr := source_row_gates p hp pool Q k l j negative J lists Z M r ell V eta tau window b hZ heta hbin hwindow + have hl := source_labels p hp pool Q k l j negative J lists Z M r ell V eta tau window b hZ heta hbin hQ + exact ⟨source_valid p hp pool Q k l j negative J lists Z M r ell V eta tau window b, + source_frequency_ne_zero p pool Q k l j negative J lists Z M r ell V eta tau window b, + hr.1,hr.2, + retained_label_numeric p hp pool Q k l j Z ell eta hZ heta hbin hQ negative J lists _ b _, + hl.1,hl.2, + source_outer_caps p hp pool Q k l j negative J lists Z M r ell V eta tau window b Lcol LY Lcap + hZ hcol hYi hgeom hphysical, + source_geometry p pool Q k l j negative J lists Z M r ell V eta tau window b, + source_mass_gate p hp pool Q k l j negative J lists Z M r ell V eta tau window b Lcol LY Lcap eps pi + hZ heps hcol hYi hgeom hphysical hbudget⟩ + +end SevenEighths.InverseMomentFirstLabelCell +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepGates.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..4ae5bd00c4261d998aae6f9c8d97bc930535110c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepGates.lean @@ -0,0 +1,100 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicCell +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesBudget +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesRank + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstLabelCell +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstPriorityParents InverseFirstGlobalParents +open InverseMomentGlobalRetainedGates InverseInitialArithmetic InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +def extra (negative : Bool) (c : CubeCoordinates ι) : Finset ι := + if negative then c.rightExponent.support else c.leftExponent.support + +lemma extra_subset (negative : Bool) (c : CubeCoordinates ι) : extra negative c⊆c.support := by + cases negative + · exact Finset.subset_union_left + · exact Finset.subset_union_right + +lemma dyadic_exponent_nonneg (Z : ℝ) (hZ : 11) k l j,SourceValid p y := by + intro y hy + obtain ⟨o,ho,D,hD,hs,rfl⟩ := (InverseFirstGlobalCaps.mem_parentCell p pool Q (fun _ _=>1) k l y).mp + (Finset.mem_filter.mp hy).1 + exact original_fill_valid p pool Q o (Finset.mem_filter.mp ho).1 D + +include hp in +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem label_parent_bounds (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (k : SourceIndex) (l j : ℕ) (Z ell eta : ℝ) (hZ : 11) k l j, + ‖eisEmbedding (primeProduct p y.cube.support y.cube.leftExponent)‖^2≤Z^(ell+eta) ∧ + ‖eisEmbedding (primeProduct p y.cube.support y.cube.rightExponent)‖^2≤Z^(ell+eta) ∧ + primeProductNorm p (cubeActiveSupport y.cube.support + (fun i=>y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit) + ≤Z^(InverseFirstGlobalCaps.dyadicExponent Z (k 4)+eta) ∧ + primeProductNorm p y.firstCommon≤Z^(InverseFirstGlobalCaps.dyadicExponent Z (k 2)+eta) ∧ + primeProductNorm p y.quotientSupport≤Z^(InverseFirstGlobalCaps.dyadicExponent Z l+eta) ∧ + Z^(InverseFirstGlobalCaps.dyadicExponent Z j-eta)≤InverseFirstGlobalCaps.jNorm p (toOriginal y) ∧ + InverseFirstGlobalCaps.jNorm p (toOriginal y)≤Z^(InverseFirstGlobalCaps.dyadicExponent Z j+eta) ∧ + primeProductNorm p y.firstDivisor≤Z^(InverseFirstGlobalCaps.dyadicExponent Z (k 3)+eta) := by + intro y hy + have hparent := (Finset.mem_filter.mp hy).1 + have hc := InverseFirstGlobalCaps.parentCell_cube_bounds p pool Q (fun _ _=>1) k l Z ell eta hQ y hparent + have hn := InverseFirstGlobalCaps.parentCell_norm_bounds p hp pool Q (fun _ _=>1) k l Z eta hZ hbin y hparent + have hi := InverseFirstGlobalCaps.parentCell_ideal_bounds p hp pool Q (fun _ _=>1) k l Z eta hZ hbin y hparent + have hj := InverseFirstGlobalCaps.labelParentCell_bounds p hp pool Q (fun _ _=>1) k l j Z eta hZ hbin y hy + refine ⟨hc.1,hc.2,?_,hi.1.2,?_,?_,hj.2.2,?_⟩ + · simpa only [InverseFirstGlobalCaps.sourceIdeal_norm] using hi.2.2.2 + · simpa only [hn.2.1] using hn.2.2.2 + · exact (Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith)).trans hj.2.1 + · simpa only [InverseFirstGlobalCaps.sourceIdeal_norm] using hi.2.1.2 + +include hp in + +theorem retained_label_numeric (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (k : SourceIndex) (l j : ℕ) (Z ell eta : ℝ) (hZ : 11) k l j) negative J lists pool cutoff b X + ∀x∈source, + ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta) ∧ + ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta) ∧ + primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) + ≤Z^(InverseFirstGlobalCaps.dyadicExponent Z (k 4)+eta) ∧ + primeProductNorm p x.firstCommon≤Z^(InverseFirstGlobalCaps.dyadicExponent Z (k 2)+eta) ∧ + (Ideal.absNorm x.quotient:ℝ)≤Z^(InverseFirstGlobalCaps.dyadicExponent Z l+eta) ∧ + Z^(InverseFirstGlobalCaps.dyadicExponent Z j-eta)≤ + ‖eisEmbedding (jLabel p x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2 ∧ + ‖eisEmbedding (jLabel p x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2≤Z^(InverseFirstGlobalCaps.dyadicExponent Z j+eta) ∧ + primeProductNorm p x.firstDivisor≤Z^(InverseFirstGlobalCaps.dyadicExponent Z (k 3)+eta) := by + intro source x hx + have h := label_parent_bounds p hp pool Q k l j Z ell eta hZ heta hbin hQ + exact original_numeric_gates p (extra negative) _ negative J lists pool cutoff _ _ _ _ _ _ _ + (fun y hy=>(h y hy).1) (fun y hy=>(h y hy).2.1) (fun y hy=>(h y hy).2.2.1) + (fun y hy=>(h y hy).2.2.2.1) (fun y hy=>(h y hy).2.2.2.2.1) + (fun y hy=>⟨(h y hy).2.2.2.2.2.1,(h y hy).2.2.2.2.2.2.1⟩) + (fun y hy=>(h y hy).2.2.2.2.2.2.2) x (supported_subset p _ _ negative J lists pool cutoff b X hx) + +end SevenEighths.InverseMomentFirstLabelCell +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepPhysicalGates.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepPhysicalGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..daceca47e96d091d7172d4525821dd2180fa1cfc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepPhysicalGates.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStepData + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstLabelCell +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstPriorityParents InverseFirstGlobalParents +open InverseMomentGlobalRetainedGates InverseInitialArithmetic InverseSecondSourceBlocks +open InverseSecondUniformCutoff InversePrioritySecondSource +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) + +def parentWeight (l : ℕ) (x : Source ι 0) : ℂ := + (‖commonSelector p (fun _=>1) l x.quotientSupport‖:ℂ) + +lemma parentWeight_norm (l : ℕ) (x : Source ι 0) : ‖parentWeight p l x‖≤1 := by + simp only [parentWeight,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _)] + simpa using InverseFirstGlobalCaps.commonSelector_norm p (fun _=>1) l x.quotientSupport + +lemma secondCutoff_nonneg (Z M r ell V eta tau window : ℝ) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (hZ : 01) k l j,∀G E : Finset ι, + correlatedSecondRadius p (secondParentDivisor p (parent p y)) G E + (columnScale Z r k l negative*Real.exp window) (firstCellRadius Z M r ell V eta tau k j) (Z^tau)≤ + secondCutoff p Z M r ell V eta tau window k l j negative G E := by + intro y hy G E + have hd := (InverseFirstGlobalCaps.parentCell_ideal_bounds p hp pool Q (fun _ _=>1) k l + Z eta hZ hbin y (Finset.mem_filter.mp hy).1).2.1.2 + apply correlated_le_uniform p Z (exponent Z (k 3)) eta _ G E _ _ _ + (by unfold firstCellRadius;exact Real.rpow_pos_of_pos (zero_lt_one.trans hZ) _) + (Real.rpow_nonneg (zero_lt_one.trans hZ).le _) + simpa [secondParentDivisor,parent,InverseFirstGlobalCaps.sourceIdeal_norm, + primeSubsetGenerator_norm_eq_productNorm] using hd + +include hp in +theorem parent_tail_caps (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (Z ell eta Lcap : ℝ) (hZ : 11) k l j, + ‖eisEmbedding (primeProduct p y.cube.support y.cube.leftExponent)‖^2≤Z^Lcap ∧ + ‖eisEmbedding (primeProduct p y.cube.support y.cube.rightExponent)‖^2≤Z^Lcap ∧ + ‖eisEmbedding (∏i∈cubeActiveSupport y.cube.support + (fun i=>y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit,p i)‖≤Z^Lcap ∧ + primeProductNorm p y.firstCommon≤Z^Lcap ∧ primeProductNorm p y.quotientSupport≤Z^Lcap := by + intro y hy + have hb := label_parent_bounds p hp pool Q k l j Z ell eta hZ heta hbin hQ y hy + have hpw {a : ℝ} (ha : a≤Lcap) : Z^a≤Z^Lcap := Real.rpow_le_rpow_of_exponent_le hZ.le ha + refine ⟨hb.1.trans (hpw hell),hb.2.1.trans (hpw hell),?_, + hb.2.2.2.1.trans (hpw hcommon),hb.2.2.2.2.1.trans (hpw hquot)⟩ + have he := hb.2.2.1.trans (hpw hactive) + have hone := Real.one_le_rpow hZ.le hcap + change ‖eisEmbedding (∏i∈_,p i)‖^2≤Z^Lcap at he + have hn := norm_nonneg (eisEmbedding (∏i∈cubeActiveSupport y.cube.support + (fun i=>y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit,p i)) + nlinarith + +end SevenEighths.InverseMomentFirstLabelCell +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..47b64fea697ae30f61c0ca948f4ef0bb67db0d55 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLabelCellStepSource.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStepGates + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstLabelCell +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstPriorityParents InverseFirstGlobalParents +open InverseMomentGlobalRetainedGates InverseInitialArithmetic InverseSecondSourceBlocks +open InverseSecondUniformCutoff +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + +abbrev exponent := InverseFirstGlobalCaps.dyadicExponent + +def columnA (Z : ℝ) (k : SourceIndex) (negative : Bool) : ℝ := + exponent Z (k (if negative then 0 else 1)) + +def columnScale (Z r : ℝ) (k : SourceIndex) (l : ℕ) (negative : Bool) : ℝ := + Z^(r-columnA Z k negative-exponent Z (k 2)-exponent Z l) + +def secondCutoff (p : ι→O) (Z M r ell V eta tau window : ℝ) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (G E : Finset ι) : ℝ := + uniformSecondRadius p Z (exponent Z (k 3)) eta G E + (columnScale Z r k l negative*Real.exp window) (firstCellRadius Z M r ell V eta tau k j) (Z^tau) + +def source (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) := + supportedRetainedSource p (extra negative) + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k l j) + negative J lists pool (secondCutoff p Z M r ell V eta tau window k l j negative) + b (columnScale Z r k l negative) + +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem source_valid (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) : + ActualSecondSourceConditions p (source p pool Q k l j negative J lists Z M r ell V eta tau window b) := + supported_conditions p hp _ _ (label_parent_valid p pool Q k l j) (fun y _hy=>extra_subset negative y.cube) + negative J lists pool _ b _ + +lemma source_frequency_ne_zero (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) : + ∀x∈source p pool Q k l j negative J lists Z M r ell V eta tau window b,x.second.frequency≠0 := + supported_frequency_ne_zero p _ _ negative J lists pool _ b _ + +lemma source_geometry (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) : + ∀x∈source p pool Q k l j negative J lists Z M r ell V eta tau window b, + primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*columnScale Z r k l negative := + geometrySource_gate p _ b _ + +include hp in +theorem source_row_gates (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (Z M r ell V eta tau window b : ℝ) + (hZ : 1ActualEisensteinCubic.O + +theorem actual_live_label_step + (old:ℝ → ℂ)(oldb:ℝ)(hsold:∀y,old y≠0 → y≤oldb) + (om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)(hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι)(Q:Finset (ι →₀ ℕ))(labels:Finset (Ideal O))(β:Ideal O → (ι →₀ ℕ) → ℂ) + (Ψ:O →* ℂ)(m:O)(slots:Finset σ)(lists:σ → Finset ι)(weights:σ → ι → ℂ) + (Φ:𝓢(ℝ,ℂ))(Z M r ell V eta pi epschild A theta t Kphysical:ℝ), + 2≤Z → 2≤Z^eta → 0≤M → M≤F → (-eta≤r) → r≤F → 0≤ell → ell≤F → 0≤V → V≤F → + 0≤eta → eta≤1 → tau≤1 → Real.exp window≤Z^eta → 0≤pi → 6*eta≤pi → + em*(20*(3*F+16)+30)≤pi/4 → ed*(20*(3*F+16)+30)≤pi/4 → + (∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) → + (∀I∈labels,I≠0) → (∀u,‖Ψ u‖≤1) → (slots:Set σ).PairwiseDisjoint lists → slots.card≤K → + (∀i∈slots,∀q∈lists i,‖weights i q‖≤1) → 0≤A → + let cutoff:=fun (q:CubeCoordinates ι)(C:Finset ι)(_I:Ideal O)(D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource old theta (y/Z^r); + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let S:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) (Z^(2*F+15*eta+tau)); + ∀k∈liveJointKeys p S pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ Kphysical), + ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 negative Ψ m slots lists weights ω₁ ω₂ + Z M r ell V eta tau window b epschild A K degree → + (Z^(firstKappa M r ell V (exponent Z (k.1 3)) (columnA Z k.1 negative) (exponent Z (k.1 2)) (exponent Z (k.1 4)))* + Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (extra negative) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) (parentWeight p k.2.1) + negative Ψ m slots lists weights om (columnScale Z r k.1 k.2.1 negative) t (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤ + Cz*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder (2*degree))*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+epschild)+Ct*Z^(-saving):=by + let cap:=3*F+16 + have hcap:0≤cap:=by dsimp [cap];linarith + have hbig:0≤16*cap+20:=by positivity + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hw₁,hw₂,hs₁,hs₂,he⟩:=actual_label_cell_step om lo hi hlo hs negative + window (16*cap+20) (16*cap+20) tau saving (hhib.trans hwindow) hbig hbig htau b hb ed hed (fun _=>0) (by intro i;norm_num) K em hem + refine ⟨ω₁,ω₂,af,bf,haf,hab,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro degree + obtain ⟨C,Cbin,Cz,Ct,hC,hCb,hCz,hCt,hstep⟩:=he degree + refine ⟨C,Cbin,Cz,Ct,hC,hCb,hCz,hCt,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc pool Q labels β Ψ m slots lists weights Φ + Z M r ell V eta pi epschild A theta t Kphysical hZ hbin hM hMF hr hrF hell hellF hV hVF heta heta1 htau1 + hwin hpi hetapi hsmall hsmall' hQ hn hΨ hslots hcard hw hA cutoff W mark S k hk hchild + have hZ1:10) + hZ heta hbin (by linarith) hQ hslots hcard hw hΨ (by intro i;simp) hhib le_rfl hb + · exact (hwindow.trans hwin).trans (Real.rpow_le_rpow_of_exponent_le hZ1.le (by linarith)) + · exact hwin.trans (Real.rpow_le_rpow_of_exponent_le hZ1.le (by linarith)) + · exact hA + · exact hcol + · exact hYi + · exact hgeom + · exact hphysical + · exact hbudget + · exact hcost + · exact hY1 + · exact hX1 + · exact hYcap + · exact hYi.trans (Real.rpow_le_rpow_of_exponent_le hZ1.le (by linarith)) + · exact hcol.trans (Real.rpow_le_rpow_of_exponent_le hZ1.le (by linarith)) + · exact hPcap + · exact hellcap + · exact hactivecap + · exact hcommoncap + · exact hquotcap + · exact hchild + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveCaps.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveCaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..c9066747688d0be27817572c1756a57870d1ffa8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveCaps.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileAssembly +import OAI.NumberTheory.DirichletL.Descent.CubeSupportNorm + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMomentFirstLiveCaps +open InverseMoment InverseMomentFirstOriginalProfile ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +lemma factor_four_bound (a b c d L:ℝ)(ha:1≤a)(hb:1≤b)(hc:1≤c)(hd:1≤d) + (h:a*b*c*d≤L): a≤L ∧ b≤L ∧ c≤L ∧ d≤L:=by + have ha0:0≤a:=zero_le_one.trans ha + have hb0:0≤b:=zero_le_one.trans hb + have hc0:0≤c:=zero_le_one.trans hc + have hd0:0≤d:=zero_le_one.trans hd + have hab:1≤a*b:=ha.trans (le_mul_of_one_le_right ha0 hb) + have habc:1≤a*b*c:=hab.trans (le_mul_of_one_le_right (mul_nonneg ha0 hb0) hc) + have habd:1≤a*b*d:=hab.trans (le_mul_of_one_le_right (mul_nonneg ha0 hb0) hd) + have ha':a≤a*b*c*d:=by + calc + a≤a*b:=le_mul_of_one_le_right ha0 hb + _≤a*b*c:=le_mul_of_one_le_right (mul_nonneg ha0 hb0) hc + _≤a*b*c*d:=le_mul_of_one_le_right (mul_nonneg (mul_nonneg ha0 hb0) hc0) hd + have hb':b≤a*b*c*d:=by + calc + b≤a*b:=le_mul_of_one_le_left hb0 ha + _≤a*b*c:=le_mul_of_one_le_right (mul_nonneg ha0 hb0) hc + _≤a*b*c*d:=le_mul_of_one_le_right (mul_nonneg (mul_nonneg ha0 hb0) hc0) hd + have hc':c≤a*b*c*d:=by + calc + c≤a*b*c:=le_mul_of_one_le_left hc0 hab + _≤a*b*c*d:=le_mul_of_one_le_right (mul_nonneg (mul_nonneg ha0 hb0) hc0) hd + exact ⟨ha'.trans h,hb'.trans h,hc'.trans h,(le_mul_of_one_le_left hd0 habc).trans h⟩ + +theorem first_profile_live_factors (W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ))(K L:ℝ)(q:Fin 9→ℝ) + (hq:∀i,1≤q i)(hW:∀x,W x≠0→x≤L) + (hn:firstNormProfile (fun y=>star (W y)) W Φ (fun _ _=>1) K q≠0): + q 0≤L ∧ q 1≤L ∧ q 2≤L ∧ q 5≤L:=by + have h₁:W (q 0*q 2*q 5*q 7)≠0:=by + intro h + apply hn + simp [firstNormProfile,h] + have h₂:W (q 1*q 2*q 5*q 8)≠0:=by + intro h + apply hn + simp [firstNormProfile,h] + have hb₁:=factor_four_bound (q 0) (q 2) (q 5) (q 7) L (hq _) (hq _) (hq _) (hq _) (hW _ h₁) + have hb₂:=factor_four_bound (q 1) (q 2) (q 5) (q 8) L (hq _) (hq _) (hq _) (hq _) (hW _ h₂) + exact ⟨hb₁.1,hb₂.1,hb₁.2.1,hb₁.2.2.1⟩ + +variable {ι:Type*}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem original_live_profile_caps + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))(Y:ℝ) + (β:Ideal O→(ι→₀ℕ)→ℂ)(cutoff:CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ)(W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ))(K L:ℝ) + (hW:∀y,W y≠0→y≤L)(x:OriginalIndex ι) + (hx:x∈firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun o=>o.1) Y) + (j:FirstCommonIndex ι) + (hn:sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K x j≠0): + leftNorm p x≤L ∧ rightNorm p x≤L ∧ commonNorm p x≤L ∧ primeProductNorm p j.2.1≤L:=by + have hq:∀i,1≤firstCommonNorms p (leftNorm p x) (rightNorm p x) (commonNorm p x) (activeNorm p x) + (divisorElement p x.1) x.2.2 j i:=by + have hs:=original_source_norms_ge_one p hp pool Q labels Y x hx + intro i + fin_cases i + · exact hs 0 + · exact hs 1 + · exact hs 2 + · exact hs 3 + · exact hs 4 + · exact primeProductNorm_ge_one p hp _ + · exact hs 5 + · exact primeProductNorm_ge_one p hp _ + · exact primeProductNorm_ge_one p hp _ + have hprof:firstNormProfile (fun y=>star (W y)) W Φ (fun _ _=>1) K + (firstCommonNorms p (leftNorm p x) (rightNorm p x) (commonNorm p x) (activeNorm p x) + (divisorElement p x.1) x.2.2 j)≠0:=by + intro hz + exact hn (by unfold sourceSummand;rw [hz,mul_zero]) + exact first_profile_live_factors W Φ K L _ hq hW hprof + +end SevenEighths.InverseMomentFirstLiveCaps + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveColumnScale.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveColumnScale.lean new file mode 100644 index 0000000000000000000000000000000000000000..bf29cdf50328baa4244bea0fc6afbaffa7e75a05 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveColumnScale.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicLiveRadius +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileScales +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCaps + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem first_profile_live_products (W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ))(K L:ℝ)(q:Fin 9→ℝ) + (hq:∀i,1≤q i)(hW:∀x,W x≠0→x≤L) + (hn:firstNormProfile (fun y=>star (W y)) W Φ (fun _ _=>1) K q≠0): + q 0*q 2*q 5≤L ∧ q 1*q 2*q 5≤L:=by + have h₁:W (q 0*q 2*q 5*q 7)≠0:=by intro h;apply hn;simp [firstNormProfile,h] + have h₂:W (q 1*q 2*q 5*q 8)≠0:=by intro h;apply hn;simp [firstNormProfile,h] + constructor + · exact (le_mul_of_one_le_right (mul_nonneg (mul_nonneg (zero_le_one.trans (hq 0)) (zero_le_one.trans (hq 2))) (zero_le_one.trans (hq 5))) (hq 7)).trans (hW _ h₁) + · exact (le_mul_of_one_le_right (mul_nonneg (mul_nonneg (zero_le_one.trans (hq 1)) (zero_le_one.trans (hq 2))) (zero_le_one.trans (hq 5))) (hq 8)).trans (hW _ h₂) + +private theorem dyadic_column_scale {a c z X b : ℝ} + (ha : 1 ≤ a) (hc : 1 ≤ c) (hz : 1 ≤ z) (hprod : a * c * z ≤ b * X) : + 1 ≤ X / (dyadScale (dyadIndex a) * dyadScale (dyadIndex c) * + dyadScale (dyadIndex z)) * b := by + have hscale : dyadScale (dyadIndex a) * dyadScale (dyadIndex c) * + dyadScale (dyadIndex z) ≤ a * c * z := + mul_le_mul + (mul_le_mul (dyadIndex_bounds a ha).1 (dyadIndex_bounds c hc).1 + (dyadScale_pos _).le (zero_le_one.trans ha)) + (dyadIndex_bounds z hz).1 (dyadScale_pos _).le + (mul_nonneg (zero_le_one.trans ha) (zero_le_one.trans hc)) + rw [div_mul_eq_mul_div, + le_div_iff₀ (mul_pos (mul_pos (dyadScale_pos _) (dyadScale_pos _)) (dyadScale_pos _)), + one_mul, mul_comm X b] + exact hscale.trans hprod + +theorem original_live_column_scale {ι:Type}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))(Y:ℝ) + (β:Ideal O→(ι→₀ℕ)→ℂ)(cutoff:CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ)(W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ))(K X b:ℝ) + (_hX:0labels) (fun x=>x.1) Y) pool + (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K)): + 1≤physicalScales X k.1 k.2.1 7*b ∧ 1≤physicalScales X k.1 k.2.1 8*b:=by + obtain ⟨⟨x,j⟩,hm,rfl⟩:=Finset.mem_image.mp hk + obtain ⟨hm,hnon⟩:=Finset.mem_filter.mp hm + obtain ⟨hx,hj⟩:=Finset.mem_product.mp hm + have hs:=original_source_norms_ge_one p hp pool Q labels Y x hx + have hq:∀i,1≤firstCommonNorms p (leftNorm p x) (rightNorm p x) (commonNorm p x) (activeNorm p x) + (divisorElement p x.1) x.2.2 j i:=by + intro i + fin_cases i + · exact hs 0 + · exact hs 1 + · exact hs 2 + · exact hs 3 + · exact hs 4 + · exact primeProductNorm_ge_one p hp _ + · exact hs 5 + · exact primeProductNorm_ge_one p hp _ + · exact primeProductNorm_ge_one p hp _ + have hprof:firstNormProfile (fun y=>star (W y)) W Φ (fun _ _=>1) K + (firstCommonNorms p (leftNorm p x) (rightNorm p x) (commonNorm p x) (activeNorm p x) + (divisorElement p x.1) x.2.2 j)≠0:=by + intro hzero + exact hnon (by unfold sourceSummand;rw [hzero,mul_zero]) + have hb:=first_profile_live_products W Φ K (b*X) _ hq hW hprof + constructor + · change 1 ≤ X / (dyadScale (dyadIndex (leftNorm p x)) * + dyadScale (dyadIndex (commonNorm p x)) * + dyadScale (dyadIndex (primeProductNorm p j.2.1))) * b + exact dyadic_column_scale (hs 0) (hs 2) (primeProductNorm_ge_one p hp _) hb.1 + · change 1 ≤ X / (dyadScale (dyadIndex (rightNorm p x)) * + dyadScale (dyadIndex (commonNorm p x)) * + dyadScale (dyadIndex (primeProductNorm p j.2.1))) * b + exact dyadic_column_scale (hs 1) (hs 2) (primeProductNorm_ge_one p hp _) hb.2 + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveCountBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveCountBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..0c4be13b7356dd870e300634d11108d70e2c152a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveCountBudget.lean @@ -0,0 +1,153 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveSupport + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +lemma liveNormCap_power_bound (b Lcap Z r ell F eta tau : ℝ) + (_hb : 0 ≤ b) (hcap : 0 ≤ Lcap) (hZ : 2 ≤ Z) + (hr : r ≤ Lcap) (hell : ell ≤ Lcap) (hF : 0 ≤ F) (hFcap : F ≤ Lcap) + (heta : 0 ≤ eta) (heta1 : eta ≤ 1) (htau : 0 ≤ tau) (htau1 : tau ≤ 1) : + 1 ≤ liveNormCap (b*Z^r) (Z^(ell+eta)) (Z^(2*F+15*eta+tau)) ∧ + liveNormCap (b*Z^r) (Z^(ell+eta)) (Z^(2*F+15*eta+tau)) ≤ + max 1 b * Z^(3*Lcap+16) := by + have hz : 0Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι)(Q : Finset (ι→₀ℕ))(labels : Finset (Ideal O)) + (β : Ideal O → (ι→₀ℕ) → ℂ)(cutoff : CubeCoordinates ι → Finset ι → Ideal O → Finset ι → ℝ) + (Ψ : O→*ℂ)(m : O)(mark : (ι→₀ℕ) → Finset ι → ℂ)(W : ℝ → ℂ)(Φ : 𝓢(ℝ,ℂ)) + (K Z r ell F eta tau theta : ℝ), + 2 ≤ Z → r ≤ Lcap → ell ≤ Lcap → 0 ≤ F → F ≤ Lcap → 0 ≤ eta → eta ≤ 1 → 0 ≤ tau → tau ≤ 1 → + (∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2 ≤ Z^(ell+eta)) → + (∀I∈labels,I≠0) → (∀y,W y≠0 → y ≤ b) → + ((liveJointKeys p + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) + (Z^(2*F+15*eta+tau))) pool + (sourceSummand p hp hcop hg β cutoff Ψ m mark + (fun y=>CompletedHeight.normTwistedSource W theta (y/Z^r)) Φ K)).card:ℝ) ≤ C*Z^ε := by + obtain ⟨C,hC,hcount⟩ := live_joint_scalar_small_power b Lcap ε hb hcap hε + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ hcop hg pool Q labels β cutoff Ψ m mark W Φ K Z r ell F eta tau theta + hZ hr hell hF hFcap heta heta1 htau htau1 hQ hlabels hW + have hz : 0labels) (fun x=>x.1) + (Z^(2*F+15*eta+tau))) pool + (sourceSummand p hp hcop hg β cutoff Ψ m mark + (fun y=>CompletedHeight.normTwistedSource W theta (y/Z^r)) Φ K)).card:ℝ) ≤ + (((dyadIndex (liveNormCap (b*Z^r) (Z^(ell+eta)) (Z^(2*F+15*eta+tau))))+1:ℕ):ℝ)^8 := by exact_mod_cast he + exact he'.trans (hcount Z r ell F eta tau hZ hr hell hF hFcap heta heta1 htau htau1) + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveExponentCaps.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveExponentCaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..6d17cd664ba17ff8fa9bc1e0b9f2a585325977ad --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveExponentCaps.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicLiveRadius +import OAI.NumberTheory.DirichletL.Descent.FirstLiveNorms + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +lemma actual_dyadic_exponent_cap (Z eta x A:ℝ)(hZ:1Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(cutoff:CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ)(om:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ)) + (K Z r ell F eta tau theta b:ℝ)(hZ:1normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + ∀k∈liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K), + (∀i,0≤dyadicExponent Z (k.1 i) ∧ dyadicExponent Z (k.1 i)≤3*F+15*eta+tau) ∧ + (0≤dyadicExponent Z k.2.1 ∧ dyadicExponent Z k.2.1≤3*F+15*eta+tau) ∧ + (0≤dyadicExponent Z k.2.2 ∧ dyadicExponent Z k.2.2≤3*F+15*eta+tau):=by + intro Y W source k hk + have hz:0 first | exact hA | exact hAB | exact hB | exact hY + · exact actual_dyadic_exponent_cap Z eta _ _ hZ hbin (primeProductNorm_ge_one p hp _) (h₂.trans hA) + · exact actual_dyadic_exponent_cap Z eta _ _ hZ hbin + (EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq _ (primeProduct_ne_zero p hp _ _)) (h₃.trans hB) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveHeightStep.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveHeightStep.lean new file mode 100644 index 0000000000000000000000000000000000000000..ecb6ac847c462208f8e0bcdbb96c30994de7c1d2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveHeightStep.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLiveActualStep +import OAI.NumberTheory.DirichletL.Descent.FirstSecondHeightCost + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseAmbientProfileTower JointLogSeparation FourierBridge +open InverseMomentFirstOriginalProfile InverseMomentFirstLabelCell CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem actual_live_first_height + (old:ℝ → ℂ)(oldb:ℝ)(hsold:∀y,old y≠0 → y≤oldb) + (om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1)(hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι)(Q:Finset (ι →₀ ℕ))(labels:Finset (Ideal O))(β:Ideal O → (ι →₀ ℕ) → ℂ) + (Ψ:O →* ℂ)(m:O)(slots:Finset σ)(lists:σ → Finset ι)(weights:σ → ι → ℂ) + (Φ:𝓢(ℝ,ℂ))(Z M r ell V eta pi epschild A theta Kphysical loss:ℝ), + 2≤Z → 2≤Z^eta → 0≤M → M≤F → (-eta≤r) → r≤F → 0≤ell → ell≤F → 0≤V → V≤F → + 0≤eta → eta≤1 → tau≤1 → Real.exp window≤Z^eta → 0≤pi → 6*eta≤pi → + em*(20*(3*F+16)+30)≤pi/4 → ed*(20*(3*F+16)+30)≤pi/4 → + (∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) → + (∀I∈labels,I≠0) → (∀u,‖Ψ u‖≤1) → (slots:Set σ).PairwiseDisjoint lists → slots.card≤K → + (∀i∈slots,∀q∈lists i,‖weights i q‖≤1) → 0≤A → 0≤epschild → -saving≤r+3*ell+V+48*eta+tau+pi+epschild+eps → + 48*eta+tau+pi+epschild+eps≤loss → + let cutoff:=fun (q:CubeCoordinates ι)(C:Finset ι)(_I:Ideal O)(D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource old theta (y/Z^r); + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let S:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) (Z^(2*F+15*eta+tau)); + ∀k∈liveJointKeys p S pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ Kphysical), + ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 negative Ψ m slots lists weights ω₁ ω₂ + Z M r ell V eta tau window b epschild A K degree → ∀z:Frequency×(Fin 9 → ℝ), + (Z^(firstKappa M r ell V (exponent Z (k.1 3)) (columnA Z k.1 negative) (exponent Z (k.1 2)) (exponent Z (k.1 4)))* + Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (extra negative) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) (parentWeight p k.2.1) + negative Ψ m slots lists weights om (columnScale Z r k.1 k.2.1 negative) (InverseMomentFirstSecondHeightCost.firstHeight negative z) (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤ + (C*(1+A)*Z^(r+3*ell+V+loss))* + (tripleHeight (InverseMomentFirstSecondHeightCost.firstDegree degree) z.1* + coordinateHeight (InverseMomentFirstSecondHeightCost.firstDegree degree) z.2) :=by + obtain ⟨w₁,w₂,af,bf,haf,hab,hw₁,hw₂,hs₁,hs₂,he⟩:=actual_live_label_step + old oldb hsold om lo hi hlo hs negative F tau saving window b em ed hF htau hb hhib hwindow hold hem hed K + refine ⟨w₁,w₂,af,bf,haf,hab,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro degree eps heps + obtain ⟨C,Cbin,Cz,Ct,hC,hCb,hCz,hCt,hstep⟩:=he degree + obtain ⟨Ctotal,hCtotal,hbudget⟩:=InverseMomentFirstSecondHeightCost.first_source_requested_loss degree C Cbin Cz Ct eps hC hCz hCt heps + refine ⟨Ctotal,hCtotal,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc pool Q labels β Ψ m slots lists weights Φ + Z M r ell V eta pi epschild A theta Kphysical loss hZ hbin hM hMF hr hrF hell hellF hV hVF heta heta1 htau1 + hwin hpi hetapi hsmall hsmall' hQ hn hΨ hslots hcard hw hA hechild hsave hloss cutoff W mark S k hk hchild z + have he':=hstep p hp hcop hg hpr hinj hc pool Q labels β Ψ m slots lists weights Φ + Z M r ell V eta pi epschild A theta (InverseMomentFirstSecondHeightCost.firstHeight negative z) Kphysical + hZ hbin hM hMF hr hrF hell hellF hV hVF heta heta1 htau1 hwin hpi hetapi hsmall hsmall' + hQ hn hΨ hslots hcard hw hA k hk hchild + exact he'.trans (hbudget A Z (r+3*ell+V) eta tau pi epschild saving loss hA hZ heta hechild hsave hloss negative z) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveNorms.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveNorms.lean new file mode 100644 index 0000000000000000000000000000000000000000..80d15162686853fce38d45af30da06de73e2ef29 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveNorms.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCaps +import OAI.NumberTheory.DirichletL.Inversion.FirstGlobalCaps + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMomentFirstLiveCaps +open InverseMoment InverseMomentFirstOriginalProfile ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O +variable {ι:Type*}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem original_live_norm_caps + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))(Y:ℝ) + (β:Ideal O→(ι→₀ℕ)→ℂ)(cutoff:CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ)(W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ))(K L B:ℝ) + (hB:0≤B)(hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤B) + (hlabels:∀I∈labels,I≠0)(hW:∀y,W y≠0→y≤L)(x:OriginalIndex ι) + (hx:x∈firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun o=>o.1) Y) + (j:FirstCommonIndex ι) + (hn:sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K x j≠0): + (∀i:Fin 6,originalNorms p x i≤(![L,L,L,L*B^2,B^2,Y]:Fin 6→ℝ) i) ∧ + primeProductNorm p j.2.1≤L ∧ InverseFirstGlobalCaps.jNorm p x.1≤B^2:=by + obtain ⟨ha₁,ha₂,hcommon,hquot⟩:=original_live_profile_caps p hp hcop hg pool Q labels Y β cutoff Ψ m mark W Φ K L hW x hx j hn + obtain ⟨ho,hfreq⟩:=Finset.mem_sigma.mp hx + obtain ⟨hb,hC,hD⟩:=(mem_firstOriginalOuter pool Q x.1).mp ho + obtain ⟨hf,hrow⟩:=(mem_firstRetainedSource p labels x.1.1 Y x.2).mp hfreq + have hcube:=reopenedCubeFamily_cube_norms p Q B hQ x.1.1 hb + have hsup:=cube_whole_support_dyad p hp x.1.1 B hB hcube.1 hcube.2 + have hdiv:primeProductNorm p x.1.2.2≤L*B^2:=by + calc + _≤primeProductNorm p (x.1.2.1∪cubePrincipalSupport x.1.1.support x.1.1.leftExponent + x.1.1.rightExponent x.1.1.leftBit x.1.1.rightBit):= + primeProductNorm_mono p hp (Finset.mem_powerset.mp hD) + _≤primeProductNorm p x.1.2.1*primeProductNorm p x.1.1.support:=by + apply (primeProductNorm_union_le_mul p hp _ _).trans + exact mul_le_mul_of_nonneg_left (primeProductNorm_mono p hp (Finset.filter_subset _ _)) + (primeProductNorm_pos p hp _).le + _≤L*B^2:=mul_le_mul hcommon hsup (primeProductNorm_pos p hp _).le + ((primeProductNorm_pos p hp _).le.trans hcommon) + have hactive:activeNorm p x≤B^2:= + (primeProductNorm_mono p hp (Finset.filter_subset _ _)).trans hsup + have hE:=firstPhysicalMultiplier_ne_zero p hp x.1.1.support x.1.1.leftExponent x.1.1.rightExponent + x.1.1.leftBit x.1.1.rightBit x.2.1 (hlabels _ hf) + have hh0:x.2.2≠0:=(Finset.mem_erase.mp hrow).1 + have hh:=((mem_nonzeroChildFrequencyBall _ hE Y x.2.2).mp hrow).2 + have hfreqnorm:‖eisEmbedding x.2.2‖^2≤Y:= + (element_norm_le_of_dvd (mul_ne_zero hE hh0) (dvd_mul_left x.2.2 _)).trans hh + have hj:InverseFirstGlobalCaps.jNorm p x.1≤B^2:=by + have hd:=jLabel_dvd_cube_product p x.1.1.support x.1.1.leftExponent x.1.1.rightExponent + x.1.1.leftBit x.1.1.rightBit x.1.1.support_pos + have hnorm:=element_norm_le_of_dvd + (mul_ne_zero (primeProduct_ne_zero p hp _ _) (primeProduct_ne_zero p hp _ _)) hd + simp only [map_mul,norm_mul,mul_pow] at hnorm + exact hnorm.trans ((mul_le_mul hcube.1 hcube.2 (sq_nonneg _) hB).trans_eq (pow_two B).symm) + refine ⟨?_,hquot,hj⟩ + intro i + fin_cases i + · exact ha₁ + · exact ha₂ + · exact hcommon + · simpa [originalNorms,InverseMomentFirstChildWindows.sourceNorms,divisorElement, + primeSubsetGenerator_norm_eq_productNorm] using hdiv + · exact hactive + · exact hfreqnorm + +end SevenEighths.InverseMomentFirstLiveCaps + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveRadiusPositive.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveRadiusPositive.lean new file mode 100644 index 0000000000000000000000000000000000000000..9a1617fe78b876d34650901ff5b4ecef5df720a8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveRadiusPositive.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicLiveRadius + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem first_live_cell_radius_one {ι:Type}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O))(Y Z M r ell V eta tau:ℝ) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ)(W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ))(K:ℝ) + (hlabels:∀I∈labels,I≠0): + let cutoff:=fun (q:CubeCoordinates ι)(C:Finset ι)(_I:Ideal O)(D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + ∀k∈liveJointKeys p + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) pool + (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K),1≤firstCellRadius Z M r ell V eta tau k.1 k.2.2:=by + intro cutoff k hk + obtain ⟨⟨x,j⟩,hm,rfl⟩:=Finset.mem_image.mp hk + obtain ⟨hm,hnon⟩:=Finset.mem_filter.mp hm + have hx:=(Finset.mem_product.mp hm).1 + have hweight:firstOriginalWeight p β cutoff x.1 x.2≠0:=by + intro hh + exact hnon (sourceSummand_zero_of_weight p hp hcop hg β cutoff Ψ m mark W Φ K x j hh) + have hrow:=original_weight_frequency p β cutoff x hweight + obtain ⟨ho,hf⟩:=Finset.mem_sigma.mp hx + obtain ⟨hI,hfreq⟩:=(mem_firstRetainedSource p labels x.1.1 Y x.2).mp hf + have hfreq0:x.2.2≠0:=(Finset.mem_erase.mp hfreq).1 + have hE:=firstPhysicalMultiplier_ne_zero p hp x.1.1.support x.1.1.leftExponent x.1.1.rightExponent + x.1.1.leftBit x.1.1.rightBit x.2.1 (hlabels _ hI) + have hn:= (mem_childFrequencyBall _ hE _ _).mp hrow + have hone:=EisensteinSchwartzPoisson.one_le_eisenstein_norm_sq _ (mul_ne_zero hE hfreq0) + have href:x.1∈refinedOuter p pool Q (sourceIndex (InverseMomentFirstOriginalProfile.originalNorms p) x) + (labelGate p (dyadIndex (InverseFirstGlobalCaps.jNorm p x.1))):=by + rw [refinedOuter_label] + refine Finset.mem_filter.mpr ⟨?_,rfl⟩ + exact InverseFirstGlobalCaps.sourceCell_outer p pool Q labels Y _ _ (Finset.mem_filter.mpr ⟨hx,rfl⟩) + change 1≤firstCellRadius Z M r ell V eta tau (sourceIndex (InverseMomentFirstOriginalProfile.originalNorms p) x) + (dyadIndex (InverseFirstGlobalCaps.jNorm p x.1)) + rw [←first_dyadic_radius_cell p pool Q _ _ x.1 href] + exact hone.trans hn + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveStepScalars.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveStepScalars.lean new file mode 100644 index 0000000000000000000000000000000000000000..58dd2705776355c1218f2c3479f23d6c42677777 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstLiveStepScalars.lean @@ -0,0 +1,97 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLiveExponentCaps +import OAI.NumberTheory.DirichletL.Descent.FirstLiveColumnScale +import OAI.NumberTheory.DirichletL.Descent.FirstLiveRadiusPositive +import OAI.NumberTheory.DirichletL.Descent.FirstStepScalarCaps +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStep + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstLabelCell CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +lemma columnScale_physical (Z r:ℝ)(hZ:1 rfl + + theorem original_live_step_scalars {ι:Type}[DecidableEq ι] + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O)(mark:(ι→₀ℕ)→Finset ι→ℂ)(om:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ)) + (K Z M r ell V F eta tau theta oldb b window em ed pi:ℝ) + (hZ:1firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let S:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) (Z^(2*F+15*eta+tau)); + ∀k∈liveJointKeys p S pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K),∀negative:Bool, + let X:=columnScale Z r k.1 k.2.1 negative; + let Y:=firstCellRadius Z M r ell V eta tau k.1 k.2.2; + 1≤Y ∧ 1≤X*Real.exp window ∧ X*Real.exp window≤Z^(A+1) ∧ Y≤Z^(16*A+20) ∧ Y⁻¹≤Z^(4*A+2) ∧ + b*X≤Z^(16*A+20) ∧ exponent Z (k.1 3)+eta+2*(A+1)+tau+(4*A+2)≤16*A+20 ∧ + firstKappa M r ell V (exponent Z (k.1 3)) (columnA Z k.1 negative) (exponent Z (k.1 2)) (exponent Z (k.1 4))+ + (9/2:ℝ)*eta≤16*A+20 ∧ + em*(ell+exponent Z (k.1 4)/2+exponent Z k.2.1+(16*A+20)+11*eta/2)≤pi ∧ + em*(r-columnA Z k.1 negative-exponent Z (k.1 2)-exponent Z k.2.1)+7*eta/2+ + ed*(3*ell+exponent Z (k.1 2)+exponent Z k.2.1+5*eta)+ + 2*em*(2*ell+exponent Z (k.1 2)+exponent Z k.2.1+4*eta)≤pi+eta/2 ∧ + ell+eta≤16*A+20 ∧ exponent Z (k.1 4)+eta≤16*A+20 ∧ + exponent Z (k.1 2)+eta≤16*A+20 ∧ exponent Z k.2.1+eta≤16*A+20:=by + intro A cutoff W S k hk negative X Y + have hz:0⟨(hcoords i).1,(hcoords i).2.trans hecap⟩ + have hacap:0≤columnA Z k.1 negative ∧ columnA Z k.1 negative≤A:=hkcap (if negative then 0 else 1) + have htcap:exponent Z k.2.1≤A:=ht.2.trans hecap + have hjcap:exponent Z k.2.2≤A:=hj.2.trans hecap + have hscl:=first_step_scalar_caps Z A M r ell V (exponent Z (k.1 3)) (columnA Z k.1 negative) + (exponent Z (k.1 2)) (exponent Z (k.1 4)) (exponent Z k.2.1) (exponent Z k.2.2) eta tau window b + hZ hA hM (hMF.trans hFA) (by linarith) (hrF.trans hFA) hell (hellF.trans hFA) hV (hVF.trans hFA) + (hkcap 3).1 (hkcap 3).2 hacap.1 hacap.2 (hkcap 2).1 (hkcap 2).2 (hkcap 4).1 (hkcap 4).2 + ht.1 htcap hj.1 hjcap heta heta1 htau htau1 hwindow (hb.trans hwindow) + have hloss:=first_step_scalar_losses A r ell (columnA Z k.1 negative) (exponent Z (k.1 2)) (exponent Z (k.1 4)) + (exponent Z k.2.1) eta pi em ed hA (hrF.trans hFA) (hellF.trans hFA) hacap.1 (hkcap 2).1 (hkcap 2).2 + (hkcap 4).2 ht.1 htcap heta heta1 hem hed hpi hetapi hsmall hsmall' + have hYone:=first_live_cell_radius_one p hp hcop hg pool Q labels _ Z M r ell V eta tau β Ψ m mark W Φ K hlabels k hk + have hW:∀y,W y≠0→y≤oldb*Z^r:=by + intro y hy + have hnon:om (y/Z^r)≠0:=by intro h;exact hy (by simp [W,normTwistedSource,h]) + exact (div_le_iff₀ (Real.rpow_pos_of_pos hz _)).mp (hs _ hnon) + have hcol:=original_live_column_scale p hp hcop hg pool Q labels _ β cutoff Ψ m mark W Φ K (Z^r) oldb + (Real.rpow_pos_of_pos hz _) hW k hk + have hXone:1≤X*Real.exp window:=by + have hpos:0≤X:=Real.rpow_nonneg hz.le _ + apply le_trans _ (mul_le_mul_of_nonneg_left hold hpos) + dsimp [X] + rw [columnScale_physical Z r hZ] + cases negative + · exact hcol.2 + · exact hcol.1 + refine ⟨hYone,hXone,hscl.1,hscl.2.1,hscl.2.2.1,hscl.2.2.2.1,hscl.2.2.2.2.1, + hscl.2.2.2.2.2.1,hloss.1,hloss.2,?_,?_,?_,?_⟩ <;> linarith [(hkcap 4).2,(hkcap 2).2] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedColumns.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedColumns.lean new file mode 100644 index 0000000000000000000000000000000000000000..93fc95c7218f0d75e21d4afc8a09941f1c0cddf4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedColumns.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstPhysicalTail +import OAI.NumberTheory.DirichletL.Descent.MarkBounds + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +variable {ι : Type*} [DecidableEq ι] + +theorem cube_whole_column_norm (p : ι→O) (b : CubeCoordinates ι) (hb : b.Admissible) + (C N : Finset ι) (hC : Disjoint C b.support) (hN : Disjoint N (b.support∪C)) + (negative : Bool) : + primeProductNorm p (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪N) = + ‖eisEmbedding (aLabel p b.support (if negative then b.rightBit else b.leftBit))‖^2 * + primeProductNorm p C * primeProductNorm p N := by + have hd : (if negative then b.rightDivisor else b.leftDivisor) ⊆ b.support := by + cases negative + · exact hb.1 + · exact hb.2 + rw [primeProductNorm_union p _ _ (hN.symm.mono_left (Finset.union_subset_union hd (Finset.Subset.refl C))), + primeProductNorm_union p _ _ (hC.symm.mono_left hd)] + congr 2 + cases negative <;> simp only [Bool.false_eq_true,ite_false,ite_true] + · rw [CubeCoordinates.aLabel_left p b hb]; rfl + · rw [CubeCoordinates.aLabel_right p b hb]; rfl + +def wholeMarkedTest {σ : Type*} [DecidableEq σ] (slots : Finset σ) + (lists : σ→Finset ι) (a : σ→ι→ℂ) (test : Finset ι→ℂ) (U : Finset ι) : ℂ := + primeMark slots lists a U * test U + +theorem whole_marked_test_uniform (ε : ℝ) (hε : 0<ε) : + ∃ Cm : ℝ, 0Ideal.span {p i}))) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i∈slots,∀ k∈lists i,‖a i k‖≤1) → + ∀ (test : Finset ι→ℂ) (G L : ℝ),0≤G → 0≤L → + (∀ U,‖test U‖≤G) → (∀ U,test U≠0 → primeProductNorm p U≤L) → + ∀ U,‖wholeMarkedTest slots lists a test U‖≤Cm*L^ε*G := by + obtain ⟨Cm,hCm,hmark⟩ := finite_primeMark_small_power ε hε + refine ⟨Cm,hCm,?_⟩ + intro ι σ _ _ p hp _ hcop slots lists a hslots ha test G L hG hL hb hs U + by_cases hz : test U=0 + · simp only [wholeMarkedTest,hz,mul_zero,norm_zero]; positivity + · have hn0 := (primeProductNorm_pos p hp U).le + rw [wholeMarkedTest,norm_mul] + calc + _ ≤ (Cm*(primeProductNorm p U)^ε)*G := + mul_le_mul (hmark p hp hcop slots lists a hslots ha U) (hb U) (norm_nonneg _) (by positivity) + _ ≤ Cm*L^ε*G := by gcongr; exact hs U hz + +variable (p : ι→O) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem canonical_residual_norm (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (hΨ : ∀ u,‖Ψ u‖≤1) (m f : O) (H : Finset ι→ℂ) (N : Finset ι) : + ‖canonicalCubeResidual p hg b C negative Ψ m f H N‖ ≤ + ‖H (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪N)‖ := by + exact originalLabelColumn_core_norm_le p hg b.support b.leftBit b.rightBit negative + Ψ hΨ m (∏i∈C,p i) f _ N + +theorem canonical_residual_test_nonzero (b : CubeCoordinates ι) (C : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m f : O) (H : Finset ι→ℂ) (N : Finset ι) + (hn : canonicalCubeResidual p hg b C negative Ψ m f H N≠0) : + H (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪N)≠0 := by + exact originalLabelColumn_core_test_ne_zero p hg b.support b.leftBit b.rightBit negative + Ψ m (∏i∈C,p i) f _ N hn + +theorem canonical_marked_residual_support {σ : Type*} [DecidableEq σ] + (b : CubeCoordinates ι) (hb : b.Admissible) (C N : Finset ι) + (hC : Disjoint C b.support) (hN : Disjoint N (b.support∪C)) (negative : Bool) + (Ψ : O→*ℂ) (m f : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (test : Finset ι→ℂ) (L : ℝ) (hs : ∀ U,test U≠0 → primeProductNorm p U≤L) + (hn : canonicalCubeResidual p hg b C negative Ψ m f (wholeMarkedTest slots lists a test) N≠0) : + ‖eisEmbedding (aLabel p b.support (if negative then b.rightBit else b.leftBit))‖^2 * + primeProductNorm p C * primeProductNorm p N≤L := by + have ht := canonical_residual_test_nonzero p hg b C negative Ψ m f _ N hn + have htest := (mul_ne_zero_iff.mp ht).2 + simpa only [cube_whole_column_norm p b hb C N hC hN negative] using hs _ htest + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedZero.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedZero.lean new file mode 100644 index 0000000000000000000000000000000000000000..d69072076d5097f52efe75d29396d1ff0c9d6f9f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedZero.lean @@ -0,0 +1,45 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstMarkedColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic EisensteinSchwartzPoisson +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem first_marked_zero_uniform (ε : ℝ) (hε : 0<ε) : + ∃ Cm : ℝ,0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (pool : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ),(∀ u,‖Ψ₁ u‖≤1) → (∀ u,‖Ψ₂ u‖≤1) → + ∀ (m₁ m₂ f : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → (∀ i∈slots,∀ k∈lists i,‖a i k‖≤1) → + ∀ (test₁ test₂ : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) (G₁ G₂ L K : ℝ),0≤G₁ → 0≤G₂ → 0≤L → + (∀ U,‖test₁ U‖≤G₁) → (∀ U,‖test₂ U‖≤G₂) → + (∀ U,test₁ U≠0 → primeProductNorm p U≤L) → + (∀ U,test₂ U≠0 → primeProductNorm p U≤L) → + ‖canonicalCubeDualZero p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ f + (wholeMarkedTest slots lists a test₁) (wholeMarkedTest slots lists a test₂) W K‖ ≤ + if cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit=∅ then + (Cm*L^ε*G₁)*(Cm*L^ε*G₂) * |K| * ‖paperRadialFourier W 0‖ else 0 := by + obtain ⟨Cm,hCm,hmark⟩ := whole_marked_test_uniform ε hε + refine ⟨Cm,hCm,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hc pool b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ f slots lists a hslots ha + test₁ test₂ W G₁ G₂ L K hG₁ hG₂ hL ht₁ ht₂ hs₁ hs₂ + apply (canonicalCubeDualZero_norm_le p hp hcop hg hinj hc pool b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ f _ _ W K).trans + split_ifs + · exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right + (mul_le_mul (hmark p hp hcop slots lists a hslots ha test₁ G₁ L hG₁ hL ht₁ hs₁ _) + (hmark p hp hcop slots lists a hslots ha test₂ G₂ L hG₂ hL ht₂ hs₂ _) + (norm_nonneg _) (by positivity)) (abs_nonneg _)) (norm_nonneg _) + · exact le_rfl + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedZeroSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedZeroSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..9b93fc47f880aa9b4d08a647157d715cb302fb75 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstMarkedZeroSource.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstZeroSource +import OAI.NumberTheory.DirichletL.Descent.CubeSupportNorm + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem full_marked_first_zero_bound (ε : ℝ) (hε : 0<ε) : + ∃C:ℝ,0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (bs:Finset (CubeCoordinates ι)) (labels:Finset (Ideal O)) + (coeff:CubeCoordinates ι→Finset ι→Ideal O→ℂ) (Ψ₁ Ψ₂:O→*ℂ) + (m₁ m₂:O) (test₁ test₂:CubeCoordinates ι→Finset ι→ℂ) + (extra₁ extra₂ : CubeCoordinates ι→Finset ι) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (W:𝓢(ℝ,ℂ)) (Γ G₁ G₂ L K B F:ℝ), + 0≤Γ → 0≤G₁ → 0≤G₂ → 0primeMark slots lists a (extra₁ b∪U)*test₁ b U) + (fun U=>primeMark slots lists a (extra₂ b∪U)*test₂ b U) W K‖≤ + C*B^(1+ε)*L*F*Γ*((B^2*L)^ε)^2*(G₁*G₂ * |K| * ‖paperRadialFourier W 0‖) := by + obtain ⟨Cz,hCz,hzero⟩ := full_variable_first_zero_bound ε hε + obtain ⟨Cm,hCm,hmark⟩ := whole_cube_marked_test_uniform ε hε + refine ⟨Cz*Cm^2,by positivity,?_⟩ + intro ι σ _ _ p hp _ hcop hg hinj hc pool bs labels coeff Ψ₁ Ψ₂ m₁ m₂ + test₁ test₂ extra₁ extra₂ slots lists a W Γ G₁ G₂ L K B F + hΓ hG₁ hG₂ hL hB hF hΨ₁ hΨ₂ hadm hb₁ hb₂ hI0 hIF hcoeff hslots ha + he₁ he₂ htest₁ htest₂ hs₁ hs₂ + have hB0 : 0≤B := le_trans zero_le_one hB + have hextra (extra : CubeCoordinates ι→Finset ι) (he : ∀b∈bs,extra b⊆b.support) + (b : CubeCoordinates ι) (hb : b∈bs) : primeProductNorm p (extra b)≤B^2 := + (primeProductNorm_mono p hp (he b hb)).trans (cube_whole_support_dyad p hp b B hB0 (hb₁ b hb) (hb₂ b hb)) + have ht₁ (b : CubeCoordinates ι) (hb : b∈bs) : + ∀U,‖primeMark slots lists a (extra₁ b∪U)*test₁ b U‖≤Cm*(B^2*L)^ε*G₁ := + hmark p hp hcop slots lists a hslots ha (extra₁ b) (test₁ b) (B^2) G₁ L + (sq_nonneg _) hG₁ hL.le (hextra extra₁ he₁ b hb) (htest₁ b hb) (hs₁ b hb) + have ht₂ (b : CubeCoordinates ι) (hb : b∈bs) : + ∀U,‖primeMark slots lists a (extra₂ b∪U)*test₂ b U‖≤Cm*(B^2*L)^ε*G₂ := + hmark p hp hcop slots lists a hslots ha (extra₂ b) (test₂ b) (B^2) G₂ L + (sq_nonneg _) hG₂ hL.le (hextra extra₂ he₂ b hb) (htest₂ b hb) (hs₂ b hb) + have hh := hzero p hp hcop hg hinj hc pool bs labels coeff Ψ₁ Ψ₂ m₁ m₂ + (fun b U=>primeMark slots lists a (extra₁ b∪U)*test₁ b U) + (fun b U=>primeMark slots lists a (extra₂ b∪U)*test₂ b U) W + Γ (Cm*(B^2*L)^ε*G₁) (Cm*(B^2*L)^ε*G₂) L K B F + hΓ (by positivity) (by positivity) hL hB hF hΨ₁ hΨ₂ hadm hb₁ hb₂ hI0 hIF hcoeff ht₁ ht₂ + (fun b hb U hU=>hs₁ b hb U (mul_ne_zero_iff.mp hU).2) + exact hh.trans_eq (by ring) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..a1f92bdbc6c7a5d26d01ebf8739b7df96d56c1f4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeAssembly.lean @@ -0,0 +1,113 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstModeColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap ContDiff +open ActualEisensteinCubic FirstPassCubeLabels FourierBridge JointLogSeparation +open MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstModeIdealRows (F B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (C₁ C₂ : Finset ι → ℂ) (d h : Eis) (a : Fin 7 → ℝ) + (y₁ y₂ : Finset ι → ℝ) (z : Frequency × (Fin 9 → ℝ)) : ℂ := + firstOuterPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2) a * + cubeBaseFactor p hp hg B v ε₁ ε₂ d h * + idealPairReindex p hg F + (cubeMinusCoefficient p hp hcop hg B v ε₁ ε₂ + (firstColumnMode true C₁ y₁ (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7)) d) + (cubePlusCoefficient p hp hcop hg B v ε₁ ε₂ + (firstColumnMode false C₂ y₂ (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8)) d) h + +theorem first_gauss_common_integral + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F B : Finset ι) (hFB : Disjoint F B) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (d h : Eis) (a : Fin 7 → ℝ) (y₁ y₂ : Finset ι → ℝ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (V : Fin 9 → ℝ → ℂ) (R : ℝ) + (g : Fin 9 → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) + (he : ∀ y : Fin 9 → ℝ, firstPoissonProfile W₁ W₂ Φ V R y = + ∫ z : Frequency × (Fin 9 → ℝ), fullProfileDensity g b₁ b₂ b₃ z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y z.1 z.2) : + (∑ N ∈ F.powerset, ∑ P ∈ F.powerset, if Disjoint N P then + threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h * + firstPoissonProfile W₁ W₂ Φ V R (firstCoordinates a (y₁ N) (y₂ P)) else 0) = + ∫ z : Frequency × (Fin 9 → ℝ), fullProfileDensity g b₁ b₂ b₃ z * + firstModeIdealRows p hp hcop hg F B v ε₁ ε₂ C₁ C₂ d h a y₁ y₂ z := by + let coeff := fun j : Finset ι × Finset ι => if Disjoint j.1 j.2 then + threeGaussRowFactor p hp hcop hg j.1 j.2 B v ε₁ ε₂ C₁ C₂ d h else 0 + let coord := fun j : Finset ι × Finset ι => firstCoordinates a (y₁ j.1) (y₂ j.2) + calc + _ = ∑ j ∈ F.powerset ×ˢ F.powerset, coeff j * + ∫ z : Frequency × (Fin 9 → ℝ), fullProfileDensity g b₁ b₂ b₃ z * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (coord j) z.1 z.2 := by + simp only [Finset.sum_product,coeff,coord] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro P hP + by_cases hd : Disjoint N P <;> simp [hd,he] + _ = ∫ z : Frequency × (Fin 9 → ℝ), fullProfileDensity g b₁ b₂ b₃ z * + ∑ j ∈ F.powerset ×ˢ F.powerset, coeff j * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (coord j) z.1 z.2 := + full_density_finite_sum _ g b₁ b₂ b₃ _ _ _ coeff coord + _ = _ := by + apply integral_congr_ae + filter_upwards with z + congr 1 + simp only [Finset.sum_product,coeff,coord,ite_mul,zero_mul] + exact actual_first_mode_ideal_rows p hp hcop hg hinj hc hpr F B hFB + v ε₁ ε₂ C₁ C₂ d h a y₁ y₂ z + +theorem first_gauss_uniform_common_measure + (W₁ W₂ : ℝ → ℂ) (lo hi : ℝ) (hlo : 0 < lo) + (hs₁ : Function.support W₁ ⊆ Set.Icc lo hi) + (hs₂ : Function.support W₂ ⊆ Set.Icc lo hi) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ,ℂ)) (V : Fin 9 → ℝ → ℂ) (M : Fin 9 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ,ℂ)) (C : ℝ), 0 ≤ C ∧ ∀ R : ℝ, 0 < R → + ∃ b₃ : 𝓢(ℝ,ℂ), + (∀ (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F B : Finset ι), Disjoint F B → ∀ (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (C₁ C₂ : Finset ι → ℂ) (d h : Eis) (a : Fin 7 → ℝ) (y₁ y₂ : Finset ι → ℝ), + (∑ N ∈ F.powerset, ∑ P ∈ F.powerset, if Disjoint N P then + threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h * + firstPoissonProfile W₁ W₂ Φ V R (firstCoordinates a (y₁ N) (y₂ P)) else 0) = + ∫ z : Frequency × (Fin 9 → ℝ), + fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z * + firstModeIdealRows p hp hcop hg F B v ε₁ ε₂ C₁ C₂ d h a y₁ y₂ z) ∧ + Integrable (fun z : Frequency × (Fin 9 → ℝ) => + tripleHeight J z.1 * coordinateHeight J z.2 * + ‖fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z‖) ∧ + (1+R)^A * (∫ z : Frequency × (Fin 9 → ℝ), + tripleHeight J z.1 * coordinateHeight J z.2 * + ‖fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ z‖) ≤ C := by + obtain ⟨b₁,b₂,C,hC,hs⟩ := first_full_profile_common_measure + W₁ W₂ lo hi hlo hs₁ hs₂ hW₁ hW₂ Φ V M hV hS hM hbox A J + refine ⟨b₁,b₂,C,hC,?_⟩ + intro R hR + obtain ⟨b₃,he,hI,hB⟩ := hs R hR + refine ⟨b₃,?_,hI,hB⟩ + intro hinj hc hpr F B hFB v ε₁ ε₂ C₁ C₂ d h a y₁ y₂ + apply first_gauss_common_integral p hp hcop hg hinj hc hpr F B hFB + v ε₁ ε₂ C₁ C₂ d h a y₁ y₂ W₁ W₂ Φ V R + (firstRootSchwartz V hV hS) b₁ b₂ b₃ + intro y + rw [full_density_mode_fubini] + simpa only [pureProfileMode_height] using he y + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeChild.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeChild.lean new file mode 100644 index 0000000000000000000000000000000000000000..bfc170a4ab6894b19e7a0ca2ba54ac167f1d3ea3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeChild.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstModeColumns +import OAI.NumberTheory.DirichletL.Descent.FirstPass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FourierBridge RayFourExpansion +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstModeCubeCoefficient (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (y : Finset ι → ℝ) (t : ℝ) (d : Eis) : + Finset ι → ℂ := + if negative then cubeMinusCoefficient p hp hcop hg B v ε₁ ε₂ + (firstColumnMode true C y t) d + else cubePlusCoefficient p hp hcop hg B v ε₁ ε₂ + (firstColumnMode false C y t) d + +theorem firstModeCubeCoefficient_eq (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (y : Finset ι → ℝ) (t : ℝ) (d : Eis) : + firstModeCubeCoefficient p hp hcop hg B v ε₁ ε₂ negative C y t d = + cubeLogCoefficient p hp hcop hg B v ε₁ ε₂ negative C (fun _ => 1) y (-t) d := by + have ht (u : ℝ) : logPhase (-t) (-u) = logPhase t u := by + unfold logPhase + congr 1 + push_cast + ring + have hm : firstColumnMode true C y t = logTwistMinus C (fun _ => 1) y (-t) := by + funext S + simp only [firstColumnMode,logTwistMinus,ite_true,one_mul,ht] + have hp' : firstColumnMode false C y t = logTwistPlus C (fun _ => 1) y (-t) := by + funext S + simp only [firstColumnMode,logTwistPlus,Bool.false_eq_true,ite_false,one_mul,ht] + cases negative <;> + simp only [firstModeCubeCoefficient,cubeLogCoefficient,Bool.false_eq_true,ite_false,ite_true,hm,hp'] + +omit [DecidableEq σ] in +theorem actual_first_mode_marked_input + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F D B A : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ j ∈ B, 0 < v j) (negative : Bool) (χ : RayCharacter) + (Ψ : Eis →* ℂ) (m : Eis) (slots : Finset σ) + (lists : σ → Finset ι) (a : σ → ι → ℂ) (H : Finset ι → ℂ) + (y : Finset ι → ℝ) (t : ℝ) (c d f h : Eis) : + rayIdealRow p hg F + (firstModeCubeCoefficient p hp hcop hg B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative + (multiplicativeCoreColumn p Ψ m (fun U => primeMark slots lists a (A ∪ U)*H U)) c f) + y t d) negative χ D h = + beforeDilationLabel (fun i => Ideal.span {p i}) hg p B v ε₁ ε₂ negative c d f D * + ∑ r : FirstCoreIndex, firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r * + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U => primeMark slots lists a (A ∪ U)*H U) (fun _ => 1) y c d r (-t) + (h*f^2*dilationLabel p B v ε₁ ε₂) := by + rw [firstModeCubeCoefficient_eq, + rayIdealRow_cube_labels p hp hinj hcop hg F D B v ε₁ ε₂ hv] + congr 1 + exact marked_dilatedCoreRow_eq_input_family p hp hcop hg hc hpr F D B A v ε₁ ε₂ + negative χ Ψ m slots lists a H (fun _ => 1) y c d (-t) _ + +theorem actual_first_mode_priority_input + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F D B A : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ j ∈ B, 0 < v j) (negative : Bool) (χ : RayCharacter) + (Ψ : Eis →* ℂ) (m : Eis) (slots : Finset σ) + (lists : σ → Finset ι) (a : σ → ι → ℂ) (H : Finset ι → ℂ) + (y : Finset ι → ℝ) (t : ℝ) (c d f h : Eis) : + rayIdealRow p hg F + (firstModeCubeCoefficient p hp hcop hg B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative + (multiplicativeCoreColumn p Ψ m (fun U => primeMark slots lists a (A ∪ U)*H U)) c f) + y t d) negative χ D h = + beforeDilationLabel (fun i => Ideal.span {p i}) hg p B v ε₁ ε₂ negative c d f D * + ∑ r : FirstCoreIndex, firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r * + ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ D) * + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U => primeMark (slots \ J) (fun i => lists i \ (A ∪ D)) a U*H U) + (fun _ => 1) y c d r (-t) (h*f^2*dilationLabel p B v ε₁ ε₂) := by + rw [actual_first_mode_marked_input p hp hcop hg hinj hc hpr F D B A v ε₁ ε₂ hv] + simp_rw [firstCoreInputRow_marked_priority] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeColumns.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeColumns.lean new file mode 100644 index 0000000000000000000000000000000000000000..816895fda7dc8b7efe54ce9c8a5a3d4f07316e10 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstModeColumns.lean @@ -0,0 +1,83 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstProfileIdentity +import OAI.NumberTheory.DirichletL.Descent.ProfileIntegral + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FourierBridge JointLogSeparation +open MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def firstCoordinates (a : Fin 7 → ℝ) (x y : ℝ) : Fin 9 → ℝ := + ![a 0,a 1,a 2,a 3,a 4,a 5,a 6,x,y] + +def firstOuterPhase (h : Fin 9 → ℝ) (a : Fin 7 → ℝ) : ℂ := + ∏ i : Fin 7, logPhase (h ⟨i.val, by omega⟩) (a i) + +theorem first_mode_split (a : Fin 7 → ℝ) (x y : ℝ) + (v : Frequency × (Fin 9 → ℝ)) : + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope (firstCoordinates a x y) v.1 v.2 = + firstOuterPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope v.1 v.2) a * + logPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope v.1 v.2 7) x * + logPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope v.1 v.2 8) y := by + rw [pureProfileMode_height] + simp [Fin.prod_univ_succ,firstCoordinates,firstOuterPhase] + ring + +def firstColumnMode (negative : Bool) {ι : Type*} (C : Finset ι → ℂ) + (y : Finset ι → ℝ) (t : ℝ) (S : Finset ι) : ℂ := + C S * if negative then star (logPhase t (y S)) else logPhase t (y S) + +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem threeGaussRowFactor_first_mode (N P B : Finset ι) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (y₁ y₂ : Finset ι → ℝ) (t₁ t₂ : ℝ) (d h : Eis) : + threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ + (firstColumnMode true C₁ y₁ t₁) (firstColumnMode false C₂ y₂ t₂) d h = + logPhase t₁ (y₁ N) * logPhase t₂ (y₂ P) * + threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h := by + simp only [threeGaussRowFactor,firstColumnMode,Bool.false_eq_true,ite_false,ite_true, + star_mul,star_star] + ring + +theorem actual_first_mode_ideal_rows + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F B : Finset ι) (hFB : Disjoint F B) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (d h : Eis) (a : Fin 7 → ℝ) (y₁ y₂ : Finset ι → ℝ) + (z : Frequency × (Fin 9 → ℝ)) : + (∑ N ∈ F.powerset, ∑ P ∈ F.powerset, if Disjoint N P then + threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope + (firstCoordinates a (y₁ N) (y₂ P)) z.1 z.2 else 0) = + firstOuterPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2) a * + cubeBaseFactor p hp hg B v ε₁ ε₂ d h * + idealPairReindex p hg F + (cubeMinusCoefficient p hp hcop hg B v ε₁ ε₂ + (firstColumnMode true C₁ y₁ (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7)) d) + (cubePlusCoefficient p hp hcop hg B v ε₁ ε₂ + (firstColumnMode false C₂ y₂ (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8)) d) h := by + rw [mul_assoc, ← sum_threeGaussRowFactor_eq_ideal_rows p hp hinj hcop hg hc hpr F B hFB] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro P hP + by_cases hd : Disjoint N P + · simp only [hd,ite_true] + rw [first_mode_split,threeGaussRowFactor_first_mode] + ring + · simp [hd] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstNominal.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstNominal.lean new file mode 100644 index 0000000000000000000000000000000000000000..b062df7880b8f23debbaf589fd7e3b58f889c82d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstNominal.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstProfileIdentity + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +noncomputable section + +def firstRootScale (s : Fin 9 → ℝ) : ℝ := + s 3 * Real.sqrt (s 4) * s 5 * Real.sqrt (s 7) * Real.sqrt (s 8) + +theorem firstRootScale_pos (s : Fin 9 → ℝ) (hs : ∀ i, 0 < s i) : + 0 < firstRootScale s := by + unfold firstRootScale + exact mul_pos (mul_pos (mul_pos (mul_pos (hs 3) (Real.sqrt_pos.2 (hs 4))) + (hs 5)) (Real.sqrt_pos.2 (hs 7))) (Real.sqrt_pos.2 (hs 8)) + +theorem firstNormProfile_nominal (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 9 → ℝ → ℂ) (s q : Fin 9 → ℝ) + (hs : ∀ i, 0 < s i) (hq : ∀ i, 0 < q i) (K : ℝ) : + firstNormProfile (fun x => W₁ (x/(s 0*s 2*s 5*s 7))) + (fun x => W₂ (x/(s 1*s 2*s 5*s 8))) Φ + (fun i y => V i (y-Real.log (s i))) K q = + ((firstRootScale s : ℝ):ℂ)⁻¹ * + firstNormProfile W₁ W₂ Φ V (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) + (fun i => q i/s i) := by + have hl : (q 0/s 0)*(q 2/s 2)*(q 5/s 5)*(q 7/s 7) = + q 0*q 2*q 5*q 7/(s 0*s 2*s 5*s 7) := by ring + have hr : (q 1/s 1)*(q 2/s 2)*(q 5/s 5)*(q 8/s 8) = + q 1*q 2*q 5*q 8/(s 1*s 2*s 5*s 8) := by ring + have hk : (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))*(q 6/s 6)/ + ((q 3/s 3)*(q 4/s 4)*(q 5/s 5)^2*(q 7/s 7)*(q 8/s 8)) = + K*q 6/(q 3*q 4*(q 5)^2*q 7*q 8) := by + field_simp [(hs 3).ne', (hs 4).ne', (hs 5).ne', (hs 6).ne', (hs 7).ne', (hs 8).ne'] + have hd : (q 3/s 3)*Real.sqrt (q 4/s 4)*(q 5/s 5)* + Real.sqrt (q 7/s 7)*Real.sqrt (q 8/s 8) = + (q 3*Real.sqrt (q 4)*q 5*Real.sqrt (q 7)*Real.sqrt (q 8))/firstRootScale s := by + rw [Real.sqrt_div (hq 4).le,Real.sqrt_div (hq 7).le,Real.sqrt_div (hq 8).le] + unfold firstRootScale + ring + unfold firstNormProfile + simp only [Real.log_div (hq _).ne' (hs _).ne'] + rw [hl,hr,hk] + have hdC : (↑(q 3/s 3):ℂ)*↑(Real.sqrt (q 4/s 4))*↑(q 5/s 5)* + ↑(Real.sqrt (q 7/s 7))*↑(Real.sqrt (q 8/s 8)) = + ((q 3:ℂ)*↑(Real.sqrt (q 4))*(q 5:ℂ)*↑(Real.sqrt (q 7))*↑(Real.sqrt (q 8)))/ + (firstRootScale s:ℂ) := by exact_mod_cast hd + rw [hdC] + have hDc : (firstRootScale s:ℂ) ≠ 0 := + Complex.ofReal_ne_zero.mpr (firstRootScale_pos s hs).ne' + field_simp [hDc] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOldEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOldEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..c2632f9c8059d143937bac635a8c7e1f1a49ba09 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOldEnergy.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstBlockEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstFreshEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + +theorem firstBlockOuterWeight_norm_le + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (selector : Finset ι → ℂ) (r : RayCharacter × RayCharacter) (D : Finset ι) (h : Eis) : + ‖firstBlockOuterWeight p selector r D h‖ ≤ ‖crossCoeff r.1 r.2‖*‖selector D‖ := by + have hprime (i : ι) : Prime (Ideal.span {p i}) := + Ideal.prime_of_isPrime (NeZero.ne (Ideal.span {p i})) inferInstance + have hm : ‖supportMobius (fun i => Ideal.span {p i}) D‖ = 1 := by + have hs := congrArg norm (supportMobius_sq _ hprime hinj D) + simp only [norm_mul,norm_one] at hs + nlinarith [norm_nonneg (supportMobius (fun i => Ideal.span {p i}) D)] + have hc : ‖rowCoprimeMask (fun i => Ideal.span {p i}) D h‖ ≤ 1 := by + unfold rowCoprimeMask + split_ifs <;> norm_num + simp only [firstBlockOuterWeight,norm_mul,hm,mul_one] + exact mul_le_of_le_one_right (mul_nonneg (norm_nonneg _) (norm_nonneg _)) hc + +def firstOldLabelCoefficient (hp : ∀ i,p i ≠ 0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (C : Finset ι → ℂ) (c d : Eis) (f : Ideal Eis) : Finset ι → ℂ := + firstBareCubeCoefficient p hp hg hcop B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative C c (ConcretePrimeRowBridge.idealGenerator f)) d + +theorem first_block_old_label_energy (ε : ℝ) (hε : 0 < ε) : + ∃ K : ℝ,0 < K ∧ ∀ {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (F B : Finset ι) (selector : Finset ι → ℂ) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool), + (∀ j∈B,0 < v j) → ∀ (negative : Bool) (C : Finset ι → ℂ) + (ω : ℝ → ℂ) (X t : ℝ),0 < X → ∀ (c d : Eis) + (source : Finset (Ideal Eis × Eis)) (rows : Finset Eis) (w : Ideal Eis × Eis → ℂ) (M Y : ℝ), + 0 ≤ M → 0 ≤ Y → (∀ x∈source,Squarefree x.1) → + (∀ x∈source,DescentWeightedCauchy.firstElementRowMap (dilationLabel p B v ε₁ ε₂) x ∈ rows) → + (∀ z∈rows,z ≠ 0) → (∀ z∈rows,(Ideal.absNorm (Ideal.span {z}):ℝ) ≤ Y) → + (∀ x∈source,‖w x‖ ≤ M) → + (∑ x∈source,‖w x‖ * firstBlockEnergy p hg F selector + (firstOldLabelCoefficient p hp hcop hg B v ε₁ ε₂ negative C c d x.1) + negative ω X t x.2) ≤ + M*K*Y^ε * ∑ r : RayCharacter × RayCharacter, ∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖) * + ∑ z∈rows,‖dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative + (if negative then r.1 else r.2) C (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) c d (-t) z‖^2 := by + obtain ⟨K,hK,hpush⟩ := first_fresh_energy_small_power ε hε + refine ⟨K,hK,?_⟩ + intro ι _ p hp _ hinj hcop hg F B selector v ε₁ ε₂ hv negative C ω X t hX c d + source rows w M Y hM hY hs hmap hrows hnorm hw + calc + _ = ∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset,∑ x∈source, + ‖w x‖*‖firstBlockOuterWeight p selector r D x.2‖* + ‖firstCommonColumn p hg F D + (firstOldLabelCoefficient p hp hcop hg B v ε₁ ε₂ negative C c d x.1) + negative (if negative then r.1 else r.2) ω X t x.2‖^2 := by + simp only [firstBlockEnergy,Finset.mul_sum,← mul_assoc] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro r hr + exact Finset.sum_comm + _ ≤ ∑ r : RayCharacter × RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)* + (M*K*Y^ε*∑ z∈rows,‖dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative + (if negative then r.1 else r.2) C (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) c d (-t) z‖^2) := by + apply Finset.sum_le_sum + intro r hr + apply Finset.sum_le_sum + intro D hD + calc + _ ≤ (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑ x∈source, + ‖w x‖*‖firstCommonColumn p hg F D + (firstOldLabelCoefficient p hp hcop hg B v ε₁ ε₂ negative C c d x.1) + negative (if negative then r.1 else r.2) ω X t x.2‖^2 := by + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro x hx + have hh := mul_le_mul_of_nonneg_left + (firstBlockOuterWeight_norm_le p hinj selector r D x.2) (norm_nonneg (w x)) + exact (mul_le_mul_of_nonneg_right hh (sq_nonneg _)).trans_eq (by ring) + _ ≤ _ := mul_le_mul_of_nonneg_left + (hpush p hp hinj hcop hg F D B v ε₁ ε₂ hv negative + (if negative then r.1 else r.2) C ω X t hX c d source rows w M Y + hM hY hs hmap hrows hnorm hw) (mul_nonneg (norm_nonneg _) (norm_nonneg _)) + _ = _ := by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + ring_nf + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..c0dcf6de57cadd170e80a918878b499521551445 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileAssembly.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileCells + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows CompletedHeight +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def coefficient (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (negative : Bool) + (x : OriginalIndex ι) : Finset ι→ℂ := + firstCanonicalCoefficient p hp hcop hg x.1.1 x.1.2.1 negative Ψ m (divisorElement p x.1) + (mark (if negative then x.1.1.rightExponent else x.1.1.leftExponent)) x.2 + +def weight (β : Ideal O→(ι→₀ℕ)→ℂ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) (Ψ : O→*ℂ) (m : O) + (x : OriginalIndex ι) : ℂ := + retainedCubeWeight p hp hcop hg x.1.1 x.1.2.1 Ψ Ψ m m + (divisorElement p x.1) (firstOriginalWeight p β R x.1) x.2 + +def sourceSummand (β : Ideal O→(ι→₀ℕ)→ℂ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) + (x : OriginalIndex ι) (j : FirstCommonIndex ι) : ℂ := + weight p hp hcop hg β R Ψ m x * + firstCommonWeight p hg (coefficient p hp hcop hg Ψ m mark true x) + (coefficient p hp hcop hg Ψ m mark false x) x.2.2 j * + firstNormProfile (fun y=>star (W y)) W Φ (fun _ _=>1) K + (firstCommonNorms p (leftNorm p x) (rightNorm p x) (commonNorm p x) (activeNorm p x) + (divisorElement p x.1) x.2.2 j) + +theorem original_retained_sum (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) (s : Fin 9→ℝ) (hs : ∀i,0labels) (fun x=>x.1) Y, + ∑j∈firstCommonIndices pool,sourceSummand p hp hcop hg β R Ψ m mark W Φ K x j := by + have hleft : s 0*s 2*s 5*s 7≠0 := ne_of_gt (mul_pos (mul_pos (mul_pos (hs 0) (hs 2)) (hs 5)) (hs 7)) + have hright : s 1*s 2*s 5*s 8≠0 := ne_of_gt (mul_pos (mul_pos (mul_pos (hs 1) (hs 2)) (hs 5)) (hs 8)) + simp only [originalRetainedFamily,firstFamilyPhysicalRows,firstBlockedPhysicalRows, + Finset.mul_sum,sourceSummand,weight,coefficient,leftNorm,rightNorm,commonNorm,activeNorm,divisorElement, + Bool.false_eq_true,ite_true,ite_false,one_mul] + apply Finset.sum_congr rfl + intro x hx + apply Finset.sum_congr rfl + intro j hj + simp only [firstNormProfile,mul_div_cancel₀ _ hleft,mul_div_cancel₀ _ hright] + ring + +theorem original_retained_cell_partition (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) (s : Fin 9→ℝ) (hs : ∀i,0labels) (fun x=>x.1) Y + let term := sourceSummand p hp hcop hg β R Ψ m mark W Φ K + originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W Φ K Y R s= + ∑k∈sourceKeys (originalNorms p) source,∑l∈liveCommonKeys p pool source (fun _ _=>1) term, + ∑x∈sourceCell (originalNorms p) source k,∑j∈firstCommonIndices pool, + commonSelector p (fun _=>1) l j.2.1*term x j := by + intro source term + rw [original_retained_sum p hp hcop hg pool Q labels β Ψ m mark W Φ K Y R s hs] + simpa only [one_mul] using original_live_signed_partition p pool source (originalNorms p) (fun _ _=>1) term + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileCellEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileCellEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..b7710b58e513a62ee76c831f889a55a73dfe40db --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileCellEnergy.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfilePhysical +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileAssembly +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileWindows + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + +def originalChildEnergy (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l : ℕ) + (negative : Bool) (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (omega : ℝ→ℂ) (T t Y : ℝ) : ℝ := + ∑x∈originalOuterCell p pool Q k, + firstCanonicalSecondEnergy p hp hg hinj pool x.1 x.2.1 negative Ψ m (divisorElement p x) + (mark (if negative then x.1.rightExponent else x.1.leftExponent)) + (commonSelector p (fun _=>1) l) omega T t Y + +def originalCellRows (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (k : SourceIndex) (l : ℕ) (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) (s : Fin 9→ℝ) : ℂ := + firstFamilyPhysicalRows p hg + (sourceCell (originalNorms p) + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) k) + pool (fun _=>commonSelector p (fun _=>1) l) + (coefficient p hp hcop hg Ψ m mark true) (coefficient p hp hcop hg Ψ m mark false) + (weight p hp hcop hg β cutoff Ψ m) W₁ W₂ Φ + (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) K + (fun x=>divisorElement p x.1) (fun x=>x.2.2) s + +theorem original_cell_physical_budget (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) (m₁ m₂ : ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) + (hg₁ : Function.support g₁⊆Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂⊆Set.Icc (-m₂) m₂) : + ∃(omega₁ omega₂ : 𝓢(ℝ,ℂ))(lo hi : ℝ),0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (Γ Y : ℝ) + (_hΨ : ∀u,‖Ψ u‖≤1) (_hΓ : 0≤Γ) (_hY : 0Z^(![aa₁,aa₂,bb,delta,rr,tq,hh,r-aa₁-bb-tq,r-aa₂-bb-tq] i)) + (_hLe : L=eta*Real.log Z) + (_hleft : ∀z : Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V delta aa₁ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + originalChildEnergy p hp hg hinj pool Q k l true Ψ m mark omega₁ T₁ + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) Y≤ + Benergy*(tripleHeight J z.1*coordinateHeight J z.2)) + (_hright : ∀z : Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V delta aa₂ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + originalChildEnergy p hp hg hinj pool Q k l false Ψ m mark omega₂ T₂ + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) Y≤ + Benergy*(tripleHeight J z.1*coordinateHeight J z.2)), + (Z^(-r-2*ell-V)*Z^M)*‖originalCellRows p hp hcop hg pool Q labels β cutoff Ψ m mark k l + (positiveSource g₁ 1 (-theta)) (positiveSource g₂ 1 theta) Φ K Y (rawScales k l T₁ T₂)‖≤ + ((Γ^2*Kpush*Y^ε*Benergy)*(Cprofile*((1+‖-theta‖)^InverseClippingProfiles.momentOrder J* + (1+‖theta‖)^InverseClippingProfiles.momentOrder J)/ + (1+K*(rawScales k l T₁ T₂) 6/((rawScales k l T₁ T₂) 3*(rawScales k l T₁ T₂) 4* + ((rawScales k l T₁ T₂) 5)^2*T₁*T₂))^Aker)) := by + obtain ⟨w₁,w₂,U,M₀,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,hM,hUc,hUs,hwin⟩ := + original_cell_windows g₁ g₂ m₁ m₂ 1 (fun _=>0) hm₁ hm₂ hg₁ hg₂ (fun _=>le_rfl) + refine ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro ε hε Aker J + obtain ⟨Cprofile,Kpush,hC,hKp,he⟩ := actual_first_original_subset_physical_budget + ε hε U g₁ g₂ Φ M₀ (fun _=>0) m₁ m₂ 1 + hM (fun _=>le_rfl) hUs hg₁ hg₂ Aker J + refine ⟨Cprofile,Kpush,hC,hKp,?_⟩ + intro ι _ p hp _ hg hinj hcop hc hpr pool Q labels β cutoff Ψ m mark Γ Y hΨ hΓ hY hsf hn hβ + k l T₁ T₂ K theta L hT₁ hT₂ hK hL Benergy Z M r ell V delta aa₁ aa₂ bb rr tq hh eta hB hZ hscale hLe hleft hright + let source := sourceCell (originalNorms p) + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) k + have hgates := hwin p hp hg pool Q labels Y (coefficient p hp hcop hg Ψ m mark true) + (coefficient p hp hcop hg Ψ m mark false) k l T₁ T₂ (fun _=>0) 1 1 (-theta) theta + hT₁ hT₂ (by intro i;simp) le_rfl le_rfl le_rfl le_rfl + have hb := he p hp hg hinj hcop hc hpr pool (originalOuterCell p pool Q k) (fun x=>x.1) (fun x=>x.2.1) + Ψ Ψ m m (divisorElement p) (fun x=>mark x.1.rightExponent) (fun x=>mark x.1.leftExponent) + (fun _=>commonSelector p (fun _=>1) l) (fun _=>labels) (firstOriginalWeight p β cutoff) (Γ^2) Y + hΨ hΨ (sq_nonneg _) hY (fun _ _=>hsf) (fun _ _=>hn) + (fun x hx=>original_weight_bound p pool Q labels β cutoff Γ Y hΓ hβ x (original_outer_cell_subset p pool Q k hx)) + w₁ w₂ (fun _=>0) 1 1 (-theta) theta (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) + K L hK (rawScales k l T₁ T₂) (rawScales_pos k l T₁ T₂ hT₁ hT₂) + source (original_cell_subset p pool Q labels Y k) + (fun x hx=>original_source_positive p hp pool Q labels Y x (Finset.mem_filter.mp hx).1) + (by intro i;simp) le_rfl le_rfl le_rfl le_rfl hL hgates.1 hgates.2.1 hgates.2.2 + Benergy hB Z M r ell V delta aa₁ aa₂ bb rr tq hh eta hZ hscale hLe + (by simpa [originalChildEnergy,rawScales] using hleft) + (by simpa [originalChildEnergy,rawScales] using hright) + unfold originalCellRows + unfold SevenEighths.InverseMomentFirstOriginalProfile.coefficient SevenEighths.InverseMomentFirstOriginalProfile.weight + simpa [source,rawScales] using hb + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileCells.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileCells.lean new file mode 100644 index 0000000000000000000000000000000000000000..8b7ca88fc55e838417da0339fb3d413bb2a5ffae --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileCells.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileIdentity +import OAI.NumberTheory.DirichletL.Descent.FirstChildWindowsLive + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseSecondSourceBlocks +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +def originalNorms (x : OriginalIndex ι) : Fin 6→ℝ := + sourceNorms (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) + (fun x=>divisorElement p x.1) (fun x=>x.2.2) x + +def originalOuterCell (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) : + Finset (FirstOriginalOuter ι) := + (firstOriginalOuter pool Q).filter (fun x=>∀i:Fin 5, + dyadIndex (originalNorms p ⟨x,(1,1)⟩ i.castSucc)=k i.castSucc) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma originalNorms_outer (x : OriginalIndex ι) (i : Fin 5) : + originalNorms p ⟨x.1,(1,1)⟩ i.castSucc=originalNorms p x i.castSucc := by + unfold originalNorms sourceNorms + fin_cases i <;> simp [Fin.castSucc,leftNorm,rightNorm,commonNorm,activeNorm] + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem original_cell_subset (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (Y : ℝ) (k : SourceIndex) : + sourceCell (originalNorms p) + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) k ⊆ + firstGlobalRetainedSource p (originalOuterCell p pool Q k) (fun _=>labels) (fun x=>x.1) Y := by + intro x hx + obtain ⟨hxs,hk⟩ := Finset.mem_filter.mp hx + obtain ⟨ho,hf⟩ := Finset.mem_sigma.mp hxs + apply Finset.mem_sigma.mpr + refine ⟨Finset.mem_filter.mpr ⟨ho,?_⟩,hf⟩ + intro i + rw [originalNorms_outer p x i] + exact congrFun hk i.castSucc + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma original_outer_cell_subset (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) : + originalOuterCell p pool Q k⊆firstOriginalOuter pool Q := Finset.filter_subset _ _ + +theorem original_outer_cell_ratios (hp : ∀i,p i≠0) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) + (x : FirstOriginalOuter ι) (hx : x∈originalOuterCell p pool Q k) (i : Fin 5) : + originalNorms p ⟨x,(1,1)⟩ i.castSucc/dyadScale (k i.castSucc)∈Set.Icc 1 2 := by + have hnorm : ∀j:Fin 6,1≤originalNorms p ⟨x,(1,1)⟩ j := by + apply sourceNorms_ge_one + · exact element_norm_ge_one _ (primeProduct_ne_zero p hp _ _) + · exact element_norm_ge_one _ (primeProduct_ne_zero p hp _ _) + · exact primeProductNorm_ge_one p hp _ + · exact primeProductNorm_ge_one p hp _ + · exact primeSubsetGenerator_ne_zero _ _ + · exact one_ne_zero + have hh := dyadIndex_bounds _ (hnorm i.castSucc) + rw [(Finset.mem_filter.mp hx).2 i] at hh + exact ⟨(le_div_iff₀ (dyadScale_pos _)).mpr (by simpa using hh.1), + (div_le_iff₀ (dyadScale_pos _)).mpr hh.2.le⟩ + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileData.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileData.lean new file mode 100644 index 0000000000000000000000000000000000000000..a9bc2a4bba89f3774a56568d3353da217ca007b0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileData.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstGlobalSourceEnergy +import OAI.NumberTheory.DirichletL.Descent.PriorityProfile +import OAI.NumberTheory.DirichletL.Descent.FirstChildWindowsCells + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +open CompletedHeight FourierBridge +local notation "O" => ActualEisensteinCubic.O +abbrev OriginalIndex (ι : Type*) := Σ _ : FirstOriginalOuter ι,Ideal O×O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +def leftNorm (x : OriginalIndex ι) : ℝ := ‖eisEmbedding (aLabel p x.1.1.support x.1.1.rightBit)‖^2 +def rightNorm (x : OriginalIndex ι) : ℝ := ‖eisEmbedding (aLabel p x.1.1.support x.1.1.leftBit)‖^2 +def commonNorm (x : OriginalIndex ι) : ℝ := primeProductNorm p x.1.2.1 +def activeNorm (x : OriginalIndex ι) : ℝ := primeProductNorm p (cubeActiveSupport x.1.1.support + (fun i=>x.1.1.leftExponent i+x.1.1.rightExponent i) x.1.1.leftBit x.1.1.rightBit) +def divisorElement (k : FirstOriginalOuter ι) : O := primeSubsetGenerator (fun i=>Ideal.span {p i}) k.2.2 + +include hp in +theorem original_source_positive (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (Y : ℝ) : + ∀x∈firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun k=>k.1) Y, + 0labels) (fun k=>k.1) Y, + ∀i,1≤InverseMomentFirstChildWindows.sourceNorms (leftNorm p) (rightNorm p) (commonNorm p) + (activeNorm p) (fun x=>divisorElement p x.1) (fun x=>x.2.2) x i := by + intro x hx + have hh := original_source_positive p hp pool Q labels Y x hx + apply InverseMomentFirstChildWindows.sourceNorms_ge_one + · exact element_norm_ge_one _ (primeProduct_ne_zero p hp _ _) + · exact element_norm_ge_one _ (primeProduct_ne_zero p hp _ _) + · exact primeProductNorm_ge_one p hp _ + · exact primeProductNorm_ge_one p hp _ + · exact hh.2.2.2.2.1 + · exact hh.2.2.2.2.2 + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem original_weight_bound (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (β : Ideal O→(ι→₀ℕ)→ℂ) + (R : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) (Γ Y : ℝ) + (hΓ : 0≤Γ) (hβ : ∀I∈labels,∀v∈Q,‖β I v‖≤Γ) : + ∀k∈firstOriginalOuter pool Q,∀x∈firstRetainedSource p labels k.1 Y, + ‖firstOriginalWeight p β R k x‖≤Γ^2 := by + intro k hk x hx + have hb := (mem_firstOriginalOuter pool Q k).mp hk + have hf := ((mem_firstRetainedSource p labels k.1 Y x).mp hx).1 + exact (firstOriginalWeight_norm_le p β R k x).trans + (reopenedPairCoefficient_bound Q labels β Γ hΓ hβ k.1 hb.1 k.2.1 x.1 hf) + +theorem actual_old_profile (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0 ActualEisensteinCubic.O +open InverseMomentFirstProfileUniform InverseAmbientProfileTower +theorem actual_first_original_subset_two_energies (ε : ℝ) (hε : 0<ε) + (U₀ : Fin 9 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 9 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ Cprofile Kpush : ℝ,0 ≤ Cprofile ∧ 0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀ i,ringChar (Eis⧸Ideal.span {p i})≠2) + (_hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F : Finset ι) (outer:Finset κ) (b : κ→SecondPassArithmetic.CubeCoordinates ι) (common : κ→Finset ι) + (Ψ₁ Ψ₂ : Eis→*ℂ) (mleft mright : Eis) (dd:κ→Eis) (H₁ H₂ selector : κ→Finset ι→ℂ) + (labels : κ→Finset (Ideal Eis)) (a : κ→Ideal Eis×Eis→ℂ) (Γ Y : ℝ) + (_hΨ₁ : ∀ u,‖Ψ₁ u‖≤1) (_hΨ₂ : ∀ u,‖Ψ₂ u‖≤1) + (_hΓ : 0≤Γ) (_hY : 0 firstCanonicalCoefficient p hp hcop hg (b x.1) (common x.1) true Ψ₁ mleft (dd x.1) (H₁ x.1) x.2 + let C₂ := fun x : (Σ _ : κ,Ideal Eis×Eis) => firstCanonicalCoefficient p hp hcop hg (b x.1) (common x.1) false Ψ₂ mright (dd x.1) (H₂ x.1) x.2 + let w := fun x : (Σ _ : κ,Ideal Eis×Eis) => retainedCubeWeight p hp hcop hg (b x.1) (common x.1) Ψ₁ Ψ₂ mleft mright (dd x.1) (a x.1) x.2 + ∀ (_hpos : ∀ x∈source,0selector x.1) C₁ C₂ w (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) Φ A₁ A₂ C R K (fun x=>dd x.1) (fun x=>x.2.2) s‖ ≤ + (Real.exp ((9/2:ℝ)*L)/firstRootScale s)* + ((Γ*Kpush*Y^ε*(Real.sqrt B₁*Real.sqrt B₂))*(Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker)) := by + obtain ⟨Cprofile,hCprofile,hprofile⟩ := actual_first_moving_family_two_energies_uniform + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + obtain ⟨Kpush,hKpush,hpush⟩ := first_global_retained_push_uniform ε hε + refine ⟨Cprofile,Kpush,hCprofile,hKpush,?_⟩ + intro ι κ _ _ p hp _ hg hinj hcop hc hpr F outer b common Ψ₁ Ψ₂ mleft mright dd H₁ H₂ selector labels a Γ Y + hΨ₁ hΨ₂ hΓ hY hlabels hn ha ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ A₁ A₂ C R K L hK s hs selected hselected + source C₁ C₂ w hpos hρ hc₁ hc₂ hc₁b hc₂b hL hω₁ hω₂ hcut B₁ B₂ hB₁ hB₂ hleft hright + have hweight : 0≤Γ*Kpush*Y^ε := by positivity + have hroot:Real.sqrt (Γ*Kpush*Y^ε*B₁)*Real.sqrt (Γ*Kpush*Y^ε*B₂)=Γ*Kpush*Y^ε*(Real.sqrt B₁*Real.sqrt B₂):=by + rw [Real.sqrt_mul hweight,Real.sqrt_mul hweight] + calc + _=(Real.sqrt (Γ*Kpush*Y^ε))^2*(Real.sqrt B₁*Real.sqrt B₂):=by ring + _= _:=by rw [Real.sq_sqrt hweight] + rw [←hroot] + apply hprofile p hp hg source F (fun x=>selector x.1) C₁ C₂ w ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ + A₁ A₂ C R K L hK (fun x=>dd x.1) (fun x=>x.2.2) s hpos hs hρ hc₁ hc₂ hc₁b hc₂b hL + hω₁ hω₂ hcut (Γ*Kpush*Y^ε*B₁) (Γ*Kpush*Y^ε*B₂) (mul_nonneg hweight hB₁) (mul_nonneg hweight hB₂) + · intro z + have he := hpush p hp hinj hcop hg hc hpr F outer b common Ψ₁ Ψ₂ mleft mright dd + labels a Γ Y hΨ₁ hΨ₂ hΓ hY hlabels hn ha true H₁ selector ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) (hs 7) + simp only [ite_true,] at he + have hm1 : firstFamilyEnergy p hg source F (fun x=>selector x.1) C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) (fun x=>x.2.2) ≤ + firstFamilyEnergy p hg (firstGlobalRetainedSource p outer labels b Y) F + (fun x=>selector x.1) C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) (fun x=>x.2.2) := by + unfold firstFamilyEnergy + exact Finset.sum_le_sum_of_subset_of_nonneg hselected (fun x hx hn=> + mul_nonneg (norm_nonneg _) (firstBlockEnergy_nonneg p hg _ _ _ _ _ _ _ _)) + apply (hm1.trans he).trans + simpa only [mul_assoc,ite_true,ite_false,Bool.false_eq_true] using mul_le_mul_of_nonneg_left (hleft z) hweight + · intro z + have he := hpush p hp hinj hcop hg hc hpr F outer b common Ψ₁ Ψ₂ mleft mright dd + labels a Γ Y hΨ₁ hΨ₂ hΓ hY hlabels hn ha false H₂ selector ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) (hs 8) + simp only [ite_false,Bool.false_eq_true] at he + have hm2 : firstFamilyEnergy p hg source F (fun x=>selector x.1) C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) (fun x=>x.2.2) ≤ + firstFamilyEnergy p hg (firstGlobalRetainedSource p outer labels b Y) F + (fun x=>selector x.1) C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) (fun x=>x.2.2) := by + unfold firstFamilyEnergy + exact Finset.sum_le_sum_of_subset_of_nonneg hselected (fun x hx hn=> + mul_nonneg (norm_nonneg _) (firstBlockEnergy_nonneg p hg _ _ _ _ _ _ _ _)) + apply (hm2.trans he).trans + simpa only [mul_assoc,ite_true,ite_false,Bool.false_eq_true] using mul_le_mul_of_nonneg_left (hright z) hweight + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..388b212ec48839c72a163996d5e6fe5e351eb29f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileIdentity.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileData + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open CompletedHeight FourierBridge +open InverseMomentFirstProfileUniform +local notation "O" => ActualEisensteinCubic.O +variable {ι κ : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] +variable (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +include hp in +lemma physical_rows_congr_positive (F : Finset ι) (selector C₁ C₂ : Finset ι→ℂ) + (W₁ W₂ V₁ V₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R K : ℝ) (d h : O) + (hA₁ : 0h₁ _ (div_pos hy (mul_pos (mul_pos (mul_pos (hs 0) (hs 2)) (hs 5)) (hs 7)))) + (fun y hy=>h₂ _ (div_pos hy (mul_pos (mul_pos (mul_pos (hs 1) (hs 2)) (hs 5)) (hs 8)))) + +include hp in + +theorem original_family_profiles (S : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ→Finset ι→ℂ) (w : κ→ℂ) + (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0star (normTwistedSource om theta ((s 0*s 2*s 5*s 7)*y/X))) + (fun y=>normTwistedSource om theta ((s 1*s 2*s 5*s 8)*y/X)) Φ A₁ A₂ C R K d h s= + firstFamilyPhysicalRows p hg S F selector C₁ C₂ w + (positiveSource (priorityLogWindow om a b ha hsom true) 1 (-theta)) + (positiveSource (priorityLogWindow om a b ha hsom false) 1 theta) Φ A₁ A₂ C R K d h s := by + apply physical_family_congr_positive p hp hg S F selector C₁ C₂ w _ _ _ _ Φ A₁ A₂ C R K d h s hs hpos + · intro y hy + rw [hleft,mul_div_cancel_left₀ y (ne_of_gt hX)] + exact (actual_old_profile om a b ha hsom theta y hy).2.symm + · intro y hy + rw [hright,mul_div_cancel_left₀ y (ne_of_gt hX)] + exact (actual_old_profile om a b ha hsom theta y hy).1.symm + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveAggregate.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveAggregate.lean new file mode 100644 index 0000000000000000000000000000000000000000..b058332d5b4435e8f07876f2838a3bb79289da10 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveAggregate.lean @@ -0,0 +1,46 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveIdentity +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveCount +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileScales + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseMomentFirstProfileUniform CompletedHeight +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem original_retained_joint_profile_bound (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (β : Ideal O→(ι→₀ℕ)→ℂ) + (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0labels) (fun x=>x.1) Y + let W := fun y=>normTwistedSource om theta (y/X) + let term := sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K + ‖originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W Φ K Y cutoff reference‖≤ + ∑k∈liveJointKeys p source pool term, + ‖refinedCellRows p hp hcop hg pool Q labels β cutoff Ψ m mark k.1 k.2.1 (labelGate p k.2.2) + (positiveSource (priorityLogWindow om a b ha hsom true) 1 (-theta)) + (positiveSource (priorityLogWindow om a b ha hsom false) 1 theta) Φ K Y (physicalScales X k.1 k.2.1)‖ := by + intro source W term + rw [original_retained_joint_partition p hp hcop hg pool Q labels β cutoff Ψ m mark W Φ K Y reference href] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro k hk + have hp₁ := (physicalScales_products X k.1 k.2.1).1 + have hp₂ := (physicalScales_products X k.1 k.2.1).2 + rw [original_refined_cell_profile_identity p hp hcop hg pool Q labels β cutoff Ψ m mark om a b ha hsom + Φ K Y X theta hX k.1 k.2.1 (labelGate p k.2.2) (physicalScales X k.1 k.2.1) (physicalScales_pos X hX k.1 k.2.1) hp₁ hp₂] + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveCount.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveCount.lean new file mode 100644 index 0000000000000000000000000000000000000000..91f81a0e53cfebf1ecc29a900215d0cce549a47c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveCount.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLivePartition + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels InverseMomentFirstChildWindows InverseSecondSourceBlocks +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem liveJointKeys_card (S : Finset (OriginalIndex ι)) (pool : Finset ι) + (term : OriginalIndex ι→FirstCommonIndex ι→ℂ) (B : ℕ) + (hcap : ∀x∈S,∀j∈firstCommonIndices pool,term x j≠0→ + (∀i,sourceIndex (originalNorms p) x i≤B) ∧ + dyadIndex (primeProductNorm p j.2.1)≤B ∧ + dyadIndex (InverseFirstGlobalCaps.jNorm p x.1)≤B) : + (liveJointKeys p S pool term).card≤(B+1)^8 := by + let box := (Fintype.piFinset (fun _ : Fin 6=>Finset.range (B+1))) ×ˢ + (Finset.range (B+1) ×ˢ Finset.range (B+1)) + have hsub : liveJointKeys p S pool term⊆box := by + intro k hk + obtain ⟨⟨x,j⟩,hm,rfl⟩ := Finset.mem_image.mp hk + obtain ⟨hm,hn⟩ := Finset.mem_filter.mp hm + obtain ⟨hx,hj⟩ := Finset.mem_product.mp hm + obtain ⟨h₁,h₂,h₃⟩ := hcap x hx j hj hn + exact Finset.mem_product.mpr ⟨Fintype.mem_piFinset.mpr + (fun i=>Finset.mem_range.mpr (Nat.lt_succ_of_le (h₁ i))), + Finset.mem_product.mpr ⟨Finset.mem_range.mpr (Nat.lt_succ_of_le h₂), + Finset.mem_range.mpr (Nat.lt_succ_of_le h₃)⟩⟩ + have hc : box.card=(B+1)^8 := by + simp only [box,Finset.card_product,Fintype.card_piFinset,Finset.card_range,Finset.prod_const,Finset.card_univ,Fintype.card_fin] + ring + exact hc ▸ Finset.card_le_card hsub + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem liveJointKeys_card_of_norm_cap (S : Finset (OriginalIndex ι)) (pool : Finset ι) + (term : OriginalIndex ι→FirstCommonIndex ι→ℂ) (R : ℝ) + (hcap : ∀x∈S,∀j∈firstCommonIndices pool,term x j≠0→ + (∀i,0 + Nat.floor_mono (Real.logb_le_logb_of_le (by norm_num : (1:ℝ)<2) ha haR) + exact ⟨fun i=>hm _ (h₁ i).1 (h₁ i).2,hm _ h₂.1 h₂.2,hm _ h₃.1 h₃.2⟩ + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..183f11dabcedb645183887cf796bc9d396e48084 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveEnergy.lean @@ -0,0 +1,124 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveSource +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfilePhysical +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileAssembly +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileWindows + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseMomentFirstProfileUniform +open InverseAmbientProfileTower JointLogSeparation FourierBridge +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + +def refinedChildEnergy (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l : ℕ) + (gate : FirstOriginalOuter ι→Prop) (negative : Bool) (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (omega : ℝ→ℂ) (T t Y : ℝ) : ℝ := + ∑x∈refinedOuter p pool Q k gate, + firstCanonicalSecondEnergy p hp hg hinj pool x.1 x.2.1 negative Ψ m (divisorElement p x) + (mark (if negative then x.1.rightExponent else x.1.leftExponent)) + (commonSelector p (fun _=>1) l) omega T t Y + +def refinedCellRows (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (k : SourceIndex) (l : ℕ) (gate : FirstOriginalOuter ι→Prop) (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) (s : Fin 9→ℝ) : ℂ := + firstFamilyPhysicalRows p hg + (refinedSource p pool Q labels β cutoff Y k gate) + pool (fun _=>commonSelector p (fun _=>1) l) + (coefficient p hp hcop hg Ψ m mark true) (coefficient p hp hcop hg Ψ m mark false) + (weight p hp hcop hg β cutoff Ψ m) W₁ W₂ Φ + (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) K + (fun x=>divisorElement p x.1) (fun x=>x.2.2) s + +theorem original_refined_cell_physical_budget (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) (m₁ m₂ : ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) + (hg₁ : Function.support g₁⊆Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂⊆Set.Icc (-m₂) m₂) : + ∃(omega₁ omega₂ : 𝓢(ℝ,ℂ))(lo hi : ℝ),0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (Γ Ysource Y : ℝ) + (_hΨ : ∀u,‖Ψ u‖≤1) (_hΓ : 0≤Γ) (_hY : 0Z^(![aa₁,aa₂,bb,delta,rr,tq,hh,r-aa₁-bb-tq,r-aa₂-bb-tq] i)) + (_hLe : L=eta*Real.log Z) + (_hleft : ∀z : Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V delta aa₁ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + refinedChildEnergy p hp hg hinj pool Q k l gate true Ψ m mark omega₁ T₁ + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) Y≤ + Benergy*(tripleHeight J z.1*coordinateHeight J z.2)) + (_hright : ∀z : Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V delta aa₂ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + refinedChildEnergy p hp hg hinj pool Q k l gate false Ψ m mark omega₂ T₂ + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) Y≤ + Benergy*(tripleHeight J z.1*coordinateHeight J z.2)), + (Z^(-r-2*ell-V)*Z^M)*‖refinedCellRows p hp hcop hg pool Q labels β cutoff Ψ m mark k l gate + (positiveSource g₁ 1 (-theta)) (positiveSource g₂ 1 theta) Φ K Ysource (rawScales k l T₁ T₂)‖≤ + ((Γ^2*Kpush*Y^ε*Benergy)*(Cprofile*((1+‖-theta‖)^InverseClippingProfiles.momentOrder J* + (1+‖theta‖)^InverseClippingProfiles.momentOrder J)/ + (1+K*(rawScales k l T₁ T₂) 6/((rawScales k l T₁ T₂) 3*(rawScales k l T₁ T₂) 4* + ((rawScales k l T₁ T₂) 5)^2*T₁*T₂))^Aker)) := by + obtain ⟨w₁,w₂,U,M₀,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,hM,hUc,hUs,hwin⟩ := + original_cell_windows g₁ g₂ m₁ m₂ 1 (fun _=>0) hm₁ hm₂ hg₁ hg₂ (fun _=>le_rfl) + refine ⟨w₁,w₂,lo,hi,hlo,hlh,hw₁,hw₂,hs₁,hs₂,?_⟩ + intro ε hε Aker J + obtain ⟨Cprofile,Kpush,hC,hKp,he⟩ := actual_first_original_subset_physical_budget + ε hε U g₁ g₂ Φ M₀ (fun _=>0) m₁ m₂ 1 + hM (fun _=>le_rfl) hUs hg₁ hg₂ Aker J + refine ⟨Cprofile,Kpush,hC,hKp,?_⟩ + intro ι _ p hp _ hg hinj hcop hc hpr pool Q labels β cutoff Ψ m mark Γ Ysource Y hΨ hΓ hY hsf hn hβ + k l gate hcutoff T₁ T₂ K theta L hT₁ hT₂ hK hL Benergy Z M r ell V delta aa₁ aa₂ bb rr tq hh eta hB hZ hscale hLe hleft hright + let source := refinedSource p pool Q labels β cutoff Ysource k gate + have hgates := hwin p hp hg pool Q labels Ysource (coefficient p hp hcop hg Ψ m mark true) + (coefficient p hp hcop hg Ψ m mark false) k l T₁ T₂ (fun _=>0) 1 1 (-theta) theta + hT₁ hT₂ (by intro i;simp) le_rfl le_rfl le_rfl le_rfl + have hb := he p hp hg hinj hcop hc hpr pool (refinedOuter p pool Q k gate) (fun x=>x.1) (fun x=>x.2.1) + Ψ Ψ m m (divisorElement p) (fun x=>mark x.1.rightExponent) (fun x=>mark x.1.leftExponent) + (fun _=>commonSelector p (fun _=>1) l) (fun _=>labels) (firstOriginalWeight p β cutoff) (Γ^2) Y + hΨ hΨ (sq_nonneg _) hY (fun _ _=>hsf) (fun _ _=>hn) + (fun x hx=>original_weight_bound p pool Q labels β cutoff Γ Y hΓ hβ x (original_outer_cell_subset p pool Q k (Finset.mem_filter.mp hx).1)) + w₁ w₂ (fun _=>0) 1 1 (-theta) theta (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) + K L hK (rawScales k l T₁ T₂) (rawScales_pos k l T₁ T₂ hT₁ hT₂) + source (refined_source_radius p hp pool Q labels β cutoff Ysource Y k gate hn hcutoff) + (fun x hx=>original_source_positive p hp pool Q labels Ysource x (Finset.mem_filter.mp (Finset.mem_filter.mp hx).1).1) + (by intro i;simp) le_rfl le_rfl le_rfl le_rfl hL + (fun x hx=>hgates.1 x (Finset.mem_filter.mp hx).1) + (fun x hx=>hgates.2.1 x (Finset.mem_filter.mp hx).1) + (fun x hx=>hgates.2.2 x (Finset.mem_filter.mp hx).1) + Benergy hB Z M r ell V delta aa₁ aa₂ bb rr tq hh eta hZ hscale hLe + (by simpa [refinedChildEnergy,rawScales] using hleft) + (by simpa [refinedChildEnergy,rawScales] using hright) + unfold refinedCellRows + unfold SevenEighths.InverseMomentFirstOriginalProfile.coefficient SevenEighths.InverseMomentFirstOriginalProfile.weight + simpa [source,rawScales] using hb + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..5e0b35418d5308dc28175f5627174e6eefe51af8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveIdentity.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseMomentFirstProfileUniform CompletedHeight +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem original_refined_cell_profile_identity (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (β : Ideal O→(ι→₀ℕ)→ℂ) + (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 01) l j.2.1* + sourceSummand p hp hcop hg β cutoff Ψ m mark + (fun y=>normTwistedSource om theta (y/X)) Φ K x j)= + refinedCellRows p hp hcop hg pool Q labels β cutoff Ψ m mark k l gate + (positiveSource (priorityLogWindow om a b ha hsom true) 1 (-theta)) + (positiveSource (priorityLogWindow om a b ha hsom false) 1 theta) Φ K Y s := by + intro source + let W₁ := fun y=>star (normTwistedSource om theta ((s 0*s 2*s 5*s 7)*y/X)) + let W₂ := fun y=>normTwistedSource om theta ((s 1*s 2*s 5*s 8)*y/X) + have he := original_family_profiles p hp hg source pool (fun _=>commonSelector p (fun _=>1) l) + (coefficient p hp hcop hg Ψ m mark true) (coefficient p hp hcop hg Ψ m mark false) + (weight p hp hcop hg β cutoff Ψ m) om a b ha hsom Φ + (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) K X theta + (fun x=>divisorElement p x.1) (fun x=>x.2.2) s hs + (by intro x hx;have hh:=original_source_positive p hp pool Q labels Y x (Finset.mem_filter.mp (refinedSource_subset p pool Q labels β cutoff Y k gate hx)).1 + exact ⟨hh.1,hh.2.1,hh.2.2.1⟩) hX hleft hright + change _=firstFamilyPhysicalRows p hg source pool _ _ _ _ _ _ Φ _ _ _ _ K _ _ s + rw [←he] + have hl : s 0*s 2*s 5*s 7≠0 := hleft.trans_ne (ne_of_gt hX) + have hr : s 1*s 2*s 5*s 8≠0 := hright.trans_ne (ne_of_gt hX) + simp only [firstFamilyPhysicalRows,firstBlockedPhysicalRows,sourceSummand,Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + apply Finset.sum_congr rfl + intro j hj + simp only [firstNormProfile,mul_div_cancel₀ _ hl,mul_div_cancel₀ _ hr] + ring + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveParents.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveParents.lean new file mode 100644 index 0000000000000000000000000000000000000000..f491ec137b146f74df53a5978a6c4a43cd6fc906 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveParents.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy +import OAI.NumberTheory.DirichletL.Descent.OriginalCellPriority + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseFirstPriorityParents InverseFirstGlobalParents +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type} [DecidableEq ι] [DecidableEq σ] + +lemma refined_parent_source (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (selector : FirstOriginalOuter ι→Finset ι→ℂ) (k : SourceIndex) (l j : ℕ) : + globalParentSource (originalSubsetSource (refinedOuter p pool Q k (labelGate p j))) + pool (originalSelector (fun x=>commonSelector p (selector x) l))= + InverseFirstGlobalCaps.labelParentCell p pool Q selector k l j := by + ext x + rw [InverseFirstGlobalCaps.labelParentCell,Finset.mem_filter,InverseFirstGlobalCaps.mem_parentCell] + simp only [globalParentSource,Finset.mem_biUnion,originalSubsetSource,Finset.mem_image,Finset.mem_filter] + constructor + · rintro ⟨y,⟨o,ho,rfl⟩,D,⟨hD,hs⟩,rfl⟩ + have ho' := Finset.mem_filter.mp ho + refine ⟨⟨o,?_,D,hD,by simpa using hs,rfl⟩,?_⟩ + · simpa only [originalOuterCell_eq_caps] using ho'.1 + · simpa [labelGate,fillFirstQuotient,toOriginal,ofOriginal] using ho'.2 + · rintro ⟨⟨o,ho,D,hD,hs,rfl⟩,hj⟩ + refine ⟨ofOriginal o,⟨o,?_,rfl⟩,D,⟨hD,by simpa using hs⟩,rfl⟩ + apply Finset.mem_filter.mpr + refine ⟨?_,?_⟩ + · simpa only [originalOuterCell_eq_caps] using ho + · simpa [labelGate,fillFirstQuotient,toOriginal,ofOriginal] using hj + +theorem refined_child_priority (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l j : ℕ) + (negative : Bool) (Ψ : O→*ℂ) (m : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (om : ℝ→ℂ) (X t Y : ℝ) (hY : 0primeMark slots lists a (v.support∪U)) om X t Y ≤ + globalPriorityOriginalEnergy p hg hp hinj + (fun b=>if negative then b.rightExponent.support else b.leftExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k l j) + (fun x=>(‖commonSelector p (fun _=>1) l x.quotientSupport‖:ℂ)) + negative Ψ m slots lists a om X t Y := by + have he := original_subset_canonical_priority p hp hg hinj hc + (refinedOuter p pool Q k (labelGate p j)) pool (fun _=>commonSelector p (fun _=>1) l) + (fun b=>if negative then b.rightExponent.support else b.leftExponent.support) + negative Ψ m slots lists a om X t Y hY + rw [refined_parent_source] at he + cases negative <;> simpa [refinedChildEnergy,divisorElement] using he + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLivePartition.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLivePartition.lean new file mode 100644 index 0000000000000000000000000000000000000000..963889e328cf72f842ecee095af7e62be9e13bee --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLivePartition.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveSource +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileAssembly + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseSecondSourceBlocks +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +abbrev JointKey := SourceIndex × ℕ × ℕ + +def jointKey (x : OriginalIndex ι) (j : FirstCommonIndex ι) : JointKey := + (sourceIndex (originalNorms p) x,dyadIndex (primeProductNorm p j.2.1), + dyadIndex (InverseFirstGlobalCaps.jNorm p x.1)) + +def liveJointKeys (S : Finset (OriginalIndex ι)) (pool : Finset ι) + (term : OriginalIndex ι→FirstCommonIndex ι→ℂ) : Finset JointKey := + ((S×ˢfirstCommonIndices pool).filter (fun x=>term x.1 x.2≠0)).image + (fun x=>jointKey p x.1 x.2) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma sum_live_joint_cells (S : Finset (OriginalIndex ι)) (pool : Finset ι) + (term : OriginalIndex ι→FirstCommonIndex ι→ℂ) : + (∑x∈S,∑j∈firstCommonIndices pool,term x j)= + ∑k∈liveJointKeys p S pool term,∑x∈S,∑j∈firstCommonIndices pool, + if jointKey p x j=k then term x j else 0 := by + conv_rhs => rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro x hx + conv_rhs => rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro j hj + by_cases hz : term x j=0 + · simp [hz] + · have hk : jointKey p x j∈liveJointKeys p S pool term := + Finset.mem_image.mpr ⟨(x,j),Finset.mem_filter.mpr ⟨Finset.mem_product.mpr ⟨hx,hj⟩,hz⟩,rfl⟩ + simp [hk] + +lemma sourceSummand_zero_of_weight (hp : ∀i,p i≠0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) + (x : OriginalIndex ι) (j : FirstCommonIndex ι) (hx : firstOriginalWeight p β cutoff x.1 x.2=0) : + sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K x j=0 := by + simp [sourceSummand,weight,retainedCubeWeight,hx] + +lemma joint_cell_eq_refined (hp : ∀i,p i≠0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (k : JointKey) : + let S := firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y + let term := sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K + (∑x∈S,∑j∈firstCommonIndices pool,if jointKey p x j=k then term x j else 0)= + ∑x∈refinedSource p pool Q labels β cutoff Y k.1 (labelGate p k.2.2), + ∑j∈firstCommonIndices pool,commonSelector p (fun _=>1) k.2.1 j.2.1*term x j := by + intro S term + simp only [refinedSource,sourceCell,Finset.sum_filter] + apply Finset.sum_congr rfl + intro x hx + by_cases hw : firstOriginalWeight p β cutoff x.1 x.2=0 + · have ht : ∀j,term x j=0 := fun j=>sourceSummand_zero_of_weight p hp hcop hg β cutoff Ψ m mark W Φ K x j hw + simp [ht,hw] + · by_cases hs : sourceIndex (originalNorms p) x=k.1 + · by_cases hj : dyadIndex (InverseFirstGlobalCaps.jNorm p x.1)=k.2.2 + · simp [jointKey,hs,hj,labelGate,hw,Prod.ext_iff,commonSelector,ite_mul] + · simp [jointKey,hs,hj,labelGate,Prod.ext_iff] + · simp [jointKey,hs,Prod.ext_iff] + +theorem original_retained_joint_partition (hp : ∀i,p i≠0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K Y : ℝ) + (s : Fin 9→ℝ) (hs : ∀i,0labels) (fun x=>x.1) Y + let term := sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K + originalRetainedFamily p hp hcop hg pool Q labels β Ψ m mark W Φ K Y cutoff s= + ∑k∈liveJointKeys p S pool term, + ∑x∈refinedSource p pool Q labels β cutoff Y k.1 (labelGate p k.2.2), + ∑j∈firstCommonIndices pool,commonSelector p (fun _=>1) k.2.1 j.2.1*term x j := by + intro S term + rw [original_retained_sum p hp hcop hg pool Q labels β Ψ m mark W Φ K Y cutoff s hs, + sum_live_joint_cells p S pool term] + apply Finset.sum_congr rfl + intro k hk + exact joint_cell_eq_refined p hp hcop hg pool Q labels β cutoff Ψ m mark W Φ K Y k + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..ebd7c836f421e53c662641ae14b16f11ea775999 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveSource.lean @@ -0,0 +1,80 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileParents + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +def refinedOuter (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) + (gate : FirstOriginalOuter ι→Prop) : Finset (FirstOriginalOuter ι) := + (originalOuterCell p pool Q k).filter gate + +def refinedSource (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Y : ℝ) (k : SourceIndex) (gate : FirstOriginalOuter ι→Prop) : Finset (OriginalIndex ι) := + (sourceCell (originalNorms p) + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) k).filter + (fun x=>gate x.1 ∧ firstOriginalWeight p β cutoff x.1 x.2≠0) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma refinedSource_subset (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Y : ℝ) (k : SourceIndex) (gate : FirstOriginalOuter ι→Prop) : + refinedSource p pool Q labels β cutoff Y k gate⊆sourceCell (originalNorms p) + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) k := + Finset.filter_subset _ _ + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma original_weight_frequency (β : Ideal O→(ι→₀ℕ)→ℂ) + (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (x : OriginalIndex ι) (hx : firstOriginalWeight p β cutoff x.1 x.2≠0) : + x.2.2∈reopenedPhysicalCutoff p x.1.1 x.2.1 (cutoff x.1.1 x.1.2.1 x.2.1) x.1.2.2 := by + by_contra hh + exact hx (by simp [firstOriginalWeight,hh]) + +theorem refined_source_radius (hp : ∀i,p i≠0) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ysource Ychild : ℝ) (k : SourceIndex) (gate : FirstOriginalOuter ι→Prop) + (hn : ∀I∈labels,I≠0) + (hcut : ∀x∈refinedOuter p pool Q k gate,∀I∈labels,cutoff x.1 x.2.1 I x.2.2≤Ychild) : + refinedSource p pool Q labels β cutoff Ysource k gate⊆ + firstGlobalRetainedSource p (refinedOuter p pool Q k gate) (fun _=>labels) (fun x=>x.1) Ychild := by + intro x hx + obtain ⟨hxcell,hgate,hweight⟩ := Finset.mem_filter.mp hx + have hxold := original_cell_subset p pool Q labels Ysource k hxcell + obtain ⟨ho,hf⟩ := Finset.mem_sigma.mp hxold + have hm := (mem_firstRetainedSource p labels x.1.1 Ysource x.2).mp hf + have houter : x.1∈refinedOuter p pool Q k gate := Finset.mem_filter.mpr ⟨ho,hgate⟩ + have hE := firstPhysicalMultiplier_ne_zero p hp x.1.1.support x.1.1.leftExponent x.1.1.rightExponent + x.1.1.leftBit x.1.1.rightBit x.2.1 (hn x.2.1 hm.1) + apply Finset.mem_sigma.mpr + refine ⟨houter,(mem_firstRetainedSource p labels x.1.1 Ychild x.2).mpr ⟨hm.1,?_⟩⟩ + apply Finset.mem_erase.mpr + refine ⟨(Finset.mem_erase.mp hm.2).1,?_⟩ + apply (mem_childFrequencyBall _ hE Ychild x.2.2).mpr + exact ((mem_childFrequencyBall _ hE _ x.2.2).mp + (original_weight_frequency p β cutoff x hweight)).trans (hcut x.1 houter x.2.1 hm.1) + +def labelGate (j : ℕ) (x : FirstOriginalOuter ι) : Prop := + InverseSecondSourceBlocks.dyadIndex (InverseFirstGlobalCaps.jNorm p x)=j + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma refinedOuter_label (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (j : ℕ) : + refinedOuter p pool Q k (labelGate p j)= + (InverseFirstGlobalCaps.outerCell p pool Q k).filter + (fun x=>InverseSecondSourceBlocks.dyadIndex (InverseFirstGlobalCaps.jNorm p x)=j) := by + rw [refinedOuter,originalOuterCell_eq_caps] + ext x + simp [labelGate] + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveSupport.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..3359fde6111757c8c76f5243efa7deef6597eea6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileLiveSupport.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveCount +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstLiveNorms + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] +variable (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) +variable (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def liveNormCap (L B Y : ℝ) : ℝ := max Y (max L (max (L*B^2) (B^2))) + +theorem original_live_joint_card (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (Y : ℝ) (β : Ideal O→(ι→₀ℕ)→ℂ) + (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K L B : ℝ) + (hB : 0≤B) (hQ : ∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤B) + (hlabels : ∀I∈labels,I≠0) (hW : ∀y,W y≠0→y≤L) : + (liveJointKeys p + (firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y) pool + (sourceSummand p hp hcop hg β cutoff Ψ m mark W Φ K)).card≤ + (dyadIndex (liveNormCap L B Y)+1)^8 := by + apply liveJointKeys_card_of_norm_cap + intro x hx j hj hn + obtain ⟨h₁,h₂,h₃⟩ := InverseMomentFirstLiveCaps.original_live_norm_caps p hp hcop hg + pool Q labels Y β cutoff Ψ m mark W Φ K L B hB hQ hlabels hW x hx j hn + have hc : ∀i : Fin 6,(![L,L,L,L*B^2,B^2,Y] : Fin 6→ℝ) i≤liveNormCap L B Y := by + intro i + fin_cases i <;> simp [liveNormCap,le_max_iff] + refine ⟨fun i=>⟨lt_of_lt_of_le zero_lt_one (original_source_norms_ge_one p hp pool Q labels Y x hx i),(h₁ i).trans (hc i)⟩,?_,?_⟩ + · exact ⟨primeProductNorm_pos p hp _,h₂.trans (le_max_of_le_right (le_max_left _ _))⟩ + · refine ⟨lt_of_lt_of_le zero_lt_one (element_norm_ge_one _ (primeProduct_ne_zero p hp _ _)),?_⟩ + exact h₃.trans (le_max_of_le_right (le_max_of_le_right (le_max_right _ _))) + +theorem original_twisted_live_joint_card (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (Y : ℝ) (β : Ideal O→(ι→₀ℕ)→ℂ) + (cutoff : CubeCoordinates ι→Finset ι→Ideal O→Finset ι→ℝ) + (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K b B X theta : ℝ) + (hX : 0labels) (fun x=>x.1) Y) pool + (sourceSummand p hp hcop hg β cutoff Ψ m mark + (fun y=>CompletedHeight.normTwistedSource W theta (y/X)) Φ K)).card≤ + (dyadIndex (liveNormCap (b*X) B Y)+1)^8 := by + apply original_live_joint_card p hp hcop hg pool Q labels Y β cutoff Ψ m mark _ Φ K (b*X) B hB hQ hlabels + intro y hy + have hwy : W (y/X)≠0 := by + intro hz + exact hy (by simp [CompletedHeight.normTwistedSource,hz]) + exact (div_le_iff₀ hX).mp (hW _ hwy) + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileParents.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileParents.lean new file mode 100644 index 0000000000000000000000000000000000000000..fa9fbee1c51a560d2c5fce0de0ebb0d1892a22a7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileParents.lean @@ -0,0 +1,41 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileCellEnergy +import OAI.NumberTheory.DirichletL.Inversion.FirstGlobalCaps + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment InverseMomentFirstChildWindows ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma originalNorms_eq_caps : originalNorms p=InverseFirstGlobalCaps.originalNorms p := by + funext x i + fin_cases i <;> rfl + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma originalOuterCell_eq_caps (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) : + originalOuterCell p pool Q k=InverseFirstGlobalCaps.outerCell p pool Q k := by + unfold originalOuterCell InverseFirstGlobalCaps.outerCell InverseFirstGlobalCaps.outerGate + ext x + simp only [Finset.mem_filter,originalNorms_eq_caps,InverseFirstGlobalCaps.originalNorms_outer] + +lemma originalChildEnergy_eq_caps (hp : ∀i,p i≠0) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (k : SourceIndex) (l : ℕ) + (negative : Bool) (Ψ : O→*ℂ) (m : O) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (omega : ℝ→ℂ) (T t Y : ℝ) : + originalChildEnergy p hp hg hinj pool Q k l negative Ψ m mark omega T t Y= + ∑x∈InverseFirstGlobalCaps.outerCell p pool Q k, + firstCanonicalSecondEnergy p hp hg hinj pool x.1 x.2.1 negative Ψ m (divisorElement p x) + (mark (if negative then x.1.rightExponent else x.1.leftExponent)) + (commonSelector p (fun _=>1) l) omega T t Y := by + rw [originalChildEnergy,originalOuterCell_eq_caps] + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfilePhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfilePhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..11fd7bd5ded57ed073b1ad70c7515e91ca923003 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfilePhysical.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileFiltered +import OAI.NumberTheory.DirichletL.Descent.FirstHeightBudget + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +open InverseMomentFirstProfileUniform InverseAmbientProfileTower +theorem actual_first_original_subset_physical_budget (ε : ℝ) (hε : 0<ε) + (U₀ : Fin 9 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 9 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ Cprofile Kpush : ℝ,0 ≤ Cprofile ∧ 0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀ i,ringChar (Eis⧸Ideal.span {p i})≠2) + (_hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F : Finset ι) (outer:Finset κ) (b : κ→SecondPassArithmetic.CubeCoordinates ι) (common : κ→Finset ι) + (Ψ₁ Ψ₂ : Eis→*ℂ) (mleft mright : Eis) (dd:κ→Eis) (H₁ H₂ selector : κ→Finset ι→ℂ) + (labels : κ→Finset (Ideal Eis)) (a : κ→Ideal Eis×Eis→ℂ) (Γ Y : ℝ) + (_hΨ₁ : ∀ u,‖Ψ₁ u‖≤1) (_hΨ₂ : ∀ u,‖Ψ₂ u‖≤1) + (_hΓ : 0≤Γ) (_hY : 0 firstCanonicalCoefficient p hp hcop hg (b x.1) (common x.1) true Ψ₁ mleft (dd x.1) (H₁ x.1) x.2 + let C₂ := fun x : (Σ _ : κ,Ideal Eis×Eis) => firstCanonicalCoefficient p hp hcop hg (b x.1) (common x.1) false Ψ₂ mright (dd x.1) (H₂ x.1) x.2 + let w := fun x : (Σ _ : κ,Ideal Eis×Eis) => retainedCubeWeight p hp hcop hg (b x.1) (common x.1) Ψ₁ Ψ₂ mleft mright (dd x.1) (a x.1) x.2 + ∀ (_hpos : ∀ x∈source,0Z^(![aa₁,aa₂,bb,delta,rr,tq,hh,r-aa₁-bb-tq,r-aa₂-bb-tq] i)) + (_hLe:L=eta*Real.log Z) + (_hleft : ∀ z : Frequency × (Fin 9 → ℝ), + (Z^(firstKappa M r ell V delta aa₁ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + (∑k∈outer,firstCanonicalSecondEnergy p hp hg hinj F (b k) (common k) true Ψ₁ mleft (dd k) (H₁ k) (selector k) ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) Y) ≤ + Benergy*(tripleHeight J z.1*coordinateHeight J z.2)) + (_hright : ∀ z : Frequency × (Fin 9 → ℝ), + (Z^(firstKappa M r ell V delta aa₂ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + (∑k∈outer,firstCanonicalSecondEnergy p hp hg hinj F (b k) (common k) false Ψ₂ mright (dd k) (H₂ k) (selector k) ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) Y) ≤ + Benergy*(tripleHeight J z.1*coordinateHeight J z.2)), + (Z^(-r-2*ell-V)*Z^M)*‖firstFamilyPhysicalRows p hg source F (fun x=>selector x.1) C₁ C₂ w (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) Φ A₁ A₂ C R K (fun x=>dd x.1) (fun x=>x.2.2) s‖ ≤ + ((Γ*Kpush*Y^ε*Benergy)*(Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker)) := by + obtain ⟨Cprofile,Kpush,hCprofile,hKpush,he⟩:=actual_first_original_subset_two_energies ε hε + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + refine ⟨Cprofile,Kpush,hCprofile,hKpush,?_⟩ + intro ι κ _ _ p hp _ hg hinj hcop hc hpr F outer b common Ψ₁ Ψ₂ mleft mright dd H₁ H₂ selector labels a Γ Y + hΨ₁ hΨ₂ hΓ hY hlabels hn ha ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ A₁ A₂ C R K L hK s hs selected hselected + source C₁ C₂ w hpos hρ hc₁ hc₂ hc₁b hc₂b hL hω₁ hω₂ hcut Benergy hBenergy + Z M r ell V delta aa₁ aa₂ bb rr tq hh eta hZ hscale hLe hleft hright + let P₁:=Z^(firstKappa M r ell V delta aa₁ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let P₂:=Z^(firstKappa M r ell V delta aa₂ bb rr)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + have hp₁:0Z^(![Real.logb Z (dyadScale (k 0)), + Real.logb Z (dyadScale (k 1)),Real.logb Z (dyadScale (k 2)), + Real.logb Z (dyadScale (k 3)),Real.logb Z (dyadScale (k 4)),Real.logb Z (dyadScale l), + Real.logb Z (dyadScale (k 5)), + r-Real.logb Z (dyadScale (k 0))-Real.logb Z (dyadScale (k 2))-Real.logb Z (dyadScale l), + r-Real.logb Z (dyadScale (k 1))-Real.logb Z (dyadScale (k 2))-Real.logb Z (dyadScale l)] i) := by + have hz : 0 simp [physicalScales,rawScales,he,Real.rpow_sub hz,div_div] + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..8ed5b3096b5f45b3092b71f8830b1438d6781632 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileUniform.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstUnequalPhysicalEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstGlobalPush + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +open InverseMomentFirstProfileUniform InverseAmbientProfileTower +theorem actual_first_moving_family_two_energies_uniform + (U₀ : Fin 9 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 9 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ Cprofile : ℝ,0 ≤ Cprofile ∧ ∀ {ι κ : Type*} [DecidableEq ι] (p : ι → Eis) (_hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (source : Finset κ) (F : Finset ι) (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (A₁ A₂ C R : κ → ℝ) (K L : ℝ) (_hK : 0 < K) (d h : κ → Eis) (s : Fin 9 → ℝ) + (_hpos : ∀ x∈source,0 < A₁ x ∧ 0 < A₂ x ∧ 0 < C x ∧ 0 < R x ∧ d x ≠ 0 ∧ h x ≠ 0) + (_hs : ∀ i,0 < s i) + (_hρ : ∀ i,|ρ i| ≤ B₀ i) (_hc₁ : 1 ≤ c₁) (_hc₂ : 1 ≤ c₂) + (_hc₁b : c₁ ≤ bcap) (_hc₂b : c₂ ≤ bcap) (_hL : 0 ≤ L) + (_hω₁ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + (positiveSource g₁ c₁ θ₁) (A₁ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.1/(s 0*s 2*s 5*s 7)) ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) = 1) + (_hω₂ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + (positiveSource g₂ c₂ θ₂) (A₂ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.2/(s 1*s 2*s 5*s 8)) ≠ 0 → + ω₂ (primeProductNorm p j.2.2.2/s 8) = 1) + (_hcut : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) ≠ 0 → ω₂ (primeProductNorm p j.2.2.2/s 8) ≠ 0 → + ∀ i,U₀ i ((firstRelativeLog (firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j) s i)+ρ i) = 1) + (B₁ B₂ : ℝ) (_hB₁ : 0 ≤ B₁) (_hB₂ : 0 ≤ B₂) + (_hleft : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) h ≤ + B₁*(tripleHeight J z.1*coordinateHeight J z.2)) + (_hright : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) h ≤ + B₂*(tripleHeight J z.1*coordinateHeight J z.2)), + ‖firstFamilyPhysicalRows p hg source F selector C₁ C₂ w (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) Φ A₁ A₂ C R K d h s‖ ≤ + (Real.exp ((9/2:ℝ)*L)/firstRootScale s)* + ((Real.sqrt B₁*Real.sqrt B₂)*(Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker)) := by + obtain ⟨Cprofile,hCprofile,hmeasure⟩ := InverseMomentFirstProfileUniform.first_profile_common_measure + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + refine ⟨Cprofile,hCprofile,?_⟩ + intro ι κ _ p hp _ hg source F selector C₁ C₂ w ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ + A₁ A₂ C R K L hK d h s hpos hs hρ hc₁ hc₂ hc₁b hc₂b hL + hω₁ hω₂ hcut B₁ B₂ hB₁ hB₂ hleft hright + have hRad : 0 < K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8) := by + exact div_pos (mul_pos hK (hs 6)) + (mul_pos (mul_pos (mul_pos (mul_pos (hs 3) (hs 4)) (sq_pos_of_pos (hs 5))) (hs 7)) (hs 8)) + obtain ⟨b₃,hb₃⟩ := hmeasure (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) hRad + obtain ⟨hsep,hWeighted,hMoment⟩ := hb₃ ρ c₁ c₂ θ₁ θ₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + let g := fun i => rooted (U₀ i) (M₀ i) (InverseClippingProfiles.firstBalancedSlope i) (hU i) + let f₁ := rooted g₁ m₁ (-(1/2:ℝ)) hg₁ + let f₂ := rooted g₂ m₂ (-(1/2:ℝ)) hg₂ + let den := density g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have hden : Integrable den := first_balanced_density_integrable g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have he := actual_first_family_two_energies p hg hp source F selector C₁ C₂ w + (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) ω₁ ω₂ Φ (fun i y => U₀ i (y+ρ i)) + A₁ A₂ C R K L d h s hpos hs den hden hsep hω₁ hω₂ hcut + J B₁ B₂ hB₁ hB₂ hWeighted hleft hright + have hd : (∫ z : Frequency × (Fin 9 → ℝ),tripleHeight J z.1*coordinateHeight J z.2*‖den z‖) ≤ + Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker := by + apply (le_div_iff₀ (pow_pos (by linarith : 0 < 1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) Aker)).mpr + exact (mul_comm _ _).le.trans hMoment + exact he.trans (mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hd (mul_nonneg (Real.sqrt_nonneg _) (Real.sqrt_nonneg _))) + (by have := firstRootScale_pos s hs; positivity)) + +theorem first_global_retained_push_uniform (ε:ℝ)(hε:0<ε): + ∃ K:ℝ,0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F:Finset ι)(outer:Finset κ)(cube:κ→CubeCoordinates ι)(common:κ→Finset ι) + (Ψ₁ Ψ₂:Eis→*ℂ)(m₁ m₂:Eis)(d:κ→Eis) + (labels:κ→Finset (Ideal Eis))(a:κ→Ideal Eis×Eis→ℂ)(Γ Y:ℝ), + (∀u,‖Ψ₁ u‖≤1)→(∀u,‖Ψ₂ u‖≤1)→0≤Γ→0selector x.1) + (fun x=>firstCanonicalCoefficient p hp hcop hg (cube x.1) (common x.1) negative + (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) (d x.1) (H x.1) x.2) + (fun x=>retainedCubeWeight p hp hcop hg (cube x.1) (common x.1) Ψ₁ Ψ₂ m₁ m₂ + (d x.1) (a x.1) x.2) + negative ω X t (fun x=>x.2.2) ≤ + Γ*K*Y^ε*∑k∈outer,firstCanonicalSecondEnergy p hp hg hinj F (cube k) (common k) + negative (if negative then Ψ₁ else Ψ₂) (if negative then m₁ else m₂) (d k) + (H k) (selector k) ω X t Y := by + obtain ⟨K,hK,hpush⟩:=first_retained_actual_second_energy ε hε + refine ⟨K,hK,?_⟩ + intro ι κ _ _ p hp _ hinj hcop hg hc hpr F outer cube common Ψ₁ Ψ₂ m₁ m₂ d labels a Γ Y + hΨ₁ hΨ₂ hΓ hY hs hn ha negative H selector ω X t hX + simp only [firstFamilyEnergy,firstGlobalRetainedSource,Finset.sum_sigma] + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro k hk + exact hpush p hp hinj hcop hg hc hpr F (cube k) (common k) Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ + (d k) (labels k) (a k) Γ Y hΓ hY (hs k hk) (hn k hk) (ha k hk) + negative (H k) (selector k) ω X t hX + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileWindows.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileWindows.lean new file mode 100644 index 0000000000000000000000000000000000000000..b92d5ef4e4e2f9b76d9a1c026da61ce7820358fa --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstOriginalProfileWindows.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileCells + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstOriginalProfile +open InverseMoment ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseMomentFirstChildWindows InverseMomentFirstProfileUniform +local notation "O" => ActualEisensteinCubic.O +theorem original_cell_windows (g₁ g₂ : 𝓢(ℝ,ℂ)) (m₁ m₂ bcap : ℝ) + (Bρ : Fin 9→ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) + (hg₁ : Function.support g₁⊆Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂⊆Set.Icc (-m₂) m₂) + (hBρ : ∀i,0≤Bρ i) : + ∃(w₁ w₂ : 𝓢(ℝ,ℂ))(U₀ : Fin 9→𝓢(ℝ,ℂ))(M₀ : Fin 9→ℝ)(a b : ℝ), + 0labels) (fun x=>x.1) Y) k + let F := pool + let selector : OriginalIndex ι→Finset ι→ℂ := fun _=>commonSelector p (fun _=>1) l + let A₁ := leftNorm p + let A₂ := rightNorm p + let C := commonNorm p + let R := activeNorm p + let d := fun x : OriginalIndex ι=>divisorElement p x.1 + let h := fun x : OriginalIndex ι=>x.2.2 + let s := rawScales k l T₁ T₂ + (∀x∈source,∀j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j≠0 → + positiveSource g₁ c₁ θ₁ (A₁ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.1/(s 0*s 2*s 5*s 7))≠0 → + w₁ (primeProductNorm p j.2.2.1/s 7)=1) ∧ + (∀x∈source,∀j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j≠0 → + positiveSource g₂ c₂ θ₂ (A₂ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.2/(s 1*s 2*s 5*s 8))≠0 → + w₂ (primeProductNorm p j.2.2.2/s 8)=1) ∧ + (∀x∈source,∀j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j≠0 → + w₁ (primeProductNorm p j.2.2.1/s 7)≠0 → w₂ (primeProductNorm p j.2.2.2/s 8)≠0 → + ∀i,U₀ i (firstRelativeLog (firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j) s i+ρ i)=1) := by + obtain ⟨w₁,w₂,U,M,a,b,ha,hab,hwc₁,hwc₂,hws₁,hws₂,hM,hUc,hUs,he⟩ := + actual_first_child_windows g₁ g₂ m₁ m₂ bcap (fun _=>1) (fun _=>2) Bρ + hm₁ hm₂ hg₁ hg₂ (by intro i;norm_num) (by intro i;norm_num) hBρ + refine ⟨w₁,w₂,U,M,a,b,ha,hab,hwc₁,hwc₂,hws₁,hws₂,hM,hUc,hUs,?_⟩ + intro ι _ p hp _ hg pool Q labels Y C₁ C₂ k l T₁ T₂ ρ c₁ c₂ θ₁ θ₂ + hT₁ hT₂ hρ hc₁ hcb₁ hc₂ hcb₂ source F selector A₁ A₂ C R d h s + apply he p hp hg source F selector C₁ C₂ A₁ A₂ C R d h s ρ c₁ c₂ θ₁ θ₂ + (rawScales_pos k l T₁ T₂ hT₁ hT₂) hρ hc₁ hcb₁ hc₂ hcb₂ + intro x hx j hj hn + exact actual_original_cell_ratios p hp hg _ (fun _ _=>1) C₁ C₂ + (leftNorm p) (rightNorm p) (commonNorm p) (activeNorm p) + (fun x=>divisorElement p x.1) (fun x=>x.2.2) + (original_source_norms_ge_one p hp pool Q labels Y) k l T₁ T₂ x hx j hn + +end SevenEighths.InverseMomentFirstOriginalProfile +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstPass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPass.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f11e5396a7fcfa03dde0a940377ec5a9ab40264 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPass.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondPass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open FirstCauchyArithmetic RayFourExpansion +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +omit [DecidableEq σ] in +theorem marked_dilatedCoreRow_eq_input_family + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda ^ 2 ∣ p i - 1) + (F D B A : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (H : Finset ι → ℂ) (V : ℝ → ℂ) (y : Finset ι → ℝ) + (c d : Eis) (t : ℝ) (z : Eis) : + dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative χ + (multiplicativeCoreColumn p Ψ m (fun U => primeMark slots lists a (A ∪ U) * H U)) + V y c d t z = + ∑ r : FirstCoreIndex, firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r * + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U => primeMark slots lists a (A ∪ U) * H U) V y c d r t z := + dilatedCoreRow_eq_input_family p hp hcop hg hc hpr F D B v ε₁ ε₂ negative χ Ψ m _ V y c d t z + +theorem firstCoreInputRow_marked_priority + (F D B A : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (H : Finset ι → ℂ) (V : ℝ → ℂ) (y : Finset ι → ℝ) + (c d : Eis) (r : FirstCoreIndex) (t : ℝ) (z : Eis) : + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U => primeMark slots lists a (A ∪ U) * H U) V y c d r t z = + ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ D) * + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U => primeMark (slots \ J) (fun i => lists i \ (A ∪ D)) a U * H U) + V y c d r t z := by + unfold firstCoreInputRow inputConjugateRow supportConjugateSum + simp only [Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro U hU + have he := primeMark_priority slots lists a (A ∪ D) U + simp only [primeMark_residual_lists] at he + have hset : (D ∪ U) \ (A ∪ D) = U \ (A ∪ D) := by + ext i + simp only [Finset.mem_sdiff, Finset.mem_union] + tauto + simp only [secondInputCoefficient, firstCoreTest, ← Finset.union_assoc] + rw [he] + simp only [Finset.sum_mul, Finset.mul_sum, ← primeMark_residual_lists, hset] + apply Finset.sum_congr rfl + intro J hJ + ring + +theorem firstCoreInputRow_fixed_pool + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (H : Finset ι → ℂ) (V : ℝ → ℂ) (y : Finset ι → ℝ) + (c d : Eis) (r : FirstCoreIndex) (t : ℝ) (z : Eis) : + firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m H V y c d r t z = + inputConjugateRow p hg F (firstCoreTwist negative χ Ψ r) + ((m * b0Label p B v ε₁ ε₂) * ∏ i ∈ D, p i) + (c * jLabel p B v ε₁ ε₂) d (firstCoreTest H V y negative t D) + (if negative then -z else z) := + inputConjugateRow_fixed_pool p hg hinj F D _ _ _ _ _ _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalCommon.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalCommon.lean new file mode 100644 index 0000000000000000000000000000000000000000..eeeec42cc007fcdb9a2ac1dab262fba9e99514bb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalCommon.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCommonProfile + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstCommonCoefficient (C₁ C₂ : Finset ι → ℂ) + (r : RayCharacter × RayCharacter) (D U V : Finset ι) (h : Eis) : ℂ := + star (supportMobius (fun i => Ideal.span {p i}) U * + (star (supportRay p r.1 (D ∪ U))*C₁ (D ∪ U)) * + star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg U h)) * + (supportMobius (fun i => Ideal.span {p i}) V * + (supportRay p r.2 (D ∪ V)*C₂ (D ∪ V)) * + star (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg V h)) + +def firstPhysicalCommonRows (F : Finset ι) (C₁ C₂ : Finset ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R K : ℝ) (d h : Eis) : ℂ := + ∑ r : RayCharacter × RayCharacter, crossCoeff r.1 r.2 * + ∑ D ∈ F.powerset, supportMobius (fun i => Ideal.span {p i}) D * + rowCoprimeMask (fun i => Ideal.span {p i}) D h * + ∑ U ∈ (F \ D).powerset, ∑ V ∈ (F \ D).powerset, + firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + ![A₁,A₂,C,‖eisEmbedding d‖^2,R,primeProductNorm p D, + ‖eisEmbedding h‖^2,primeProductNorm p U,primeProductNorm p V] * + firstCommonCoefficient p hg C₁ C₂ r D U V h + +theorem actual_first_physical_common + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F B : Finset ι) (hFB : Disjoint F B) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C K : ℝ) (d h : Eis) : + (‖eisEmbedding d‖^2 : ℂ)⁻¹ * + (∑ N ∈ F.powerset, ∑ P ∈ F.powerset, if Disjoint N P then + canonicalPairMode p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ Φ + (fun y => W₁ (A₁*C*Real.exp y)) (fun y => W₂ (A₂*C*Real.exp y)) 1 1 K d h else 0) = + (K:ℂ) * cubeBaseFactor p hp hg B v ε₁ ε₂ d h * + firstPhysicalCommonRows p hg F + (cubeMinusCoefficient p hp hcop hg B v ε₁ ε₂ C₁ d) + (cubePlusCoefficient p hp hcop hg B v ε₁ ε₂ C₂ d) + W₁ W₂ Φ A₁ A₂ C (primeProductNorm p (cubeActiveSupport B v ε₁ ε₂)) K d h := by + let R := primeProductNorm p (cubeActiveSupport B v ε₁ ε₂) + let H := fun N P : Finset ι => firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + ![A₁,A₂,C,‖eisEmbedding d‖^2,R,1,‖eisEmbedding h‖^2,primeProductNorm p N,primeProductNorm p P] + calc + _ = (K:ℂ) * (∑ N ∈ F.powerset, ∑ P ∈ F.powerset, if Disjoint N P then + H N P*threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h else 0) := by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro P hP + by_cases hd : Disjoint N P + · simp only [hd,ite_true] + simpa only [H,R,mul_assoc] using canonicalPairMode_whole_profile p hp hcop hg + N P B hd (hFB.mono_left (Finset.mem_powerset.mp hN)) + (hFB.mono_left (Finset.mem_powerset.mp hP)) v ε₁ ε₂ C₁ C₂ W₁ W₂ Φ A₁ A₂ C K d h + · simp [hd] + _ = _ := by + rw [actual_first_gauss_coupled_reindex p hp hcop hg hinj hc hpr F B hFB] + rw [mul_assoc] + apply congrArg (fun z : ℂ => (K:ℂ)*(cubeBaseFactor p hp hg B v ε₁ ε₂ d h*z)) + unfold firstCoupledRayColumns firstPhysicalCommonRows + apply Finset.sum_congr rfl + intro r hr + apply congrArg (fun z : ℂ => crossCoeff r.1 r.2*z) + apply Finset.sum_congr rfl + intro D hD + apply congrArg (fun z : ℂ => supportMobius (fun i => Ideal.span {p i}) D * + rowCoprimeMask (fun i => Ideal.span {p i}) D h*z) + apply Finset.sum_congr rfl + intro U hU + apply Finset.sum_congr rfl + intro V hV + have hDU : Disjoint D U := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hU) disjoint_sdiff_self_right + have hDV : Disjoint D V := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hV) disjoint_sdiff_self_right + dsimp only [H] + rw [firstNormProfile_actual_common p hp D U V hDU hDV] + simp only [firstCommonCoefficient,R,mul_assoc] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalCutoff.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..9268c79fa96a517372064dbb7e6ce8048b2dc3e8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalCutoff.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCutoffScale + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +def firstPhysicalMultiplier {ι : Type*} (p : ι→O) (S : Finset ι) + (v₁ v₂ : ι→ℕ) (ε₁ ε₂ : ι→Bool) (f : Ideal O) : O := + (ConcretePrimeRowBridge.idealGenerator f)^2 * dilationLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂ + +lemma firstPhysicalMultiplier_ne_zero {ι : Type*} (p : ι→O) (hp : ∀ i,p i≠0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (S : Finset ι) (v₁ v₂ : ι→ℕ) (ε₁ ε₂ : ι→Bool) (f : Ideal O) (hf : f≠0) : + firstPhysicalMultiplier p S v₁ v₂ ε₁ ε₂ f≠0 := + mul_ne_zero (pow_ne_zero _ (ConcretePrimeRowBridge.idealGenerator_ne_zero f hf)) + (primeProduct_ne_zero p hp _ _) + +lemma firstPhysicalMultiplier_row {ι : Type*} (p : ι→O) (S : Finset ι) + (v₁ v₂ : ι→ℕ) (ε₁ ε₂ : ι→Bool) (f : Ideal O) (h : O) : + firstPhysicalMultiplier p S v₁ v₂ ε₁ ε₂ f*h = + DescentWeightedCauchy.firstElementRowMap (dilationLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂) (f,h) := by + unfold firstPhysicalMultiplier DescentWeightedCauchy.firstElementRowMap + ring + +theorem first_physical_cutoff_raw_tail {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (S N Q : Finset ι) (v₁ v₂ : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (hv : ∀ i∈S,0v₁ i+v₂ i) ε₁ ε₂)‖^2) + (hcol₁ : ‖eisEmbedding (aLabel p S ε₁)‖^2*primeProductNorm p common*primeProductNorm p N≤Z^(r+eta)) + (hcol₂ : ‖eisEmbedding (aLabel p S ε₂)‖^2*primeProductNorm p common*primeProductNorm p Q≤Z^(r+eta)) + (hout : h∉childFrequencyBall (firstPhysicalMultiplier p S v₁ v₂ ε₁ ε₂ f) + (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau))) : + Z^tau ≤ (Z^M/(primeProductNorm p divisor * + primeProductNorm p ((N∪Q)∪cubeActiveSupport S (fun i=>v₁ i+v₂ i) ε₁ ε₂)))*‖eisEmbedding h‖^2 := by + by_contra hbad + have hratio := (lt_of_not_ge hbad).le + have hrow := first_ratio_canonical_row p hp S N Q v₁ v₂ ε₁ ε₂ hv hNQ hNS hQS common divisor f h + Z M r ell V delta B j eta tau hZ hb₁ hb₂ hf hd hc hj hcol₁ hcol₂ hratio + apply hout + apply (mem_childFrequencyBall _ (firstPhysicalMultiplier_ne_zero p hp S v₁ v₂ ε₁ ε₂ f hf0) _ h).mpr + simpa only [firstPhysicalMultiplier_row] using hrow + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalFamily.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..0136832ac35bedd9be8ae9a3cf28da5e61d7184e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalFamily.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCanonicalEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstFamilySource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstCanonicalCoefficient (b : CubeCoordinates ι) (C : Finset ι) + (negative : Bool) (Ψ : O→*ℂ) (m d : O) (H : Finset ι→ℂ) (x : Ideal O×O) : Finset ι→ℂ := + firstBareCubeCoefficient p hp hg hcop b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative + (canonicalCubeResidual p hg b C negative Ψ m (ConcretePrimeRowBridge.idealGenerator x.1) H) d + +theorem firstCanonicalCoefficient_old (b : CubeCoordinates ι) (C : Finset ι) + (negative : Bool) (Ψ : O→*ℂ) (m d : O) (H : Finset ι→ℂ) (x : Ideal O×O) : + firstCanonicalCoefficient p hp hcop hg b C negative Ψ m d H x = + firstOldLabelCoefficient p hp hcop hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative + (multiplicativeCoreColumn p Ψ m + (fun U=>H (((if negative then b.rightDivisor else b.leftDivisor)∪C)∪U))) + (∏i∈C,p i) d x.1 := rfl + +lemma first_unblocked_physical (F : Finset ι) (C₁ C₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C R K : ℝ) (d h : O) : + firstBlockedPhysicalRows p hg F (fun _=>1) C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h = + firstPhysicalCommonRows p hg F C₁ C₂ W₁ W₂ Φ A₁ A₂ C R K d h := by + rw [firstPhysicalCommonRows_indexed] + simp only [firstBlockedPhysicalRows,one_mul] + +theorem retained_first_physical_family (pool : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ d : O) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) + (source : Finset (Ideal O×O)) (a : Ideal O×O→ℂ) + (s : Fin 9→ℝ) (hs : ∀ i,01) + (firstCanonicalCoefficient p hp hcop hg b C true Ψ₁ m₁ d H₁) + (firstCanonicalCoefficient p hp hcop hg b C false Ψ₂ m₂ d H₂) + (retainedCubeWeight p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ d a) + (fun x=>star (W₁ ((s 0*s 2*s 5*s 7)*x))) + (fun x=>W₂ ((s 1*s 2*s 5*s 8)*x)) Φ + (fun _=>‖eisEmbedding (aLabel p b.support b.rightBit)‖^2) + (fun _=>‖eisEmbedding (aLabel p b.support b.leftBit)‖^2) + (fun _=>primeProductNorm p C) + (fun _=>primeProductNorm p (cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)) + K (fun _=>d) Prod.snd s := by + have hscale₁ : s 0*s 2*s 5*s 7≠0 := mul_ne_zero (mul_ne_zero (mul_ne_zero (hs 0).ne' (hs 2).ne') (hs 5).ne') (hs 7).ne' + have hscale₂ : s 1*s 2*s 5*s 8≠0 := mul_ne_zero (mul_ne_zero (mul_ne_zero (hs 1).ne' (hs 2).ne') (hs 5).ne') (hs 8).ne' + have hw₁ : (fun y=>star (W₁ ((s 0*s 2*s 5*s 7)*(y/(s 0*s 2*s 5*s 7))))) = + fun y=>star (W₁ y) := by + funext y + rw [mul_div_cancel₀ _ hscale₁] + have hw₂ : (fun y=>W₂ ((s 1*s 2*s 5*s 8)*(y/(s 1*s 2*s 5*s 8)))) = W₂ := by + funext y + rw [mul_div_cancel₀ _ hscale₂] + simp only [firstFamilyPhysicalRows,Finset.mul_sum,hw₁,hw₂] + apply Finset.sum_congr rfl + intro x hx + rw [first_unblocked_physical p hg] + simp only [firstCubePhysicalMode,retainedCubeWeight,firstCanonicalCoefficient, + firstBareCubeCoefficient,Bool.false_eq_true,ite_false,ite_true] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..18ec87f6a5fe636ce5d555b26310091f7bf0487f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPhysicalTail.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstPhysicalCutoff +import OAI.NumberTheory.DirichletL.Descent.FirstWholeTail + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem full_first_physical_tail (order : ℕ) : + ∃ (s : Finset (ℕ×ℕ)) (Ct : ℝ),0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hchar : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (pool S common divisor : Finset ι) (v₁ v₂ : ι→ℕ) (ε₁ ε₂ : ι→Bool), + (∀ i∈S,0v₁ i+v₂ i) ε₁ ε₂)‖^2 → + (∀ N∈pool.powerset,C₁ N≠0 → + ‖eisEmbedding (aLabel p S ε₂)‖^2*primeProductNorm p common*primeProductNorm p N≤Z^(r+eta)) → + (∀ Q∈pool.powerset,C₂ Q≠0 → + ‖eisEmbedding (aLabel p S ε₁)‖^2*primeProductNorm p common*primeProductNorm p Q≤Z^(r+eta)) → + let U₁ := Z^(r+eta)/(‖eisEmbedding (aLabel p S ε₂)‖^2*primeProductNorm p common) + let U₂ := Z^(r+eta)/(‖eisEmbedding (aLabel p S ε₁)‖^2*primeProductNorm p common) + let active := cubeActiveSupport S (fun i=>v₁ i+v₂ i) ε₁ ε₂ + let slow := Z^M/(primeProductNorm p divisor*primeProductNorm p active*U₁*U₂) + let T := childFrequencyBall (firstPhysicalMultiplier p S v₁ v₂ ε₁ ε₂ f) + (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)) + ‖∑' h : {h : O // h∉T},actualFirstKernel p hp hcop hg pool S (fun i=>v₁ i+v₂ i) ε₁ ε₂ + C₁ C₂ W (fun _=>1) (fun _=>1) 1 1 (Z^M) + (primeSubsetGenerator (fun i=>Ideal.span {p i}) divisor) h.val‖ ≤ + (128*U₁)*(128*U₂)*(G₁*G₂*Z^M)* + ((Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)/((min 1 slow)^2*(1+Z^tau)^order)) := by + obtain ⟨s,Ct,hCt,hfull⟩ := full_first_supported_remainder order + refine ⟨s,Ct,hCt,?_⟩ + intro ι _ p hp _ hinj hcop hg hchar pool S common divisor v₁ v₂ ε₁ ε₂ hv hpool f hf0 + C₁ C₂ W G₁ G₂ Z M r ell V delta B j eta tau hG₁ hG₂ hZ hC₁ hC₂ hb₁ hb₂ hf hd hc hj hcol₁ hcol₂ + U₁ U₂ active slow T + have hA (ε : ι→Bool) : 0<‖eisEmbedding (aLabel p S ε)‖^2 := + SecondPassIntegration.elementNorm_pos _ (primeProduct_ne_zero p hp _ _) + have hU₁ : 0v₁ i+v₂ i) ε₁ ε₂ hpool C₁ C₂ W + G₁ G₂ 1 1 (Z^M) (Z^tau) (Real.log U₁) (Real.log U₂) hG₁ hG₂ zero_lt_one zero_lt_one + (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _).le hC₁ hC₂ hlog₁ hlog₂ + (primeSubsetGenerator (fun i=>Ideal.span {p i}) divisor) (primeSubsetGenerator_ne_zero _ _) T + (fun N hN Q hQ hNQ hn hq h hout=>by + simpa only [primeSubsetGenerator_norm_eq_productNorm, Finset.union_comm] using + first_physical_cutoff_raw_tail p hp S Q N v₁ v₂ ε₁ ε₂ hv hNQ.symm + (hpool.mono_left (Finset.mem_powerset.mp hQ)) (hpool.mono_left (Finset.mem_powerset.mp hN)) + common divisor f hf0 h Z M r ell V delta B j eta tau hZ hb₁ hb₂ hf hd hc hj + (hcol₂ Q hQ hq) (hcol₁ N hN hn) hout) + simpa only [Real.exp_log hU₁,Real.exp_log hU₂,one_mul,primeSubsetGenerator_norm_eq_productNorm] + using hb + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstPriorityEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPriorityEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..1c01597d6afe7121798bd76a325adce793ab8710 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstPriorityEnergy.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstToSecond +import OAI.NumberTheory.DirichletL.Descent.FirstPass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→Eis) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem first_fresh_real_energy + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i})≠2) + (F D B : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis→*ℂ) (m : Eis) + (H : Finset ι→ℂ) (ω : ℝ→ℂ) (X : ℝ) (c d : Eis) + (core : FirstCoreIndex) (height Y : ℝ) (hY : 0ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d core (-height) z‖^2 := by + unfold firstFreshSecondPoisson + rw [←firstCoreInputRow_smoothed_second_poisson p hg hp hinj hc F D B v ε₁ ε₂ negative χ Ψ m + H (fun u=>ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d core (-height) rowMajorant Y hY, + rowMajorant_tsum_eq_sum _ Y hY] + let P := fun z=>firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m H + (fun u=>ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d core (-height) z + change (∑ z∈rowMajorantBall Y,rowMajorant (‖eisEmbedding z‖^2/Y)*(‖P z‖^2 : ℝ)).re = + ∑ z∈rowMajorantBall Y,(rowMajorant (‖eisEmbedding z‖^2/Y)).re*‖P z‖^2 + simp only [Complex.re_sum,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,mul_zero,sub_zero] + +lemma priority_norm_sum_sq {α : Type*} (s : Finset α) (f : α→ℂ) : + ‖∑ i∈s,f i‖^2≤(s.card:ℝ)*∑ i∈s,‖f i‖^2 := by + have hnorm := pow_le_pow_left₀ (norm_nonneg _) (norm_sum_le s f) 2 + apply hnorm.trans + simpa using Finset.sum_mul_sq_le_sq_mul_sq s (fun _=>(1:ℝ)) (fun i=>‖f i‖) + +theorem first_fresh_priority_energy + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i})≠2) + (F D B A : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis→*ℂ) (m : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (H : Finset ι→ℂ) (ω : ℝ→ℂ) (X : ℝ) (c d : Eis) + (core : FirstCoreIndex) (height Y : ℝ) (hY : 0primeMark slots lists a (A∪U)*H U) ω X c d core height Y).re ≤ + (2:ℝ)^slots.card * ∑ J∈slots.powerset,‖primeMark J lists a (A∪D)‖^2 * + (firstFreshSecondPoisson p hp hg hinj F D B v ε₁ ε₂ negative χ Ψ m + (fun U=>primeMark (slots\J) (fun i=>lists i\(A∪D)) a U*H U) ω X c d core height Y).re := by + rw [first_fresh_real_energy p hp hg hinj hc F D B v ε₁ ε₂ negative χ Ψ m _ ω X c d core height Y hY] + calc + _ ≤ ∑ z∈rowMajorantBall Y,(rowMajorant (‖eisEmbedding z‖^2/Y)).re * + ((slots.powerset.card:ℝ)*∑ J∈slots.powerset, + ‖primeMark J lists a (A∪D) * firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m + (fun U=>primeMark (slots\J) (fun i=>lists i\(A∪D)) a U*H U) + (fun u=>ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d core (-height) z‖^2) := by + apply Finset.sum_le_sum + intro z hz + apply mul_le_mul_of_nonneg_left _ (rowMajorant_nonneg _) + rw [firstCoreInputRow_marked_priority] + exact priority_norm_sum_sq _ _ + _ = _ := by + simp_rw [first_fresh_real_energy p hp hg hinj hc F D B v ε₁ ε₂ negative χ Ψ m _ ω X c d core height Y hY] + simp only [Finset.card_powerset,Nat.cast_pow,Nat.cast_ofNat,Finset.mul_sum,norm_mul,mul_pow] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro J hJ + apply Finset.sum_congr rfl + intro z hz + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstProfileIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstProfileIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..162fb16ee691d0f837c378647bf02c64de3099a5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstProfileIdentity.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Descent.FullProfile + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def firstNormProfile (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 9 → ℝ → ℂ) (R : ℝ) (q : Fin 9 → ℝ) : ℂ := + (∏ i, V i (Real.log (q i))) * W₁ (q 0*q 2*q 5*q 7) * + W₂ (q 1*q 2*q 5*q 8) * + paperRadialFourier Φ (R*q 6/(q 3*q 4*(q 5)^2*q 7*q 8)) / + ((q 3:ℂ)*(Real.sqrt (q 4):ℂ)*(q 5:ℂ)* + (Real.sqrt (q 7):ℂ)*(Real.sqrt (q 8):ℂ)) + +theorem firstPoissonProfile_log (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 9 → ℝ → ℂ) (R : ℝ) (q : Fin 9 → ℝ) (hq : ∀ i, 0 < q i) : + firstPoissonProfile W₁ W₂ Φ V R (fun i => Real.log (q i)) = + firstNormProfile W₁ W₂ Φ V R q := by + have hl : (∑ i, firstLeftSlope i * Real.log (q i)) = + Real.log (q 0)+Real.log (q 2)+Real.log (q 5)+Real.log (q 7) := by + simp [Fin.sum_univ_succ,firstLeftSlope]; ring + have hr : (∑ i, firstRightSlope i * Real.log (q i)) = + Real.log (q 1)+Real.log (q 2)+Real.log (q 5)+Real.log (q 8) := by + simp [Fin.sum_univ_succ,firstRightSlope]; ring + have hk : (∑ i, firstKernelSlope i * Real.log (q i)) = + Real.log (q 6) - (Real.log (q 3)+Real.log (q 4)+Real.log (q 5)+ + Real.log (q 5)+Real.log (q 7)+Real.log (q 8)) := by + simp [Fin.sum_univ_succ,firstKernelSlope]; ring + unfold firstPoissonProfile firstNormProfile + rw [hl,hr,hk] + simp only [Real.exp_add,Real.exp_sub,Real.exp_log (hq _)] + rw [show R*(q 6/(q 3*q 4*q 5*q 5*q 7*q 8)) = + R*q 6/(q 3*q 4*(q 5)^2*q 7*q 8) from by ring] + simp only [Fin.prod_univ_succ,firstRootWindows,inverseNormWindow,inverseRootWindow, + Matrix.cons_val_zero,Matrix.cons_val_succ,Fin.isValue,Real.exp_log (hq _), + Fin.prod_univ_zero,mul_one] + simp only [Fin.succ,Fin.val_mk] + norm_num + ring + +theorem canonicalPairMode_whole_profile {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (N P B : Finset ι) (hNP : Disjoint N P) (hNB : Disjoint N B) (hPB : Disjoint P B) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (C₁ C₂ : Finset ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (A₁ A₂ C K : ℝ) (d h : Eis) : + (‖eisEmbedding d‖^2 : ℂ)⁻¹ * + canonicalPairMode p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ Φ + (fun y => W₁ (A₁*C*Real.exp y)) (fun y => W₂ (A₂*C*Real.exp y)) 1 1 K d h = + (K:ℂ) * firstNormProfile W₁ W₂ Φ (fun _ _ => 1) K + ![A₁,A₂,C,‖eisEmbedding d‖^2,primeProductNorm p (cubeActiveSupport B v ε₁ ε₂), + 1,‖eisEmbedding h‖^2,primeProductNorm p N,primeProductNorm p P] * + threeGaussRowFactor p hp hcop hg N P B v ε₁ ε₂ C₁ C₂ d h := by + have hNC : Disjoint N (cubeActiveSupport B v ε₁ ε₂) := + hNB.mono_right (Finset.filter_subset _ _) + have hPC : Disjoint P (cubeActiveSupport B v ε₁ ε₂) := + hPB.mono_right (Finset.filter_subset _ _) + have hs (S : Finset ι) : ‖eisEmbedding (∏ i ∈ S,p i)‖ = + Real.sqrt (primeProductNorm p S) := by + simp only [primeProductNorm,Real.sqrt_sq_eq_abs,abs_of_nonneg (norm_nonneg _)] + unfold canonicalPairMode firstNormProfile + simp only [columnLog,div_one,Real.exp_log (primeProductNorm_pos p hp _), + Matrix.cons_val_zero,Fin.isValue, + Finset.prod_const_one,one_mul,] + rw [primeProductNorm_union p (N ∪ P) _ (Finset.disjoint_union_left.mpr ⟨hNC,hPC⟩), + primeProductNorm_union p N P hNP] + rw [Finset.prod_union (Finset.disjoint_union_left.mpr ⟨hNC,hPC⟩),Finset.prod_union hNP] + simp only [map_mul,norm_mul,hs] + rw [show K*‖eisEmbedding h‖^2 / + (‖eisEmbedding d‖^2*(primeProductNorm p N*primeProductNorm p P* + primeProductNorm p (cubeActiveSupport B v ε₁ ε₂))) = + K*‖eisEmbedding h‖^2 / + (‖eisEmbedding d‖^2*primeProductNorm p (cubeActiveSupport B v ε₁ ε₂)* + primeProductNorm p N*primeProductNorm p P) from by ring] + push_cast + ring_nf + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstProfileUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstProfileUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..90c64e4f42b7b8d5ff16ed896aad86905ed6895f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstProfileUniform.lean @@ -0,0 +1,351 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondProfileUniform + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation EisensteinSchwartzPoisson +open SevenEighths.InverseMoment +open SevenEighths.InverseInitialProfile +open SevenEighths.InverseAmbientProfileTower +namespace SevenEighths.InverseMomentFirstProfileUniform + +def rooted (g : 𝓢(ℝ, ℂ)) (M a : ℝ) + (hg : Function.support g ⊆ Set.Icc (-M) M) : 𝓢(ℝ, ℂ) := + InverseClippingProfiles.rootSchwartz g M 0 1 0 a 0 zero_lt_one (by simp) hg + +@[simp] theorem rooted_apply (g : 𝓢(ℝ, ℂ)) (M a : ℝ) + (hg : Function.support g ⊆ Set.Icc (-M) M) (y : ℝ) : + rooted g M a hg y = (Real.exp (a*y) : ℂ)*g y := by + simp [rooted, InverseClippingProfiles.rootedWindow, InverseClippingProfiles.logWindow] + +theorem rooted_support (g : 𝓢(ℝ, ℂ)) (M a : ℝ) + (hg : Function.support g ⊆ Set.Icc (-M) M) : + Function.support (rooted g M a hg) ⊆ Set.Icc (-M) M := by + intro y hy + exact hg (by simpa using hy) + +def translated (g : 𝓢(ℝ, ℂ)) (ρ : ℝ) : 𝓢(ℝ, ℂ) := + SchwartzMap.compSubConstCLM ℂ (-ρ) g + +@[simp] theorem translated_apply (g : 𝓢(ℝ, ℂ)) (ρ y : ℝ) : + translated g ρ y = g (y+ρ) := by simp [translated] + +theorem fourier_translated (g : 𝓢(ℝ, ℂ)) (ρ t : ℝ) : + (𝓕 (translated g ρ)) t = logPhase t ρ * (𝓕 g) t := by + rw [SchwartzMap.fourier_coe] + have he : (translated g ρ : ℝ → ℂ) = fun y => g (y+ρ) := by ext y; simp + rw [he, InverseClippingProfiles.fourier_translate, ← SchwartzMap.fourier_coe] + +def normalization (ρ : Fin 9 → ℝ) (c₁ c₂ L : ℝ) : ℝ := + Real.exp (-(9/2:ℝ)*L - ∑ i, InverseClippingProfiles.firstBalancedSlope i*ρ i + + (Real.log c₁+Real.log c₂)/2) + +def density (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ, ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) (p : Ambient (Fin 9)) : ℂ := + (normalization ρ c₁ c₂ L : ℂ) * + fullProfileDensity (fun i => translated (g i) (ρ i)) + (𝓕 (clippedTwist g₁ c₁ θ₁)) (𝓕 (clippedTwist g₂ c₂ θ₂)) b₃ p + +theorem density_formula (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ, ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) (p : Ambient (Fin 9)) : + density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p = + (normalization ρ c₁ c₂ L : ℂ) * + (sourceDensity g₁ c₁ θ₁ p.1.1 * (sourceDensity g₂ c₂ θ₂ p.1.2.1 * b₃ p.1.2.2)) * + (∏ i, logPhase (p.2 i) (ρ i) * (𝓕 (g i)) (p.2 i)) := by + simp only [density, fullProfileDensity, tripleCoefficient, coordinateDensity, + fourier_translated, fourier_clippedTwist] + ring + +private theorem fourier_twist (g : 𝓢(ℝ, ℂ)) (θ t : ℝ) : + (𝓕 (frequencyTwist g θ)) t = (𝓕 g) (t-θ) := by + rw [SchwartzMap.fourier_coe] + have he : (frequencyTwist g θ : ℝ → ℂ) = fun y => logPhase θ y * g y := by + ext y + exact frequencyTwist_apply g θ y + rw [he, InverseClippingProfiles.fourier_phase_shift, ← SchwartzMap.fourier_coe] + +theorem density_norm (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ, ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) (p : Ambient (Fin 9)) : + ‖density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖ = normalization ρ c₁ c₂ L * + ‖twistedFullDensity g g₁ g₂ b₃ (θ₁,θ₂) p‖ := by + rw [density_formula] + simp only [norm_mul, norm_prod, sourceDensity_norm, logPhase_norm, one_mul, + Complex.norm_real, Real.norm_eq_abs, normalization, + abs_of_pos (Real.exp_pos _), twistedFullDensity, fullProfileDensity, + tripleCoefficient, coordinateDensity, fourier_twist] + ring + +theorem density_joint_measurable (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ, ℂ)) : + StronglyMeasurable (fun z : ((Fin 9 → ℝ) × (ℝ × ℝ) × (ℝ × ℝ) × ℝ) × Ambient (Fin 9) => + density g g₁ g₂ b₃ z.1.1 z.1.2.1.1 z.1.2.1.2 z.1.2.2.1.1 z.1.2.2.1.2 z.1.2.2.2 z.2) := by + simp_rw [density_formula] + apply Measurable.stronglyMeasurable + unfold normalization sourceDensity logPhase + have h1 := (𝓕 g₁ : 𝓢(ℝ, ℂ)).continuous.measurable + have h2 := (𝓕 g₂ : 𝓢(ℝ, ℂ)).continuous.measurable + have h3 := b₃.continuous.measurable + have hu (i : Fin 9) := (𝓕 (g i) : 𝓢(ℝ, ℂ)).continuous.measurable + have he := Complex.continuous_exp.measurable + fun_prop + +theorem normalization_bound (B : Fin 9 → ℝ) (b : ℝ) + (ρ : Fin 9 → ℝ) (c₁ c₂ L : ℝ) (hρ : ∀ i, |ρ i| ≤ B i) + (hc₁ : 0 < c₁) (hc₂ : 0 < c₂) (hc₁b : c₁ ≤ b) (hc₂b : c₂ ≤ b) (hL : 0 ≤ L) : + normalization ρ c₁ c₂ L ≤ + Real.exp ((∑ i, |InverseClippingProfiles.firstBalancedSlope i| *B i)+Real.log b) := by + unfold normalization + apply Real.exp_le_exp.mpr + have hs : -(∑ i, InverseClippingProfiles.firstBalancedSlope i*ρ i) ≤ + ∑ i, |InverseClippingProfiles.firstBalancedSlope i| *B i := by + rw [← Finset.sum_neg_distrib] + apply Finset.sum_le_sum + intro i _ + calc + _ ≤ |InverseClippingProfiles.firstBalancedSlope i*ρ i| := neg_le_abs _ + _ = |InverseClippingProfiles.firstBalancedSlope i| *|ρ i| := abs_mul _ _ + _ ≤ _ := mul_le_mul_of_nonneg_left (hρ i) (abs_nonneg _) + have h1 := Real.log_le_log hc₁ hc₁b + have h2 := Real.log_le_log hc₂ hc₂b + linarith + +theorem density_weighted_integrable (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ, ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) (J : ℕ) : + Integrable (fun p : Ambient (Fin 9) => ambientWeight J p * + ‖density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖) := by + simp_rw [density_norm] + convert (InverseAmbientProfileTower.fullProfileDensity_weighted_integrable g + (𝓕 (frequencyTwist g₁ θ₁)) (𝓕 (frequencyTwist g₂ θ₂)) b₃ J).const_mul + (normalization ρ c₁ c₂ L) using 1 + funext p + unfold twistedFullDensity + ring + +private theorem radial_common_box (Φ : 𝓢(ℝ, ℂ)) (M : Fin 9 → ℝ) + (hM : ∀ i, 0 ≤ M i) (A J : ℕ) : + ∃ C : ℝ, 0 ≤ C ∧ ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ (V : Fin 9 → ℝ → ℂ), (∀ i y, V i y ≠ 0 → |y| ≤ M i) → + ∀ y : Fin 9 → ℝ, + (∏ i, V i (y i))*paperRadialFourier Φ (R*Real.exp (∑ i, firstKernelSlope i*y i)) = + ∫ t : ℝ, (∏ i, V i (y i)*logPhase t (firstKernelSlope i*y i))*b₃ t) ∧ + (1+R)^A * (∫ t : ℝ, (1+‖t‖)^J * ‖b₃ t‖) ≤ C := by + let box : Fin 9 → ℝ → ℂ := fun i y => if |y| ≤ M i then 1 else 0 + have hb : ∀ i y, box i y ≠ 0 → |y| ≤ M i := by + intro i y h + simpa [box] using h + obtain ⟨C,hC,hs⟩ := paperRadialFourier_log_separation_envelope Φ box + firstKernelSlope M hM hb A J + refine ⟨C,hC,?_⟩ + intro R hR + obtain ⟨b₃,he,_,hm,_⟩ := hs R hR + refine ⟨b₃,?_,hm⟩ + intro V hV y + simp only [Finset.prod_mul_distrib] + by_cases hz : (∏ i, V i (y i)) = 0 + · simp [hz] + · have hall (i : Fin 9) : V i (y i) ≠ 0 := + (Finset.prod_ne_zero_iff.mp hz) i (Finset.mem_univ i) + have hbox (i : Fin 9) : box i (y i) = 1 := by simp [box, hV i _ (hall i)] + have h := he y + simp only [hbox, one_mul, Finset.prod_const_one] at h + rw [h, ← integral_const_mul] + apply integral_congr_ae + filter_upwards with t + ring + +theorem translated_box (g : 𝓢(ℝ, ℂ)) (M B ρ : ℝ) + (hg : Function.support g ⊆ Set.Icc (-M) M) (hρ : |ρ| ≤ B) + {y : ℝ} (hy : translated g ρ y ≠ 0) : |y| ≤ M+B := by + have h := hg (show g (y+ρ) ≠ 0 from by simpa only [translated_apply] using hy) + have hr := abs_le.mp hρ + apply abs_le.mpr + constructor <;> linarith [h.1,h.2,hr.1,hr.2] + +theorem density_weighted_integral (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ, ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) (J : ℕ) : + (∫ p : Ambient (Fin 9), ambientWeight J p * + ‖density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖) = normalization ρ c₁ c₂ L * + (∫ t : ℝ, (1+‖t‖)^J * ‖(𝓕 (frequencyTwist g₁ θ₁)) t‖) * + (∫ t : ℝ, (1+‖t‖)^J * ‖(𝓕 (frequencyTwist g₂ θ₂)) t‖) * + (∫ t : ℝ, (1+‖t‖)^J * ‖b₃ t‖) * + (∏ i, ∫ t : ℝ, (1+‖t‖)^J * ‖(𝓕 (g i)) t‖) := by + simp_rw [density_norm] + have he (p : Ambient (Fin 9)) : + ambientWeight J p * (normalization ρ c₁ c₂ L * + ‖twistedFullDensity g g₁ g₂ b₃ (θ₁,θ₂) p‖) = + normalization ρ c₁ c₂ L * (tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity g (𝓕 (frequencyTwist g₁ θ₁)) + (𝓕 (frequencyTwist g₂ θ₂)) b₃ p‖) := by + unfold ambientWeight tripleHeight coordinateHeight twistedFullDensity + ring + simp_rw [he] + rw [integral_const_mul, InverseMoment.fullProfileDensity_weighted_integral] + simp only [tripleHeight] + rw [tripleCoefficient_weighted_integral] + ring + +def profile (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ Φ : 𝓢(ℝ, ℂ)) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ R L : ℝ) (y : Fin 9 → ℝ) : ℂ := + (normalization ρ c₁ c₂ L : ℂ) * + ((∏ i, translated (g i) (ρ i) (y i)) * + clippedTwist g₁ c₁ θ₁ (∑ i, firstLeftSlope i*y i) * + clippedTwist g₂ c₂ θ₂ (∑ i, firstRightSlope i*y i) * + paperRadialFourier Φ (R*Real.exp (∑ i, firstKernelSlope i*y i))) + +def requiredOuterOrder (J : ℕ) : ℕ := J+2*InverseClippingProfiles.momentOrder J + +theorem common_measure (g : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ Φ : 𝓢(ℝ, ℂ)) + (M B : Fin 9 → ℝ) (b : ℝ) + (hM : ∀ i, 0 ≤ M i) (hB : ∀ i, 0 ≤ B i) + (hg : ∀ i, Function.support (g i) ⊆ Set.Icc (-M i) (M i)) (A J : ℕ) : + ∃ C : ℝ, 0 ≤ C ∧ ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + ∀ (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ), + (∀ i, |ρ i| ≤ B i) → 0 < c₁ → 0 < c₂ → c₁ ≤ b → c₂ ≤ b → 0 ≤ L → + (∀ y : Fin 9 → ℝ, profile g g₁ g₂ Φ ρ c₁ c₂ θ₁ θ₂ R L y = + ∫ p : Ambient (Fin 9), density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y p.1 p.2) ∧ + Integrable (fun p : Ambient (Fin 9) => ambientWeight J p * + ‖density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖) ∧ + (1+R)^A * (∫ p : Ambient (Fin 9), ambientWeight J p * + ‖density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖) ≤ + C*((1+‖θ₁‖)^(InverseClippingProfiles.momentOrder J) * + (1+‖θ₂‖)^(InverseClippingProfiles.momentOrder J)) := by + obtain ⟨C₃,hC₃,hsep⟩ := radial_common_box Φ (fun i => M i+B i) + (fun i => add_nonneg (hM i) (hB i)) A J + obtain ⟨C₁,hC₁,h₁⟩ := frequencyTwist_fourier_moment J g₁ + obtain ⟨C₂,hC₂,h₂⟩ := frequencyTwist_fourier_moment J g₂ + let D := ∏ i, ∫ t : ℝ, (1+‖t‖)^J * ‖(𝓕 (g i)) t‖ + let E := Real.exp ((∑ i, |InverseClippingProfiles.firstBalancedSlope i| * B i)+Real.log b) + have hD : 0 ≤ D := Finset.prod_nonneg (fun i _ => integral_nonneg (fun _ => by positivity)) + have hE : 0 ≤ E := (Real.exp_pos _).le + refine ⟨E*C₁*C₂*C₃*D, by positivity, ?_⟩ + intro R hR + obtain ⟨b₃,he,hm⟩ := hsep R hR + refine ⟨b₃,?_⟩ + intro ρ c₁ c₂ θ₁ θ₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + refine ⟨?_, density_weighted_integrable _ _ _ _ _ _ _ _ _ _ _, ?_⟩ + · intro y + have hb : ∀ i z, translated (g i) (ρ i) z ≠ 0 → |z| ≤ M i+B i := + fun i z hz => translated_box (g i) (M i) (B i) (ρ i) (hg i) (hρ i) hz + have hid := descent_profile_identity (clippedTwist g₁ c₁ θ₁) (clippedTwist g₂ c₂ θ₂) + Φ (fun i => translated (g i) (ρ i)) firstLeftSlope firstRightSlope firstKernelSlope + R b₃ (he _ hb) y + have habs := profile_integral_coordinate_absorption (fun i => translated (g i) (ρ i)) + (𝓕 (clippedTwist g₁ c₁ θ₁)) (𝓕 (clippedTwist g₂ c₂ θ₂)) b₃ + firstLeftSlope firstRightSlope firstKernelSlope y + simp only [profileMode] at habs + unfold profile + rw [hid, habs, ← full_density_mode_fubini, ← integral_const_mul] + apply integral_congr_ae + filter_upwards with p + unfold density + ring + · rw [density_weighted_integral] + have h12 := mul_le_mul (h₁ θ₁) (h₂ θ₂) + (integral_nonneg (fun _ => by positivity)) (by positivity) + have h123 := mul_le_mul h12 hm (by positivity) (by positivity) + have hd := mul_le_mul_of_nonneg_right h123 hD + have hn := normalization_bound B b ρ c₁ c₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + have hh := mul_le_mul hn hd (by positivity) hE + convert hh using 1 <;> + (dsimp only [InverseClippingProfiles.momentOrder, E, D]; ring) + +theorem balanced_exponential_identity (ρ y : Fin 9 → ℝ) (c₁ c₂ L : ℝ) : + normalization ρ c₁ c₂ L * + (∏ i, Real.exp (InverseClippingProfiles.firstBalancedSlope i*(y i+ρ i))) * + Real.exp (-(1/2:ℝ)*((∑ i, firstLeftSlope i*y i)+Real.log c₁)) * + Real.exp (-(1/2:ℝ)*((∑ i, firstRightSlope i*y i)+Real.log c₂)) = + Real.exp (-(9/2:ℝ)*L)*Real.exp (InverseClippingProfiles.firstRootExponent y) := by + rw [normalization, ← Real.exp_sum, ← Real.exp_add, ← Real.exp_add, + ← Real.exp_add, ← Real.exp_add] + congr 1 + norm_num [InverseClippingProfiles.firstBalancedSlope, + InverseClippingProfiles.firstRootExponent, firstLeftSlope, firstRightSlope, + Fin.sum_univ_succ] + ring + +def positiveSource (g : 𝓢(ℝ, ℂ)) (c θ x : ℝ) : ℂ := + logPhase θ (Real.log x)*g (Real.log x+Real.log c) + +theorem positiveSource_logSchwartz (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) + {c x : ℝ} (hc : 0 < c) (hx : 0 < x) (θ : ℝ) : + positiveSource (CubicReflectionKernel.logSchwartz W a b ha hs hW) c θ x = + clippedSource W c θ x := by + simp only [positiveSource, CubicReflectionKernel.logSchwartz_apply, + Real.exp_add, Real.exp_log hc, Real.exp_log hx, clippedSource] + rw [mul_comm x c] + +theorem balanced_profile_identity + (U : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ Φ : 𝓢(ℝ, ℂ)) + (M : Fin 9 → ℝ) (m₁ m₂ : ℝ) + (hU : ∀ i, Function.support (U i) ⊆ Set.Icc (-M i) (M i)) + (h₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (h₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) + (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ R L : ℝ) (y : Fin 9 → ℝ) : + profile (fun i => rooted (U i) (M i) (InverseClippingProfiles.firstBalancedSlope i) (hU i)) + (rooted g₁ m₁ (-(1/2:ℝ)) h₁) (rooted g₂ m₂ (-(1/2:ℝ)) h₂) + Φ ρ c₁ c₂ θ₁ θ₂ R L y = + (Real.exp (-(9/2:ℝ)*L) : ℂ) * firstPoissonProfile + (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) + Φ (fun i y => U i (y+ρ i)) R y := by + have he := congrArg (fun x : ℝ => (x : ℂ)) (balanced_exponential_identity ρ y c₁ c₂ L) + simp only [Complex.ofReal_mul, Complex.ofReal_prod] at he + unfold profile firstPoissonProfile + rw [InverseClippingProfiles.firstRootWindows_prod] + simp only [translated_apply, clippedTwist_apply, rooted_apply, positiveSource, Real.log_exp, + Finset.prod_mul_distrib] + linear_combination + (∏ i, U i (y i+ρ i)) * logPhase θ₁ (∑ i, firstLeftSlope i*y i) * + g₁ ((∑ i, firstLeftSlope i*y i)+Real.log c₁) * + logPhase θ₂ (∑ i, firstRightSlope i*y i) * + g₂ ((∑ i, firstRightSlope i*y i)+Real.log c₂) * + paperRadialFourier Φ (R*Real.exp (∑ i, firstKernelSlope i*y i)) * he + +theorem first_profile_common_measure + (U : Fin 9 → 𝓢(ℝ, ℂ)) (g₁ g₂ Φ : 𝓢(ℝ, ℂ)) + (M B : Fin 9 → ℝ) (m₁ m₂ b : ℝ) + (hM : ∀ i, 0 ≤ M i) (hB : ∀ i, 0 ≤ B i) + (hU : ∀ i, Function.support (U i) ⊆ Set.Icc (-M i) (M i)) + (h₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (h₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (A J : ℕ) : + let G := fun i => rooted (U i) (M i) (InverseClippingProfiles.firstBalancedSlope i) (hU i) + let f₁ := rooted g₁ m₁ (-(1/2:ℝ)) h₁ + let f₂ := rooted g₂ m₂ (-(1/2:ℝ)) h₂ + ∃ C : ℝ, 0 ≤ C ∧ ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + ∀ (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ), + (∀ i, |ρ i| ≤ B i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ b → c₂ ≤ b → 0 ≤ L → + (∀ y : Fin 9 → ℝ, + (Real.exp (-(9/2:ℝ)*L) : ℂ) * firstPoissonProfile + (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) + Φ (fun i y => U i (y+ρ i)) R y = + ∫ p : Ambient (Fin 9), density G f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p * + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y p.1 p.2) ∧ + Integrable (fun p : Ambient (Fin 9) => ambientWeight J p * + ‖density G f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖) ∧ + (1+R)^A * (∫ p : Ambient (Fin 9), ambientWeight J p * + ‖density G f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L p‖) ≤ + C*((1+‖θ₁‖)^(InverseClippingProfiles.momentOrder J) * + (1+‖θ₂‖)^(InverseClippingProfiles.momentOrder J)) := by + dsimp only + obtain ⟨C,hC,hs⟩ := common_measure + (fun i => rooted (U i) (M i) (InverseClippingProfiles.firstBalancedSlope i) (hU i)) + (rooted g₁ m₁ (-(1/2:ℝ)) h₁) (rooted g₂ m₂ (-(1/2:ℝ)) h₂) Φ M B b hM hB + (fun i => rooted_support _ _ _ _) A J + refine ⟨C,hC,?_⟩ + intro R hR + obtain ⟨b₃,hb₃⟩ := hs R hR + refine ⟨b₃,?_⟩ + intro ρ c₁ c₂ θ₁ θ₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + have h := hb₃ ρ c₁ c₂ θ₁ θ₂ L hρ (zero_lt_one.trans_le hc₁) + (zero_lt_one.trans_le hc₂) hc₁b hc₂b hL + refine ⟨?_,h.2⟩ + intro y + rw [← balanced_profile_identity U g₁ g₂ Φ M m₁ m₂ hU h₁ h₂] + exact h.1 y + +end SevenEighths.InverseMomentFirstProfileUniform + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstRapidPhysicalTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstRapidPhysicalTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..f0b7ccdf156554116cc7cc3ff08f97f9ac019e99 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstRapidPhysicalTail.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstTailAggregation +import OAI.NumberTheory.DirichletL.Descent.FirstSourceTail + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem first_whole_cube_rapid_physical_tail (ε:ℝ) (hε:0<ε) + (Mmax Fmax eta tau saving:ℝ) (hMm:0≤Mmax) (hFm:0≤Fmax) + (heta:0≤eta) (htau:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (b:CubeCoordinates ι) (C D extra₁ extra₂:Finset ι) + (f:Ideal O) (Ψ₁ Ψ₂:O→*ℂ) (m₁ m₂:O) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (test₁ test₂:Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) + (E G₁ G₂ Z M r ell V B j:ℝ) (delta:Finset ι→ℝ), + b.Admissible → Disjoint C b.support → + D⊆C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit → + f≠0 → 0≤E → 0≤G₁ → 0≤G₂ → 1≤Z → 0≤M → M≤Mmax → + 0≤ell → 0≤V → -eta≤r → r+3*ell+V≤Fmax → + primeProductNorm p C≤Z^(r+eta) → + primeProductNorm p extra₁≤E → primeProductNorm p extra₂≤E → + (∀u,‖Ψ₁ u‖≤1) → (∀u,‖Ψ₂ u‖≤1) → + (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → + (∀U,‖test₁ U‖≤G₁) → (∀U,‖test₂ U‖≤G₂) → + (∀U,test₁ U≠0→primeProductNorm p U≤Z^(r+eta)) → + (∀U,test₂ U≠0→primeProductNorm p U≤Z^(r+eta)) → + ‖eisEmbedding (primeProduct p b.support b.leftExponent)‖^2≤Z^(ell+eta) → + ‖eisEmbedding (primeProduct p b.support b.rightExponent)‖^2≤Z^(ell+eta) → + (Ideal.absNorm f:ℝ)≤Z^(V+eta) → primeProductNorm p D≤Z^(delta D+eta) → + Z^(B-eta)≤primeProductNorm p C → + Z^(j-eta)≤‖eisEmbedding (jLabel p b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2 → + ‖firstLocalPhysicalTail p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator f) + (fun U=>primeMark slots lists a (extra₁∪U)*test₁ U) + (fun U=>primeMark slots lists a (extra₂∪U)*test₂ U) W (Z^M) + (fun D=>childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent + b.rightExponent b.leftBit b.rightBit f) + (Z^(firstPhysicalHeight M r ell V (delta D) B j+12*eta+tau))) D‖≤ + 65536*(Cm*(E*Z^(r+eta))^ε*G₁)*(Cm*(E*Z^(r+eta))^ε*G₂)* + (Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)*Z^(-saving) := by + obtain ⟨order,horder⟩:=choose_actual_first_tail_order Mmax Fmax eta tau saving hMm hFm heta htau + obtain ⟨s,Ct,Cm,hCt,hCm,htail⟩:=first_whole_cube_canonical_tail ε hε order + refine ⟨s,Ct,Cm,hCt,hCm,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hc pool b C D extra₁ extra₂ f Ψ₁ Ψ₂ m₁ m₂ slots lists a + test₁ test₂ W E G₁ G₂ Z M r ell V B j delta hb hCB hD hf hE hG₁ hG₂ hZ hM hMmax + hell hV hr hwhole hC he₁ he₂ hΨ₁ hΨ₂ hslots ha ht₁ ht₂ hs₁ hs₂ hb₁ hb₂ hF hdelta hBlo hj + have hz:0 ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + +def firstRetainedSource (p : ι→O) (labels : Finset (Ideal O)) (b : CubeCoordinates ι) (Y : ℝ) : + Finset (Ideal O×O) := + labels.biUnion (fun f=> (nonzeroChildFrequencyBall + (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) Y).image + (fun h=>(f,h))) + +theorem mem_firstRetainedSource (p : ι→O) (labels : Finset (Ideal O)) (b : CubeCoordinates ι) (Y : ℝ) + (x : Ideal O×O) : + x∈firstRetainedSource p labels b Y ↔ x.1∈labels ∧ x.2∈nonzeroChildFrequencyBall + (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit x.1) Y := by + rcases x with ⟨f,h⟩ + simp [firstRetainedSource] + +theorem sum_firstRetainedSource {A : Type*} [AddCommMonoid A] + (p : ι→O) (labels : Finset (Ideal O)) (b : CubeCoordinates ι) (Y : ℝ) (H : Ideal O×O→A) : + ∑ x∈firstRetainedSource p labels b Y,H x = + ∑ f∈labels,∑ h∈nonzeroChildFrequencyBall + (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) Y,H (f,h) := by + unfold firstRetainedSource + rw [Finset.sum_biUnion] + · apply Finset.sum_congr rfl + intro f hf + exact Finset.sum_image (fun h hh k hk he=>congrArg Prod.snd he) + · intro f hf g hg hfg + apply Finset.disjoint_left.mpr + intro x hx hy + obtain ⟨h,hh,rfl⟩ := Finset.mem_image.mp hx + obtain ⟨k,hk,he⟩ := Finset.mem_image.mp hy + exact hfg (congrArg Prod.fst he).symm + +variable (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem original_retained_label_family + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (b : CubeCoordinates ι) (hb : b.Admissible) + (C : Finset ι) (hC : Disjoint C b.support) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ : O) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) + (labels : Finset (Ideal O)) (a : Ideal O→ℂ) (R : Finset ι→ℝ) : + (∑ f∈labels,a f*canonicalCubeDualFinite p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator f) + (fun U=>H₁ U*W₁ (primeProductNorm p U)) (fun U=>H₂ U*W₂ (primeProductNorm p U)) Φ K + (fun D=>childFrequencyBall + (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) (R D))) = + ∑ D∈(C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset, + (UniqueFactorizationMonoid.moebius (∏i∈D,Ideal.span {p i}):ℂ)* + ∑ x∈firstRetainedSource p labels b (R D),a x.1* + canonicalCubeOuter p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ (ConcretePrimeRowBridge.idealGenerator x.1)* + firstCubePhysicalMode p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ (ConcretePrimeRowBridge.idealGenerator x.1) + H₁ H₂ W₁ W₂ Φ K (primeSubsetGenerator (fun i=>Ideal.span {p i}) D) x.2 := by + simp_rw [canonical_retained_physical p hp hcop hg hinj hc hpr pool b hb C hC] + simp only [Finset.mul_sum,sum_firstRetainedSource,nonzeroChildFrequencyBall] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro D hD + apply Finset.sum_congr rfl + intro f hf + apply Finset.sum_congr rfl + intro h hh + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstRetainedPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstRetainedPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..a5384c4d5e9d96be04419ae378bf41eec0f73e21 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstRetainedPhysical.lean @@ -0,0 +1,93 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCanonicalPhysical +import OAI.NumberTheory.DirichletL.Descent.FirstPhysicalCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstCubePhysicalMode (pool : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ f : O) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) (d h : O) : ℂ := + (K:ℂ)*cubeBaseFactor p hp hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit d h * + firstPhysicalCommonRows p hg (pool\(b.support∪C)) + (cubeMinusCoefficient p hp hcop hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + (canonicalCubeResidual p hg b C true Ψ₁ m₁ f H₁) d) + (cubePlusCoefficient p hp hcop hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + (canonicalCubeResidual p hg b C false Ψ₂ m₂ f H₂) d) + (fun x=>star (W₁ x)) W₂ Φ + (‖eisEmbedding (aLabel p b.support b.rightBit)‖^2) + (‖eisEmbedding (aLabel p b.support b.leftBit)‖^2) + (primeProductNorm p C) + (primeProductNorm p (cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)) K d h + +theorem canonical_retained_physical + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (b : CubeCoordinates ι) (hb : b.Admissible) + (C : Finset ι) (hC : Disjoint C b.support) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ f : O) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) (T : Finset ι→Finset O) : + canonicalCubeDualFinite p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ f + (fun U=>H₁ U*W₁ (primeProductNorm p U)) (fun U=>H₂ U*W₂ (primeProductNorm p U)) Φ K T = + canonicalCubeOuter p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ f * + ∑ D∈(C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset, + (UniqueFactorizationMonoid.moebius (∏i∈D,Ideal.span {p i}):ℂ)* + ∑ h∈(T D).erase 0,firstCubePhysicalMode p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ f H₁ H₂ + W₁ W₂ Φ K (primeSubsetGenerator (fun i=>Ideal.span {p i}) D) h := by + unfold canonicalCubeDualFinite + apply congrArg + apply Finset.sum_congr rfl + intro D hD + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + have he := canonical_first_kernel_physical p hp hcop hg hinj hc hpr pool b hb C hC + Ψ₁ Ψ₂ m₁ m₂ f H₁ H₂ W₁ W₂ Φ K (primeSubsetGenerator (fun i=>Ideal.span {p i}) D) h + change (‖eisEmbedding (primeSubsetGenerator (fun i=>Ideal.span {p i}) D)‖^2:ℂ)⁻¹ * _ = + firstCubePhysicalMode p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ f H₁ H₂ W₁ W₂ Φ K _ h at he + rw [←Complex.ofReal_pow,primeSubsetGenerator_norm_eq_productNorm] at he + rw [div_eq_mul_inv,mul_assoc,he] + +theorem canonical_first_physical_split + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (b : CubeCoordinates ι) (hb : b.Admissible) + (C : Finset ι) (hC : Disjoint C b.support) + (Ψ₁ Ψ₂ : O→*ℂ) (m₁ m₂ : O) (f : Ideal O) (hf : f≠0) (H₁ H₂ : Finset ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) (hK : 0H₁ U*W₁ (primeProductNorm p U) + let H₂' := fun U=>H₂ U*W₂ (primeProductNorm p U) + let T := fun D=>childFrequencyBall + (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) (R D) + canonicalCubeBeforePoisson p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ fgen H₁' H₂' Φ K = + canonicalCubeDualZero p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ fgen H₁' H₂' Φ K + + (canonicalCubeOuter p hp hcop hg b C Ψ₁ Ψ₂ m₁ m₂ fgen * + ∑ D∈(C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset, + (UniqueFactorizationMonoid.moebius (∏i∈D,Ideal.span {p i}):ℂ)* + ∑ h∈(T D).erase 0,firstCubePhysicalMode p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ fgen H₁ H₂ + W₁ W₂ Φ K (primeSubsetGenerator (fun i=>Ideal.span {p i}) D) h) + + canonicalCubeDualTail p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ fgen H₁' H₂' Φ K T := by + intro fgen H₁' H₂' T + rw [canonicalCubeBeforePoisson_split p hp hcop hg hinj hc pool b C Ψ₁ Ψ₂ m₁ m₂ fgen H₁' H₂' Φ K hK T] + · rw [canonical_retained_physical p hp hcop hg hinj hc hpr pool b hb C hC] + · intro D hD + apply (mem_childFrequencyBall _ (firstPhysicalMultiplier_ne_zero p hp _ _ _ _ _ f hf) _ _).mpr + simpa only [mul_zero,map_zero,norm_zero,zero_pow (by decide : 2≠0)] using hR D + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstRowGeometry.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstRowGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..05450f7fe9dded7315ce539242f17315341bf768 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstRowGeometry.lean @@ -0,0 +1,93 @@ +import OAI.NumberTheory.DirichletL.Descent.PhysicalExponents +import OAI.NumberTheory.DirichletL.Descent.ChildCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +lemma first_whole_frequency_numeric (K P dn an cn a1 a2 sn tn hn L : ℝ) + (hK : 0 field_simp + +theorem first_ratio_actual_row {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (S N Q : Finset ι) (v₁ v₂ : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (hv : ∀ i∈S,0v₁ i+v₂ i) ε₁ ε₂)))*‖eisEmbedding h‖^2≤P) : + ‖eisEmbedding (DescentWeightedCauchy.firstElementRowMap + (dilationLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂) (f,h))‖^2 ≤ + P*L^2*B^4*F^2*primeProductNorm p divisor / + (K*(primeProductNorm p common)^2*‖eisEmbedding (jLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂)‖^2) := by + let active := cubeActiveSupport S (fun i=>v₁ i+v₂ i) ε₁ ε₂ + let e := dilationLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂ + let j := jLabel p S (fun i=>v₁ i+v₂ i) ε₁ ε₂ + let a1 := aLabel p S ε₁ + let a2 := aLabel p S ε₂ + have hactive : active ⊆ S := Finset.filter_subset _ _ + have hnorm : primeProductNorm p ((N∪Q)∪active)= + primeProductNorm p N*primeProductNorm p Q*primeProductNorm p active := by + rw [primeProductNorm_union p (N∪Q) active (Finset.disjoint_union_left.mpr + ⟨hNS.mono_right hactive,hQS.mono_right hactive⟩), + primeProductNorm_union p _ _ hNQ] + change (K/(primeProductNorm p divisor*primeProductNorm p ((N∪Q)∪active)))*‖eisEmbedding h‖^2≤P at hratio + rw [hnorm] at hratio + have hpos (v : ι→ℕ) : 0<‖eisEmbedding (primeProduct p S v)‖^2 := + SecondPassIntegration.elementNorm_pos _ (primeProduct_ne_zero p hp _ _) + have hfreq := first_whole_frequency_numeric K P (primeProductNorm p divisor) + (primeProductNorm p active) (primeProductNorm p common) (‖eisEmbedding a1‖^2) + (‖eisEmbedding a2‖^2) (primeProductNorm p N) (primeProductNorm p Q) + (‖eisEmbedding h‖^2) L hK hP (primeProductNorm_pos p hp _) (primeProductNorm_pos p hp _) + (primeProductNorm_pos p hp _) (hpos _) (hpos _) (primeProductNorm_pos p hp _) + (primeProductNorm_pos p hp _) (sq_nonneg _) hL hcol₁ hcol₂ hratio + have hcon := first_conductor_norm_bound p hp S v₁ v₂ ε₁ ε₂ hv B hB.le hb₁ hb₂ + have hnum := first_row_numeric_bound (primeProductNorm p active) (‖eisEmbedding e‖^2) + (‖eisEmbedding j‖^2) (‖eisEmbedding a1‖^2) (‖eisEmbedding a2‖^2) + (primeProductNorm p common) (primeProductNorm p divisor) (‖eisEmbedding h‖^2) + (Ideal.absNorm f) L (K/P) B F (primeProductNorm_pos p hp _).le (sq_nonneg _) + (hpos _) (hpos _) (hpos _) (primeProductNorm_pos p hp _) (primeProductNorm_pos p hp _).le + (sq_nonneg _) (Nat.cast_nonneg _) hL (div_pos hK hP) hB hF hcon hfreq hf + have hgen : ‖eisEmbedding (ConcretePrimeRowBridge.idealGenerator f)‖^2=(Ideal.absNorm f : ℝ) := by + rw [eisEmbedding_norm_sq_eq_absNorm_span,ConcretePrimeRowBridge.span_idealGenerator] + have hrow : ‖eisEmbedding (DescentWeightedCauchy.firstElementRowMap e (f,h))‖^2 = + ‖eisEmbedding h‖^2*(Ideal.absNorm f : ℝ)^2*‖eisEmbedding e‖^2 := by + simp only [DescentWeightedCauchy.firstElementRowMap,map_mul,map_pow,norm_mul,norm_pow,mul_pow] + rw [hgen] + rw [hrow] + apply hnum.trans_eq + field_simp + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstSecondHeightCost.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstSecondHeightCost.lean new file mode 100644 index 0000000000000000000000000000000000000000..e55ce6b321dff0f816dfbdb96a1ae2a4a745d64d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstSecondHeightCost.lean @@ -0,0 +1,160 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstHeightBudget +import OAI.NumberTheory.DirichletL.Descent.FirstLabelCellStep +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentFirstSecondHeightCost +open InverseMoment InverseAmbientProfileTower JointLogSeparation FourierBridge +open InverseMomentFirstOriginalProfile + +def firstDegree (degree : ℕ) : ℕ := 2*InverseClippingProfiles.momentOrder (2*degree) + +def firstHeight (negative : Bool) (z : Frequency×(Fin 9→ℝ)) : ℝ := + profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 (if negative then 7 else 8) + +lemma first_height_cost (degree : ℕ) (negative : Bool) (z : Frequency×(Fin 9→ℝ)) : + (1+‖firstHeight negative z‖)^(firstDegree degree)≤ + tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2 := by + cases negative + · exact first_right_height_budget _ z + · exact first_left_height_budget _ z + +lemma first_weight_one_le (J : ℕ) (z : Frequency×(Fin 9→ℝ)) : + 1≤tripleHeight J z.1*coordinateHeight J z.2 := by + simpa only [ambientWeight,tripleHeight,coordinateHeight] using ambientWeight_one_le J z + +def stepBudget (C Cbin Czero Ctail A Z F eta tau pi epschild saving : ℝ) : ℝ := + Czero*Z^(F+17*eta+tau+pi)+ + C*A*(1+Cbin*Real.log Z)^4*Z^(F+48*eta+tau+pi+epschild)+Ctail*Z^(-saving) + +lemma stepBudget_nonneg (C Cbin Czero Ctail A Z F eta tau pi epschild saving : ℝ) + (hC : 0≤C) (hz : 0≤Czero) (ht : 0≤Ctail) (hA : 0≤A) (hZ : 0≤Z) : + 0≤stepBudget C Cbin Czero Ctail A Z F eta tau pi epschild saving := by + unfold stepBudget + positivity + +theorem second_step_first_height (degree : ℕ) (negative : Bool) + (C Cbin Czero Ctail A Z F eta tau pi epschild saving : ℝ) + (hC : 0≤C) (hz : 0≤Czero) (ht : 0≤Ctail) (hA : 0≤A) (hZ : 0≤Z) + (z : Frequency×(Fin 9→ℝ)) : + Czero*Z^(F+17*eta+tau+pi)+ + C*A*(1+‖firstHeight negative z‖)^(firstDegree degree)*(1+Cbin*Real.log Z)^4* + Z^(F+48*eta+tau+pi+epschild)+Ctail*Z^(-saving)≤ + stepBudget C Cbin Czero Ctail A Z F eta tau pi epschild saving* + (tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2) := by + have hw := first_weight_one_le (firstDegree degree) z + have hh := first_height_cost degree negative z + have hzero : Czero*Z^(F+17*eta+tau+pi)≤ + (Czero*Z^(F+17*eta+tau+pi))*(tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2) := + le_mul_of_one_le_right (by positivity) hw + have htail : Ctail*Z^(-saving)≤ + (Ctail*Z^(-saving))*(tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2) := + le_mul_of_one_le_right (by positivity) hw + have hmiddle := mul_le_mul_of_nonneg_left hh + (show 0≤C*A*(1+Cbin*Real.log Z)^4*Z^(F+48*eta+tau+pi+epschild) by positivity) + have hs := add_le_add (add_le_add hzero hmiddle) htail + convert hs using 1 <;> dsimp [stepBudget] <;> ring + +lemma log_fourth_small_power (Cbin ε : ℝ) (hε : 0<ε) : + ∃ Clog : ℝ,0 ActualEisensteinCubic.O +variable {ι : Type*} (p : ι→O) (hp : ∀i,p i≠0) + +include hp in +theorem first_nonempty_column_center (U : Finset ι) (Z r eta : ℝ) (hZ : 1b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)≤Z^cap ∧ + (∀ eps : ι→Bool,Z^(r+eta)/(‖eisEmbedding (aLabel p b.support eps)‖^2*primeProductNorm p C)≤Z^cap) := by + dsimp only + have hz : 0 ActualEisensteinCubic.O + +theorem choose_actual_first_tail_order (Mmax Fmax eta tau saving : ℝ) + (hMm : 0≤Mmax) (hFm : 0≤Fmax) (heta : 0≤eta) (htau : 0b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + let slow := Z^M/(primeProductNorm p D*primeProductNorm p active*U₁*U₂) + (128*U₁)*(128*U₂)*(G₁*G₂*Z^M)*(P/((min 1 slow)^2*(1+Z^tau)^order))≤ + 65536*G₁*G₂*P*Z^(-saving) := by + obtain ⟨order,he⟩ := choose_first_tail_order (Mmax+Fmax+3*eta) tau saving (by linarith) htau + refine ⟨order,?_⟩ + intro ι _ p hp _ b C D hCB hD Z M r ell V G₁ G₂ P hZ hM hMmax hell hV hr hwhole hG₁ hG₂ hP h1 h2 hC + dsimp only + have hz : 0b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)) + (Z^(r+eta)/(‖eisEmbedding (aLabel p b.support b.rightBit)‖^2*primeProductNorm p C)) + (Z^(r+eta)/(‖eisEmbedding (aLabel p b.support b.leftBit)‖^2*primeProductNorm p C)) + G₁ G₂ P hZ (Real.rpow_pos_of_pos hz _) (primeProductNorm_pos p hp _) (primeProductNorm_pos p hp _) + (div_pos (Real.rpow_pos_of_pos hz _) (mul_pos (hapos _) (primeProductNorm_pos p hp _))) + (div_pos (Real.rpow_pos_of_pos hz _) (mul_pos (hapos _) (primeProductNorm_pos p hp _))) + hG₁ hG₂ hP hk hki hd ha (hu _) (hu _) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstStepScalarCaps.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstStepScalarCaps.lean new file mode 100644 index 0000000000000000000000000000000000000000..b03f5bad116a0e6c30273fe44c75e37ea63cc521 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstStepScalarCaps.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicRadius + +namespace OAI + +noncomputable section + +namespace SevenEighths.InverseMoment + + theorem first_step_scalar_caps (Z A M r ell V delta aa bb rr t j eta tau window b:ℝ) + (hZ:1 nlinarith + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstTailAbsorption.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstTailAbsorption.lean new file mode 100644 index 0000000000000000000000000000000000000000..55943b5324494693e9422a458f567ccf6531978c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstTailAbsorption.lean @@ -0,0 +1,66 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstCanonicalTail + +namespace OAI + +namespace SevenEighths.InverseMoment +open SecondPassArithmetic +noncomputable section + +lemma first_tail_fixed_cap (K D E U₁ U₂ B G₁ G₂ P H : ℝ) (A : ℕ) + (hK : 0 ActualEisensteinCubic.O +section +variable {ι:Type*} [DecidableEq ι] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstLocalPhysicalTail (pool:Finset ι) (b:CubeCoordinates ι) (C:Finset ι) + (Ψ₁ Ψ₂:O→*ℂ) (m₁ m₂ f:O) (H₁ H₂:Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) + (K:ℝ) (T:Finset ι→Finset O) (D:Finset ι):ℂ := + ∑'h:{h:O // h∉T D},actualFirstKernel p hp hcop hg (pool\(b.support∪C)) b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + (canonicalCubeResidual p hg b C true Ψ₁ m₁ f H₁) + (canonicalCubeResidual p hg b C false Ψ₂ m₂ f H₂) W (fun _=>1) (fun _=>1) 1 1 K + (primeSubsetGenerator (fun i=>Ideal.span {p i}) D) h.val + +theorem cube_tail_support_test (pool:Finset ι) (b:CubeCoordinates ι) (C:Finset ι) + (Ψ₁ Ψ₂:O→*ℂ) (m₁ m₂ f:O) (H₁ H₂:Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) + (K L:ℝ) (T:Finset ι→Finset O) + (hs:∀U,H₁ U≠0→primeProductNorm p U≤L) (hC:¬primeProductNorm p C≤L) : + canonicalCubeDualTail p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ f H₁ H₂ W K T=0 := by + have hz (U:Finset ι):H₁ ((b.rightDivisor∪C)∪U)=0:=by + by_contra h + exact hC ((primeProductNorm_mono p hp + (Finset.Subset.trans Finset.subset_union_right Finset.subset_union_left)).trans (hs _ h)) + have hcoef (U:Finset ι):canonicalCubeResidual p hg b C true Ψ₁ m₁ f H₁ U=0:=by + simp only [canonicalCubeResidual,originalLabelColumn,multiplicativeCoreColumn,ite_true,hz,mul_zero,zero_mul] + simp only [canonicalCubeDualTail,actualFirstKernel,threeGaussRowFactor,hcoef,mul_zero, + star_zero,zero_mul,ite_self,Finset.sum_const_zero,tsum_zero] + +end + +theorem full_first_tail_from_local (ε:ℝ) (hε:0<ε) : + ∃Ctail:ℝ,0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (bs:Finset (CubeCoordinates ι)) (labels:Finset (Ideal O)) + (a:CubeCoordinates ι→Finset ι→Ideal O→ℂ) (Ψ₁ Ψ₂:O→*ℂ) (m₁ m₂:O) + (H₁ H₂:CubeCoordinates ι→Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) (K B L F Γ E:ℝ) + (T:CubeCoordinates ι→Finset ι→Ideal O→Finset ι→Finset O), + 1≤B → 0b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)≤B^2:= + (primeProductNorm_mono p hp (Finset.filter_subset _ _)).trans + (cube_whole_support_dyad p hp b B hBp.le (hb₁ b hb) (hb₂ b hb)) + change ‖eisEmbedding (∏i∈cubeActiveSupport b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit,p i)‖^2≤B^2 at hn + nlinarith [norm_nonneg (eisEmbedding (∏i∈cubeActiveSupport b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit,p i))] + let z (b:CubeCoordinates ι) (C:Finset ι) (I:Ideal O):ℂ:= + canonicalCubeDualTail p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator I) (H₁ b) (H₂ b) W K (T b C I) + have hblock (b:CubeCoordinates ι) (hb:b∈bs) (C:Finset ι) + (hC:C∈boundedPrimeSupports p (pool\b.support) L) (I:Ideal O) (hI:I∈labels): + ‖z b C I‖≤128*(L*B^2)*E:=by + have hCB:Disjoint C b.support:=Finset.disjoint_left.mpr (fun i hi hib=> + (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp (Finset.mem_filter.mp hC).1) hi)).2 hib) + dsimp only [z,canonicalCubeDualTail] + rw [norm_mul] + apply (mul_le_of_le_one_left (norm_nonneg _) (canonicalCubeOuter_norm_le_one p hp hcop hg hc b C + Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ _)).trans + calc + _≤∑D∈(C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset,E:=by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro D hD + rw [norm_mul] + exact (mul_le_mul (sourceMobiusDivisor_norm_le_one p hp D) + (hlocal b hb C hC I hI D hD) (norm_nonneg _) zero_le_one).trans_eq (one_mul E) + _= ((C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset.card:ℝ)*E:=by simp + _≤_:=mul_le_mul_of_nonneg_right (cubeSourceDivisors_card p hp hinj b C B L hBp hL hCB + (hb₁ b hb) (hb₂ b hb) (Finset.mem_filter.mp hC).2) hE + have hcommon (b:CubeCoordinates ι) (hb:b∈bs): + ‖∑C∈(pool\b.support).powerset,∑I∈labels,a b C I*z b C I‖≤ + (128*L)*(128*F)*Γ*(128*(L*B^2)*E):=by + have heq:(∑C∈(pool\b.support).powerset,∑I∈labels,a b C I*z b C I)= + ∑C∈boundedPrimeSupports p (pool\b.support) L,∑I∈labels,a b C I*z b C I:=by + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro C hC hnot + have hn:¬primeProductNorm p C≤L:=fun h=>hnot (Finset.mem_filter.mpr ⟨hC,h⟩) + apply Finset.sum_eq_zero + intro I hI + rw [show z b C I=0 from cube_tail_support_test p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ _ + (H₁ b) (H₂ b) W K L (T b C I) (hs b hb) hn,mul_zero] + rw [heq] + calc + _≤∑C∈boundedPrimeSupports p (pool\b.support) L,∑I∈labels,Γ*(128*(L*B^2)*E):=by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro C hC + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro I hI + rw [norm_mul] + exact mul_le_mul (ha b hb C (Finset.mem_filter.mp hC).1 I hI) (hblock b hb C hC I hI) (norm_nonneg _) hΓ + _= ((boundedPrimeSupports p (pool\b.support) L).card:ℝ)*(labels.card:ℝ)*Γ*(128*(L*B^2)*E):=by simp;ring + _≤_:=by gcongr;exact boundedPrimeSupports_card_positive p hp hinj _ _ hL + change ‖∑b∈bs,∑C∈(pool\b.support).powerset,∑I∈labels,a b C I*z b C I‖≤_ + calc + _≤∑b∈bs,(128*L)*(128*F)*Γ*(128*(L*B^2)*E):= + (norm_sum_le _ _).trans (Finset.sum_le_sum hcommon) + _= (bs.card:ℝ)*((128*L)*(128*F)*Γ*(128*(L*B^2)*E)):=by simp + _≤(Cb*B^(1+ε)*B)*((128*L)*(128*F)*Γ*(128*(L*B^2)*E)):=by gcongr + _= _:=by + have he:B^(1+ε)*B*B^2=B^(4+ε):=by + calc + _=B^(1+ε)*B^(1:ℝ)*B^(2:ℝ):=by rw [Real.rpow_one,Real.rpow_two] + _=B^((1+ε)+1+2):=by rw [←Real.rpow_add hBp,←Real.rpow_add hBp] + _= _:=by congr 1;ring + calc + _=(Cb*128^3)*(B^(1+ε)*B*B^2)*L^2*F*Γ*E:=by ring + _= _:=by rw [he] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstToSecond.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstToSecond.lean new file mode 100644 index 0000000000000000000000000000000000000000..5bed75bfdd76a05808488e48723bb52a35207564 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstToSecond.lean @@ -0,0 +1,132 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstFreshEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def firstFreshSecondPoisson + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (H : Finset ι → ℂ) (ω : ℝ → ℂ) (X : ℝ) (c d : Eis) + (r : FirstCoreIndex) (t Y : ℝ) : ℂ := + ∑ G ∈ (F\D).powerset, ∑ U ∈ ((F\D)\G).powerset, ∑ V ∈ ((F\D)\G).powerset, + if Disjoint U V then overlapPairWeight p hg (firstCoreTwist negative χ Ψ r) + (m*b0Label p B v ε₁ ε₂) (c*jLabel p B v ε₁ ε₂) d + (firstCoreTest H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) negative (-t) D) G U V * + maskedSecondDual p hg hp hinj G U V rowMajorant Y else 0 + +theorem firstFreshSecondPoisson_fixed_pool + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (H : Finset ι → ℂ) (ω : ℝ → ℂ) (X : ℝ) (c d : Eis) + (r : FirstCoreIndex) (t Y : ℝ) (hY : 0 < Y) : + firstFreshSecondPoisson p hp hg hinj F D B v ε₁ ε₂ negative χ Ψ m H ω X c d r t Y = + ∑ G∈F.powerset,∑ U∈(F\G).powerset,∑ V∈(F\G).powerset, + if Disjoint U V then overlapPairWeight p hg (firstCoreTwist negative χ Ψ r) + ((m*b0Label p B v ε₁ ε₂)*∏ i∈D,p i) (c*jLabel p B v ε₁ ε₂) d + (firstCoreTest H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) negative (-t) D) G U V * + maskedSecondDual p hg hp hinj G U V rowMajorant Y else 0 := by + unfold firstFreshSecondPoisson + rw [← firstCoreInputRow_smoothed_second_poisson p hg hp hinj hc F D B v ε₁ ε₂ negative χ Ψ m + H (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d r (-t) rowMajorant Y hY] + rw [firstCoreInputRow_smoothed_sign p hg F D B v ε₁ ε₂ negative χ Ψ m H + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d r (-t) rowMajorant Y] + simp_rw [inputConjugateRow_fixed_pool p hg hinj F D] + exact inputConjugateRow_smoothed_second_poisson p hg hp hinj hc F + (firstCoreTwist negative χ Ψ r) ((m*b0Label p B v ε₁ ε₂)*∏ i∈D,p i) + (c*jLabel p B v ε₁ ε₂) d + (firstCoreTest H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) negative (-t) D) rowMajorant Y hY + +theorem first_fresh_core_energy_to_second + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (H : Finset ι → ℂ) (ω : ℝ → ℂ) (X : ℝ) (c d : Eis) (t : ℝ) + (rows : Finset Eis) (Y : ℝ) (hY : 0 < Y) + (hrows : ∀ z ∈ rows,(Ideal.absNorm (Ideal.span {z}):ℝ) ≤ Y) + (hΨ : ‖Ψ (∏ i∈D,p i)‖ ≤ 1) : + (∑ z∈rows,‖dilatedCoreRow p hp hcop hg F D B v ε₁ ε₂ negative χ + (multiplicativeCoreColumn p Ψ m H) (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) c d (-t) z‖^2) ≤ + (32*512) * ∑ r : FirstCoreIndex,‖firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r‖ * + (firstFreshSecondPoisson p hp hg hinj F D B v ε₁ ε₂ negative χ Ψ m H ω X c d r t Y).re := by + calc + _ ≤ ∑ z∈rows,(32*512) * ∑ r : FirstCoreIndex, + ‖firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r‖ * + ‖firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m H + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d r (-t) z‖^2 := by + apply Finset.sum_le_sum + intro z hz + exact dilatedCoreRow_sq_le_input_family p hp hcop hg hc hpr F D B v ε₁ ε₂ + negative χ Ψ m H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) c d (-t) z hΨ + _ = (32*512) * ∑ r : FirstCoreIndex,‖firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r‖ * + ∑ z∈rows,‖firstCoreInputRow p hg F D B v ε₁ ε₂ negative χ Ψ m H + (fun u => ω (Real.exp u)) (columnLog p (primeProductNorm p D*X)) c d r (-t) z‖^2 := by + rw [← Finset.mul_sum,Finset.sum_comm] + simp only [Finset.mul_sum] + _ ≤ _ := by + apply mul_le_mul_of_nonneg_left _ (by norm_num) + apply Finset.sum_le_sum + intro r hr + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + exact firstCoreInputRow_finite_le_second_poisson p hg hp hinj hc F D B v ε₁ ε₂ + negative χ Ψ m H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) c d r (-t) rows Y hY hrows + +theorem first_fresh_old_labels_to_second (ε : ℝ) (hε : 0 < ε) : + ∃ K : ℝ,0 < K ∧ ∀ {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}), + (∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) → + (∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) → + ∀ (F D B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool), (∀ j∈B,0 < v j) → + ∀ (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis), + ‖Ψ (∏ i∈D,p i)‖ ≤ 1 → ∀ (H : Finset ι → ℂ) (ω : ℝ → ℂ) (X t : ℝ),0 < X → + ∀ (c d : Eis) (source : Finset (Ideal Eis × Eis)) (rows : Finset Eis) + (w : Ideal Eis × Eis → ℂ) (M Y : ℝ),0 ≤ M → 0 < Y → + (∀ x∈source,Squarefree x.1) → + (∀ x∈source,DescentWeightedCauchy.firstElementRowMap (dilationLabel p B v ε₁ ε₂) x ∈ rows) → + (∀ z∈rows,z ≠ 0) → (∀ z∈rows,(Ideal.absNorm (Ideal.span {z}):ℝ) ≤ Y) → + (∀ x∈source,‖w x‖ ≤ M) → + (∑ x∈source,‖w x‖ * ‖firstCommonColumn p hg F D + (firstBareCubeCoefficient p hp hg hcop B v ε₁ ε₂ negative + (originalLabelColumn p hg B ε₁ ε₂ negative (multiplicativeCoreColumn p Ψ m H) + c (ConcretePrimeRowBridge.idealGenerator x.1)) d) + negative χ ω X t x.2‖^2) ≤ + M*K*Y^ε * ((32*512)*∑ r : FirstCoreIndex, + ‖firstCoreOuter p hg B v ε₁ ε₂ negative Ψ m D r‖ * + (firstFreshSecondPoisson p hp hg hinj F D B v ε₁ ε₂ negative χ Ψ m H ω X c d r t Y).re) := by + obtain ⟨K,hK,hpush⟩ := first_fresh_energy_small_power ε hε + refine ⟨K,hK,?_⟩ + intro ι _ p hp _ hinj hcop hg hc hpr F D B v ε₁ ε₂ hv negative χ Ψ m hΨ H ω X t hX + c d source rows w M Y hM hY hs hmap hrows hnorm hw + apply (hpush p hp hinj hcop hg F D B v ε₁ ε₂ hv negative χ + (multiplicativeCoreColumn p Ψ m H) ω X t hX c d source rows w M Y hM hY.le + hs hmap hrows hnorm hw).trans + exact mul_le_mul_of_nonneg_left + (first_fresh_core_energy_to_second p hp hcop hg hinj hc hpr F D B v ε₁ ε₂ negative χ + Ψ m H ω X c d t rows Y hY hnorm hΨ) (by positivity) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstTwoPassEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstTwoPassEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..2cb47b5976d60f1d4acd4d9ca36633b5db39a286 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstTwoPassEnergy.lean @@ -0,0 +1,154 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstLiveHeightStep +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicFullEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform InverseMomentFirstLabelCell +open InverseMomentFirstSecondHeightCost +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_two_pass_energy + (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V Γ theta pi epschild A loss:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Lcap)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r) + (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool) + (_hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap) + + (_hVcap:V≤Lcap)(_hwin:Real.exp window≤Z^eta)(_hpi:0≤pi)(_hpieta:6*eta≤pi) + (_hemcost:em*(20*(3*Lcap+16)+30)≤pi/4)(_hedcost:ed*(20*(3*Lcap+16)+30)≤pi/4) + (_hechild:0≤epschild)(_hsave: -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond) + (_hloss:48*eta+tau+pi+epschild+epsSecond≤loss)(_hcard:slots.card≤K) + (_hΨ:∀u,‖Ψ u‖≤1)(_hΓ:0≤Γ)(_hA:0≤A) + (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0)(_hβ:∀I∈labels,∀v∈Q,‖β I v‖≤Γ) + (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) + (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1), + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Lcap+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W rowMajorant (Z^M)); + (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂ + Z M r ell V eta tau window bw epschild A K degree)→ + (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂ + Z M r ell V eta tau window bw epschild A K degree)→ + Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=> + varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (ConcretePrimeRowBridge.idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤ + Czero*Γ^2*Z^(M-ell+3*eta+epsFirst*(5*ell+2*r+7*eta))+ + C*Γ^2*(1+A)*Z^(r+3*ell+V+loss)*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder (firstDegree degree))* + Z^((2*Lcap+15*eta+tau)*epsFirst+epsFirst)+Ctail*Γ^2*Z^(-saving) :=by + obtain ⟨om₁,om₂,lo,hi,hlo,hlh,hom₁,hom₂,hs₁,hs₂,hfull⟩:=original_dyadic_full_energy om a b ha hs Lcap Lcap eta tau saving hcap hcap hb heta heta1 htau htau1 + let bw:=max 1 (max hi b) + have hbw:1≤bw:=le_max_left _ _ + have hbwb: b≤bw:=(le_max_right hi b).trans (le_max_right 1 _) + have hbwh:hi≤bw:=(le_max_left hi b).trans (le_max_right 1 _) + have hbwp:0(hs hy).2 + obtain ⟨w₁₁,w₁₂,af₁,bf₁,haf₁,hab₁,hw₁₁,hw₁₂,hs₁₁,hs₁₂,hleft⟩:=actual_live_first_height + om b hsold om₁ lo hi hlo (subset_closure.trans hs₁) true + Lcap tau saving window bw em ed hcap htau hbw hbwh hew.ge (hbwb.trans hew.ge) hem hed K + obtain ⟨w₂₁,w₂₂,af₂,bf₂,haf₂,hab₂,hw₂₁,hw₂₂,hs₂₁,hs₂₂,hright⟩:=actual_live_first_height + om b hsold om₂ lo hi hlo (subset_closure.trans hs₂) false + Lcap tau saving window bw em ed hcap htau hbw hbwh hew.ge (hbwb.trans hew.ge) hem hed K + refine ⟨w₁₁,w₁₂,w₂₁,w₂₂,af₁,bf₁,af₂,bf₂,window,bw,haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hew.symm,?_⟩ + intro epsFirst epsSecond hepsF hepsS degree + obtain ⟨Cf,Cz,Ct,hCf,hCz,hCt,hfull⟩:=hfull epsFirst hepsF (firstDegree degree) + obtain ⟨Cl,hCl,hleft⟩:=hleft degree epsSecond hepsS + obtain ⟨Cr,hCr,hright⟩:=hright degree epsSecond hepsS + refine ⟨Cf*(Cl+Cr),Cz,Ct,mul_nonneg hCf (by positivity),hCz,hCt,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights + Z M r ell V Γ theta pi epschild A loss hZ hbin hM hF hMcap hell hV hr hbZ hQpool hQ hrcap hellcap + hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hΨ hΓ hA hsf hn hβ hlabels hslots hweights + mark Y cutoff W source keys hl hr' + let Be:ℝ:=(Cl+Cr)*(1+A)*Z^(r+3*ell+V+loss) + have hz:0q.rightExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + true Ψ m slots lists weights om₁ + ((physicalScales (Z^r) k.1 k.2.1) 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Be*(tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2) := by + intro k hk z + have he:=hleft p hp hcop hg hpr hinj hc pool Q labels β Ψ m slots lists weights rowMajorant + Z M r ell V eta pi epschild A theta (Z^M) loss hZ hbin hM hMcap hr hrcap hell hellcap hV hVcap + heta heta1 htau1 hwin hpi hpieta hemcost hedcost hQ hn hΨ hslots hcard hweights hA hechild hsave hloss k hk (hl k hk) z + rw [columnScale_physical Z r (by linarith)] at he + apply he.trans + change (Cl*(1+A)*Z^(r+3*ell+V+loss))*_ ≤ Be*_ + have hwgt:0≤tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2 := le_trans zero_le_one (first_weight_one_le _ z) + dsimp[Be] + gcongr + linarith + have right : ∀k∈keys,∀z:Frequency×(Fin 9→ℝ), + (Z^(firstKappa M r ell V (dyadicExponent Z (k.1 3)) (dyadicExponent Z (k.1 1)) + (dyadicExponent Z (k.1 2)) (dyadicExponent Z (k.1 4)))*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj (fun q=>q.leftExponent.support) pool + (InverseFirstGlobalCaps.labelParentCell p pool Q (fun _ _=>1) k.1 k.2.1 k.2.2) + (fun x=>(‖commonSelector p (fun _=>1) k.2.1 x.quotientSupport‖:ℂ)) + false Ψ m slots lists weights om₂ + ((physicalScales (Z^r) k.1 k.2.1) 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) + (firstCellRadius Z M r ell V eta tau k.1 k.2.2)≤Be*(tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2) := by + intro k hk z + have he:=hright p hp hcop hg hpr hinj hc pool Q labels β Ψ m slots lists weights rowMajorant + Z M r ell V eta pi epschild A theta (Z^M) loss hZ hbin hM hMcap hr hrcap hell hellcap hV hVcap + heta heta1 htau1 hwin hpi hpieta hemcost hedcost hQ hn hΨ hslots hcard hweights hA hechild hsave hloss k hk (hr' k hk) z + rw [columnScale_physical Z r (by linarith)] at he + apply he.trans + change (Cr*(1+A)*Z^(r+3*ell+V+loss))*_ ≤ Be*_ + have hwgt:0≤tripleHeight (firstDegree degree) z.1*coordinateHeight (firstDegree degree) z.2 := le_trans zero_le_one (first_weight_one_le _ z) + dsimp[Be] + gcongr + linarith + have hall:=hfull p hp hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights Z M r ell V Γ theta Be + hZ hbin hM hF hMcap hell hV hr hbZ hQpool hQ hrcap hellcap hΨ hΓ hBe hsf hn hβ hlabels hslots hweights left right + convert hall using 1 ; dsimp[Be] ; ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstTwoPassLowerRank.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstTwoPassLowerRank.lean new file mode 100644 index 0000000000000000000000000000000000000000..967b6cb0243972eacfa094208a43223f8eb682aa --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstTwoPassLowerRank.lean @@ -0,0 +1,115 @@ +import OAI.NumberTheory.DirichletL.Descent.CanonicalLowerMoments +import OAI.NumberTheory.DirichletL.Descent.FirstTwoPassParentEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicFullEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstDyadicOriginalBranches +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveParents +import OAI.NumberTheory.DirichletL.Descent.FirstLiveCountBudget +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveAggregate +import OAI.NumberTheory.DirichletL.Descent.FirstOriginalProfileLiveEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseFirstGlobalCaps InverseSecondSourceBlocks InverseMomentFirstChildWindows +open InverseMomentFirstOriginalProfile InverseMomentFirstProfileUniform InverseMomentFirstLabelCell +open InverseMomentFirstSecondHeightCost +open InverseAmbientProfileTower JointLogSeparation FourierBridge CompletedHeight +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_two_pass_from_lower_moments + (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(base Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V Γ theta pi epschild A loss lossFinal delta Qwidth z c:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Lcap)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r) + (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool) + (_hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap) + + (_hVcap:V≤Lcap)(_hwin:Real.exp window≤Z^eta)(_hpi:0≤pi)(_hpieta:6*eta≤pi) + (_hemcost:em*(20*(3*Lcap+16)+30)≤pi/4)(_hedcost:ed*(20*(3*Lcap+16)+30)≤pi/4) + (_hechild:0≤epschild)(_hsave: -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond) + (_hloss:48*eta+tau+pi+epschild+epsSecond≤loss)(_hcard:slots.card≤K) + (_hparent:M-ell≤r+3*ell+V) + (_hprincipal:3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal) + (_hretained:loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal) + (_htail: -saving≤r+3*ell+V+lossFinal) + (_hΨ:∀u,‖Ψ u‖≤1)(_hΓ:0≤Γ)(_hA:0≤A) + (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0)(_hβ:∀I∈labels,∀v∈Q,‖β I v‖≤Γ) + (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) + (_hbase:CanonicalCoefficientClass.IsBaseRayTwist base Ψ)(_hm:m≠0) + (_hd:0primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Lcap+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let _keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W rowMajorant (Z^M)); + CanonicalLowerMoments p hp hcop hg pool base slots lists weights ω₁₁ Z M (r+3*ell+V+15*eta) z (c-7*eta) epschild A K degree→ + CanonicalLowerMoments p hp hcop hg pool base slots lists weights ω₁₂ Z M (r+3*ell+V+15*eta) z (c-7*eta) epschild A K degree→ + CanonicalLowerMoments p hp hcop hg pool base slots lists weights ω₂₁ Z M (r+3*ell+V+15*eta) z (c-7*eta) epschild A K degree→ + CanonicalLowerMoments p hp hcop hg pool base slots lists weights ω₂₂ Z M (r+3*ell+V+15*eta) z (c-7*eta) epschild A K degree→ + Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=> + varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (ConcretePrimeRowBridge.idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤ + C*Γ^2*(1+A)*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder (firstDegree degree))* + Z^(r+3*ell+V+lossFinal) :=by + obtain ⟨w₁₁,w₁₂,w₂₁,w₂₂,af₁,bf₁,af₂,bf₂,window,bw,haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hew,he⟩:= + original_two_pass_parent_energy om a b ha hs Lcap eta tau saving em ed hcap hb heta heta1 htau htau1 hem hed K + refine ⟨w₁₁,w₁₂,w₂₁,w₂₂,af₁,bf₁,af₂,bf₂,window,bw,haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hew,?_⟩ + intro epsFirst epsSecond hepsF hepsS degree + obtain ⟨C,hC,he⟩:=he epsFirst epsSecond hepsF hepsS degree + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels β base Ψ m slots lists weights + Z M r ell V Γ theta pi epschild A loss lossFinal delta Qwidth z c hZ hbin hM hF hMcap hell hV hr hbZ hQpool hQ hrcap hellcap + hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hparent hprincipal hretained htail + hΨ hΓ hA hsf hn hβ hlabels hbase hm hd hterminal hsmall hmargin hpuncture hslots hweights + mark Y cutoff W source keys hl₁ hl₂ hr₁ hr₂ + have hZ1:1ActualEisensteinCubic.O + +theorem original_two_pass_parent_energy + (om:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0Ideal.span {p i})) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(weights:σ→ι→ℂ) + (Z M r ell V Γ theta pi epschild A loss lossFinal:ℝ) + (_hZ:2≤Z)(_hbin:2≤Z^eta)(_hM:0≤M)(_hF:r+3*ell+V≤Lcap)(_hMcap:M≤Lcap)(_hell:0≤ell)(_hV:0≤V)(_hr: -eta≤r) + (_hbZ:b≤Z^eta)(_hQpool:∀v∈Q,v.support⊆pool) + (_hQ:∀v∈Q,‖eisEmbedding (primeProduct p v.support v)‖^2≤Z^(ell+eta)) + (_hrcap:r≤Lcap)(_hellcap:ell≤Lcap) + + (_hVcap:V≤Lcap)(_hwin:Real.exp window≤Z^eta)(_hpi:0≤pi)(_hpieta:6*eta≤pi) + (_hemcost:em*(20*(3*Lcap+16)+30)≤pi/4)(_hedcost:ed*(20*(3*Lcap+16)+30)≤pi/4) + (_hechild:0≤epschild)(_hsave: -saving≤r+3*ell+V+48*eta+tau+pi+epschild+epsSecond) + (_hloss:48*eta+tau+pi+epschild+epsSecond≤loss)(_hcard:slots.card≤K) + (_hparent:M-ell≤r+3*ell+V) + (_hprincipal:3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal) + (_hretained:loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal) + (_htail: -saving≤r+3*ell+V+lossFinal) + (_hΨ:∀u,‖Ψ u‖≤1)(_hΓ:0≤Γ)(_hA:0≤A) + (_hsf:∀I∈labels,Squarefree I)(_hn:∀I∈labels,I≠0)(_hβ:∀I∈labels,∀v∈Q,‖β I v‖≤Γ) + (_hlabels:∀I∈labels,(Ideal.absNorm I:ℝ)≤Z^(V+eta)) + (_hslots:(slots:Set σ).PairwiseDisjoint lists)(_hweights:∀i∈slots,∀q∈lists i,‖weights i q‖≤1), + let mark:=fun v U=>primeMark slots lists weights (v.support∪U); + let Y:=Z^(2*Lcap+15*eta+tau); + let cutoff:=fun (q:CubeCoordinates ι) (C:Finset ι) (_I:Ideal O) (D:Finset ι)=>firstDyadicRadius p q C D Z M r ell V eta tau; + let W:=fun y=>normTwistedSource om theta (y/Z^r); + let source:=firstGlobalRetainedSource p (firstOriginalOuter pool Q) (fun _=>labels) (fun x=>x.1) Y; + let keys:=liveJointKeys p source pool (sourceSummand p hp hcop hg β cutoff Ψ m mark W rowMajorant (Z^M)); + (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 true Ψ m slots lists weights ω₁₁ ω₁₂ + Z M r ell V eta tau window bw epschild A K degree)→ + (∀k∈keys,ChildBounds p hp hcop hg pool Q k.1 k.2.1 k.2.2 false Ψ m slots lists weights ω₂₁ ω₂₂ + Z M r ell V eta tau window bw epschild A K degree)→ + Z^(-r-2*ell-V)*CanonicalRowCompletion.rowFamilyEnergy labels (fun I z=> + varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (ConcretePrimeRowBridge.idealGenerator I) + (fun v U=>mark v U*W (primeProductNorm p U)) z) (Z^M)≤ + C*Γ^2*(1+A)*(1+‖theta‖)^(2*InverseClippingProfiles.momentOrder (firstDegree degree))* + Z^(r+3*ell+V+lossFinal) :=by + obtain ⟨w₁₁,w₁₂,w₂₁,w₂₂,af₁,bf₁,af₂,bf₂,window,bw,haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hew,he⟩:= + original_two_pass_energy om a b ha hs Lcap eta tau saving em ed hcap hb heta heta1 htau htau1 hem hed K + refine ⟨w₁₁,w₁₂,w₂₁,w₂₂,af₁,bf₁,af₂,bf₂,window,bw,haf₁,hab₁,haf₂,hab₂,hw₁₁,hw₁₂,hw₂₁,hw₂₂,hs₁₁,hs₁₂,hs₂₁,hs₂₂,hbw,hbwb,hew,?_⟩ + intro epsFirst epsSecond hepsF hepsS degree + obtain ⟨C,Cz,Ct,hC,hCz,hCt,he⟩:=he epsFirst epsSecond hepsF hepsS degree + refine ⟨C+Cz+Ct,by positivity,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights + Z M r ell V Γ theta pi epschild A loss lossFinal hZ hbin hM hF hMcap hell hV hr hbZ hQpool hQ hrcap hellcap + hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hparent hprincipal hretained htail + hΨ hΓ hA hsf hn hβ hlabels hslots hweights mark Y cutoff W source keys hl hr' + have hall:=he p hp hg hinj hcop hc hpr pool Q labels β Ψ m slots lists weights + Z M r ell V Γ theta pi epschild A loss hZ hbin hM hF hMcap hell hV hr hbZ hQpool hQ hrcap hellcap + hVcap hwin hpi hpieta hemcost hedcost hechild hsave hloss hcard hΨ hΓ hA hsf hn hβ hlabels hslots hweights hl hr' + exact hall.trans (two_pass_scalar C Cz Ct Γ A Z (r+3*ell+V) M r ell eta tau pi epsFirst loss Lcap saving lossFinal + ((1+‖theta‖)^(2*InverseClippingProfiles.momentOrder (firstDegree degree))) hC hCz hCt hA (by linarith) + (one_le_pow₀ (by linarith [norm_nonneg theta])) hparent hprincipal hretained htail) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e557f7d991f9f80fbe1a7b47a1535ca6b438a90 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalEnergy.lean @@ -0,0 +1,54 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstFamilyEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι κ : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem first_family_integral_of_two_energies (source : Finset κ) (F : Finset ι) + (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (A₁ A₂ C R : κ → ℝ) (d h : κ → Eis) + (s : Fin 9 → ℝ) (density : Frequency × (Fin 9 → ℝ) → ℂ) + (J : ℕ) (B₁ B₂ : ℝ) (hB₁ : 0 ≤ B₁) (hB₂ : 0 ≤ B₂) + (hDensity : Integrable (fun z : Frequency × (Fin 9 → ℝ) => + tripleHeight J z.1*coordinateHeight J z.2*‖density z‖)) + (hleft : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) h ≤ + B₁*(tripleHeight J z.1*coordinateHeight J z.2)) + (hright : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) h ≤ + B₂*(tripleHeight J z.1*coordinateHeight J z.2)) : + ‖∫ z : Frequency × (Fin 9 → ℝ),density z * + firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + (Real.sqrt B₁*Real.sqrt B₂)*∫ z : Frequency × (Fin 9 → ℝ),tripleHeight J z.1*coordinateHeight J z.2*‖density z‖ := by + have hb (z : Frequency × (Fin 9 → ℝ)) : + ‖firstFamilySeparatedRow p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z‖ ≤ + (Real.sqrt B₁*Real.sqrt B₂)*(tripleHeight J z.1*coordinateHeight J z.2) := by + apply (first_family_cauchy p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s z).trans + have hh := mul_le_mul (Real.sqrt_le_sqrt (hleft z)) (Real.sqrt_le_sqrt (hright z)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + apply hh.trans_eq + rw [Real.sqrt_mul hB₁,Real.sqrt_mul hB₂] + calc + _=(Real.sqrt B₁*Real.sqrt B₂)*(Real.sqrt (tripleHeight J z.1*coordinateHeight J z.2))^2:=by ring + _= _:=by rw [Real.sq_sqrt];unfold tripleHeight coordinateHeight;positivity + calc + _ ≤ ∫ z : Frequency × (Fin 9 → ℝ),(Real.sqrt B₁*Real.sqrt B₂)*(tripleHeight J z.1*coordinateHeight J z.2*‖density z‖) := by + apply norm_integral_le_of_norm_le (hDensity.const_mul _) + filter_upwards with z + rw [norm_mul] + exact (mul_le_mul_of_nonneg_left (hb z) (norm_nonneg _)).trans_eq (by ring) + _ = _ := integral_const_mul _ _ +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalMovingEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalMovingEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..b0d8d59d3147a9f2e88f2d58ca76dd4858a55166 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalMovingEnergy.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstUnequalPhysicalEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +open InverseMomentFirstProfileUniform InverseAmbientProfileTower +variable {ι κ : Type*} [DecidableEq ι] +theorem actual_first_moving_family_two_energies + (U₀ : Fin 9 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 9 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ Cprofile : ℝ,0 ≤ Cprofile ∧ ∀ (p : ι → Eis) (_hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (source : Finset κ) (F : Finset ι) (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (ρ : Fin 9 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (A₁ A₂ C R : κ → ℝ) (K L : ℝ) (_hK : 0 < K) (d h : κ → Eis) (s : Fin 9 → ℝ) + (_hpos : ∀ x∈source,0 < A₁ x ∧ 0 < A₂ x ∧ 0 < C x ∧ 0 < R x ∧ d x ≠ 0 ∧ h x ≠ 0) + (_hs : ∀ i,0 < s i) + (_hρ : ∀ i,|ρ i| ≤ B₀ i) (_hc₁ : 1 ≤ c₁) (_hc₂ : 1 ≤ c₂) + (_hc₁b : c₁ ≤ bcap) (_hc₂b : c₂ ≤ bcap) (_hL : 0 ≤ L) + (_hω₁ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + (positiveSource g₁ c₁ θ₁) (A₁ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.1/(s 0*s 2*s 5*s 7)) ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) = 1) + (_hω₂ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + (positiveSource g₂ c₂ θ₂) (A₂ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.2/(s 1*s 2*s 5*s 8)) ≠ 0 → + ω₂ (primeProductNorm p j.2.2.2/s 8) = 1) + (_hcut : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) ≠ 0 → ω₂ (primeProductNorm p j.2.2.2/s 8) ≠ 0 → + ∀ i,U₀ i ((firstRelativeLog (firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j) s i)+ρ i) = 1) + (B₁ B₂ : ℝ) (_hB₁ : 0 ≤ B₁) (_hB₂ : 0 ≤ B₂) + (_hleft : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) h ≤ + B₁*(tripleHeight J z.1*coordinateHeight J z.2)) + (_hright : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) h ≤ + B₂*(tripleHeight J z.1*coordinateHeight J z.2)), + ‖firstFamilyPhysicalRows p hg source F selector C₁ C₂ w (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) Φ A₁ A₂ C R K d h s‖ ≤ + (Real.exp ((9/2:ℝ)*L)/firstRootScale s)* + ((Real.sqrt B₁*Real.sqrt B₂)*(Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker)) := by + obtain ⟨Cprofile,hCprofile,hmeasure⟩ := InverseMomentFirstProfileUniform.first_profile_common_measure + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + refine ⟨Cprofile,hCprofile,?_⟩ + intro p hp _ hg source F selector C₁ C₂ w ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ + A₁ A₂ C R K L hK d h s hpos hs hρ hc₁ hc₂ hc₁b hc₂b hL + hω₁ hω₂ hcut B₁ B₂ hB₁ hB₂ hleft hright + have hRad : 0 < K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8) := by + exact div_pos (mul_pos hK (hs 6)) + (mul_pos (mul_pos (mul_pos (mul_pos (hs 3) (hs 4)) (sq_pos_of_pos (hs 5))) (hs 7)) (hs 8)) + obtain ⟨b₃,hb₃⟩ := hmeasure (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) hRad + obtain ⟨hsep,hWeighted,hMoment⟩ := hb₃ ρ c₁ c₂ θ₁ θ₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + let g := fun i => rooted (U₀ i) (M₀ i) (InverseClippingProfiles.firstBalancedSlope i) (hU i) + let f₁ := rooted g₁ m₁ (-(1/2:ℝ)) hg₁ + let f₂ := rooted g₂ m₂ (-(1/2:ℝ)) hg₂ + let den := density g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have hden : Integrable den := first_balanced_density_integrable g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have he := actual_first_family_two_energies p hg hp source F selector C₁ C₂ w + (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) ω₁ ω₂ Φ (fun i y => U₀ i (y+ρ i)) + A₁ A₂ C R K L d h s hpos hs den hden hsep hω₁ hω₂ hcut + J B₁ B₂ hB₁ hB₂ hWeighted hleft hright + have hd : (∫ z : Frequency × (Fin 9 → ℝ),tripleHeight J z.1*coordinateHeight J z.2*‖den z‖) ≤ + Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker := by + apply (le_div_iff₀ (pow_pos (by linarith : 0 < 1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) Aker)).mpr + exact (mul_comm _ _).le.trans hMoment + exact he.trans (mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hd (mul_nonneg (Real.sqrt_nonneg _) (Real.sqrt_nonneg _))) + (by have := firstRootScale_pos s hs; positivity)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalPhysicalEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalPhysicalEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..ebb33d559baec02f501ae4938d08c1c015e10efd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalPhysicalEnergy.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstFamilySource +import OAI.NumberTheory.DirichletL.Descent.FirstUnequalEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι κ : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_first_family_two_energies (hp : ∀ i,p i ≠ 0) + (source : Finset κ) (F : Finset ι) (selector C₁ C₂ : κ → Finset ι → ℂ) (w : κ → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (V : Fin 9 → ℝ → ℂ) + (A₁ A₂ C R : κ → ℝ) (K L : ℝ) (d h : κ → Eis) (s : Fin 9 → ℝ) + (hpos : ∀ x∈source,0 < A₁ x ∧ 0 < A₂ x ∧ 0 < C x ∧ 0 < R x ∧ d x ≠ 0 ∧ h x ≠ 0) + (hs : ∀ i,0 < s i) (density : Frequency × (Fin 9 → ℝ) → ℂ) (hDensity : Integrable density) + (hsep : ∀ y : Fin 9 → ℝ, + (Real.exp (-(9/2:ℝ)*L):ℂ)*firstPoissonProfile W₁ W₂ Φ V + (K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8)) y = + ∫ z : Frequency × (Fin 9 → ℝ),density z* + pureProfileMode firstLeftSlope firstRightSlope firstKernelSlope y z.1 z.2) + (hω₁ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + W₁ (A₁ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.1/(s 0*s 2*s 5*s 7)) ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) = 1) + (hω₂ : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + W₂ (A₂ x*C x*primeProductNorm p j.2.1*primeProductNorm p j.2.2.2/(s 1*s 2*s 5*s 8)) ≠ 0 → + ω₂ (primeProductNorm p j.2.2.2/s 8) = 1) + (hcut : ∀ x∈source,∀ j∈firstCommonIndices F, + selector x j.2.1*firstCommonWeight p hg (C₁ x) (C₂ x) (h x) j ≠ 0 → + ω₁ (primeProductNorm p j.2.2.1/s 7) ≠ 0 → ω₂ (primeProductNorm p j.2.2.2/s 8) ≠ 0 → + ∀ i,V i (firstRelativeLog (firstCommonNorms p (A₁ x) (A₂ x) (C x) (R x) (d x) (h x) j) s i) = 1) + (J : ℕ) (B₁ B₂ : ℝ) (hB₁ : 0 ≤ B₁) (hB₂ : 0 ≤ B₂) + (hWeighted : Integrable (fun z : Frequency × (Fin 9 → ℝ) => + tripleHeight J z.1*coordinateHeight J z.2*‖density z‖)) + (hleft : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₁ w true ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) h ≤ + B₁*(tripleHeight J z.1*coordinateHeight J z.2)) + (hright : ∀ z : Frequency × (Fin 9 → ℝ), + firstFamilyEnergy p hg source F selector C₂ w false ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) h ≤ + B₂*(tripleHeight J z.1*coordinateHeight J z.2)) : + ‖firstFamilyPhysicalRows p hg source F selector C₁ C₂ w W₁ W₂ Φ A₁ A₂ C R K d h s‖ ≤ + (Real.exp ((9/2:ℝ)*L)/firstRootScale s)* + ((Real.sqrt B₁*Real.sqrt B₂)*∫ z : Frequency × (Fin 9 → ℝ),tripleHeight J z.1*coordinateHeight J z.2*‖density z‖) := by + have he := actual_first_balanced_family p hg hp source F selector C₁ C₂ w + W₁ W₂ ω₁ ω₂ Φ V A₁ A₂ C R K L d h s hpos hs density hDensity hsep hω₁ hω₂ hcut + have hb := first_family_integral_of_two_energies p hg source F selector C₁ C₂ w ω₁ ω₂ A₁ A₂ C R d h s + density J B₁ B₂ hB₁ hB₂ hWeighted hleft hright + have hn := congrArg norm he + conv_lhs at hn => rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] + conv_rhs at hn => rw [norm_mul,norm_inv,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (firstRootScale_pos s hs)] + have hexp : Real.exp ((9/2:ℝ)*L)*Real.exp (-(9/2:ℝ)*L) = 1 := by + rw [←Real.exp_add] + ring_nf + exact Real.exp_zero + have hn' := congrArg (fun a : ℝ => Real.exp ((9/2:ℝ)*L)*a) hn + rw [←mul_assoc,hexp,one_mul] at hn' + rw [←mul_assoc,←div_eq_mul_inv] at hn' + rw [hn'] + exact mul_le_mul_of_nonneg_left hb (by have := firstRootScale_pos s hs; positivity) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalRetainedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalRetainedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..cfca0e302683c8b6dc4a38c4938aed1779ea537c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstUnequalRetainedEnergy.lean @@ -0,0 +1,104 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstUnequalMovingEnergy +import OAI.NumberTheory.DirichletL.Descent.FirstActualSecondEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open JointLogSeparation FourierBridge MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +open InverseMomentFirstProfileUniform InverseAmbientProfileTower +variable {ι : Type*} [DecidableEq ι] +theorem actual_first_retained_two_energies (ε : ℝ) (hε : 0<ε) + (U₀ : Fin 9 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 9 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ Cprofile Kpush : ℝ,0 ≤ Cprofile ∧ 0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀ i,ringChar (Eis⧸Ideal.span {p i})≠2) + (_hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (F : Finset ι) (b : SecondPassArithmetic.CubeCoordinates ι) (common : Finset ι) + (Ψ₁ Ψ₂ : Eis→*ℂ) (mleft mright dd : Eis) (H₁ H₂ selector : Finset ι→ℂ) + (labels : Finset (Ideal Eis)) (a : Ideal Eis×Eis→ℂ) (Γ Y : ℝ) + (_hΨ₁ : ∀ u,‖Ψ₁ u‖≤1) (_hΨ₂ : ∀ u,‖Ψ₂ u‖≤1) + (_hΓ : 0≤Γ) (_hY : 0selector) C₁ C₂ w (positiveSource g₁ c₁ θ₁) (positiveSource g₂ c₂ θ₂) Φ A₁ A₂ C R K (fun _=>dd) Prod.snd s‖ ≤ + (Real.exp ((9/2:ℝ)*L)/firstRootScale s)* + ((Γ*Kpush*Y^ε*(Real.sqrt B₁*Real.sqrt B₂))*(Cprofile*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+K*s 6/(s 3*s 4*(s 5)^2*s 7*s 8))^Aker)) := by + obtain ⟨Cprofile,hCprofile,hprofile⟩ := actual_first_moving_family_two_energies (ι := ι) (κ := Ideal Eis×Eis) + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + obtain ⟨Kpush,hKpush,hpush⟩ := first_retained_actual_second_energy ε hε + refine ⟨Cprofile,Kpush,hCprofile,hKpush,?_⟩ + intro p hp _ hg hinj hcop hc hpr F b common Ψ₁ Ψ₂ mleft mright dd H₁ H₂ selector labels a Γ Y + hΨ₁ hΨ₂ hΓ hY hlabels hn ha ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ A₁ A₂ C R K L hK s hs + source C₁ C₂ w hpos hρ hc₁ hc₂ hc₁b hc₂b hL hω₁ hω₂ hcut B₁ B₂ hB₁ hB₂ hleft hright + have hweight : 0≤Γ*Kpush*Y^ε := by positivity + have hroot:Real.sqrt (Γ*Kpush*Y^ε*B₁)*Real.sqrt (Γ*Kpush*Y^ε*B₂)=Γ*Kpush*Y^ε*(Real.sqrt B₁*Real.sqrt B₂):=by + rw [Real.sqrt_mul hweight,Real.sqrt_mul hweight] + calc + _=(Real.sqrt (Γ*Kpush*Y^ε))^2*(Real.sqrt B₁*Real.sqrt B₂):=by ring + _= _:=by rw [Real.sq_sqrt hweight] + rw [←hroot] + apply hprofile p hp hg source F (fun _=>selector) C₁ C₂ w ω₁ ω₂ ρ c₁ c₂ θ₁ θ₂ + A₁ A₂ C R K L hK (fun _=>dd) Prod.snd s hpos hs hρ hc₁ hc₂ hc₁b hc₂b hL + hω₁ hω₂ hcut (Γ*Kpush*Y^ε*B₁) (Γ*Kpush*Y^ε*B₂) (mul_nonneg hweight hB₁) (mul_nonneg hweight hB₂) + · intro z + have he := hpush p hp hinj hcop hg hc hpr F b common Ψ₁ Ψ₂ hΨ₁ hΨ₂ mleft mright dd + labels a Γ Y hΓ hY hlabels hn ha true H₁ selector ω₁ (s 7) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 7) (hs 7) + apply he.trans + simpa only [mul_assoc,ite_true,ite_false,Bool.false_eq_true] using mul_le_mul_of_nonneg_left (hleft z) hweight + · intro z + have he := hpush p hp hinj hcop hg hc hpr F b common Ψ₁ Ψ₂ hΨ₁ hΨ₂ mleft mright dd + labels a Γ Y hΓ hY hlabels hn ha false H₂ selector ω₂ (s 8) + (profileHeight firstLeftSlope firstRightSlope firstKernelSlope z.1 z.2 8) (hs 8) + apply he.trans + simpa only [mul_assoc,ite_true,ite_false,Bool.false_eq_true] using mul_le_mul_of_nonneg_left (hright z) hweight + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeCanonicalTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeCanonicalTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..806e408813e2c16412e1a5aa71ee06dc0f1d2d89 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeCanonicalTail.lean @@ -0,0 +1,104 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstWholeMarkedColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem first_whole_cube_canonical_tail (ε : ℝ) (hε : 0<ε) (order : ℕ) : + ∃ (s : Finset (ℕ×ℕ)) (Ct Cm : ℝ),0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hchar : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (pool : Finset ι) (b : CubeCoordinates ι),b.Admissible → + ∀ (common divisor : Finset ι),Disjoint common b.support → + ∀ (f : Ideal O),f≠0 → + ∀ (Ψ₁ Ψ₂ : O→*ℂ),(∀ u,‖Ψ₁ u‖≤1) → (∀ u,‖Ψ₂ u‖≤1) → + ∀ (m₁ m₂ : O) (extra₁ extra₂ : Finset ι) (E : ℝ) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ), + 0≤E → primeProductNorm p extra₁≤E → primeProductNorm p extra₂≤E → + (slots : Set σ).PairwiseDisjoint lists → (∀ i∈slots,∀ k∈lists i,‖a i k‖≤1) → + ∀ (test₁ test₂ : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) + (G₁ G₂ Z M r ell V delta B j eta tau : ℝ),0≤G₁ → 0≤G₂ → 0b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit)‖^2 → + let residualPool := pool\(b.support∪common) + let C₁ := canonicalCubeResidual p hg b common true Ψ₁ m₁ (ConcretePrimeRowBridge.idealGenerator f) + (fun U=>primeMark slots lists a (extra₁∪U)*test₁ U) + let C₂ := canonicalCubeResidual p hg b common false Ψ₂ m₂ (ConcretePrimeRowBridge.idealGenerator f) + (fun U=>primeMark slots lists a (extra₂∪U)*test₂ U) + let U₁ := Z^(r+eta)/(‖eisEmbedding (aLabel p b.support b.rightBit)‖^2*primeProductNorm p common) + let U₂ := Z^(r+eta)/(‖eisEmbedding (aLabel p b.support b.leftBit)‖^2*primeProductNorm p common) + let G₁' := Cm*(E*Z^(r+eta))^ε*G₁ + let G₂' := Cm*(E*Z^(r+eta))^ε*G₂ + let active := cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + let slow := Z^M/(primeProductNorm p divisor*primeProductNorm p active*U₁*U₂) + let T := childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit f) + (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)) + ‖∑' h : {h : O // h∉T},actualFirstKernel p hp hcop hg residualPool b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit C₁ C₂ W + (fun _=>1) (fun _=>1) 1 1 (Z^M) + (primeSubsetGenerator (fun i=>Ideal.span {p i}) divisor) h.val‖ ≤ + (128*U₁)*(128*U₂)*(G₁'*G₂'*Z^M)* + ((Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)/((min 1 slow)^2*(1+Z^tau)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_first_physical_tail order + obtain ⟨Cm,hCm,hmark⟩ := whole_cube_marked_test_uniform ε hε + refine ⟨s,Ct,Cm,hCt,hCm,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hchar pool b hb common divisor hcommon f hf0 Ψ₁ Ψ₂ hΨ₁ hΨ₂ + m₁ m₂ extra₁ extra₂ E slots lists a hE he₁ he₂ hslots ha test₁ test₂ W G₁ G₂ Z M r ell V delta B j eta tau hG₁ hG₂ hZ + htest₁ htest₂ hs₁ hs₂ hb₁ hb₂ hf hd hc hj residualPool C₁ C₂ U₁ U₂ G₁' G₂' active slow T + have hdis : Disjoint residualPool (b.support∪common) := by + apply Finset.disjoint_left.mpr + intro i hi hi2 + exact (Finset.mem_sdiff.mp hi).2 hi2 + apply htail p hp hinj hcop hg hchar residualPool b.support common divisor b.leftExponent b.rightExponent + b.leftBit b.rightBit b.support_pos (hdis.mono_right Finset.subset_union_left) f hf0 C₁ C₂ W + G₁' G₂' Z M r ell V delta B j eta tau (by dsimp [G₁']; positivity) (by dsimp [G₂']; positivity) hZ + · intro N hN + exact (canonical_residual_norm p hg b common true Ψ₁ hΨ₁ m₁ _ _ N).trans + (hmark p hp hcop slots lists a hslots ha extra₁ test₁ E G₁ (Z^(r+eta)) hE hG₁ + (Real.rpow_pos_of_pos hZ _).le he₁ htest₁ hs₁ _) + · intro N hN + exact (canonical_residual_norm p hg b common false Ψ₂ hΨ₂ m₂ _ _ N).trans + (hmark p hp hcop slots lists a hslots ha extra₂ test₂ E G₂ (Z^(r+eta)) hE hG₂ + (Real.rpow_pos_of_pos hZ _).le he₂ htest₂ hs₂ _) + · exact hb₁ + · exact hb₂ + · exact hf + · exact hd + · exact hc + · exact hj + · intro N hN hn + have ht := canonical_residual_test_nonzero p hg b common true Ψ₁ m₁ + (ConcretePrimeRowBridge.idealGenerator f) _ N hn + have hn' := hs₁ _ (mul_ne_zero_iff.mp ht).2 + have he := cube_whole_column_norm p b hb common N hcommon + (hdis.mono_left (Finset.mem_powerset.mp hN)) true + simp only [ite_true] at he + exact he ▸ hn' + · intro N hN hn + have ht := canonical_residual_test_nonzero p hg b common false Ψ₂ m₂ + (ConcretePrimeRowBridge.idealGenerator f) _ N hn + have hn' := hs₂ _ (mul_ne_zero_iff.mp ht).2 + have he := cube_whole_column_norm p b hb common N hcommon + (hdis.mono_left (Finset.mem_powerset.mp hN)) false + simp only [ite_false,Bool.false_eq_true] at he + exact he ▸ hn' + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeCubePriority.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeCubePriority.lean new file mode 100644 index 0000000000000000000000000000000000000000..387e7a82f31cdedd74a08fb905849b6253f05007 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeCubePriority.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstActualPriorityEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def firstWholePrioritySecondEnergy (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (F : Finset ι) (b : CubeCoordinates ι) (C extra : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m d : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (selector : Finset ι→ℂ) (ω : ℝ→ℂ) (X t Y : ℝ) : ℝ := + let A := extra∪((if negative then b.rightDivisor else b.leftDivisor)∪C) + (32*512)*(2:ℝ)^slots.card * ∑ r : RayCharacter×RayCharacter,∑ D∈F.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑ core : FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative Ψ m D core‖ * + ∑ J∈slots.powerset,‖primeMark J lists a (A∪D)‖^2 * + (firstFreshSecondPoisson p hp hg hinj F D b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative (if negative then r.1 else r.2) Ψ m + (fun U=>primeMark (slots\J) (fun i=>lists i\(A∪D)) a U) + ω X (∏i∈C,p i) d core t Y).re + +theorem first_actual_second_whole_cube_priority + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (F : Finset ι) (b : CubeCoordinates ι) (C extra : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m d : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (selector : Finset ι→ℂ) (ω : ℝ→ℂ) (X t Y : ℝ) (hY : 0primeMark slots lists a (extra∪U)) selector ω X t Y ≤ + firstWholePrioritySecondEnergy p hp hg hinj F b C extra negative Ψ m d slots lists a selector ω X t Y := by + let A := extra∪((if negative then b.rightDivisor else b.leftDivisor)∪C) + have hb (r : RayCharacter×RayCharacter) (D : Finset ι) (core : FirstCoreIndex) := + first_fresh_priority_energy p hp hg hinj hc F D b.support A + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative + (if negative then r.1 else r.2) Ψ m slots lists a (fun _=>1) + ω X (∏i∈C,p i) d core t Y hY + simp only [mul_one] at hb + unfold firstCanonicalSecondEnergy firstWholePrioritySecondEnergy + simp only [Finset.mul_sum] + apply Finset.sum_le_sum + intro r hr + apply Finset.sum_le_sum + intro D hD + apply Finset.sum_le_sum + intro core hcore + have h := mul_le_mul_of_nonneg_left (hb r D core) + (show 0≤(32*512:ℝ)*(‖crossCoeff r.1 r.2‖*‖selector D‖)* + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative Ψ m D core‖ from by positivity) + convert h using 1 + · dsimp only [A] + simp only [Finset.union_assoc] + ring + · simp only [A,Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeMarkedColumns.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeMarkedColumns.lean new file mode 100644 index 0000000000000000000000000000000000000000..8b3636fca0446e4fdb7fba7f280c41c63b086174 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeMarkedColumns.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstMarkedZero + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O + +theorem primeProductNorm_union_le_mul {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] (A U : Finset ι) : + primeProductNorm p (A∪U)≤primeProductNorm p A*primeProductNorm p U := by + have he : A∪U=A∪(U\A) := by ext i;simp only [Finset.mem_union,Finset.mem_sdiff];tauto + rw [he,primeProductNorm_union p A (U\A) Finset.disjoint_sdiff] + exact mul_le_mul_of_nonneg_left (primeProductNorm_mono p hp Finset.sdiff_subset) + (primeProductNorm_pos p hp A).le + +theorem whole_cube_marked_test_uniform (ε : ℝ) (hε : 0<ε) : + ∃ Cm : ℝ,0Ideal.span {p i}))) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → (∀ i∈slots,∀ k∈lists i,‖a i k‖≤1) → + ∀ (extra : Finset ι) (test : Finset ι→ℂ) (E G L : ℝ),0≤E → 0≤G → 0≤L → + primeProductNorm p extra≤E → (∀ U,‖test U‖≤G) → + (∀ U,test U≠0→primeProductNorm p U≤L) → + ∀ U,‖primeMark slots lists a (extra∪U)*test U‖≤Cm*(E*L)^ε*G := by + obtain ⟨Cm,hCm,hmark⟩ := finite_primeMark_small_power ε hε + refine ⟨Cm,hCm,?_⟩ + intro ι σ _ _ p hp _ hcop slots lists a hslots ha extra test E G L hE hG hL he hb hs U + by_cases hz : test U=0 + · simp only [hz,mul_zero,norm_zero];positivity + have hnorm : primeProductNorm p (extra∪U)≤E*L := + (primeProductNorm_union_le_mul p hp extra U).trans + (mul_le_mul he (hs U hz) (primeProductNorm_pos p hp U).le hE) + have hnorm0 := (primeProductNorm_pos p hp (extra∪U)).le + rw [norm_mul] + calc + _ ≤ (Cm*(primeProductNorm p (extra∪U))^ε)*G := + mul_le_mul (hmark p hp hcop slots lists a hslots ha _) (hb U) (norm_nonneg _) (by positivity) + _ ≤ _ := by gcongr + +theorem first_whole_cube_marked_zero_uniform (ε : ℝ) (hε : 0<ε) : + ∃ Cm : ℝ,0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (pool : Finset ι) (b : CubeCoordinates ι) (C extra₁ extra₂ : Finset ι) + (Ψ₁ Ψ₂ : O→*ℂ),(∀ u,‖Ψ₁ u‖≤1) → (∀ u,‖Ψ₂ u‖≤1) → + ∀ (m₁ m₂ f : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → (∀ i∈slots,∀ k∈lists i,‖a i k‖≤1) → + ∀ (test₁ test₂ : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) (E G₁ G₂ L K : ℝ), + 0≤E → 0≤G₁ → 0≤G₂ → 0≤L → primeProductNorm p extra₁≤E → primeProductNorm p extra₂≤E → + (∀ U,‖test₁ U‖≤G₁) → (∀ U,‖test₂ U‖≤G₂) → + (∀ U,test₁ U≠0→primeProductNorm p U≤L) → (∀ U,test₂ U≠0→primeProductNorm p U≤L) → + ‖canonicalCubeDualZero p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ f + (fun U=>primeMark slots lists a (extra₁∪U)*test₁ U) + (fun U=>primeMark slots lists a (extra₂∪U)*test₂ U) W K‖ ≤ + if cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit=∅ then + (Cm*(E*L)^ε*G₁)*(Cm*(E*L)^ε*G₂) * |K| * ‖EisensteinSchwartzPoisson.paperRadialFourier W 0‖ else 0 := by + obtain ⟨Cm,hCm,hmark⟩ := whole_cube_marked_test_uniform ε hε + refine ⟨Cm,hCm,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hc pool b C extra₁ extra₂ Ψ₁ Ψ₂ hΨ₁ hΨ₂ + m₁ m₂ f slots lists a hslots ha test₁ test₂ W E G₁ G₂ L K hE hG₁ hG₂ hL he₁ he₂ hb₁ hb₂ hs₁ hs₂ + apply (canonicalCubeDualZero_norm_le p hp hcop hg hinj hc pool b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ f _ _ W K).trans + split_ifs + · exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right + (mul_le_mul (hmark p hp hcop slots lists a hslots ha extra₁ test₁ E G₁ L hE hG₁ hL he₁ hb₁ hs₁ _) + (hmark p hp hcop slots lists a hslots ha extra₂ test₂ E G₂ L hE hG₂ hL he₂ hb₂ hs₂ _) + (norm_nonneg _) (by positivity)) (abs_nonneg _)) (norm_nonneg _) + · exact le_rfl + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..1530f82246dc6de363445aa05aa6d3ead18d32f2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstWholeTail.lean @@ -0,0 +1,144 @@ +import OAI.NumberTheory.DirichletL.Descent.MarkedTails + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding eisEmbedding_ne_zero) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem full_first_supported_remainder (A : ℕ) : + ∃ (s : Finset (ℕ×ℕ)) (C : ℝ),0Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (F B : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool),Disjoint F B → + ∀ (C₁ C₂ : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) (G₁ G₂ X₁ X₂ K P M₁ M₂ : ℝ), + 0≤G₁ → 0≤G₂ → 01) (fun _=>1) X₁ X₂ K d h.val‖≤ + (128*U₁)*(128*U₂)*(G₁*G₂*K)* + ((C*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)/ + ((min 1 slow)^2*(1+P)^A)) := by + obtain ⟨s,C,hC,hb⟩:=full_uniform_canonicalPairMode_remainder A + refine ⟨s,C,hC,?_⟩ + intro ι _ p hp _ hinj hcop hg hc F B v ε₁ ε₂ hFB C₁ C₂ W G₁ G₂ X₁ X₂ K P M₁ M₂ hG₁ hG₂ hX₁ hX₂ hK hP hC₁ hC₂ hS₁ hS₂ d hd T hT + dsimp only + let U₁:=X₁*Real.exp M₁ + let U₂:=X₂*Real.exp M₂ + let S:=cubeActiveSupport B v ε₁ ε₂ + let slow:=K/(‖eisEmbedding d‖^2*primeProductNorm p S*U₁*U₂) + let tail:ℝ:=(C*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)/ + ((min 1 slow)^2*(1+P)^A) + let Q:ℝ:=G₁*G₂*K*tail + have hU₁:01) (fun _=>1) X₁ X₂ K d h.val else 0 + have hnzero (N R:Finset ι) (hn:C₁ N=0):rem N R=0:=by + simp [rem,canonicalPairMode,threeGaussRowFactor,hn] + have hrzero (N R:Finset ι) (hr:C₂ R=0):rem N R=0:=by + simp [rem,canonicalPairMode,threeGaussRowFactor,hr] + have heq : (∑'h:{h:O // h∉T},actualFirstKernel p hp hcop hg F B v ε₁ ε₂ C₁ C₂ W (fun _=>1) (fun _=>1) X₁ X₂ K d h.val)= + ∑N∈boundedPrimeSupports p F U₁,∑R∈boundedPrimeSupports p F U₂,rem N R := by + rw [actualFirstKernel_complement_eq_pairs p hp hcop hg F B v ε₁ ε₂ C₁ C₂ W (fun _=>1) (fun _=>1) X₁ X₂ K hK d hd T] + change (∑N∈F.powerset,∑R∈F.powerset,rem N R)=_ + calc + _ = ∑N∈boundedPrimeSupports p F U₁,∑R∈F.powerset,rem N R := by + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro N hN hn + have hz:C₁ N=0:=by + by_contra h + exact hn (Finset.mem_filter.mpr ⟨hN,columnLog_norm_upper p hp X₁ M₁ hX₁ N (hS₁ N hN h)⟩) + simp only [hnzero N _ hz,Finset.sum_const_zero] + _ = _ := by + apply Finset.sum_congr rfl + intro N hN + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro R hR hr + have hz:C₂ R=0:=by + by_contra h + exact hr (Finset.mem_filter.mpr ⟨hR,columnLog_norm_upper p hp X₂ M₂ hX₂ R (hS₂ R hR h)⟩) + exact hrzero N R hz + have hrem (N:Finset ι) (hN:N∈boundedPrimeSupports p F U₁) (R:Finset ι) (hR:R∈boundedPrimeSupports p F U₂):‖rem N R‖≤Q:=by + have hNF: N∈F.powerset:=(Finset.mem_filter.mp hN).1 + have hRF: R∈F.powerset:=(Finset.mem_filter.mp hR).1 + by_cases hn:C₁ N=0 + · rw [hnzero N R hn,norm_zero]; exact hQ + by_cases hr:C₂ R=0 + · rw [hrzero N R hr,norm_zero]; exact hQ + by_cases hNR:Disjoint N R + · have hNB:=hFB.mono_left (Finset.mem_powerset.mp hNF) + have hRB:=hFB.mono_left (Finset.mem_powerset.mp hRF) + have hNS:Disjoint N S:=hNB.mono_right (Finset.filter_subset _ _) + have hRS:Disjoint R S:=hRB.mono_right (Finset.filter_subset _ _) + have hnorm:primeProductNorm p ((N∪R)∪S)=primeProductNorm p N*primeProductNorm p R*primeProductNorm p S:=by + rw [primeProductNorm_union p _ _ (Finset.disjoint_union_left.mpr ⟨hNS,hRS⟩),primeProductNorm_union p _ _ hNR] + have hprod:=mul_le_mul (Finset.mem_filter.mp hN).2 (Finset.mem_filter.mp hR).2 + (primeProductNorm_pos p hp R).le hU₁.le + have hscale:slow≤K/(‖eisEmbedding d‖^2*primeProductNorm p ((N∪R)∪S)):=by + apply div_le_div_of_nonneg_left hK.le (mul_pos hNd (primeProductNorm_pos p hp _)) + rw [hnorm] + calc + _ ≤ ‖eisEmbedding d‖^2*(U₁*U₂*primeProductNorm p S):=mul_le_mul_of_nonneg_left + (mul_le_mul_of_nonneg_right hprod (primeProductNorm_pos p hp S).le) hNd.le + _ = _ := by ring + have hnroot:1≤‖eisEmbedding (∏i∈(N∪R)∪S,p i)‖:=by + have hx:=primeProductNorm_ge_one p hp ((N∪R)∪S) + change 1≤‖eisEmbedding (∏i∈(N∪R)∪S,p i)‖^2 at hx + nlinarith [norm_nonneg (eisEmbedding (∏i∈(N∪R)∪S,p i))] + have hpre:(K/‖eisEmbedding (∏i∈(N∪R)∪S,p i)‖)*(‖C₁ N‖*‖C₂ R‖)≤G₁*G₂*K:=by + calc + _ ≤ K*(G₁*G₂):=mul_le_mul (div_le_self hK.le hnroot) + (mul_le_mul (hC₁ N hNF) (hC₂ R hRF) (norm_nonneg _) hG₁) + (mul_nonneg (norm_nonneg _) (norm_nonneg _)) hK.le + _ = _ := by ring + have hfrac:(C*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)/ + ((min 1 (K/(‖eisEmbedding d‖^2*primeProductNorm p ((N∪R)∪S))))^2*(1+P)^A)≤tail:=by + apply div_le_div_of_nonneg_left (by positivity) + (mul_pos (sq_pos_of_pos (lt_min (by norm_num) hslow)) (pow_pos (by linarith) _)) + exact mul_le_mul_of_nonneg_right (pow_le_pow_left₀ (le_min zero_le_one hslow.le) + (min_le_min_left 1 hscale) 2) (pow_nonneg (by linarith) _) + have hpair:=hb p hp hcop hg hc N R B v ε₁ ε₂ C₁ C₂ W (fun _=>1) (fun _=>1) + X₁ X₂ K P hK hP d hd T (hT N hNF R hRF hNR hn hr) + simp only [norm_one,one_mul] at hpair + dsimp only [rem] + rw [ite_eq_left hNR] + exact hpair.trans (mul_le_mul hpre hfrac (by positivity) (mul_nonneg (mul_nonneg hG₁ hG₂) hK.le)) + · simp only [rem,ite_eq_right hNR,norm_zero];exact hQ + rw [heq] + calc + _ ≤ ∑N∈boundedPrimeSupports p F U₁,∑R∈boundedPrimeSupports p F U₂,‖rem N R‖ := + (norm_sum_le _ _).trans (Finset.sum_le_sum (fun N hN=>norm_sum_le _ _)) + _ ≤ ∑N∈boundedPrimeSupports p F U₁,∑R∈boundedPrimeSupports p F U₂,Q:= + Finset.sum_le_sum (fun N hN=>Finset.sum_le_sum (fun R hR=>hrem N hN R hR)) + _ = ((boundedPrimeSupports p F U₁).card:ℝ)*((boundedPrimeSupports p F U₂).card:ℝ)*Q:=by simp;ring + _ ≤ (128*U₁)*(128*U₂)*Q:=mul_le_mul_of_nonneg_right + (mul_le_mul (boundedPrimeSupports_card_positive p hp hinj F U₁ hU₁) + (boundedPrimeSupports_card_positive p hp hinj F U₂ hU₂) (Nat.cast_nonneg _) (by positivity)) hQ + _ = _ := by dsimp [Q,tail,slow,U₁,U₂,S];ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FirstZeroSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FirstZeroSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..5d82c08c5fc7d012ebc9d17a904e5a3fa1d13d5c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FirstZeroSource.lean @@ -0,0 +1,145 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstWholeMarkedColumns + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +section +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) +include hinj hc in +theorem first_variable_zero_common_bound + (pool : Finset ι) (b : CubeCoordinates ι) (labels : Finset (Ideal O)) + (a : Finset ι→Ideal O→ℂ) (Ψ₁ Ψ₂ : O→*ℂ) + (hΨ₁ : ∀u,‖Ψ₁ u‖≤1) (hΨ₂ : ∀u,‖Ψ₂ u‖≤1) + (m₁ m₂ : O) (H₁ H₂ : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) + (Γ G₁ G₂ L K : ℝ) (hΓ : 0≤Γ) (hG₁ : 0≤G₁) (hG₂ : 0≤G₂) (hL : 0b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit=∅ then + (128*(L))*(labels.card:ℝ)*(Γ*(G₁*G₂*|K| *‖paperRadialFourier W 0‖)) else 0 := by + let z (C:Finset ι) (I:Ideal O):ℂ:=canonicalCubeDualZero p hp hcop hg pool b C Ψ₁ Ψ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator I) + H₁ H₂ W K + let Q:ℝ:=Γ*(G₁*G₂*|K| *‖paperRadialFourier W 0‖) + have hQ:0≤Q:=by dsimp [Q];positivity + have heq : (∑C∈(pool\b.support).powerset,∑I∈labels,a C I*z C I)= + ∑C∈boundedPrimeSupports p (pool\b.support) (L),∑I∈labels,a C I*z C I := by + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro C hC hnot + have hbnd : ¬primeProductNorm p C≤L:=fun h=>hnot (Finset.mem_filter.mpr ⟨hC,h⟩) + apply Finset.sum_eq_zero + intro I hI + have hz : H₁ (b.rightDivisor∪C)=0 := by + by_contra hh + exact hbnd ((primeProductNorm_mono p hp Finset.subset_union_right).trans (hsupp _ hh)) + have hz' : z C I=0 := by + dsimp only [z] + rw [canonicalCubeDualZero_eq_density p hp hcop hg hinj] + split_ifs <;> simp [hz] + rw [hz',mul_zero] + change ‖∑C∈(pool\b.support).powerset,∑I∈labels,a C I*z C I‖≤_ + rw [heq] + by_cases hb : cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit=∅ + · rw [ite_eq_left hb] + have hpnt (C:Finset ι) (hC:C∈boundedPrimeSupports p (pool\b.support) (L)) (I:Ideal O) (hI:I∈labels):‖a C I*z C I‖≤Q:=by + rw [norm_mul] + have hz:=canonicalCubeDualZero_norm_le p hp hcop hg hinj hc pool b C Ψ₁ Ψ₂ hΨ₁ hΨ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator I) H₁ H₂ W K + rw [ite_eq_left hb] at hz + have hz' : ‖z C I‖≤G₁*G₂ * |K| * ‖paperRadialFourier W 0‖ := by + apply hz.trans + exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right + (mul_le_mul (hH₁ _) (hH₂ _) (norm_nonneg _) hG₁) (abs_nonneg _)) (norm_nonneg _) + exact mul_le_mul (ha C (Finset.mem_filter.mp hC).1 I hI) hz' (norm_nonneg _) hΓ + calc + _ ≤ ∑C∈boundedPrimeSupports p (pool\b.support) (L),∑I∈labels,‖a C I*z C I‖:= + (norm_sum_le _ _).trans (Finset.sum_le_sum (fun C hC=>norm_sum_le _ _)) + _ ≤ ∑C∈boundedPrimeSupports p (pool\b.support) (L),∑I∈labels,Q:= + Finset.sum_le_sum (fun C hC=>Finset.sum_le_sum (fun I hI=>hpnt C hC I hI)) + _ = ((boundedPrimeSupports p (pool\b.support) (L)).card:ℝ)*(labels.card:ℝ)*Q:=by simp;ring + _ ≤ _ := mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (boundedPrimeSupports_card_positive p hp hinj _ _ hL) (Nat.cast_nonneg _)) hQ + · rw [ite_eq_right hb] + have hz (C:Finset ι) (I:Ideal O):z C I=0:=by + dsimp [z] + rw [canonicalCubeDualZero_eq_density p hp hcop hg hinj,ite_eq_right hb] + simp only [hz,mul_zero,Finset.sum_const_zero,norm_zero,le_refl] + +end +theorem full_variable_first_zero_bound (ε : ℝ) (hε : 0<ε) : + ∃C:ℝ,0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) (_hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (bs:Finset (CubeCoordinates ι)) (labels:Finset (Ideal O)) + (a:CubeCoordinates ι→Finset ι→Ideal O→ℂ) (Ψ₁ Ψ₂:O→*ℂ) + (m₁ m₂:O) (H₁ H₂:CubeCoordinates ι→Finset ι→ℂ) (W:𝓢(ℝ,ℂ)) (Γ G₁ G₂ L K B F:ℝ), + 0≤Γ → 0≤G₁ → 0≤G₂ → 0cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit=∅ + have hQ:0≤Q:=by dsimp [Q];positivity + have hlabel:(labels.card:ℝ)≤128*F:=DescentFiberCost.finite_ideal_count_real labels F hF hI0 hIF + have hbcount:((bs.filter good).card:ℝ)≤C*B^(1+ε):=by + have h:=hcount p hp hinj (bs.filter good) B 1 hB (by norm_num) + (fun b hb=>hadm b (Finset.mem_filter.mp hb).1) + (fun b hb=>hb1 b (Finset.mem_filter.mp hb).1) + (fun b hb=>hb2 b (Finset.mem_filter.mp hb).1) + (fun b hb=>by + have he : cubeActiveSupport b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit=∅ := (Finset.mem_filter.mp hb).2 + rw [he] + simp) + simpa only [mul_one] using h + calc + _ ≤ ∑b∈bs,‖∑D∈(pool\b.support).powerset,∑I∈labels,a b D I* + canonicalCubeDualZero p hp hcop hg pool b D Ψ₁ Ψ₂ m₁ m₂ + (ConcretePrimeRowBridge.idealGenerator I) + (H₁ b) (H₂ b) W K‖:=norm_sum_le _ _ + _ ≤ ∑b∈bs,if good b then (128*(L))*(labels.card:ℝ)*Q else 0:=by + apply Finset.sum_le_sum + intro b hb + exact first_variable_zero_common_bound p hp hcop hg hinj hc pool b labels (a b) Ψ₁ Ψ₂ hΨ₁ hΨ₂ + m₁ m₂ (H₁ b) (H₂ b) W Γ G₁ G₂ L K hΓ hG₁ hG₂ hL (ha b hb) (hH₁ b hb) (hH₂ b hb) (hsupp b hb) + _ = ((bs.filter good).card:ℝ)*((128*(L))*(labels.card:ℝ)*Q):=by + rw [←Finset.sum_filter];simp + _ ≤ (C*B^(1+ε))*((128*(L))*(128*F)*Q):=by + apply mul_le_mul hbcount _ (by positivity) (by positivity) + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left hlabel (by positivity)) hQ + _ = _ := by dsimp [Q];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FixedSquare.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FixedSquare.lean new file mode 100644 index 0000000000000000000000000000000000000000..c61f03517ebf1a1158801c8ad613f4dd045d70de --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FixedSquare.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Descent.DyadicBlock +import OAI.NumberTheory.DirichletL.Descent.MaskedGrid +import OAI.NumberTheory.DirichletL.Descent.DivisorSum + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss IdealMobiusDivisorSum +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem hybrid_fixed_square_grid_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C₀ : ℝ, 0 < C₀ ∧ ∀ K N B L C T : ℝ, + 1 ≤ K → 1 ≤ N → 1 ≤ B → 1 ≤ C → 1 ≤ T → + ∀ (t : Ideal Eis), T ≤ (Ideal.absNorm t : ℝ) → + ∀ (rows nset Pset : Finset (Ideal Eis)) (D : Finset HybridColumnData) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → + (∀ d ∈ D, d.square = t ∧ C ≤ (Ideal.absNorm d.common : ℝ) ∧ + (Ideal.absNorm d.common : ℝ) ≤ 2 * C ∧ d.common * d.residualN ∈ nset ∧ + (Ideal.absNorm ((d.common * d.residualB) * d.square ^ 2) : ℝ) ≤ B) → + (∀ d ∈ D, ‖beta d.common d.residualN d.residualB‖ ≤ 1) → + (∑ k ∈ rows, ‖maskedGridHybridRow (hybridGridSupport D) Pset a beta t k‖ ^ 2) ≤ + C₀ * K ^ ε * (K * (N * B) * N) ^ ε * (K + N * B) * B / T ^ 2 * + CubicSieve.sieveNorm N (2 * L) * (columnDyadicLength K + 1 : ℝ) ^ 2 := by + obtain ⟨C₁, hC₁, hblock⟩ := hybrid_extracted_dyadic_block ε hε + obtain ⟨C₂, hC₂, hmask⟩ := maskedGridHybridRow_divisor_energy ε hε + refine ⟨C₁ * C₂ * 256 ^ 2, by positivity, ?_⟩ + intro K N B L C T hK hN hB hC hT t ht rows nset Pset D a beta + hrows hn hP ha hD hbeta + have hr0 : ∀ k ∈ rows, k ≠ 0 ∧ (Ideal.absNorm k : ℝ) ≤ K := + fun k hk => ⟨(hrows k hk).1.1, (hrows k hk).2⟩ + let E := C₁ * (K * (N * B) * N) ^ ε * (K + N * B) * B / T ^ 2 * + CubicSieve.sieveNorm N (2 * L) + have hs : 0 ≤ CubicSieve.sieveNorm N (2 * L) := sq_nonneg _ + have hE : 0 ≤ E := by dsimp only [E]; positivity + have hTprim : ∀ u ∈ hybridGridSupport D, primaryGenerator (u.2 * u.1.1) ≠ 0 := by + intro u hu + obtain ⟨d, hd, rfl⟩ := Finset.mem_image.mp hu + exact (hn _ (hD d hd).2.2.2.1).1.2 + have hterm (v : Ideal Eis × Ideal Eis) (hv : v ∈ hybridDivisorPairPool rows) : + (∑ k ∈ rows, if v ∈ (idealDivisors k) ×ˢ (idealDivisors k) then + ‖gridDivisorHybridBlock (hybridGridSupport D) Pset a beta t k v.1 v.2‖ ^ 2 else 0) ≤ + E * (1 / ((Ideal.absNorm v.1 : ℝ) * (Ideal.absNorm v.2 : ℝ))) := by + have hp := Finset.mem_product.mp (hybridDivisorPairPool_subset rows hv) + have hR := (hybridDivisorPool_bounds rows K hr0 v.1 hp.1).1 + have hr := (hybridDivisorPool_bounds rows K hr0 v.2 hp.2).1 + by_cases hcop : IsCoprime v.1 v.2 + · rw [double_divisor_row_reindex rows (fun k hk => (hr0 k hk).1) v.1 v.2 hcop] + have he := hblock K N B L C T hK hN hB hC hT v.1 v.2 t hR hr ht + rows nset Pset D a beta hrows hn hP ha hD hbeta + convert he using 1 + dsimp only [E] + field_simp + · simp only [gridDivisorHybridBlock_zero_of_not_coprime _ _ _ _ _ _ _ _ hcop + (fun P hPP => (hP P hPP).1.2) hTprim, + norm_zero, zero_pow (by norm_num : 2 ≠ 0), ite_self, Finset.sum_const_zero] + exact mul_nonneg hE (by positivity) + have he := hmask K hK rows (hybridGridSupport D) Pset a beta t hr0 + have hsum : (∑ v ∈ hybridDivisorPairPool rows, + ∑ k ∈ rows, if v ∈ (idealDivisors k) ×ˢ (idealDivisors k) then + ‖gridDivisorHybridBlock (hybridGridSupport D) Pset a beta t k v.1 v.2‖ ^ 2 else 0) ≤ + E * (256 * (columnDyadicLength K + 1 : ℝ)) ^ 2 := by + calc + _ ≤ ∑ v ∈ hybridDivisorPairPool rows, + E * (1 / ((Ideal.absNorm v.1 : ℝ) * (Ideal.absNorm v.2 : ℝ))) := + Finset.sum_le_sum hterm + _ = E * ∑ v ∈ hybridDivisorPairPool rows, + 1 / ((Ideal.absNorm v.1 : ℝ) * (Ideal.absNorm v.2 : ℝ)) := by rw [Finset.mul_sum] + _ ≤ _ := mul_le_mul_of_nonneg_left (hybrid_divisor_pair_inverse_norm_sum rows K hr0) hE + apply he.trans + calc + _ ≤ C₂ * K ^ ε * (E * (256 * (columnDyadicLength K + 1 : ℝ)) ^ 2) := + mul_le_mul_of_nonneg_left hsum (by positivity) + _ = _ := by dsimp only [E]; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FreshWindows.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FreshWindows.lean new file mode 100644 index 0000000000000000000000000000000000000000..f71c0846bde9ff481542dc8e26a9262f0ec2b3fa --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FreshWindows.lean @@ -0,0 +1,95 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondWholeKernel +import OAI.NumberTheory.DirichletL.Descent.SecondPass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem fresh_ratio_of_source_support (W : ℝ → ℂ) (a b g₀ g₁ v₀ v₁ g v n : ℝ) + (hs : Function.support W ⊆ Set.Icc a b) + (hg₀ : 0 < g₀) (hv₀ : 0 < v₀) (hg : g ∈ Set.Icc g₀ g₁) + (hv : v ∈ Set.Icc v₀ v₁) (hn : 0 ≤ n) (hw : W (g*v*n) ≠ 0) : + n ∈ Set.Icc (a/(g₁*v₁)) (b/(g₀*v₀)) := by + have hgp : 0 < g := hg₀.trans_le hg.1 + have hvp : 0 < v := hv₀.trans_le hv.1 + have hghi : 0 < g₁ := hgp.trans_le hg.2 + have hvhi : 0 < v₁ := hvp.trans_le hv.2 + have hsource := hs hw + constructor + · apply (div_le_iff₀ (mul_pos hghi hvhi)).mpr + calc + a ≤ g*v*n := hsource.1 + _ ≤ (g₁*v₁)*n := mul_le_mul_of_nonneg_right + (mul_le_mul hg.2 hv.2 hvp.le hghi.le) hn + _ = _ := by ring + · apply (le_div_iff₀ (mul_pos hg₀ hv₀)).mpr + calc + _ = (g₀*v₀)*n := by ring + _ ≤ g*v*n := mul_le_mul_of_nonneg_right + (mul_le_mul hg.1 hv.1 hv₀.le hgp.le) hn + _ ≤ b := hsource.2 + +theorem fresh_window_eq_one (W ω : ℝ → ℂ) (a b g₀ g₁ v₀ v₁ g v n : ℝ) + (hs : Function.support W ⊆ Set.Icc a b) + (hg₀ : 0 < g₀) (hv₀ : 0 < v₀) (hg : g ∈ Set.Icc g₀ g₁) + (hv : v ∈ Set.Icc v₀ v₁) (hn : 0 ≤ n) + (hω : ∀ n ∈ Set.Icc (a/(g₁*v₁)) (b/(g₀*v₀)), ω n = 1) + (hw : W (g*v*n) ≠ 0) : ω n = 1 := + hω n (fresh_ratio_of_source_support W a b g₀ g₁ v₀ v₁ g v n hs hg₀ hv₀ hg hv hn hw) + +theorem secondChildKernelPair_insert_fresh {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (F V : Finset ι) (Ψ₁ Ψ₂ : Eis →* ℂ) (m r c d e k₁ k₂ : Eis) + (K : Finset ι → Finset ι → ℂ) (ω₁ ω₂ : Finset ι → ℂ) + (hω : ∀ N ∈ (F \ V).powerset, ∀ M ∈ (F \ V).powerset, + K (V ∪ N) (V ∪ M) ≠ 0 → ω₁ (V ∪ N) = 1 ∧ ω₂ (V ∪ M) = 1) : + secondChildKernelPair p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k₁ k₂ K = + secondChildKernelPair p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k₁ k₂ + (fun S T => star (ω₁ S)*ω₂ T*K S T) := by + unfold secondChildKernelPair + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro M hM + by_cases hK : K (V ∪ N) (V ∪ M) = 0 + · simp only [hK,mul_zero] + · obtain ⟨h1,h2⟩ := hω N hN M hM hK + simp only [h1,h2,star_one,one_mul] + +theorem secondChildKernelPair_separated_marked {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (F V A₁ A₂ : Finset ι) (Ψ₁ Ψ₂ : Eis →* ℂ) (m r c d e k₁ k₂ : Eis) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (X₁ X₂ : ℝ) : + secondChildKernelPair p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k₁ k₂ + (fun S T => star (primeMark slots₁ lists₁ a₁ (A₁ ∪ S)*W₁ (primeProductNorm p S/X₁)) * + (primeMark slots₂ lists₂ a₂ (A₂ ∪ T)*W₂ (primeProductNorm p T/X₂))) = + star (canonicalMarkedSplit p hp hcop hg F V A₁ Ψ₁ m r c d e k₁ slots₁ lists₁ a₁ W₁ X₁) * + canonicalMarkedSplit p hp hcop hg F V A₂ Ψ₂ m r c d e k₂ slots₂ lists₂ a₂ W₂ X₂ := by + have hs (Ψ : Eis →* ℂ) (A : Finset ι) (k : Eis) (slots : Finset σ) + (lists : σ → Finset ι) (a : σ → ι → ℂ) (W : ℝ → ℂ) (X : ℝ) := + secondChildSum_marked_fixed_pool p hp hcop hg F V A Ψ m r c d e k slots lists a W X + unfold canonicalMarkedSplit + rw [← hs Ψ₁ A₁ k₁ slots₁ lists₁ a₁ W₁ X₁, ← hs Ψ₂ A₂ k₂ slots₂ lists₂ a₂ W₂ X₂] + unfold secondChildKernelPair secondChildSum + rw [star_sum, Finset.sum_mul] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro M hM + simp only [secondChildColumn,star_mul,mul_one] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/FullProfile.lean b/lean/OAI/NumberTheory/DirichletL/Descent/FullProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..dbecc56af162599044e5fc3801fa502a2743827c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/FullProfile.lean @@ -0,0 +1,133 @@ +import OAI.NumberTheory.DirichletL.Descent.RootWindows + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge EisensteinSchwartzPoisson JointLogSeparation +noncomputable section + +def rootSchwartz {ι : Type*} (U : ι → ℝ → ℂ) + (hU : ∀ i, ContDiff ℝ ∞ (U i)) (hS : ∀ i, HasCompactSupport (U i)) + (i : ι) : 𝓢(ℝ, ℂ) := (hS i).toSchwartzMap (hU i) + +@[simp] theorem rootSchwartz_apply {ι : Type*} (U : ι → ℝ → ℂ) + (hU : ∀ i, ContDiff ℝ ∞ (U i)) (hS : ∀ i, HasCompactSupport (U i)) + (i : ι) (y : ℝ) : rootSchwartz U hU hS i y = U i y := rfl + +theorem full_source_profile_common_measure {ι : Type*} [Fintype ι] + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (U : ι → ℝ → ℂ) (a₁ a₂ ak M : ι → ℝ) + (hU : ∀ i, ContDiff ℝ ∞ (U i)) (hS : ∀ i, HasCompactSupport (U i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, U i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ y : ι → ℝ, + (∏ i, U i (y i)) * W₁ (Real.exp (∑ i, a₁ i * y i)) * + W₂ (Real.exp (∑ i, a₂ i * y i)) * + paperRadialFourier Φ (R * Real.exp (∑ i, ak i * y i)) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : ι → ℝ, + fullProfileDensity (rootSchwartz U hU hS) b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + (∏ i, logPhase (profileHeight a₁ a₂ ak (t₁,t₂,t₃) u i) (y i))) ∧ + Integrable (fun p : Frequency × (ι → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (rootSchwartz U hU hS) b₁ b₂ b₃ p‖) ∧ + (1 + R)^A * (∫ p : Frequency × (ι → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (rootSchwartz U hU hS) b₁ b₂ b₃ p‖) ≤ C := by + obtain ⟨b₁,b₂,C,hC,hsep⟩ := source_descent_profile_separation + W₁ W₂ a b ha hs₁ hs₂ hW₁ hW₂ Φ U a₁ a₂ ak M hM hbox A J + let g := rootSchwartz U hU hS + let D : ℝ := ∏ i, ∫ u : ℝ, (1 + ‖u‖)^J * ‖(𝓕 (g i)) u‖ + have hD : 0 ≤ D := Finset.prod_nonneg (fun i hi => integral_nonneg (fun u => by positivity)) + refine ⟨b₁,b₂,C*D,mul_nonneg hC hD, ?_⟩ + intro R hR + obtain ⟨b₃,he,hi,hb⟩ := hsep R hR + refine ⟨b₃,?_,fullProfileDensity_weighted_integrable g b₁ b₂ b₃ J,?_⟩ + · intro y + rw [he y] + have habs := profile_integral_coordinate_absorption g b₁ b₂ b₃ a₁ a₂ ak y + simpa only [g, profileMode, rootSchwartz_apply, pureProfileMode_height] using habs + · rw [fullProfileDensity_weighted_integral] + change (1+R)^A * ((∫ t : Frequency, tripleHeight J t * ‖tripleCoefficient b₁ b₂ b₃ t‖) * D) ≤ C*D + rw [← mul_assoc] + exact mul_le_mul_of_nonneg_right hb hD + +def firstRootSchwartz (V : Fin 9 → ℝ → ℂ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) : + Fin 9 → 𝓢(ℝ, ℂ) := + rootSchwartz (firstRootWindows V) + (fun i => (firstRootWindows_smooth_compact V hV hS i).1) + (fun i => (firstRootWindows_smooth_compact V hV hS i).2) + +theorem first_full_profile_common_measure + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (V : Fin 9 → ℝ → ℂ) (M : Fin 9 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ y : Fin 9 → ℝ, firstPoissonProfile W₁ W₂ Φ V R y = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : Fin 9 → ℝ, + fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + (∏ i, logPhase (profileHeight firstLeftSlope firstRightSlope firstKernelSlope + (t₁,t₂,t₃) u i) (y i))) ∧ + Integrable (fun p : Frequency × (Fin 9 → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ∧ + (1 + R)^A * (∫ p : Frequency × (Fin 9 → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (firstRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ≤ C := by + have hb : ∀ i y, firstRootWindows V i y ≠ 0 → |y| ≤ M i := by + intro i y hy + fin_cases i <;> apply hbox _ y + all_goals first | exact hy | exact (div_ne_zero_iff.mp hy).1 + exact full_source_profile_common_measure W₁ W₂ a b ha hs₁ hs₂ hW₁ hW₂ Φ + (firstRootWindows V) firstLeftSlope firstRightSlope firstKernelSlope M + (fun i => (firstRootWindows_smooth_compact V hV hS i).1) + (fun i => (firstRootWindows_smooth_compact V hV hS i).2) hM hb A J + +def secondRootSchwartz (V : Fin 6 → ℝ → ℂ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) : + Fin 6 → 𝓢(ℝ, ℂ) := + rootSchwartz (secondRootWindows V) + (fun i => (secondRootWindows_smooth_compact V hV hS i).1) + (fun i => (secondRootWindows_smooth_compact V hV hS i).2) + +theorem second_full_profile_common_measure + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (V : Fin 6 → ℝ → ℂ) (M : Fin 6 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ R : ℝ, 0 < R → ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ y : Fin 6 → ℝ, secondPoissonProfile W₁ W₂ Φ V R y = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : Fin 6 → ℝ, + fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + (∏ i, logPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope + (t₁,t₂,t₃) u i) (y i))) ∧ + Integrable (fun p : Frequency × (Fin 6 → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ∧ + (1 + R)^A * (∫ p : Frequency × (Fin 6 → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ≤ C := by + have hb : ∀ i y, secondRootWindows V i y ≠ 0 → |y| ≤ M i := by + intro i y hy + fin_cases i <;> apply hbox _ y + all_goals first | exact hy | exact (div_ne_zero_iff.mp hy).1 + exact full_source_profile_common_measure W₁ W₂ a b ha hs₁ hs₂ hW₁ hW₂ Φ + (secondRootWindows V) secondLeftSlope secondRightSlope secondKernelSlope M + (fun i => (secondRootWindows_smooth_compact V hV hS i).1) + (fun i => (secondRootWindows_smooth_compact V hV hS i).2) hM hb A J + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GeneratorTransport.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GeneratorTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..7d8da6d607df360322162241cb22347e7ad4233e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GeneratorTransport.lean @@ -0,0 +1,67 @@ +import OAI.NumberTheory.DirichletL.Descent.Canonical + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem secondChildColumn_label_transfer (Ψ : Eis →* ℂ) (m a f k : Eis) + (H : Finset ι → ℂ) (S : Finset ι) : + secondChildColumn p hp hcop hg Ψ m (a*f) k H S = + secondChildColumn p hp hcop hg Ψ m f (a^4*k) H S := by + simp only [secondChildColumn, finiteSquarefreeRow, map_mul, map_pow, + Finset.prod_mul_distrib, Finset.prod_pow, mul_pow] + ring + +theorem secondChildColumn_puncture_unit (Ψ : Eis →* ℂ) (u : Eisˣ) (m f k : Eis) + (H : Finset ι → ℂ) (S : Finset ι) : + secondChildColumn p hp hcop hg Ψ ((u:Eis)*m) f k H S = + secondChildColumn p hp hcop hg Ψ m f k H S := by + have he : Ideal.span {((u:Eis)*m)} = Ideal.span {m} := + Ideal.span_singleton_mul_left_unit u.isUnit m + simp only [secondChildColumn,rowCoprimeMask_congr_span p S he] + +theorem secondChildColumn_generator_unit (Ψ : Eis →* ℂ) (u : Eisˣ) (m f d k : Eis) + (H : Finset ι → ℂ) (S : Finset ι) : + secondChildColumn p hp hcop hg Ψ m ((u:Eis)*f) ((u:Eis)*d*k) H S = + secondChildColumn p hp hcop hg Ψ m f (d*((u:Eis)^5*k)) H S := by + rw [secondChildColumn_label_transfer] + congr 1 + ring + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_label_transfer (F : Finset ι) (Ψ : Eis →* ℂ) + (m a f k : Eis) (slots : Finset σ) (lists : σ → Finset ι) (coeff : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg F Ψ m (a*f) k slots lists coeff W X = + finiteCanonicalMarkedRow p hp hcop hg F Ψ m f (a^4*k) slots lists coeff W X := by + simp only [finiteCanonicalMarkedRow,fixedChildRow,secondChildColumn_label_transfer] + +theorem generator_eq_unit_primary (I : Ideal Eis) (e : Eis) + (he : Ideal.span {e} = I) (hI : primaryGenerator I ≠ 0) : + ∃ u : Eisˣ, e = (u:Eis)*primaryGenerator I := by + have ha : Associated (primaryGenerator I) e := + Ideal.span_singleton_eq_span_singleton.mp ((primaryGenerator_spec I hI).1.trans he.symm) + obtain ⟨u,hu⟩ := ha + exact ⟨u,by simpa only [mul_comm] using hu.symm⟩ + +lemma normalized_generator_row_norm (u : Eisˣ) (d k : Eis) : + ‖ConcreteTraceCRT.eisEmbedding (d*((u:Eis)^5*k))‖ = + ‖ConcreteTraceCRT.eisEmbedding (d*k)‖ := by + have he : d*((u:Eis)^5*k) = ((u^5:Eisˣ):Eis)*(d*k) := by + change d*((u:Eis)^5*k) = (u:Eis)^5*(d*k) + ring + rw [he,GaussGeneratorTransport.norm_eisEmbedding_unit_mul] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalCanonicalEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalCanonicalEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..28f325bf1665535dd4dda25ba64abf2b8ee8c3f9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalCanonicalEnergy.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Inversion.FirstGlobalParents +import OAI.NumberTheory.DirichletL.Descent.GlobalParentEnergy +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFullAggregate + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +open InverseFirstPriorityParents +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ]{Jo:ℕ} +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem global_canonical_to_original_priority + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (outer:Finset (Source ι Jo))(pool:Finset ι)(selector:Source ι Jo→Finset ι→ℂ) + (houter:∀x∈outer,x.quotientSupport=∅)(extra:CubeCoordinates ι→Finset ι) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:ℝ→ℂ)(X t Y:ℝ)(hY:0Ideal.span {p i}) x.firstDivisor) + (fun U=>primeMark slots lists a (extra x.cube∪U)) (selector x) om X t Y) ≤ + globalPriorityOriginalEnergy p hg hp hinj extra pool (globalParentSource outer pool selector) + (fun x=>(‖selector (eraseFirstQuotient x) x.quotientSupport‖:ℂ)) + negative Ψ m slots lists a om X t Y := by + apply le_trans (Finset.sum_le_sum (fun x hx=> + first_actual_second_whole_cube_priority p hp hg hinj hc pool x.cube x.firstCommon (extra x.cube) + negative Ψ m (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.firstDivisor) + slots lists a (selector x) om X t Y hY)) + exact le_of_eq (global_second_energy_source p hg hp hinj outer pool selector houter extra + negative Ψ m slots lists a om X t Y) + +theorem original_canonical_to_global_priority + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(selector:FirstOriginalOuter ι→Finset ι→ℂ) + (extra:CubeCoordinates ι→Finset ι)(negative:Bool)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:ℝ→ℂ)(X t Y:ℝ)(hY:0Ideal.span {p i}) k.2.2) + (fun U=>primeMark slots lists a (extra k.1∪U)) (selector k) om X t Y) ≤ + globalPriorityOriginalEnergy p hg hp hinj extra pool + (InverseFirstGlobalParents.originalParentSource pool Q selector) + (fun x=>(‖selector (InverseFirstGlobalParents.toOriginal x) x.quotientSupport‖:ℂ)) + negative Ψ m slots lists a om X t Y := by + apply le_trans (Finset.sum_le_sum (fun k hk=> + first_actual_second_whole_cube_priority p hp hg hinj hc pool k.1 k.2.1 (extra k.1) + negative Ψ m (primeSubsetGenerator (fun i=>Ideal.span {p i}) k.2.2) + slots lists a (selector k) om X t Y hY)) + exact le_of_eq (InverseFirstGlobalParents.original_second_energy_source p hg hp hinj pool Q + selector extra negative Ψ m slots lists a om X t Y) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalParentEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalParentEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..06620270aa4a42f6c0f8d62108b2bb60e7276e2f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalParentEnergy.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalParentSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic RayFourExpansion +open InverseFirstPriorityParents InverseMomentWholePriorityParents InverseWholePriorityValidSource +open InversePrioritySecondSource +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type*}[DecidableEq ι][DecidableEq σ]{Jo:ℕ} +variable (p:ι→O)[∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem global_original_priority_slice + (outer:Finset (Source ι Jo))(pool:Finset ι)(selector:Source ι Jo→Finset ι→ℂ) + (houter:∀x∈outer,x.quotientSupport=∅) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex) + (H:Source ι Jo→ℂ): + (∑x∈globalParentSource outer pool selector, + globalPriorityOuter p hg negative Ψ m ray core + (fun x=>(‖selector (eraseFirstQuotient x) x.quotientSupport‖:ℂ)) x*H x)= + ∑x∈outer,∑D∈pool.powerset, + (priorityOuter p hg x.cube negative Ψ m (selector x) ray core D:ℂ)*H (fillFirstQuotient x D):=by + rw [sum_globalParentSource outer pool selector houter] + apply Finset.sum_congr rfl + intro x hx + rw [Finset.sum_filter] + apply Finset.sum_congr rfl + intro D hD + by_cases hs:selector x D≠0 + · rw [ite_eq_left hs] + simp only [globalPriorityOuter,erase_fillFirstQuotient,eraseFirstQuotient_eq _ (houter x hx)] + dsimp only [fillFirstQuotient,priorityOuter] + simp only [norm_one,mul_one,Complex.ofReal_mul] + ring + · rw [ite_eq_right hs,priorityOuter_zero p hg x.cube negative Ψ m (selector x) ray core D (not_ne_iff.mp hs)] + simp + +theorem global_second_energy_source + (hp:∀i,p i≠0)(hinj:Function.Injective (fun i=>Ideal.span {p i})) + (outer:Finset (Source ι Jo))(pool:Finset ι)(selector:Source ι Jo→Finset ι→ℂ) + (houter:∀x∈outer,x.quotientSupport=∅)(extra:CubeCoordinates ι→Finset ι) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:ℝ→ℂ)(X t Y:ℝ): + (∑x∈outer,firstWholePrioritySecondEnergy p hp hg hinj pool x.cube x.firstCommon + (extra x.cube) negative Ψ m (primeSubsetGenerator (fun i=>Ideal.span {p i}) x.firstDivisor) + slots lists a (selector x) om X t Y)= + (32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + (∑x∈globalParentSource outer pool selector, + globalPriorityOuter p hg negative Ψ m ray core + (fun x=>(‖selector (eraseFirstQuotient x) x.quotientSupport‖:ℂ)) x* + (‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots J (fun i=>lists i\extra x.cube) + a om X t Y ray core (parent p x)).re:=by + have hs (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(J:Finset σ): + (∑x∈globalParentSource outer pool selector, + globalPriorityOuter p hg negative Ψ m ray core + (fun x=>(‖selector (eraseFirstQuotient x) x.quotientSupport‖:ℂ)) x* + (‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots J (fun i=>lists i\extra x.cube) + a om X t Y ray core (parent p x))= + ∑x∈outer,∑D∈pool.powerset,(priorityOuter p hg x.cube negative Ψ m (selector x) ray core D:ℂ)* + (‖primeMark J lists a ((extra x.cube∪((if negative then x.cube.rightDivisor else x.cube.leftDivisor)∪x.firstCommon))∪D)‖^2:ℝ)* + wholePriorityPoisson p hp hg hinj pool x.cube x.firstCommon x.firstDivisor (extra x.cube) + negative Ψ m slots J lists a om X t Y ray core D:=by + simp_rw [mul_assoc] + rw [global_original_priority_slice p hg outer pool selector houter negative Ψ m ray core] + apply Finset.sum_congr rfl + intro x hx + apply Finset.sum_congr rfl + intro D hD + have hm : wholeExtractedSupport (fun x=>extra x.cube) negative (fillFirstQuotient x D)= + ((extra x.cube∪((if negative then x.cube.rightDivisor else x.cube.leftDivisor)∪x.firstCommon))∪D) := by + simp only [wholeExtractedSupport,extractedSupport,fillFirstQuotient,Finset.union_assoc] + rw [hm] + have hf : fillFirstQuotient x D = fixedPoint x.cube x.firstCommon x.firstDivisor x.oldAssigned D := by + cases x;rfl + rw [hf] + change (priorityOuter p hg x.cube negative Ψ m (selector x) ray core D:ℂ)* + ((‖primeMark J lists a ((extra x.cube∪((if negative then x.cube.rightDivisor else x.cube.leftDivisor)∪x.firstCommon))∪D)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots J (fun i=>lists i\extra x.cube) + a om X t Y ray core (parent p (fixedPoint x.cube x.firstCommon x.firstDivisor x.oldAssigned D))) = _ + rw [parentPoisson_fixed_whole p hp hg hinj] + simp_rw [hs] + simp only [Complex.re_sum,Complex.mul_re,Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,mul_zero,zero_mul,sub_zero,add_zero] + unfold firstWholePrioritySecondEnergy + simp only [Finset.mul_sum,wholePriorityPoisson,priorityOuter] + rw [Finset.sum_comm (s:=outer)] + apply Finset.sum_congr rfl + intro ray hray + simp_rw [Finset.sum_comm (s:=pool.powerset) (t:=(Finset.univ : Finset FirstCoreIndex))] + rw [Finset.sum_comm (s:=outer)] + apply Finset.sum_congr rfl + intro core hcore + simp_rw [Finset.sum_comm (s:=pool.powerset) (t:=slots.powerset)] + rw [Finset.sum_comm (s:=outer)] + apply Finset.sum_congr rfl + intro J hJ + apply Finset.sum_congr rfl + intro x hx + apply Finset.sum_congr rfl + intro D hD + ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalParentSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalParentSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..d8dd8a9fdf2442f7a976c29be03dfce8f1b6a1c7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalParentSource.lean @@ -0,0 +1,67 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open InverseFirstPriorityParents +variable {ι:Type*} [DecidableEq ι] {Jo:ℕ} +def eraseFirstQuotient (x:Source ι Jo):Source ι Jo:= {x with quotientSupport:=∅} +def fillFirstQuotient (x:Source ι Jo)(D:Finset ι):Source ι Jo:={x with quotientSupport:=D} +omit [DecidableEq ι] in +@[simp] theorem erase_fillFirstQuotient (x:Source ι Jo)(D:Finset ι): + eraseFirstQuotient (fillFirstQuotient x D)=eraseFirstQuotient x:=rfl +omit [DecidableEq ι] in +@[simp] theorem eraseFirstQuotient_eq (x:Source ι Jo)(hx:x.quotientSupport=∅): + eraseFirstQuotient x=x:=by cases x;simpa [eraseFirstQuotient] using hx.symm + +def globalParentSource (outer:Finset (Source ι Jo))(pool:Finset ι) + (selector:Source ι Jo→Finset ι→ℂ):Finset (Source ι Jo):= + outer.biUnion (fun x=>(pool.powerset.filter (fun D=>selector x D≠0)).image (fillFirstQuotient x)) + +omit [DecidableEq ι] in +theorem sum_globalParentSource {A:Type*}[AddCommMonoid A] + (outer:Finset (Source ι Jo))(pool:Finset ι)(selector:Source ι Jo→Finset ι→ℂ) + (houter:∀x∈outer,x.quotientSupport=∅)(H:Source ι Jo→A): + ∑x∈globalParentSource outer pool selector,H x= + ∑x∈outer,∑D∈pool.powerset.filter (fun D=>selector x D≠0),H (fillFirstQuotient x D):=by + unfold globalParentSource + rw [Finset.sum_biUnion] + · apply Finset.sum_congr rfl + intro x hx + exact Finset.sum_image (fun D hD E hE he=>congrArg Source.quotientSupport he) + · intro x hx y hy hxy + apply Finset.disjoint_left.mpr + intro z hz hz' + obtain ⟨D,hD,rfl⟩:=Finset.mem_image.mp hz + obtain ⟨E,hE,he⟩:=Finset.mem_image.mp hz' + have he':=congrArg eraseFirstQuotient he + simp only [erase_fillFirstQuotient,eraseFirstQuotient_eq _ (houter x hx), + eraseFirstQuotient_eq _ (houter y hy)] at he' + exact hxy he'.symm + +omit [DecidableEq ι] in +theorem mem_globalParentSource + (outer:Finset (Source ι Jo))(pool:Finset ι)(selector:Source ι Jo→Finset ι→ℂ) + (houter:∀x∈outer,x.quotientSupport=∅)(x:Source ι Jo): + x∈globalParentSource outer pool selector ↔ + eraseFirstQuotient x∈outer ∧ x.quotientSupport⊆pool ∧ + selector (eraseFirstQuotient x) x.quotientSupport≠0:=by + constructor + · intro hx + obtain ⟨y,hy,hyx⟩:=Finset.mem_biUnion.mp hx + obtain ⟨D,hD,rfl⟩:=Finset.mem_image.mp hyx + simp only [erase_fillFirstQuotient,eraseFirstQuotient_eq _ (houter y hy)] + exact ⟨hy,Finset.mem_powerset.mp (Finset.mem_filter.mp hD).1,(Finset.mem_filter.mp hD).2⟩ + · rintro ⟨hx,hD,hs⟩ + apply Finset.mem_biUnion.mpr + refine ⟨eraseFirstQuotient x,hx,Finset.mem_image.mpr ⟨x.quotientSupport,?_,?_⟩⟩ + · exact Finset.mem_filter.mpr ⟨Finset.mem_powerset.mpr hD,hs⟩ + · cases x;rfl +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..0d016d436c9b0a2bd5ee51f5133fa17fb80a2f01 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMass.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Inversion.FirstPriorityParents +import OAI.NumberTheory.DirichletL.Descent.PrincipalSelectorMass + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalPrincipalMass +open InverseMoment InverseFirstPriorityParents InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open IdealMobiusDivisorSum (idealDivisors mem_idealDivisors) +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +abbrev Core (ι : Type*) := CubeCoordinates ι×Finset ι×Finset ι + +def core {ι : Type*} {Jo : ℕ} (x : Source ι Jo) : Core ι := + (x.cube,x.firstCommon,x.quotientSupport) + +def divisorTarget {ι : Type*} [DecidableEq ι] (p : ι→O) (q : Core ι) : Ideal O := + sourceIdeal p q.1.support*sourceIdeal p q.2.1*sourceIdeal p q.2.2 + +lemma divisorTarget_ne_zero {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] (q : Core ι) : divisorTarget p q≠0 := + mul_ne_zero (mul_ne_zero (sourceIdeal_ne_zero p hp _) (sourceIdeal_ne_zero p hp _)) + (sourceIdeal_ne_zero p hp _) + +lemma firstDivisor_dvd_target {ι : Type*} [DecidableEq ι] (p : ι→O) + [∀i,(Ideal.span {p i}).IsMaximal] {Jo : ℕ} (x : Source ι Jo) (hx : SourceValid p x) : + sourceIdeal p x.firstDivisor∣divisorTarget p (core x) := by + have hd := sourceIdeal_dvd p _ _ hx.first_divisor + rw [sourceIdeal_union p _ _ hx.common_disjoint] at hd + apply hd.trans + change sourceIdeal p x.firstCommon*sourceIdeal p x.cube.support∣ + sourceIdeal p x.cube.support*sourceIdeal p x.firstCommon*sourceIdeal p x.quotientSupport + rw [mul_comm (sourceIdeal p x.firstCommon)] + exact dvd_mul_right _ _ + +theorem core_fiber_card {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] + (hinj : Function.Injective (fun i=>Ideal.span {p i})) {Jo : ℕ} + (S : Finset (Source ι Jo)) (q : Core ι) + (hS : ∀x∈S,SourceValid p x) (hq : ∀x∈S,core x=q) : + S.card≤(idealDivisors (divisorTarget p q)).card^(Jo+1) := by + let D := idealDivisors (divisorTarget p q) + have hD := divisorTarget_ne_zero p hp q + let encode (x : S) : D×(Fin Jo→D) := + (⟨sourceIdeal p x.val.firstDivisor,(mem_idealDivisors hD).mpr (by + simpa only [hq x.val x.property] using firstDivisor_dvd_target p x.val (hS x.val x.property))⟩, + fun i=>⟨(x.val.oldAssigned i).val,(mem_idealDivisors hD).mpr (by + have hh := (hS x.val x.property).old_support i + change (x.val.oldAssigned i).val∣divisorTarget p (core x.val) at hh + simpa only [hq x.val x.property] using hh)⟩) + have hi : Function.Injective encode := by + intro x y he + have hk := (hq x.val x.property).trans (hq y.val y.property).symm + have hd : x.val.firstDivisor=y.val.firstDivisor := + sourceIdeal_injective p hinj (congrArg (fun z=>z.1.val) he) + have ho : x.val.oldAssigned=y.val.oldAssigned := by + funext i + apply Subtype.ext + exact congrArg (fun z=>(z.2 i).val) he + apply Subtype.ext + exact Source.ext (congrArg Prod.fst hk) (congrArg (fun q=>q.2.1) hk) hd + (congrArg (fun q=>q.2.2) hk) ho + have hh := Fintype.card_le_of_injective encode hi + simpa only [Fintype.card_coe,Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,D,pow_succ,mul_comm] using hh + +theorem core_fiber_small_power (Jmax : ℕ) (eps : ℝ) (heps : 0Ideal.span {p i})) + (Jo : ℕ),Jo≤Jmax → ∀(S : Finset (Source ι Jo))(q : Core ι), + (∀x∈S,SourceValid p x) → (∀x∈S,core x=q) → + (S.card:ℝ)≤C*(Ideal.absNorm (divisorTarget p q):ℝ)^eps := by + obtain ⟨D,hD,hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power + (eps/(Jmax+1)) (by positivity) + refine ⟨D^(Jmax+1),by positivity,?_⟩ + intro ι _ p hp _ hinj Jo hJo S q hS hq + have h0 := divisorTarget_ne_zero p hp q + have hcard : S.card≤(idealDivisors (divisorTarget p q)).card^(Jmax+1) := + (core_fiber_card p hp hinj S q hS hq).trans + (Nat.pow_le_pow_right (InverseInitialFibers.divisor_card_pos _ h0) (Nat.add_le_add_right hJo 1)) + have hb := pow_le_pow_left₀ (Nat.cast_nonneg _) (hdiv _ h0) (Jmax+1) + apply (show (S.card:ℝ)≤((idealDivisors (divisorTarget p q)).card:ℝ)^(Jmax+1) by exact_mod_cast hcard).trans + apply hb.trans_eq + rw [mul_pow] + congr 1 + rw [←Real.rpow_natCast,←Real.rpow_mul (Nat.cast_nonneg _)] + congr 1 + push_cast + field_simp + +lemma divisorTarget_norm_bound {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] (q : Core ι) (B V T : ℝ) + (hB : 0≤B) (hV : 0≤V) (_hT : 0≤T) + (hb₁ : ‖eisEmbedding (primeProduct p q.1.support q.1.leftExponent)‖^2≤B) + (hb₂ : ‖eisEmbedding (primeProduct p q.1.support q.1.rightExponent)‖^2≤B) + (hC : primeProductNorm p q.2.1≤V) (ht : primeProductNorm p q.2.2≤T) : + (Ideal.absNorm (divisorTarget p q):ℝ)≤B^2*V*T := by + unfold divisorTarget + simp only [map_mul,Nat.cast_mul,sourceIdeal,←eisEmbedding_norm_sq_eq_absNorm_span] + change primeProductNorm p q.1.support*primeProductNorm p q.2.1*primeProductNorm p q.2.2≤_ + exact mul_le_mul (mul_le_mul (cubeCoordinates_radical_bound p hp q.1 B hB hb₁ hb₂) + hC (primeProductNorm_pos p hp _).le (sq_nonneg _)) ht (primeProductNorm_pos p hp _).le + (mul_nonneg (sq_nonneg _) hV) + +end SevenEighths.InverseMomentGlobalPrincipalMass +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassCount.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassCount.lean new file mode 100644 index 0000000000000000000000000000000000000000..b68cde013bea504fcce35ba16398bb93d76bccff --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassCount.lean @@ -0,0 +1,104 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPrincipalMass + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalPrincipalMass +open InverseMoment InverseFirstPriorityParents InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +lemma support_family_card {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (S : Finset (Finset ι)) (U : ℝ) (hU : 0Ideal.span {p i})) + (Jo : ℕ),Jo≤Jmax → ∀(S : Finset (Source ι Jo))(B H V T : ℝ), + 1≤B → 0≤H → 0x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤H) → + (∀x∈S,primeProductNorm p x.firstCommon≤V) → + (∀x∈S,primeProductNorm p x.quotientSupport≤T) → + (S.card:ℝ)≤C*B^(1+eps)*H*V*T*(B^2*V*T)^eps := by + obtain ⟨Cf,hCf,hfiber⟩ := core_fiber_small_power Jmax eps heps + obtain ⟨Cb,hCb,hcube⟩ := cube_coordinates_parity_count eps heps + refine ⟨Cf*Cb*128^2,by positivity,?_⟩ + intro ι _ p hp _ hinj Jo hJo S B H V T hB hH hV hT hS hleft hright hactive hcommon hquot + let Q := S.image core + let bs := S.image Source.cube + let cs := S.image Source.firstCommon + let ts := S.image Source.quotientSupport + have hbcount : (bs.card:ℝ)≤Cb*B^(1+eps)*H := hcube p hp hinj bs B H hB hH + (by intro b hb;obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hb;exact (hS x hx).admissible) + (by intro b hb;obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hb;exact hleft x hx) + (by intro b hb;obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hb;exact hright x hx) + (by intro b hb;obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hb;exact hactive x hx) + have hccount : (cs.card:ℝ)≤128*V := support_family_card p hp hinj cs V hV + (by intro A hA;obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hA;exact hcommon x hx) + have htcount : (ts.card:ℝ)≤128*T := support_family_card p hp hinj ts T hT + (by intro A hA;obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hA;exact hquot x hx) + have hsub : Q⊆bs×ˢ(cs×ˢts) := by + intro q hq + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hq + exact Finset.mem_product.mpr ⟨Finset.mem_image_of_mem _ hx, + Finset.mem_product.mpr ⟨Finset.mem_image_of_mem _ hx,Finset.mem_image_of_mem _ hx⟩⟩ + have hQcard : (Q.card:ℝ)≤(Cb*B^(1+eps)*H)*(128*V)*(128*T) := by + have hh : (Q.card:ℝ)≤(bs.card:ℝ)*((cs.card:ℝ)*(ts.card:ℝ)) := by + exact_mod_cast (Finset.card_le_card hsub).trans_eq (by simp only [Finset.card_product]) + apply hh.trans + calc + _ ≤ (Cb*B^(1+eps)*H)*((128*V)*(128*T)) := by gcongr + _ = _ := by ring + have hF (q : Core ι) (hq : q∈Q) : + ((S.filter (fun x=>core x=q)).card:ℝ)≤Cf*(B^2*V*T)^eps := by + have hf := hfiber p hp hinj Jo hJo (S.filter (fun x=>core x=q)) q + (fun x hx=>hS x (Finset.mem_filter.mp hx).1) (fun x hx=>(Finset.mem_filter.mp hx).2) + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hq + apply hf.trans + apply mul_le_mul_of_nonneg_left _ hCf.le + exact Real.rpow_le_rpow (Nat.cast_nonneg _) + (divisorTarget_norm_bound p hp (core x) B V T (zero_le_one.trans hB) hV.le hT.le + (hleft x hx) (hright x hx) (hcommon x hx) (hquot x hx)) heps.le + have he : (S.card:ℝ)=∑q∈Q,((S.filter (fun x=>core x=q)).card:ℝ) := by + calc + _ = ∑_x∈S,(1:ℝ) := by simp + _ = ∑q∈Q,∑_x∈S.filter (fun x=>core x=q),(1:ℝ) := + (Finset.sum_fiberwise_of_maps_to (fun x hx=>Finset.mem_image_of_mem core hx) _).symm + _ = _ := by simp + rw [he] + calc + _ ≤ ∑_q∈Q,Cf*(B^2*V*T)^eps := Finset.sum_le_sum hF + _ = (Q.card:ℝ)*(Cf*(B^2*V*T)^eps) := by simp + _ ≤ ((Cb*B^(1+eps)*H)*(128*V)*(128*T))*(Cf*(B^2*V*T)^eps) := + mul_le_mul_of_nonneg_right hQcard (by positivity) + _ = _ := by ring + +end SevenEighths.InverseMomentGlobalPrincipalMass +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassPrefactor.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassPrefactor.lean new file mode 100644 index 0000000000000000000000000000000000000000..6558f02bfac5db69e0402e240a9d667915ed136f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassPrefactor.lean @@ -0,0 +1,97 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPrincipalMassSource +import OAI.NumberTheory.DirichletL.Descent.PhysicalExponents + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalPrincipalMass +open InverseMoment InverseFirstPriorityParents InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +def physicalPrincipalFactor (Z M r ell V delta A B R j t eta tau eps window : ℝ) : ℝ := + (Z^(firstKappa M r ell V delta A B R)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)* + (Z^(r-A-B-t)*Real.exp window)^(1+eps) + +lemma principal_nominal_identity (M r ell V delta A B R j t : ℝ) : + firstKappa M r ell V delta A B R+firstPhysicalHeight M r ell V delta B j+ + (r-A-B-t)+(ell+R/2+B+t)=r+3*ell+V-B-j := by + unfold firstKappa firstPhysicalHeight + ring + +lemma physical_principal_exact (Z M r ell V delta A B R j t eta tau eps window loss : ℝ) + (hZ : 0Ideal.span {p i})) + (Jo : ℕ),Jo≤Jmax → ∀(S : Finset (Source ι Jo)) + (Z M r ell V delta A B R j t eta tau eps window pi : ℝ), + 1≤Z → 0≤ell+eta → 0≤eps → 0≤B → 0≤j → + eps*(r-A-B-t)+7*eta/2+dsmall*(3*ell+B+t+5*eta)+2*eps*(2*ell+B+t+4*eta)≤pi+eta/2 → + (∀x∈S,SourceValid p x) → + (∀x∈S,‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta)) → + (∀x∈S,‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta)) → + (∀x∈S,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(R+eta)) → + (∀x∈S,primeProductNorm p x.firstCommon≤Z^(B+eta)) → + (∀x∈S,primeProductNorm p x.quotientSupport≤Z^(t+eta)) → + ∀(extra : CubeCoordinates ι→Finset ι)(negative : Bool), + (∀x∈S,extra x.cube⊆x.cube.support) → + physicalPrincipalFactor Z M r ell V delta A B R j t eta tau eps window* + (∑x∈S,(primeProductNorm p (principalSupport extra negative x))^(2*eps))≤ + C*Real.exp (window*(1+eps))*Z^(r+3*ell+V+17*eta+tau+pi) := by + obtain ⟨C,hC,hsource⟩ := original_weighted_source Jmax dsmall hdsmall + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ hinj Jo hJo S Z M r ell V delta A B R j t eta tau eps window pi hZ hell heps hB hj hcost hS hb₁ hb₂ hactive hcommon hquot extra negative hextra + let loss := 7*eta/2+dsmall*(3*ell+B+t+5*eta)+2*eps*(2*ell+B+t+4*eta) + have hZp : 0 ActualEisensteinCubic.O + +lemma active_norm_of_square {ι : Type*} [DecidableEq ι] (p : ι→O) + (A : Finset ι) (Z R eta : ℝ) (hZ : 0Ideal.span {p i})) + (Jo : ℕ),Jo≤Jmax → ∀(S : Finset (Source ι Jo))(Z ell R Bfirst t eta a loss : ℝ), + 1≤Z → 0≤ell+eta → 0≤a → + 7*eta/2+delta*(3*ell+Bfirst+t+5*eta)+a*(2*ell+Bfirst+t+4*eta)≤loss → + (∀x∈S,SourceValid p x) → + (∀x∈S,‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta)) → + (∀x∈S,‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta)) → + (∀x∈S,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(R+eta)) → + (∀x∈S,primeProductNorm p x.firstCommon≤Z^(Bfirst+eta)) → + (∀x∈S,primeProductNorm p x.quotientSupport≤Z^(t+eta)) → + ∀(extra : CubeCoordinates ι→Finset ι)(negative : Bool), + (∀x∈S,extra x.cube⊆x.cube.support) → + (∑x∈S,(primeProductNorm p (principalSupport extra negative x))^a)≤ + C*Z^(ell+R/2+Bfirst+t+loss) := by + obtain ⟨C,hC,hraw⟩ := original_weighted_mass Jmax delta hdelta + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ hinj Jo hJo S Z ell R Bfirst t eta a loss hZ hell ha hloss hS hb₁ hb₂ hactive hcommon hquot extra negative hextra + have hZp : 0active_norm_of_square p _ Z R eta hZp (hactive x hx)) + hcommon hquot extra negative hextra + apply hh.trans + calc + _ = C*( (Z^(ell+eta))^(1+delta)*Z^((R+eta)/2)*Z^(Bfirst+eta)*Z^(t+eta)* + ((Z^(ell+eta))^2*Z^(Bfirst+eta)*Z^(t+eta))^(delta+a)) := by ring + _ = C*Z^(ell+R/2+Bfirst+t+7*eta/2+delta*(3*ell+Bfirst+t+5*eta)+a*(2*ell+Bfirst+t+4*eta)) := by + rw [weighted_mass_power Z ell R Bfirst t eta delta a hZp] + _ ≤ _ := mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hZ (by linarith)) hC.le + +end SevenEighths.InverseMomentGlobalPrincipalMass +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassWeighted.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassWeighted.lean new file mode 100644 index 0000000000000000000000000000000000000000..f633117caa1527238cda953125aeeaed85fcf17e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrincipalMassWeighted.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPrincipalMassCount + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalPrincipalMass +open InverseMoment InverseFirstPriorityParents InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +def principalSupport {ι : Type*} [DecidableEq ι] {Jo : ℕ} + (extra : CubeCoordinates ι→Finset ι) (negative : Bool) (x : Source ι Jo) : Finset ι := + (extra x.cube∪((if negative then x.cube.rightDivisor else x.cube.leftDivisor)∪x.firstCommon))∪x.quotientSupport + +lemma principalSupport_norm {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] {Jo : ℕ} + (extra : CubeCoordinates ι→Finset ι) (negative : Bool) (x : Source ι Jo) + (hx : SourceValid p x) (hextra : extra x.cube⊆x.cube.support) + (B V T : ℝ) (hB : 0≤B) (hV : 0≤V) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤B) + (hC : primeProductNorm p x.firstCommon≤V) (ht : primeProductNorm p x.quotientSupport≤T) : + primeProductNorm p (principalSupport extra negative x)≤B^2*V*T := by + have hh := first_whole_extracted_norm p hp x.cube hx.admissible x.firstCommon (extra x.cube) + hextra negative B hB hb₁ hb₂ + unfold principalSupport + apply (primeProductNorm_union_le_mul p hp _ _).trans + exact mul_le_mul (hh.trans (mul_le_mul_of_nonneg_left hC (sq_nonneg _))) ht + (primeProductNorm_pos p hp _).le (mul_nonneg (sq_nonneg _) hV) + +theorem original_weighted_mass (Jmax : ℕ) (eps : ℝ) (heps : 0Ideal.span {p i})) + (Jo : ℕ),Jo≤Jmax → ∀(S : Finset (Source ι Jo))(B H V T a : ℝ), + 1≤B → 0≤H → 0x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤H) → + (∀x∈S,primeProductNorm p x.firstCommon≤V) → + (∀x∈S,primeProductNorm p x.quotientSupport≤T) → + ∀(extra : CubeCoordinates ι→Finset ι)(negative : Bool), + (∀x∈S,extra x.cube⊆x.cube.support) → + (∑x∈S,(primeProductNorm p (principalSupport extra negative x))^a)≤ + C*B^(1+eps)*H*V*T*(B^2*V*T)^(eps+a) := by + obtain ⟨C,hC,hcount⟩ := original_source_card Jmax eps heps + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ hinj Jo hJo S B H V T a hB hH hV hT ha hS hb₁ hb₂ hactive hcommon hquot extra negative hextra + have hcard := hcount p hp hinj Jo hJo S B H V T hB hH hV hT hS hb₁ hb₂ hactive hcommon hquot + have hBp : 0 + Real.rpow_le_rpow (primeProductNorm_pos p hp _).le + (principalSupport_norm p hp extra negative x (hS x hx) (hextra x hx) B V T hBp.le hV.le + (hb₁ x hx) (hb₂ x hx) (hcommon x hx) (hquot x hx)) ha) + _ = (S.card:ℝ)*(B^2*V*T)^a := by simp + _ ≤ (C*B^(1+eps)*H*V*T*(B^2*V*T)^eps)*(B^2*V*T)^a := + mul_le_mul_of_nonneg_right hcard (by positivity) + _ = _ := by rw [mul_assoc,←Real.rpow_add (by positivity : 0ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +def globalPriorityRetainedAggregate + (p:ι→Eis)[∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hp:∀i,p i≠0)(hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + {Jo:ℕ}(extra:CubeCoordinates ι→Finset ι)(pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo))(w:InverseFirstPriorityParents.Source ι Jo→ℂ) + (negative:Bool)(Ψ:Eis→*ℂ)(m:Eis)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (V:𝓢(ℝ,ℂ))(X Y:ℝ)(R:Finset ι→Finset ι→ℝ):ℝ:= + (32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z* + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative J lists) (fun _=>R), + globalPriorityWeight p hg negative Ψ m ray core w J a x* + wholeRow p hp hcop hg extra pool negative (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) + m slots J lists a V X Y z x‖ + +theorem global_priority_retained_aggregate + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff); + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2))) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityRetainedAggregate p hg hp hcop extra pool original w + negative Ψ m slots lists a (principalWindow om lo hi hlo hsupport negative t) X Y cutoff ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,Cbin,hC,hCbin,he⟩:= + global_priority_retained_all_rays (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ J K εmass hεmass + let Ctot:=(32*512)*(4:ℝ)^K*(Fintype.card (RayCharacter×RayCharacter):ℝ)* + (Fintype.card FirstCoreIndex:ℝ)*C + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,Ctot,Cbin,by dsimp [Ctot];positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A hslots hA hdata + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:=C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) + have hb (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ)(ha:assigned⊆slots): + P*‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff), + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖≤H:=by + obtain ⟨haassigned,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hcube₁,hcube₂,hactive,hj,hquot,hΨ, + ha₁,ha₂,hlabels,ho,hslots₁,hslots₂,hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,hleft,hright⟩:=hdata ray core assigned ha + exact he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a (fun _=>cutoff) + Y (R assigned) L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t (labels assigned) A + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA' hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hZ:1‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff), + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ + change ∀ray core assigned, assigned⊆slots → P*S ray core assigned≤H at hb + change P*((32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑assigned∈slots.powerset,S ray core assigned)≤_ + calc + _=(32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑assigned∈slots.powerset,P*S ray core assigned:=by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro ray hr + apply Finset.sum_congr rfl + intro core hc + apply Finset.sum_congr rfl + intro assigned ha + ring + _≤(32*512)*(2:ℝ)^slots.card*∑_ray:RayCharacter×RayCharacter,∑_core:FirstCoreIndex,∑_assigned∈slots.powerset,H:=by + apply mul_le_mul_of_nonneg_left _ (by positivity) + exact Finset.sum_le_sum fun ray _=>Finset.sum_le_sum fun core _=>Finset.sum_le_sum fun assigned ha=>hb ray core assigned (Finset.mem_powerset.mp ha) + _=(32*512)*(4:ℝ)^slots.card*(Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ)*H:=by + simp only [Finset.sum_const,Finset.card_univ,Finset.card_powerset,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + rw [show (4:ℝ)^slots.card=(2:ℝ)^slots.card*(2:ℝ)^slots.card by rw [←mul_pow];norm_num] + ring + _≤(32*512)*(4:ℝ)^K*(Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ)*H:=by gcongr + _= _:=by dsimp [Ctot,H];ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityBranches.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityBranches.lean new file mode 100644 index 0000000000000000000000000000000000000000..3c56731ce188b633b5eefcfd438420811295a530 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityBranches.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityBranches +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseInitialArithmetic InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityValidSource InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +open InverseMomentWholePriorityPhysical InversePrioritySecondSource InverseSecondPrincipalCaller +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] {Jo:ℕ} +variable (p:ι→Eis) [∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem global_priority_signed_branches + (hp:∀i,p i≠0) (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (Source ι Jo)) (w:Source ι Jo→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0extra x.cube) original negative assigned lists + let source:=unifiedSource p pool parents (fun _=>R) + (∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots assigned (fun i=>lists i\extra x.cube) a om X t Y ray core (parent p x))= + (∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p x))+ + (∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * ∑x∈source, + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a V X Y z x)+ + (∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p x)) := by + intro V Ψ₀ parents source + rw [global_priority_physical_source p hp hcop hg hinj hc hpr extra pool original negative Ψ m ray core w + slots assigned lists a om lo hi hlo hs X t Y hX hY R] + rw [wholePaired_parent_sq_sum p (fun x=>extra x.cube) hinj original negative assigned lists a + (globalPriorityOuter p hg negative Ψ m ray core w) + (priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R), + wholePaired_parent_sq_sum p (fun x=>extra x.cube) hinj original negative assigned lists a + (globalPriorityOuter p hg negative Ψ m ray core w) + (priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R)] + rfl + +theorem global_priority_slice_bound + (hp:∀i,p i≠0) (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (Source ι Jo)) (w:Source ι Jo→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0extra x.cube) original negative assigned lists + let source:=unifiedSource p pool parents (fun _=>R) + ‖∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots assigned (fun i=>lists i\extra x.cube) a om X t Y ray core (parent p x)‖≤ + (∑x∈original,‖globalPriorityOuter p hg negative Ψ m ray core w x‖* + ‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2* + ‖priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p x)‖)+ + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * ∑x∈source, + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a V X Y z x‖+ + (∑x∈original,‖globalPriorityOuter p hg negative Ψ m ray core w x‖* + ‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2* + ‖priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p x)‖) := by + intro V Ψ₀ parents source + rw [global_priority_signed_branches p hg hp hcop hinj hc hpr extra pool original w negative + Ψ m ray core slots assigned lists a om lo hi hlo hs X t Y hX hY R] + have hn (H:Source ι Jo→ℂ): + ‖∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)*H x‖≤ + ∑x∈original,‖globalPriorityOuter p hg negative Ψ m ray core w x‖* + ‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2*‖H x‖:=by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro x hx + rw [norm_mul,norm_mul,Complex.norm_real,Real.norm_of_nonneg (sq_nonneg _)] + exact (norm_add_le _ _).trans (add_le_add ((norm_add_le _ _).trans (add_le_add (hn _) (le_refl _))) (hn _)) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce08171d61cda8d34fadb0d7e10d0aad492aae67 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityEnergy.lean @@ -0,0 +1,145 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityRetainedMovingRadius +import OAI.NumberTheory.DirichletL.Descent.GlobalPrioritySource +import OAI.NumberTheory.DirichletL.Inversion.WholePriorityRetainedSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_retained_moving_radius + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) +, + let source:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀(z:SecondRayIndex) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y:ℂ)*secondRayCoefficient z * + ∑x∈source,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,Cbin,hC,hCbin,he⟩:= + actual_priority_retained_moving_radius (ι:=ι) (σ:=σ) om rowMajorant lo hi hlo hsupport negative + caps hcaps B₀ hB₀ J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,coefficientBound*C,Cbin,mul_nonneg coefficientBound_pos.le hC,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff source Ψ₀ z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hsource:ActualSecondSourceConditions p source:= + unified_conditions p hp extra original hvalid hextra negative assigned lists pool cutoff + have hd:∀x∈source,∀i∈InverseMomentWholeRetainedSource.deleted p extra negative x, + i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient:= + unified_deleted_support p hinj extra original hvalid hextra negative assigned lists pool cutoff + have hw:∀x∈source,‖normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x‖≤1:= + fun x hx=>normalizedGlobalPriorityWeight_norm p hg hinj extra original pool negative Ψ m ray core w hwOriginal hΨ + assigned lists a haassigned cutoff x hx + have hΨ₀:∀n,‖Ψ₀ n‖≤1:=fun n=>(firstCoreTwist_norm_le negative (if negative then ray.1 else ray.2) + Ψ core n).trans (hΨ n) + have he₀:=he p hp hcop hg hpr hinj hc source hsource pool Ψ₀ m z (slots\assigned) (slots\assigned) + lists lists a a (InverseMomentWholeRetainedSource.deleted p extra negative) + (InverseMomentWholeRetainedSource.deleted p extra negative) + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t + (normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a) labels A + hd hd hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ₀ hw + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hrow:∀x:MarkedSecondSource ι (Jo+(assigned.card+assigned.card)) 0,wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x= + actualSecondSignedWeight p hp hcop hg Ψ₀ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x* + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ₀ m z) + (slots\assigned) (slots\assigned) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) a a + (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) + rowMajorant Y X:=fun x=>wholeRow_eq p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a _ X Y z x + rw [globalPriority_sum_normalized p hg negative Ψ m ray core w assigned a source] + rw [show (Y:ℂ)*secondRayCoefficient z*((coefficientBound:ℂ)* + ∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x)= + (coefficientBound:ℂ)*((Y:ℂ)*secondRayCoefficient z* + ∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x) by ring] + rw [norm_mul,Complex.norm_real,Real.norm_of_nonneg coefficientBound_pos.le] + simp_rw [hrow,←mul_assoc] + convert mul_le_mul_of_nonneg_left he₀ coefficientBound_pos.le using 1 <;> ring_nf + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredAggregate.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredAggregate.lean new file mode 100644 index 0000000000000000000000000000000000000000..83daebc66d11d55bd7f1749d42d7477067aa3c3c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredAggregate.lean @@ -0,0 +1,166 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityAggregate +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredRays +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_filtered_aggregate + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + hi≤b → slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=InverseMomentGlobalRetainedGates.geometrySource p (unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff)) b X; + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2))) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityRetainedAggregate p hg hp hcop extra pool original w + negative Ψ m slots lists a (principalWindow om lo hi hlo hsupport negative t) X Y cutoff ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + global_priority_filtered_all_rays (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + let Ctot:=(32*512)*(4:ℝ)^K*(Fintype.card (RayCharacter×RayCharacter):ℝ)* + (Fintype.card FirstCoreIndex:ℝ)*C + refine ⟨Ctot,Cbin,by dsimp [Ctot];positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A hhib hslots hA hdata + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:=C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) + have hb (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ)(ha:assigned⊆slots): + P*‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff), + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖≤H:=by + obtain ⟨haassigned,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hcube₁,hcube₂,hactive,hj,hquot,hΨ, + ha₁,ha₂,hlabels,ho,hslots₁,hslots₂,hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,hleft,hright⟩:=hdata ray core assigned ha + exact he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a (fun _=>cutoff) + Y (R assigned) L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t (labels assigned) A + hhib haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA' hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hZ:1‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff), + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ + change ∀ray core assigned, assigned⊆slots → P*S ray core assigned≤H at hb + change P*((32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑assigned∈slots.powerset,S ray core assigned)≤_ + calc + _=(32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑assigned∈slots.powerset,P*S ray core assigned:=by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro ray hr + apply Finset.sum_congr rfl + intro core hc + apply Finset.sum_congr rfl + intro assigned ha + ring + _≤(32*512)*(2:ℝ)^slots.card*∑_ray:RayCharacter×RayCharacter,∑_core:FirstCoreIndex,∑_assigned∈slots.powerset,H:=by + apply mul_le_mul_of_nonneg_left _ (by positivity) + exact Finset.sum_le_sum fun ray _=>Finset.sum_le_sum fun core _=>Finset.sum_le_sum fun assigned ha=>hb ray core assigned (Finset.mem_powerset.mp ha) + _=(32*512)*(4:ℝ)^slots.card*(Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ)*H:=by + simp only [Finset.sum_const,Finset.card_univ,Finset.card_powerset,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + rw [show (4:ℝ)^slots.card=(2:ℝ)^slots.card*(2:ℝ)^slots.card by rw [←mul_pow];norm_num] + ring + _≤(32*512)*(4:ℝ)^K*(Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ)*H:=by gcongr + _= _:=by dsimp [Ctot,H];ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredAggregateUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredAggregateUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..21570bfc292fb04c0d88c0fc7783b17745056f10 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredAggregateUniform.lean @@ -0,0 +1,167 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredAggregate +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredRaysUniform +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityAggregate +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredRays +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +theorem global_priority_filtered_aggregate_uniform_types + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + hi≤b → slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=InverseMomentGlobalRetainedGates.geometrySource p (unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff)) b X; + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2))) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityRetainedAggregate p hg hp hcop extra pool original w + negative Ψ m slots lists a (principalWindow om lo hi hlo hsupport negative t) X Y cutoff ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + global_priority_filtered_all_rays_uniform_types om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + let Ctot:=(32*512)*(4:ℝ)^K*(Fintype.card (RayCharacter×RayCharacter):ℝ)* + (Fintype.card FirstCoreIndex:ℝ)*C + refine ⟨Ctot,Cbin,by dsimp [Ctot];positivity,hCbin,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A hhib hslots hA hdata + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:=C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) + have hb (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ)(ha:assigned⊆slots): + P*‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff), + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖≤H:=by + obtain ⟨haassigned,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hcube₁,hcube₂,hactive,hj,hquot,hΨ, + ha₁,ha₂,hlabels,ho,hslots₁,hslots₂,hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,hleft,hright⟩:=hdata ray core assigned ha + exact he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a (fun _=>cutoff) + Y (R assigned) L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t (labels assigned) A + hhib haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA' hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hZ:1‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈unifiedSource p pool (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff), + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ + change ∀ray core assigned, assigned⊆slots → P*S ray core assigned≤H at hb + change P*((32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑assigned∈slots.powerset,S ray core assigned)≤_ + calc + _=(32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑assigned∈slots.powerset,P*S ray core assigned:=by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro ray hr + apply Finset.sum_congr rfl + intro core hc + apply Finset.sum_congr rfl + intro assigned ha + ring + _≤(32*512)*(2:ℝ)^slots.card*∑_ray:RayCharacter×RayCharacter,∑_core:FirstCoreIndex,∑_assigned∈slots.powerset,H:=by + apply mul_le_mul_of_nonneg_left _ (by positivity) + exact Finset.sum_le_sum fun ray _=>Finset.sum_le_sum fun core _=>Finset.sum_le_sum fun assigned ha=>hb ray core assigned (Finset.mem_powerset.mp ha) + _=(32*512)*(4:ℝ)^slots.card*(Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ)*H:=by + simp only [Finset.sum_const,Finset.card_univ,Finset.card_powerset,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + rw [show (4:ℝ)^slots.card=(2:ℝ)^slots.card*(2:ℝ)^slots.card by rw [←mul_pow];norm_num] + ring + _≤(32*512)*(4:ℝ)^K*(Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ)*H:=by gcongr + _= _:=by dsimp [Ctot,H];ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..2aeeafa53166b5216aa9ab5ced28533471aa1ca9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredEnergy.lean @@ -0,0 +1,161 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityRetainedMovingRadiusWindowOrder +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesGeometry +import OAI.NumberTheory.DirichletL.Descent.GlobalPrioritySource +import OAI.NumberTheory.DirichletL.Inversion.WholePriorityRetainedSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_filtered_moving_radius + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) +, + let originalSource:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀(z:SecondRayIndex) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + let source:=InverseMomentGlobalRetainedGates.geometrySource p originalSource b X; + hi≤b → + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y:ℂ)*secondRayCoefficient z * + ∑x∈originalSource,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_priority_retained_moving_radius_window_order (ι:=ι) (σ:=σ) om rowMajorant lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + refine ⟨coefficientBound*C,Cbin,mul_nonneg coefficientBound_pos.le hC,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff originalSource Ψ₀ z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A source hhib + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hsub:source⊆originalSource:=InverseMomentGlobalRetainedGates.geometrySource_subset p originalSource b X + have hsource:ActualSecondSourceConditions p source:= + ActualSecondSourceConditions.mono p (unified_conditions p hp extra original hvalid hextra negative assigned lists pool cutoff) hsub + have hd:∀x∈source,∀i∈InverseMomentWholeRetainedSource.deleted p extra negative x, + i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient:= + fun x hx=>unified_deleted_support p hinj extra original hvalid hextra negative assigned lists pool cutoff x (hsub hx) + have hw:∀x∈source,‖normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x‖≤1:= + fun x hx=>normalizedGlobalPriorityWeight_norm p hg hinj extra original pool negative Ψ m ray core w hwOriginal hΨ + assigned lists a haassigned cutoff x (hsub hx) + have hΨ₀:∀n,‖Ψ₀ n‖≤1:=fun n=>(firstCoreTwist_norm_le negative (if negative then ray.1 else ray.2) + Ψ core n).trans (hΨ n) + have he₀:=he p hp hcop hg hpr hinj hc source hsource pool Ψ₀ m z (slots\assigned) (slots\assigned) + lists lists a a (InverseMomentWholeRetainedSource.deleted p extra negative) + (InverseMomentWholeRetainedSource.deleted p extra negative) + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t + (normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a) labels A + hd hd hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ₀ hw + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hrow:∀x:MarkedSecondSource ι (Jo+(assigned.card+assigned.card)) 0,wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x= + actualSecondSignedWeight p hp hcop hg Ψ₀ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x* + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ₀ m z) + (slots\assigned) (slots\assigned) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) a a + (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) + rowMajorant Y X:=fun x=>wholeRow_eq p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a _ X Y z x + have hupper:∀y,principalWindow om lo hi hlo hsupport negative t y≠0 → y≤b:=by + intro y hy + have hy':y∈Function.support om:=by + rw [←principalWindow_support om lo hi hlo hsupport negative t] + exact hy + exact (hsupport hy').2.trans hhib + rw [InverseMomentGlobalRetainedGates.original_retained_geometry_sum p hp hcop hg extra pool originalSource + (globalPriorityWeight p hg negative Ψ m ray core w assigned a) negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y b hX hupper z] + rw [globalPriority_sum_normalized p hg negative Ψ m ray core w assigned a source] + rw [show (Y:ℂ)*secondRayCoefficient z*((coefficientBound:ℂ)* + ∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x)= + (coefficientBound:ℂ)*((Y:ℂ)*secondRayCoefficient z* + ∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x) by ring] + rw [norm_mul,Complex.norm_real,Real.norm_of_nonneg coefficientBound_pos.le] + simp_rw [hrow,←mul_assoc] + convert mul_le_mul_of_nonneg_left he₀ coefficientBound_pos.le using 1 <;> ring_nf + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredEnergyUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredEnergyUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..b5f1c6b82e12c2bf84a9bec514e674767fce5308 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredEnergyUniform.lean @@ -0,0 +1,162 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredEnergy +import OAI.NumberTheory.DirichletL.Descent.PriorityRetainedMovingRadiusWindowOrderUniform +import OAI.NumberTheory.DirichletL.Descent.PriorityRetainedMovingRadiusWindowOrder +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesGeometry +import OAI.NumberTheory.DirichletL.Descent.GlobalPrioritySource +import OAI.NumberTheory.DirichletL.Inversion.WholePriorityRetainedSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +theorem global_priority_filtered_moving_radius_uniform_types + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) +, + let originalSource:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀(z:SecondRayIndex) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + let source:=InverseMomentGlobalRetainedGates.geometrySource p originalSource b X; + hi≤b → + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y:ℂ)*secondRayCoefficient z * + ∑x∈originalSource,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_priority_retained_moving_radius_window_order_uniform_types om rowMajorant lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + refine ⟨coefficientBound*C,Cbin,mul_nonneg coefficientBound_pos.le hC,hCbin,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff originalSource Ψ₀ z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A source hhib + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hsub:source⊆originalSource:=InverseMomentGlobalRetainedGates.geometrySource_subset p originalSource b X + have hsource:ActualSecondSourceConditions p source:= + ActualSecondSourceConditions.mono p (unified_conditions p hp extra original hvalid hextra negative assigned lists pool cutoff) hsub + have hd:∀x∈source,∀i∈InverseMomentWholeRetainedSource.deleted p extra negative x, + i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient:= + fun x hx=>unified_deleted_support p hinj extra original hvalid hextra negative assigned lists pool cutoff x (hsub hx) + have hw:∀x∈source,‖normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x‖≤1:= + fun x hx=>normalizedGlobalPriorityWeight_norm p hg hinj extra original pool negative Ψ m ray core w hwOriginal hΨ + assigned lists a haassigned cutoff x (hsub hx) + have hΨ₀:∀n,‖Ψ₀ n‖≤1:=fun n=>(firstCoreTwist_norm_le negative (if negative then ray.1 else ray.2) + Ψ core n).trans (hΨ n) + have he₀:=he p hp hcop hg hpr hinj hc source hsource pool Ψ₀ m z (slots\assigned) (slots\assigned) + lists lists a a (InverseMomentWholeRetainedSource.deleted p extra negative) + (InverseMomentWholeRetainedSource.deleted p extra negative) + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t + (normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a) labels A + hd hd hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ₀ hw + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hrow:∀x:MarkedSecondSource ι (Jo+(assigned.card+assigned.card)) 0,wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x= + actualSecondSignedWeight p hp hcop hg Ψ₀ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x* + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ₀ m z) + (slots\assigned) (slots\assigned) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) a a + (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) + rowMajorant Y X:=fun x=>wholeRow_eq p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a _ X Y z x + have hupper:∀y,principalWindow om lo hi hlo hsupport negative t y≠0 → y≤b:=by + intro y hy + have hy':y∈Function.support om:=by + rw [←principalWindow_support om lo hi hlo hsupport negative t] + exact hy + exact (hsupport hy').2.trans hhib + rw [InverseMomentGlobalRetainedGates.original_retained_geometry_sum p hp hcop hg extra pool originalSource + (globalPriorityWeight p hg negative Ψ m ray core w assigned a) negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y b hX hupper z] + rw [globalPriority_sum_normalized p hg negative Ψ m ray core w assigned a source] + rw [show (Y:ℂ)*secondRayCoefficient z*((coefficientBound:ℂ)* + ∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x)= + (coefficientBound:ℂ)*((Y:ℂ)*secondRayCoefficient z* + ∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x) by ring] + rw [norm_mul,Complex.norm_real,Real.norm_of_nonneg coefficientBound_pos.le] + simp_rw [hrow,←mul_assoc] + convert mul_le_mul_of_nonneg_left he₀ coefficientBound_pos.le using 1 <;> ring_nf + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredRays.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredRays.lean new file mode 100644 index 0000000000000000000000000000000000000000..d7a321199a3e6e2e2d4bf2a24c14a92c19e733e3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredRays.lean @@ -0,0 +1,134 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_filtered_all_rays + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) +, + let originalSource:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀ + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + let source:=InverseMomentGlobalRetainedGates.geometrySource p originalSource b X; + hi≤b → + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈originalSource,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + global_priority_filtered_moving_radius (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + refine ⟨C*(512*32^2),Cbin,by positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff originalSource Ψ₀ + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A source hhib + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:= (1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild) + let S:SecondRayIndex→ℂ:=fun z=>(Y:ℂ)*secondRayCoefficient z * + ∑x∈originalSource,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x + have hP:0≤P:=by dsimp [P];positivity + have hH:0≤H:=by dsimp [H];positivity + have hz (z:SecondRayIndex):P*‖S z‖≤C*A*H*‖secondRayCoefficient z‖:=by + have h:=he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + hhib haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass + (hleft z) (hright z) + convert h using 1 ; dsimp only [P,S,H] ; ring + calc + _≤P*∑z:SecondRayIndex,‖S z‖:=mul_le_mul_of_nonneg_left (norm_sum_le _ _) hP + _=∑z:SecondRayIndex,P*‖S z‖:=Finset.mul_sum _ _ _ + _≤∑z:SecondRayIndex,C*A*H*‖secondRayCoefficient z‖:=Finset.sum_le_sum (fun z _=>hz z) + _=C*A*H*(∑z:SecondRayIndex,‖secondRayCoefficient z‖):=(Finset.mul_sum _ _ _).symm + _≤C*A*H*(512*32^2):=mul_le_mul_of_nonneg_left secondRayCoefficient_mass (by positivity) + _= _:=by dsimp [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredRaysUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredRaysUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..487e0f788e5bc013f692997b9060ae5f664f659e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredRaysUniform.lean @@ -0,0 +1,135 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredRays +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredEnergyUniform +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +theorem global_priority_filtered_all_rays_uniform_types + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) +, + let originalSource:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀ + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + let source:=InverseMomentGlobalRetainedGates.geometrySource p originalSource b X; + hi≤b → + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈originalSource,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + global_priority_filtered_moving_radius_uniform_types om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + refine ⟨C*(512*32^2),Cbin,by positivity,hCbin,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff originalSource Ψ₀ + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A source hhib + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:= (1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild) + let S:SecondRayIndex→ℂ:=fun z=>(Y:ℂ)*secondRayCoefficient z * + ∑x∈originalSource,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x + have hP:0≤P:=by dsimp [P];positivity + have hH:0≤H:=by dsimp [H];positivity + have hz (z:SecondRayIndex):P*‖S z‖≤C*A*H*‖secondRayCoefficient z‖:=by + have h:=he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + hhib haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass + (hleft z) (hright z) + convert h using 1 ; dsimp only [P,S,H] ; ring + calc + _≤P*∑z:SecondRayIndex,‖S z‖:=mul_le_mul_of_nonneg_left (norm_sum_le _ _) hP + _=∑z:SecondRayIndex,P*‖S z‖:=Finset.mul_sum _ _ _ + _≤∑z:SecondRayIndex,C*A*H*‖secondRayCoefficient z‖:=Finset.sum_le_sum (fun z _=>hz z) + _=C*A*H*(∑z:SecondRayIndex,‖secondRayCoefficient z‖):=(Finset.mul_sum _ _ _).symm + _≤C*A*H*(512*32^2):=mul_le_mul_of_nonneg_left secondRayCoefficient_mass (by positivity) + _= _:=by dsimp [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredStep.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredStep.lean new file mode 100644 index 0000000000000000000000000000000000000000..1459c07626950aa4b5bd45ab9d3479b9219395cf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFilteredStep.lean @@ -0,0 +1,170 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredAggregate +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFullAggregate + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseFirstPriorityParents InversePrioritySecondSource InverseMomentGlobalPriorityTail +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_filtered_physical_step + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + hi≤b → (slots:Set σ).PairwiseDisjoint lists→slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=InverseMomentGlobalRetainedGates.geometrySource p (unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff)) b X; + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2))) → + Jo≤Jmax→0≤ell+eta→0≤Bfirst→0≤j→ + εmass*(r-Acol-Bfirst-tcount)+7*eta/2+dsmall*(3*ell+Bfirst+tcount+5*eta)+ + 2*εmass*(2*ell+Bfirst+tcount+4*eta)≤pi+eta/2→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(Ractive+eta))→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^(Bfirst+eta))→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^(tcount+eta))→ + 1≤Y→1≤X*Real.exp window→Y≤Z^Lcap→Y⁻¹≤Z^Lcap→X*Real.exp window≤Z^Lcap→ + firstKappa M r ell V delta Acol Bfirst Ractive+(9/2:ℝ)*eta≤Lcap→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (∏i∈cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^Lcap)→ + (∀G E,0≤cutoff G E)→ + (∀x∈original,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp window) Y (Z^tau)≤cutoff G E.val)→ + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj extra pool original w negative Ψ m slots lists a om X t Y ≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild)+Ctail*Z^(-saving) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + global_priority_filtered_aggregate (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + obtain ⟨sz,Cz,hCz,hzero⟩:=global_priority_zero_physical εmass hεmass Jmax dsmall hdsmall + obtain ⟨st,Ct,hCt,htail⟩:=global_physical_tail_rapid Jmax Lcap tau saving hLcap htau + let Cz':=Cz*(4:ℝ)^K*(sz.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)*(SchwartzMap.seminorm ℝ 0 0 om)^2*Real.exp (window*(1+εmass)) + let Ct':=Ct*(4:ℝ)^K*(st.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)*(SchwartzMap.seminorm ℝ 0 0 om)^2 + refine ⟨C,Cbin,Cz',Ct',hC,hCbin,by dsimp [Cz'];positivity,by dsimp [Ct'];positivity,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hw Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst pi b ρ t labels A + hhib hdisj hslots hA hdata hJo hell hBfirst hj hcost hcube₁ hcube₂ hactive hcommon hquotient + hYone hscale hy hyi hx hPcap hcubeCap₁ hcubeCap₂ hactiveCap hcommonCap hquotCap hrad hcutoff + have hh:=hdata 1 1 ∅ (Finset.empty_subset _) + obtain ⟨_,hρ,hL,hZ,hX,hY,heta,hbin,_,_,_,_,_,_,hΨall,_,_,_,_,_,_,_,hYe,hXe,hLe,_,hZ2,_,_,_,_,_,_,_⟩:=hh + have hz:0ActualEisensteinCubic.O +theorem global_priority_filtered_physical_step_uniform_types + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + hi≤b → (slots:Set σ).PairwiseDisjoint lists→slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=InverseMomentGlobalRetainedGates.geometrySource p (unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff)) b X; + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6→ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2))) → + Jo≤Jmax→0≤ell+eta→0≤Bfirst→0≤j→ + εmass*(r-Acol-Bfirst-tcount)+7*eta/2+dsmall*(3*ell+Bfirst+tcount+5*eta)+ + 2*εmass*(2*ell+Bfirst+tcount+4*eta)≤pi+eta/2→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(Ractive+eta))→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^(Bfirst+eta))→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^(tcount+eta))→ + 1≤Y→1≤X*Real.exp window→Y≤Z^Lcap→Y⁻¹≤Z^Lcap→X*Real.exp window≤Z^Lcap→ + firstKappa M r ell V delta Acol Bfirst Ractive+(9/2:ℝ)*eta≤Lcap→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (∏i∈cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^Lcap)→ + (∀G E,0≤cutoff G E)→ + (∀x∈original,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp window) Y (Z^tau)≤cutoff G E.val)→ + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj extra pool original w negative Ψ m slots lists a om X t Y ≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild)+Ctail*Z^(-saving) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + global_priority_filtered_aggregate_uniform_types om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,Cbin,hC,hCbin,he⟩:=hordered J + obtain ⟨sz,Cz,hCz,hzero⟩:=global_priority_zero_physical εmass hεmass Jmax dsmall hdsmall + obtain ⟨st,Ct,hCt,htail⟩:=global_physical_tail_rapid Jmax Lcap tau saving hLcap htau + let Cz':=Cz*(4:ℝ)^K*(sz.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)*(SchwartzMap.seminorm ℝ 0 0 om)^2*Real.exp (window*(1+εmass)) + let Ct':=Ct*(4:ℝ)^K*(st.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)*(SchwartzMap.seminorm ℝ 0 0 om)^2 + refine ⟨C,Cbin,Cz',Ct',hC,hCbin,by dsimp [Cz'];positivity,by dsimp [Ct'];positivity,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hw Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst pi b ρ t labels A + hhib hdisj hslots hA hdata hJo hell hBfirst hj hcost hcube₁ hcube₂ hactive hcommon hquotient + hYone hscale hy hyi hx hPcap hcubeCap₁ hcubeCap₂ hactiveCap hcommonCap hquotCap hrad hcutoff + have hh:=hdata 1 1 ∅ (Finset.empty_subset _) + obtain ⟨_,hρ,hL,hZ,hX,hY,heta,hbin,_,_,_,_,_,_,hΨall,_,_,_,_,_,_,_,hYe,hXe,hLe,_,hZ2,_,_,_,_,_,_,_⟩:=hh + have hz:0ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_fixed_child_step + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + hi≤b → b≤bcap → (slots:Set σ).PairwiseDisjoint lists→slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=InverseMomentGlobalRetainedGates.geometrySource p (unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff)) b X; + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ s:ℝ,∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (childLogTest ω₁ s) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(1+‖s‖)^(2*J)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ s:ℝ,∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (childLogTest ω₂ s) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(1+‖s‖)^(2*J))) → + Jo≤Jmax→0≤ell+eta→0≤Bfirst→0≤j→ + εmass*(r-Acol-Bfirst-tcount)+7*eta/2+dsmall*(3*ell+Bfirst+tcount+5*eta)+ + 2*εmass*(2*ell+Bfirst+tcount+4*eta)≤pi+eta/2→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(Ractive+eta))→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^(Bfirst+eta))→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^(tcount+eta))→ + 1≤Y→1≤X*Real.exp window→Y≤Z^Lcap→Y⁻¹≤Z^Lcap→X*Real.exp window≤Z^Lcap→ + firstKappa M r ell V delta Acol Bfirst Ractive+(9/2:ℝ)*eta≤Lcap→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (∏i∈cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^Lcap)→ + (∀G E,0≤cutoff G E)→ + (∀x∈original,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp window) Y (Z^tau)≤cutoff G E.val)→ + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj extra pool original w negative Ψ m slots lists a om X t Y ≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder (2*J))* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild)+Ctail*Z^(-saving) := by + obtain ⟨v₁,v₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hstep⟩:= + global_priority_filtered_physical_step (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + window Lcap tau saving hhi hLcap htau Jmax dsmall hdsmall caps hcaps B₀ hB₀ K εmass hεmass + obtain ⟨w₁,a₁,b₁,ha₁,hab₁,hw₁,hsw₁,hfixed₁⟩:=canonical_actual_child_uniform + v₁ af bf bcap haf hbcap ((subset_tsupport _).trans hs₁) (v₁.smooth ⊤) + obtain ⟨w₂,a₂,b₂,ha₂,hab₂,hw₂,hsw₂,hfixed₂⟩:=canonical_actual_child_uniform + v₂ af bf bcap haf hbcap ((subset_tsupport _).trans hs₂) (v₂.smooth ⊤) + refine ⟨w₁,w₂,min a₁ a₂,max b₁ b₂,lt_min ha₁ ha₂, + (min_le_left _ _).trans (hab₁.trans (le_max_left _ _)),hw₁,hw₂, + hsw₁.trans (Set.Icc_subset_Icc (min_le_left _ _) (le_max_left _ _)), + hsw₂.trans (Set.Icc_subset_Icc (min_le_right _ _) (le_max_right _ _)),?_⟩ + intro J + obtain ⟨C₁,hC₁,he₁⟩:=hfixed₁ J + obtain ⟨C₂,hC₂,he₂⟩:=hfixed₂ J + obtain ⟨C,Cbin,Czero,Ctail,hC,hCbin,hCzero,hCtail,he⟩:=hstep (2*J) + let Cmax:=max C₁ C₂ + have hmax:0≤Cmax:=hC₁.le.trans (le_max_left _ _) + refine ⟨C*Cmax,Cbin,Czero,Ctail,mul_nonneg hC hmax,hCbin,hCzero,hCtail,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hw Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst pi b ρ t labels A + hhib hbcap' hdisj hslots hA hdata hJo hell hBfirst hj hcost hcube₁ hcube₂ hactive hcommon hquotient + hYone hscale hy hyi hx hPcap hcubeCap₁ hcubeCap₂ hactiveCap hcommonCap hquotCap hrad hcutoff + have hout:=he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hw Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst pi b ρ t labels (Cmax*A) + hhib hdisj hslots (mul_nonneg hmax hA) + have hnew: + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj extra pool original w negative Ψ m slots lists a om X t Y ≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*(Cmax*A)*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder (2*J))* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild)+Ctail*Z^(-saving) := by + apply hout + · intro ray core assigned hassigned + obtain ⟨haa,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hb₁,hb₂,hactive',hj',hq,hΨ, + hal,har,hlabels,ho,hsl,hsr,hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,hleft,hright⟩:=hdata ray core assigned hassigned + refine ⟨haa,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hb₁,hb₂,hactive',hj',hq,hΨ, + hal,har,hlabels,ho,hsl,hsr,mul_nonneg hmax hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,?_,?_⟩ + · intro z d hd u J₁ hJ₁ γ hγ + have hgeomcell:=source_cell_joint_bound p hp _ (fun x hx=>(Finset.mem_erase.mp (hrows x hx)).1) b X hgeom d hd + have hh:=he₁ p hp hcop hg hpr pool _ _ ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (fun f hf=>pow_nonneg (Nat.cast_nonneg _) _) Z X _ + (A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild)) d false u hZ hX + (hgeomcell.trans (mul_le_mul_of_nonneg_right hbcap' hX.le)) (mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _)) + (fun s=>hleft z d hd s J₁ hJ₁ γ hγ) + change _≤(Cmax*A)*Z^(_)*_ + apply hh.trans + have hH:0≤tripleHeight (2*J) u.1*coordinateHeight (2*J) u.2:=by + unfold tripleHeight coordinateHeight + positivity + have hE:0≤A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild):= + mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _) + convert mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (le_max_left C₁ C₂) hE) hH using 1 ; ring + · intro z d hd u J₂ hJ₂ γ hγ + have hgeomcell:=source_cell_joint_bound p hp _ (fun x hx=>(Finset.mem_erase.mp (hrows x hx)).1) b X hgeom d hd + have hh:=he₂ p hp hcop hg hpr pool _ _ ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (fun f hf=>pow_nonneg (Nat.cast_nonneg _) _) Z X _ + (A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild)) d true u hZ hX + (hgeomcell.trans (mul_le_mul_of_nonneg_right hbcap' hX.le)) (mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _)) + (fun s=>hright z d hd s J₂ hJ₂ γ hγ) + change _≤(Cmax*A)*Z^(_)*_ + apply hh.trans + have hH:0≤tripleHeight (2*J) u.1*coordinateHeight (2*J) u.2:=by + unfold tripleHeight coordinateHeight + positivity + have hE:0≤A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild):= + mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _) + convert mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (le_max_right C₁ C₂) hE) hH using 1 ; ring + all_goals assumption + convert hnew using 1 ; ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFixedChildStepUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFixedChildStepUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..903c5118a6a8581e31fa48b27d3e646d9e306fe1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFixedChildStepUniform.lean @@ -0,0 +1,205 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFixedChildStep +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredStepUniform +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFilteredStep +import OAI.NumberTheory.DirichletL.Descent.ClippedChild + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseFirstPriorityParents InversePrioritySecondSource InverseMomentGlobalPriorityTail +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +theorem global_priority_fixed_child_step_uniform_types + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:Finset ι→Finset ι→ℝ) +, + ∀ + (Y:ℝ) (R:Finset σ→BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : Finset σ→BlockIndex→Finset (Ideal Eis)) (A : ℝ), + hi≤b → b≤bcap → (slots:Set σ).PairwiseDisjoint lists→slots.card≤K → 0≤A → (∀(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(assigned:Finset σ), assigned⊆slots → + let source:=InverseMomentGlobalRetainedGates.geometrySource p (unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) (fun _=>cutoff)) b X; + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core; + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) ∧ + (∀ i,|ρ i| ≤ B₀ i) ∧ + 0 ≤ L ∧ + 1 < Z ∧ + 0 < X ∧ + 0 < Y ∧ + 0≤eta ∧ + 2≤Z^eta ∧ + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R assigned (index p x))) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) ∧ + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) ∧ + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) ∧ + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) ∧ + (∀ a,‖Ψ a‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) ∧ + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels assigned d) ∧ + Jo+(assigned.card+assigned.card) ≤ 2*K ∧ + (slots\assigned).card ≤ K ∧ + (slots\assigned).card ≤ K ∧ + 0 ≤ A ∧ + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) ∧ + X=Z^(r-Acol-Bfirst-tcount) ∧ + L=eta*Real.log Z ∧ + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) ∧ + 2≤Z ∧ + 1≤b ∧ + b≤Z^(6*eta) ∧ + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) ∧ + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) ∧ + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ s:ℝ,∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (childLogTest ω₁ s) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(1+‖s‖)^(2*J)) ∧ + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ s:ℝ,∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (childLogTest ω₂ s) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(1+‖s‖)^(2*J))) → + Jo≤Jmax→0≤ell+eta→0≤Bfirst→0≤j→ + εmass*(r-Acol-Bfirst-tcount)+7*eta/2+dsmall*(3*ell+Bfirst+tcount+5*eta)+ + 2*εmass*(2*ell+Bfirst+tcount+4*eta)≤pi+eta/2→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^(ell+eta))→ + (∀x∈original,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(Ractive+eta))→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^(Bfirst+eta))→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^(tcount+eta))→ + 1≤Y→1≤X*Real.exp window→Y≤Z^Lcap→Y⁻¹≤Z^Lcap→X*Real.exp window≤Z^Lcap→ + firstKappa M r ell V delta Acol Bfirst Ractive+(9/2:ℝ)*eta≤Lcap→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^Lcap)→ + (∀x∈original,‖ConcreteTraceCRT.eisEmbedding (∏i∈cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^Lcap)→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^Lcap)→ + (∀G E,0≤cutoff G E)→ + (∀x∈original,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp window) Y (Z^tau)≤cutoff G E.val)→ + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj extra pool original w negative Ψ m slots lists a om X t Y ≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder (2*J))* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild)+Ctail*Z^(-saving) := by + obtain ⟨v₁,v₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hstep⟩:= + global_priority_filtered_physical_step_uniform_types om lo hi hlo hsupport negative + window Lcap tau saving hhi hLcap htau Jmax dsmall hdsmall caps hcaps B₀ hB₀ K εmass hεmass + obtain ⟨w₁,a₁,b₁,ha₁,hab₁,hw₁,hsw₁,hfixed₁⟩:=canonical_actual_child_uniform + v₁ af bf bcap haf hbcap ((subset_tsupport _).trans hs₁) (v₁.smooth ⊤) + obtain ⟨w₂,a₂,b₂,ha₂,hab₂,hw₂,hsw₂,hfixed₂⟩:=canonical_actual_child_uniform + v₂ af bf bcap haf hbcap ((subset_tsupport _).trans hs₂) (v₂.smooth ⊤) + refine ⟨w₁,w₂,min a₁ a₂,max b₁ b₂,lt_min ha₁ ha₂, + (min_le_left _ _).trans (hab₁.trans (le_max_left _ _)),hw₁,hw₂, + hsw₁.trans (Set.Icc_subset_Icc (min_le_left _ _) (le_max_left _ _)), + hsw₂.trans (Set.Icc_subset_Icc (min_le_right _ _) (le_max_right _ _)),?_⟩ + intro J + obtain ⟨C₁,hC₁,he₁⟩:=hfixed₁ J + obtain ⟨C₂,hC₂,he₂⟩:=hfixed₂ J + obtain ⟨C,Cbin,Czero,Ctail,hC,hCbin,hCzero,hCtail,he⟩:=hstep (2*J) + let Cmax:=max C₁ C₂ + have hmax:0≤Cmax:=hC₁.le.trans (le_max_left _ _) + refine ⟨C*Cmax,Cbin,Czero,Ctail,mul_nonneg hC hmax,hCbin,hCzero,hCtail,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hw Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst pi b ρ t labels A + hhib hbcap' hdisj hslots hA hdata hJo hell hBfirst hj hcost hcube₁ hcube₂ hactive hcommon hquotient + hYone hscale hy hyi hx hPcap hcubeCap₁ hcubeCap₂ hactiveCap hcommonCap hquotCap hrad hcutoff + have hout:=he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hw Ψ m slots lists a cutoff + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst pi b ρ t labels (Cmax*A) + hhib hdisj hslots (mul_nonneg hmax hA) + have hnew: + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityOriginalEnergy p hg hp hinj extra pool original w negative Ψ m slots lists a om X t Y ≤ + Czero*Z^(r+3*ell+V+17*eta+tau+pi)+ + C*(Cmax*A)*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder (2*J))* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild)+Ctail*Z^(-saving) := by + apply hout + · intro ray core assigned hassigned + obtain ⟨haa,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hb₁,hb₂,hactive',hj',hq,hΨ, + hal,har,hlabels,ho,hsl,hsr,hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,hleft,hright⟩:=hdata ray core assigned hassigned + refine ⟨haa,hρ,hL,hZ,hX,hY,heta,hbin,hrows,hb₁,hb₂,hactive',hj',hq,hΨ, + hal,har,hlabels,ho,hsl,hsr,mul_nonneg hmax hA',hYe,hXe,hLe,hVe,hZ2,hb,hthreshold,hnorm,hgeom,hmass,?_,?_⟩ + · intro z d hd u J₁ hJ₁ γ hγ + have hgeomcell:=source_cell_joint_bound p hp _ (fun x hx=>(Finset.mem_erase.mp (hrows x hx)).1) b X hgeom d hd + have hh:=he₁ p hp hcop hg hpr pool _ _ ((slots\assigned)\J₁) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (fun f hf=>pow_nonneg (Nat.cast_nonneg _) _) Z X _ + (A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild)) d false u hZ hX + (hgeomcell.trans (mul_le_mul_of_nonneg_right hbcap' hX.le)) (mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _)) + (fun s=>hleft z d hd s J₁ hJ₁ γ hγ) + change _≤(Cmax*A)*Z^(_)*_ + apply hh.trans + have hH:0≤tripleHeight (2*J) u.1*coordinateHeight (2*J) u.2:=by + unfold tripleHeight coordinateHeight + positivity + have hE:0≤A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild):= + mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _) + convert mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (le_max_left C₁ C₂) hE) hH using 1 ; ring + · intro z d hd u J₂ hJ₂ γ hγ + have hgeomcell:=source_cell_joint_bound p hp _ (fun x hx=>(Finset.mem_erase.mp (hrows x hx)).1) b X hgeom d hd + have hh:=he₂ p hp hcop hg hpr pool _ _ ((slots\assigned)\J₂) lists a + ((labels assigned d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R assigned d)) (secondLabelWeight K) + (fun f hf=>pow_nonneg (Nat.cast_nonneg _) _) Z X _ + (A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild)) d true u hZ hX + (hgeomcell.trans (mul_le_mul_of_nonneg_right hbcap' hX.le)) (mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _)) + (fun s=>hright z d hd s J₂ hJ₂ γ hγ) + change _≤(Cmax*A)*Z^(_)*_ + apply hh.trans + have hH:0≤tripleHeight (2*J) u.1*coordinateHeight (2*J) u.2:=by + unfold tripleHeight coordinateHeight + positivity + have hE:0≤A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel d+εchild):= + mul_nonneg hA (Real.rpow_nonneg (zero_lt_one.trans hZ).le _) + convert mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (le_max_right C₁ C₂) hE) hH using 1 ; ring + all_goals assumption + convert hnew using 1 ; ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFullAggregate.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFullAggregate.lean new file mode 100644 index 0000000000000000000000000000000000000000..a265c00b10b61852748d4a48f33173b42ff7acf0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityFullAggregate.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityFullBranches + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion FirstCauchyArithmetic +open InverseSecondPrincipalCaller InversePrioritySecondSource InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityRetainedSource InverseMomentGlobalPriorityTail +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ]{Jo:ℕ} +variable (p:ι→O)[∀i,(Ideal.span {p i}).IsMaximal](hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) +def globalPriorityOriginalEnergy (hp:∀i,p i≠0)(hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι)(pool:Finset ι)(original:Finset (Source ι Jo))(w:Source ι Jo→ℂ) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:ℝ→ℂ)(X t Y:ℝ):ℝ:= + (32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + (∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots J (fun i=>lists i\extra x.cube) + a om X t Y ray core (parent p x)).re + +def globalPriorityTailAggregate (hp:∀i,p i≠0)(hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι)(pool:Finset ι)(original:Finset (Source ι Jo))(w:Source ι Jo→ℂ) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (V:𝓢(ℝ,ℂ))(X Y:ℝ)(R:Finset ι→Finset ι→ℝ):ℝ:= + (32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ‖∑y∈wholeAssignedParents p (fun x=>extra x.cube) original negative J lists, + coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) y* + priorityTailParent p hg hp hinj extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) + m slots J lists a V X Y R y‖ + +theorem global_priority_three_branches + (hp:∀i,p i≠0)(hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2)(hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι)(pool:Finset ι)(original:Finset (Source ι Jo))(w:Source ι Jo→ℂ) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] {Jo:ℕ} +variable (p:ι→Eis) [∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem global_priority_slice_full_tail + (hp:∀i,p i≠0) (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (Source ι Jo)) (w:Source ι Jo→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0extra x.cube) original negative assigned lists + let source:=unifiedSource p pool parents (fun _=>R) + ‖∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots assigned (fun i=>lists i\extra x.cube) a om X t Y ray core (parent p x)‖≤ + (∑x∈original,‖globalPriorityOuter p hg negative Ψ m ray core w x‖* + ‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2* + ‖priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p x)‖)+ + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * ∑x∈source, + globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a V X Y z x‖+ + ‖∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p x)‖ := by + intro V Ψ₀ parents source + rw [global_priority_signed_branches p hg hp hcop hinj hc hpr extra pool original w negative + Ψ m ray core slots assigned lists a om lo hi hlo hs X t Y hX hY R] + have hn (H:Source ι Jo→ℂ): + ‖∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)*H x‖≤ + ∑x∈original,‖globalPriorityOuter p hg negative Ψ m ray core w x‖* + ‖primeMark assigned lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2*‖H x‖:=by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro x hx + rw [norm_mul,norm_mul,Complex.norm_real,Real.norm_of_nonneg (sq_nonneg _)] + exact (norm_add_le _ _).trans (add_le_add ((norm_add_le _ _).trans (add_le_add (hn _) (le_refl _))) (le_refl _)) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..3ac56295208194fd37035b26dad9de3560159757 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityMass.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityBranches +import OAI.NumberTheory.DirichletL.Descent.GlobalPrincipalMassPrefactor + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InverseFirstPriorityParents InverseMomentWholePriorityParents InverseWholePriorityRetainedSource +open InverseSecondPrincipalCaller InversePrincipalEnergy FirstCauchyArithmetic +local notation "O"=>ActualEisensteinCubic.O + +theorem global_priority_weighted_branch (ε:ℝ)(hε:0<ε): + ∃Cb:ℝ,0Ideal.span {p i}))) + {Jo:ℕ}(original:Finset (Source ι Jo))(extra:CubeCoordinates ι→Finset ι) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(w:Source ι Jo→ℂ) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(B:ℝ), + (slots:Set σ).PairwiseDisjoint lists→(∀i∈slots,∀k∈lists i,‖a i k‖≤1)→ + (∀u,‖Ψ u‖≤1)→(∀x∈original,‖w x‖≤1)→0≤B→ + ∀U:(RayCharacter×RayCharacter)→FirstCoreIndex→Finset σ→Source ι Jo→ℝ, + (∀r core J,J∈slots.powerset→∀x∈original,0≤U r core J x)→ + (∀r core J,J∈slots.powerset→∀x∈original,U r core J x≤B)→ + (32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ∑x∈original,‖globalPriorityOuter p hg negative Ψ m r core w x‖* + ‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2*U r core J x≤ + Cb*(4:ℝ)^slots.card*B* + ∑x∈original,(primeProductNorm p (wholeExtractedSupport (fun x=>extra x.cube) negative x))^(2*ε):=by + obtain ⟨Cm,hCm,hmark⟩:=finite_primeMark_small_power ε hε + let Cr:ℝ:=Fintype.card (RayCharacter×RayCharacter) + let Cc:ℝ:=Fintype.card FirstCoreIndex + refine ⟨(32*512)*Cr*Cc*coefficientBound*Cm^2,by + have hr:0(primeProductNorm p (wholeExtractedSupport (fun x=>extra x.cube) negative x))^(2*ε) + have hn(x:Source ι Jo):0≤N x:=Real.rpow_nonneg (primeProductNorm_pos p hp _).le _ + have hm(J:Finset σ)(hJ:J∈slots.powerset)(x:Source ι Jo): + ‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2≤Cm^2*N x:=by + have hj:=Finset.mem_powerset.mp hJ + have hh:=hmark p hp hcop J lists a (fun i hi j hj' hij=>hslots (hj hi) (hj hj') hij) + (fun i hi=>ha i (hj hi)) (wholeExtractedSupport (fun x=>extra x.cube) negative x) + have he:((primeProductNorm p (wholeExtractedSupport (fun x=>extra x.cube) negative x))^ε)^2=N x:=by + dsimp [N] + rw [←Real.rpow_natCast,←Real.rpow_mul (primeProductNorm_pos p hp _).le] + congr 1;ring + exact (pow_le_pow_left₀ (norm_nonneg _) hh 2).trans_eq (by rw [mul_pow,he]) + have hw'(r:RayCharacter×RayCharacter)(core:FirstCoreIndex)(x:Source ι Jo)(hx:x∈original): + ‖globalPriorityOuter p hg negative Ψ m r core w x‖≤coefficientBound:=by + rw [globalPriorityOuter,norm_mul] + have ht:=priorityOuter_norm p hg x.cube negative Ψ m (fun _=>1) r core x.quotientSupport (by simp) (hΨ _) + exact (mul_le_mul (hw x hx) ht (norm_nonneg _) zero_le_one).trans_eq (one_mul _) + calc + _≤(32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ∑x∈original,coefficientBound*(Cm^2*N x)*B:=by + apply mul_le_mul_of_nonneg_left _ (by positivity) + apply Finset.sum_le_sum + intro r hr + apply Finset.sum_le_sum + intro core hc + apply Finset.sum_le_sum + intro J hJ + apply Finset.sum_le_sum + intro x hx + exact mul_le_mul (mul_le_mul (hw' r core x hx) (hm J hJ x) (sq_nonneg _) coefficientBound_pos.le) + (hU r core J hJ x hx) (hU0 r core J hJ x hx) (mul_nonneg coefficientBound_pos.le (mul_nonneg (sq_nonneg Cm) (hn x))) + _= _:=by + have hsum:(∑x∈original,coefficientBound*(Cm^2*N x)*B)= + coefficientBound*Cm^2*B*∑x∈original,N x:=by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intros;ring + rw [hsum] + simp only [Finset.sum_const,Finset.card_univ,Finset.card_powerset,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + have he:((2:ℝ)^slots.card)^2=(4:ℝ)^slots.card:=by rw [←pow_mul,pow_mul'];norm_num + rw [←he] + dsimp only [Cr,Cc,N] + ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..a3bd3f9b4fc7714613add29fdfa838c91e1149cc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityPhysical.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic SecondPassArithmetic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open InverseFirstPriorityParents InverseMomentWholePriorityParents InverseWholePriorityRetainedSource +open InverseMomentWholePriorityPhysical InversePrioritySecondSource InversePrincipalEnergy InverseSecondPrincipalCaller +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] {Jo:ℕ} +variable (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem global_priority_physical_source + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι)(pool:Finset ι)(original:Finset (Source ι Jo)) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex) + (w:Source ι Jo→ℂ)(slots J:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0extra x.cube) original negative J lists + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + let V:=principalWindow om lo hi hlo hs negative t + let H:=fun y:SecondParentSource ι (Jo+(J.card+J.card))=>markedRadial p (slots\J) + (residualLists p negative (fun i=>lists i\extra y.cube) y) a ∅ V X + let K:=fun y:SecondParentSource ι (Jo+(J.card+J.card))=>secondVariableCutoff p y R + let coeff:=coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) + (∑x∈original,globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots J (fun i=>lists i\extra x.cube) + a om X t Y ray core (parent p x))= + (∑y∈parents,coeff y*truncatedSecondZero p hg pool Ψ₀ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) (H y) rowMajorant Y (K y))+ + (∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z* + ∑x∈unifiedSource p pool parents (fun _=>R),globalPriorityWeight p hg negative Ψ m ray core w J a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots J lists a V X Y z x)+ + (∑y∈parents,coeff y*secondSourceTail p hp hg hinj pool Ψ₀ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) (H y) rowMajorant Y (K y)):=by + intro parents Ψ₀ V H K coeff + rw [whole_signed_source_full p hp hcop hg hinj hc hpr extra pool original + (globalPriorityOuter p hg negative Ψ m ray core w) negative Ψ m slots J lists a + om lo hi hlo hs X t Y hX hY ray core R (fun _ _=>())] + exact fullPhysical_unified p hg hp hcop hinj extra pool parents coeff negative Ψ m slots J lists a + V X Y ray core R (fun _ _=>()) +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityRays.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityRays.lean new file mode 100644 index 0000000000000000000000000000000000000000..72a1dce37708f5bcc6f860a2aa391a66fca5a797 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityRays.lean @@ -0,0 +1,129 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem global_priority_retained_all_rays + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (original:Finset (InverseFirstPriorityParents.Source ι Jo)) + (_hvalid:∀x∈original,InverseFirstPriorityParents.SourceValid p x) + (_hextra:∀x∈original,extra x.cube⊆x.cube.support) + (w:InverseFirstPriorityParents.Source ι Jo→ℂ) (_hw:∀x∈original,‖w x‖≤1) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) +, + let source:=unifiedSource p pool + (InverseMomentWholePriorityParents.wholeAssignedParents p (fun x=>extra x.cube) original negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀ + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈source,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,Cbin,hC,hCbin,he⟩:= + global_priority_retained_moving_radius (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C*(512*32^2),Cbin,by positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff source Ψ₀ + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:= (1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild) + let S:SecondRayIndex→ℂ:=fun z=>(Y:ℂ)*secondRayCoefficient z * + ∑x∈source,globalPriorityWeight p hg negative Ψ m ray core w assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x + have hP:0≤P:=by dsimp [P];positivity + have hH:0≤H:=by dsimp [H];positivity + have hz (z:SecondRayIndex):P*‖S z‖≤C*A*H*‖secondRayCoefficient z‖:=by + have h:=he p hp hcop hg hpr hinj hc extra pool original hvalid hextra w hwOriginal + Ψ m ray core slots assigned lists a cutoff z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass + (hleft z) (hright z) + convert h using 1 ; dsimp only [P,S,H] ; ring + calc + _≤P*∑z:SecondRayIndex,‖S z‖:=mul_le_mul_of_nonneg_left (norm_sum_le _ _) hP + _=∑z:SecondRayIndex,P*‖S z‖:=Finset.mul_sum _ _ _ + _≤∑z:SecondRayIndex,C*A*H*‖secondRayCoefficient z‖:=Finset.sum_le_sum (fun z _=>hz z) + _=C*A*H*(∑z:SecondRayIndex,‖secondRayCoefficient z‖):=(Finset.mul_sum _ _ _).symm + _≤C*A*H*(512*32^2):=mul_le_mul_of_nonneg_left secondRayCoefficient_mass (by positivity) + _= _:=by dsimp [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrioritySource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrioritySource.lean new file mode 100644 index 0000000000000000000000000000000000000000..b3074af3f415758a82f5ed055f76680eeb3fb944 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPrioritySource.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Inversion.WholePriorityRetainedSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic SecondPassArithmetic FirstPassCubeLabels FirstCauchyArithmetic RayFourExpansion +open InverseFirstPriorityParents InverseMomentWholePriorityParents InverseWholePriorityRetainedSource +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] {Jo:ℕ} +variable (p:ι→O)[∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def globalPriorityOuter (negative:Bool)(Ψ:O→*ℂ)(m:O) + (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(w:Source ι Jo→ℂ)(x:Source ι Jo):ℂ:= + w x*(priorityOuter p hg x.cube negative Ψ m (fun _=>1) ray core x.quotientSupport:ℂ) + +def globalPriorityWeight (negative:Bool)(Ψ:O→*ℂ)(m:O) + (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(w:Source ι Jo→ℂ) + (J:Finset σ)(a:σ→ι→ℂ)(x:MarkedSecondSource ι (Jo+(J.card+J.card)) 0):ℂ:= + coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) (secondParentOf x) + +def normalizedGlobalPriorityWeight (negative:Bool)(Ψ:O→*ℂ)(m:O) + (ray:RayCharacter×RayCharacter)(core:FirstCoreIndex)(w:Source ι Jo→ℂ) + (J:Finset σ)(a:σ→ι→ℂ)(x:MarkedSecondSource ι (Jo+(J.card+J.card)) 0):ℂ:= + globalPriorityWeight p hg negative Ψ m ray core w J a x/(coefficientBound:ℂ) + +theorem globalPriorityWeight_norm + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι)(original:Finset (Source ι Jo))(pool:Finset ι) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex) + (w:Source ι Jo→ℂ)(hw:∀x∈original,‖w x‖≤1)(hΨ:∀u,‖Ψ u‖≤1) + (J:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ha:∀i∈J,∀k∈lists i,‖a i k‖≤1) + (R:SecondParentSource ι (Jo+(J.card+J.card))→Finset ι→Finset ι→ℝ) + (x:MarkedSecondSource ι (Jo+(J.card+J.card)) 0) + (hx:x∈unifiedSource p pool (wholeAssignedParents p (fun x=>extra x.cube) original negative J lists) R): + ‖globalPriorityWeight p hg negative Ψ m ray core w J a x‖≤coefficientBound:=by + apply InverseMomentWholeRetainedSource.whole_coefficient_norm p hinj (fun x=>extra x.cube) + original negative J lists a _ coefficientBound ha + · intro y hy + rw [globalPriorityOuter,norm_mul] + have hn:=priorityOuter_norm p hg y.cube negative Ψ m (fun _=>1) ray core y.quotientSupport + (by simp) (hΨ _) + exact (mul_le_mul (hw y hy) hn (norm_nonneg _) zero_le_one).trans_eq (one_mul _) + · exact ((mem_unifiedSource p pool _ R x).mp hx).1 + +theorem normalizedGlobalPriorityWeight_norm + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι)(original:Finset (Source ι Jo))(pool:Finset ι) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex) + (w:Source ι Jo→ℂ)(hw:∀x∈original,‖w x‖≤1)(hΨ:∀u,‖Ψ u‖≤1) + (J:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(ha:∀i∈J,∀k∈lists i,‖a i k‖≤1) + (R:SecondParentSource ι (Jo+(J.card+J.card))→Finset ι→Finset ι→ℝ) + (x:MarkedSecondSource ι (Jo+(J.card+J.card)) 0) + (hx:x∈unifiedSource p pool (wholeAssignedParents p (fun x=>extra x.cube) original negative J lists) R): + ‖normalizedGlobalPriorityWeight p hg negative Ψ m ray core w J a x‖≤1:=by + rw [normalizedGlobalPriorityWeight,norm_div,Complex.norm_real,Real.norm_of_nonneg coefficientBound_pos.le] + exact (div_le_one coefficientBound_pos).mpr + (globalPriorityWeight_norm p hg hinj extra original pool negative Ψ m ray core w hw hΨ J lists a ha R x hx) + +omit [DecidableEq σ] in +theorem globalPriority_sum_normalized + (negative:Bool)(Ψ:O→*ℂ)(m:O)(ray:RayCharacter×RayCharacter)(core:FirstCoreIndex) + (w:Source ι Jo→ℂ)(J:Finset σ)(a:σ→ι→ℂ) + (source:Finset (MarkedSecondSource ι (Jo+(J.card+J.card)) 0)) + (H:MarkedSecondSource ι (Jo+(J.card+J.card)) 0→ℂ): + (∑x∈source,globalPriorityWeight p hg negative Ψ m ray core w J a x*H x)= + (coefficientBound:ℂ)*∑x∈source,normalizedGlobalPriorityWeight p hg negative Ψ m ray core w J a x*H x:=by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + unfold normalizedGlobalPriorityWeight + have hn:(coefficientBound:ℂ)≠0:=by exact_mod_cast coefficientBound_pos.ne' + field_simp +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..1f05809b75b427562150b1a343d979f2cb0f0b17 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTail.lean @@ -0,0 +1,127 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityTailMass +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityTailCollapse + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentGlobalPriorityTail +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseMomentGlobalPrincipalMass InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InversePrioritySecondSource InverseSecondPrincipalCaller InversePrincipalEnergy +open InverseWholePriorityRetainedSource FirstCauchyArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem global_parent_tail_rapid (Jmax : ℕ) (Lcap tau saving : ℝ) + (hLcap : 0≤Lcap) (htau : 0Ideal.span {p i})) + (_hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (Jo : ℕ),Jo≤Jmax → ∀(extra : CubeCoordinates ι→Finset ι)(pool : Finset ι) + (source : Finset (Source ι Jo))(negative : Bool)(Ψ : O→*ℂ)(m : O) + (ray : RayCharacter×RayCharacter)(core : FirstCoreIndex) + (w : Source ι Jo→ℂ)(slots J : Finset σ)(lists : σ→Finset ι)(a : σ→ι→ℂ), + J⊆slots → (slots:Set σ).PairwiseDisjoint lists → + (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → (∀u,‖Ψ u‖≤1) → (∀x∈source,‖w x‖≤1) → + ∀(om : 𝓢(ℝ,ℂ))(lo hi : ℝ)(hlo : 0x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap) → + (∀x∈source,primeProductNorm p x.firstCommon≤Z^Lcap) → + (∀x∈source,primeProductNorm p x.quotientSupport≤Z^Lcap) → + (∀x∈source,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp M) Y (Z^tau)≤R G E.val) → + ‖∑y∈wholeAssignedParents p (fun x=>extra x.cube) source negative J lists, + coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) y* + priorityTailParent p hg hp hinj extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) + m slots J lists a (principalWindow om lo hi hlo hs negative height) X Y R y‖≤ + C*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (SchwartzMap.seminorm ℝ 0 0 om)^2*Z^(-saving) := by + obtain ⟨s,Ct,hCt,htail⟩ := priority_tail_parent_uniform Lcap tau (saving+13*Lcap) hLcap htau + obtain ⟨Cm,hCm,hmark⟩ := finite_primeMark_small_power (1/2) (by norm_num) + obtain ⟨Cs,hCs,hmass⟩ := original_tail_mass Jmax + have hCb : 0(firstCoreTwist_norm_le negative _ Ψ core u).trans (hΨ u) + have hout (x : Source ι Jo) (hx : x∈source) : + ‖globalPriorityOuter p hg negative Ψ m ray core w x‖≤coefficientBound := by + rw [globalPriorityOuter,norm_mul] + exact (mul_le_mul (hw x hx) + (priorityOuter_norm p hg x.cube negative Ψ m (fun _=>1) ray core x.quotientSupport + (by simp) (hΨ _)) (norm_nonneg _) zero_le_one).trans_eq (one_mul _) + have hm (x : Source ι Jo) : + ‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2≤ + Cm^2*primeProductNorm p (principalSupport extra negative x) := by + have hh := hmark p hp hcop J lists a + (fun i hi j hj hij=>hslots (hJ hi) (hJ hj) hij) (fun i hi=>ha i (hJ hi)) + (principalSupport extra negative x) + have he : ((primeProductNorm p (principalSupport extra negative x))^(1/2:ℝ))^2= + primeProductNorm p (principalSupport extra negative x) := by + rw [←Real.rpow_natCast,←Real.rpow_mul (primeProductNorm_pos p hp _).le] + norm_num + have hsupp : wholeExtractedSupport (fun x=>extra x.cube) negative x=principalSupport extra negative x := by + simp only [wholeExtractedSupport,extractedSupport,principalSupport,Finset.union_assoc] + rw [hsupp] + exact (pow_le_pow_left₀ (norm_nonneg _) hh 2).trans_eq (by rw [mul_pow,he]) + have ht (x : Source ι Jo) (hx : x∈source) : + ‖priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots J lists a V X Y R (parent p x)‖≤T := by + simpa only [T,Q,mul_assoc] using htail p hp hg hinj hcop hc extra pool negative Ψ₀ m slots J lists a + hslots ha hΨ₀ om lo hi hlo hs X M Y Z height R hX hhi hZ hY hscale hy hyi hXcap + (parent p x) (hR x hx) + have hmass₀ := hmass p hp hinj Jo hJo source Z Lcap hZ hLcap hsource hb₁ hb₂ hactive hcommon hquot extra negative hextra + rw [original_paired_tail p hg hp hinj] + calc + _ ≤ ∑x∈source,‖globalPriorityOuter p hg negative Ψ m ray core w x* + (‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots J lists a V X Y R (parent p x)‖ := norm_sum_le _ _ + _ ≤ ∑x∈source,coefficientBound*(Cm^2*primeProductNorm p (principalSupport extra negative x))*T := by + apply Finset.sum_le_sum + intro x hx + rw [norm_mul,norm_mul,Complex.norm_real,Real.norm_of_nonneg (sq_nonneg _)] + exact mul_le_mul (mul_le_mul (hout x hx) (hm x) (sq_nonneg _) coefficientBound_pos.le) + (ht x hx) (norm_nonneg _) + (mul_nonneg hCb.le (mul_nonneg (sq_nonneg _) (primeProductNorm_pos p hp _).le)) + _ = coefficientBound*Cm^2*T*(∑x∈source,primeProductNorm p (principalSupport extra negative x)) := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intros + ring + _ ≤ coefficientBound*Cm^2*T*(Cs*Z^(13*Lcap)) := + mul_le_mul_of_nonneg_left hmass₀ (by positivity) + _ = _ := by + have he : Z^(-(saving+13*Lcap))*Z^(13*Lcap)=Z^(-saving) := by + rw [←Real.rpow_add hz] + congr 1 + ring + dsimp only [T,Q] + calc + _ = coefficientBound*Cm^2*Ct*Cs*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (SchwartzMap.seminorm ℝ 0 0 om)^2*(Z^(-(saving+13*Lcap))*Z^(13*Lcap)) := by ring + _ = _ := by rw [he] + +end SevenEighths.InverseMomentGlobalPriorityTail +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailAggregate.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailAggregate.lean new file mode 100644 index 0000000000000000000000000000000000000000..978c9badb650149799de1a5220723e485f022e70 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailAggregate.lean @@ -0,0 +1,97 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityTail + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentGlobalPriorityTail +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseMomentGlobalPrincipalMass InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InversePrioritySecondSource InverseSecondPrincipalCaller InversePrincipalEnergy +open InverseWholePriorityRetainedSource FirstCauchyArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem global_parent_tail_aggregate_rapid (Jmax : ℕ) (Lcap tau saving : ℝ) + (hLcap : 0≤Lcap) (htau : 0Ideal.span {p i})) + (_hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (Jo : ℕ),Jo≤Jmax → ∀(extra : CubeCoordinates ι→Finset ι)(pool : Finset ι) + (source : Finset (Source ι Jo))(negative : Bool)(Ψ : O→*ℂ)(m : O) + (w : Source ι Jo→ℂ)(slots : Finset σ)(lists : σ→Finset ι)(a : σ→ι→ℂ), + (slots:Set σ).PairwiseDisjoint lists → + (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → (∀u,‖Ψ u‖≤1) → (∀x∈source,‖w x‖≤1) → + ∀(om : 𝓢(ℝ,ℂ))(lo hi : ℝ)(hlo : 0x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap) → + (∀x∈source,primeProductNorm p x.firstCommon≤Z^Lcap) → + (∀x∈source,primeProductNorm p x.quotientSupport≤Z^Lcap) → + (∀x∈source,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp M) Y (Z^tau)≤R G E.val) → + (32*512)*(2:ℝ)^slots.card* + (∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ‖∑y∈wholeAssignedParents p (fun x=>extra x.cube) source negative J lists, + coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) y* + priorityTailParent p hg hp hinj extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) + m slots J lists a (principalWindow om lo hi hlo hs negative height) X Y R y‖)≤ + C*(4:ℝ)^slots.card*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (SchwartzMap.seminorm ℝ 0 0 om)^2*Z^(-saving) := by + obtain ⟨s,C,hC,hbound⟩ := global_parent_tail_rapid Jmax Lcap tau saving hLcap htau + let N : ℝ := (Fintype.card (RayCharacter×RayCharacter):ℝ)*(Fintype.card FirstCoreIndex:ℝ) + have hN : 0extra x.cube) source negative J lists, + coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) y* + priorityTailParent p hg hp hinj extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) + m slots J lists a (principalWindow om lo hi hlo hs negative height) X Y R y‖) + ≤N*(2:ℝ)^slots.card*B := by + calc + _ ≤ ∑_ray:RayCharacter×RayCharacter,∑_core:FirstCoreIndex,∑_J∈slots.powerset,B := by + apply Finset.sum_le_sum + intro ray hr + apply Finset.sum_le_sum + intro core hc₀ + apply Finset.sum_le_sum + intro J hJ + exact hbound p hp hg hinj hcop hc Jo hJo extra pool source negative Ψ m ray core w slots J lists a + (Finset.mem_powerset.mp hJ) hslots ha hΨ hw om lo hi hlo hs X M Y Z height R + hX hhi hZ hY hscale hy hyi hXcap hsource hextra hb₁ hb₂ hactive hcommon hquot hR + _ = _ := by + simp only [Finset.sum_const,Finset.card_powerset,Finset.card_univ,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + dsimp [N] + ring + apply (mul_le_mul_of_nonneg_left hsum (by positivity : 0≤(32*512)*(2:ℝ)^slots.card)).trans_eq + have he : ((2:ℝ)^slots.card)^2=(4:ℝ)^slots.card := by + rw [←pow_mul,pow_mul'] + norm_num + dsimp [B] + calc + _ = (32*512)*N*C*((2:ℝ)^slots.card)^2*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (SchwartzMap.seminorm ℝ 0 0 om)^2*Z^(-saving) := by ring + _ = _ := by rw [he] + +end SevenEighths.InverseMomentGlobalPriorityTail +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailCollapse.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailCollapse.lean new file mode 100644 index 0000000000000000000000000000000000000000..9984d23a4b327336c22629ecd9e93de61ee8a12c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailCollapse.lean @@ -0,0 +1,42 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityParentBounds +import OAI.NumberTheory.DirichletL.Descent.GlobalPrioritySource + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentGlobalPriorityTail +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InversePrioritySecondSource InverseSecondPrincipalCaller InversePrincipalEnergy +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +lemma tail_forget (hp : ∀i,p i≠0) (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m : O) (slots J : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (V : 𝓢(ℝ,ℂ)) (X Y : ℝ) (R : Finset ι→Finset ι→ℝ) + (y : SecondParentSource ι (Jo+(J.card+J.card))) : + priorityTailParent p hg hp hinj extra pool negative Ψ m slots J lists a V X Y R + (forgetAppended (Jo:=Jo) y)= + priorityTailParent p hg hp hinj extra pool negative Ψ m slots J lists a V X Y R y := rfl + +theorem original_paired_tail (hp : ∀i,p i≠0) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) (source : Finset (Source ι Jo)) + (negative : Bool) (Ψ : O→*ℂ) (m : O) (slots J : Finset σ) + (lists : σ→Finset ι) (a : σ→ι→ℂ) (w : Source ι Jo→ℂ) + (V : 𝓢(ℝ,ℂ)) (X Y : ℝ) (R : Finset ι→Finset ι→ℝ) : + (∑y∈wholeAssignedParents p (fun x=>extra x.cube) source negative J lists, + coefficient p J a w y*priorityTailParent p hg hp hinj extra pool negative Ψ m slots J lists a V X Y R y)= + ∑x∈source,w x*(‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2:ℝ)* + priorityTailParent p hg hp hinj extra pool negative Ψ m slots J lists a V X Y R (parent p x) := by + rw [wholePaired_parent_sq_sum p (fun x=>extra x.cube) hinj] + simp only [tail_forget] + +end SevenEighths.InverseMomentGlobalPriorityTail +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..e7f7c6efe3fe8cd6232440f9d7e4d4fcdef71500 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityTailMass.lean @@ -0,0 +1,50 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPrincipalMassWeighted + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalPriorityTail +open InverseMoment InverseFirstPriorityParents InverseInitialArithmetic +open InverseMomentGlobalPrincipalMass +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem original_tail_mass (Jmax : ℕ) : + ∃C : ℝ,0Ideal.span {p i})) + (Jo : ℕ),Jo≤Jmax → ∀(S : Finset (Source ι Jo))(Z L : ℝ), + 1≤Z → 0≤L → (∀x∈S,SourceValid p x) → + (∀x∈S,‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Z^L) → + (∀x∈S,‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Z^L) → + (∀x∈S,‖eisEmbedding (∏i∈cubeActiveSupport x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^L) → + (∀x∈S,primeProductNorm p x.firstCommon≤Z^L) → + (∀x∈S,primeProductNorm p x.quotientSupport≤Z^L) → + ∀(extra : CubeCoordinates ι→Finset ι)(negative : Bool), + (∀x∈S,extra x.cube⊆x.cube.support) → + (∑x∈S,primeProductNorm p (principalSupport extra negative x))≤C*Z^(13*L) := by + obtain ⟨C,hC,hraw⟩ := original_weighted_mass Jmax 1 (by norm_num) + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ hinj Jo hJo S Z L hZ hL hS hb₁ hb₂ hactive hcommon hquot extra negative hextra + have hz : 0 ActualEisensteinCubic.O + +theorem global_physical_tail_rapid (Jmax : ℕ) (Lcap tau saving : ℝ) + (hLcap : 0≤Lcap) (htau : 0Ideal.span {p i})) + (_hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (Jo : ℕ),Jo≤Jmax → ∀(extra : CubeCoordinates ι→Finset ι)(pool : Finset ι) + (source : Finset (Source ι Jo))(negative : Bool)(Ψ : O→*ℂ)(m : O) + (w : Source ι Jo→ℂ)(slots : Finset σ)(lists : σ→Finset ι)(a : σ→ι→ℂ), + (slots:Set σ).PairwiseDisjoint lists → + (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → (∀u,‖Ψ u‖≤1) → (∀x∈source,‖w x‖≤1) → + ∀(om : 𝓢(ℝ,ℂ))(lo hi : ℝ)(hlo : 0x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖≤Z^Lcap) → + (∀x∈source,primeProductNorm p x.firstCommon≤Z^Lcap) → + (∀x∈source,primeProductNorm p x.quotientSupport≤Z^Lcap) → + (∀x∈source,∀G∈pool.powerset,∀E:G.powerset, + correlatedSecondRadius p (secondParentDivisor p (parent p x)) G E.val + (X*Real.exp M) Y (Z^tau)≤R G E.val) → + (Z^kappa*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))*((32*512)*(2:ℝ)^slots.card* + (∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ‖∑y∈wholeAssignedParents p (fun x=>extra x.cube) source negative J lists, + coefficient p J a (globalPriorityOuter p hg negative Ψ m ray core w) y* + priorityTailParent p hg hp hinj extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) + m slots J lists a (principalWindow om lo hi hlo hs negative height) X Y R y‖))≤ + C*(4:ℝ)^slots.card*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (SchwartzMap.seminorm ℝ 0 0 om)^2*Z^(-saving) := by + obtain ⟨s,C,hC,hbound⟩ := global_parent_tail_aggregate_rapid Jmax Lcap tau (saving+Lcap) hLcap htau + refine ⟨s,C,hC,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop hc Jo hJo extra pool source negative Ψ m w slots lists a + hslots ha hΨ hw om lo hi hlo hs X M Y Z height kappa eta R hkappa hX hhi hZ hY hscale hy hyi hXcap + hsource hextra hb₁ hb₂ hactive hcommon hquot hR + have hz : 0ActualEisensteinCubic.O +variable {ι σ:Type*}[DecidableEq ι][DecidableEq σ]{Jo:ℕ} +def globalPriorityZeroAggregate + (p:ι→O)[∀i,(Ideal.span {p i}).IsMaximal](hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (extra:CubeCoordinates ι→Finset ι)(pool:Finset ι)(original:Finset (Source ι Jo))(w:Source ι Jo→ℂ) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (V:𝓢(ℝ,ℂ))(X Y:ℝ)(R:Finset ι→Finset ι→ℝ):ℝ:= + (32*512)*(2:ℝ)^slots.card*∑ray:RayCharacter×RayCharacter,∑core:FirstCoreIndex,∑J∈slots.powerset, + ∑x∈original,‖globalPriorityOuter p hg negative Ψ m ray core w x‖* + ‖primeMark J lists a (wholeExtractedSupport (fun x=>extra x.cube) negative x)‖^2* + ‖priorityZeroParent p hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots J lists a V X Y R (parent p x)‖ + +theorem global_priority_zero_aggregate (ε:ℝ)(hε:0<ε): + ∃(s:Finset (ℕ×ℕ))(Czero:ℝ),0Ideal.span {p i})) + (_hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + {Jo:ℕ}(extra:CubeCoordinates ι→Finset ι)(pool:Finset ι)(original:Finset (Source ι Jo))(w:Source ι Jo→ℂ) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ), + (slots:Set σ).PairwiseDisjoint lists→(∀i∈slots,∀k∈lists i,‖a i k‖≤1)→(∀u,‖Ψ u‖≤1)→ + (∀x∈original,‖w x‖≤1)→ + ∀(om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0extra x.cube) negative x))^(2*ε):=by + obtain ⟨s,Cp,hCp,hprincipal⟩:=priority_zero_parent_uniform ε hε + obtain ⟨Cb,hCb,hmass⟩:=global_priority_weighted_branch ε hε + refine ⟨s,Cb*Cp,mul_pos hCb hCp,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop Jo extra pool original w negative Ψ m slots lists a + hslots ha hΨ hw om lo hi hlo hs X M Y t R hX hhi hY hR + let B:=Cp*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)*(SchwartzMap.seminorm ℝ 0 0 om)^2* + Y*(X*Real.exp M)^(1+ε) + have hB:0≤B:=by dsimp [B];positivity + have hh:=hmass p hp hg hcop original extra negative Ψ m w slots lists a B hslots ha hΨ hw hB + (fun ray core J x=>‖priorityZeroParent p hg extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots J lists a + (principalWindow om lo hi hlo hs negative t) X Y R (parent p x)‖) + (by intros;positivity) + (fun ray core J hJ x hx=>hprincipal p hp hg hinj hcop extra pool negative + (firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core) m slots J lists a hslots ha + (fun u=>(firstCoreTwist_norm_le negative _ Ψ core u).trans (hΨ u)) + om lo hi hlo hs X M Y t R hX hhi hY hR (parent p x)) + convert hh using 1 <;> dsimp only [globalPriorityZeroAggregate,B] ; ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityZeroPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityZeroPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..d5b54f9fddacc4aa9bc79ba451973c0840b24766 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalPriorityZeroPhysical.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalPriorityZero + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion FirstCauchyArithmetic +open InverseSecondPrincipalCaller InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseMomentGlobalPrincipalMass +local notation "O"=>ActualEisensteinCubic.O + +theorem global_priority_zero_physical (ε:ℝ)(hε:0<ε)(Jmax:ℕ)(dsmall:ℝ)(hdsmall:0Ideal.span {p i})) + (_hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (Jo:ℕ),Jo≤Jmax→∀(extra:CubeCoordinates ι→Finset ι)(pool:Finset ι) + (original:Finset (Source ι Jo))(w:Source ι Jo→ℂ)(negative:Bool)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ), + (slots:Set σ).PairwiseDisjoint lists→(∀i∈slots,∀k∈lists i,‖a i k‖≤1)→(∀u,‖Ψ u‖≤1)→ + (∀x∈original,‖w x‖≤1)→ + ∀(om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)≤Z^(Ractive+eta))→ + (∀x∈original,primeProductNorm p x.firstCommon≤Z^(B+eta))→ + (∀x∈original,primeProductNorm p x.quotientSupport≤Z^(t+eta))→ + (∀x∈original,extra x.cube⊆x.cube.support)→ + hi≤Real.exp window→1≤Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)→(∀G E,0≤R G E)→ + (Z^(firstKappa M r ell V delta A B Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + globalPriorityZeroAggregate p hg extra pool original w negative Ψ m slots lists a + (principalWindow om lo hi hlo hs negative height) (Z^(r-A-B-t)) + (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)) R≤ + Czero*(4:ℝ)^slots.card*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (SchwartzMap.seminorm ℝ 0 0 om)^2*Real.exp (window*(1+ε))* + Z^(r+3*ell+V+17*eta+tau+pi):=by + obtain ⟨s,Cp,hCp,hprincipal⟩:=global_priority_zero_aggregate ε hε + obtain ⟨Cm,hCm,hmass⟩:=original_physical_weighted_source Jmax dsmall hdsmall + refine ⟨s,Cp*Cm,mul_pos hCp hCm,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop Jo hJo extra pool original w negative Ψ m slots lists a + hslots ha hΨ hw om lo hi hlo hs Z M r ell V delta A B Ractive j t eta tau window pi height R + hZ hell hB hj hcost hsource hc₁ hc₂ hactive hcommon hquot hextra hhi hY hR + have hz:0extra x.cube) negative x=principalSupport extra negative x:=by + simp only [wholeExtractedSupport,extractedSupport,principalSupport,Finset.union_assoc] + simp_rw [hsupp] at he + apply he.trans + calc + _=Q*(physicalPrincipalFactor Z M r ell V delta A B Ractive j t eta tau ε window* + ∑x∈original,(primeProductNorm p (principalSupport extra negative x))^(2*ε)):=by + dsimp [Q,P,physicalPrincipalFactor];ring + _≤Q*(Cm*Real.exp (window*(1+ε))*Z^(r+3*ell+V+17*eta+tau+pi)):=mul_le_mul_of_nonneg_left hm hQ + _= _:=by dsimp [Q];ring +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGates.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..7a7c6b79715491ec70059aabc6bf4549211a649e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGates.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondUniformCutoff +import OAI.NumberTheory.DirichletL.Descent.ActualChildStateTriples +import OAI.NumberTheory.DirichletL.Descent.GlobalPrioritySource + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalRetainedGates +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityRetainedSource InversePrioritySecondSource InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +def retainedSource (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) : Finset (MarkedSecondSource ι (Jo+(J.card+J.card)) 0) := + unifiedSource p pool (wholeAssignedParents p (fun x=>extra x.cube) original negative J lists) (fun _=>cutoff) + +lemma original_parent_witness + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) + (x : MarkedSecondSource ι (Jo+(J.card+J.card)) 0) + (hx : x∈retainedSource p extra original negative J lists pool cutoff) : + ∃y∈original,forgetAppended (Jo:=Jo) (secondParentOf x)=parent p y := by + have hp := ((mem_unifiedSource p pool _ (fun _=>cutoff) x).mp hx).1 + obtain ⟨y,hy,q,hq,he⟩ := (mem_wholeAssignedParents p (fun x=>extra x.cube) original negative J lists _).mp hp + exact ⟨y,hy,by simpa only [forget_attach] using congrArg (forgetAppended (Jo:=Jo)) he.symm⟩ + +lemma original_coordinates + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) + (x : MarkedSecondSource ι (Jo+(J.card+J.card)) 0) + (hx : x∈retainedSource p extra original negative J lists pool cutoff) : + ∃y∈original,x.cube=y.cube ∧ x.firstCommon=y.firstCommon ∧ + x.firstDivisor=y.firstDivisor ∧ x.quotient=sourceIdeal p y.quotientSupport ∧ + (∀i:Fin Jo,x.oldAssigned (Fin.castAdd (J.card+J.card) i)=y.oldAssigned i) := by + obtain ⟨y,hy,he⟩ := original_parent_witness p extra original negative J lists pool cutoff x hx + exact ⟨y,hy,congrArg SecondParentSource.cube he,congrArg SecondParentSource.firstCommon he, + congrArg SecondParentSource.firstDivisor he,congrArg SecondParentSource.quotient he, + fun i=>congrArg (fun z=>z.oldAssigned i) he⟩ + +lemma retained_conditions (hp : ∀i,p i≠0) + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (hvalid : ∀x∈original,SourceValid p x) (hextra : ∀x∈original,extra x.cube⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) : + ActualSecondSourceConditions p (retainedSource p extra original negative J lists pool cutoff) := + unified_conditions p hp extra original hvalid hextra negative J lists pool (fun _=>cutoff) + +lemma original_numeric_gates (extra : CubeCoordinates ι→Finset ι) + (original : Finset (Source ι Jo)) (negative : Bool) (J : Finset σ) + (lists : σ→Finset ι) (pool : Finset ι) (cutoff : Finset ι→Finset ι→ℝ) + (B A C Q JL JU D : ℝ) + (hB₁ : ∀y∈original,‖eisEmbedding (primeProduct p y.cube.support y.cube.leftExponent)‖^2≤B) + (hB₂ : ∀y∈original,‖eisEmbedding (primeProduct p y.cube.support y.cube.rightExponent)‖^2≤B) + (hA : ∀y∈original,primeProductNorm p (cubeActiveSupport y.cube.support + (fun i=>y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit)≤A) + (hC : ∀y∈original,primeProductNorm p y.firstCommon≤C) + (hQ : ∀y∈original,primeProductNorm p y.quotientSupport≤Q) + (hJ : ∀y∈original,JL≤‖eisEmbedding (jLabel p y.cube.support + (fun i=>y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit)‖^2 ∧ + ‖eisEmbedding (jLabel p y.cube.support (fun i=>y.cube.leftExponent i+y.cube.rightExponent i) + y.cube.leftBit y.cube.rightBit)‖^2≤JU) + (hD : ∀y∈original,primeProductNorm p y.firstDivisor≤D) : + ∀x∈retainedSource p extra original negative J lists pool cutoff, + ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤B ∧ + ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤B ∧ + primeProductNorm p (cubeActiveSupport x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)≤A ∧ primeProductNorm p x.firstCommon≤C ∧ + (Ideal.absNorm x.quotient:ℝ)≤Q ∧ + JL≤‖eisEmbedding (jLabel p x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2 ∧ + ‖eisEmbedding (jLabel p x.cube.support (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2≤JU ∧ + primeProductNorm p x.firstDivisor≤D := by + intro x hx + obtain ⟨y,hy,hb,hc,hd,hq,ho⟩ := original_coordinates p extra original negative J lists pool cutoff x hx + rw [hb,hc,hd,hq] + refine ⟨hB₁ y hy,hB₂ y hy,hA y hy,hC y hy,?_,(hJ y hy).1,(hJ y hy).2,hD y hy⟩ + simpa only [sourceIdeal,←eisEmbedding_norm_sq_eq_absNorm_span,primeProductNorm] using hQ y hy + +end SevenEighths.InverseMomentGlobalRetainedGates +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..500744cb26f1c7aa2ad7756c8b95584326ce3c25 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesBudget.lean @@ -0,0 +1,46 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesCaps +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesChildren + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalRetainedGates +open InverseMoment InverseInitialArithmetic InverseSecondSourceBlocks +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O + + theorem source_cell_exponent_cap {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) + (hk : ∀x∈source,x.second.frequency≠0) (Z Lcap : ℝ) (hZ : 1 ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +include hp in +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +lemma uniform_radius_cap (G E : Finset ι) (hEG : E⊆G) + (Z delta eta L Y tau Lcol LY : ℝ) (hZ : 0uniformSecondRadius p Z delta eta G E L Y (Z^tau)) b X, + ∀i,outerNorms p x i≤Z^Lcap := by + intro x hx i + have hret := supported_subset p extra original negative J lists pool _ b X hx + have hm := (mem_unifiedSource p pool _ _ x).mp hret + have hg : primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤Z^Lcap := + (geometrySource_gate p _ b X x hx).trans hgeom + have hG : primeProductNorm p x.second.sourceCommon≤Z^Lcap := + (le_mul_of_one_le_right (primeProductNorm_pos p hp _).le (primeProductNorm_ge_one p hp _)).trans hg + have hV : primeProductNorm p x.second.overlap≤Z^Lcap := + (le_mul_of_one_le_left (primeProductNorm_pos p hp _).le (primeProductNorm_ge_one p hp _)).trans hg + fin_cases i + · exact hG + · exact (primeProductNorm_mono p hp hm.2.2.1).trans hG + · exact hV + · have hb := (mem_nonzeroChildFrequencyBall _ (actualSecondMultiplier_ne_zero p x) _ _).mp hm.2.2.2.2 + exact (bare_frequency_norm_le _ _ (actualSecondMultiplier_ne_zero p x)).trans + (hb.2.trans ((uniform_radius_cap p hp _ _ hm.2.2.1 Z delta eta L Y tau Lcol LY + (zero_lt_one.trans_le hZ) hL hY hLc hYi).trans + (Real.rpow_le_rpow_of_exponent_le hZ hphysical))) + +end SevenEighths.InverseMomentGlobalRetainedGates +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesChildren.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesChildren.lean new file mode 100644 index 0000000000000000000000000000000000000000..9aede25549bea83f1d3e929af67a4b07fb9cb342 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesChildren.lean @@ -0,0 +1,89 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesRadius + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalRetainedGates +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityRetainedSource InversePrioritySecondSource InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondSourceBlocks +open InverseSecondFibers CompletedGauss +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +lemma supported_original_property + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X : ℝ) + (F : CubeCoordinates ι→Finset ι→Finset ι→Ideal O→Prop) + (hF : ∀y∈original,F y.cube y.firstCommon y.firstDivisor (sourceIdeal p y.quotientSupport)) : + ∀x∈supportedRetainedSource p extra original negative J lists pool cutoff b X, + F x.cube x.firstCommon x.firstDivisor x.quotient := by + intro x hx + obtain ⟨y,hy,hb,hc,hd,hq,ho⟩ := original_coordinates p extra original negative J lists pool cutoff x + (supported_subset p extra original negative J lists pool cutoff b X hx) + rw [hb,hc,hd,hq] + exact hF y hy + +theorem supported_label_gates (hp : ∀i,p i≠0) + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X Z B j eta : ℝ) (hZ : 1y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit)‖^2≤Z^(j+eta)) : + let source := supportedRetainedSource p extra original negative J lists pool cutoff b X + (∀d,∀x∈cell p source d,(actualSecondChild p 1 1 x).2.1∈actualCellLabels p source d) ∧ + (∀d,∀I∈(actualCellLabels p source d).filter Squarefree, + Squarefree I ∧ I≠0 ∧ (Ideal.absNorm I:ℝ)≤Z^(actualCellLabelExponent Z B j eta d)) := by + intro source + have hc := supported_original_property p extra original negative J lists pool cutoff b X + (fun _ C _ _=>primeProductNorm p C≤Z^(B+eta)) hC + have hj := supported_original_property p extra original negative J lists pool cutoff b X + (fun q _ _ _=>‖eisEmbedding (jLabel p q.support + (fun i=>q.leftExponent i+q.rightExponent i) q.leftBit q.rightBit)‖^2≤Z^(j+eta)) hJ + exact ⟨fun d x hx=>actual_cell_labels_cover p source d x hx, + fun d=>actual_cell_squarefree_labels p hp source + (supported_frequency_ne_zero p extra original negative J lists pool cutoff b X) d Z B j eta hZ hbin hc hj⟩ + +theorem supported_child_margins (hp : ∀i,p i≠0) + (hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (hvalid : ∀x∈original,SourceValid p x) (hextra : ∀x∈original,extra x.cube⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b : ℝ) (m : O) (hm : m≠0) + (Z r ell V M Q z c A B t j eta : ℝ) (hZ : 1‖eisEmbedding (primeProduct p q.support q.leftExponent)‖^2≤Z^(ell+eta)) h1 + have hb₂ := supported_original_property p extra original negative J lists pool cutoff b (Z^(r-A-B-t)) + (fun q _ _ _=>‖eisEmbedding (primeProduct p q.support q.rightExponent)‖^2≤Z^(ell+eta)) h2 + have hq := supported_original_property p extra original negative J lists pool cutoff b (Z^(r-A-B-t)) + (fun _ _ _ I=>(Ideal.absNorm I:ℝ)≤Z^(t+eta)) (by + intro y hy + simpa only [sourceIdeal,←eisEmbedding_norm_sq_eq_absNorm_span,primeProductNorm] using hT y hy) + exact actual_cell_triple_margins p hp hpr source hs hk d m hm + Z r ell V M Q z c A B t j eta hZ hparent hA ht hV hj heta hbin hQ hb₁ hb₂ hq γ hγ + +end SevenEighths.InverseMomentGlobalRetainedGates +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesGeometry.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..29485412d436ab4d483121c552039b932d091a41 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesGeometry.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGates + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.InverseMomentGlobalRetainedGates +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityRetainedSource InversePrioritySecondSource InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] +variable (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + +lemma actual_profile_zero_of_geometry + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (F : Finset ι) (x : SecondProfileData ι) (slots₁ slots₂ : Finset σ) + (lists₁ lists₂ : σ→Finset ι) (a₁ a₂ : σ→ι→ℂ) + (W₁ W₂ : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y X b : ℝ) (hX : 0Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + {Jo : ℕ} (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) (negative : Bool) + (Ψ : O→*ℂ) (m : O) (slots J : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (W : ℝ→ℂ) (X Y b : ℝ) (hX : 0lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) a a W W rowMajorant Y X b hX hW hgeom + rw [hh,mul_zero] + +omit hp [∀i,(Ideal.span {p i}).IsMaximal] in +def geometrySource {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) (b X : ℝ) : + Finset (MarkedSecondSource ι Jo Jn) := + source.filter (fun x=>primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) + +omit hp [∀i,(Ideal.span {p i}).IsMaximal] in +omit [DecidableEq ι] in +lemma geometrySource_subset {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) (b X : ℝ) : + geometrySource p source b X⊆source := Finset.filter_subset _ _ + +omit hp [∀i,(Ideal.span {p i}).IsMaximal] in +omit [DecidableEq ι] in +lemma geometrySource_gate {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) (b X : ℝ) : + ∀x∈geometrySource p source b X, + primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X := + fun _x hx=>(Finset.mem_filter.mp hx).2 + +lemma original_retained_geometry_sum + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + {Jo : ℕ} (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) + (source : Finset (MarkedSecondSource ι Jo 0)) (w : MarkedSecondSource ι Jo 0→ℂ) + (negative : Bool) (Ψ : O→*ℂ) (m : O) (slots J : Finset σ) + (lists : σ→Finset ι) (a : σ→ι→ℂ) (W : ℝ→ℂ) (X Y b : ℝ) + (hX : 0 ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +def supportedRetainedSource (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X : ℝ) : Finset (MarkedSecondSource ι (Jo+(J.card+J.card)) 0) := + geometrySource p (retainedSource p extra original negative J lists pool cutoff) b X + +lemma supported_subset (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X : ℝ) : + supportedRetainedSource p extra original negative J lists pool cutoff b X⊆ + retainedSource p extra original negative J lists pool cutoff := geometrySource_subset p _ b X + +lemma supported_conditions (hp : ∀i,p i≠0) + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (hvalid : ∀x∈original,SourceValid p x) (hextra : ∀x∈original,extra x.cube⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X : ℝ) : + ActualSecondSourceConditions p (supportedRetainedSource p extra original negative J lists pool cutoff b X) := + ActualSecondSourceConditions.mono p (retained_conditions p hp extra original hvalid hextra negative J lists pool cutoff) + (supported_subset p extra original negative J lists pool cutoff b X) + +lemma supported_frequency_ne_zero + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X : ℝ) : + ∀x∈supportedRetainedSource p extra original negative J lists pool cutoff b X,x.second.frequency≠0 := by + intro x hx + exact unified_frequency_ne_zero p pool _ (fun _=>cutoff) x + (supported_subset p extra original negative J lists pool cutoff b X hx) + +lemma supported_uniform_frequency_gate + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (Z delta eta L Y tau b X : ℝ) : + ∀x∈supportedRetainedSource p extra original negative J lists pool + (fun G E=>uniformSecondRadius p Z delta eta G E L Y (Z^tau)) b X, + x.second.frequency∈nonzeroChildFrequencyBall (actualSecondMultiplier p x) + (uniformSecondRadius p Z delta eta x.second.sourceCommon x.second.divisor L Y (Z^tau)) := by + intro x hx + exact ((mem_unifiedSource p pool _ _ x).mp + (supported_subset p extra original negative J lists pool _ b X hx)).2.2.2.2 + +theorem supported_cell_row_gates (hp : ∀i,p i≠0) + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (Z M r ell V delta A B j t eta tau L b X : ℝ) + (hZ : 1uniformSecondRadius p Z delta eta G E L + (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)) (Z^tau)) b X + (∀x∈source,x.second.frequency∈nonzeroChildFrequencyBall (actualSecondMultiplier p x) + (actualCellRowRadius Z M ell A t V j eta (index p x))) ∧ + (∀d∈keys p source,0≤actualCellRowExponent Z M ell A t V j eta d) := by + intro source + have hgates := actual_cell_uniform_source_gates p hp source Z M r ell V delta A B j t eta tau L + hZ heta hbin hL0 hL (supported_uniform_frequency_gate p extra original negative J lists pool Z delta eta L _ tau b X) + refine ⟨?_,actual_cell_radius_nonnegative_on_keys p source Z M ell A t V j eta hZ hgates⟩ + intro x hx + exact hgates (index p x) x (Finset.mem_filter.mpr ⟨hx,rfl⟩) + +end SevenEighths.InverseMomentGlobalRetainedGates +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesRank.lean b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesRank.lean new file mode 100644 index 0000000000000000000000000000000000000000..43bc9f3f1802b6a213ee15094f2ee43d7ed7a426 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/GlobalRetainedGatesRank.lean @@ -0,0 +1,47 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalRetainedGatesChildren + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.InverseMomentGlobalRetainedGates +open InverseMoment InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityRetainedSource InversePrioritySecondSource InverseInitialArithmetic +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondSourceBlocks +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} +variable (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +theorem supported_row_rank_decrease (hp : ∀i,p i≠0) + (extra : CubeCoordinates ι→Finset ι) (original : Finset (Source ι Jo)) + (hvalid : ∀x∈original,SourceValid p x) (hextra : ∀x∈original,extra x.cube⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (cutoff : Finset ι→Finset ι→ℝ) (b X Z M ell A t V j eta shortCutoff : ℝ) + (hZ : 1y.cube.leftExponent i+y.cube.rightExponent i) y.cube.leftBit y.cube.rightBit)‖^2) : + let source := supportedRetainedSource p extra original negative J lists pool cutoff b X + ∀d∈keys p source,actualCellRowExponent Z M ell A t V j eta d+3*shortCutoff/2≤M := by + intro source d hd + obtain ⟨x,hx⟩ := (mem_keys_iff p source d).mp hd + have hxs := cell_subset p source d hx + have hs := supported_conditions p hp extra original hvalid hextra negative J lists pool cutoff b X + have hk := supported_frequency_ne_zero p extra original negative J lists pool cutoff b X + have hb₁ := supported_original_property p extra original negative J lists pool cutoff b X + (fun q _ _ _=>‖eisEmbedding (primeProduct p q.support q.leftExponent)‖^2≤Z^(ell+eta)) h1 + have hb₂ := supported_original_property p extra original negative J lists pool cutoff b X + (fun q _ _ _=>‖eisEmbedding (primeProduct p q.support q.rightExponent)‖^2≤Z^(ell+eta)) h2 + have hj := supported_original_property p extra original negative J lists pool cutoff b X + (fun q _ _ _=>Z^(j-eta)≤‖eisEmbedding (jLabel p q.support + (fun i=>q.leftExponent i+q.rightExponent i) q.leftBit q.rightBit)‖^2) hJ + exact actual_cell_row_decrease p hp source hs hk d x hx Z M ell A t V j eta shortCutoff + hZ hA ht heta hbin hterminal hsmall (hb₁ x hxs) (hb₂ x hxs) (hj x hxs) + +end SevenEighths.InverseMomentGlobalRetainedGates +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Grid.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Grid.lean new file mode 100644 index 0000000000000000000000000000000000000000..39a7ba7e8eb97cbc6bd2aeaa11f2013afc8227c8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Grid.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Descent.Dyadic + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +section FiniteGrid +variable {M H C A : Type*} [DecidableEq M] [DecidableEq H] [DecidableEq C] [AddCommMonoid A] + +def gridCommonSupport (T : Finset ((M × H) × C)) (m : M) : Finset C := + (T.filter fun u => u.1.1 = m).image Prod.snd + +theorem finite_triple_support_reindex (T : Finset ((M × H) × C)) + (f : (M × H) × C → A) : + (∑ u ∈ T, f u) = ∑ p ∈ T.image Prod.fst, + ∑ c ∈ gridCommonSupport T p.1, if (p, c) ∈ T then f (p, c) else 0 := by + have hp := Finset.sum_fiberwise_of_maps_to + (s := T) (t := T.image Prod.fst) (g := Prod.fst) + (fun u hu => Finset.mem_image.mpr ⟨u, hu, rfl⟩) f + rw [← hp] + apply Finset.sum_congr rfl + intro p hp + rw [← Finset.sum_filter] + apply Finset.sum_bij (fun u _ => u.2) + · intro u hu + obtain ⟨huT, hup⟩ := Finset.mem_filter.mp hu + refine Finset.mem_filter.mpr ⟨?_, ?_⟩ + · exact Finset.mem_image.mpr ⟨u, Finset.mem_filter.mpr ⟨huT, congrArg Prod.fst hup⟩, rfl⟩ + · simpa only [← hup, Prod.eta] using huT + · intro u hu v hv he + apply Prod.ext + · exact (Finset.mem_filter.mp hu).2.trans (Finset.mem_filter.mp hv).2.symm + · exact he + · intro c hc + have hpc := (Finset.mem_filter.mp hc).2 + exact ⟨(p, c), Finset.mem_filter.mpr ⟨hpc, rfl⟩, rfl⟩ + · intro u hu + have hup := (Finset.mem_filter.mp hu).2 + simp only [← hup, Prod.eta] + +end FiniteGrid + +def HybridColumnData.gridIndex (d : HybridColumnData) : + (Ideal Eis × Ideal Eis) × Ideal Eis := ((d.residualN, d.residualB), d.common) + +theorem HybridColumnData.gridIndex_injective_on_square (t : Ideal Eis) : + Set.InjOn HybridColumnData.gridIndex {d | d.square = t} := by + intro d hd e he hg + have hm : d.residualN = e.residualN := congrArg (fun u => u.1.1) hg + have hh : d.residualB = e.residualB := congrArg (fun u => u.1.2) hg + have hc : d.common = e.common := congrArg Prod.snd hg + have ht : d.square = e.square := hd.trans he.symm + cases d + cases e + cases hc + cases hm + cases hh + cases ht + rfl + +def hybridGridSupport (D : Finset HybridColumnData) : + Finset ((Ideal Eis × Ideal Eis) × Ideal Eis) := D.image HybridColumnData.gridIndex + +theorem hybrid_grid_reindex (D : Finset HybridColumnData) (t : Ideal Eis) + (hD : ∀ d ∈ D, d.square = t) (f : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) : + (∑ d ∈ D, f d.common d.residualN d.residualB) = + ∑ p ∈ (hybridGridSupport D).image Prod.fst, + ∑ c ∈ gridCommonSupport (hybridGridSupport D) p.1, + if (p, c) ∈ hybridGridSupport D then f c p.1 p.2 else 0 := by + have he : (∑ d ∈ D, f d.common d.residualN d.residualB) = + ∑ u ∈ hybridGridSupport D, f u.2 u.1.1 u.1.2 := by + symm + apply Finset.sum_image + intro d hd e he hg + exact HybridColumnData.gridIndex_injective_on_square t (hD d hd) (hD e he) hg + rw [he] + exact finite_triple_support_reindex (hybridGridSupport D) _ + +theorem gridCommonSupport_origin (D : Finset HybridColumnData) (m c : Ideal Eis) + (hc : c ∈ gridCommonSupport (hybridGridSupport D) m) : + ∃ d ∈ D, d.residualN = m ∧ d.common = c := by + obtain ⟨u, hu, huc⟩ := Finset.mem_image.mp hc + obtain ⟨huT, hum⟩ := Finset.mem_filter.mp hu + obtain ⟨d, hd, rfl⟩ := Finset.mem_image.mp huT + exact ⟨d, hd, hum, huc⟩ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Hybrid.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Hybrid.lean new file mode 100644 index 0000000000000000000000000000000000000000..a4ab7ea2166c5bfa5d48d12f541e1076aecc2475 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Hybrid.lean @@ -0,0 +1,363 @@ +import OAI.NumberTheory.DirichletL.Descent.IdealMasks +import OAI.NumberTheory.DirichletL.Descent.Fibers +import OAI.NumberTheory.DirichletL.CubicSieve.Ideal + +namespace OAI + +namespace SevenEighths.InverseMoment + +noncomputable section + +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid IdealMobiusDivisorSum + +local notation "Eis" => ActualEisensteinCubic.O + +def inverseCubicKernel (P n : Ideal Eis) : ℂ := + star (ConcreteTraceCRT.eisEmbedding + (CubicJacobiGlobal.idealSymbol P (CompletedGauss.primaryGenerator n))) + +theorem inverseCubicKernel_eq_inverse_square (P n : Ideal Eis) : + inverseCubicKernel P n = + (CanonicalRowCompletion.idealRowHom (CompletedGauss.primaryGenerator n) P)⁻¹ ^ 2 := by + rw [inv_pow, CanonicalRowCompletion.idealRowHom_square, + inverse_eq_square_of_fourth_eq (CubicSieve.idealSymbol_fourth P _)] + exact (CubicSieve.idealKernel_square_eq_star P n).symm + +theorem inverseCubicKernel_norm_le_one (P n : Ideal Eis) : + ‖inverseCubicKernel P n‖ ≤ 1 := by + simpa only [inverseCubicKernel, norm_star, CubicSieve.idealKernel] using + CubicSieve.idealKernel_norm_le_one P n + +def hybridCubicCoefficient (R r h t : Ideal Eis) (a : Ideal Eis → ℂ) + (P : Ideal Eis) : ℂ := + (a (R * P) * inverseCubicKernel P r * (if IsCoprime P (h * t) then 1 else 0)) / + (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) + +theorem dyadic_normalized_coefficient_energy + (S : Finset (Ideal Eis)) (L : ℝ) (hL : 1 ≤ L) + (hS : ∀ P ∈ S, L ≤ (Ideal.absNorm P : ℝ) ∧ (Ideal.absNorm P : ℝ) ≤ 2 * L) + (a : Ideal Eis → ℂ) (ha : ∀ P ∈ S, ‖a P‖ ≤ 1) : + (∑ P ∈ S, ‖a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ)‖ ^ 2) ≤ 256 := by + have hL0 : 0 < L := by linarith + have hP0 (P : Ideal Eis) (hP : P ∈ S) : 0 < (Ideal.absNorm P : ℝ) := + hL0.trans_le (hS P hP).1 + have hcount : (S.card : ℝ) ≤ 128 * (2 * L) := by + apply DescentFiberCost.finite_ideal_count_real S (2 * L) (by linarith) + · intro P hP hz + have hn := hP0 P hP + simp [hz] at hn + · intro P hP + exact (hS P hP).2 + have hterm (P : Ideal Eis) (hP : P ∈ S) : + ‖a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ)‖ ^ 2 ≤ 1 / L := by + rw [norm_div, div_pow, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (Real.sqrt_nonneg _), Real.sq_sqrt (Nat.cast_nonneg _)] + calc + _ ≤ 1 / (Ideal.absNorm P : ℝ) := + div_le_div_of_nonneg_right + (by simpa using pow_le_pow_left₀ (norm_nonneg _) (ha P hP) 2) (hP0 P hP).le + _ ≤ _ := one_div_le_one_div_of_le hL0 (hS P hP).1 + calc + _ ≤ ∑ _P ∈ S, (1 / L : ℝ) := Finset.sum_le_sum hterm + _ = (S.card : ℝ) / L := by simp [div_eq_mul_inv] + _ ≤ (128 * (2 * L)) / L := div_le_div_of_nonneg_right hcount hL0.le + _ = 256 := by field_simp; ring + +theorem hybridCubicCoefficient_energy + (R r h t : Ideal Eis) (S : Finset (Ideal Eis)) (L : ℝ) (hL : 1 ≤ L) + (hS : ∀ P ∈ S, L ≤ (Ideal.absNorm P : ℝ) ∧ (Ideal.absNorm P : ℝ) ≤ 2 * L) + (a : Ideal Eis → ℂ) (ha : ∀ P ∈ S, ‖a (R * P)‖ ≤ 1) : + (∑ P ∈ S, ‖hybridCubicCoefficient R r h t a P‖ ^ 2) ≤ 256 := by + apply dyadic_normalized_coefficient_energy S L hL hS + intro P hP + by_cases hc : IsCoprime P (h * t) + · simp only [hc, ite_eq_left, mul_one, norm_mul] + exact (mul_le_mul (ha P hP) (inverseCubicKernel_norm_le_one P r) + (norm_nonneg _) (by norm_num)).trans_eq (by norm_num) + · simp [hc] + +theorem inverseCubicKernel_mul_left (R P n : Ideal Eis) : + inverseCubicKernel (R * P) n = inverseCubicKernel R n * inverseCubicKernel P n := by + simp only [inverseCubicKernel, CubicJacobiGlobal.idealSymbol_mul, map_mul, star_mul] + ring + +theorem inverseCubicKernel_mul_right (P n m : Ideal Eis) + (hP : CompletedGauss.primaryGenerator P ≠ 0) : + inverseCubicKernel P (n * m) = inverseCubicKernel P n * inverseCubicKernel P m := by + change star (CubicSieve.idealNumeratorHom P hP (n * m)) = + star (CubicSieve.idealNumeratorHom P hP n) * star (CubicSieve.idealNumeratorHom P hP m) + rw [map_mul, star_mul] + ring + +theorem inverseCubicKernel_quotients (R P' r c' m : Ideal Eis) + (hP' : CompletedGauss.primaryGenerator P' ≠ 0) : + inverseCubicKernel (R * P') ((r * c') * m) = + inverseCubicKernel R ((r * c') * m) * inverseCubicKernel P' r * + inverseCubicKernel P' (c' * m) := by + rw [inverseCubicKernel_mul_left, mul_assoc r c' m, + inverseCubicKernel_mul_right P' r (c' * m) hP'] + ring + +theorem inverseCubicKernel_eq_zero_of_not_coprime (P n : Ideal Eis) + (hP : CompletedGauss.primaryGenerator P ≠ 0) + (hn : CompletedGauss.primaryGenerator n ≠ 0) (hcop : ¬ IsCoprime P n) : + inverseCubicKernel P n = 0 := by + have hc := CubicSieve.idealSymbol_cube_mask P (CompletedGauss.primaryGenerator n) hP + rw [(CompletedGauss.primaryGenerator_spec n hn).1, ite_eq_right hcop] at hc + have hz := (pow_eq_zero_iff (by decide : (3 : ℕ) ≠ 0)).mp hc + simp only [inverseCubicKernel, hz, star_zero] + +theorem hybrid_cubic_column_mask + (P n b c m h t : Ideal Eis) + (hP : CompletedGauss.primaryGenerator P ≠ 0) + (hngen : CompletedGauss.primaryGenerator n ≠ 0) + (hn : n = c * m) (hb : b = (c * h) * t ^ 2) : + inverseCubicKernel P n * (if IsCoprime P b then 1 else 0) = + inverseCubicKernel P n * (if IsCoprime P (h * t) then 1 else 0) := by + by_cases hc : IsCoprime P c + · have he : IsCoprime P b ↔ IsCoprime P (h * t) := by + rw [hb] + simp only [IsCoprime.mul_right_iff, IsCoprime.pow_right_iff (by decide : 0 < 2), + hc, true_and] + simp only [he] + · have hPn : ¬ IsCoprime P n := by + rw [hn, IsCoprime.mul_right_iff] + exact fun hcop => hc hcop.1 + rw [inverseCubicKernel_eq_zero_of_not_coprime P n hP hngen hPn] + simp + +theorem hybrid_original_kernel_decomposition + (k P n b c m h t : Ideal Eis) + (hk : CanonicalQuadraticSieve.Admissible k) + (hP : CompletedGauss.primaryGenerator P ≠ 0) + (hngen : CompletedGauss.primaryGenerator n ≠ 0) + (hn : n = c * m) (hb : b = (c * h) * t ^ 2) + (hct : CompletedGauss.primaryGenerator (c * t) ≠ 0) : + CanonicalQuadraticSieve.quadraticRow k (CompletedGauss.primaryGenerator (n * b)) * + inverseCubicKernel P n * (if IsCoprime P b then 1 else 0) * + (if IsCoprime k P then 1 else 0) = + (if IsCoprime k t then 1 else 0) * (if IsCoprime k (P * c) then 1 else 0) * + CanonicalQuadraticSieve.quadraticRow k (CompletedGauss.primaryGenerator (m * h)) * + inverseCubicKernel P n * (if IsCoprime P (h * t) then 1 else 0) := by + have hm : ((if IsCoprime k P then (1 : ℂ) else 0) * + (if IsCoprime k (c * t) then 1 else 0)) = + (if IsCoprime k t then 1 else 0) * (if IsCoprime k (P * c) then 1 else 0) := by + simp only [IsCoprime.mul_right_iff] + by_cases hkp : IsCoprime k P <;> by_cases hkc : IsCoprime k c <;> + by_cases hkt : IsCoprime k t <;> simp [hkp, hkc, hkt] + calc + _ = ((if IsCoprime k P then 1 else 0) * (if IsCoprime k (c * t) then 1 else 0)) * + CanonicalQuadraticSieve.quadraticRow k (CompletedGauss.primaryGenerator (m * h)) * + (inverseCubicKernel P n * (if IsCoprime P b then 1 else 0)) := by + rw [hybrid_quadratic_square_mask k n b c m h t hk hn hb hct] + ring + _ = _ := by rw [hm, hybrid_cubic_column_mask P n b c m h t hP hngen hn hb]; ring + +theorem hybrid_kernel_quotients (R r k' P' c' m h : Ideal Eis) + (hk : CanonicalQuadraticSieve.Admissible ((R * r) * k')) + (hP' : CompletedGauss.primaryGenerator P' ≠ 0) : + CanonicalQuadraticSieve.quadraticRow ((R * r) * k') + (CompletedGauss.primaryGenerator (m * h)) * + inverseCubicKernel (R * P') ((r * c') * m) = + (CanonicalQuadraticSieve.quadraticRow (R * r) + (CompletedGauss.primaryGenerator (m * h)) * + inverseCubicKernel R ((r * c') * m)) * + inverseCubicKernel P' r * + CanonicalQuadraticSieve.quadraticRow k' + (CompletedGauss.primaryGenerator (m * h)) * + inverseCubicKernel P' (c' * m) := by + rw [CanonicalQuadraticSieve.quadraticRow_mul (R * r) k' hk, + inverseCubicKernel_quotients R P' r c' m hP'] + ring + +def hybridColumnCoefficient (R r : Ideal Eis) + (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (c m h : Ideal Eis) : ℂ := + beta (r * c) m h * + CanonicalQuadraticSieve.quadraticRow (R * r) (CompletedGauss.primaryGenerator (m * h)) * + inverseCubicKernel R ((r * c) * m) + +theorem hybridColumnCoefficient_norm_le_one (R r c m h : Ideal Eis) + (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (hb : ‖beta (r * c) m h‖ ≤ 1) : + ‖hybridColumnCoefficient R r beta c m h‖ ≤ 1 := by + simp only [hybridColumnCoefficient, norm_mul] + have hfirst : ‖beta (r * c) m h‖ * + ‖CanonicalQuadraticSieve.quadraticRow (R * r) + (CompletedGauss.primaryGenerator (m * h))‖ ≤ 1 := by + exact (mul_le_mul hb (CanonicalQuadraticSieve.quadraticRow_norm_le_one _ _) + (norm_nonneg _) (by norm_num)).trans_eq (by norm_num) + exact (mul_le_mul hfirst (inverseCubicKernel_norm_le_one R ((r * c) * m)) + (norm_nonneg _) (by norm_num)).trans_eq (by norm_num) + +theorem normalized_ideal_product_weight (R P : Ideal Eis) (z : ℂ) : + z / (Real.sqrt (Ideal.absNorm (R * P) : ℝ) : ℂ) = + (Real.sqrt (Ideal.absNorm R : ℝ) : ℂ)⁻¹ * + (z / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ)) := by + rw [map_mul, Nat.cast_mul, Real.sqrt_mul (Nat.cast_nonneg _), Complex.ofReal_mul] + simp only [div_eq_mul_inv, mul_inv_rev] + ring + +theorem hybrid_extracted_block_identity + (R r k' P' c m h t : Ideal Eis) + (hk : CanonicalQuadraticSieve.Admissible ((R * r) * k')) + (hP' : CompletedGauss.primaryGenerator P' ≠ 0) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) : + a (R * P') / (Real.sqrt (Ideal.absNorm (R * P') : ℝ) : ℂ) * + beta (r * c) m h * + (CanonicalQuadraticSieve.quadraticRow ((R * r) * k') + (CompletedGauss.primaryGenerator (m * h)) * + inverseCubicKernel (R * P') ((r * c) * m)) * + (if IsCoprime P' (h * t) then 1 else 0) = + (Real.sqrt (Ideal.absNorm R : ℝ) : ℂ)⁻¹ * + hybridColumnCoefficient R r beta c m h * + CanonicalQuadraticSieve.quadraticRow k' (CompletedGauss.primaryGenerator (m * h)) * + hybridCubicCoefficient R r h t a P' * inverseCubicKernel P' (c * m) := by + rw [normalized_ideal_product_weight, hybrid_kernel_quotients R r k' P' c m h hk hP'] + simp only [hybridColumnCoefficient, hybridCubicCoefficient, div_eq_mul_inv] + ring + +def hybridInner (nset bset : Finset (Ideal Eis)) + (beta : Ideal Eis → Ideal Eis → ℂ) (k P : Ideal Eis) : ℂ := + ∑ n ∈ nset, ∑ b ∈ bset, + beta n b * CanonicalQuadraticSieve.quadraticRow k + (CompletedGauss.primaryGenerator (n * b)) * inverseCubicKernel P n * + (if IsCoprime P b then 1 else 0) + +def hybridRow (Pset nset bset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) : ℂ := + ∑ P ∈ Pset, a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * + (if IsCoprime k P then 1 else 0) * hybridInner nset bset beta k P + +def hybridDivisorTerm (Pset nset bset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ) + (k R : Ideal Eis) : ℂ := + ∑ P ∈ Pset, if R ∣ P then + a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * hybridInner nset bset beta k P else 0 + +theorem hybridRow_mobius (Pset nset bset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ) + (k : Ideal Eis) (hk : k ≠ 0) : + hybridRow Pset nset bset a beta k = + ∑ R ∈ idealDivisors k, (moebius R : ℂ) * + ∑ P ∈ Pset, if R ∣ P then + a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * + hybridInner nset bset beta k P else 0 := by + unfold hybridRow + conv_lhs => simp only [ideal_coprime_mobius k _ hk, Finset.mul_sum, Finset.sum_mul] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro R hR + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro P hP + by_cases hRP : R ∣ P <;> simp only [hRP, ite_true, ite_false, mul_zero, zero_mul] + ring + +theorem hybrid_first_mask_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ (K : ℝ), 1 ≤ K → + ∀ (rows Pset nset bset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, k ≠ 0 ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∑ k ∈ rows, ‖hybridRow Pset nset bset a beta k‖ ^ 2) ≤ + C * K ^ ε * + ∑ R ∈ rows.biUnion idealDivisors, ∑ k ∈ rows, + if R ∈ idealDivisors k then + ‖hybridDivisorTerm Pset nset bset a beta k R‖ ^ 2 else 0 := by + obtain ⟨C, hC, hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power ε hε + refine ⟨C, hC, ?_⟩ + intro K hK rows Pset nset bset a beta hrows + have hrewrite : (∑ k ∈ rows, ‖hybridRow Pset nset bset a beta k‖ ^ 2) = + ∑ k ∈ rows, ‖∑ R ∈ idealDivisors k, + (moebius R : ℂ) * hybridDivisorTerm Pset nset bset a beta k R‖ ^ 2 := by + apply Finset.sum_congr rfl + intro k hk + rw [hybridRow_mobius Pset nset bset a beta k (hrows k hk).1] + rfl + rw [hrewrite] + apply finite_expansion_energy rows (rows.biUnion idealDivisors) idealDivisors + (fun _ R => (moebius R : ℂ)) (hybridDivisorTerm Pset nset bset a beta) (C * K ^ ε) + · intro k hk R hR + exact Finset.mem_biUnion.mpr ⟨k, hk, hR⟩ + · intro k hk R hR + exact QuadraticInitialBound.norm_ideal_moebius_le_one R + · intro k hk + exact (hdiv k (hrows k hk).1).trans + (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow (Nat.cast_nonneg _) (hrows k hk).2 hε.le) hC.le) + +def doubleMaskRow (pairs : Finset (Ideal Eis × Ideal Eis)) + (F : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) : ℂ := + ∑ p ∈ pairs, (if IsCoprime k (p.1 * p.2) then 1 else 0) * F k p.1 p.2 + +def doubleMaskDivisorTerm (pairs : Finset (Ideal Eis × Ideal Eis)) + (F : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) + (D : Ideal Eis × Ideal Eis) : ℂ := + ∑ p ∈ pairs, if D.1 ∣ p.1 ∧ D.2 ∣ p.2 then F k p.1 p.2 else 0 + +theorem doubleMaskRow_mobius (pairs : Finset (Ideal Eis × Ideal Eis)) + (F : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) (hk : k ≠ 0) : + doubleMaskRow pairs F k = + ∑ D ∈ (idealDivisors k) ×ˢ (idealDivisors k), + ((moebius D.1 : ℂ) * (moebius D.2 : ℂ)) * doubleMaskDivisorTerm pairs F k D := by + have hm (P c : Ideal Eis) : + (if IsCoprime k (P * c) then (1 : ℂ) else 0) = + ∑ D ∈ (idealDivisors k) ×ˢ (idealDivisors k), + if D.1 ∣ P ∧ D.2 ∣ c then (moebius D.1 : ℂ) * (moebius D.2 : ℂ) else 0 := by + rw [hybrid_double_mask_mobius k P c hk, Finset.sum_product] + unfold doubleMaskRow + conv_lhs => simp only [hm, Finset.sum_mul] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro D hD + rw [doubleMaskDivisorTerm, Finset.mul_sum] + apply Finset.sum_congr rfl + intro p hp + by_cases h : D.1 ∣ p.1 ∧ D.2 ∣ p.2 <;> simp [h] + +theorem hybrid_double_mask_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K : ℝ, 1 ≤ K → + ∀ (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)) + (F : Ideal Eis → Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, k ≠ 0 ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∑ k ∈ rows, ‖doubleMaskRow pairs F k‖ ^ 2) ≤ + C * K ^ ε * + ∑ D ∈ rows.biUnion (fun k => (idealDivisors k) ×ˢ (idealDivisors k)), + ∑ k ∈ rows, if D ∈ (idealDivisors k) ×ˢ (idealDivisors k) then + ‖doubleMaskDivisorTerm pairs F k D‖ ^ 2 else 0 := by + obtain ⟨C, hC, hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power (ε / 2) (by positivity) + refine ⟨C ^ 2, pow_pos hC 2, ?_⟩ + intro K hK rows pairs F hrows + have he (k : Ideal Eis) (hk : k ∈ rows) := doubleMaskRow_mobius pairs F k (hrows k hk).1 + simp_rw [Finset.sum_congr rfl (fun k hk => congrArg (fun z : ℂ => ‖z‖ ^ 2) (he k hk))] + apply finite_expansion_energy rows + (rows.biUnion (fun k => (idealDivisors k) ×ˢ (idealDivisors k))) + (fun k => (idealDivisors k) ×ˢ (idealDivisors k)) + (fun _ D => (moebius D.1 : ℂ) * (moebius D.2 : ℂ)) + (doubleMaskDivisorTerm pairs F) (C ^ 2 * K ^ ε) + · intro k hk D hD + exact Finset.mem_biUnion.mpr ⟨k, hk, hD⟩ + · intro k hk D hD + rw [norm_mul] + calc + _ ≤ 1 * 1 := mul_le_mul + (QuadraticInitialBound.norm_ideal_moebius_le_one D.1) + (QuadraticInitialBound.norm_ideal_moebius_le_one D.2) (norm_nonneg _) (by norm_num) + _ = 1 := by norm_num + · intro k hk + have hd := (hdiv k (hrows k hk).1).trans + (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow (Nat.cast_nonneg _) (hrows k hk).2 (by positivity)) hC.le) + calc + _ = ((idealDivisors k).card : ℝ) ^ 2 := by simp [Finset.card_product, pow_two] + _ ≤ (C * K ^ (ε / 2)) ^ 2 := pow_le_pow_left₀ (Nat.cast_nonneg _) hd 2 + _ = C ^ 2 * K ^ ε := by + rw [mul_pow, pow_two (K ^ (ε / 2)), ← Real.rpow_add (by linarith : 0 < K)] + congr 1 + congr 1 + ring + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/HybridBound.lean b/lean/OAI/NumberTheory/DirichletL/Descent/HybridBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..177bc8009e479cd8eedbb2c58c147655a782634f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/HybridBound.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Descent.SourceHybrid + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +private theorem hybrid_log_cost_bound (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → + K ^ (ε / 9) * (K * (N * B) * N) ^ (ε / 9) * + (columnDyadicLength K + 1 : ℝ) ^ 2 * (columnDyadicLength N + 1 : ℝ) ^ 2 * + (columnDyadicLength B + 1 : ℝ) ^ 2 ≤ C * (K * N * B) ^ ε := by + let δ := ε / 9 + let A := 2 + 1 / (δ * Real.log 2) + have hδ : 0 < δ := by dsimp only [δ]; positivity + have hA : 0 < A := by dsimp only [A]; positivity + refine ⟨A ^ 6, pow_pos hA 6, ?_⟩ + intro K N B hK hN hB + let Q := K * N * B + have hQ : 1 ≤ Q := one_le_mul_of_one_le_of_one_le + (one_le_mul_of_one_le_of_one_le hK hN) hB + have hQ0 : 0 < Q := by linarith + have hKQ : K ≤ Q := + (le_mul_of_one_le_right (by linarith : 0 ≤ K) hN).trans + (le_mul_of_one_le_right (by positivity : 0 ≤ K * N) hB) + have hNQ : N ≤ Q := + (le_mul_of_one_le_left (by linarith : 0 ≤ N) hK).trans + (le_mul_of_one_le_right (by positivity : 0 ≤ K * N) hB) + have hBQ : B ≤ Q := le_mul_of_one_le_left (by linarith) + (one_le_mul_of_one_le_of_one_le hK hN) + have hquad : K * (N * B) * N ≤ Q ^ 2 := by + calc + _ = Q * N := by dsimp only [Q]; ring + _ ≤ Q * Q := mul_le_mul_of_nonneg_left hNQ hQ0.le + _ = _ := by ring + have hlog (Y : ℝ) (hY : 1 ≤ Y) (hYQ : Y ≤ Q) : + (columnDyadicLength Y + 1 : ℝ) ≤ A * Q ^ δ := by + exact (columnDyadicLength_small_power δ hδ Y hY).trans + (mul_le_mul_of_nonneg_left (Real.rpow_le_rpow (by linarith) hYQ hδ.le) hA.le) + have hpow2 : (Q ^ 2) ^ δ = (Q ^ δ) ^ 2 := by + rw [← Real.rpow_natCast_mul hQ0.le 2 δ] + rw [← Real.rpow_natCast, ← Real.rpow_mul hQ0.le] + congr 1 + ring + have hpow9 : (Q ^ δ) ^ 9 = Q ^ ε := by + rw [← Real.rpow_natCast, ← Real.rpow_mul hQ0.le] + congr 1 + dsimp only [δ] + ring + calc + _ ≤ Q ^ δ * (Q ^ δ) ^ 2 * (A * Q ^ δ) ^ 2 * (A * Q ^ δ) ^ 2 * (A * Q ^ δ) ^ 2 := by + have hbase := Real.rpow_le_rpow (by positivity : 0 ≤ K * (N * B) * N) hquad hδ.le + rw [hpow2] at hbase + gcongr + · exact hlog K hK hKQ + · exact hlog N hN hNQ + · exact hlog B hB hBQ + _ = A ^ 6 * (Q ^ δ) ^ 9 := by ring + _ = _ := by rw [hpow9] + +theorem supportedHybridRow_energy_sieve_norm (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → + ∀ (rows : Finset (Ideal Eis)) (S : Finset (Ideal Eis × Ideal Eis)) + (Pset : Finset (Ideal Eis)) (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ S, Squarefree p.1 ∧ primaryGenerator p.1 ≠ 0 ∧ primaryGenerator p.2 ≠ 0 ∧ + (Ideal.absNorm p.1 : ℝ) ≤ N ∧ (Ideal.absNorm p.2 : ℝ) ≤ B) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → (∀ p ∈ S, ‖beta p.1 p.2‖ ≤ 1) → + (∑ k ∈ rows, ‖supportedHybridRow S Pset a beta k‖ ^ 2) ≤ + C * (K * N * B) ^ ε * (K + N * B) * B * CubicSieve.sieveNorm N (2 * L) := by + obtain ⟨C₀, hC₀, he⟩ := supportedHybridRow_energy_log (ε / 9) (by positivity) + obtain ⟨C₁, hC₁, hlogs⟩ := hybrid_log_cost_bound ε hε + refine ⟨C₀ * C₁, mul_pos hC₀ hC₁, ?_⟩ + intro K N B L hK hN hB rows S Pset a beta hrows hS hP ha hbeta + have hb := he K N B L hK hN hB rows S Pset a beta hrows hS hP ha hbeta + have hs : 0 ≤ CubicSieve.sieveNorm N (2 * L) := sq_nonneg _ + apply hb.trans + calc + _ = C₀ * (K ^ (ε / 9) * (K * (N * B) * N) ^ (ε / 9) * + (columnDyadicLength K + 1 : ℝ) ^ 2 * (columnDyadicLength N + 1 : ℝ) ^ 2 * + (columnDyadicLength B + 1 : ℝ) ^ 2) * + (K + N * B) * B * CubicSieve.sieveNorm N (2 * L) := by ring + _ ≤ C₀ * (C₁ * (K * N * B) ^ ε) * (K + N * B) * B * CubicSieve.sieveNorm N (2 * L) := by + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left (hlogs K N B hK hN hB) hC₀.le) + (by positivity)) (by linarith)) hs + _ = _ := by ring + +theorem hybridRow_energy_sieve_norm (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → + ∀ (rows nset bset Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ b ∈ bset, primaryGenerator b ≠ 0 ∧ (Ideal.absNorm b : ℝ) ≤ B) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → (∀ n ∈ nset, ∀ b ∈ bset, ‖beta n b‖ ≤ 1) → + (∑ k ∈ rows, ‖hybridRow Pset nset bset a beta k‖ ^ 2) ≤ + C * (K * N * B) ^ ε * (K + N * B) * B * CubicSieve.sieveNorm N (2 * L) := by + obtain ⟨C, hC, he⟩ := supportedHybridRow_energy_sieve_norm ε hε + refine ⟨C, hC, ?_⟩ + intro K N B L hK hN hB rows nset bset Pset a beta hrows hn hb hP ha hbeta + have hprod : ∀ p ∈ nset ×ˢ bset, + Squarefree p.1 ∧ primaryGenerator p.1 ≠ 0 ∧ primaryGenerator p.2 ≠ 0 ∧ + (Ideal.absNorm p.1 : ℝ) ≤ N ∧ (Ideal.absNorm p.2 : ℝ) ≤ B := by + intro p hp + obtain ⟨hpn, hpb⟩ := Finset.mem_product.mp hp + exact ⟨(hn p.1 hpn).1.1, (hn p.1 hpn).1.2, (hb p.2 hpb).1, + (hn p.1 hpn).2, (hb p.2 hpb).2⟩ + have hh := he K N B L hK hN hB rows (nset ×ˢ bset) Pset a beta hrows hprod hP ha + (fun p hp => hbeta p.1 (Finset.mem_product.mp hp).1 p.2 (Finset.mem_product.mp hp).2) + simpa only [supportedHybridRow_product] using hh + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/HybridReduction.lean b/lean/OAI/NumberTheory/DirichletL/Descent/HybridReduction.lean new file mode 100644 index 0000000000000000000000000000000000000000..b0da773ced17db15d18290f72818bf65dc7f7157 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/HybridReduction.lean @@ -0,0 +1,196 @@ +import OAI.NumberTheory.DirichletL.Descent.Quadratic +import OAI.NumberTheory.DirichletL.Descent.Hybrid + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem finite_inverse_cubic_energy + (Jset Pset : Finset (Ideal Eis)) (N L : ℝ) + (hJ : ∀ J ∈ Jset, CubicSieve.Admissible J ∧ (Ideal.absNorm J : ℝ) ≤ N) + (hP : ∀ P ∈ Pset, CubicSieve.Admissible P ∧ (Ideal.absNorm P : ℝ) ≤ L) + (a : Ideal Eis → ℂ) : + (∑ J ∈ Jset, ‖∑ P ∈ Pset, a P * inverseCubicKernel P J‖ ^ 2) ≤ + CubicSieve.sieveNorm N L * ∑ P ∈ Pset, ‖a P‖ ^ 2 := by + let A : Matrix Jset Pset ℂ := fun J P => CubicSieve.idealKernel P.val J.val + have hnorm : CubicSieve.squaredNorm (fun J P => star (A J P)) = + CubicSieve.squaredNorm A := + congrArg (fun z : ℝ => z ^ 2) (CubicSieve.operator_conjugate_norm A) + have hfamily : CubicSieve.squaredNorm A ≤ CubicSieve.sieveNorm N L := + CubicSieve.family_squared_norm_le + (fun J : Jset => J.val) (fun P : Pset => P.val) + Subtype.val_injective Subtype.val_injective N L + (fun J => hJ J.val J.property) (fun P => hP P.val P.property) + have he := CubicSieve.energy_le_squaredNorm (fun J P => star (A J P)) (fun P => a P.val) + rw [hnorm] at he + have he' := he.trans (mul_le_mul_of_nonneg_right hfamily + (Finset.sum_nonneg fun _ _ => sq_nonneg _)) + have hinner (J : Jset) : + (∑ P : Pset, star (A J P) * a P.val) = + ∑ P ∈ Pset, a P * inverseCubicKernel P J.val := by + simp only [A, inverseCubicKernel, CubicSieve.idealKernel, mul_comm] + exact Finset.sum_coe_sort Pset + (fun P => a P * star (ConcreteTraceCRT.eisEmbedding + (CubicJacobiGlobal.idealSymbol P (primaryGenerator J.val)))) + simp_rw [hinner] at he' + rw [Finset.sum_coe_sort Jset + (fun J => ‖∑ P ∈ Pset, a P * inverseCubicKernel P J‖ ^ 2), + Finset.sum_coe_sort Pset (fun P => ‖a P‖ ^ 2)] at he' + exact he' + +theorem hybrid_quadratic_reduction (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X : ℝ, 1 ≤ K → 1 ≤ X → + ∀ (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ pairs, Squarefree (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + ∀ (B mBad : Ideal Eis) (cset : Ideal Eis → Finset (Ideal Eis)) + (Pset : Finset (Ideal Eis)) (coef : Ideal Eis → Ideal Eis → ℂ) + (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (Cbound : ℝ), + (∀ p ∈ pairs, ((cset p.1).card : ℝ) ≤ Cbound) → + (∀ p ∈ pairs, ∀ c ∈ cset p.1, ‖beta c p.1 p.2‖ ≤ 1) → + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (B * (p.1 * p.2))) * + (∑ c ∈ cset p.1, beta c p.1 p.2 * + (∑ P ∈ Pset, coef p.2 P * inverseCubicKernel P (c * (mBad * p.1))))‖ ^ 2) ≤ + C * (K * X) ^ ε * (K + X) * Cbound * + ∑ p ∈ pairs, ∑ c ∈ cset p.1, + ‖∑ P ∈ Pset, coef p.2 P * inverseCubicKernel P (c * (mBad * p.1))‖ ^ 2 := by + obtain ⟨C, hC, hquadratic⟩ := quadratic_squarefree_product_energy_fixed_factor ε hε + refine ⟨C, hC, ?_⟩ + intro K X hK hX rows pairs hrows hpairs B mBad cset Pset coef beta Cbound hcount hbeta + let F (p : Ideal Eis × Ideal Eis) (c : Ideal Eis) := + ∑ P ∈ Pset, coef p.2 P * inverseCubicKernel P (c * (mBad * p.1)) + have he := hquadratic K X hK hX rows pairs hrows hpairs B + (fun p => ∑ c ∈ cset p.1, beta c p.1 p.2 * F p c) + apply he.trans + have hlocal (p : Ideal Eis × Ideal Eis) (hp : p ∈ pairs) : + ‖∑ c ∈ cset p.1, beta c p.1 p.2 * F p c‖ ^ 2 ≤ + Cbound * ∑ c ∈ cset p.1, ‖F p c‖ ^ 2 := by + exact (bounded_finset_coefficient_sum_sq (cset p.1) + (fun c => beta c p.1 p.2) (F p) (hbeta p hp)).trans + (mul_le_mul_of_nonneg_right (hcount p hp) (Finset.sum_nonneg fun _ _ => sq_nonneg _)) + calc + _ ≤ C * (K * X) ^ ε * (K + X) * + ∑ p ∈ pairs, Cbound * ∑ c ∈ cset p.1, ‖F p c‖ ^ 2 := by + apply mul_le_mul_of_nonneg_left (Finset.sum_le_sum hlocal) + positivity + _ = _ := by rw [← Finset.mul_sum]; simp only [F]; ring + +theorem cubic_product_row_bound_of_sieve (ε : ℝ) (hε : 0 < ε) : + ∃ D : ℝ, 0 < D ∧ ∀ N : ℝ, 1 ≤ N → + ∀ (pairs : Finset (Ideal Eis × Ideal Eis)) (Jset Pset : Finset (Ideal Eis)) + (mBad : Ideal Eis) (S : ℝ), + (∀ p ∈ pairs, p.2 * (mBad * p.1) ∈ Jset) → + (∀ J ∈ Jset, CubicSieve.Admissible J ∧ (Ideal.absNorm J : ℝ) ≤ N) → + (∀ a : Ideal Eis → ℂ, + (∑ J ∈ Jset, ‖∑ P ∈ Pset, a P * inverseCubicKernel P J‖ ^ 2) ≤ + S * ∑ P ∈ Pset, ‖a P‖ ^ 2) → + ∀ a : Ideal Eis → ℂ, + (∑ p ∈ pairs, ‖∑ P ∈ Pset, + a P * inverseCubicKernel P (p.2 * (mBad * p.1))‖ ^ 2) ≤ + D * N ^ ε * S * ∑ P ∈ Pset, ‖a P‖ ^ 2 := by + obtain ⟨D, hD, hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power ε hε + refine ⟨D, hD, ?_⟩ + intro N hN pairs Jset Pset mBad S hmap hJset hcubic a + let E (J : Ideal Eis) := ‖∑ P ∈ Pset, a P * inverseCubicKernel P J‖ ^ 2 + have hfiber (J : Ideal Eis) (hJ : J ∈ Jset) : + (∑ _p ∈ pairs with _p.2 * (mBad * _p.1) = J, (1 : ℝ)) ≤ D * N ^ ε := by + have hJ0 := (hJset J hJ).1.1.ne_zero + have hc : ((pairs.filter (fun p => p.2 * (mBad * p.1) = J)).card : ℝ) ≤ + ((IdealMobiusDivisorSum.idealDivisors J).card : ℝ) := + Nat.cast_le.mpr (scaled_product_fiber_card pairs mBad J hJ0) + have hd := (hdiv J hJ0).trans (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow (Nat.cast_nonneg _) (hJset J hJ).2 hε.le) hD.le) + exact (by simpa using hc : + (∑ _p ∈ pairs with _p.2 * (mBad * _p.1) = J, (1 : ℝ)) ≤ + ((IdealMobiusDivisorSum.idealDivisors J).card : ℝ)).trans hd + have hf := fiber_energy_bound pairs Jset (fun p => p.2 * (mBad * p.1)) + (fun _ => 1) (fun _ => D * N ^ ε) E hmap (fun _ _ => sq_nonneg _) hfiber + simp only [one_mul, ← Finset.mul_sum] at hf + apply hf.trans + calc + _ ≤ (D * N ^ ε) * (S * ∑ P ∈ Pset, ‖a P‖ ^ 2) := + mul_le_mul_of_nonneg_left (hcubic a) (by positivity) + _ = _ := by ring + +theorem cubic_product_row_sieve_norm (ε : ℝ) (hε : 0 < ε) : + ∃ D : ℝ, 0 < D ∧ ∀ N L : ℝ, 1 ≤ N → + ∀ (pairs : Finset (Ideal Eis × Ideal Eis)) (Jset Pset : Finset (Ideal Eis)) + (mBad : Ideal Eis), + (∀ p ∈ pairs, p.2 * (mBad * p.1) ∈ Jset) → + (∀ J ∈ Jset, CubicSieve.Admissible J ∧ (Ideal.absNorm J : ℝ) ≤ N) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ (Ideal.absNorm P : ℝ) ≤ L) → + ∀ a : Ideal Eis → ℂ, + (∑ p ∈ pairs, ‖∑ P ∈ Pset, + a P * inverseCubicKernel P (p.2 * (mBad * p.1))‖ ^ 2) ≤ + D * N ^ ε * CubicSieve.sieveNorm N L * ∑ P ∈ Pset, ‖a P‖ ^ 2 := by + obtain ⟨D, hD, hb⟩ := cubic_product_row_bound_of_sieve ε hε + refine ⟨D, hD, ?_⟩ + intro N L hN pairs Jset Pset mBad hmap hJ hP a + exact hb N hN pairs Jset Pset mBad (CubicSieve.sieveNorm N L) hmap hJ + (finite_inverse_cubic_energy Jset Pset N L hJ hP) a + +theorem hybrid_fixed_block_sieve_norm (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X N L : ℝ, 1 ≤ K → 1 ≤ X → 1 ≤ N → + ∀ (rows : Finset (Ideal Eis)) (pairs cubicPairs : Finset (Ideal Eis × Ideal Eis)) + (Hset Jset Pset : Finset (Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ pairs, Squarefree (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + ∀ (B mBad : Ideal Eis) (cset : Ideal Eis → Finset (Ideal Eis)) + (coef : Ideal Eis → Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (Cbound Ebound : ℝ), 0 ≤ Cbound → + (∀ p ∈ pairs, ((cset p.1).card : ℝ) ≤ Cbound) → + (∀ p ∈ pairs, ∀ c ∈ cset p.1, ‖beta c p.1 p.2‖ ≤ 1) → + (∀ p ∈ pairs, p.2 ∈ Hset) → + (∀ p ∈ pairs, ∀ c ∈ cset p.1, (p.1, c) ∈ cubicPairs) → + (∀ u ∈ cubicPairs, u.2 * (mBad * u.1) ∈ Jset) → + (∀ J ∈ Jset, CubicSieve.Admissible J ∧ (Ideal.absNorm J : ℝ) ≤ N) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ (Ideal.absNorm P : ℝ) ≤ L) → + (∀ h ∈ Hset, (∑ P ∈ Pset, ‖coef h P‖ ^ 2) ≤ Ebound) → + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (B * (p.1 * p.2))) * + (∑ c ∈ cset p.1, beta c p.1 p.2 * + (∑ P ∈ Pset, coef p.2 P * inverseCubicKernel P (c * (mBad * p.1))))‖ ^ 2) ≤ + C * (K * X * N) ^ ε * (K + X) * Cbound * (Hset.card : ℝ) * + CubicSieve.sieveNorm N L * Ebound := by + obtain ⟨Cq, hCq, hquad⟩ := hybrid_quadratic_reduction ε hε + obtain ⟨D, hD, hcube⟩ := cubic_product_row_sieve_norm ε hε + refine ⟨Cq * D, mul_pos hCq hD, ?_⟩ + intro K X N L hK hX hN rows pairs cubicPairs Hset Jset Pset hrows hpairs + B mBad cset coef beta Cbound Ebound hCbound hcount hbeta hH hmc hmap hJ hP hcoef + let E (h m c : Ideal Eis) := ‖∑ P ∈ Pset, + coef h P * inverseCubicKernel P (c * (mBad * m))‖ ^ 2 + have hnorm : 0 ≤ CubicSieve.sieveNorm N L := sq_nonneg _ + have he := hquad K X hK hX rows pairs hrows hpairs B mBad cset Pset coef beta + Cbound hcount hbeta + have hpos := positive_triple_enlarge pairs cset Hset cubicPairs E hH hmc + (fun _ _ _ => sq_nonneg _) + have htotal : (∑ p ∈ pairs, ∑ c ∈ cset p.1, E p.2 p.1 c) ≤ + (Hset.card : ℝ) * (D * N ^ ε * CubicSieve.sieveNorm N L * Ebound) := by + apply hpos.trans + calc + _ ≤ ∑ _h ∈ Hset, D * N ^ ε * CubicSieve.sieveNorm N L * Ebound := by + apply Finset.sum_le_sum + intro h hh + apply (hcube N L hN cubicPairs Jset Pset mBad hmap hJ hP (coef h)).trans + exact mul_le_mul_of_nonneg_left (hcoef h hh) + (mul_nonneg (mul_nonneg hD.le (Real.rpow_nonneg (by linarith) _)) hnorm) + _ = _ := by simp + apply he.trans + calc + _ ≤ (Cq * (K * X) ^ ε * (K + X) * Cbound) * + ((Hset.card : ℝ) * (D * N ^ ε * CubicSieve.sieveNorm N L * Ebound)) := by + apply mul_le_mul_of_nonneg_left htotal + positivity + _ = _ := by + rw [Real.mul_rpow (show 0 ≤ K * X by positivity) (show 0 ≤ N by linarith)] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/IdealMasks.lean b/lean/OAI/NumberTheory/DirichletL/Descent/IdealMasks.lean new file mode 100644 index 0000000000000000000000000000000000000000..dad6b8dcc8f08649fb95f1fb5dbe8aded3d38791 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/IdealMasks.lean @@ -0,0 +1,187 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Descent.Marks +import OAI.NumberTheory.DirichletL.Descent.Overlap + +namespace OAI + +namespace SevenEighths.InverseMoment + +noncomputable section + +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid IdealMobiusDivisorSum + +theorem prime_mem_support_iff_dvd (P A : Ideal ActualEisensteinCubic.O) + (hP : Prime P) (hA : A ≠ 0) : + P ∈ IdealMobiusDivisorSum.primeSupport A ↔ P ∣ A := by + simp only [IdealMobiusDivisorSum.primeSupport, Multiset.mem_toFinset, + UniqueFactorizationMonoid.mem_normalizedFactors_iff hA, hP, true_and] + +theorem ideal_primeMark_eq_divisibility {σ : Type*} [DecidableEq σ] + (I : Finset σ) (L : σ → Finset (Ideal ActualEisensteinCubic.O)) + (a : σ → Ideal ActualEisensteinCubic.O → ℂ) + (hL : ∀ i ∈ I, ∀ P ∈ L i, Prime P) + (A : Ideal ActualEisensteinCubic.O) (hA : A ≠ 0) : + primeMark I L a (IdealMobiusDivisorSum.primeSupport A) = + ∏ i ∈ I, ∑ P ∈ L i, if P ∣ A then a i P else 0 := by + unfold primeMark primeSlot + apply Finset.prod_congr rfl + intro i hi + apply Finset.sum_congr rfl + intro P hP + simp only [prime_mem_support_iff_dvd P A (hL i hi P hP) hA] + +theorem ideal_primeSupport_mul_cube (n b : Ideal ActualEisensteinCubic.O) + (hn : n ≠ 0) (hb : b ≠ 0) : + IdealMobiusDivisorSum.primeSupport (n * b ^ 3) = + IdealMobiusDivisorSum.primeSupport n ∪ IdealMobiusDivisorSum.primeSupport b := by + simp only [IdealMobiusDivisorSum.primeSupport, + normalizedFactors_mul hn (pow_ne_zero 3 hb), normalizedFactors_pow, + Multiset.toFinset_add] + congr 1 + ext P + simp + +theorem ideal_whole_mark_priority {σ : Type*} [DecidableEq σ] + (I : Finset σ) (L : σ → Finset (Ideal ActualEisensteinCubic.O)) + (a : σ → Ideal ActualEisensteinCubic.O → ℂ) + (n b : Ideal ActualEisensteinCubic.O) (hn : n ≠ 0) (hb : b ≠ 0) : + primeMark I L a (IdealMobiusDivisorSum.primeSupport (n * b ^ 3)) = + ∑ J ∈ I.powerset, + primeMark J L a (IdealMobiusDivisorSum.primeSupport n) * + primeMark (I \ J) L a + (IdealMobiusDivisorSum.primeSupport b \ IdealMobiusDivisorSum.primeSupport n) := by + rw [ideal_primeSupport_mul_cube n b hn hb] + exact primeMark_priority _ _ _ _ _ + +theorem ideal_primeMark_small_power (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {σ : Type*} [DecidableEq σ] + (I : Finset σ) (L : σ → Finset (Ideal ActualEisensteinCubic.O)) + (a : σ → Ideal ActualEisensteinCubic.O → ℂ), + (I : Set σ).PairwiseDisjoint L → + (∀ i ∈ I, ∀ P ∈ L i, ‖a i P‖ ≤ 1) → + ∀ A : Ideal ActualEisensteinCubic.O, A ≠ 0 → + ‖primeMark I L a (IdealMobiusDivisorSum.primeSupport A)‖ ≤ + C * (Ideal.absNorm A : ℝ) ^ ε := by + obtain ⟨C, hC, hb⟩ := SquarefreeDivisorBound.prime_support_subsets_bound ε hε + refine ⟨C, hC, ?_⟩ + intro σ _ I L a hL ha A hA + exact (primeMark_norm_le_divisor_count I L a _ hL ha).trans (hb A hA) + +theorem ideal_coprime_mobius (K P : Ideal ActualEisensteinCubic.O) (hK : K ≠ 0) : + (if IsCoprime K P then (1 : ℂ) else 0) = + ∑ R ∈ idealDivisors K, if R ∣ P then (moebius R : ℂ) else 0 := by + let G := K ⊔ P + have hG : G ≠ 0 := by + intro hz + apply hK + exact le_antisymm (show K ≤ 0 from hz ▸ (le_sup_left : K ≤ G)) bot_le + have hdiv : (idealDivisors K).filter (fun R => R ∣ P) = idealDivisors G := by + ext R + simp only [Finset.mem_filter, mem_idealDivisors hK, mem_idealDivisors hG, + Ideal.dvd_iff_le, G, sup_le_iff] + rw [← Finset.sum_filter, hdiv, sum_moebius_divisors G hG] + simp only [Ideal.isCoprime_iff_sup_eq, G] + +theorem idealZeroMask_primary_indicator + (D B : Ideal ActualEisensteinCubic.O) (hD : D ≠ 0) + (hB : CompletedGauss.primaryGenerator B ≠ 0) : + CanonicalQuadraticSieve.idealZeroMask D (CompletedGauss.primaryGenerator B) = + if IsCoprime B D then 1 else 0 := by + have he : Ideal.span {CompletedGauss.primaryGenerator B} = + Ideal.span {ConcretePrimeRowBridge.idealGenerator B} := by + rw [(CompletedGauss.primaryGenerator_spec B hB).1, + ConcretePrimeRowBridge.span_idealGenerator] + rw [CanonicalQuadraticSieve.idealZeroMask_span_eq D _ _ he, + CanonicalQuadraticSieve.idealZeroMask_generator_eq_indicator D B hD] + +theorem hybrid_quadratic_square_mask + (k n b c m h t : Ideal ActualEisensteinCubic.O) + (hk : CanonicalQuadraticSieve.Admissible k) + (hn : n = c * m) (hb : b = (c * h) * t ^ 2) + (hct : CompletedGauss.primaryGenerator (c * t) ≠ 0) : + CanonicalQuadraticSieve.quadraticRow k (CompletedGauss.primaryGenerator (n * b)) = + (if IsCoprime k (c * t) then 1 else 0) * + CanonicalQuadraticSieve.quadraticRow k (CompletedGauss.primaryGenerator (m * h)) := by + have he : n * b = (c * t) ^ 2 * (m * h) := by rw [hn, hb]; ring + rw [he, CanonicalQuadraticSieve.canonical_quadraticRow_primary_squarefree k hk, + idealZeroMask_primary_indicator k (c * t) hk.1 hct] + rw [isCoprime_comm] + +theorem hybrid_double_mask_mobius + (k P c : Ideal ActualEisensteinCubic.O) (hk : k ≠ 0) : + (if IsCoprime k (P * c) then (1 : ℂ) else 0) = + ∑ R ∈ idealDivisors k, ∑ r ∈ idealDivisors k, + if R ∣ P ∧ r ∣ c then (moebius R : ℂ) * (moebius r : ℂ) else 0 := by + have hsplit : (if IsCoprime k (P * c) then (1 : ℂ) else 0) = + (if IsCoprime k P then 1 else 0) * (if IsCoprime k c then 1 else 0) := by + simp only [IsCoprime.mul_right_iff] + by_cases hP : IsCoprime k P <;> by_cases hc : IsCoprime k c <;> simp [hP, hc] + rw [hsplit, ideal_coprime_mobius k P hk, ideal_coprime_mobius k c hk, + Finset.sum_mul] + apply Finset.sum_congr rfl + intro R hR + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + by_cases hP : R ∣ P <;> by_cases hc : r ∣ c <;> simp [hP, hc] + +theorem hybrid_column_decomposition + (n b : Ideal ActualEisensteinCubic.O) (hn : Squarefree n) (hb : b ≠ 0) : + ∃ c m h t : Ideal ActualEisensteinCubic.O, + n = c * m ∧ b = (c * h) * t ^ 2 ∧ + Squarefree c ∧ Squarefree m ∧ Squarefree h ∧ + IsRelPrime c m ∧ IsRelPrime c h ∧ IsCoprime m h ∧ t ≠ 0 := by + let g := QuadraticSquarefreeKernel.squarefreePart b + let t := QuadraticSquarefreeKernel.squarePart b + let c := gcd n g + let m := CanonicalQuadraticSieve.idealQuotient c n + let h := CanonicalQuadraticSieve.idealQuotient c g + have hg : Squarefree g := QuadraticSquarefreeKernel.squarefree_squarefreePart b + have hcn : c ∣ n := gcd_dvd_left n g + have hcg : c ∣ g := gcd_dvd_right n g + have hc : c ≠ 0 := ne_zero_of_dvd_ne_zero hn.ne_zero hcn + have hnm : n = c * m := (CanonicalQuadraticSieve.idealQuotient_mul hcn).symm + have hgh : g = c * h := (CanonicalQuadraticSieve.idealQuotient_mul hcg).symm + have hbgt : b = g * t ^ 2 := by + rw [mul_comm] + exact (QuadraticSquarefreeKernel.squarePart_sq_mul_squarefreePart b).symm + obtain ⟨hcm, hcs, hms⟩ := squarefree_mul_iff.mp (hnm ▸ hn) + obtain ⟨hch, _, hhs⟩ := squarefree_mul_iff.mp (hgh ▸ hg) + have hmh : IsCoprime m h := + (CanonicalQuadraticSieve.gcd_eq_iff_quotient_coprime c n g hc hcn hcg).mp rfl + exact ⟨c, m, h, t, hnm, by rw [hbgt, hgh], hcs, hms, hhs, hcm, hch, hmh, + QuadraticSquarefreeKernel.squarePart_ne_zero hb⟩ + +theorem ideal_product_fiber_card + (s t : Finset (Ideal ActualEisensteinCubic.O)) + (J : Ideal ActualEisensteinCubic.O) (hJ : J ≠ 0) : + (((s ×ˢ t).filter (fun p => p.1 * p.2 = J)).card) ≤ (idealDivisors J).card := + CanonicalQuadraticSieve.product_fiber_card (s ×ˢ t) J hJ + +theorem scaled_product_fiber_card + (pairs : Finset (Ideal ActualEisensteinCubic.O × Ideal ActualEisensteinCubic.O)) + (B J : Ideal ActualEisensteinCubic.O) (hJ : J ≠ 0) : + ((pairs.filter (fun p => p.2 * (B * p.1) = J)).card) ≤ (idealDivisors J).card := by + apply Finset.card_le_card_of_injOn Prod.fst + · intro p hp + apply (mem_idealDivisors hJ).mpr + refine ⟨p.2 * B, ?_⟩ + rw [← (Finset.mem_filter.mp hp).2] + ring + · intro p hp q hq hpq + have hep := (Finset.mem_filter.mp hp).2 + have heq := (Finset.mem_filter.mp hq).2 + have hBm : B * p.1 ≠ 0 := by + intro hz + apply hJ + rw [← hep, hz, mul_zero] + apply Prod.ext hpq + apply mul_right_cancel₀ hBm + rw [hep, hpq, heq] + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/InitializationEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/InitializationEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..0c71bbbae7deb39b1374839ff8f09b4d6efa0ecf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/InitializationEnergy.lean @@ -0,0 +1,157 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialFibers +import OAI.NumberTheory.DirichletL.Descent.Fibers +import OAI.NumberTheory.DirichletL.Descent.Sharp + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss CanonicalQuadraticSieve SevenEighths.InverseInitialFibers +open IdealMobiusDivisorSum +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +abbrev InitialChild := Ideal Eis × Ideal Eis × Eis + +def initialChild {J : ℕ} (x : InitialTuple J) : InitialChild := + (idealQuotient x.divisor x.common, x.divisor * x.residual, + primaryGenerator x.divisor * x.frequency) + +structure InitialSourceValid {J : ℕ} (x : InitialTuple J) : Prop where + common_ne_zero : x.common ≠ 0 + residual_ne_zero : x.residual ≠ 0 + divisor_good : primaryGenerator x.divisor ≠ 0 + divisor_dvd : x.divisor ∣ x.common + assigned_dvd : ∀ i, (x.assigned i).val ∣ x.common * x.residual + +theorem initialChild_valid {J : ℕ} (x : InitialTuple J) (hx : InitialSourceValid x) : + Valid x (initialChild x).1 (initialChild x).2.1 (initialChild x).2.2 := by + have ht : idealQuotient x.divisor x.common * x.divisor = x.common := by + rw [mul_comm, idealQuotient_mul hx.divisor_dvd] + refine ⟨ht, rfl, hx.divisor_good, rfl, ?_⟩ + intro i + change (x.assigned i).val ∣ idealQuotient x.divisor x.common * (x.divisor * x.residual) + rw [← mul_assoc, ht] + exact hx.assigned_dvd i + +theorem initialChild_nonzero {J : ℕ} (x : InitialTuple J) (hx : InitialSourceValid x) : + (initialChild x).1 ≠ 0 ∧ (initialChild x).2.1 ≠ 0 := by + have hD : x.divisor ≠ 0 := by intro he; exact hx.divisor_good (by simp [he]) + constructor + · intro ht + have he := (initialChild_valid x hx).common_eq + rw [ht, zero_mul] at he + exact hx.common_ne_zero he.symm + · exact mul_ne_zero hD hx.residual_ne_zero + +def initialQuotientSet {J : ℕ} (source : Finset (InitialTuple J)) : Finset (Ideal Eis) := + source.image (fun x => (initialChild x).1) + +def initialDivisorWeight (J : ℕ) (c : InitialChild) : ℝ := + ((idealDivisors c.2.1).card : ℝ) ^ (J + 1) * ((idealDivisors c.1).card : ℝ) ^ J + +theorem initialChild_fiber_weight {J : ℕ} (source : Finset (InitialTuple J)) + (hsource : ∀ x ∈ source, InitialSourceValid x) (c : InitialChild) + (ht : c.1 ≠ 0) (hf : c.2.1 ≠ 0) (w : InitialTuple J → ℝ) + (hw : ∀ x ∈ source, w x ≤ 1) : + (∑ x ∈ source with initialChild x = c, w x) ≤ initialDivisorWeight J c := by + have hvalid : ∀ x ∈ source.filter (fun x => initialChild x = c), Valid x c.1 c.2.1 c.2.2 := by + intro x hx + obtain ⟨hxs, he⟩ := Finset.mem_filter.mp hx + simpa only [he] using initialChild_valid x (hsource x hxs) + calc + _ ≤ ∑ _x ∈ source.filter (fun x => initialChild x = c), (1 : ℝ) := + Finset.sum_le_sum (fun x hx => hw x (Finset.mem_filter.mp hx).1) + _ = ((source.filter (fun x => initialChild x = c)).card : ℝ) := by simp + _ ≤ initialDivisorWeight J c := by + have hh := valid_tuple_card_le_separated _ c.1 c.2.1 c.2.2 ht hf hvalid + dsimp only [initialDivisorWeight] + exact_mod_cast hh + +theorem initial_energy_projection {J : ℕ} (source : Finset (InitialTuple J)) + (hsource : ∀ x ∈ source, InitialSourceValid x) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hlabels : ∀ f ∈ labels, f ≠ 0) + (hchild : ∀ x ∈ source, (initialChild x).2.1 ∈ labels ∧ (initialChild x).2.2 ∈ rows) + (w : InitialTuple J → ℝ) (hw : ∀ x ∈ source, w x ≤ 1) (F : InitialChild → ℂ) : + (∑ x ∈ source, w x * ‖F (initialChild x)‖ ^ 2) ≤ + ∑ t ∈ initialQuotientSet source, ((idealDivisors t).card : ℝ) ^ J * + ∑ f ∈ labels, ((idealDivisors f).card : ℝ) ^ (J + 1) * + ∑ k ∈ rows, ‖F (t, f, k)‖ ^ 2 := by + have hmaps : ∀ x ∈ source, initialChild x ∈ initialQuotientSet source ×ˢ (labels ×ˢ rows) := by + intro x hx + exact Finset.mem_product.mpr ⟨Finset.mem_image.mpr ⟨x, hx, rfl⟩, + Finset.mem_product.mpr (hchild x hx)⟩ + have hfiber : ∀ c ∈ initialQuotientSet source ×ˢ (labels ×ˢ rows), + (∑ x ∈ source with initialChild x = c, w x) ≤ initialDivisorWeight J c := by + intro c hc + obtain ⟨ht, hfk⟩ := Finset.mem_product.mp hc + obtain ⟨x, hx, he⟩ := Finset.mem_image.mp ht + have ht0 : c.1 ≠ 0 := he ▸ (initialChild_nonzero x (hsource x hx)).1 + exact initialChild_fiber_weight source hsource c ht0 + (hlabels c.2.1 (Finset.mem_product.mp hfk).1) w hw + have he := fiber_energy_bound source (initialQuotientSet source ×ˢ (labels ×ˢ rows)) + initialChild w (initialDivisorWeight J) (fun c => ‖F c‖ ^ 2) hmaps + (fun _ _ => sq_nonneg _) hfiber + apply he.trans_eq + simp only [Finset.sum_product, initialDivisorWeight, Finset.mul_sum] + apply Finset.sum_congr rfl + intro t ht + apply Finset.sum_congr rfl + intro f hf + apply Finset.sum_congr rfl + intro k hk + ring + +def initialPositiveEnergy {J : ℕ} (source : Finset (InitialTuple J)) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (F : InitialChild → ℂ) : ℝ := + ∑ t ∈ initialQuotientSet source, ((idealDivisors t).card : ℝ) ^ J * + ∑ f ∈ labels, ((idealDivisors f).card : ℝ) ^ (J + 1) * + ∑ k ∈ rows, ‖F (t, f, k)‖ ^ 2 + +theorem initialPositiveEnergy_nonneg {J : ℕ} (source : Finset (InitialTuple J)) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (F : InitialChild → ℂ) : + 0 ≤ initialPositiveEnergy source labels rows F := by + unfold initialPositiveEnergy + positivity + +theorem initial_weighted_count {J : ℕ} (source : Finset (InitialTuple J)) + (hsource : ∀ x ∈ source, InitialSourceValid x) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hlabels : ∀ f ∈ labels, f ≠ 0) + (hchild : ∀ x ∈ source, (initialChild x).2.1 ∈ labels ∧ (initialChild x).2.2 ∈ rows) + (w : InitialTuple J → ℝ) (hw0 : ∀ x ∈ source, 0 ≤ w x) (hw1 : ∀ x ∈ source, w x ≤ 1) + (F G : InitialChild → ℂ) : + ‖∑ x ∈ source, (w x : ℂ) * F (initialChild x) * star (G (initialChild x))‖ ≤ + Real.sqrt (initialPositiveEnergy source labels rows F) * + Real.sqrt (initialPositiveEnergy source labels rows G) := by + have hF := initial_energy_projection source hsource labels rows hlabels hchild w hw1 F + have hG := initial_energy_projection source hsource labels rows hlabels hchild w hw1 G + apply (weighted_cauchy source w (F ∘ initialChild) (G ∘ initialChild) hw0).trans + exact mul_le_mul (Real.sqrt_le_sqrt hF) (Real.sqrt_le_sqrt hG) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + +theorem initial_weighted_count_normalized {J : ℕ} (source : Finset (InitialTuple J)) + (hsource : ∀ x ∈ source, InitialSourceValid x) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hlabels : ∀ f ∈ labels, f ≠ 0) + (hchild : ∀ x ∈ source, (initialChild x).2.1 ∈ labels ∧ (initialChild x).2.2 ∈ rows) + (w : InitialTuple J → ℝ) (hw0 : ∀ x ∈ source, 0 ≤ w x) (hw1 : ∀ x ∈ source, w x ≤ 1) + (F G : InitialChild → ℂ) (H : ℝ) (hH : 0 < H) : + ‖∑ x ∈ source, (w x : ℂ) * F (initialChild x) * star (G (initialChild x))‖ ≤ + H * (Real.sqrt (H⁻¹ * initialPositiveEnergy source labels rows F) * + Real.sqrt (H⁻¹ * initialPositiveEnergy source labels rows G)) := by + apply (initial_weighted_count source hsource labels rows hlabels hchild w hw0 hw1 F G).trans_eq + rw [Real.sqrt_mul (inv_nonneg.mpr hH.le), Real.sqrt_mul (inv_nonneg.mpr hH.le)] + have hc : H * (Real.sqrt H⁻¹) ^ 2 = 1 := by + rw [Real.sq_sqrt (inv_nonneg.mpr hH.le), mul_inv_cancel₀ hH.ne'] + calc + _ = (H * (Real.sqrt H⁻¹) ^ 2) * + (Real.sqrt (initialPositiveEnergy source labels rows F) * + Real.sqrt (initialPositiveEnergy source labels rows G)) := by rw [hc, one_mul] + _ = _ := by ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/LocalReflection.lean b/lean/OAI/NumberTheory/DirichletL/Descent/LocalReflection.lean new file mode 100644 index 0000000000000000000000000000000000000000..0810a9fc32b73d63209388a43acd192baf68944e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/LocalReflection.lean @@ -0,0 +1,65 @@ +import Mathlib.NumberTheory.GaussSum +import Mathlib.Analysis.Complex.Basic +import Mathlib.Tactic.Ring + +namespace OAI + +namespace SevenEighths.InverseMoment + +open scoped BigOperators Classical + +noncomputable section + +variable {F : Type*} [Field F] [Fintype F] + +def zeroMark (x : F) : ℂ := if x = 0 then 1 else 0 + +def localFourier (f : F → ℂ) (ψ : AddChar F ℂ) (h : F) : ℂ := + ∑ t : F, f t * ψ (-(h * t)) + +theorem localFourier_zeroMark (ψ : AddChar F ℂ) (h : F) : + localFourier zeroMark ψ h = 1 := by + simp [localFourier, zeroMark] + +theorem localFourier_trivial_nonzero (ψ : AddChar F ℂ) + (hψ : ψ.IsPrimitive) (h : F) (hh : h ≠ 0) : + localFourier (fun t => (1 : MulChar F ℂ) t) ψ h = -1 := by + have he := gaussSum_one_left (hψ (neg_ne_zero.mpr hh)) + simpa only [gaussSum, AddChar.mulShift_apply, neg_mul, localFourier] using he + +omit [Fintype F] in +theorem zeroMark_complement (x : F) : + zeroMark x = 1 - (1 : MulChar F ℂ) x := by + by_cases hx : x = 0 + · simp [zeroMark, hx, MulChar.map_zero] + · rw [zeroMark, ite_eq_right hx, MulChar.one_apply (isUnit_iff_ne_zero.mpr hx)] + ring + +def localReflectionActive (f : F → ℂ) (χ : MulChar F ℂ) + (ψ : AddChar F ℂ) (σ ε : Fˣ) (x : F) : ℂ := + (Fintype.card F : ℂ)⁻¹ * ∑ h : Fˣ, + localFourier f ψ h * ((χ⁻¹) ^ 2) (σ * h) * + ψ (((ε : F) * x) * ((h⁻¹ : Fˣ) : F)) + +theorem marked_active_eq_neg_trivial (χ : MulChar F ℂ) + (ψ : AddChar F ℂ) (hψ : ψ.IsPrimitive) (σ ε : Fˣ) (x : F) : + localReflectionActive zeroMark χ ψ σ ε x = + -localReflectionActive (fun t => (1 : MulChar F ℂ) t) χ ψ σ ε x := by + unfold localReflectionActive + rw [← mul_neg, ← Finset.sum_neg_distrib] + congr 1 + apply Finset.sum_congr rfl + intro h hh + rw [localFourier_zeroMark, localFourier_trivial_nonzero ψ hψ h (Units.ne_zero h)] + ring + +theorem marked_inactive_coefficient (ψ : AddChar F ℂ) : + (Fintype.card F : ℂ)⁻¹ * localFourier zeroMark ψ 0 = + (Fintype.card F : ℂ)⁻¹ := by + rw [localFourier_zeroMark, mul_one] + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkBounds.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..d14b0c506dac4df3b1f74000bc6f9a6e16ea9bee --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkBounds.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.IdealMasks + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + + theorem finite_primeSupport_card {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) (U : Finset ι) : + (IdealMobiusDivisorSum.primeSupport (Ideal.span {∏ i ∈ U, p i})).card = U.card := by + have hc : Pairwise (Function.onFun IsCoprime (fun i : U => Ideal.span {p i.val})) := by + intro i j hij + exact hcop (fun he => hij (Subtype.ext he)) + have he := Fintype.card_congr (productPrimeIndexEquiv (fun i : U => p i.val) hc) + simpa only [Finset.prod_coe_sort, PrimeIndex, Fintype.card_coe, CompletedGauss.primeSupport, IdealMobiusDivisorSum.primeSupport] using he.symm + +theorem finite_primeMark_small_power (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (_hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (_hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i ∈ slots, ∀ k ∈ lists i, ‖a i k‖ ≤ 1) → ∀ U : Finset ι, + ‖primeMark slots lists a U‖ ≤ C * (primeProductNorm p U)^ε := by + obtain ⟨C,hC,hb⟩ := SquarefreeDivisorBound.prime_support_subsets_bound ε hε + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop slots lists a hslots ha U + have hI : (Ideal.span {∏ i ∈ U, p i} : Ideal Eis) ≠ 0 := + Ideal.span_singleton_eq_bot.not.mpr (Finset.prod_ne_zero_iff.mpr (fun i hi => hp i)) + have hh := hb (Ideal.span {∏ i ∈ U, p i}) hI + rw [finite_primeSupport_card p hcop U] at hh + have hn : (Ideal.absNorm (Ideal.span {∏ i ∈ U, p i}) : ℝ) = primeProductNorm p U := + (ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span _).symm + rw [hn] at hh + exact (primeMark_norm_le_divisor_count slots lists a U hslots ha).trans hh + +theorem finite_primeMark_extracted_bound (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (_hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (_hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i ∈ slots, ∀ k ∈ lists i, ‖a i k‖ ≤ 1) → ∀ A U : Finset ι, + ‖primeMark slots lists a (A ∪ U)‖ ≤ (2:ℝ)^A.card * C * (primeProductNorm p U)^ε := by + obtain ⟨C,hC,hb⟩ := SquarefreeDivisorBound.prime_support_subsets_bound ε hε + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop slots lists a hslots ha A U + have hI : (Ideal.span {∏ i ∈ U, p i} : Ideal Eis) ≠ 0 := + Ideal.span_singleton_eq_bot.not.mpr (Finset.prod_ne_zero_iff.mpr (fun i hi => hp i)) + have hh := hb (Ideal.span {∏ i ∈ U, p i}) hI + rw [finite_primeSupport_card p hcop U] at hh + have hn : (Ideal.absNorm (Ideal.span {∏ i ∈ U, p i}) : ℝ) = primeProductNorm p U := + (ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span _).symm + rw [hn] at hh + calc + _ ≤ (2:ℝ)^(A ∪ U).card := primeMark_norm_le_divisor_count _ _ _ _ hslots ha + _ ≤ (2:ℝ)^(A.card+U.card) := pow_le_pow_right₀ (by norm_num) (Finset.card_union_le _ _) + _ = (2:ℝ)^A.card * (2:ℝ)^U.card := pow_add _ _ _ + _ ≤ (2:ℝ)^A.card * (C * (primeProductNorm p U)^ε) := mul_le_mul_of_nonneg_left hh (by positivity) + _ = _ := by ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkedFourier.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..32500521df87c67c31b0fa9b7ab6824449455921 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedFourier.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Descent.Completion +import OAI.NumberTheory.DirichletL.Descent.Poisson + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss CanonicalRowCompletion +open CubicEisenstein hiding summand +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem completed_summand_primary_support (Ψ : Eis →* ℂ) (W : ℝ → ℂ) + (X : ℝ) (I J : Ideal Eis) (h : summand Ψ W X I J ≠ 0) : + primaryGenerator (I * J ^ 3) ≠ 0 := by + have hI : primaryGenerator I ≠ 0 := by + intro hz + apply h + simp [summand, columnWeight, squarefreeGaussCoefficient, hz] + have hJ : primaryGenerator J ≠ 0 := by + intro hz + apply h + rw [summand, cubeWeight_zero_of_primaryGenerator_zero Ψ J hz] + ring + rw [primaryGenerator_mul, show primaryGenerator (J ^ 3) = primaryGenerator J ^ 3 from + map_pow primaryGeneratorHom J 3] + exact mul_ne_zero hI (pow_ne_zero _ hJ) + +theorem markedCompletedT_congr_primary (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) + (d e : Ideal Eis → ℂ) (h : ∀ A, primaryGenerator A ≠ 0 → d A = e A) : + markedCompletedT Ψ W X d = markedCompletedT Ψ W X e := by + apply tsum_congr + intro I + apply tsum_congr + intro J + by_cases hz : summand Ψ W X I J = 0 + · simp only [hz, zero_mul] + · rw [h (I * J ^ 3) (completed_summand_primary_support Ψ W X I J hz)] + +theorem markedCompletedT_quotient_fourier (c : Eis) (hc : c ≠ 0) + [Fintype (Eis ⧸ Ideal.span {c})] (F : (Eis ⧸ Ideal.span {c}) → ℂ) + (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) : + markedCompletedT Ψ W X (fun A => F (Ideal.Quotient.mk _ (primaryGenerator A))) = + ∑ h : Eis ⧸ Ideal.span {c}, finiteAdditiveFourierCoeff (quotientTrace c hc) F h * + completedFixedFrequency Ψ c hc h W X := by + have hinv (n : Eis) : + F (Ideal.Quotient.mk _ n) = + ∑ h : Eis ⧸ Ideal.span {c}, finiteAdditiveFourierCoeff (quotientTrace c hc) F h * + fixedRowFourierPhase c hc h n := + (finiteAdditiveFourier_inversion (quotientTrace c hc) + (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive c hc) F (Ideal.Quotient.mk _ n)).symm + have hp (p : Ideal Eis × Ideal Eis) : + summand Ψ W X p.1 p.2 * F (Ideal.Quotient.mk _ (primaryGenerator (p.1 * p.2 ^ 3))) = + ∑ h : Eis ⧸ Ideal.span {c}, finiteAdditiveFourierCoeff (quotientTrace c hc) F h * + (summand Ψ W X p.1 p.2 * fixedRowFourierPhase c hc h + (primaryGenerator p.1 * primaryGenerator p.2 ^ 3)) := by + rw [primaryGenerator_mul, show primaryGenerator (p.2 ^ 3) = primaryGenerator p.2 ^ 3 from + map_pow primaryGeneratorHom p.2 3, hinv, Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + ring + rw [markedCompletedT_eq_tsum Ψ W hW X hX] + simp_rw [hp] + rw [Summable.tsum_finsetSum] + · simp only [tsum_mul_left, completedFixedFrequency] + · intro h hh + exact (completedFixedFrequency_summable Ψ c hc h W hW X hX).mul_left _ + +theorem finiteAdditiveFourierCoeff_zero_delta {R : Type*} [CommRing R] [Fintype R] + (ψ : AddChar R ℂ) (h : R) : + finiteAdditiveFourierCoeff ψ (fun x => if x = 0 then 1 else 0) h = + (Fintype.card R : ℂ)⁻¹ := by + simp [finiteAdditiveFourierCoeff] + +theorem markedCompletedT_divisor_fourier (c : Eis) (hc : c ≠ 0) + [Fintype (Eis ⧸ Ideal.span {c})] + (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) : + markedCompletedT Ψ W X (fun A => if Ideal.span {c} ∣ A then 1 else 0) = + (Fintype.card (Eis ⧸ Ideal.span {c}) : ℂ)⁻¹ * + ∑ h : Eis ⧸ Ideal.span {c}, completedFixedFrequency Ψ c hc h W X := by + have hmark : markedCompletedT Ψ W X (fun A => if Ideal.span {c} ∣ A then 1 else 0) = + markedCompletedT Ψ W X (fun A => + if Ideal.Quotient.mk (Ideal.span {c}) (primaryGenerator A) = 0 then 1 else 0) := by + apply markedCompletedT_congr_primary + intro A hA + have hd : Ideal.span {c} ∣ A ↔ + Ideal.Quotient.mk (Ideal.span {c}) (primaryGenerator A) = 0 := by + calc + _ ↔ A ≤ Ideal.span {c} := Ideal.dvd_iff_le + _ ↔ Ideal.span {primaryGenerator A} ≤ Ideal.span {c} := by + rw [(primaryGenerator_spec A hA).1] + _ ↔ primaryGenerator A ∈ Ideal.span {c} := Ideal.span_singleton_le_iff_mem _ + _ ↔ _ := (Ideal.Quotient.eq_zero_iff_mem).symm + simp only [hd] + rw [hmark, markedCompletedT_quotient_fourier c hc + (fun x : Eis ⧸ Ideal.span {c} => if x = 0 then (1 : ℂ) else 0) Ψ W hW X hX] + simp only [finiteAdditiveFourierCoeff_zero_delta, Finset.mul_sum] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkedPhase.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedPhase.lean new file mode 100644 index 0000000000000000000000000000000000000000..1c29dd5e5290b8c5ec2371eee0a1721170bc8ec6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedPhase.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Descent.ReflectedDual + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss CubicEisenstein ConcreteTraceCRT LocalReflectionBrackets +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +noncomputable local instance markedPhaseFintype (P : Ideal Eis) [P.IsMaximal] : + Fintype (Eis ⧸ P) := Fintype.ofFinite _ +variable {ι : Type*} [Fintype ι] {p : ι → Eis} {N a0 c0 : Eis} {mode : Bool} + +def markedActiveExponent (S : Finset ι) (j : ι → ℕ) (i : ι) : ℕ := if i ∈ S then 0 else j i + +theorem mixedActiveBracket_eq_signed [∀ i, (Ideal.span {p i}).IsMaximal] + (hp : ∀ i, p i ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (D : ControlledStratumArithmetic p N a0 c0 mode) + (i : ι) (x : Eis) : + mixedActiveBracket hp hg j S D i x = (if i ∈ S then (-1 : ℂ) else 1) * + ((((actualSextic (Ideal.span {p i}) (hg i))⁻¹) ^ 2) (D.sigma i) * + phase (actualSextic (Ideal.span {p i}) (hg i)) (quotientTrace (p i) (hp i)) + (markedActiveExponent S j i) (D.epsilon i) * + bracket (actualSextic (Ideal.span {p i}) (hg i)) (markedActiveExponent S j i) + (Ideal.Quotient.mk _ x)) := by + by_cases hi : i ∈ S + · simp only [mixedActiveBracket, markedActiveExponent, hi, + phase, bracket, show (0 : ℕ) ≠ 4 by decide, ↓reduceIte, inv_pow, map_mul] + ring + · simp only [mixedActiveBracket, markedActiveExponent, hi, ite_false, one_mul] + +theorem mixedActiveBracket_product [∀ i, (Ideal.span {p i}).IsMaximal] + (hp : ∀ i, p i ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (D : ControlledStratumArithmetic p N a0 c0 mode) (x : Eis) : + (∏ i, mixedActiveBracket hp hg j S D i x) = + (-1 : ℂ) ^ S.card * D.bracketProduct hp hg (markedActiveExponent S j) x := by + simp_rw [mixedActiveBracket_eq_signed] + rw [Finset.prod_mul_distrib] + have hsign : (∏ i : ι, if i ∈ S then (-1 : ℂ) else 1) = (-1 : ℂ) ^ S.card := by + rw [Finset.prod_ite] + simp + rw [hsign] + rfl + +theorem mixedReflectedValue_eq_signed [∀ i, (Ideal.span {p i}).IsMaximal] + (D : ControlledStratumArithmetic p N a0 c0 mode) + (s : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode)) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (W : ℝ → ℂ) (X : ℝ) : + mixedReflectedValue D s hp hc0 hg j S W X = + (-1 : ℂ) ^ S.card * D.reflectedValue s hp hc0 hg (markedActiveExponent S j) W X := by + unfold mixedReflectedValue ControlledStratumArithmetic.reflectedValue + simp_rw [mixedActiveBracket_product] + conv_rhs => rw [mul_left_comm] + congr 1 + rw [← tsum_mul_left] + apply tsum_congr + intro t + ring + +theorem mixed_model_coefficient [∀ i, (Ideal.span {p i}).IsMaximal] + (D : ControlledStratumArithmetic p N a0 c0 mode) + (s : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode)) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (u : Eisˣ) (m : ℕ) (I J : Ideal Eis) : + s.amplitude u m I J * + (star D.fixedFactor * ShortDraftCusp.A4BadPhase c0 hc0 + (D.matrix (fun _ => 1) 1 1) D.U (s.modelDualNumerator u m I J)) * + (∏ i, mixedActiveBracket hp hg j S D i (s.modelDualNumerator u m I J)) = + ((-1 : ℂ) ^ S.card * D.modelRowPhase s hp hg (markedActiveExponent S j) u m) * + ∑ e : ι → Fin 3, + fixedCuspArrayWithPhase s.index u + (s.reflectionStaticPhase c0 hc0 + (Ideal.Quotient.mk _ (-(D.matrix (fun _ => 1) 1 1) * D.U)) + (s.modelDualNumerator u) u) m I J * + reflectedBranch (fun i => Ideal.span {p i}) hg (markedActiveExponent S j) e + (primaryGenerator I) (primaryGenerator J) := by + rw [mixedActiveBracket_product] + calc + _ = (-1 : ℂ) ^ S.card * (s.amplitude u m I J * + (star D.fixedFactor * ShortDraftCusp.A4BadPhase c0 hc0 + (D.matrix (fun _ => 1) 1 1) D.U (s.modelDualNumerator u m I J)) * + D.bracketProduct hp hg (markedActiveExponent S j) (s.modelDualNumerator u m I J)) := by ring + _ = _ := + (congrArg ((-1 : ℂ) ^ S.card * ·) + (D.model_coefficient s hp hc0 hg (markedActiveExponent S j) u m I J)).trans + (mul_assoc _ _ _).symm + +theorem marked_modelRowPhase_norm [∀ i, (Ideal.span {p i}).IsMaximal] + (D : ControlledStratumArithmetic p N a0 c0 mode) + (s : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode)) + (hN : (9 : Eis) * c0 ∣ N) (hr : λ₀ ^ 2 ∣ (∏ i, p i) - 1) + (hbase : if mode then λ₀ ^ 2 ∣ a0 - 1 else λ₀ ^ 2 ∣ c0 - 1) + (hp : ∀ i, p i ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (hchar : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (j : ι → ℕ) (hj : ∀ i, j i < 6) (S : Finset ι) (u : Eisˣ) (m : ℕ) : + ‖(-1 : ℂ) ^ S.card * D.modelRowPhase s hp hg (markedActiveExponent S j) u m‖ = 1 := by + have hj' : ∀ i, markedActiveExponent S j i < 6 := by + intro i + unfold markedActiveExponent + split_ifs + · norm_num + · exact hj i + rw [norm_mul, norm_pow, norm_neg, norm_one, one_pow, one_mul] + exact D.modelRowPhase_norm hN hr hbase s hp hg hchar _ hj' u m + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkedReflection.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedReflection.lean new file mode 100644 index 0000000000000000000000000000000000000000..2a541966ceb61e095bc874387e4cc41a801fcc9d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedReflection.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Descent.MarkedTwists + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open CompletedGauss CanonicalRowCompletion CubicEisenstein +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {ι : Type*} + +def markTwist (p : ι → Eis) (T : Finset ι) : Eis →* ℂ := + ∏ i ∈ T, coprimalityMask (p i) + +theorem markTwist_norm (p : ι → Eis) (T : Finset ι) (x : Eis) : ‖markTwist p T x‖ ≤ 1 := by + simp only [markTwist, MonoidHom.finsetProd_apply, norm_prod] + exact Finset.prod_le_one₀ (fun i hi => norm_nonneg _) (fun i hi => coprimalityMask_norm _ _) + +theorem markTwist_periodic (p : ι → Eis) (S T : Finset ι) (hTS : T ⊆ S) : + CanonicalCoefficientClass.FactorsModulo (Ideal.span {∏ i ∈ S, p i}) (markTwist p T) := by + intro x y hxy + simp only [markTwist, MonoidHom.finsetProd_apply] + apply Finset.prod_congr rfl + intro i hi + apply coprimalityMask_periodic (p i) x y + apply Ideal.mem_span_singleton.mpr + exact (Finset.dvd_prod_of_mem p (hTS hi)).trans (Ideal.mem_span_singleton.mp hxy) + +def markedThetaQuotient (p : ι → Eis) (S : Finset ι) (Ψ : Eis →* ℂ) (c : Eis) + (x : Eis ⧸ Ideal.span {c}) : ℂ := + fixedThetaQuotient Ψ c x * ∏ i ∈ S, if p i ∣ Quotient.out x then 1 else 0 + +theorem markedThetaQuotient_twists (p : ι → Eis) (S : Finset ι) + (hp : ∀ i ∈ S, Prime (p i)) (Ψ : Eis →* ℂ) (c : Eis) + (x : Eis ⧸ Ideal.span {c}) : + markedThetaQuotient p S Ψ c x = + ∑ T ∈ S.powerset, (-1 : ℂ) ^ T.card * fixedThetaQuotient (markTwist p T * Ψ) c x := by + have hmark (i : ι) (hi : i ∈ S) : + (if p i ∣ Quotient.out x then (1 : ℂ) else 0) = + 1 - coprimalityMask (p i) (Quotient.out x) := by + change (if p i ∣ Quotient.out x then (1 : ℂ) else 0) = + 1 - (if IsCoprime (p i) (Quotient.out x) then 1 else 0) + rw [(hp i hi).coprime_iff_not_dvd] + by_cases h : p i ∣ Quotient.out x <;> simp [h] + unfold markedThetaQuotient + rw [Finset.prod_congr rfl hmark, Finset.prod_sub] + simp only [Finset.prod_const_one, mul_one, Finset.mul_sum] + apply Finset.sum_congr rfl + intro T hT + rw [show markTwist p T * Ψ = Ψ * markTwist p T from mul_comm _ _] + simp only [fixedThetaQuotient, fixedThetaTwist_mul, markTwist, MonoidHom.finsetProd_apply] + ring + +theorem markedCompletedT_canonical_reflection (p : ι → Eis) (S : Finset ι) + (hp : ∀ i ∈ S, Prime (p i)) + (Ψ : Eis →* ℂ) (hΨ : ∀ x, ‖Ψ x‖ ≤ 1) + (Q : Ideal Eis) (hperiod : CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c : Eis) (hc : c ≠ 0) [Fintype (Eis ⧸ Ideal.span {c})] + (hcQ : Ideal.span {c} ≤ Ideal.span {(9 : Eis)} * (Q * Ideal.span {∏ i ∈ S, p i})) + (W : ℝ → ℂ) (hWcompact : HasCompactSupport W) + (v0 v1 : ℝ) (hv0 : 0 < v0) (hWs : Function.support W ⊆ Set.Icc v0 v1) + (hW : ContDiff ℝ ∞ W) (X : ℝ) (hX : 0 < X) : + markedCompletedT Ψ W X (fun A => ∏ i ∈ S, if Ideal.span {p i} ∣ A then 1 else 0) = + thetaDerivativeScalar⁻¹ * ∑ h : Eis ⧸ Ideal.span {c}, + finiteAdditiveFourierCoeff (quotientTrace c hc) (markedThetaQuotient p S Ψ c) h * + (finiteTwistCusp c hc h).smoothedKernel W X := by + have hnorm (T : Finset ι) : ∀ x, ‖(markTwist p T * Ψ) x‖ ≤ 1 := by + intro x + rw [MonoidHom.mul_apply, norm_mul] + exact (mul_le_mul_of_nonneg_right (markTwist_norm p T x) (norm_nonneg _)).trans + ((one_mul _).le.trans (hΨ x)) + have hper (T : Finset ι) (hT : T ∈ S.powerset) : + CanonicalCoefficientClass.FactorsModulo (Q * Ideal.span {∏ i ∈ S, p i}) + (markTwist p T * Ψ) := by + intro x y hxy + simp only [MonoidHom.mul_apply] + rw [markTwist_periodic p S T (Finset.mem_powerset.mp hT) x y (Ideal.mul_le_right hxy), + hperiod x y (Ideal.mul_le_left hxy)] + have hcoeff (h : Eis ⧸ Ideal.span {c}) : + finiteAdditiveFourierCoeff (quotientTrace c hc) (markedThetaQuotient p S Ψ c) h = + ∑ T ∈ S.powerset, (-1 : ℂ) ^ T.card * + finiteAdditiveFourierCoeff (quotientTrace c hc) + (fixedThetaQuotient (markTwist p T * Ψ) c) h := by + unfold finiteAdditiveFourierCoeff + simp_rw [markedThetaQuotient_twists p S hp Ψ c] + simp only [Finset.sum_mul] + rw [Finset.sum_comm] + simp only [Finset.sum_div, Finset.mul_sum, mul_div_assoc, mul_assoc] + rw [markedCompletedT_prime_product_twists S p hp Ψ W hWcompact X hX] + change (∑ T ∈ S.powerset, (-1 : ℂ) ^ T.card * completedT (markTwist p T * Ψ) W X) = _ + calc + _ = ∑ T ∈ S.powerset, (-1 : ℂ) ^ T.card * (thetaDerivativeScalar⁻¹ * + ∑ h : Eis ⧸ Ideal.span {c}, finiteAdditiveFourierCoeff (quotientTrace c hc) + (fixedThetaQuotient (markTwist p T * Ψ) c) h * + (finiteTwistCusp c hc h).smoothedKernel W X) := by + apply Finset.sum_congr rfl + intro T hT + rw [completedT_canonical_smoothed_reflection _ (hnorm T) _ (hper T hT) + c hc hcQ W v0 v1 hv0 hWs hW X hX] + _ = _ := by + simp_rw [hcoeff] + simp only [Finset.mul_sum, Finset.sum_mul] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro h hh + apply Finset.sum_congr rfl + intro T hT + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkedStratum.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedStratum.lean new file mode 100644 index 0000000000000000000000000000000000000000..82f6ff3f3b27e5d6f7ee2e9d61a428edd5963c59 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedStratum.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Descent.MarkedFourier + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CubicEisenstein LocalReflectionBrackets CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +section Local +variable {F : Type*} [Field F] [Fintype F] + +def markedFrequencyRow (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (σ ε : Fˣ) (x h : F) : ℂ := + finiteAdditiveFourierCoeff ψ zeroMark h * frequencyMultiplier χ ψ σ ε x h + +theorem markedFrequencyRow_zero (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (σ ε : Fˣ) (x : F) : + markedFrequencyRow χ ψ σ ε x 0 = (Fintype.card F : ℂ)⁻¹ := by + simp [markedFrequencyRow, frequencyMultiplier, finiteAdditiveFourierCoeff, zeroMark] + +theorem markedFrequencyRow_units (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (σ ε : Fˣ) (x : F) : + (∑ h : Fˣ, markedFrequencyRow χ ψ σ ε x h) = + localReflectionActive zeroMark χ ψ σ ε x := by + unfold markedFrequencyRow finiteAdditiveFourierCoeff frequencyMultiplier localReflectionActive localFourier + simp only [Units.ne_zero, ite_false, Units.val_inv_eq_inv_val, + Finset.mul_sum, neg_mul] + apply Finset.sum_congr rfl + intro h hh + ring + +def mixedFrequencyRow (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (marked : Bool) (j : ℕ) (σ ε : Fˣ) (x h : F) : ℂ := + if marked then markedFrequencyRow χ ψ σ ε x h else frequencyRow χ ψ j σ ε x h + +end Local + +noncomputable local instance markedStratumField (P : Ideal Eis) [P.IsMaximal] : Field (Eis ⧸ P) := + Ideal.Quotient.field P +noncomputable local instance markedStratumFintype (P : Ideal Eis) [P.IsMaximal] : Fintype (Eis ⧸ P) := + Fintype.ofFinite _ + +theorem actual_mixed_frequency_units (P : Ideal Eis) [P.IsMaximal] + (hg : ConcretePrimeRowBridge.goodLambda ∉ P) (hc : ringChar (Eis ⧸ P) ≠ 2) + (ψ : AddChar (Eis ⧸ P) ℂ) (hψ : ψ.IsPrimitive) (marked : Bool) + (j : ℕ) (hj : j < 6) (σ ε : (Eis ⧸ P)ˣ) (x : Eis ⧸ P) : + (∑ h : (Eis ⧸ P)ˣ, mixedFrequencyRow (actualSextic P hg) ψ marked j σ ε x h) = + if marked then + (rootCard (Eis ⧸ P) : ℂ)⁻¹ * tau (actualSextic P hg) ψ 2 * + (((actualSextic P hg) ^ 2)⁻¹) ((σ : Eis ⧸ P) * (ε : Eis ⧸ P) * x) + else (((actualSextic P hg)⁻¹) ^ 2) σ * + phase (actualSextic P hg) ψ j ε * bracket (actualSextic P hg) j x := by + cases marked + · simp only [mixedFrequencyRow, Bool.false_eq_true, ite_false] + exact canonical_frequencyRow_units P hg hc ψ hψ j hj σ ε x + · simp only [mixedFrequencyRow, ite_true] + rw [markedFrequencyRow_units, actual_marked_active_formula P hg hc ψ hψ σ ε x] + +theorem actual_mixed_frequency_zero (P : Ideal Eis) [P.IsMaximal] + (hg : ConcretePrimeRowBridge.goodLambda ∉ P) (hc : ringChar (Eis ⧸ P) ≠ 2) + (ψ : AddChar (Eis ⧸ P) ℂ) (marked : Bool) + (j : ℕ) (hj : j < 6) (σ ε : (Eis ⧸ P)ˣ) (x : Eis ⧸ P) : + mixedFrequencyRow (actualSextic P hg) ψ marked j σ ε x 0 = + if marked then (Fintype.card (Eis ⧸ P) : ℂ)⁻¹ + else if j = 0 then 1 - (Fintype.card (Eis ⧸ P) : ℂ)⁻¹ else 0 := by + cases marked + · simp only [mixedFrequencyRow, Bool.false_eq_true, ite_false] + exact canonical_frequencyRow_zero P hg hc ψ j hj σ ε x + · simp only [mixedFrequencyRow, ite_true] + exact markedFrequencyRow_zero _ _ _ _ _ + +theorem actual_mixed_active_stratum {ι : Type*} [Fintype ι] + (P : ι → Ideal Eis) [∀ i, (P i).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ P i) + (hc : ∀ i, ringChar (Eis ⧸ P i) ≠ 2) + (ψ : ∀ i, AddChar (Eis ⧸ P i) ℂ) (hψ : ∀ i, (ψ i).IsPrimitive) + (marked : ι → Bool) (j : ι → ℕ) (hj : ∀ i, j i < 6) + (A : Finset ι) (σ ε : ∀ i, (Eis ⧸ P i)ˣ) (x : ∀ i, Eis ⧸ P i) : + (∑ h ∈ FixedRayActiveSet.activeStratum (fun i => Eis ⧸ P i) A, + ∏ i, mixedFrequencyRow (actualSextic (P i) (hg i)) (ψ i) (marked i) (j i) + (σ i) (ε i) (x i) (h i)) = + (∏ i ∈ A, if marked i then + (rootCard (Eis ⧸ P i) : ℂ)⁻¹ * tau (actualSextic (P i) (hg i)) (ψ i) 2 * + (((actualSextic (P i) (hg i)) ^ 2)⁻¹) + ((σ i : Eis ⧸ P i) * (ε i : Eis ⧸ P i) * x i) + else (((actualSextic (P i) (hg i))⁻¹) ^ 2) (σ i) * + phase (actualSextic (P i) (hg i)) (ψ i) (j i) (ε i) * + bracket (actualSextic (P i) (hg i)) (j i) (x i)) * + (∏ i ∈ (Finset.univ : Finset ι) \ A, + if marked i then (Fintype.card (Eis ⧸ P i) : ℂ)⁻¹ + else if j i = 0 then 1 - (Fintype.card (Eis ⧸ P i) : ℂ)⁻¹ else 0) := by + rw [FixedRayActiveSet.sum_active_stratum] + congr 1 + · apply Finset.prod_congr rfl + intro i hi + exact actual_mixed_frequency_units (P i) (hg i) (hc i) (ψ i) (hψ i) + (marked i) (j i) (hj i) (σ i) (ε i) (x i) + · apply Finset.prod_congr rfl + intro i hi + exact actual_mixed_frequency_zero (P i) (hg i) (hc i) (ψ i) + (marked i) (j i) (hj i) (σ i) (ε i) (x i) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkedTails.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedTails.lean new file mode 100644 index 0000000000000000000000000000000000000000..5f4320bc9bebf3ee0e89aa6e16fe2ea3bb95028d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedTails.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Descent.MarkBounds +import OAI.NumberTheory.DirichletL.Descent.PoissonTails + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def markedColumn {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (A : Finset ι) (C : Finset ι → ℂ) (U : Finset ι) : ℂ := + primeMark slots lists a (A ∪ U) * C U + +lemma markedColumn_source_support {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (A : Finset ι) (C : Finset ι → ℂ) (U : Finset ι) + (h : markedColumn slots lists a A C U ≠ 0) : C U ≠ 0 := + (mul_ne_zero_iff.mp h).2 + +theorem markedColumn_uniform_bound (ε : ℝ) (hε : 0 < ε) : + ∃ Cm : ℝ, 0 < Cm ∧ ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (_hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (_hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i ∈ slots, ∀ k ∈ lists i, ‖a i k‖ ≤ 1) → + ∀ (A F : Finset ι) (C : Finset ι → ℂ) (G X M : ℝ), + 0 ≤ G → 0 < X → + (∀ U ∈ F.powerset, ‖C U‖ ≤ G) → + (∀ U ∈ F.powerset, C U ≠ 0 → columnLog p X U ≤ M) → + ∀ U ∈ F.powerset, ‖markedColumn slots lists a A C U‖ ≤ + (2:ℝ)^A.card * Cm * (X*Real.exp M)^ε * G := by + obtain ⟨Cm,hCm,hmark⟩ := finite_primeMark_extracted_bound ε hε + refine ⟨Cm,hCm,?_⟩ + intro ι σ _ _ p hp _ hcop slots lists a hslots ha A F C G X M hG hX hC hsupport U hU + by_cases hz : C U = 0 + · simp only [markedColumn,hz,mul_zero,norm_zero] + positivity + · have hn := columnLog_norm_upper p hp X M hX U (hsupport U hU hz) + rw [markedColumn,norm_mul] + have hm := hmark p hp hcop slots lists a hslots ha A U + have hnorm : 0 < primeProductNorm p U := primeProductNorm_pos p hp U + apply (mul_le_mul hm (hC U hU) (norm_nonneg _) (by positivity)).trans + gcongr + +theorem marked_first_kernel_remainder (ε : ℝ) (hε : 0 < ε) (order : ℕ) : + ∃ (s : Finset (ℕ×ℕ)) (Ct Cm : ℝ), 0 < Ct ∧ 0 < Cm ∧ + ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (F B A₁ A₂ : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool), Disjoint F B → + ∀ (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) + (a₁ a₂ : σ → ι → ℂ), + (slots₁ : Set σ).PairwiseDisjoint lists₁ → (slots₂ : Set σ).PairwiseDisjoint lists₂ → + (∀ i ∈ slots₁, ∀ k ∈ lists₁ i, ‖a₁ i k‖ ≤ 1) → + (∀ i ∈ slots₂, ∀ k ∈ lists₂ i, ‖a₂ i k‖ ≤ 1) → + ∀ (C₁ C₂ : Finset ι → ℂ) (W : 𝓢(ℝ,ℂ)) (G₁ G₂ X₁ X₂ K P M₁ M₂ : ℝ), + 0 ≤ G₁ → 0 ≤ G₂ → 0 < X₁ → 0 < X₂ → 0 < K → 0 ≤ P → + (∀ U ∈ F.powerset, ‖C₁ U‖ ≤ G₁) → (∀ U ∈ F.powerset, ‖C₂ U‖ ≤ G₂) → + (∀ U ∈ F.powerset, C₁ U ≠ 0 → columnLog p X₁ U ≤ M₁) → + (∀ U ∈ F.powerset, C₂ U ≠ 0 → columnLog p X₂ U ≤ M₂) → + ∀ d : Eis, d ≠ 0 → + let U₁ := X₁*Real.exp M₁ + let U₂ := X₂*Real.exp M₂ + let G₁' := (2:ℝ)^A₁.card * Cm * U₁^ε * G₁ + let G₂' := (2:ℝ)^A₂.card * Cm * U₂^ε * G₂ + let slow := K/(‖eisEmbedding d‖^2*primeProductNorm p (cubeActiveSupport B v ε₁ ε₂)*U₁*U₂) + let T := firstFrequencyDisk (canonicalFirstFrequencyRadius p B v ε₁ ε₂ d X₁ X₂ K P) + ‖∑' h : {h : Eis // h ∉ T}, actualFirstKernel p hp hcop hg F B v ε₁ ε₂ + (markedColumn slots₁ lists₁ a₁ A₁ C₁) (markedColumn slots₂ lists₂ a₂ A₂ C₂) + W (fun _ => 1) (fun _ => 1) X₁ X₂ K d h.val‖ ≤ + (128*U₁)*(128*U₂)*(G₁'*G₂'*K) * + ((Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / + ((min 1 slow)^2*(1+P/Real.exp (M₁+M₂))^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_uniform_actualFirstKernel_disk_remainder order + obtain ⟨Cm,hCm,hmark⟩ := markedColumn_uniform_bound ε hε + refine ⟨s,Ct,Cm,hCt,hCm,?_⟩ + intro ι σ _ _ p hp _ hinj hcop hg hc F B A₁ A₂ v ε₁ ε₂ hFB + slots₁ slots₂ lists₁ lists₂ a₁ a₂ hl₁ hl₂ ha₁ ha₂ C₁ C₂ W G₁ G₂ X₁ X₂ K P M₁ M₂ + hG₁ hG₂ hX₁ hX₂ hK hP hC₁ hC₂ hs₁ hs₂ d hd + apply htail p hp hinj hcop hg hc F B v ε₁ ε₂ hFB _ _ W _ _ X₁ X₂ K P M₁ M₂ + (by positivity) (by positivity) hX₁ hX₂ hK hP + · exact hmark p hp hcop slots₁ lists₁ a₁ hl₁ ha₁ A₁ F C₁ G₁ X₁ M₁ hG₁ hX₁ hC₁ hs₁ + · exact hmark p hp hcop slots₂ lists₂ a₂ hl₂ ha₂ A₂ F C₂ G₂ X₂ M₂ hG₂ hX₂ hC₂ hs₂ + · intro U hU hn + exact hs₁ U hU (markedColumn_source_support _ _ _ _ _ _ hn) + · intro U hU hn + exact hs₂ U hU (markedColumn_source_support _ _ _ _ _ _ hn) + · exact hd + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MarkedTwists.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedTwists.lean new file mode 100644 index 0000000000000000000000000000000000000000..7638184dfca89a2313f858400aa040d3f89802cf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MarkedTwists.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Descent.MarkedFourier + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss CanonicalRowCompletion +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem markedCompletedT_monoid (Ψ φ : Eis →* ℂ) (W : ℝ → ℂ) (X : ℝ) : + markedCompletedT Ψ W X (fun A => φ (primaryGenerator A)) = completedT (φ * Ψ) W X := by + unfold markedCompletedT completedT + apply tsum_congr + intro I + apply tsum_congr + intro J + change summand Ψ W X I J * φ (primaryGenerator (I * J ^ 3)) = _ + rw [summand_mul_fixed_twist, primaryGenerator_mul, + show primaryGenerator (J ^ 3) = primaryGenerator J ^ 3 from map_pow primaryGeneratorHom J 3] + exact mul_comm _ _ + +theorem whole_prime_mark_eq_mask_complement (p : Eis) (hp : Prime p) + (A : Ideal Eis) (hA : primaryGenerator A ≠ 0) : + (if Ideal.span {p} ∣ A then (1 : ℂ) else 0) = + 1 - coprimalityMask p (primaryGenerator A) := by + have hd : Ideal.span {p} ∣ A ↔ p ∣ primaryGenerator A := by + calc + _ ↔ A ≤ Ideal.span {p} := Ideal.dvd_iff_le + _ ↔ Ideal.span {primaryGenerator A} ≤ Ideal.span {p} := by + rw [(primaryGenerator_spec A hA).1] + _ ↔ _ := by rw [Ideal.span_singleton_le_iff_mem, Ideal.mem_span_singleton] + change (if Ideal.span {p} ∣ A then (1 : ℂ) else 0) = + 1 - (if IsCoprime p (primaryGenerator A) then 1 else 0) + rw [hp.coprime_iff_not_dvd] + by_cases h : p ∣ primaryGenerator A <;> simp [hd, h] + +theorem markedCompletedT_prime_product_twists {ι : Type*} + (S : Finset ι) (p : ι → Eis) (hp : ∀ i ∈ S, Prime (p i)) + (Ψ : Eis →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) : + markedCompletedT Ψ W X + (fun A => ∏ i ∈ S, if Ideal.span {p i} ∣ A then 1 else 0) = + ∑ T ∈ S.powerset, (-1 : ℂ) ^ T.card * + completedT ((∏ i ∈ T, coprimalityMask (p i)) * Ψ) W X := by + have he : markedCompletedT Ψ W X + (fun A => ∏ i ∈ S, if Ideal.span {p i} ∣ A then 1 else 0) = + markedCompletedT Ψ W X (fun A => + ∑ T ∈ S.powerset, (-1 : ℂ) ^ T.card * + (∏ i ∈ T, coprimalityMask (p i)) (primaryGenerator A)) := by + apply markedCompletedT_congr_primary + intro A hA + calc + _ = ∏ i ∈ S, (1 - coprimalityMask (p i) (primaryGenerator A)) := by + apply Finset.prod_congr rfl + intro i hi + exact whole_prime_mark_eq_mask_complement (p i) (hp i hi) A hA + _ = _ := by + rw [Finset.prod_sub] + simp + rw [he, markedCompletedT_finset_sum S.powerset Ψ W hW X hX] + apply Finset.sum_congr rfl + intro T hT + rw [markedCompletedT_const_mul, markedCompletedT_monoid] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Marks.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Marks.lean new file mode 100644 index 0000000000000000000000000000000000000000..cdc2a3d0e2fe41ea544ff0241b3d66b78464ca0c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Marks.lean @@ -0,0 +1,108 @@ +import Mathlib.Analysis.Complex.Basic +import Mathlib.Algebra.BigOperators.Ring.Finset +import Mathlib.Tactic.NormNum + +namespace OAI + +namespace SevenEighths.InverseMoment + +open scoped BigOperators + +noncomputable section + +variable {σ ι : Type*} [DecidableEq σ] [DecidableEq ι] + +def primeSlot (L : Finset ι) (a : ι → ℂ) (A : Finset ι) : ℂ := + ∑ p ∈ L, if p ∈ A then a p else 0 + +def primeMark (I : Finset σ) (L : σ → Finset ι) (a : σ → ι → ℂ) + (A : Finset ι) : ℂ := ∏ i ∈ I, primeSlot (L i) (a i) A + +omit [DecidableEq σ] in +@[simp] theorem primeMark_empty (L : σ → Finset ι) (a : σ → ι → ℂ) + (A : Finset ι) : primeMark ∅ L a A = 1 := by + simp [primeMark] + +theorem primeMark_eq_tuple_sum (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A : Finset ι) : + primeMark I L a A = ∑ p ∈ I.pi L, + ∏ i ∈ I.attach, if p i.1 i.2 ∈ A then a i.1 (p i.1 i.2) else 0 := by + exact Finset.prod_sum I L (fun i p => if p ∈ A then a i p else 0) + +theorem primeSlot_priority (L A B : Finset ι) (a : ι → ℂ) : + primeSlot L a (A ∪ B) = primeSlot L a A + primeSlot L a (B \ A) := by + unfold primeSlot + rw [← Finset.sum_add_distrib] + apply Finset.sum_congr rfl + intro p hp + by_cases hA : p ∈ A <;> by_cases hB : p ∈ B <;> simp [hA, hB] + +theorem primeMark_priority (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A B : Finset ι) : + primeMark I L a (A ∪ B) = + ∑ J ∈ I.powerset, primeMark J L a A * primeMark (I \ J) L a (B \ A) := by + unfold primeMark + simp_rw [primeSlot_priority] + exact Finset.prod_add _ _ I + +theorem primeSlot_residual_list (L A B : Finset ι) (a : ι → ℂ) : + primeSlot L a (B \ A) = primeSlot (L \ A) a B := by + simp only [primeSlot, Finset.sum_ite_mem] + congr 1 + ext p + simp only [Finset.mem_inter, Finset.mem_sdiff] + tauto + +omit [DecidableEq σ] in +theorem primeMark_residual_lists (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A B : Finset ι) : + primeMark I L a (B \ A) = primeMark I (fun i => L i \ A) a B := by + unfold primeMark + apply Finset.prod_congr rfl + intro i hi + exact primeSlot_residual_list _ _ _ _ + +theorem primeSlot_norm_le (L A : Finset ι) (a : ι → ℂ) + (ha : ∀ p ∈ L, ‖a p‖ ≤ 1) : + ‖primeSlot L a A‖ ≤ ((L ∩ A).card : ℝ) := by + simp only [primeSlot, Finset.sum_ite_mem] + apply (norm_sum_le _ _).trans + calc + ∑ p ∈ L ∩ A, ‖a p‖ ≤ ∑ p ∈ L ∩ A, (1 : ℝ) := + Finset.sum_le_sum fun p hp => ha p (Finset.mem_inter.mp hp).1 + _ = _ := by simp + +omit [DecidableEq σ] in +theorem primeMark_norm_le_divisor_count (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A : Finset ι) + (hL : (I : Set σ).PairwiseDisjoint L) + (ha : ∀ i ∈ I, ∀ p ∈ L i, ‖a i p‖ ≤ 1) : + ‖primeMark I L a A‖ ≤ (2 : ℝ) ^ A.card := by + have hdis : (I : Set σ).PairwiseDisjoint (fun i => L i ∩ A) := by + intro i hi j hj hij + exact (hL hi hj hij).mono (Finset.inter_subset_left) (Finset.inter_subset_left) + have hcard : (∑ i ∈ I, (L i ∩ A).card) ≤ A.card := by + rw [← Finset.card_biUnion hdis] + apply Finset.card_le_card + intro p hp + obtain ⟨i, hi, hp⟩ := Finset.mem_biUnion.mp hp + exact (Finset.mem_inter.mp hp).2 + calc + ‖primeMark I L a A‖ = ∏ i ∈ I, ‖primeSlot (L i) (a i) A‖ := by + exact norm_prod _ _ + _ ≤ ∏ i ∈ I, ((L i ∩ A).card : ℝ) := by + exact Finset.prod_le_prod₀ (fun i _ => norm_nonneg _) + (fun i hi => primeSlot_norm_le _ _ _ (ha i hi)) + _ ≤ ∏ i ∈ I, (2 : ℝ) ^ (L i ∩ A).card := by + apply Finset.prod_le_prod₀ (fun i _ => Nat.cast_nonneg _) + intro i hi + exact_mod_cast (Nat.le_of_lt (L i ∩ A).card.lt_two_pow_self) + _ = (2 : ℝ) ^ (∑ i ∈ I, (L i ∩ A).card) := + Finset.prod_pow_eq_pow_sum _ _ _ + _ ≤ (2 : ℝ) ^ A.card := pow_le_pow_right₀ (by norm_num) hcard + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MaskedGrid.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MaskedGrid.lean new file mode 100644 index 0000000000000000000000000000000000000000..a44f53862aeb9d92671ac44d7fcfa5d5292b43ad --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MaskedGrid.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Descent.ExtractedGrid + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss IdealMobiusDivisorSum UniqueFactorizationMonoid +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local notation "Grid" => Finset ((Ideal Eis × Ideal Eis) × Ideal Eis) + +def maskedGridHybridRow (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (t k : Ideal Eis) : ℂ := + ∑ u ∈ T, ∑ P ∈ Pset, (if IsCoprime k (P * u.2) then 1 else 0) * + (a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * beta u.2 u.1.1 u.1.2 * + (quadraticRow k (primaryGenerator (u.1.1 * u.1.2)) * inverseCubicKernel P (u.2 * u.1.1)) * + (if IsCoprime P (u.1.2 * t) then 1 else 0)) + +theorem maskedGridHybridRow_mobius (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (t k : Ideal Eis) (hk : k ≠ 0) : + maskedGridHybridRow T Pset a beta t k = + ∑ D ∈ (idealDivisors k) ×ˢ (idealDivisors k), + ((moebius D.1 : ℂ) * (moebius D.2 : ℂ)) * + gridDivisorHybridBlock T Pset a beta t k D.1 D.2 := by + have hm (P c : Ideal Eis) : + (if IsCoprime k (P * c) then (1 : ℂ) else 0) = + ∑ D ∈ (idealDivisors k) ×ˢ (idealDivisors k), + if D.1 ∣ P ∧ D.2 ∣ c then (moebius D.1 : ℂ) * (moebius D.2 : ℂ) else 0 := by + rw [hybrid_double_mask_mobius k P c hk, Finset.sum_product] + unfold maskedGridHybridRow + simp_rw [hm, Finset.sum_mul] + conv_lhs => + arg 2 + ext u + rw [Finset.sum_comm] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro D hD + unfold gridDivisorHybridBlock + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro u hu + by_cases hrc : D.2 ∣ u.2 + · simp only [hrc, ite_true, and_true, Finset.mul_sum] + apply Finset.sum_congr rfl + intro P hP + by_cases hRP : D.1 ∣ P <;> simp [hRP] + · simp [hrc] + +theorem gridDivisorHybridBlock_zero_of_not_coprime + (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) + (t k R r : Ideal Eis) (hRr : ¬ IsCoprime R r) + (hP : ∀ P ∈ Pset, primaryGenerator P ≠ 0) + (hT : ∀ u ∈ T, primaryGenerator (u.2 * u.1.1) ≠ 0) : + gridDivisorHybridBlock T Pset a beta t k R r = 0 := by + unfold gridDivisorHybridBlock + apply Finset.sum_eq_zero + intro u hu + by_cases hrc : r ∣ u.2 + · simp only [hrc, ite_true] + apply Finset.sum_eq_zero + intro P hPP + by_cases hRP : R ∣ P + · simp only [hRP, ite_true] + rw [inverseCubicKernel_divisor_overlap_zero R r P u.2 u.1.1 + (hP P hPP) (hT u hu) hRP hrc hRr] + simp + · simp only [hRP, ite_false] + · simp only [hrc, ite_false] + +theorem maskedGridHybridRow_divisor_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K : ℝ, 1 ≤ K → + ∀ (rows : Finset (Ideal Eis)) (T : Grid) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ) (t : Ideal Eis), + (∀ k ∈ rows, k ≠ 0 ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∑ k ∈ rows, ‖maskedGridHybridRow T Pset a beta t k‖ ^ 2) ≤ + C * K ^ ε * + ∑ D ∈ rows.biUnion (fun k => (idealDivisors k) ×ˢ (idealDivisors k)), + ∑ k ∈ rows, if D ∈ (idealDivisors k) ×ˢ (idealDivisors k) then + ‖gridDivisorHybridBlock T Pset a beta t k D.1 D.2‖ ^ 2 else 0 := by + obtain ⟨C, hC, hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power (ε / 2) (by positivity) + refine ⟨C ^ 2, pow_pos hC 2, ?_⟩ + intro K hK rows T Pset a beta t hrows + have he (k : Ideal Eis) (hk : k ∈ rows) := + maskedGridHybridRow_mobius T Pset a beta t k (hrows k hk).1 + simp_rw [Finset.sum_congr rfl (fun k hk => congrArg (fun z : ℂ => ‖z‖ ^ 2) (he k hk))] + apply finite_expansion_energy rows + (rows.biUnion (fun k => (idealDivisors k) ×ˢ (idealDivisors k))) + (fun k => (idealDivisors k) ×ˢ (idealDivisors k)) + (fun _ D => (moebius D.1 : ℂ) * (moebius D.2 : ℂ)) + (fun k D => gridDivisorHybridBlock T Pset a beta t k D.1 D.2) (C ^ 2 * K ^ ε) + · intro k hk D hD + exact Finset.mem_biUnion.mpr ⟨k, hk, hD⟩ + · intro k hk D hD + rw [norm_mul] + calc + _ ≤ 1 * 1 := mul_le_mul + (QuadraticInitialBound.norm_ideal_moebius_le_one D.1) + (QuadraticInitialBound.norm_ideal_moebius_le_one D.2) (norm_nonneg _) (by norm_num) + _ = 1 := by norm_num + · intro k hk + have hd := (hdiv k (hrows k hk).1).trans + (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow (Nat.cast_nonneg _) (hrows k hk).2 (by positivity)) hC.le) + calc + _ = ((idealDivisors k).card : ℝ) ^ 2 := by simp [Finset.card_product, pow_two] + _ ≤ (C * K ^ (ε / 2)) ^ 2 := pow_le_pow_left₀ (Nat.cast_nonneg _) hd 2 + _ = C ^ 2 * K ^ ε := by + rw [mul_pow, pow_two (K ^ (ε / 2)), ← Real.rpow_add (by linarith : 0 < K)] + congr 1 + congr 1 + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/MixedRow.lean b/lean/OAI/NumberTheory/DirichletL/Descent/MixedRow.lean new file mode 100644 index 0000000000000000000000000000000000000000..4252f46b472990d6fb67040c289fcb6f5aa6e59e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/MixedRow.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Descent.ActiveCusp + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss CanonicalRowCompletion CubicEisenstein +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +noncomputable local instance mixedQuotientFintype (P : Ideal Eis) [P.IsMaximal] : + Fintype (Eis ⧸ P) := Fintype.ofFinite _ +variable {ι : Type*} [Fintype ι] + +def unmarkedSexticTwist (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (j : ι → ℕ) (S : Finset ι) : Eis →* ℂ where + toFun n := ∏ i ∈ (Finset.univ : Finset ι) \ S, + (actualSextic (Ideal.span {p i}) (hg i) ^ j i) (Ideal.Quotient.mk _ n) + map_one' := by simp + map_mul' x y := by simp only [map_mul, Finset.prod_mul_distrib] + +def mixedPrimeFunction (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (j : ι → ℕ) (S : Finset ι) + (i : ι) (x : Eis ⧸ Ideal.span {p i}) : ℂ := + if i ∈ S then zeroMark x else (actualSextic (Ideal.span {p i}) (hg i) ^ j i) x + +theorem unmarkedSexticTwist_norm (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (j : ι → ℕ) (S : Finset ι) (n : Eis) : + ‖unmarkedSexticTwist p hg j S n‖ ≤ 1 := by + change ‖∏ i ∈ (Finset.univ : Finset ι) \ S, + (actualSextic (Ideal.span {p i}) (hg i) ^ j i) (Ideal.Quotient.mk _ n)‖ ≤ 1 + rw [norm_prod] + exact Finset.prod_le_one₀ (fun i hi => norm_nonneg _) + (fun i hi => FiniteRayExpansion.norm_char_le_one _ _) + +theorem unmarkedSexticTwist_periodic (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (j : ι → ℕ) (S : Finset ι) : + CanonicalCoefficientClass.FactorsModulo (Ideal.span {∏ i, p i}) (unmarkedSexticTwist p hg j S) := by + intro x y hxy + change (∏ i ∈ (Finset.univ : Finset ι) \ S, _) = ∏ i ∈ (Finset.univ : Finset ι) \ S, _ + apply Finset.prod_congr rfl + intro i hi + have he : Ideal.Quotient.mk (Ideal.span {p i}) x = Ideal.Quotient.mk _ y := by + apply Ideal.Quotient.eq.mpr + apply Ideal.mem_span_singleton.mpr + exact (Finset.dvd_prod_of_mem p (Finset.mem_univ i)).trans (Ideal.mem_span_singleton.mp hxy) + rw [he] + +theorem mixedPrimeFunction_product (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (j : ι → ℕ) (S : Finset ι) (n : Eis) : + (∏ i, mixedPrimeFunction p hg j S i (Ideal.Quotient.mk _ n)) = + unmarkedSexticTwist p hg j S n * ∏ i ∈ S, if p i ∣ n then 1 else 0 := by + rw [← Finset.prod_sdiff (Finset.subset_univ S)] + have hS : (∏ i ∈ S, mixedPrimeFunction p hg j S i (Ideal.Quotient.mk _ n)) = + ∏ i ∈ S, if p i ∣ n then (1 : ℂ) else 0 := by + apply Finset.prod_congr rfl + intro i hi + simp only [mixedPrimeFunction, hi, ite_true, zeroMark, + Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton] + rw [hS] + congr 1 + apply Finset.prod_congr rfl + intro i hi + simp only [mixedPrimeFunction, (Finset.mem_sdiff.mp hi).2, ite_false] + +omit [Fintype ι] in +theorem markedThetaQuotient_mk (p : ι → Eis) (S : Finset ι) + (Ψ : Eis →* ℂ) (Q : Ideal Eis) (hΨ : CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c : Eis) (hcQ : Ideal.span {c} ≤ Ideal.span {(9 : Eis)} * (Q * Ideal.span {∏ i ∈ S, p i})) + (n : Eis) : + markedThetaQuotient p S Ψ c (Ideal.Quotient.mk _ n) = + fixedThetaTwist Ψ n * ∏ i ∈ S, if p i ∣ n then 1 else 0 := by + unfold markedThetaQuotient + have hcbase : Ideal.span {c} ≤ Ideal.span {(9 : Eis)} * Q := + hcQ.trans (Ideal.mul_mono_right Ideal.mul_le_left) + rw [fixedThetaQuotient_mk Ψ Q hΨ c hcbase] + congr 1 + apply Finset.prod_congr rfl + intro i hi + have hxy : Quotient.out (Ideal.Quotient.mk (Ideal.span {c}) n) - n ∈ Ideal.span {c} := + Ideal.Quotient.eq.mp (Ideal.Quotient.mk_out (Ideal.Quotient.mk (Ideal.span {c}) n)) + have hp : p i ∣ Quotient.out (Ideal.Quotient.mk (Ideal.span {c}) n) - n := + (Finset.dvd_prod_of_mem p hi).trans (Ideal.mem_span_singleton.mp + (Ideal.mul_le_right (Ideal.mul_le_right (hcQ hxy)))) + simp only [dvd_iff_dvd_of_dvd_sub hp] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/OriginalBlock.lean b/lean/OAI/NumberTheory/DirichletL/Descent/OriginalBlock.lean new file mode 100644 index 0000000000000000000000000000000000000000..bdb123a6f510d2a388f6b0fdf64a475a473d17f7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/OriginalBlock.lean @@ -0,0 +1,106 @@ +import OAI.NumberTheory.DirichletL.Descent.HybridReduction +import OAI.NumberTheory.DirichletL.Descent.Quotients + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem hybrid_original_quotient_block (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X N L A H : ℝ, + 1 ≤ K → 1 ≤ X → 1 ≤ N → 1 ≤ A → 1 ≤ H → + ∀ (R r t : Ideal Eis), R ≠ 0 → r ≠ 0 → + ∀ (rows nset Pset : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)) + (cset : Ideal Eis → Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ + L ≤ (Ideal.absNorm P : ℝ) ∧ (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → + (∀ p ∈ pairs, Squarefree (p.1 * p.2) ∧ + (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + (∀ p ∈ pairs, p.2 ≠ 0 ∧ (Ideal.absNorm p.2 : ℝ) ≤ H) → + (∀ p ∈ pairs, ∀ c ∈ cset p.1, + c ≠ 0 ∧ (Ideal.absNorm c : ℝ) ≤ A ∧ (r * c) * p.1 ∈ nset) → + (∀ p ∈ pairs, ∀ c ∈ cset p.1, ‖beta (r * c) p.1 p.2‖ ≤ 1) → + (∑ k ∈ quotientSupport (R * r) rows, + ‖(Real.sqrt (Ideal.absNorm R : ℝ) : ℂ)⁻¹ * + (∑ p ∈ pairs, quadraticRow k (primaryGenerator (p.1 * p.2)) * + (∑ c ∈ cset p.1, hybridColumnCoefficient R r beta c p.1 p.2 * + (∑ P ∈ quotientSupport R Pset, + hybridCubicCoefficient R r p.2 t a P * inverseCubicKernel P (c * p.1))))‖ ^ 2) ≤ + C * (K * X * N) ^ ε * (K + X) * A * H / + (Ideal.absNorm R : ℝ) * CubicSieve.sieveNorm N (2 * L) := by + obtain ⟨C, hC, hblock⟩ := hybrid_fixed_block_sieve_norm ε hε + refine ⟨C * (128 * 128 * 256), by positivity, ?_⟩ + intro K X N L A H hK hX hN hA hH R r t hR hr rows nset Pset pairs cset a beta + hrows hn hP ha hpairs hhs hcs hbeta + let Hset := pairs.image Prod.snd + let mc := (pairs.image Prod.fst).biUnion fun m => (cset m).image fun c => (m, c) + have hRr : R * r ≠ 0 := mul_ne_zero hR hr + have hn0 : ∀ n ∈ nset, n ≠ 0 := fun n hn' => (hn n hn').1.1.ne_zero + have hP0 : ∀ P ∈ Pset, P ≠ 0 := fun P hP' => (hP P hP').1.1.ne_zero + have hHcount : (Hset.card : ℝ) ≤ 128 * H := by + apply DescentFiberCost.finite_ideal_count_real Hset H hH + · intro h hh + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hh + exact (hhs p hp).1 + · intro h hh + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hh + exact (hhs p hp).2 + have hcCount : ∀ p ∈ pairs, ((cset p.1).card : ℝ) ≤ 128 * A := by + intro p hp + exact DescentFiberCost.finite_ideal_count_real (cset p.1) A hA + (fun c hc => (hcs p hp c hc).1) (fun c hc => (hcs p hp c hc).2.1) + have hmc : ∀ p ∈ pairs, ∀ c ∈ cset p.1, (p.1, c) ∈ mc := by + intro p hp c hc + exact Finset.mem_biUnion.mpr ⟨p.1, Finset.mem_image.mpr ⟨p, hp, rfl⟩, + Finset.mem_image.mpr ⟨c, hc, rfl⟩⟩ + have hmap : ∀ u ∈ mc, u.2 * (1 * u.1) ∈ quotientSupport r nset := by + intro u hu + obtain ⟨m, hm, cu⟩ := Finset.mem_biUnion.mp hu + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hm + obtain ⟨c, hc, rfl⟩ := Finset.mem_image.mp cu + apply (mem_quotientSupport r (c * (1 * p.1)) hr nset).mpr + simpa only [one_mul, mul_assoc] using (hcs p hp c hc).2.2 + have he := hblock K X N (2 * L) hK hX hN + (quotientSupport (R * r) rows) pairs mc Hset (quotientSupport r nset) + (quotientSupport R Pset) + (fun k hk => ⟨quotientSupport_quadratic_admissible (R * r) hRr rows + (fun k hk => (hrows k hk).1) k hk, + quotientSupport_norm_le (R * r) hRr rows K + (fun k hk => (hrows k hk).1.1) (fun k hk => (hrows k hk).2) k hk⟩) + hpairs 1 1 cset (fun h => hybridCubicCoefficient R r h t a) + (hybridColumnCoefficient R r beta) (128 * A) 256 (by positivity) hcCount + (fun p hp c hc => hybridColumnCoefficient_norm_le_one R r c p.1 p.2 beta (hbeta p hp c hc)) + (fun p hp => Finset.mem_image.mpr ⟨p, hp, rfl⟩) hmc hmap + (fun J hJ => ⟨quotientSupport_cubic_admissible r hr nset (fun n hn' => (hn n hn').1) J hJ, + quotientSupport_norm_le r hr nset N hn0 (fun n hn' => (hn n hn').2) J hJ⟩) + (fun P hP' => ⟨quotientSupport_cubic_admissible R hR Pset (fun P hP' => (hP P hP').1) P hP', + quotientSupport_norm_le R hR Pset (2 * L) hP0 (fun P hP' => (hP P hP').2.2) P hP'⟩) + (fun h _ => quotient_hybridCubicCoefficient_energy R r h t hR Pset L hP0 + (fun P hP' => (hP P hP').2) a ha) + simp only [one_mul] at he + have hsqrt : ‖(Real.sqrt (Ideal.absNorm R : ℝ) : ℂ)⁻¹‖ ^ 2 = + (Ideal.absNorm R : ℝ)⁻¹ := by + rw [norm_inv, inv_pow, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (Real.sqrt_nonneg _), Real.sq_sqrt (Nat.cast_nonneg _)] + simp_rw [norm_mul, mul_pow, hsqrt] + rw [← Finset.mul_sum] + apply (mul_le_mul_of_nonneg_left he (inv_nonneg.mpr (Nat.cast_nonneg _))).trans + calc + _ ≤ (Ideal.absNorm R : ℝ)⁻¹ * + (C * (K * X * N) ^ ε * (K + X) * (128 * A) * (128 * H) * + CubicSieve.sieveNorm N (2 * L) * 256) := by + gcongr + exact sq_nonneg _ + _ = _ := by ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/OriginalCellPriority.lean b/lean/OAI/NumberTheory/DirichletL/Descent/OriginalCellPriority.lean new file mode 100644 index 0000000000000000000000000000000000000000..5c7e83bb0b4c8f6306fb6872047ced5b7d225ad8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/OriginalCellPriority.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Descent.GlobalCanonicalEnergy +import OAI.NumberTheory.DirichletL.Inversion.FirstGlobalCaps + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FirstCauchyArithmetic +open InverseFirstPriorityParents InverseFirstGlobalParents +local notation "O"=>ActualEisensteinCubic.O +variable {ι σ:Type}[DecidableEq ι][DecidableEq σ] + +def originalSubsetSource (outer:Finset (FirstOriginalOuter ι)):Finset (Source ι 0):= + outer.image ofOriginal + +theorem original_subset_canonical_priority + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (outer:Finset (FirstOriginalOuter ι))(pool:Finset ι) + (selector:FirstOriginalOuter ι→Finset ι→ℂ)(extra:CubeCoordinates ι→Finset ι) + (negative:Bool)(Ψ:O→*ℂ)(m:O)(slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ) + (om:ℝ→ℂ)(X t Y:ℝ)(hY:0Ideal.span {p i}) k.2.2) + (fun U=>primeMark slots lists a (extra k.1∪U)) (selector k) om X t Y) ≤ + globalPriorityOriginalEnergy p hg hp hinj extra pool + (globalParentSource (originalSubsetSource outer) pool (originalSelector selector)) + (fun x=>(‖selector (toOriginal x) x.quotientSupport‖:ℂ)) + negative Ψ m slots lists a om X t Y:=by + have hempty:∀x∈originalSubsetSource outer,x.quotientSupport=∅:=by + intro x hx + obtain ⟨k,hk,rfl⟩:=Finset.mem_image.mp hx + rfl + have he:=global_canonical_to_original_priority p hp hg hinj hc + (originalSubsetSource outer) pool (originalSelector selector) hempty extra + negative Ψ m slots lists a om X t Y hY + rw [show originalSubsetSource outer=outer.image ofOriginal from rfl, + Finset.sum_image (fun _ _ _ _ h=>ofOriginal_injective h)] at he + have hs (k:FirstOriginalOuter ι): originalSelector selector (ofOriginal k)=selector k := + originalSelector_ofOriginal_fun selector k + simp_rw [hs] at he + simpa only [originalSubsetSource,ofOriginal,originalSelector,toOriginal,eraseFirstQuotient] using he + +theorem original_cell_parent_source + (p:ι→O)(pool:Finset ι)(Q:Finset (ι→₀ℕ)) + (selector:FirstOriginalOuter ι→Finset ι→ℂ) + (k:InverseMomentFirstChildWindows.SourceIndex)(l:ℕ): + globalParentSource (originalSubsetSource (InverseFirstGlobalCaps.outerCell p pool Q k)) + pool (originalSelector (fun x=>InverseMomentFirstChildWindows.commonSelector p (selector x) l))= + InverseFirstGlobalCaps.parentCell p pool Q selector k l:=by + ext x + rw [InverseFirstGlobalCaps.mem_parentCell] + simp only [globalParentSource,Finset.mem_biUnion,originalSubsetSource,Finset.mem_image, + Finset.mem_filter] + constructor + · rintro ⟨y,⟨o,ho,rfl⟩,D,⟨hD,hs⟩,he⟩ + exact ⟨o,ho,D,hD,by simpa using hs,he⟩ + · rintro ⟨o,ho,D,hD,hs,he⟩ + exact ⟨ofOriginal o,⟨o,ho,rfl⟩,D,⟨hD,by simpa using hs⟩,he⟩ + +theorem original_cell_canonical_priority + (p:ι→O)(hp:∀i,p i≠0)[∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(selector:FirstOriginalOuter ι→Finset ι→ℂ) + (k:InverseMomentFirstChildWindows.SourceIndex)(l:ℕ) + (extra:CubeCoordinates ι→Finset ι)(negative:Bool)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(om:ℝ→ℂ)(X t Y:ℝ)(hY:0Ideal.span {p i}) o.2.2) + (fun U=>primeMark slots lists a (extra o.1∪U)) + (InverseMomentFirstChildWindows.commonSelector p (selector o) l) om X t Y)≤ + globalPriorityOriginalEnergy p hg hp hinj extra pool + (InverseFirstGlobalCaps.parentCell p pool Q selector k l) + (fun x=>(‖InverseMomentFirstChildWindows.commonSelector p (selector (toOriginal x)) l x.quotientSupport‖:ℂ)) + negative Ψ m slots lists a om X t Y:=by + have he:=original_subset_canonical_priority p hp hg hinj hc + (InverseFirstGlobalCaps.outerCell p pool Q k) pool + (fun x=>InverseMomentFirstChildWindows.commonSelector p (selector x) l) extra negative Ψ m slots lists a om X t Y hY + rwa [original_cell_parent_source] at he + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/OriginalZeroPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/OriginalZeroPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..ef42aaf66ea362112492a2d0eb03b1a5da552995 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/OriginalZeroPhysical.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedZeroEnergy +import OAI.NumberTheory.DirichletL.Descent.PhysicalExponents + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +local notation "O"=>ActualEisensteinCubic.O + +theorem original_first_zero_physical (ε:ℝ)(hε:0<ε): + ∃C:ℝ,0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι)(Q:Finset (ι→₀ℕ))(labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ)(Ψ:O→*ℂ)(m:O) + (slots:Finset σ)(lists:σ→Finset ι)(a:σ→ι→ℂ)(W:ℝ→ℂ)(Φ:𝓢(ℝ,ℂ)) + (Z M r ell V eta Γ G:ℝ),1 + canonicalCubeDualZero p hp hcop hg pool b C Ψ Ψ m m (ConcretePrimeRowBridge.idealGenerator I) + (fun U=>primeMark slots lists a (U∪b.rightExponent.support)*W (primeProductNorm p U)) + (fun U=>primeMark slots lists a (U∪b.leftExponent.support)*W (primeProductNorm p U)) Φ (Z^M))‖≤ + C*Γ^2*G^2*‖paperRadialFourier Φ 0‖*Z^(M-ell+3*eta+ε*(5*ell+2*r+7*eta)):=by + obtain ⟨C,hC,he⟩:=original_reopened_marked_zero_bound ε hε + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg hinj hc pool Q labels β Ψ m slots lists a W Φ Z M r ell V eta Γ G + hZ hell hV hΓ hG hΨ hQ hn hlabels hβ hslots ha hW hs + have hz:0 rw [h] <;> norm_num + +theorem inverse_square_cube_mask {M : Type*} [Monoid M] + (ψ : M →* ℂ) (n b : M) (h : ψ b ^ 6 = 0 ∨ ψ b ^ 6 = 1) : + (ψ (n * b ^ 3))⁻¹ ^ 2 = (ψ n)⁻¹ ^ 2 * ψ b ^ 6 := by + rw [map_mul, map_pow, mul_inv_rev, mul_pow, inverse_cube_square_eq_sixth h] + ring + +theorem overlap_scalar_norm_le {z : ℂ} (hz : ‖z‖ ≤ 1) : ‖z ^ 2‖ ≤ 1 := by + rw [norm_pow] + simpa using pow_le_pow_left₀ (norm_nonneg z) hz 2 + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PhysicalBlockBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PhysicalBlockBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..2c6613bf77ec731c2e446b68f80fb917a160e154 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PhysicalBlockBudget.lean @@ -0,0 +1,62 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingMass +import OAI.NumberTheory.DirichletL.Descent.PhysicalExponents + +namespace OAI + +noncomputable section + +namespace SevenEighths.InverseMoment + +theorem second_source_scalar_norm (Y E V X : ℝ) + (hY : 0 Z^(s i)) = Z^(s 3+s 4/2+s 5+s 7/2+s 8/2) := by + have hs (x : ℝ) : Real.sqrt (Z^x) = Z^(x/2) := by + rw [Real.sqrt_eq_rpow,← Real.rpow_mul hZ.le] + congr 1 + ring + unfold firstRootScale + rw [hs,hs,hs,← Real.rpow_add hZ,← Real.rpow_add hZ,← Real.rpow_add hZ,← Real.rpow_add hZ] + +def firstKappa (M r ell V δ A B R : ℝ) : ℝ := M-2*r-2*ell-V-δ+A+B-R/2 +def firstPhysicalHeight (M r ell V δ B j : ℝ) : ℝ := 2*r-2*B-M+4*ell+2*V+δ-j +def secondLambda (M r ell V δ A B j t g θ : ℝ) : ℝ := + firstPhysicalHeight M r ell V δ B j - θ - (r-A-B-t-g) +def secondCount (ell R j t g θ : ℝ) : ℝ := ell+R/2-j+t+g-θ +def secondFormalColumn (r A B t g v : ℝ) : ℝ := r-A-B-t-g-v +def secondFormalLabel (B θ v j : ℝ) : ℝ := B+θ+v+j + +theorem first_physical_scalar (Z : ℝ) (hZ : 0 < Z) + (M r ell V δ A₁ A₂ B R t h : ℝ) : + Z^(-r-2*ell-V) * Z^M / + firstRootScale (fun i => Z^(![A₁,A₂,B,δ,R,t,h,r-A₁-B-t,r-A₂-B-t] i)) = + Z^((firstKappa M r ell V δ A₁ B R+firstKappa M r ell V δ A₂ B R)/2) := by + rw [firstRootScale_rpow Z hZ,←Real.rpow_add hZ,←Real.rpow_sub hZ] + congr 1 + norm_num [firstKappa] + ring + +theorem second_physical_scalar (Z : ℝ) (hZ : 0 < Z) + (M r ell V δ A B j t g θ v η τ : ℝ) : + Z^(firstPhysicalHeight M r ell V δ B j+12*η+τ) / + (Z^θ*Z^v*Z^(secondFormalColumn r A B t g v)) * Real.exp (6*(η*Real.log Z)) = + Z^(secondLambda M r ell V δ A B j t g θ+18*η+τ) := by + have he : Real.exp (6*(η*Real.log Z)) = Z^(6*η) := by + rw [Real.rpow_def_of_pos hZ] + congr 1 + ring + rw [he,←Real.rpow_add hZ,←Real.rpow_add hZ,←Real.rpow_sub hZ,←Real.rpow_add hZ] + congr 1 + unfold secondLambda secondFormalColumn + ring + +theorem physical_prefactor_identity (M r ell V δ A B R j t g θ v : ℝ) : + firstKappa M r ell V δ A B R + secondLambda M r ell V δ A B j t g θ + + secondCount ell R j t g θ + + 2*(secondFormalColumn r A B t g v+secondFormalLabel B θ v j) = r+3*ell+V := by + unfold firstKappa secondLambda firstPhysicalHeight secondCount secondFormalColumn secondFormalLabel + ring + +theorem physical_step_energy_exponent (M r ell V δ A B R j t g θ v η τ π ε clip : ℝ) + (hclip : clip ≤ 6*η) : + firstKappa M r ell V δ A B R + secondLambda M r ell V δ A B j t g θ + + secondCount ell R j t g θ + + 2*(secondFormalColumn r A B t g v+secondFormalLabel B θ v j+clip) + + (9/2+18+11/2)*η+τ+π+ε ≤ r+3*ell+V+40*η+τ+π+ε := + step_energy_exponent (physical_prefactor_identity M r ell V δ A B R j t g θ v) hclip + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Poisson.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Poisson.lean new file mode 100644 index 0000000000000000000000000000000000000000..6665d93cb1fa1596d36b2702727bcc35948fb6c3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Poisson.lean @@ -0,0 +1,169 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Descent.Marks +import OAI.NumberTheory.DirichletL.Descent.LocalReflection + +namespace OAI + +namespace SevenEighths.InverseMoment + +noncomputable section + +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic +open FirstPassCubeLabels +open SecondPassArithmetic + +noncomputable local instance markedQuotientField (P : Ideal ActualEisensteinCubic.O) + [P.IsMaximal] : Field (ActualEisensteinCubic.O ⧸ P) := Ideal.Quotient.field P + +noncomputable local instance markedQuotientFintype (P : Ideal ActualEisensteinCubic.O) + [P.IsMaximal] : Fintype (ActualEisensteinCubic.O ⧸ P) := Fintype.ofFinite _ + +theorem ideal_divisibility_local_zeroMark + (P A : Ideal ActualEisensteinCubic.O) [P.IsMaximal] + (hA : CompletedGauss.primaryGenerator A ≠ 0) : + zeroMark (Ideal.Quotient.mk P (CompletedGauss.primaryGenerator A)) = + if P ∣ A then 1 else 0 := by + have hd : P ∣ A ↔ CompletedGauss.primaryGenerator A ∈ P := by + calc + P ∣ A ↔ A ≤ P := Ideal.dvd_iff_le + _ ↔ Ideal.span {CompletedGauss.primaryGenerator A} ≤ P := by + rw [(CompletedGauss.primaryGenerator_spec A hA).1] + _ ↔ _ := Ideal.span_singleton_le_iff_mem P + simp only [zeroMark, Ideal.Quotient.eq_zero_iff_mem, hd] + +theorem actual_marked_active_eq + (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] (hg : ConcretePrimeRowBridge.goodLambda ∉ P) + (ψ : AddChar (ActualEisensteinCubic.O ⧸ P) ℂ) (hψ : ψ.IsPrimitive) + (σ ε : (ActualEisensteinCubic.O ⧸ P)ˣ) (x : ActualEisensteinCubic.O ⧸ P) : + localReflectionActive zeroMark (CompletedGauss.actualSextic P hg) ψ σ ε x = + -LocalReflectionBrackets.activeRow (CompletedGauss.actualSextic P hg) ψ 0 σ ε x := by + simpa only [localReflectionActive, localFourier, + LocalReflectionBrackets.activeRow, pow_zero] using + marked_active_eq_neg_trivial (CompletedGauss.actualSextic P hg) ψ hψ σ ε x + +theorem actual_marked_active_norm + (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] (hg : ConcretePrimeRowBridge.goodLambda ∉ P) + (hchar : ringChar (ActualEisensteinCubic.O ⧸ P) ≠ 2) + (ψ : AddChar (ActualEisensteinCubic.O ⧸ P) ℂ) (hψ : ψ.IsPrimitive) + (σ ε : (ActualEisensteinCubic.O ⧸ P)ˣ) (x : ActualEisensteinCubic.O ⧸ P) : + ‖localReflectionActive zeroMark (CompletedGauss.actualSextic P hg) ψ σ ε x‖ = + (LocalReflectionBrackets.rootCard (ActualEisensteinCubic.O ⧸ P))⁻¹ * + if x = 0 then 0 else 1 := by + rw [actual_marked_active_eq P hg ψ hψ σ ε x, norm_neg, + LocalReflectionBrackets.canonical_A5_norm_eq_bracket P hg hchar ψ hψ 0 + (by norm_num) σ ε x, LocalReflectionBrackets.norm_bracket_zero] + +theorem actual_marked_active_formula + (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] + (hg : ConcretePrimeRowBridge.goodLambda ∉ P) + (hchar : ringChar (ActualEisensteinCubic.O ⧸ P) ≠ 2) + (ψ : AddChar (ActualEisensteinCubic.O ⧸ P) ℂ) (hψ : ψ.IsPrimitive) + (σ ε : (ActualEisensteinCubic.O ⧸ P)ˣ) (x : ActualEisensteinCubic.O ⧸ P) : + localReflectionActive zeroMark (CompletedGauss.actualSextic P hg) ψ σ ε x = + (LocalReflectionBrackets.rootCard (ActualEisensteinCubic.O ⧸ P) : ℂ)⁻¹ * + LocalReflectionBrackets.tau (CompletedGauss.actualSextic P hg) ψ 2 * + (((CompletedGauss.actualSextic P hg) ^ 2)⁻¹) + ((σ : ActualEisensteinCubic.O ⧸ P) * (ε : ActualEisensteinCubic.O ⧸ P) * x) := by + rw [actual_marked_active_eq P hg ψ hψ σ ε x, + LocalReflectionBrackets.canonical_A5_normalized P hg hchar ψ hψ 0 (by norm_num)] + simp only [LocalReflectionBrackets.phase, LocalReflectionBrackets.bracket, + show (0 : ℕ) ≠ 4 by decide, ↓reduceIte, inv_pow, map_mul] + ring + +theorem actual_marked_gauss_phase_norm + (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] + (hg : ConcretePrimeRowBridge.goodLambda ∉ P) + (hchar : ringChar (ActualEisensteinCubic.O ⧸ P) ≠ 2) + (ψ : AddChar (ActualEisensteinCubic.O ⧸ P) ℂ) (hψ : ψ.IsPrimitive) : + ‖LocalReflectionBrackets.tau (CompletedGauss.actualSextic P hg) ψ 2‖ = 1 := by + have h := LocalReflectionBrackets.canonical_phase_norm P hg hchar ψ hψ 0 (by norm_num) 1 + simpa only [LocalReflectionBrackets.phase, show (0 : ℕ) ≠ 4 by decide, + ↓reduceIte, Units.val_one, map_one, mul_one, norm_neg] using h + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → ActualEisensteinCubic.O) (hp : ∀ i, p i ≠ 0) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +include hcop + +omit [DecidableEq ι] in +theorem row_slot_cross_phase + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda ^ 2 ∣ p i - 1) (i k : ι) (hik : i ≠ k) : + MixedCrossSeparation.crossSymbol p hg i k ^ 4 * + MixedCrossSeparation.crossSymbol p hg k i ^ 2 = 1 := by + have hs : MixedCrossSeparation.crossSymbol p hg i k ^ 2 = + MixedCrossSeparation.crossSymbol p hg k i ^ 2 := + canonicalSextic_sq_reciprocity_primary (Ideal.span {p i}) (Ideal.span {p k}) + (hg i) (hg k) (p i) (p k) rfl rfl (hpr i) (hpr k) + have hnot : p k ∉ Ideal.span {p i} := by + intro hm + have hle : Ideal.span {p k} ≤ Ideal.span {p i} := + Ideal.span_le.mpr (Set.singleton_subset_iff.mpr hm) + have ht := (hcop hik).sup_eq + rw [sup_eq_left.mpr hle] at ht + exact (inferInstance : (Ideal.span {p i}).IsMaximal).ne_top ht + have h6 : MixedCrossSeparation.crossSymbol p hg i k ^ 6 = 1 := by + simpa only [MixedCrossSeparation.crossSymbol, map_pow, ite_eq_right hnot] using + canonicalSextic_sixth_power_mask (Ideal.span {p i}) (hg i) (p k) + calc + _ = MixedCrossSeparation.crossSymbol p hg i k ^ 6 := by rw [← hs]; ring + _ = 1 := h6 + +omit [DecidableEq ι] in +theorem row_slot_product_phase + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda ^ 2 ∣ p i - 1) (R P : Finset ι) (hRP : Disjoint R P) : + (∏ i ∈ R, ∏ k ∈ P, + MixedCrossSeparation.crossSymbol p hg i k ^ 4 * + MixedCrossSeparation.crossSymbol p hg k i ^ 2) = 1 := by + apply Finset.prod_eq_one + intro i hi + apply Finset.prod_eq_one + intro k hk + exact row_slot_cross_phase p hcop hg hpr i k (fun h => + (Finset.disjoint_left.mp hRP) hi (h.symm ▸ hk)) + +theorem canonicalSourceCoefficient_mark_priority + (Ψ : ActualEisensteinCubic.O →* ℂ) (m f : ActualEisensteinCubic.O) + (H : Finset ι → ℂ) (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A S : Finset ι) : + canonicalSourceCoefficient p hp hcop hg Ψ m f + (fun U => H U * primeMark I L a (A ∪ U)) S = + ∑ J ∈ I.powerset, primeMark J L a A * + canonicalSourceCoefficient p hp hcop hg Ψ m f + (fun U => H U * primeMark (I \ J) L a (U \ A)) S := by + simp only [canonicalSourceCoefficient, primeMark_priority, Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + ring + +omit [DecidableEq σ] in +theorem marked_disjoint_source_poisson + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (ActualEisensteinCubic.O ⧸ Ideal.span {p i}) ≠ 2) + (F M B A₁ A₂ : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (C₁ C₂ : Finset ι → ℂ) (I₁ I₂ : Finset σ) + (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W : 𝓢(ℝ, ℂ)) (V₁ V₂ : ℝ → ℂ) (X₁ X₂ K : ℝ) (hK : 0 < K) : + disjointCanonicalSource p hp hcop hg F M B v ε₁ ε₂ + (fun U => C₁ U * primeMark I₁ L₁ a₁ (A₁ ∪ U)) + (fun U => C₂ U * primeMark I₂ L₂ a₂ (A₂ ∪ U)) W V₁ V₂ X₁ X₂ K = + ∑ D ∈ M.powerset, + (UniqueFactorizationMonoid.moebius (∏ i ∈ D, Ideal.span {p i}) : ℂ) / + (primeProductNorm p D : ℂ) * + ∑' h : ActualEisensteinCubic.O, + actualFirstKernel p hp hcop hg F B v ε₁ ε₂ + (fun U => C₁ U * primeMark I₁ L₁ a₁ (A₁ ∪ U)) + (fun U => C₂ U * primeMark I₂ L₂ a₂ (A₂ ∪ U)) W V₁ V₂ X₁ X₂ K + (primeSubsetGenerator (fun i => Ideal.span {p i}) D) h := by + exact disjointCanonicalSource_poisson p hp hcop hg hinj hc F M B v ε₁ ε₂ + (fun U => C₁ U * primeMark I₁ L₁ a₁ (A₁ ∪ U)) + (fun U => C₂ U * primeMark I₂ L₂ a₂ (A₂ ∪ U)) W V₁ V₂ X₁ X₂ K hK + +end + +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PoissonTails.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PoissonTails.lean new file mode 100644 index 0000000000000000000000000000000000000000..b19d03ec254471ee9ab5da93ad24782df34eaed7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PoissonTails.lean @@ -0,0 +1,65 @@ +import OAI.NumberTheory.DirichletL.Foundation + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def secondOuterBall (Y E X₁ X₂ H : ℝ) : Finset Eis := + secondFrequencyCutoff (Y / (E * X₁ * X₂)) H + +theorem secondOuterBall_raw_tail {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) (Y E X₁ X₂ H : ℝ) + (hY : 0 < Y) (hE : 0 < E) (hX₁ : 0 < X₁) (hX₂ : 0 < X₂) + (e : Eis) (he : e ≠ 0) (heE : ‖eisEmbedding e‖^2 ≤ E) + (S T : Finset ι) (hd : Disjoint S T) + (hS : primeProductNorm p S ≤ X₁) (hT : primeProductNorm p T ≤ X₂) + (k : Eis) (hk : k ∉ secondOuterBall Y E X₁ X₂ H) : + H ≤ (Y / (‖eisEmbedding e‖^2 * + ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2)) * ‖eisEmbedding k‖^2 := by + have hs : 0 < Y/(E*X₁*X₂) := by positivity + have hn : 0 < ‖eisEmbedding e‖^2 := sq_pos_of_pos (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero he)) + have hprod : ‖eisEmbedding e‖^2 * primeProductNorm p S * primeProductNorm p T ≤ E*X₁*X₂ := by + exact mul_le_mul (mul_le_mul heE hS (primeProductNorm_pos p hp S).le hE.le) + hT (primeProductNorm_pos p hp T).le (mul_pos hE hX₁).le + have hb : Y/(E*X₁*X₂) ≤ + Y/(‖eisEmbedding e‖^2 * ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2) := by + rw [active_norm_sq_disjoint p S T hd] + apply div_le_div_of_nonneg_left hY.le + · exact mul_pos hn (mul_pos (primeProductNorm_pos p hp S) (primeProductNorm_pos p hp T)) + · simpa only [mul_assoc] using hprod + exact (outside_secondFrequencyCutoff _ H hs k hk).le.trans + (mul_le_mul_of_nonneg_right hb (sq_nonneg _)) + +theorem secondOuterBall_remainder {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(ℝ, ℂ)) (Y E X₁ X₂ H : ℝ), + 0 < Y → 0 < E → 0 < X₁ → 0 < X₂ → 0 ≤ H → + ∀ (e : Eis), e ≠ 0 → ‖eisEmbedding e‖^2 ≤ E → + ∀ (S T : Finset ι), Disjoint S T → + primeProductNorm p S ≤ X₁ → primeProductNorm p T ≤ X₂ → + let n := ∏ i : activeSupport T S, p i.val + let scale := Y / (‖eisEmbedding e‖^2 * ‖eisEmbedding n‖^2) + ‖∑' k : {k : Eis // k ∉ secondOuterBall Y E X₁ X₂ H}, + secondPairRadialMode p hp hg hinj S T e k.val W Y‖ ≤ + (Y / ‖eisEmbedding n‖) * + ((C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / + ((min 1 scale)^2 * (1+H)^A)) := by + obtain ⟨s,C,hC,hb⟩ := secondPairRadialMode_remainder p hp hg hinj hc A + refine ⟨s,C,hC,?_⟩ + intro W Y E X₁ X₂ H hY hE hX₁ hX₂ hH e he heE S T hd hS hT + exact hb S T e he W Y H hY hH (secondOuterBall Y E X₁ X₂ H) + (fun k hk => secondOuterBall_raw_tail p hp Y E X₁ X₂ H hY hE hX₁ hX₂ e he heE S T hd hS hT k hk) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PrincipalChild.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PrincipalChild.lean new file mode 100644 index 0000000000000000000000000000000000000000..97bcf550e5e2f906f450ac89a202e21630afdf8d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PrincipalChild.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Inversion.PrincipalEnergy +import OAI.NumberTheory.DirichletL.Descent.ChildCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InversePrincipalEnergy +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +lemma zero_mem_childFrequencyBall (a : Eis) (ha : a ≠ 0) (R : ℝ) (hR : 0 ≤ R) : + (0 : Eis) ∈ childFrequencyBall a R := by + apply (mem_childFrequencyBall a ha R 0).mpr + simpa using hR + +def secondPhysicalCutoff {ι : Type*} [DecidableEq ι] (p : ι → Eis) + (d : Eis) (R : ℝ) (_G E : Finset ι) : Finset Eis := + childFrequencyBall (d * primeSubsetGenerator (fun i => Ideal.span {p i}) E) R + +def secondPhysicalMask {ι : Type*} [DecidableEq ι] (p : ι → Eis) + (d : Eis) (R : ℝ) (_G E : Finset ι) (k : Eis) : ℂ := + if k ∈ nonzeroChildFrequencyBall + (d * primeSubsetGenerator (fun i => Ideal.span {p i}) E) R then 1 else 0 + +lemma secondPhysicalMask_norm_le_one {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (d : Eis) (R : ℝ) (G E : Finset ι) (k : Eis) : + ‖secondPhysicalMask p d R G E k‖ ≤ 1 := by + unfold secondPhysicalMask + split_ifs <;> norm_num + +lemma secondPhysicalMask_exact {ι : Type*} [DecidableEq ι] + (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + (d : Eis) (hd : d ≠ 0) (R : ℝ) (G E : Finset ι) (k : Eis) : + secondPhysicalMask p d R G E k = + if 0 < ‖ConcreteTraceCRT.eisEmbedding + (d * primeSubsetGenerator (fun i => Ideal.span {p i}) E * k)‖^2 ∧ + ‖ConcreteTraceCRT.eisEmbedding + (d * primeSubsetGenerator (fun i => Ideal.span {p i}) E * k)‖^2 ≤ R + then 1 else 0 := by + unfold secondPhysicalMask + have he := mem_nonzeroChildFrequencyBall + (d * primeSubsetGenerator (fun i => Ideal.span {p i}) E) + (mul_ne_zero hd (primeSubsetGenerator_ne_zero _ _)) R k + split_ifs with h₁ h₂ h₂ + · rfl + · exact (h₂ (he.mp h₁)).elim + · exact (h₁ (he.mpr h₂)).elim + · rfl + +theorem physical_child_principal_energy (ε : ℝ) (hε : 0 < ε) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i ∈ slots, ∀ k ∈ lists i, ‖a i k‖ ≤ 1) → + ∀ (A F : Finset ι) (Ψ : Eis →* ℂ), (∀ z, ‖Ψ z‖ ≤ 1) → + ∀ (m c d : Eis), d ≠ 0 → ∀ (V W : 𝓢(ℝ, ℂ)) (X M Y R : ℝ), + 0 < X → 1 ≤ Y → 0 ≤ R → + (∀ t, V t ≠ 0 → t ≤ Real.exp M) → + ‖truncatedSecondZero p hg F Ψ m c d (markedRadial p slots lists a A V X) W Y + (secondPhysicalCutoff p d R)‖ + + ‖principalRestoration p hg hinj hp F Ψ m c d (markedRadial p slots lists a A V X) W Y + (secondPhysicalMask p d R)‖ ≤ + C * (4 : ℝ)^A.card * + (s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W * (SchwartzMap.seminorm ℝ 0 0 V)^2) * + Y * (X * Real.exp M)^(1 + ε) := by + obtain ⟨s,C,hC,he⟩ := marked_principal_energy ε hε + refine ⟨s,C,hC,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop slots lists a hs ha A F Ψ hΨ m c d hd V W X M Y R hX hY hR hV + apply he p hp hg hinj hcop slots lists a hs ha A F Ψ hΨ m c d V W X M Y hX hY hV + · intro G hG E hE + exact zero_mem_childFrequencyBall _ (mul_ne_zero hd (primeSubsetGenerator_ne_zero _ _)) R hR + · intro G hG E k + exact secondPhysicalMask_norm_le_one p d R G E.val k.val + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PrincipalSelectorMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PrincipalSelectorMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..527640dc58e613cbd7f750abcd4abce6afcc2f71 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PrincipalSelectorMass.lean @@ -0,0 +1,71 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityPrincipal + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open FirstPassCubeLabels SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O + +theorem first_selector_weighted_mass {ι:Type*} [DecidableEq ι] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (pool A:Finset ι) (selector:Finset ι→ℂ) (E T S ε:ℝ) + (hE:0≤E) (hT:0 congr 1 <;> ring_nf + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..2de4d08bb98704f47ba38076199e78e40e52cf8a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergy.lean @@ -0,0 +1,124 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondCellPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_cell_recursive + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source) (d:InverseSecondSourceBlocks.BlockIndex) + (_hcell:∀x∈source,InverseSecondSourceBlocks.index p x=d), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y R L Z X Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+Vlabel) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+Vlabel) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^Aker)) := by + let g:=priorityLogWindow om lo hi hlo hsupport negative + let mg:=|Real.log lo|+|Real.log hi| + have hm:0≤mg:=add_nonneg (abs_nonneg _) (abs_nonneg _) + have hg:Function.support g⊆Set.Icc (-mg) mg:=priorityLogWindow_support om lo hi hlo hsupport negative + have hcg:Function.support (conjugateProfile g)⊆Set.Icc (-mg) mg:=by + intro x hx + apply hg + simpa only [Function.mem_support,conjugateProfile_apply,star_ne_zero] using hx + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,henergy⟩:= + actual_second_fixed_block_recursive (ι:=ι) (σ:=σ) (conjugateProfile g) g Φ mg mg 1 + (fun _=>1) (fun _=>2) B₀ hm hm (le_refl 1) (fun _=>zero_lt_one) + (fun _=>by norm_num) hB₀ hcg hg Aker J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,?_⟩ + intro p hp _ hcop hg₀ hpr hinj hc Jo source hs d hcell pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X Vlabel εchild ell Ractive j tcount gcount theta eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY hrows hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hblock:=actual_source_block_ratios p hp source d hcell + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) + have he:=henergy p hp hcop hg₀ hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + (scales d 0) (scales d 1) (scales d 2) (scales d 3) Y R L Z + (secondCellColumnExponent Z X d) Vlabel εchild ell Ractive j tcount gcount theta eta ρ + 1 1 (-priorityHeight negative t) (priorityHeight negative t) w labels A + hd₁ hd₂ hρ (le_refl 1) (le_refl 1) (le_refl 1) (le_refl 1) hL (lt_trans zero_lt_one hZ) + (dyadScale_pos _) (dyadScale_pos _) (dyadScale_pos _) (dyadScale_pos _) + (Real.rpow_pos_of_pos (lt_trans zero_lt_one hZ) _) hY hrows hblock + hcube₁ hcube₂ hactive hj hquot hcommon hdiv hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + rw [second_cell_physical_scale Z X d hZ hX] at he + refine le_trans (le_of_eq (congrArg (fun v : ℂ => ‖(Y : ℂ) * secondRayCoefficient z * v‖) ?_)) he + apply Finset.sum_congr rfl + intro x _hx + exact congrArg (fun v : ℂ => (w x * actualSecondSignedWeight p hp hcop hg₀ Ψ + (m * ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * v) + (actual_priority_profile_common p hp hcop hg₀ pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ _ _ a₁ a₂ om lo hi hlo hsupport negative t Φ Y X hX) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergyWindowOrder.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergyWindowOrder.lean new file mode 100644 index 0000000000000000000000000000000000000000..70cbc02d7e5f2224a85e30ca03ff759500effc51 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergyWindowOrder.lean @@ -0,0 +1,128 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondBlockEnergyWindowOrder +import OAI.NumberTheory.DirichletL.Descent.SecondCellPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_cell_recursive_window_order + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source) (d:InverseSecondSourceBlocks.BlockIndex) + (_hcell:∀x∈source,InverseSecondSourceBlocks.index p x=d), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y R L Z X Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+Vlabel) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+Vlabel) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^Aker)) := by + let g:=priorityLogWindow om lo hi hlo hsupport negative + let mg:=|Real.log lo|+|Real.log hi| + have hm:0≤mg:=add_nonneg (abs_nonneg _) (abs_nonneg _) + have hg:Function.support g⊆Set.Icc (-mg) mg:=priorityLogWindow_support om lo hi hlo hsupport negative + have hcg:Function.support (conjugateProfile g)⊆Set.Icc (-mg) mg:=by + intro x hx + apply hg + simpa only [Function.mem_support,conjugateProfile_apply,star_ne_zero] using hx + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_second_fixed_block_recursive_window_order (ι:=ι) (σ:=σ) (conjugateProfile g) g Φ mg mg 1 + (fun _=>1) (fun _=>2) B₀ hm hm (le_refl 1) (fun _=>zero_lt_one) + (fun _=>by norm_num) hB₀ hcg hg Aker K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩:=hordered J + refine ⟨C,hC,?_⟩ + intro p hp _ hcop hg₀ hpr hinj hc Jo source hs d hcell pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X Vlabel εchild ell Ractive j tcount gcount theta eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY hrows hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hblock:=actual_source_block_ratios p hp source d hcell + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) + have he:=henergy p hp hcop hg₀ hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + (scales d 0) (scales d 1) (scales d 2) (scales d 3) Y R L Z + (secondCellColumnExponent Z X d) Vlabel εchild ell Ractive j tcount gcount theta eta ρ + 1 1 (-priorityHeight negative t) (priorityHeight negative t) w labels A + hd₁ hd₂ hρ (le_refl 1) (le_refl 1) (le_refl 1) (le_refl 1) hL (lt_trans zero_lt_one hZ) + (dyadScale_pos _) (dyadScale_pos _) (dyadScale_pos _) (dyadScale_pos _) + (Real.rpow_pos_of_pos (lt_trans zero_lt_one hZ) _) hY hrows hblock + hcube₁ hcube₂ hactive hj hquot hcommon hdiv hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + rw [second_cell_physical_scale Z X d hZ hX] at he + refine le_trans (le_of_eq (congrArg (fun v : ℂ => ‖(Y : ℂ) * secondRayCoefficient z * v‖) ?_)) he + apply Finset.sum_congr rfl + intro x _hx + exact congrArg (fun v : ℂ => (w x * actualSecondSignedWeight p hp hcop hg₀ Ψ + (m * ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * v) + (actual_priority_profile_common p hp hcop hg₀ pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ _ _ a₁ a₂ om lo hi hlo hsupport negative t Φ Y X hX) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergyWindowOrderUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergyWindowOrderUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..ed6ceb0ab2a929766eb038debf8bbb0a3ffa206a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityCellEnergyWindowOrderUniform.lean @@ -0,0 +1,129 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergyWindowOrder +import OAI.NumberTheory.DirichletL.Descent.SecondBlockEnergyWindowOrderUniform +import OAI.NumberTheory.DirichletL.Descent.SecondBlockEnergyWindowOrder +import OAI.NumberTheory.DirichletL.Descent.SecondCellPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +theorem actual_priority_cell_recursive_window_order_uniform_types + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source) (d:InverseSecondSourceBlocks.BlockIndex) + (_hcell:∀x∈source,InverseSecondSourceBlocks.index p x=d), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y R L Z X Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+Vlabel) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+Vlabel) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^Aker)) := by + let g:=priorityLogWindow om lo hi hlo hsupport negative + let mg:=|Real.log lo|+|Real.log hi| + have hm:0≤mg:=add_nonneg (abs_nonneg _) (abs_nonneg _) + have hg:Function.support g⊆Set.Icc (-mg) mg:=priorityLogWindow_support om lo hi hlo hsupport negative + have hcg:Function.support (conjugateProfile g)⊆Set.Icc (-mg) mg:=by + intro x hx + apply hg + simpa only [Function.mem_support,conjugateProfile_apply,star_ne_zero] using hx + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_second_fixed_block_recursive_window_order_uniform_types (conjugateProfile g) g Φ mg mg 1 + (fun _=>1) (fun _=>2) B₀ hm hm (le_refl 1) (fun _=>zero_lt_one) + (fun _=>by norm_num) hB₀ hcg hg Aker K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩:=hordered J + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg₀ hpr hinj hc Jo source hs d hcell pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X Vlabel εchild ell Ractive j tcount gcount theta eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY hrows hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hblock:=actual_source_block_ratios p hp source d hcell + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) + have he:=henergy p hp hcop hg₀ hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + (scales d 0) (scales d 1) (scales d 2) (scales d 3) Y R L Z + (secondCellColumnExponent Z X d) Vlabel εchild ell Ractive j tcount gcount theta eta ρ + 1 1 (-priorityHeight negative t) (priorityHeight negative t) w labels A + hd₁ hd₂ hρ (le_refl 1) (le_refl 1) (le_refl 1) (le_refl 1) hL (lt_trans zero_lt_one hZ) + (dyadScale_pos _) (dyadScale_pos _) (dyadScale_pos _) (dyadScale_pos _) + (Real.rpow_pos_of_pos (lt_trans zero_lt_one hZ) _) hY hrows hblock + hcube₁ hcube₂ hactive hj hquot hcommon hdiv hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + rw [second_cell_physical_scale Z X d hZ hX] at he + refine le_trans (le_of_eq (congrArg (fun v : ℂ => ‖(Y : ℂ) * secondRayCoefficient z * v‖) ?_)) he + apply Finset.sum_congr rfl + intro x _hx + exact congrArg (fun v : ℂ => (w x * actualSecondSignedWeight p hp hcop hg₀ Ψ + (m * ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * v) + (actual_priority_profile_common p hp hcop hg₀ pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ _ _ a₁ a₂ om lo hi hlo hsupport negative t Φ Y X hX) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadius.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadius.lean new file mode 100644 index 0000000000000000000000000000000000000000..d9823b432a7e6854b78e1be60ce67df4ae6d9cba --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadius.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondCellParameters + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_source_moving_radius + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + ∑d∈keys p source,(Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+(Vlabel d))+εchild))* + Z^((ell+Ractive/2-j+tcount+(secondCellExponent Z d 0)-(secondCellExponent Z d 1)+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^0)) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,henergy⟩:= + actual_priority_cell_recursive (ι:=ι) (σ:=σ) om Φ lo hi hlo hsupport negative B₀ hB₀ 0 J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hz:0frequency_ne_zero_of_gate _ _ (hrows x hx) + rw [physical_source_partition p hp hcop hg source pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ w] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro d hd + have hin : cell p source d⊆source:=cell_subset p source d + have hcommon:∀x∈cell p source d,primeProductNorm p x.second.sourceCommon≤Z^(secondCellExponent Z d 0+eta):=by + intro x hx + have hr:primeProductNorm p x.second.sourceCommon≤2*scales d 0:= + (div_le_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 0).2.le + apply hr.trans + rw [Real.rpow_add hz,second_cell_scale_rpow Z d 0 hZ] + simpa only [mul_comm] using mul_le_mul_of_nonneg_left hbin (show 0≤scales d 0 from (dyadScale_pos _).le) + have hdiv:∀x∈cell p source d,Z^(secondCellExponent Z d 1-eta)≤primeProductNorm p x.second.divisor:=by + intro x hx + have hr:scales d 1≤primeProductNorm p x.second.divisor:=by + simpa [outerNorms,scales] using (le_div_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 1).1 + have hh:Z^(secondCellExponent Z d 1-eta)≤Z^(secondCellExponent Z d 1):= + Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith) + rw [second_cell_scale_rpow Z d 1 hZ] at hh + exact hh.trans hr + exact henergy p hp hcop hg hpr hinj hc (cell p source d) (cell_conditions p source hs d) d + (fun x hx=>(mem_cell p source d x).mp hx |>.2) pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y (R d) L Z X (Vlabel d) εchild ell Ractive j tcount + (secondCellExponent Z d 0) (secondCellExponent Z d 1) eta ρ t w (labels d) A + (fun x hx=>hd₁ x (hin hx)) (fun x hx=>hd₂ x (hin hx)) hρ hL hZ hX hY + (fun x hx=>by simpa only [(mem_cell p source d x).mp hx |>.2] using hrows x (hin hx)) (fun x hx=>hcube₁ x (hin hx)) (fun x hx=>hcube₂ x (hin hx)) + (fun x hx=>hactive x (hin hx)) (fun x hx=>hj x (hin hx)) (fun x hx=>hquot x (hin hx)) + hcommon hdiv hΨ (fun x hx=>hw x (hin hx)) ha₁ ha₂ (hlabels d hd) ho hslots₁ hslots₂ hA + (hleft d hd) (hright d hd) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadiusWindowOrder.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadiusWindowOrder.lean new file mode 100644 index 0000000000000000000000000000000000000000..a7c99bd99d0ea34f2172146d5ff18a7d9e6813a3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadiusWindowOrder.lean @@ -0,0 +1,129 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergyWindowOrder +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondCellParameters + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_source_moving_radius_window_order + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + ∑d∈keys p source,(Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+(Vlabel d))+εchild))* + Z^((ell+Ractive/2-j+tcount+(secondCellExponent Z d 0)-(secondCellExponent Z d 1)+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^0)) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_priority_cell_recursive_window_order (ι:=ι) (σ:=σ) om Φ lo hi hlo hsupport negative B₀ hB₀ 0 K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩:=hordered J + refine ⟨C,hC,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hz:0frequency_ne_zero_of_gate _ _ (hrows x hx) + rw [physical_source_partition p hp hcop hg source pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ w] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro d hd + have hin : cell p source d⊆source:=cell_subset p source d + have hcommon:∀x∈cell p source d,primeProductNorm p x.second.sourceCommon≤Z^(secondCellExponent Z d 0+eta):=by + intro x hx + have hr:primeProductNorm p x.second.sourceCommon≤2*scales d 0:= + (div_le_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 0).2.le + apply hr.trans + rw [Real.rpow_add hz,second_cell_scale_rpow Z d 0 hZ] + simpa only [mul_comm] using mul_le_mul_of_nonneg_left hbin (show 0≤scales d 0 from (dyadScale_pos _).le) + have hdiv:∀x∈cell p source d,Z^(secondCellExponent Z d 1-eta)≤primeProductNorm p x.second.divisor:=by + intro x hx + have hr:scales d 1≤primeProductNorm p x.second.divisor:=by + simpa [outerNorms,scales] using (le_div_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 1).1 + have hh:Z^(secondCellExponent Z d 1-eta)≤Z^(secondCellExponent Z d 1):= + Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith) + rw [second_cell_scale_rpow Z d 1 hZ] at hh + exact hh.trans hr + exact henergy p hp hcop hg hpr hinj hc (cell p source d) (cell_conditions p source hs d) d + (fun x hx=>(mem_cell p source d x).mp hx |>.2) pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y (R d) L Z X (Vlabel d) εchild ell Ractive j tcount + (secondCellExponent Z d 0) (secondCellExponent Z d 1) eta ρ t w (labels d) A + (fun x hx=>hd₁ x (hin hx)) (fun x hx=>hd₂ x (hin hx)) hρ hL hZ hX hY + (fun x hx=>by simpa only [(mem_cell p source d x).mp hx |>.2] using hrows x (hin hx)) (fun x hx=>hcube₁ x (hin hx)) (fun x hx=>hcube₂ x (hin hx)) + (fun x hx=>hactive x (hin hx)) (fun x hx=>hj x (hin hx)) (fun x hx=>hquot x (hin hx)) + hcommon hdiv hΨ (fun x hx=>hw x (hin hx)) ha₁ ha₂ (hlabels d hd) ho hslots₁ hslots₂ hA + (hleft d hd) (hright d hd) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadiusWindowOrderUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadiusWindowOrderUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..a23272583193ed5af3039ba191bd52808145b739 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityMovingRadiusWindowOrderUniform.lean @@ -0,0 +1,130 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadiusWindowOrder +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergyWindowOrderUniform +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergyWindowOrder +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondCellParameters + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +theorem actual_priority_source_moving_radius_window_order_uniform_types + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + ∑d∈keys p source,(Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+(Vlabel d))+εchild))* + Z^((ell+Ractive/2-j+tcount+(secondCellExponent Z d 0)-(secondCellExponent Z d 1)+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^0)) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_priority_cell_recursive_window_order_uniform_types om Φ lo hi hlo hsupport negative B₀ hB₀ 0 K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩:=hordered J + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hz:0frequency_ne_zero_of_gate _ _ (hrows x hx) + rw [physical_source_partition p hp hcop hg source pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ w] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro d hd + have hin : cell p source d⊆source:=cell_subset p source d + have hcommon:∀x∈cell p source d,primeProductNorm p x.second.sourceCommon≤Z^(secondCellExponent Z d 0+eta):=by + intro x hx + have hr:primeProductNorm p x.second.sourceCommon≤2*scales d 0:= + (div_le_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 0).2.le + apply hr.trans + rw [Real.rpow_add hz,second_cell_scale_rpow Z d 0 hZ] + simpa only [mul_comm] using mul_le_mul_of_nonneg_left hbin (show 0≤scales d 0 from (dyadScale_pos _).le) + have hdiv:∀x∈cell p source d,Z^(secondCellExponent Z d 1-eta)≤primeProductNorm p x.second.divisor:=by + intro x hx + have hr:scales d 1≤primeProductNorm p x.second.divisor:=by + simpa [outerNorms,scales] using (le_div_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 1).1 + have hh:Z^(secondCellExponent Z d 1-eta)≤Z^(secondCellExponent Z d 1):= + Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith) + rw [second_cell_scale_rpow Z d 1 hZ] at hh + exact hh.trans hr + exact henergy p hp hcop hg hpr hinj hc (cell p source d) (cell_conditions p source hs d) d + (fun x hx=>(mem_cell p source d x).mp hx |>.2) pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y (R d) L Z X (Vlabel d) εchild ell Ractive j tcount + (secondCellExponent Z d 0) (secondCellExponent Z d 1) eta ρ t w (labels d) A + (fun x hx=>hd₁ x (hin hx)) (fun x hx=>hd₂ x (hin hx)) hρ hL hZ hX hY + (fun x hx=>by simpa only [(mem_cell p source d x).mp hx |>.2] using hrows x (hin hx)) (fun x hx=>hcube₁ x (hin hx)) (fun x hx=>hcube₂ x (hin hx)) + (fun x hx=>hactive x (hin hx)) (fun x hx=>hj x (hin hx)) (fun x hx=>hquot x (hin hx)) + hcommon hdiv hΨ (fun x hx=>hw x (hin hx)) ha₁ ha₂ (hlabels d hd) ho hslots₁ hslots₂ hA + (hleft d hd) (hright d hd) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityProfile.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..4d20a8966ac3aef1a2ce46637063e0bdfd65295e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityProfile.lean @@ -0,0 +1,107 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondBlockEnergy +import OAI.NumberTheory.DirichletL.Descent.WholePriorityPhysical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration +local notation "O" => ActualEisensteinCubic.O + +def priorityLogWindow (om:𝓢(ℝ,ℂ)) (a b:ℝ) (ha:0 simpa only [priorityLogWindow,Bool.false_eq_true,ite_true,ite_false, + conjugateProfile_apply,CubicReflectionKernel.logSchwartz_apply,Function.mem_support,star_ne_zero] using hy + have hh:=hs hn + have hlo:=Real.log_le_log ha hh.1 + have hhi:=Real.log_le_log (Real.exp_pos y) hh.2 + rw [Real.log_exp] at hlo hhi + constructor + · linarith [neg_abs_le (Real.log a),abs_nonneg (Real.log b)] + · linarith [le_abs_self (Real.log b),abs_nonneg (Real.log a)] + +theorem principalWindow_positiveSource (om:𝓢(ℝ,ℂ)) (a b:ℝ) (ha:0 simp only [priorityLogWindow,priorityHeight,Bool.false_eq_true,ite_true,ite_false, + positiveSource,Real.log_one,add_zero,conjugateProfile_apply,CubicReflectionKernel.logSchwartz_apply, + Real.exp_log hx,normTwistedSource] + +theorem positiveSource_conjugate_one (g:𝓢(ℝ,ℂ)) (t x:ℝ) : + star (positiveSource (conjugateProfile g) 1 (-t) x)=positiveSource g 1 t x := by + simp only [positiveSource,Real.log_one,add_zero,conjugateProfile_apply,star_mul,star_star, + logPhase_conjugate,neg_neg,mul_comm] + +theorem actualSecondProfileRow_congr_positive {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι) (x:SecondProfileData ι) (slots₁ slots₂:Finset σ) + (lists₁ lists₂:σ→Finset ι) (a₁ a₂:σ→ι→ℂ) + (W₁ W₂ V₁ V₂:ℝ→ℂ) (Φ:𝓢(ℝ,ℂ)) (Y X:ℝ) (hX:0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι) (x:SecondProfileData ι) (slots₁ slots₂:Finset σ) + (lists₁ lists₂:σ→Finset ι) (a₁ a₂:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0star (positiveSource (conjugateProfile g) 1 (-θ) y)) (positiveSource g 1 θ) Φ Y X := by + intro g θ + apply actualSecondProfileRow_congr_positive p hp hcop hg pool x slots₁ slots₂ lists₁ lists₂ a₁ a₂ + _ _ _ _ Φ Y X hX + · intro y hy + rw [positiveSource_conjugate_one] + exact principalWindow_positiveSource om lo hi hlo hs negative t y hy + · intro y hy + exact principalWindow_positiveSource om lo hi hlo hs negative t y hy + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedBound.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..53650875280fe3bb0a4f406435a6fb145d053631 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedBound.lean @@ -0,0 +1,146 @@ +import OAI.NumberTheory.DirichletL.Descent.PrioritySourceEnergy +import OAI.NumberTheory.DirichletL.Descent.PrioritySourceBudget + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_retained_bound + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y R L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,henergy⟩:= + actual_priority_source_recursive (ι:=ι) (σ:=σ) om Φ lo hi hlo hsupport negative B₀ hB₀ J K εmass hεmass + obtain ⟨Cbin,hCbin,hbudget⟩:=priority_source_scalar_budget caps hcaps + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,36*(2:ℝ)^(2*K)*C,Cbin,by positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b + ρ t w labels A hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have he:=henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + let H:ℝ:=(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J) + have hheight:(1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J=H:=by + cases negative <;> simp [priorityHeight,H,two_mul,pow_add] + let D:ℝ:=36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A*C*H + have hD:0≤D:=by dsimp [D,H];positivity + let S:ℝ:=∑d∈keys p source,priorityCellScalar Z Y L X ell Ractive j tcount eta εchild εmass Bfirst (secondRayCoefficient z) d + have hfactor: + (∑d∈keys p source,(Real.exp (6*L)*‖(Y:ℂ)*secondRayCoefficient z* + ((scales d 1*scales d 2*Z^(secondCellColumnExponent Z X d):ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel d)+εchild))* + Z^((ell+Ractive/2-j+tcount+secondCellExponent Z d 0-secondCellExponent Z d 1+11*eta/2)*(1+εmass)))* + (C*((1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J))))=D*S:=by + dsimp only [S] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + rw [hheight,hVe d] + dsimp only [D,priorityCellScalar,secondCount] + ring + simp only [pow_zero,div_one] at he + rw [hfactor] at he + have hbnd:=hbudget p hp source Z M r ell V delta Acol Bfirst Ractive j tcount eta tau pi εchild εmass b D + (secondRayCoefficient z) hZ2 hD hb hthreshold + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) hnorm + (by simpa only [hXe] using hgeom) hmass + have hs: C*0≤C*0:=le_refl _ + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + have hP:0≤P:=by dsimp [P];positivity + have hconst:D≤(36*(2:ℝ)^(2*K)*C)*A*H:=by + have h1:(2:ℝ)^slots₁.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₁ + have h2:(2:ℝ)^slots₂.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₂ + calc + _≤36*(2:ℝ)^K*(2:ℝ)^K*A*C*H:=by dsimp only [D];gcongr + _= _:=by rw [show 2*K=K+K by omega,pow_add];ring + calc + _≤P*(D*S):=mul_le_mul_of_nonneg_left he hP + _≤D*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by + convert hbnd using 1 ; dsimp only [P,S] ; rw [hYe,hXe,hLe] ; ring + _≤((36*(2:ℝ)^(2*K)*C)*A*H)*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by gcongr + _= _:=by dsimp only [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadius.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadius.lean new file mode 100644 index 0000000000000000000000000000000000000000..68a7639200d5d61f1e8a86801addc7f15974a946 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadius.lean @@ -0,0 +1,145 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadius +import OAI.NumberTheory.DirichletL.Descent.PrioritySourceBudget + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_retained_moving_radius + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,henergy⟩:= + actual_priority_source_moving_radius (ι:=ι) (σ:=σ) om Φ lo hi hlo hsupport negative B₀ hB₀ J K εmass hεmass + obtain ⟨Cbin,hCbin,hbudget⟩:=priority_source_scalar_budget caps hcaps + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,36*(2:ℝ)^(2*K)*C,Cbin,by positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b + ρ t w labels A hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have he:=henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + let H:ℝ:=(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J) + have hheight:(1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J=H:=by + cases negative <;> simp [priorityHeight,H,two_mul,pow_add] + let D:ℝ:=36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A*C*H + have hD:0≤D:=by dsimp [D,H];positivity + let S:ℝ:=∑d∈keys p source,priorityCellScalar Z Y L X ell Ractive j tcount eta εchild εmass Bfirst (secondRayCoefficient z) d + have hfactor: + (∑d∈keys p source,(Real.exp (6*L)*‖(Y:ℂ)*secondRayCoefficient z* + ((scales d 1*scales d 2*Z^(secondCellColumnExponent Z X d):ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel d)+εchild))* + Z^((ell+Ractive/2-j+tcount+secondCellExponent Z d 0-secondCellExponent Z d 1+11*eta/2)*(1+εmass)))* + (C*((1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J))))=D*S:=by + dsimp only [S] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + rw [hheight,hVe d] + dsimp only [D,priorityCellScalar,secondCount] + ring + simp only [pow_zero,div_one] at he + rw [hfactor] at he + have hbnd:=hbudget p hp source Z M r ell V delta Acol Bfirst Ractive j tcount eta tau pi εchild εmass b D + (secondRayCoefficient z) hZ2 hD hb hthreshold + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) hnorm + (by simpa only [hXe] using hgeom) hmass + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + have hP:0≤P:=by dsimp [P];positivity + have hconst:D≤(36*(2:ℝ)^(2*K)*C)*A*H:=by + have h1:(2:ℝ)^slots₁.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₁ + have h2:(2:ℝ)^slots₂.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₂ + calc + _≤36*(2:ℝ)^K*(2:ℝ)^K*A*C*H:=by dsimp only [D];gcongr + _= _:=by rw [show 2*K=K+K by omega,pow_add];ring + calc + _≤P*(D*S):=mul_le_mul_of_nonneg_left he hP + _≤D*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by + convert hbnd using 1 ; dsimp only [P,S] ; rw [hYe,hXe,hLe] ; ring + _≤((36*(2:ℝ)^(2*K)*C)*A*H)*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by gcongr + _= _:=by dsimp only [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadiusWindowOrder.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadiusWindowOrder.lean new file mode 100644 index 0000000000000000000000000000000000000000..c9add9dd3fca7fb8ede2e17e5406288b2b7aef1c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadiusWindowOrder.lean @@ -0,0 +1,149 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadiusWindowOrder +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadius +import OAI.NumberTheory.DirichletL.Descent.PrioritySourceBudget + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_retained_moving_radius_window_order + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_priority_source_moving_radius_window_order (ι:=ι) (σ:=σ) om Φ lo hi hlo hsupport negative B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩:=hordered J + obtain ⟨Cbin,hCbin,hbudget⟩:=priority_source_scalar_budget caps hcaps + refine ⟨36*(2:ℝ)^(2*K)*C,Cbin,by positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b + ρ t w labels A hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have he:=henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + let H:ℝ:=(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J) + have hheight:(1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J=H:=by + cases negative <;> simp [priorityHeight,H,two_mul,pow_add] + let D:ℝ:=36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A*C*H + have hD:0≤D:=by dsimp [D,H];positivity + let S:ℝ:=∑d∈keys p source,priorityCellScalar Z Y L X ell Ractive j tcount eta εchild εmass Bfirst (secondRayCoefficient z) d + have hfactor: + (∑d∈keys p source,(Real.exp (6*L)*‖(Y:ℂ)*secondRayCoefficient z* + ((scales d 1*scales d 2*Z^(secondCellColumnExponent Z X d):ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel d)+εchild))* + Z^((ell+Ractive/2-j+tcount+secondCellExponent Z d 0-secondCellExponent Z d 1+11*eta/2)*(1+εmass)))* + (C*((1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J))))=D*S:=by + dsimp only [S] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + rw [hheight,hVe d] + dsimp only [D,priorityCellScalar,secondCount] + ring + simp only [pow_zero,div_one] at he + rw [hfactor] at he + have hbnd:=hbudget p hp source Z M r ell V delta Acol Bfirst Ractive j tcount eta tau pi εchild εmass b D + (secondRayCoefficient z) hZ2 hD hb hthreshold + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) hnorm + (by simpa only [hXe] using hgeom) hmass + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + have hP:0≤P:=by dsimp [P];positivity + have hconst:D≤(36*(2:ℝ)^(2*K)*C)*A*H:=by + have h1:(2:ℝ)^slots₁.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₁ + have h2:(2:ℝ)^slots₂.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₂ + calc + _≤36*(2:ℝ)^K*(2:ℝ)^K*A*C*H:=by dsimp only [D];gcongr + _= _:=by rw [show 2*K=K+K by omega,pow_add];ring + calc + _≤P*(D*S):=mul_le_mul_of_nonneg_left he hP + _≤D*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by + convert hbnd using 1 ; dsimp only [P,S] ; rw [hYe,hXe,hLe] ; ring + _≤((36*(2:ℝ)^(2*K)*C)*A*H)*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by gcongr + _= _:=by dsimp only [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadiusWindowOrderUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadiusWindowOrderUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..47322cdce9608471ec054aea640adee01b595d98 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PriorityRetainedMovingRadiusWindowOrderUniform.lean @@ -0,0 +1,150 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityRetainedMovingRadiusWindowOrder +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadiusWindowOrderUniform +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadiusWindowOrder +import OAI.NumberTheory.DirichletL.Descent.PriorityMovingRadius +import OAI.NumberTheory.DirichletL.Descent.PrioritySourceBudget + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +theorem actual_priority_retained_moving_radius_window_order_uniform_types + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y:ℝ) (R:BlockIndex→ℝ) (L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R (index p x))) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 (R d)) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,hordered⟩:= + actual_priority_source_moving_radius_window_order_uniform_types om Φ lo hi hlo hsupport negative B₀ hB₀ K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩:=hordered J + obtain ⟨Cbin,hCbin,hbudget⟩:=priority_source_scalar_budget caps hcaps + refine ⟨36*(2:ℝ)^(2*K)*C,Cbin,by positivity,hCbin,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b + ρ t w labels A hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have he:=henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + let H:ℝ:=(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J) + have hheight:(1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J=H:=by + cases negative <;> simp [priorityHeight,H,two_mul,pow_add] + let D:ℝ:=36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A*C*H + have hD:0≤D:=by dsimp [D,H];positivity + let S:ℝ:=∑d∈keys p source,priorityCellScalar Z Y L X ell Ractive j tcount eta εchild εmass Bfirst (secondRayCoefficient z) d + have hfactor: + (∑d∈keys p source,(Real.exp (6*L)*‖(Y:ℂ)*secondRayCoefficient z* + ((scales d 1*scales d 2*Z^(secondCellColumnExponent Z X d):ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+Vlabel d)+εchild))* + Z^((ell+Ractive/2-j+tcount+secondCellExponent Z d 0-secondCellExponent Z d 1+11*eta/2)*(1+εmass)))* + (C*((1+‖-priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J* + (1+‖priorityHeight negative t‖)^InverseClippingProfiles.momentOrder J))))=D*S:=by + dsimp only [S] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + rw [hheight,hVe d] + dsimp only [D,priorityCellScalar,secondCount] + ring + simp only [pow_zero,div_one] at he + rw [hfactor] at he + have hbnd:=hbudget p hp source Z M r ell V delta Acol Bfirst Ractive j tcount eta tau pi εchild εmass b D + (secondRayCoefficient z) hZ2 hD hb hthreshold + (fun x hx=>frequency_ne_zero_of_gate _ _ (hrows x hx)) hnorm + (by simpa only [hXe] using hgeom) hmass + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + have hP:0≤P:=by dsimp [P];positivity + have hconst:D≤(36*(2:ℝ)^(2*K)*C)*A*H:=by + have h1:(2:ℝ)^slots₁.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₁ + have h2:(2:ℝ)^slots₂.card≤2^K:=pow_le_pow_right₀ (by norm_num) hslots₂ + calc + _≤36*(2:ℝ)^K*(2:ℝ)^K*A*C*H:=by dsimp only [D];gcongr + _= _:=by rw [show 2*K=K+K by omega,pow_add];ring + calc + _≤P*(D*S):=mul_le_mul_of_nonneg_left he hP + _≤D*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by + convert hbnd using 1 ; dsimp only [P,S] ; rw [hYe,hXe,hLe] ; ring + _≤((36*(2:ℝ)^(2*K)*C)*A*H)*‖secondRayCoefficient z‖*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild):=by gcongr + _= _:=by dsimp only [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PrioritySourceBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PrioritySourceBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..e7603738c0cd543f0755e69c52ce2069553a0065 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PrioritySourceBudget.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityCellBudget + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondSourceBlocks +local notation "O"=>ActualEisensteinCubic.O + +def priorityCellScalar (Z Y L X ell Ractive j t eta eps epsmass B:ℝ) (ray:ℂ) (d:BlockIndex):ℝ := + (Real.exp (6*L)*‖(Y:ℂ)*ray*((scales d 1*scales d 2*Z^(secondCellColumnExponent Z X d):ℝ):ℂ)⁻¹‖)* + Z^((secondCount ell Ractive j t (secondCellExponent Z d 0) (secondCellExponent Z d 1)+11*eta/2)*(1+epsmass))* + Z^(2*(max 0 (secondCellColumnExponent Z X d)+ + (secondFormalLabel B (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta))+eps) + +theorem source_cell_joint_bound {ι:Type*} [DecidableEq ι] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + {Jo Jn:ℕ} (source:Finset (MarkedSecondSource ι Jo Jn)) (hk:∀x∈source,x.second.frequency≠0) + (b X:ℝ) (hgeom:∀x∈source,primeProductNorm p x.second.sourceCommon* + primeProductNorm p x.second.overlap≤b*X) (d:BlockIndex) (hd:d∈keys p source): + scales d 0*scales d 2≤b*X := by + obtain ⟨x,hx⟩:=(mem_keys_iff p source d).mp hd + have h0:scales d 0≤primeProductNorm p x.second.sourceCommon:=by + simpa [outerNorms,scales] using (le_div_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 0).1 + have h2:scales d 2≤primeProductNorm p x.second.overlap:=by + simpa [outerNorms,scales] using (le_div_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 2).1 + exact (mul_le_mul h0 h2 (dyadScale_pos _).le (primeProductNorm_pos p hp _).le).trans + (hgeom x (cell_subset p source d hx)) + +theorem priority_source_scalar_budget (caps:Fin 4→ℝ) (hcaps:∀i,0≤caps i) : + ∃ Cbin:ℝ,0≤Cbin ∧ ∀ {ι:Type*} [DecidableEq ι] + (p:ι→O) (_hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + {Jo Jn:ℕ} (source:Finset (MarkedSecondSource ι Jo Jn)) + (Z M r ell V delta A B Ractive j t eta tau pi eps epsmass b C:ℝ) + (ray:ℂ), 2≤Z → 0≤C → 1≤b → b≤Z^(6*eta) → + (∀x∈source,x.second.frequency≠0) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*Z^(r-A-B-t)) → + (∀d∈keys p source,epsmass*(secondCount ell Ractive j t (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + C*Z^(firstKappa M r ell V delta A B Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z))* + (∑d∈keys p source,priorityCellScalar Z (Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau)) + (eta*Real.log Z) (Z^(r-A-B-t)) ell Ractive j t eta eps epsmass B ray d) ≤ + C*‖ray‖*(1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+eps) := by + refine ⟨capConstant caps,capConstant_nonneg caps hcaps,?_⟩ + intro ι _ p hp _ Jo Jn source Z M r ell V delta A B Ractive j t eta tau pi eps epsmass b C + ray hZ hC hb hthreshold hk hnorm hgeom hmass + have hZ':1by positivity) (fun i _=>cap_bin_bound caps hcaps Z hZ i) + _= _:=by simp + rw [Finset.mul_sum] + calc + _≤∑_d∈keys p source,C*‖ray‖*Z^(r+3*ell+V+48*eta+tau+pi+eps):=by + apply Finset.sum_le_sum + intro d hd + have he:=priority_cell_physical_budget Z hZ' d M r ell V delta A B Ractive j t eta tau pi eps epsmass b C + ray hC hb (source_cell_joint_bound p hp source hk b _ hgeom d hd) hthreshold (hmass d hd) + convert he using 1 ; dsimp only [priorityCellScalar] ; ring + _= ((keys p source).card:ℝ)*(C*‖ray‖*Z^(r+3*ell+V+48*eta+tau+pi+eps)):=by simp + _≤ (1+capConstant caps*Real.log Z)^4*(C*‖ray‖*Z^(r+3*ell+V+48*eta+tau+pi+eps)):= + mul_le_mul_of_nonneg_right hcard (by positivity) + _= _:=by ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/PrioritySourceEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/PrioritySourceEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..afa3803a23fc7504944ebb4729f60eead5cf8648 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/PrioritySourceEnergy.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityCellEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondCellParameters + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_priority_source_recursive + (om Φ:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (Y R L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) Φ Y X)‖ ≤ + ∑d∈keys p source,(Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*(((scales d 1)*(scales d 2)*(Z^(secondCellColumnExponent Z X d)) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 (secondCellColumnExponent Z X d)+(Vlabel d))+εchild))* + Z^((ell+Ractive/2-j+tcount+(secondCellExponent Z d 0)-(secondCellExponent Z d 1)+11*eta/2)*(1+εmass)))* + (C*((1+‖(-priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J * + (1+‖(priorityHeight negative t)‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*(scales d 3)/((scales d 1)*(scales d 2)^2*(Z^(secondCellColumnExponent Z X d))^2))^0)) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,henergy⟩:= + actual_priority_cell_recursive (ι:=ι) (σ:=σ) om Φ lo hi hlo hsupport negative B₀ hB₀ 0 J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,hC,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X εchild Vlabel ell Ractive j tcount eta ρ t w labels A + hd₁ hd₂ hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hz:0frequency_ne_zero_of_gate _ _ (hrows x hx) + rw [physical_source_partition p hp hcop hg source pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ w] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro d hd + have hin : cell p source d⊆source:=cell_subset p source d + have hcommon:∀x∈cell p source d,primeProductNorm p x.second.sourceCommon≤Z^(secondCellExponent Z d 0+eta):=by + intro x hx + have hr:primeProductNorm p x.second.sourceCommon≤2*scales d 0:= + (div_le_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 0).2.le + apply hr.trans + rw [Real.rpow_add hz,second_cell_scale_rpow Z d 0 hZ] + simpa only [mul_comm] using mul_le_mul_of_nonneg_left hbin (show 0≤scales d 0 from (dyadScale_pos _).le) + have hdiv:∀x∈cell p source d,Z^(secondCellExponent Z d 1-eta)≤primeProductNorm p x.second.divisor:=by + intro x hx + have hr:scales d 1≤primeProductNorm p x.second.divisor:=by + simpa [outerNorms,scales] using (le_div_iff₀ (dyadScale_pos _)).mp (cell_ratios p hp source hk d x hx 1).1 + have hh:Z^(secondCellExponent Z d 1-eta)≤Z^(secondCellExponent Z d 1):= + Real.rpow_le_rpow_of_exponent_le hZ.le (by linarith) + rw [second_cell_scale_rpow Z d 1 hZ] at hh + exact hh.trans hr + exact henergy p hp hcop hg hpr hinj hc (cell p source d) (cell_conditions p source hs d) d + (fun x hx=>(mem_cell p source d x).mp hx |>.2) pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + deleted₁ deleted₂ Y R L Z X (Vlabel d) εchild ell Ractive j tcount + (secondCellExponent Z d 0) (secondCellExponent Z d 1) eta ρ t w (labels d) A + (fun x hx=>hd₁ x (hin hx)) (fun x hx=>hd₂ x (hin hx)) hρ hL hZ hX hY + (fun x hx=>hrows x (hin hx)) (fun x hx=>hcube₁ x (hin hx)) (fun x hx=>hcube₂ x (hin hx)) + (fun x hx=>hactive x (hin hx)) (fun x hx=>hj x (hin hx)) (fun x hx=>hquot x (hin hx)) + hcommon hdiv hΨ (fun x hx=>hw x (hin hx)) ha₁ ha₂ (hlabels d hd) ho hslots₁ hslots₂ hA + (hleft d hd) (hright d hd) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ProfileIntegral.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ProfileIntegral.lean new file mode 100644 index 0000000000000000000000000000000000000000..2374136a4f287dbfde8b35cd60fb5afeff91a9b4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ProfileIntegral.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Descent.FullProfile + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section +variable {ι : Type*} [Fintype ι] + +lemma full_density_integrable (g : ι → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) : + Integrable (fullProfileDensity g b₁ b₂ b₃) := by + have hc : Continuous (fullProfileDensity g b₁ b₂ b₃) := by + unfold fullProfileDensity coordinateDensity tripleCoefficient + fun_prop + apply (integrable_norm_iff hc.aestronglyMeasurable).mp + simpa only [tripleHeight,coordinateHeight,pow_zero,Finset.prod_const_one,mul_one,one_mul] using + fullProfileDensity_weighted_integrable g b₁ b₂ b₃ 0 + +lemma full_density_mode_integrable (g : ι → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) + (a₁ a₂ ak y : ι → ℝ) : + Integrable (fun p : Frequency × (ι → ℝ) => fullProfileDensity g b₁ b₂ b₃ p * + pureProfileMode a₁ a₂ ak y p.1 p.2) := by + have hc : Continuous (fun p : Frequency × (ι → ℝ) => pureProfileMode a₁ a₂ ak y p.1 p.2) := by + unfold pureProfileMode logPhase + fun_prop + exact (full_density_integrable g b₁ b₂ b₃).mul_bdd hc.aestronglyMeasurable + (Filter.Eventually.of_forall (fun p => (pureProfileMode_norm a₁ a₂ ak y p.1 p.2).le)) + +theorem full_density_mode_fubini (g : ι → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) + (a₁ a₂ ak y : ι → ℝ) : + (∫ p : Frequency × (ι → ℝ), fullProfileDensity g b₁ b₂ b₃ p * + pureProfileMode a₁ a₂ ak y p.1 p.2) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : ι → ℝ, + fullProfileDensity g b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + pureProfileMode a₁ a₂ ak y (t₁,t₂,t₃) u := by + let f : Frequency × (ι → ℝ) → ℂ := fun p => fullProfileDensity g b₁ b₂ b₃ p * + pureProfileMode a₁ a₂ ak y p.1 p.2 + have hf : Integrable f (volume.prod volume) := by + simpa only [Measure.volume_eq_prod] using full_density_mode_integrable g b₁ b₂ b₃ a₁ a₂ ak y + change (∫ p, f p) = _ + rw [Measure.volume_eq_prod, integral_prod _ hf] + have ht : Integrable (fun t : Frequency => ∫ u, f (t,u)) (volume.prod volume) := by + simpa only [Measure.volume_eq_prod] using hf.integral_prod_left + rw [Measure.volume_eq_prod, integral_prod _ ht] + apply integral_congr_ae + filter_upwards [ht.prod_right_ae] with t₁ ht₁ + simpa only [Measure.volume_eq_prod] using integral_prod (fun t : ℝ×ℝ => ∫ u, f ((t₁,t.1,t.2),u)) ht₁ + +theorem full_density_finite_sum {κ : Type*} (s : Finset κ) + (g : ι → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) (a₁ a₂ ak : ι → ℝ) + (c : κ → ℂ) (y : κ → ι → ℝ) : + (∑ k ∈ s, c k * ∫ p : Frequency × (ι → ℝ), fullProfileDensity g b₁ b₂ b₃ p * + pureProfileMode a₁ a₂ ak (y k) p.1 p.2) = + ∫ p : Frequency × (ι → ℝ), fullProfileDensity g b₁ b₂ b₃ p * + ∑ k ∈ s, c k * pureProfileMode a₁ a₂ ak (y k) p.1 p.2 := by + simp only [← integral_const_mul] + rw [← integral_finsetSum s (fun k hk => + (full_density_mode_integrable g b₁ b₂ b₃ a₁ a₂ ak (y k)).const_mul (c k))] + apply integral_congr_ae + filter_upwards with p + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro k hk + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Quadratic.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Quadratic.lean new file mode 100644 index 0000000000000000000000000000000000000000..ccd714507faa6138732fc11ef140afaf5fabfff0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Quadratic.lean @@ -0,0 +1,232 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Descent.IdealMasks +import OAI.NumberTheory.DirichletL.Descent.SieveComposition + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem finite_family_quadratic_hybrid_orientation : + ∀ ε : ℝ, 0 < ε → ∃ C : ℝ, 0 < C ∧ + ∀ M N : ℝ, 1 ≤ M → 1 ≤ N → + ∀ {m n : Type*} [Fintype m] [Fintype n], + ∀ (rows : m → Ideal Eis) (cols : n → Ideal Eis), + Function.Injective rows → Function.Injective cols → + (∀ i, Admissible (rows i) ∧ (Ideal.absNorm (rows i) : ℝ) ≤ M) → + (∀ j, Admissible (cols j) ∧ (Ideal.absNorm (cols j) : ℝ) ≤ N) → + ∀ a : n → ℂ, + (∑ i, ‖∑ j, quadraticRow (rows i) (primaryGenerator (cols j)) * a j‖ ^ 2) ≤ + C * (M * N) ^ ε * (M + N) * ∑ j, ‖a j‖ ^ 2 := by + intro ε hε + obtain ⟨C, hC, hsharp⟩ := sieveNorm_sharp ε hε + refine ⟨C, hC, ?_⟩ + intro M N hM hN m n _ _ rows cols hr hc hrows hcols a + let B : Matrix n m ℂ := fun j i => quadraticRow (rows i) (primaryGenerator (cols j)) + have hB : ‖FiniteSieveOperator.operator B‖ ^ 2 ≤ sieveNorm N M := + family_squared_norm_le cols rows hc hr N M hcols hrows + have hBT : B.conjTranspose = + (fun i j => quadraticRow (rows i) (primaryGenerator (cols j))) := by + ext i j + exact canonical_quadraticRow_star (rows i) (hrows i).1 _ + have he := FiniteSieveOperator.energy_bound B.conjTranspose a + rw [FiniteSieveOperator.operator_conjTranspose_norm, hBT] at he + have henergy : 0 ≤ ∑ j, ‖a j‖ ^ 2 := Finset.sum_nonneg fun _ _ => sq_nonneg _ + apply he.trans + calc + _ ≤ sieveNorm N M * ∑ j, ‖a j‖ ^ 2 := mul_le_mul_of_nonneg_right hB henergy + _ ≤ (C * (N * M) ^ ε * (N + M)) * ∑ j, ‖a j‖ ^ 2 := + mul_le_mul_of_nonneg_right (hsharp N M hN hM) henergy + _ = _ := by rw [mul_comm N M, add_comm N M] + +theorem finite_squarefree_quadratic_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X : ℝ, 1 ≤ K → 1 ≤ X → + ∀ (rows cols : Finset (Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ J ∈ cols, Squarefree J ∧ (Ideal.absNorm J : ℝ) ≤ X) → + ∀ a : Ideal Eis → ℂ, + (∑ k ∈ rows, ‖∑ J ∈ cols, quadraticRow k (primaryGenerator J) * a J‖ ^ 2) ≤ + C * (K * X) ^ ε * (K + X) * ∑ J ∈ cols, ‖a J‖ ^ 2 := by + obtain ⟨C, hC, hsharp⟩ := sieveNorm_sharp ε hε + refine ⟨4 * C, by positivity, ?_⟩ + intro K X hK hX rows cols hrows hcols a + have hf := squarefree_all_column_energy (fun J : cols => J.val) Subtype.val_injective X K + (fun J => hcols J.val J.property) (fun J => a J.val) + have hi (k : idealRange K) : + (∑ J : cols, quadraticRow k.val (primaryGenerator J.val) * a J.val) = + ∑ J ∈ cols, quadraticRow k.val (primaryGenerator J) * a J := + Finset.sum_coe_sort cols (fun J => quadraticRow k.val (primaryGenerator J) * a J) + simp_rw [hi] at hf + rw [Finset.sum_coe_sort (idealRange K) + (fun k => ‖∑ J ∈ cols, quadraticRow k (primaryGenerator J) * a J‖ ^ 2), + Finset.sum_coe_sort cols (fun J => ‖a J‖ ^ 2)] at hf + have hr : rows ⊆ idealRange K := fun k hk => mem_idealRange.mpr (hrows k hk) + have he : (∑ k ∈ rows, ‖∑ J ∈ cols, quadraticRow k (primaryGenerator J) * a J‖ ^ 2) ≤ + ∑ k ∈ idealRange K, ‖∑ J ∈ cols, quadraticRow k (primaryGenerator J) * a J‖ ^ 2 := + Finset.sum_le_sum_of_subset_of_nonneg hr (by intro k _ _; exact sq_nonneg _) + apply (he.trans hf).trans + calc + _ ≤ 4 * (C * (X * K) ^ ε * (X + K)) * ∑ J ∈ cols, ‖a J‖ ^ 2 := by + apply mul_le_mul_of_nonneg_right _ (Finset.sum_nonneg fun _ _ => sq_nonneg _) + exact mul_le_mul_of_nonneg_left (hsharp X K hX hK) (by norm_num) + _ = _ := by rw [mul_comm X K, add_comm X K]; ring + +theorem quadratic_squarefree_product_column_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X : ℝ, 1 ≤ K → 1 ≤ X → + ∀ (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ pairs, Squarefree (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + ∀ a : Ideal Eis × Ideal Eis → ℂ, + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (p.1 * p.2)) * a p‖ ^ 2) ≤ + C * (K * X) ^ ε * (K + X) * ∑ p ∈ pairs, ‖a p‖ ^ 2 := by + have hhalf : 0 < ε / 2 := by positivity + obtain ⟨Cq, hCq, hquad⟩ := finite_squarefree_quadratic_energy (ε / 2) hhalf + obtain ⟨Cd, hCd, hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power (ε / 2) hhalf + refine ⟨Cq * Cd, mul_pos hCq hCd, ?_⟩ + intro K X hK hX rows pairs hrows hpairs a + let target := pairs.image (fun p => p.1 * p.2) + have ht (J : Ideal Eis) (hJ : J ∈ target) : + Squarefree J ∧ (Ideal.absNorm J : ℝ) ≤ X := by + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hJ + exact hpairs p hp + have hfiber (J : Ideal Eis) (hJ : J ∈ target) : + ((pairs.filter (fun p => p.1 * p.2 = J)).card : ℝ) ≤ Cd * X ^ (ε / 2) := by + apply (Nat.cast_le.mpr (product_fiber_card pairs J (ht J hJ).1.ne_zero)).trans + exact (hdiv J (ht J hJ).1.ne_zero).trans (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow (Nat.cast_nonneg _) (ht J hJ).2 hhalf.le) hCd.le) + have he := column_fiber_sieve rows pairs target (fun p => p.1 * p.2) + (fun k J => quadraticRow k (primaryGenerator J)) a + (Cq * (K * X) ^ (ε / 2) * (K + X)) (Cd * X ^ (ε / 2)) (by positivity) + (fun p hp => Finset.mem_image_of_mem _ hp) hfiber + (hquad K X hK hX rows target hrows ht) + apply he.trans + have hKX : 0 < K * X := mul_pos (by linarith) (by linarith) + have hpow : (K * X) ^ (ε / 2) * X ^ (ε / 2) ≤ (K * X) ^ ε := by + calc + _ ≤ (K * X) ^ (ε / 2) * (K * X) ^ (ε / 2) := by + apply mul_le_mul_of_nonneg_left _ (Real.rpow_nonneg hKX.le _) + exact Real.rpow_le_rpow (by linarith) (le_mul_of_one_le_left (by linarith) hK) hhalf.le + _ = _ := by rw [← Real.rpow_add hKX]; congr 1 ; ring + calc + _ = (Cq * Cd) * ((K * X) ^ (ε / 2) * X ^ (ε / 2)) * (K + X) * + ∑ p ∈ pairs, ‖a p‖ ^ 2 := by ring + _ ≤ _ := by gcongr + +theorem quadratic_product_column_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X : ℝ, 1 ≤ K → 1 ≤ X → + ∀ (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ pairs, Admissible (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + ∀ a : Ideal Eis × Ideal Eis → ℂ, + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (p.1 * p.2)) * a p‖ ^ 2) ≤ + C * (K * X) ^ ε * (K + X) * ∑ p ∈ pairs, ‖a p‖ ^ 2 := by + have hhalf : 0 < ε / 2 := by positivity + obtain ⟨Cq, hCq, hquadratic⟩ := finite_family_quadratic_hybrid_orientation (ε / 2) hhalf + obtain ⟨Cd, hCd, hdiv⟩ := IdealDivisorBound.ideal_divisor_small_power (ε / 2) hhalf + refine ⟨Cq * Cd, mul_pos hCq hCd, ?_⟩ + intro K X hK hX rows pairs hrows hpairs a + let target := pairs.image (fun p => p.1 * p.2) + have ht (J : Ideal Eis) (hJ : J ∈ target) : + Admissible J ∧ (Ideal.absNorm J : ℝ) ≤ X := by + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hJ + exact hpairs p hp + have hquad (f : Ideal Eis → ℂ) : + (∑ k ∈ rows, ‖∑ J ∈ target, quadraticRow k (primaryGenerator J) * f J‖ ^ 2) ≤ + (Cq * (K * X) ^ (ε / 2) * (K + X)) * ∑ J ∈ target, ‖f J‖ ^ 2 := by + have he := hquadratic K X hK hX + (fun k : rows => k.val) (fun J : target => J.val) + Subtype.val_injective Subtype.val_injective + (fun k => hrows k.val k.property) (fun J => ht J.val J.property) + (fun J => f J.val) + have hi (k : rows) : + (∑ J : target, quadraticRow k.val (primaryGenerator J.val) * f J.val) = + ∑ J ∈ target, quadraticRow k.val (primaryGenerator J) * f J := + Finset.sum_coe_sort target (fun J => quadraticRow k.val (primaryGenerator J) * f J) + simp_rw [hi] at he + rw [Finset.sum_coe_sort rows + (fun k => ‖∑ J ∈ target, quadraticRow k (primaryGenerator J) * f J‖ ^ 2), + Finset.sum_coe_sort target (fun J => ‖f J‖ ^ 2)] at he + exact he + have hfiber (J : Ideal Eis) (hJ : J ∈ target) : + ((pairs.filter (fun p => p.1 * p.2 = J)).card : ℝ) ≤ Cd * X ^ (ε / 2) := by + apply (Nat.cast_le.mpr (CanonicalQuadraticSieve.product_fiber_card pairs J (ht J hJ).1.1)).trans + exact (hdiv J (ht J hJ).1.1).trans + (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow (Nat.cast_nonneg _) (ht J hJ).2 hhalf.le) hCd.le) + have he := column_fiber_sieve rows pairs target (fun p => p.1 * p.2) + (fun k J => quadraticRow k (primaryGenerator J)) a + (Cq * (K * X) ^ (ε / 2) * (K + X)) (Cd * X ^ (ε / 2)) (by positivity) + (fun p hp => Finset.mem_image_of_mem _ hp) hfiber hquad + apply he.trans + have hKX : 0 < K * X := mul_pos (by linarith) (by linarith) + have hpow : (K * X) ^ (ε / 2) * X ^ (ε / 2) ≤ (K * X) ^ ε := by + calc + _ ≤ (K * X) ^ (ε / 2) * (K * X) ^ (ε / 2) := by + apply mul_le_mul_of_nonneg_left _ (Real.rpow_nonneg hKX.le _) + exact Real.rpow_le_rpow (by linarith) (le_mul_of_one_le_left (by linarith) hK) hhalf.le + _ = _ := by rw [← Real.rpow_add hKX]; congr 1 ; ring + calc + _ = (Cq * Cd) * ((K * X) ^ (ε / 2) * X ^ (ε / 2)) * (K + X) * + ∑ p ∈ pairs, ‖a p‖ ^ 2 := by ring + _ ≤ _ := by gcongr + +theorem quadratic_fixed_factor_energy + (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)) + (hrows : ∀ k ∈ rows, Admissible k) (B : Ideal Eis) + (a : Ideal Eis × Ideal Eis → ℂ) : + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (B * (p.1 * p.2))) * a p‖ ^ 2) ≤ + ∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (p.1 * p.2)) * a p‖ ^ 2 := by + apply Finset.sum_le_sum + intro k hk + have he : (∑ p ∈ pairs, + quadraticRow k (primaryGenerator (B * (p.1 * p.2))) * a p) = + quadraticRow k (primaryGenerator B) * ∑ p ∈ pairs, + quadraticRow k (primaryGenerator (p.1 * p.2)) * a p := by + simp only [primaryGenerator_mul, + canonical_quadraticRow_argument_mul k (hrows k hk), Finset.mul_sum, mul_assoc] + rw [he] + apply pow_le_pow_left₀ (norm_nonneg _) + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (quadraticRow_norm_le_one k _) + +theorem quadratic_product_column_energy_fixed_factor (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X : ℝ, 1 ≤ K → 1 ≤ X → + ∀ (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ pairs, Admissible (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + ∀ (B : Ideal Eis) (a : Ideal Eis × Ideal Eis → ℂ), + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (B * (p.1 * p.2))) * a p‖ ^ 2) ≤ + C * (K * X) ^ ε * (K + X) * ∑ p ∈ pairs, ‖a p‖ ^ 2 := by + obtain ⟨C, hC, hb⟩ := quadratic_product_column_energy ε hε + refine ⟨C, hC, ?_⟩ + intro K X hK hX rows pairs hrows hpairs B a + exact (quadratic_fixed_factor_energy rows pairs (fun k hk => (hrows k hk).1) B a).trans + (hb K X hK hX rows pairs hrows hpairs a) + +theorem quadratic_squarefree_product_energy_fixed_factor (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K X : ℝ, 1 ≤ K → 1 ≤ X → + ∀ (rows : Finset (Ideal Eis)) (pairs : Finset (Ideal Eis × Ideal Eis)), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ pairs, Squarefree (p.1 * p.2) ∧ (Ideal.absNorm (p.1 * p.2) : ℝ) ≤ X) → + ∀ (B : Ideal Eis) (a : Ideal Eis × Ideal Eis → ℂ), + (∑ k ∈ rows, ‖∑ p ∈ pairs, + quadraticRow k (primaryGenerator (B * (p.1 * p.2))) * a p‖ ^ 2) ≤ + C * (K * X) ^ ε * (K + X) * ∑ p ∈ pairs, ‖a p‖ ^ 2 := by + obtain ⟨C, hC, hb⟩ := quadratic_squarefree_product_column_energy ε hε + refine ⟨C, hC, ?_⟩ + intro K X hK hX rows pairs hrows hpairs B a + exact (quadratic_fixed_factor_energy rows pairs (fun k hk => (hrows k hk).1) B a).trans + (hb K X hK hX rows pairs hrows hpairs a) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Quotients.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Quotients.lean new file mode 100644 index 0000000000000000000000000000000000000000..2d4e172ef9cf719f91d3a02574ccc32e6ebb1d8d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Quotients.lean @@ -0,0 +1,112 @@ +import OAI.NumberTheory.DirichletL.Descent.Hybrid +import OAI.NumberTheory.DirichletL.CubicSieve.Gcd + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def quotientSupport (D : Ideal Eis) (S : Finset (Ideal Eis)) : Finset (Ideal Eis) := + (S.filter (fun I => D ∣ I)).image (idealQuotient D) + +@[simp] theorem mem_quotientSupport (D J : Ideal Eis) (hD : D ≠ 0) + (S : Finset (Ideal Eis)) : + J ∈ quotientSupport D S ↔ D * J ∈ S := by + constructor + · intro hJ + obtain ⟨I, hI, he⟩ := Finset.mem_image.mp hJ + obtain ⟨hIS, hDI⟩ := Finset.mem_filter.mp hI + rw [← he, idealQuotient_mul hDI] + exact hIS + · intro hJ + refine Finset.mem_image.mpr ⟨D * J, Finset.mem_filter.mpr ⟨hJ, dvd_mul_right _ _⟩, ?_⟩ + exact mul_left_cancel₀ hD (idealQuotient_mul (dvd_mul_right D J)) + +theorem sum_quotientSupport {A : Type*} [AddCommMonoid A] + (D : Ideal Eis) (S : Finset (Ideal Eis)) (f : Ideal Eis → A) : + (∑ I ∈ S with D ∣ I, f I) = ∑ J ∈ quotientSupport D S, f (D * J) := by + rw [quotientSupport, Finset.sum_image] + · apply Finset.sum_congr rfl + intro I hI + rw [idealQuotient_mul (Finset.mem_filter.mp hI).2] + · intro I hI J hJ he + exact idealQuotient_injective_on D (Finset.mem_filter.mp hI).2 + (Finset.mem_filter.mp hJ).2 he + +theorem quotientSupport_nonzero (D : Ideal Eis) (hD : D ≠ 0) + (S : Finset (Ideal Eis)) (hS : ∀ I ∈ S, I ≠ 0) + (J : Ideal Eis) (hJ : J ∈ quotientSupport D S) : J ≠ 0 := by + have h := hS (D * J) ((mem_quotientSupport D J hD S).mp hJ) + exact (mul_ne_zero_iff.mp h).2 + +theorem quotientSupport_quadratic_admissible (D : Ideal Eis) (hD : D ≠ 0) + (S : Finset (Ideal Eis)) (hS : ∀ I ∈ S, CanonicalQuadraticSieve.Admissible I) + (J : Ideal Eis) (hJ : J ∈ quotientSupport D S) : + CanonicalQuadraticSieve.Admissible J := + admissible_of_dvd (hS (D * J) ((mem_quotientSupport D J hD S).mp hJ)) + (dvd_mul_left _ _) + +theorem quotientSupport_cubic_admissible (D : Ideal Eis) (hD : D ≠ 0) + (S : Finset (Ideal Eis)) (hS : ∀ I ∈ S, CubicSieve.Admissible I) + (J : Ideal Eis) (hJ : J ∈ quotientSupport D S) : + CubicSieve.Admissible J := + CubicSieve.cubic_admissible_of_dvd + (hS (D * J) ((mem_quotientSupport D J hD S).mp hJ)) (dvd_mul_left _ _) + +theorem quotientSupport_norm_le (D : Ideal Eis) (hD : D ≠ 0) + (S : Finset (Ideal Eis)) (N : ℝ) + (hS0 : ∀ I ∈ S, I ≠ 0) (hS : ∀ I ∈ S, (Ideal.absNorm I : ℝ) ≤ N) + (J : Ideal Eis) (hJ : J ∈ quotientSupport D S) : + (Ideal.absNorm J : ℝ) ≤ N := by + have hDJ := (mem_quotientSupport D J hD S).mp hJ + have hn : Ideal.absNorm J ≤ Ideal.absNorm (D * J) := by + apply Nat.le_of_dvd + · exact Nat.pos_of_ne_zero (fun hz => hS0 _ hDJ (Ideal.absNorm_eq_zero_iff.mp hz)) + · exact map_dvd Ideal.absNorm (dvd_mul_left J D) + exact (Nat.cast_le.mpr hn).trans (hS _ hDJ) + +theorem quotientSupport_shell (D : Ideal Eis) (hD : D ≠ 0) + (S : Finset (Ideal Eis)) (L : ℝ) + (hS0 : ∀ I ∈ S, I ≠ 0) + (hS : ∀ I ∈ S, L ≤ (Ideal.absNorm I : ℝ) ∧ (Ideal.absNorm I : ℝ) ≤ 2 * L) + (J : Ideal Eis) (hJ : J ∈ quotientSupport D S) : + max 1 (L / (Ideal.absNorm D : ℝ)) ≤ (Ideal.absNorm J : ℝ) ∧ + (Ideal.absNorm J : ℝ) ≤ 2 * max 1 (L / (Ideal.absNorm D : ℝ)) := by + have hDJ := (mem_quotientSupport D J hD S).mp hJ + have hnD : 0 < (Ideal.absNorm D : ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun hz => hD (Ideal.absNorm_eq_zero_iff.mp hz)) + have hJ0 := quotientSupport_nonzero D hD S hS0 J hJ + have hnJ : 1 ≤ (Ideal.absNorm J : ℝ) := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr + (fun hz => hJ0 (Ideal.absNorm_eq_zero_iff.mp hz)) + have hs := hS (D * J) hDJ + simp only [map_mul, Nat.cast_mul] at hs + constructor + · refine max_le hnJ ((div_le_iff₀ hnD).mpr ?_) + simpa only [mul_comm] using hs.1 + · have hj : (Ideal.absNorm J : ℝ) ≤ 2 * (L / (Ideal.absNorm D : ℝ)) := by + have hj := (le_div_iff₀ hnD).mpr (show + (Ideal.absNorm J : ℝ) * (Ideal.absNorm D : ℝ) ≤ 2 * L by + simpa only [mul_comm] using hs.2) + simpa only [mul_div_assoc] using hj + exact hj.trans (mul_le_mul_of_nonneg_left (le_max_right _ _) (by norm_num)) + +theorem quotient_hybridCubicCoefficient_energy + (R r h t : Ideal Eis) (hR : R ≠ 0) (S : Finset (Ideal Eis)) (L : ℝ) + (hS0 : ∀ I ∈ S, I ≠ 0) + (hS : ∀ I ∈ S, L ≤ (Ideal.absNorm I : ℝ) ∧ (Ideal.absNorm I : ℝ) ≤ 2 * L) + (a : Ideal Eis → ℂ) (ha : ∀ I ∈ S, ‖a I‖ ≤ 1) : + (∑ P ∈ quotientSupport R S, ‖hybridCubicCoefficient R r h t a P‖ ^ 2) ≤ 256 := by + apply hybridCubicCoefficient_energy R r h t (quotientSupport R S) + (max 1 (L / (Ideal.absNorm R : ℝ))) (le_max_left _ _) + · exact quotientSupport_shell R hR S L hS0 hS + · intro P hP + exact ha (R * P) ((mem_quotientSupport R P hR S).mp hP) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Reconstruction.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Reconstruction.lean new file mode 100644 index 0000000000000000000000000000000000000000..6422b88788713d23ed70907ed210821d751ea340 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Reconstruction.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.Decomposition +import OAI.NumberTheory.DirichletL.Descent.Hybrid + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def supportedHybridRow (S : Finset (Ideal Eis × Ideal Eis)) (Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) : ℂ := + ∑ p ∈ S, ∑ P ∈ Pset, a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * beta p.1 p.2 * + (quadraticRow k (primaryGenerator (p.1 * p.2)) * inverseCubicKernel P p.1 * + (if IsCoprime P p.2 then 1 else 0) * (if IsCoprime k P then 1 else 0)) + +theorem supportedHybridRow_product (nset bset Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) : + supportedHybridRow (nset ×ˢ bset) Pset a beta k = hybridRow Pset nset bset a beta k := by + simp only [supportedHybridRow, hybridRow, hybridInner, Finset.sum_product, + Finset.mul_sum] + conv_lhs => + arg 2 + ext n + rw [Finset.sum_comm] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro P hP + apply Finset.sum_congr rfl + intro n hn + apply Finset.sum_congr rfl + intro b hb + ring + +def reconstructedHybridTerm (a : Ideal Eis → ℂ) + (beta : Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) (P : Ideal Eis) + (d : HybridColumnData) : ℂ := + a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * + beta (d.common * d.residualN) ((d.common * d.residualB) * d.square ^ 2) * + ((if IsCoprime k d.square then 1 else 0) * + (if IsCoprime k (P * d.common) then 1 else 0) * + quadraticRow k (primaryGenerator (d.residualN * d.residualB)) * + inverseCubicKernel P (d.common * d.residualN) * + (if IsCoprime P (d.residualB * d.square) then 1 else 0)) + +theorem supportedHybridRow_reconstruct + (S : Finset (Ideal Eis × Ideal Eis)) (Pset : Finset (Ideal Eis)) + (hS : ∀ p ∈ S, Squarefree p.1 ∧ p.2 ≠ 0 ∧ + primaryGenerator p.1 ≠ 0 ∧ primaryGenerator p.2 ≠ 0) + (hP : ∀ P ∈ Pset, primaryGenerator P ≠ 0) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ) + (k : Ideal Eis) (hk : Admissible k) : + supportedHybridRow S Pset a beta k = + ∑ d ∈ hybridColumnSupport S, ∑ P ∈ Pset, reconstructedHybridTerm a beta k P d := by + unfold supportedHybridRow + rw [hybrid_finite_column_reindex S (fun p hp => ⟨(hS p hp).1, (hS p hp).2.1⟩)] + apply Finset.sum_congr rfl + intro d hd + have hdS := (mem_hybridColumnSupport S d).mp hd + have hdprim := hS d.reconstruct hdS + have hct := (d.primary_factors hdprim.2.2.1 hdprim.2.2.2).2.2.2.2 + apply Finset.sum_congr rfl + intro P hPP + unfold reconstructedHybridTerm + exact congrArg + (fun z : ℂ => a P / (Real.sqrt (Ideal.absNorm P : ℝ) : ℂ) * + beta (d.common * d.residualN) ((d.common * d.residualB) * d.square ^ 2) * z) + (hybrid_original_kernel_decomposition k P + (d.common * d.residualN) ((d.common * d.residualB) * d.square ^ 2) + d.common d.residualN d.residualB d.square hk (hP P hPP) hdprim.2.2.1 rfl rfl hct) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/RecursionParameters.lean b/lean/OAI/NumberTheory/DirichletL/Descent/RecursionParameters.lean new file mode 100644 index 0000000000000000000000000000000000000000..dc2621f67548565aabc8eb55e9ac8e9f1e8c453b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/RecursionParameters.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Descent.ActualDepthBudget +import OAI.NumberTheory.DirichletL.Descent.FirstTwoPassLowerRank + +namespace OAI + +noncomputable section + +namespace SevenEighths.InverseMoment + +def firstPassEpsilon (F eta:ℝ):ℝ:=eta/(10*F+32) +def sourceMassEpsilon (F eta:ℝ):ℝ:=2*eta/(20*(3*F+16)+30) + +theorem actual_step_parameters (F eta r ell epsChild:ℝ) + (hF:0≤F)(heta:0 linarith + +theorem actual_recursion_parameters (Mcap Fcap c eps:ℝ)(_hM:0≤Mcap)(_hF:0≤Fcap)(hc:0 first | nlinarith | constructor <;> nlinarith + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReflectedDual.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReflectedDual.lean new file mode 100644 index 0000000000000000000000000000000000000000..c9c7222bb1c6d3d422da4db55eac5ddf250ef733 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReflectedDual.lean @@ -0,0 +1,89 @@ +import OAI.NumberTheory.DirichletL.Descent.ControlledMultiplier + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff MatrixGroups +open CompletedGauss CubicEisenstein ConcreteTraceCRT CubicKubota CompletedDyadic +open CubicJacobiGlobal ShortDraftCusp FiniteGaussPhase LocalReflectionBrackets +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +noncomputable local instance dualQuotientFintype (P : Ideal Eis) [P.IsMaximal] : + Fintype (Eis ⧸ P) := Fintype.ofFinite _ +variable {ι : Type*} [Fintype ι] {p : ι → Eis} {N a0 c0 : Eis} {mode : Bool} + +def mixedSmoothedValue (D : ControlledStratumArithmetic p N a0 c0 mode) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hN : (9 : Eis) * c0 ∣ N) (hr : λ₀ ^ 2 ∣ (∏ i, p i) - 1) + (hbase : if mode then λ₀ ^ 2 ∣ a0 - 1 else λ₀ ^ 2 ∣ c0 - 1) + (s : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode)) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (W : ℝ → ℂ) (X : ℝ) : ℂ := + ∑ v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ, + fullLocalFourierWeight hp (mixedPrimeFunction p hg j S) v * + (D.datum hN hr hbase s hp hc0 v).smoothedKernel W X + +def mixedReflectedValue (D : ControlledStratumArithmetic p N a0 c0 mode) + [∀ i, (Ideal.span {p i}).IsMaximal] + (s : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode)) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) + (j : ι → ℕ) (S : Finset ι) (W : ℝ → ℂ) (X : ℝ) : ℂ := + fixedRadialCoefficientScalar * s.stratumShapeFactor (c0 * ∏ i, p i) * + ∑' t : ThetaFullIndex, + (s.amplitude t.1 t.2.1 t.2.2.1.val t.2.2.2.val / + ((ramifiedScale 1 completedRamifiedStep t.2.1 * + Real.sqrt (Ideal.absNorm t.2.2.1.val : ℝ) * (Ideal.absNorm t.2.2.2.val : ℝ) : ℝ) : ℂ)) * + CubicReflectionKernel.paperKernel (Vstar W) + ((X / (27 * (sourceCuspScale s.index) ^ 2 * (Ideal.absNorm (Ideal.span {c0 * ∏ i, p i}) : ℝ) ^ 2)) * + (ramifiedScale 1 completedRamifiedStep t.2.1) ^ 3 * + (Ideal.absNorm t.2.2.1.val : ℝ) * (Ideal.absNorm t.2.2.2.val : ℝ) ^ 3) * + ((star D.fixedFactor * A4BadPhase c0 hc0 (D.matrix (fun _ => 1) 1 1) D.U + (sourceCuspPhaseNumerator s.index (s.upper 0 0) (thetaFullFrequency t))) * + ∏ i, mixedActiveBracket hp hg j S D i + (sourceCuspPhaseNumerator s.index (s.upper 0 0) (thetaFullFrequency t))) + +theorem mixed_smoothed_eq_reflected (D : ControlledStratumArithmetic p N a0 c0 mode) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hN : (9 : Eis) * c0 ∣ N) (hr : λ₀ ^ 2 ∣ (∏ i, p i) - 1) + (hbase : if mode then λ₀ ^ 2 ∣ a0 - 1 else λ₀ ^ 2 ∣ c0 - 1) + (s : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode)) + (hp : ∀ i, p i ≠ 0) (hc0 : c0 ≠ 0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, λ₀ ∉ Ideal.span {p i}) (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (j : ι → ℕ) (hj : ∀ i, j i < 6) (S : Finset ι) + (W : ℝ → ℂ) (lo hi : ℝ) (hlo : 0 < lo) (hsupp : Function.support W ⊆ Set.Icc lo hi) + (hW : ContDiff ℝ ∞ W) (X : ℝ) (hX : 0 < X) : + mixedSmoothedValue D hN hr hbase s hp hc0 hg j S W X = + mixedReflectedValue D s hp hc0 hg j S W X := by + have hden : c0 * (∏ i, p i) ≠ 0 := + mul_ne_zero hc0 (Finset.prod_ne_zero_iff.mpr (fun i _ => hp i)) + have hmat (v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ) : + (D.sourceGamma hN hr hbase v : SL(2, Eis)) * + ControlledStratumArithmetic.fixedCusp a0 c0 mode = D.matrix v := + D.sourceGamma_mul hN hr hbase v + have hchar (v : ∀ i, (Eis ⧸ Ideal.span {p i})ˣ) : + levelTwoComplexCharacter (D.sourceGamma hN hr hbase v) = + complexCharacter (D.relativeGamma hN hr hbase v) := + D.sourceGamma_character hN hr hbase v + have hC : ∀ v, ((D.sourceGamma hN hr hbase v : SL(2, Eis)) * + ControlledStratumArithmetic.fixedCusp a0 c0 mode) 1 0 = c0 * ∏ i, p i := by + intro v + exact (congrArg (fun M : SL(2, Eis) => M 1 0) (hmat v)).trans (D.denominator v) + have he := s.sum_smoothedKernel_integral_phase (D.sourceGamma hN hr hbase) _ hden hC + (fullLocalFourierWeight hp (mixedPrimeFunction p hg j S)) W lo hi hlo hsupp hW X hX + change mixedSmoothedValue D hN hr hbase s hp hc0 hg j S W X = _ at he + rw [he] + unfold mixedReflectedValue + apply congrArg (fun z : ℂ => fixedRadialCoefficientScalar * s.stratumShapeFactor (c0 * ∏ i, p i) * z) + apply tsum_congr + intro t + congr 1 + simpa only [hchar, hmat, map_mul] using + controlled_mixed_multiplier D hN hr hbase hp hc0 hcop hg hc j hj S + (sourceCuspPhaseNumerator s.index (s.upper 0 0) (thetaFullFrequency t)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBinEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBinEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f01cda2edf3fe0518d28841b548f33b6b579fd9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBinEnergy.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedIntegralEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +open CanonicalCubeSeparation JointLogSeparation +local notation "O" => ActualEisensteinCubic.O + +theorem markedReopenedCubeBin_energy + {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes ⊆ S) (hSp : ∀P∈S,Prime P) + (Q : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D) →₀ ℕ)) + (labels : Finset (Ideal O)) (Ψ : O →* ℂ) (m : O) (W : ℝ → ℂ) + (a b : ℝ) (ha : 0 < a) (hb : 0≤b) (hs : Function.support W ⊆ Set.Icc a b) + (hW : ContDiff ℝ ∞ W) (V : 𝓢(ℝ,ℂ)) + (hV : ∀ u, |u| ≤ columnWindowRadius a b → V u = 1) + (B ell X H₀ K E : ℝ) (d : ℕ) + (hB : 0 < B) (hell : 0 < ell) (hX : X = B^3*ell) (hD : b*X≤D) (hK : 0 < K) (hE : 0 ≤ E) + (hn : ∀ v ∈ Q, B ≤ (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v) : ℝ)) + (hn' : ∀ v ∈ Q, (Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v) : ℝ) ≤ Real.exp 1*B) + (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (weights : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) : + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + let hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + letI : ∀ i : primePool F, (Ideal.span {poolPrimary F i}).IsMaximal := + fun i => by rw [poolPrimary_span F hF i]; infer_instance + let β := fun I v => reopenedCubeCoefficient H₀ + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n := fun v => (Ideal.absNorm (cubeIdeal F v) : ℝ) + (∀ ξ : ℝ, rowFamilyEnergy labels (fun I z => + varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q + (separatedCubeCoefficient (β I) n B ξ) Ψ m (idealGenerator I) + (fun v T => primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) ell T)) z) K ≤ + E*(1+|ξ|)^(2*d)) → + rowFamilyEnergy labels (fun I z => + markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z W X H₀ slots lists weights) K ≤ + (B^2*ell)⁻¹ * E * + (∫ ξ : ℝ, ‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^d)^2 := by + dsimp only + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + have hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀ i : primePool F, (Ideal.span {poolPrimary F i}).IsMaximal := + fun i => by rw [poolPrimary_span F hF i]; infer_instance + let β := fun I v => reopenedCubeCoefficient H₀ + (rowTwist Ψ (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n := fun v => (Ideal.absNorm (cubeIdeal F v) : ℝ) + intro hbound + have hrows : (fun I z => markedReopenedCubeBin S D Q Ψ m (idealGenerator I) z W X H₀ slots lists weights) = + (fun I z => ((B*Real.sqrt ell : ℝ) : ℂ)⁻¹ * ∫ ξ : ℝ, + reopeningCoefficient W a b ha hs hW ξ * + varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q + (separatedCubeCoefficient (β I) n B ξ) Ψ m (idealGenerator I) + (fun v T => primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) ell T)) z) := by + funext I z + exact markedReopenedCubeBin_separated S D hbad hSp Q Ψ m (idealGenerator I) z W a b ha hb hs hW V hV + B ell X H₀ hB hell hX hD hn hn' slots lists weights + rw [hrows] + exact varying_separated_canonical_family_energy (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q labels β n (fun v T=>primeMark slots lists weights (T∪v.support)) Ψ m + (reopeningCoefficient W a b ha hs hW) V B ell K E d hB hell hK hE hbound + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBins.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBins.lean new file mode 100644 index 0000000000000000000000000000000000000000..d877bd99b178926cd23c49d4438e46959527da8c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBins.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedBinEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +local notation "O" => ActualEisensteinCubic.O + +theorem marked_column_zero_of_subunit (Ψ : O→*ℂ) (W : ℝ→ℂ) (b Y : ℝ) + (hY : 0hn (Finset.mem_filter.mpr ⟨hv,hh⟩)) + have hN : 0<(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ) := + lt_of_lt_of_le zero_lt_one (norm_at_least_one _ (cubeIdeal_ne_zero _ v)) + have hsub : b*(X/(Ideal.absNorm (cubeIdeal (InitialMeanSquare.outsideSquarefreeIdeals S D) v):ℝ)^3)<1 := by + rw [←mul_div_assoc] + exact (div_lt_one (pow_pos hN _)).mpr hlarge + rw [marked_column_zero_of_subunit _ W b _ (div_pos hX (pow_pos hN _)) hW hsub,mul_zero] + +theorem markedReopenedCubeBin_log_bins : + markedReopenedCubeBin S D (activeCubeExponents S D b X) Ψ m f z W X H₀ slots lists a = + ∑ j∈cubeLogRange b X, + markedReopenedCubeBin S D (activeCubeLogBin S D b X j) Ψ m f z W X H₀ slots lists a := by + unfold markedReopenedCubeBin + dsimp only + exact sum_activeCubeLogBins S D b X _ + +def markedShortCompletedSum (Ψrow : O→*ℂ) (W : ℝ→ℂ) (X H₀ : ℝ) (mark : Ideal O→ℂ) : ℂ := + ∑' H:Ideal O,if (Ideal.absNorm H:ℝ)mark (H^3*I)) else 0 + +theorem original_marked_reopened_binned (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (hWc : HasCompactSupport W) (hX : 0i.val) slots lists a) + + ∑ j∈cubeLogRange b X, + markedReopenedCubeBin S D (activeCubeLogBin S D b X j) Ψ m f z W X H₀ slots lists a := by + rw [original_marked_split_to_bins S D hbad hSp Ψ m f z W hWc b X H₀ hX hW hD] + rw [markedReopenedCubeBin_eq_active S D Ψ m f z W b X H₀ slots lists a hX hW, + markedReopenedCubeBin_log_bins] + rfl + +theorem original_marked_binned_energy (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (hWc : HasCompactSupport W) (hX : 0i.val) slots lists a)‖^2 + + (cubeLogRange b X).card*∑ j∈cubeLogRange b X, + ‖markedReopenedCubeBin S D (activeCubeLogBin S D b X j) Ψ m f z W X H₀ slots lists a‖^2) := by + have hs := norm_add_sum_sq_le (cubeLogRange b X) + (markedShortCompletedSum (rowTwist Ψ (m*excludedGenerator S) f z) W X H₀ + (indexedIdealMark (fun i:primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)=>i.val) slots lists a)) + (fun j=>markedReopenedCubeBin S D (activeCubeLogBin S D b X j) Ψ m f z W X H₀ slots lists a) + rw [←original_marked_reopened_binned S D Ψ m f z W b X H₀ slots lists a hbad hSp hWc hX hW hD] at hs + have hn : ‖outsideCanonicalMarkedRow S D hbad Ψ m f z slots lists a W X‖^2 = + X*‖(Real.sqrt X:ℂ)⁻¹*outsideCanonicalMarkedRow S D hbad Ψ m f z slots lists a W X‖^2 := by + rw [norm_mul,norm_inv,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg X), + mul_pow,inv_pow,Real.sq_sqrt hX.le] + field_simp + rw [hn] + convert mul_le_mul_of_nonneg_left hs hX.le using 1 ; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBlocks.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBlocks.lean new file mode 100644 index 0000000000000000000000000000000000000000..ecf97cc2f5ab0f78a8244f71404bf75923aa4f5f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedBlocks.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +open ConcretePrimeRowBridge (idealGenerator) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +def varyingCanonicalSourceTotal {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (H : Ideal O→(ι→₀ℕ)→Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) (K : ℝ) : ℂ := + ∑b∈reopenedCubeFamily Q,∑C∈(pool\b.support).powerset,∑I∈labels, + reopenedPairCoefficient β b C I * + canonicalCubeBeforePoisson p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (H I b.rightExponent) (H I b.leftExponent) W K + +theorem varying_reopened_smoothed_source {ι : Type*} [DecidableEq ι] + (p : ι → ActualEisensteinCubic.O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (pool : Finset ι) (Q : Finset (ι →₀ ℕ)) (hQ : ∀ v ∈ Q,v.support ⊆ pool) + (labels : Finset (Ideal ActualEisensteinCubic.O)) (β : Ideal ActualEisensteinCubic.O → (ι →₀ ℕ) → ℂ) + (Ψ : ActualEisensteinCubic.O →* ℂ) (m : ActualEisensteinCubic.O) (H : Ideal O→(ι→₀ℕ)→Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) (K : ℝ) (hK : 0 < K) : + (∑ I ∈ labels,∑' z : ActualEisensteinCubic.O,W (‖eisEmbedding z‖^2/K)* + (‖varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (idealGenerator I) + (H I) z‖^2 : ℝ)) = + varyingCanonicalSourceTotal p hp hcop hg pool Q labels β Ψ m H W K := by + rw [varyingCanonicalSourceTotal,sum_reopenedCubeFamily] + simp only [reopenedPairCoefficient,CubeCoordinates.support] + calc + _ = ∑ I ∈ labels,∑ v₂ ∈ Q,∑ v₁ ∈ Q,(star (β I v₂)*β I v₁)* + canonicalCubeCorrelation p hp hcop hg pool (v₁.support∪v₂.support) v₁ v₂ + Ψ Ψ m m (idealGenerator I) (H I v₂) + (H I v₁) W K := by + apply Finset.sum_congr rfl + intro I hI + exact varying_reopened_smoothed_expand p hp hcop hg pool Q hQ (β I) Ψ m + (idealGenerator I) (H I) W K hK + _ = ∑ v₂ ∈ Q,∑ v₁ ∈ Q,∑ I ∈ labels,(star (β I v₂)*β I v₁)* + canonicalCubeCorrelation p hp hcop hg pool (v₁.support∪v₂.support) v₁ v₂ + Ψ Ψ m m (idealGenerator I) (H I v₂) + (H I v₁) W K := by + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro v₂ hv₂ + rw [Finset.sum_comm] + _ = _ := by + apply Finset.sum_congr rfl + intro v₂ hv₂ + apply Finset.sum_congr rfl + intro v₁ hv₁ + have hs : v₁.support∪v₂.support ⊆ pool := Finset.union_subset (hQ v₁ hv₁) (hQ v₂ hv₂) + simp_rw [canonicalCubeCorrelation_eq_blocks p hp hcop hg hinj hpr pool v₁ v₂ hs, + Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro A₂ hA₂ + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro A₁ hA₁ + rw [Finset.sum_comm] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedCommonMeasure.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedCommonMeasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..5240840e72fd389fc2ab176de2b3b84342caa55c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedCommonMeasure.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedSeparation + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +open CanonicalCubeSeparation JointLogSeparation +local notation "O" => ActualEisensteinCubic.O + +theorem markedReopenedCubeBin_separated {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Q : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)) + (Ψ : O→*ℂ) (m f z : O) (W : ℝ→ℂ) + (a b : ℝ) (ha : 0by rw [poolPrimary_span F hF i];infer_instance + let β := fun v=>reopenedCubeCoefficient H₀ (rowTwist Ψ (m*excludedGenerator S) f 1) (cubeIdeal F v) + let n := fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ) + markedReopenedCubeBin S D Q Ψ m f z W X H₀ slots lists weights = + ((B*Real.sqrt ell:ℝ):ℂ)⁻¹ * ∫ ξ:ℝ,reopeningCoefficient W a b ha hs hW ξ* + varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q + (separatedCubeCoefficient β n B ξ) Ψ m f + (fun v T=>primeMark slots lists weights (T∪v.support)*frequencyTwist V ξ (columnLog (poolPrimary F) ell T)) z := by + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + have hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + let β := fun v=>reopenedCubeCoefficient H₀ (rowTwist Ψ (m*excludedGenerator S) f 1) (cubeIdeal F v) + let n := fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ) + have hXp : 0(hs ht).2 + dsimp only + rw [←varying_canonical_bin_separation (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) W a b ha hs hW V hV + Finset.univ Q β n (fun v T=>primeMark slots lists weights (T∪v.support)) + Ψ m f z B ell X hB hell hX hn hn'] + unfold markedReopenedCubeBin + dsimp only + apply Finset.sum_congr rfl + intro v hv + rw [reopened_marked_global_column S D hbad hSp Ψ m f z W b X hb hXp hupper hD slots lists weights v] + rw [cubeWeight_row_factor,cubeIdeal_row F hF v z] + have hc := cube_coefficient_restore H₀ (rowTwist Ψ (m*excludedGenerator S) f 1) + (cubeIdeal F v) (cubeIdeal_ne_zero F v) + have hc' : β v*(n v:ℂ)⁻¹=largeCubeCoefficient H₀ (cubeIdeal F v)* + cubeWeight (rowTwist Ψ (m*excludedGenerator S) f 1) (cubeIdeal F v) := by + simpa only [β,n,Complex.ofReal_natCast] using hc + rw [hc'] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedIdentification.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedIdentification.lean new file mode 100644 index 0000000000000000000000000000000000000000..ae9bc6c3890ecdffc5e33271d8cce02735d7e835 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedIdentification.lean @@ -0,0 +1,71 @@ +import OAI.NumberTheory.DirichletL.Descent.CompletedReopening +import OAI.NumberTheory.DirichletL.Descent.ReopenedPriority + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +local notation "O" => ActualEisensteinCubic.O + +theorem complete_pool_whole_cube_mark {σ : Type*} [DecidableEq σ] + (F : Finset (Ideal O)) (hF : ∀ I∈F,Admissible I) + (slots : Finset σ) (lists : σ→Finset (primePool F)) (a : σ→primePool F→ℂ) + (T : Finset (primePool F)) (v : primePool F→₀ℕ) : + indexedIdealMark (fun i:primePool F=>i.val) slots lists a + ((∏i∈T,i.val)*cubeIdeal F v^3) = primeMark slots lists a (T∪v.support) := by + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + have hinj : Function.Injective (fun i:primePool F=>Ideal.span {poolPrimary F i}) := by + intro i j h + dsimp only at h + rw [poolPrimary_span F hF i,poolPrimary_span F hF j] at h + exact Subtype.ext h + have he := reopened_whole_mark_divisibility (poolPrimary F) hinj slots lists a T v + have hspan : Ideal.span {∏i∈T,poolPrimary F i}=∏i∈T,i.val := by + rw [FiniteGaussPhase.span_finset_prod] + exact Finset.prod_congr rfl (fun i _=>poolPrimary_span F hF i) + rw [hspan,cubeIdeal_eq_primeProduct_span F hF v] at he + simpa only [indexedIdealMark,poolPrimary_span F hF] using he.symm + +theorem reopened_marked_global_column {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Ψ : O→*ℂ) (m f z : O) (W : ℝ→ℂ) (b X : ℝ) (hb : 0≤b) (hX : 0by rw [poolPrimary_span F hF i];infer_instance + let Y := X/(Ideal.absNorm (cubeIdeal F v):ℝ)^3 + (∑' I:Ideal O,columnWeight (rowTwist Ψ (m*excludedGenerator S) f z) I*W ((Ideal.absNorm I:ℝ)/Y)* + indexedIdealMark (fun i:primePool F=>i.val) slots lists a (I*cubeIdeal F v^3)) = + fixedChildRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Ψ m + (fun T=>primeMark slots lists a (T∪v.support)*W (primeProductNorm (poolPrimary F) T/Y)) f z := by + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + have hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + let Y := X/(Ideal.absNorm (cubeIdeal F v):ℝ)^3 + have hN := norm_at_least_one (cubeIdeal F v) (cubeIdeal_ne_zero F v) + have hY : 0indexedIdealMark (fun i:primePool F=>i.val) slots lists a (I*cubeIdeal F v^3)) + dsimp only at he ⊢ + rw [←he] + congr 1 + funext T + rw [complete_pool_whole_cube_mark F hF slots lists a T v,mul_comm] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedIntegralEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedIntegralEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..eb6c9905cc728e177f695abc84b11f5a3430c16c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedIntegralEnergy.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedCommonMeasure + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalCubeSeparation JointLogSeparation FirstPassCubeLabels SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem varying_separated_canonical_integrable + (pool : Finset ι) (Q : Finset (ι →₀ ℕ)) (β : (ι →₀ ℕ) → ℂ) + (n : (ι →₀ ℕ) → ℝ) (mark : (ι→₀ℕ)→Finset ι→ℂ) (Ψ : O →* ℂ) (m f z : O) + (b V : 𝓢(ℝ,ℂ)) (B ell : ℝ) : + Integrable (fun ξ : ℝ => b ξ * + varyingReopenedRow p hp hcop hg pool Q (separatedCubeCoefficient β n B ξ) + Ψ m f (fun v T => mark v T*frequencyTwist V ξ (columnLog p ell T)) z) := by + let A : (ι →₀ ℕ) → Finset ι → ℂ := fun v T => + multiplicityRow (fun i => Ideal.span {p i}) hg pool v z ^ 3 * + canonicalSourceCoefficient p hp hcop hg Ψ m f (fun _ => 1) T * + finiteSquarefreeRow (fun i => Ideal.span {p i}) hg T z*mark v T + have hi := reopening_finite_sum_integrable Q pool.powerset β A n (primeProductNorm p) B ell b V + convert hi using 1 + funext ξ + rw [varyingReopenedRow_integrand p hp hcop hg] + simp only [A,Finset.mul_sum,columnLog] + apply Finset.sum_congr rfl + intro v hv + apply Finset.sum_congr rfl + intro T hT + ring + +theorem varying_separated_canonical_family_energy + (pool : Finset ι) (Q : Finset (ι →₀ ℕ)) (labels : Finset (Ideal O)) + (β : Ideal O → (ι →₀ ℕ) → ℂ) (n : (ι →₀ ℕ) → ℝ) (mark : (ι→₀ℕ)→Finset ι→ℂ) + (Ψ : O →* ℂ) (m : O) (b V : 𝓢(ℝ,ℂ)) + (B ell K E : ℝ) (d : ℕ) (hB : 0 < B) (hell : 0 < ell) (hK : 0 < K) (hE : 0 ≤ E) + (hbound : ∀ ξ : ℝ, + rowFamilyEnergy labels (fun I z => + varyingReopenedRow p hp hcop hg pool Q (separatedCubeCoefficient (β I) n B ξ) + Ψ m (idealGenerator I) (fun v T => mark v T*frequencyTwist V ξ (columnLog p ell T)) z) K ≤ + E*(1+|ξ|)^(2*d)) : + rowFamilyEnergy labels (fun I z => ((B*Real.sqrt ell : ℝ) : ℂ)⁻¹ * + ∫ ξ : ℝ, b ξ * + varyingReopenedRow p hp hcop hg pool Q (separatedCubeCoefficient (β I) n B ξ) + Ψ m (idealGenerator I) (fun v T => mark v T*frequencyTwist V ξ (columnLog p ell T)) z) K ≤ + (B^2*ell)⁻¹ * E*(∫ ξ : ℝ, ‖b ξ‖*(1+|ξ|)^d)^2 := by + have hb : Integrable (fun ξ : ℝ => ‖b ξ‖*(1+|ξ|)^d) := by + simpa only [Real.norm_eq_abs,mul_comm] using weighted_schwartz_integrable b d + have hφ (I : Ideal O) (z : O) : Integrable (fun ξ : ℝ => b ξ * + varyingReopenedRow p hp hcop hg pool Q (separatedCubeCoefficient (β I) n B ξ) + Ψ m (idealGenerator I) (fun v T => mark v T*frequencyTwist V ξ (columnLog p ell T)) z) := + varying_separated_canonical_integrable p hp hcop hg pool Q (β I) n mark Ψ m (idealGenerator I) z b V B ell + have hm := rowFamilyEnergy_integral_polynomial labels K hK b + (fun I z ξ => varyingReopenedRow p hp hcop hg pool Q (separatedCubeCoefficient (β I) n B ξ) + Ψ m (idealGenerator I) (fun v T => mark v T*frequencyTwist V ξ (columnLog p ell T)) z) + d E hE hb hφ hbound + have hn : ‖((B*Real.sqrt ell : ℝ) : ℂ)⁻¹‖^2 = (B^2*ell)⁻¹ := by + rw [norm_inv,Complex.norm_real,Real.norm_eq_abs, + abs_of_pos (mul_pos hB (Real.sqrt_pos.mpr hell)),inv_pow,mul_pow,Real.sq_sqrt hell.le] + rw [rowFamilyEnergy_const_mul labels _ K hK, hn] + convert mul_le_mul_of_nonneg_left hm (by positivity : 0 ≤ (B^2*ell)⁻¹) using 1 ; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedMarks.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedMarks.lean new file mode 100644 index 0000000000000000000000000000000000000000..e69cc10c37e9cab6c15fd35836a8fd9d92311133 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedMarks.lean @@ -0,0 +1,57 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + +omit [DecidableEq σ] in +include hinj in +theorem prime_dvd_span_primeProduct (S : Finset ι) (v : ι→ℕ) (i : ι) : + (Ideal.span {p i}:Ideal O)∣Ideal.span {primeProduct p S v} ↔ i∈S ∧ 0Ideal.span {p i}) hinj] + by_cases hi : i∈S <;> simp [hi] + +omit [DecidableEq σ] in +include hinj in +theorem prime_dvd_reopened_index (S : Finset ι) (v : ι→₀ℕ) (i : ι) : + (Ideal.span {p i}:Ideal O)∣(Ideal.span {∏k∈S,p k})*(Ideal.span {primeProduct p v.support v})^3 ↔ + i∈S∪v.support := by + have hi : Prime (Ideal.span {p i}:Ideal O) := Ideal.prime_of_isPrime (NeZero.ne _) inferInstance + have hs := prime_dvd_span_primeProduct p hinj S (fun _=>1) i + simp only [primeProduct,pow_one,Nat.zero_lt_one,and_true] at hs + rw [hi.dvd_mul,hi.dvd_pow_iff_dvd (by decide : (3:ℕ)≠0),hs, + prime_dvd_span_primeProduct p hinj v.support v i,Finset.mem_union] + have hv : i∈v.support ↔ 0lists j\v.support) a S := by + rw [Finset.union_comm,primeMark_priority] + simp only [primeMark_residual_lists] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedOriginalRow.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedOriginalRow.lean new file mode 100644 index 0000000000000000000000000000000000000000..e4c5edff267f82a76f2af07b3b633e5ef34e643b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedOriginalRow.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedIdentification + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve SecondPassArithmetic FirstPassCubeLabels +local notation "O" => ActualEisensteinCubic.O + +def markedReopenedCubeBin {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) + (Q : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)) + (Ψ : O→*ℂ) (m f z : O) (W : ℝ→ℂ) (X H₀ : ℝ) + (slots : Finset σ) + (lists : σ→Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D))) + (a : σ→primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→ℂ) : ℂ := + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + let Ψrow := rowTwist Ψ (m*excludedGenerator S) f z + ∑ v∈Q,(largeCubeCoefficient H₀ (cubeIdeal F v)*cubeWeight Ψrow (cubeIdeal F v)* + (Real.sqrt (X/(Ideal.absNorm (cubeIdeal F v):ℝ)^3):ℂ)⁻¹)* + ∑' I:Ideal O,columnWeight Ψrow I*W ((Ideal.absNorm I:ℝ)/(X/(Ideal.absNorm (cubeIdeal F v):ℝ)^3))* + indexedIdealMark (fun i:primePool F=>i.val) slots lists a (I*cubeIdeal F v^3) + +theorem original_marked_split_to_bins {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Ψ : O→*ℂ) (m f z : O) (W : ℝ→ℂ) (hWc : HasCompactSupport W) + (b X H₀ : ℝ) (hX : 0i.val) slots lists a + (Real.sqrt X:ℂ)⁻¹*outsideCanonicalMarkedRow S D hbad Ψ m f z slots lists a W X = + (∑' H:Ideal O,if (Ideal.absNorm H:ℝ)mark (H^3*I)) else 0) + + markedReopenedCubeBin S D ((outsideIdealsUpTo S D).image (cubeIndex F)) Ψ m f z W X H₀ slots lists a := by + rw [outsideCanonicalMarkedRow_reopened S D hbad hSp Ψ m f z W hWc b X H₀ hX hW hD] + dsimp only + rw [sum_outside_cubeIndex S D] + rfl + +theorem markedReopenedCubeBin_eq_varying {σ : Type*} [DecidableEq σ] + (S : Finset (Ideal O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀ P∈S,Prime P) + (Q : Finset (primePool (InitialMeanSquare.outsideSquarefreeIdeals S D)→₀ℕ)) + (Ψ : O→*ℂ) (m f z : O) (W : ℝ→ℂ) (b X H₀ : ℝ) (hb : 0≤b) (hX : 0by rw [poolPrimary_span F hF i];infer_instance + let β := fun v=>largeCubeCoefficient H₀ (cubeIdeal F v)* + cubeWeight (rowTwist Ψ (m*excludedGenerator S) f 1) (cubeIdeal F v)* + (Real.sqrt (X/(Ideal.absNorm (cubeIdeal F v):ℝ)^3):ℂ)⁻¹ + markedReopenedCubeBin S D Q Ψ m f z W X H₀ slots lists a = + varyingReopenedRow (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q β Ψ m f + (fun v T=>primeMark slots lists a (T∪v.support)* + W (primeProductNorm (poolPrimary F) T/(X/(Ideal.absNorm (cubeIdeal F v):ℝ)^3))) z := by + let F := InitialMeanSquare.outsideSquarefreeIdeals S D + have hF := InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀ i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + dsimp only + unfold markedReopenedCubeBin varyingReopenedRow + dsimp only + apply Finset.sum_congr rfl + intro v hv + rw [reopened_marked_global_column S D hbad hSp Ψ m f z W b X hb hX hW hD slots lists a v] + rw [cubeWeight_row_factor,cubeIdeal_row F hF v z] + unfold fixedChildRow + simp only [Finset.mul_sum,secondChildColumn,canonicalSourceCoefficient] + apply Finset.sum_congr rfl + intro T hT + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPhysicalEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPhysicalEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..a06b5749836c454a09fb34cb44aa746b7fbfa9fd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPhysicalEnergy.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedPhysicalSplit + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +open ConcretePrimeRowBridge (idealGenerator) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem rowFamilyEnergy_le_of_full_split (labels : Finset (Ideal O)) + (P : Ideal O→O→ℂ) (K : ℝ) (hK : 0sq_nonneg _) + simp only [Complex.add_re] + linarith [Complex.re_le_norm A,Complex.re_le_norm B,Complex.re_le_norm C] + +theorem original_reopened_physical_energy + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (hQ : ∀ v∈Q,v.support⊆pool) + (labels : Finset (Ideal O)) (hlabels : ∀ I∈labels,I≠0) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : Ideal O→(ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) + (K : ℝ) (hK : 0 + varyingReopenedRow p hp hcop hg pool Q (β I) Ψ m (idealGenerator I) + (fun v U=>mark I v U*W (primeProductNorm p U)) z) K ≤ + ‖reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + canonicalCubeDualZero p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (fun U=>mark I b.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark I b.leftExponent U*W (primeProductNorm p U)) rowMajorant K)‖ + + ‖reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + reopenedPhysicalRetained p hp hcop hg pool b C Ψ m I (mark I) W rowMajorant K (R b C I))‖ + + ‖reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + canonicalCubeDualTail p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (fun U=>mark I b.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark I b.leftExponent U*W (primeProductNorm p U)) rowMajorant K + (reopenedPhysicalCutoff p b I (R b C I)))‖ := by + apply rowFamilyEnergy_le_of_full_split labels _ K hK + exact original_reopened_physical_split p hp hcop hg hinj hc hpr pool Q hQ labels hlabels + β Ψ m mark W rowMajorant K hK R hR + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPhysicalSplit.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPhysicalSplit.lean new file mode 100644 index 0000000000000000000000000000000000000000..89788e6afbb752bf5d52e08ae73e81da08c2343c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPhysicalSplit.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedBlocks +import OAI.NumberTheory.DirichletL.Descent.FirstRetainedPhysical + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +open ConcretePrimeRowBridge (idealGenerator) +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def reopenedPhysicalSourceSum (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal O)) (β : Ideal O→(ι→₀ℕ)→ℂ) + (source : CubeCoordinates ι→Finset ι→Ideal O→ℂ) : ℂ := + ∑ b∈reopenedCubeFamily Q,∑ C∈(pool\b.support).powerset,∑ I∈labels, + reopenedPairCoefficient β b C I*source b C I + +def reopenedPhysicalCutoff (b : CubeCoordinates ι) (I : Ideal O) + (R : Finset ι→ℝ) (D : Finset ι) : Finset O := + childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent + b.leftBit b.rightBit I) (R D) + +def reopenedPhysicalRetained (pool : Finset ι) (b : CubeCoordinates ι) (C : Finset ι) + (Ψ : O→*ℂ) (m : O) (I : Ideal O) + (mark : (ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) + (K : ℝ) (R : Finset ι→ℝ) : ℂ := + canonicalCubeOuter p hp hcop hg b C Ψ Ψ m m (idealGenerator I)* + ∑ D∈(C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit).powerset, + (UniqueFactorizationMonoid.moebius (∏ i∈D,Ideal.span {p i}):ℂ)* + ∑ h∈(reopenedPhysicalCutoff p b I R D).erase 0, + firstCubePhysicalMode p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (mark b.rightExponent) (mark b.leftExponent) W W Φ K + (primeSubsetGenerator (fun i=>Ideal.span {p i}) D) h + +theorem original_reopened_physical_split + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (hQ : ∀ v∈Q,v.support⊆pool) + (labels : Finset (Ideal O)) (hlabels : ∀ I∈labels,I≠0) + (β : Ideal O→(ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m : O) + (mark : Ideal O→(ι→₀ℕ)→Finset ι→ℂ) (W : ℝ→ℂ) (Φ : 𝓢(ℝ,ℂ)) + (K : ℝ) (hK : 0mark I v U*W (primeProductNorm p U)) z‖^2:ℝ)) = + reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + canonicalCubeDualZero p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (fun U=>mark I b.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark I b.leftExponent U*W (primeProductNorm p U)) Φ K) + + reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + reopenedPhysicalRetained p hp hcop hg pool b C Ψ m I (mark I) W Φ K (R b C I)) + + reopenedPhysicalSourceSum pool Q labels β (fun b C I=> + canonicalCubeDualTail p hp hcop hg pool b C Ψ Ψ m m (idealGenerator I) + (fun U=>mark I b.rightExponent U*W (primeProductNorm p U)) + (fun U=>mark I b.leftExponent U*W (primeProductNorm p U)) Φ K + (reopenedPhysicalCutoff p b I (R b C I))) := by + rw [varying_reopened_smoothed_source p hp hcop hg hinj hpr pool Q hQ labels β Ψ m] + · unfold varyingCanonicalSourceTotal reopenedPhysicalSourceSum + simp only [←Finset.sum_add_distrib] + apply Finset.sum_congr rfl + intro b hb + apply Finset.sum_congr rfl + intro C hC + apply Finset.sum_congr rfl + intro I hI + have hCb : Disjoint C b.support := by + exact Finset.disjoint_left.mpr (fun i hi hib=> + (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hC) hi)).2 hib) + have he := canonical_first_physical_split p hp hcop hg hinj hc hpr pool b + (reopenedCubeFamily_admissible Q b hb) C hCb Ψ Ψ m m I (hlabels I hI) + (mark I b.rightExponent) (mark I b.leftExponent) W W Φ K hK (R b C I) (hR b hb C hC I hI) + dsimp only at he + rw [he] + simp only [reopenedPhysicalRetained] + rw [show reopenedPhysicalCutoff p b I (R b C I) = + (fun D=>childFrequencyBall (firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent + b.leftBit b.rightBit I) (R b C I D)) from rfl] + ring + · exact hK + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPriority.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPriority.lean new file mode 100644 index 0000000000000000000000000000000000000000..2873505c86eae93421573cbad9dfaa867da74015 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedPriority.lean @@ -0,0 +1,53 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedMarks + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem varying_reopened_prime_priority + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (β : (ι→₀ℕ)→ℂ) + (Ψ : O→*ℂ) (m f : O) (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (V : (ι→₀ℕ)→Finset ι→ℂ) (z : O) : + varyingReopenedRow p hp hcop hg pool Q β Ψ m f + (fun v S=>primeMark slots lists a (S∪v.support)*V v S) z = + ∑J∈slots.powerset,varyingReopenedRow p hp hcop hg pool Q + (fun v=>β v*primeMark J lists a v.support) Ψ m f + (fun v S=>primeMark (slots\J) (fun j=>lists j\v.support) a S*V v S) z := by + unfold varyingReopenedRow + conv_rhs => rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro v hv + conv_rhs => rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro S hS + simp only [canonicalSourceCoefficient] + rw [reopened_mark_priority] + simp only [Finset.sum_mul,Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + ring + +omit [DecidableEq σ] in +theorem allocated_cube_coefficient_bound + (slots J : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (hJ : J⊆slots) (hslots : (slots : Set σ).PairwiseDisjoint lists) + (ha : ∀ j∈slots,∀ i∈lists j,‖a j i‖≤1) + (β : (ι→₀ℕ)→ℂ) (v : ι→₀ℕ) : + ‖β v*primeMark J lists a v.support‖≤‖β v‖*(2:ℝ)^v.support.card := by + rw [norm_mul] + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + exact primeMark_norm_le_divisor_count J lists a v.support + (fun i hi j hj hne=>hslots (hJ hi) (hJ hj) hne) (fun j hj i hi=>ha j (hJ hj) i hi) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedSeparation.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedSeparation.lean new file mode 100644 index 0000000000000000000000000000000000000000..67160325833dc54c899b0e90cbec922fbbdc15ee --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedSeparation.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedOriginalRow + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open CanonicalCubeSeparation JointLogSeparation FirstPassCubeLabels SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem varyingReopenedRow_integrand + (pool : Finset ι) (Q : Finset (ι →₀ ℕ)) (β : (ι →₀ ℕ) → ℂ) + (Ψ : O →* ℂ) (m f z : O) (H : (ι→₀ℕ)→Finset ι → ℂ) : + varyingReopenedRow p hp hcop hg pool Q β Ψ m f H z = + ∑ v ∈ Q, ∑ T ∈ pool.powerset, + β v * (multiplicityRow (fun i => Ideal.span {p i}) hg pool v z ^ 3 * + canonicalSourceCoefficient p hp hcop hg Ψ m f (fun _ => 1) T * + finiteSquarefreeRow (fun i => Ideal.span {p i}) hg T z) * H v T := by + unfold varyingReopenedRow + apply Finset.sum_congr rfl + intro v hv + apply Finset.sum_congr rfl + intro T hT + simp only [canonicalSourceCoefficient] + ring + +theorem varying_canonical_bin_separation + (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) + (V : 𝓢(ℝ,ℂ)) (hV : ∀ u, |u| ≤ columnWindowRadius a b → V u = 1) + (pool : Finset ι) (Q : Finset (ι →₀ ℕ)) (β : (ι →₀ ℕ) → ℂ) + (n : (ι →₀ ℕ) → ℝ) (mark : (ι→₀ℕ)→Finset ι→ℂ) (Ψ : O →* ℂ) (m f z : O) (B ell X : ℝ) + (hB : 0 < B) (hell : 0 < ell) (hX : X = B^3*ell) + (hn : ∀ v ∈ Q, B ≤ n v) (hn' : ∀ v ∈ Q, n v ≤ Real.exp 1*B) : + (∑ v ∈ Q, (β v * (n v : ℂ)⁻¹ * (Real.sqrt (X/(n v)^3) : ℂ)⁻¹) * + multiplicityRow (fun i => Ideal.span {p i}) hg pool v z ^ 3 * + fixedChildRow p hp hcop hg pool Ψ m + (fun T => mark v T*W (primeProductNorm p T/(X/(n v)^3))) f z) = + ((B*Real.sqrt ell : ℝ) : ℂ)⁻¹ * + ∫ ξ : ℝ, reopeningCoefficient W a b ha hs hW ξ * + varyingReopenedRow p hp hcop hg pool Q + (separatedCubeCoefficient β n B ξ) Ψ m f + (fun v T => mark v T*frequencyTwist V ξ (columnLog p ell T)) z := by + let A : (ι →₀ ℕ) → Finset ι → ℂ := fun v T => + multiplicityRow (fun i => Ideal.span {p i}) hg pool v z ^ 3 * + canonicalSourceCoefficient p hp hcop hg Ψ m f (fun _ => 1) T * + finiteSquarefreeRow (fun i => Ideal.span {p i}) hg T z*mark v T + have hsep := reopening_finite_sum W a b ha hs hW V hV Q pool.powerset β A n + (primeProductNorm p) B ell X hB hell hX hn hn' + (fun T _ => primeProductNorm_pos p hp T) + calc + _ = ∑ v ∈ Q, ∑ T ∈ pool.powerset, (β v * A v T) * + ((n v : ℂ)⁻¹ * (Real.sqrt (X/(n v)^3) : ℂ)⁻¹ * + W (primeProductNorm p T/(X/(n v)^3))) := by + apply Finset.sum_congr rfl + intro v hv + rw [fixedChildRow_coefficient_expansion p hp hcop hg, Finset.mul_sum] + apply Finset.sum_congr rfl + intro T hT + dsimp only [A] + ring + _ = _ := by + rw [hsep] + congr 1 + apply integral_congr_ae + filter_upwards [] with ξ + rw [varyingReopenedRow_integrand p hp hcop hg] + simp only [A, Finset.mul_sum] + apply Finset.sum_congr rfl + intro v hv + apply Finset.sum_congr rfl + intro T hT + dsimp only [columnLog] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..08caa1ec70b86d74713d289dc2f06f4f0fddee61 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedSource.lean @@ -0,0 +1,131 @@ +import OAI.NumberTheory.DirichletL.Descent.Completion + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem bounded_row_square_expansion {β : Type*} + (C : Finset β) (a : β→ℂ) (r : β→O→ℂ) (hr : ∀b∈C,∀z,‖r b z‖≤1) + (W : 𝓢(ℝ,ℂ)) (K : ℝ) (hK : 0 + (star (r b z)*r c z)*W (‖eisEmbedding z‖^2/K)) := by + have hW : Summable (fun z:O=>‖W (‖eisEmbedding z‖^2/K)‖) := by + simpa only [EisensteinSchwartzPoisson.scaledRadialTest_apply] using + EisensteinSchwartzPoisson.actual_eisenstein_summable_norm + (EisensteinSchwartzPoisson.scaledRadialTest W K hK) + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun z=>norm_nonneg _) _ hW + intro z + simp only [norm_mul,norm_star] + calc + _ ≤ 1*1*‖W (‖eisEmbedding z‖^2/K)‖ := by + gcongr + · exact hr b hb z + · exact hr c hc z + _ = _ := by ring + have he (z:O) : W (‖eisEmbedding z‖^2/K)*(‖∑b∈C,a b*r b z‖^2:ℝ)= + ∑b∈C,∑c∈C,(star (a b)*a c)*((star (r b z)*r c z)*W (‖eisEmbedding z‖^2/K)) := by + rw [Complex.sq_norm (∑b∈C,a b*r b z),Complex.normSq_eq_conj_mul_self] + simp only [map_sum,map_mul,starRingEnd_apply] + rw [Finset.sum_mul_sum] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro b hb + apply Finset.sum_congr rfl + intro c hc + ring + simp_rw [he] + rw [Summable.tsum_finsetSum (fun b hb=>summable_sum (fun c hc=>(hs b c hb hc).mul_left _))] + apply Finset.sum_congr rfl + intro b hb + rw [Summable.tsum_finsetSum (fun c hc=>(hs b c hb hc).mul_left _)] + apply Finset.sum_congr rfl + intro c hc + exact tsum_mul_left + +variable {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def varyingReopenedRow (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (β : (ι→₀ℕ)→ℂ) + (Ψ : O→*ℂ) (m f : O) (H : (ι→₀ℕ)→Finset ι→ℂ) (z : O) : ℂ := + ∑v∈Q,∑S∈pool.powerset, + (β v*canonicalSourceCoefficient p hp hcop hg Ψ m f (H v) S)* + (multiplicityRow (fun i=>Ideal.span {p i}) hg pool v z^3* + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z) + +theorem varyingReopenedRow_const (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (β : (ι→₀ℕ)→ℂ) + (Ψ : O→*ℂ) (m f : O) (H : Finset ι→ℂ) (z : O) : + varyingReopenedRow p hp hcop hg pool Q β Ψ m f (fun _=>H) z = + reopenedCanonicalRow p hp hcop hg pool Q β Ψ m f H z := rfl + +theorem varying_reopened_smoothed_expand + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (hQ : ∀v∈Q,v.support⊆pool) + (β : (ι→₀ℕ)→ℂ) (Ψ : O→*ℂ) (m f : O) (H : (ι→₀ℕ)→Finset ι→ℂ) + (W : 𝓢(ℝ,ℂ)) (K : ℝ) (hK : 0β b.1*canonicalSourceCoefficient p hp hcop hg Ψ m f (H b.1) b.2 + let r : (ι→₀ℕ)×Finset ι→O→ℂ := fun b z=> + multiplicityRow (fun i=>Ideal.span {p i}) hg pool b.1 z^3* + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg b.2 z + have hr (b : (ι→₀ℕ)×Finset ι) (hb:b∈Q×ˢpool.powerset) (z:O) : ‖r b z‖≤1 := by + dsimp [r] + rw [norm_mul,norm_pow] + calc + _ ≤ 1 * ‖finiteSquarefreeRow (fun i => Ideal.span {p i}) hg b.2 z‖ := + mul_le_mul_of_nonneg_right + (pow_le_one₀ (norm_nonneg _) (multiplicityRow_norm_le_one p hg pool b.1 z)) + (norm_nonneg _) + _ ≤ 1 := by simpa using finiteSquarefreeRow_norm_le_one _ hg b.2 z + have he:=bounded_row_square_expansion (Q×ˢpool.powerset) a r hr W K hK + simp only [Finset.sum_product] at he + change (∑'z:O,W (‖eisEmbedding z‖^2/K)* + (‖varyingReopenedRow p hp hcop hg pool Q β Ψ m f H z‖^2:ℝ))=_ at he + rw [he] + apply Finset.sum_congr rfl + intro v₂ hv₂ + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro v₁ hv₁ + simp only [canonicalCubeCorrelation,Finset.mul_sum] + apply Finset.sum_congr rfl + intro S hS + apply Finset.sum_congr rfl + intro T hT + have hB₁ : v₁.support⊆v₁.support∪v₂.support:=Finset.subset_union_left + have hB₂ : v₂.support⊆v₁.support∪v₂.support:=Finset.subset_union_right + have hr₁ (z:O) : multiplicityRow (fun i=>Ideal.span {p i}) hg pool v₁ z= + multiplicityRow (fun i=>Ideal.span {p i}) hg (v₁.support∪v₂.support) v₁ z := by + rw [multiplicityRow_support p hg pool v₁ (hQ v₁ hv₁),multiplicityRow_support p hg _ v₁ hB₁] + have hr₂ (z:O) : multiplicityRow (fun i=>Ideal.span {p i}) hg pool v₂ z= + multiplicityRow (fun i=>Ideal.span {p i}) hg (v₁.support∪v₂.support) v₂ z := by + rw [multiplicityRow_support p hg pool v₂ (hQ v₂ hv₂),multiplicityRow_support p hg _ v₂ hB₂] + simp only [a,r,canonicalCubeSourcePair,star_mul,hr₁,hr₂] + have ht : (∑'z:O,(star (finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z)* + star (multiplicityRow (fun i=>Ideal.span {p i}) hg (v₁.support∪v₂.support) v₂ z^3)* + (multiplicityRow (fun i=>Ideal.span {p i}) hg (v₁.support∪v₂.support) v₁ z^3* + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg T z))*W (‖eisEmbedding z‖^2/K))= + ∑'z:O,(star (finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z)* + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg T z* + star (multiplicityRow (fun i=>Ideal.span {p i}) hg (v₁.support∪v₂.support) v₂ z^3)* + multiplicityRow (fun i=>Ideal.span {p i}) hg (v₁.support∪v₂.support) v₁ z^3)*W (‖eisEmbedding z‖^2/K) := by + apply tsum_congr + intro z + ring + rw [ht] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedZeroEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedZeroEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..890f3388ba479f448988ba5310430f0e6228e9e5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ReopenedZeroEnergy.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstMarkedZeroSource +import OAI.NumberTheory.DirichletL.Descent.ReopenedPhysicalEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +theorem original_reopened_marked_zero_bound (ε : ℝ) (hε : 0<ε) : + ∃ C:ℝ,0Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hinj:Function.Injective (fun i=>Ideal.span {p i})) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (pool:Finset ι) (Q:Finset (ι→₀ℕ)) (labels:Finset (Ideal O)) + (β:Ideal O→(ι→₀ℕ)→ℂ) (Ψ:O→*ℂ) (m:O) + (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (W:ℝ→ℂ) (Φ:𝓢(ℝ,ℂ)) (Γ G L K B F:ℝ), + 0≤Γ → 0≤G → 0 + canonicalCubeDualZero p hp hcop hg pool b C Ψ Ψ m m + (ConcretePrimeRowBridge.idealGenerator I) + (fun U=>primeMark slots lists a (U∪b.rightExponent.support)*W (primeProductNorm p U)) + (fun U=>primeMark slots lists a (U∪b.leftExponent.support)*W (primeProductNorm p U)) Φ K)‖≤ + C*B^(1+ε)*L*F*Γ^2*((B^2*L)^ε)^2*(G^2*|K| *‖paperRadialFourier Φ 0‖) := by + obtain ⟨C,hC,he⟩ := full_marked_first_zero_bound ε hε + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg hinj hc pool Q labels β Ψ m slots lists a W Φ Γ G L K B F + hΓ hG hL hB hF hΨ hQ hn hFlabels hβ hslots ha hW hs + have hb := reopenedCubeFamily_cube_norms p Q B hQ + have hcoeff := reopenedPairCoefficient_bound Q labels β Γ hΓ hβ + have hh := he p hp hcop hg hinj hc pool (reopenedCubeFamily Q) labels + (reopenedPairCoefficient β) Ψ Ψ m m (fun _ U=>W (primeProductNorm p U)) + (fun _ U=>W (primeProductNorm p U)) + (fun b=>b.rightExponent.support) (fun b=>b.leftExponent.support) + slots lists a Φ (Γ^2) G G L K B F (sq_nonneg _) hG hG hL hB hF hΨ hΨ + (reopenedCubeFamily_admissible Q) (fun b hb'=> (hb b hb').1) (fun b hb'=> (hb b hb').2) + hn hFlabels (fun b hb C hC I hI=>hcoeff b hb C I hI) hslots ha + (fun _ _=>Finset.subset_union_right) (fun _ _=>Finset.subset_union_left) + (fun _ _=>hW) (fun _ _=>hW) (fun _ _=>hs) (fun _ _=>hs) + simpa only [reopenedPhysicalSourceSum,Finset.union_comm,pow_two] using hh + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/RootWindows.lean b/lean/OAI/NumberTheory/DirichletL/Descent/RootWindows.lean new file mode 100644 index 0000000000000000000000000000000000000000..aaab4ef2ba52103c22f0e09e3668ac5501b6e548 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/RootWindows.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Descent.WindowFourier + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section + +theorem inverseNormWindow_contDiff (V : ℝ → ℂ) (hV : ContDiff ℝ ∞ V) : + ContDiff ℝ ∞ (inverseNormWindow V) := by + unfold inverseNormWindow + have hn : ∀ y : ℝ, (Real.exp y : ℂ) ≠ 0 := by + intro y + exact_mod_cast Real.exp_ne_zero y + simpa only [div_eq_mul_inv, Pi.inv_apply, Function.comp_apply, Complex.ofRealCLM_apply] using + hV.mul ((Complex.ofRealCLM.contDiff.comp Real.contDiff_exp).inv hn) + +theorem inverseRootWindow_contDiff (V : ℝ → ℂ) (hV : ContDiff ℝ ∞ V) : + ContDiff ℝ ∞ (inverseRootWindow V) := by + unfold inverseRootWindow + have hs : ContDiff ℝ ∞ (fun y : ℝ => Real.sqrt (Real.exp y)) := + Real.contDiff_exp.sqrt Real.exp_ne_zero + have hn : ∀ y : ℝ, (Real.sqrt (Real.exp y) : ℂ) ≠ 0 := by + intro y + exact_mod_cast ne_of_gt (Real.sqrt_pos.2 (Real.exp_pos y)) + simpa only [div_eq_mul_inv, Pi.inv_apply, Function.comp_apply, Complex.ofRealCLM_apply] using + hV.mul ((Complex.ofRealCLM.contDiff.comp hs).inv hn) + +theorem inverseNormWindow_compact (V : ℝ → ℂ) (hV : HasCompactSupport V) : + HasCompactSupport (inverseNormWindow V) := by + apply hV.mono + intro y hy + exact (div_ne_zero_iff.mp hy).1 + +theorem inverseRootWindow_compact (V : ℝ → ℂ) (hV : HasCompactSupport V) : + HasCompactSupport (inverseRootWindow V) := by + apply hV.mono + intro y hy + exact (div_ne_zero_iff.mp hy).1 + +theorem firstRootWindows_smooth_compact (V : Fin 9 → ℝ → ℂ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) : + ∀ i, ContDiff ℝ ∞ (firstRootWindows V i) ∧ HasCompactSupport (firstRootWindows V i) := by + intro i + fin_cases i <;> first + | exact ⟨hV _, hS _⟩ + | exact ⟨inverseNormWindow_contDiff _ (hV _), inverseNormWindow_compact _ (hS _)⟩ + | exact ⟨inverseRootWindow_contDiff _ (hV _), inverseRootWindow_compact _ (hS _)⟩ + +theorem secondRootWindows_smooth_compact (V : Fin 6 → ℝ → ℂ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) : + ∀ i, ContDiff ℝ ∞ (secondRootWindows V i) ∧ HasCompactSupport (secondRootWindows V i) := by + intro i + fin_cases i <;> first + | exact ⟨hV _, hS _⟩ + | exact ⟨inverseNormWindow_contDiff _ (hV _), inverseNormWindow_compact _ (hS _)⟩ + | exact ⟨inverseRootWindow_contDiff _ (hV _), inverseRootWindow_compact _ (hS _)⟩ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondActualMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondActualMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..95851b941c1b7bcce0082cc24a70701a4f98fd64 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondActualMass.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondTripleBounds + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseInitialArithmetic (sourceIdeal) +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +lemma nonzero_ideal_norm_one (I : Ideal Eis) (hI : I ≠ 0) : 1 ≤ (Ideal.absNorm I : ℝ) := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hI) + +theorem triple_normalized_mass_source_bounds (K : ℕ) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ (Γ : Finset OuterTriple) (B T R : ℝ), + 0 < B → 0 < T → 0 < R → + (∀ γ ∈ Γ, γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0) → + (∀ γ ∈ Γ, (Ideal.absNorm γ.q0 : ℝ) ≤ B ∧ + (Ideal.absNorm γ.quotient : ℝ) ≤ T ∧ (Ideal.absNorm γ.residual : ℝ) ≤ R) → + (B*T*R)⁻¹ * (∑ γ ∈ Γ, tripleDivisorWeight K γ) ≤ C*(B*T*R)^ε := by + obtain ⟨C,hC,hb⟩ := triple_normalized_mass K ε hε + refine ⟨C,hC,?_⟩ + intro Γ B T R hB hT hR hz hn + rcases Γ.eq_empty_or_nonempty with he|⟨γ,hγ⟩ + · subst Γ + simp only [Finset.sum_empty,mul_zero] + positivity + · obtain ⟨hq,ht,hr⟩ := hz γ hγ + obtain ⟨hqb,htb,hrb⟩ := hn γ hγ + exact hb Γ B T R ((nonzero_ideal_norm_one _ hq).trans hqb) + ((nonzero_ideal_norm_one _ ht).trans htb) ((nonzero_ideal_norm_one _ hr).trans hrb) hz hn + +theorem actual_second_normalized_mass (K : ℕ) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {ι : Type} [DecidableEq ι] (p : ι → Eis) + (_hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) (u v : Eisˣ) + (Z ell R j t g theta eta : ℝ), 0 < Z → + (∀ x ∈ source, x.quotient ≠ 0) → + (∀ x ∈ source, x.second.divisor ⊆ x.second.sourceCommon) → + (∀ x ∈ source, ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x ∈ source, ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x ∈ source, primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(R+eta)) → + (∀ x ∈ source, Z^(j-eta) ≤ ‖eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x ∈ source, (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) → + (∀ x ∈ source, primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) → + (∀ x ∈ source, Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + Z^(-(ell+R/2-j+t+g-theta+11*eta/2)) * + (∑ γ ∈ actualSecondTriples p u v source,tripleDivisorWeight K γ) ≤ + C*Z^((ell+R/2-j+t+g-theta+11*eta/2)*ε) := by + obtain ⟨C,hC,hb⟩ := triple_normalized_mass_source_bounds K ε hε + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ Jo Jn source u v Z ell R j t g theta eta hZ ht hE h1 h2 ha hJ hT hG hD + have hz : ∀ γ ∈ actualSecondTriples p u v source, + γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0 := by + intro γ hγ + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hγ + exact (actualSecondChild_nonzero p hp u v x (ht x hx)).2 + have hn : ∀ γ ∈ actualSecondTriples p u v source, + (Ideal.absNorm γ.q0 : ℝ) ≤ Z^(ell+R/2-j+5*eta/2) ∧ + (Ideal.absNorm γ.quotient : ℝ) ≤ Z^(t+eta) ∧ + (Ideal.absNorm γ.residual : ℝ) ≤ Z^(g-theta+2*eta) := by + intro γ hγ + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hγ + refine ⟨actual_second_q0_power_bound p hp x u v Z ell R j eta hZ + (h1 x hx) (h2 x hx) (ha x hx) (hJ x hx),hT x hx,?_⟩ + have hr := second_residual_norm_power_bound p hp _ _ (hE x hx) Z g theta eta hZ (hG x hx) (hD x hx) + change (Ideal.absNorm (sourceIdeal p (x.second.sourceCommon\x.second.divisor)) : ℝ) ≤ _ + simpa only [sourceIdeal,←eisEmbedding_norm_sq_eq_absNorm_span,primeProductNorm] using hr + have hm := hb (actualSecondTriples p u v source) + (Z^(ell+R/2-j+5*eta/2)) (Z^(t+eta)) (Z^(g-theta+2*eta)) + (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) hz hn + have he : Z^(ell+R/2-j+5*eta/2)*Z^(t+eta)*Z^(g-theta+2*eta) = + Z^(ell+R/2-j+t+g-theta+11*eta/2) := by + rw [←Real.rpow_add hZ,←Real.rpow_add hZ] + congr 1 + ring + rw [he,←Real.rpow_mul hZ.le,←Real.rpow_neg hZ.le] at hm + exact hm + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondAdmissible.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAdmissible.lean new file mode 100644 index 0000000000000000000000000000000000000000..7cf2e76a8e5b25d07ff409c87fc1529e68188ce8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAdmissible.lean @@ -0,0 +1,112 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondTripleBounds +import OAI.NumberTheory.DirichletL.Descent.Basic + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseInitialArithmetic (sourceIdeal sourceIdeal_gen) +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) + (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem actual_second_inherited_puncture_ne_zero + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) : + actualSecondInheritedPuncture m (actualSecondChild p u v x).1 ≠ 0 := by + change ((m*ConcretePrimeRowBridge.idealGenerator x.quotient)* + primaryGenerator (Ideal.span {b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}))* + primaryGenerator (sourceIdeal p (x.second.sourceCommon\x.second.divisor)) ≠ 0 + rw [show primaryGenerator (Ideal.span {b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}) = + b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit from primaryGenerator_primeProduct p hp hpr _ _, + sourceIdeal_gen p hp hpr] + exact mul_ne_zero (mul_ne_zero (mul_ne_zero hm (ConcretePrimeRowBridge.idealGenerator_ne_zero _ ht)) + (primeProduct_ne_zero p hp _ _)) (Finset.prod_ne_zero_iff.mpr (fun i _ => hp i)) + +lemma radicalGenerator_ne_zero (a : Eis) (ha : a ≠ 0) : + ConcretePrimeRowBridge.idealGenerator (Ideal.span {a}).radical ≠ 0 := by + apply ConcretePrimeRowBridge.idealGenerator_ne_zero + intro hz + apply Ideal.span_singleton_eq_bot.not.mpr ha + apply le_antisymm _ bot_le + exact (Ideal.le_radical : (Ideal.span {a} : Ideal Eis) ≤ (Ideal.span {a}).radical).trans (le_of_eq hz) + +def actualSecondPunctureWidth (Z : ℝ) (m : Eis) (γ : OuterTriple) : ℝ := + Real.logb Z (‖eisEmbedding (actualSecondInheritedRadicalPuncture m γ)‖^2) + +include hp in +theorem actual_second_puncture_width_bound + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) + (Z Q ell t g theta eta : ℝ) (hZ : 1 < Z) + (hQ : (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) ≤ Z^Q) + (hB : primeProductNorm p x.cube.support ≤ Z^(ell+eta)) + (hT : (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + actualSecondPunctureWidth Z m (actualSecondChild p u v x).1 ≤ Q+ell+t+g-theta+4*eta := by + have hp0 := actual_second_inherited_puncture_ne_zero p hp hpr x ht u v m hm + have hr0 := radicalGenerator_ne_zero _ hp0 + change actualSecondInheritedRadicalPuncture m (actualSecondChild p u v x).1 ≠ 0 at hr0 + apply (Real.logb_le_iff_le_rpow hZ (sq_pos_of_pos + (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero hr0)))).mpr + exact actual_second_puncture_power_budget p hp hpr x hE ht u v m hm + Z Q ell t g theta eta (zero_lt_one.trans hZ) hQ hB hT hG hD + +include hp in + +theorem actual_second_child_margins + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht0 : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) + (Z F M Q z c ell A t g theta V j delta eta : ℝ) (hZ : 1 < Z) + (hparent : CanonicalMargins F M Q z c) + (hA : 0 ≤ A) (ht : 0 ≤ t) (hV : 0 ≤ V) (hj : 0 ≤ j) (hdelta : 0 ≤ delta) (heta : 0 ≤ eta) + (hQ : (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) ≤ Z^Q) + (hB : primeProductNorm p x.cube.support ≤ Z^(ell+eta)) + (hT : (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + CanonicalMargins (childF F ell A t g theta V j delta) + (childM M ell A t g theta V j eta) + (actualSecondPunctureWidth Z m (actualSecondChild p u v x).1) z (c-7*eta) := by + apply child_margins hparent hA ht hV hj + (actual_second_common_center p hp x hE Z g theta eta hZ hG hD) hdelta heta + have hwidth := actual_second_puncture_width_bound p hp hpr x hE ht0 u v m hm + Z Q ell t g theta eta hZ hQ hB hT hG hD + unfold decrease + linarith + +include hp in + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem actual_second_row_decrease + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) + (Z M ell A t g theta V j eta d : ℝ) (hZ : 1 < Z) + (hA : 0 ≤ A) (ht : 0 ≤ t) (hterminal : d ≤ ell+V) (heta : eta ≤ d/16) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) + (hJ : Z^(j-eta) ≤ ‖eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) : + 3*d/2 ≤ M-childM M ell A t g theta V j eta := + child_row_decrease hA ht (actual_second_common_center p hp x hE Z g theta eta hZ hG hD) + (actual_second_label_center p hp x Z ell j eta hZ h1 h2 hJ) hterminal heta + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondAllIntegral.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAllIntegral.lean new file mode 100644 index 0000000000000000000000000000000000000000..a88ec6cc2d58e484712391d7406b59d30144d353 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAllIntegral.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondAllModes + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondAllIntegralUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_all_modes_integral + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a,‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) + (hrows : ∀ x∈source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hslots₁ : slots₁.card ≤ K) (hslots₂ : slots₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x∈source,‖w x‖ ≤ 1) + (A : ℝ) (hA : 0 ≤ A) (J : ℕ) + (density : Frequency × (Fin 6 → ℝ) → ℂ) + (hDensity : Integrable (fun t : Frequency × (Fin 6 → ℝ) => + tripleHeight J t.1*coordinateHeight J t.2*‖density t‖)) + (hleft : ∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ A*(tripleHeight J t.1*coordinateHeight J t.2)) + (hright : ∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ A*(tripleHeight J t.1*coordinateHeight J t.2)) : + ‖∫ t : Frequency × (Fin 6 → ℝ),density t*secondFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X w t‖ ≤ + (36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖density t‖ := by + let C := 36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ + have hb (t : Frequency × (Fin 6 → ℝ)) : + ‖secondFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X w t‖ ≤ C*(tripleHeight J t.1*coordinateHeight J t.2) := by + have hh := actual_second_all_modes_bound p hp hcop hg hpr hinj hc source hs sector pool Ψ hΨ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ha₁ ha₂ ω₁ ω₂ G E V B X R t labels hlabels hrows + K ho hslots₁ hslots₂ w hw (A*(tripleHeight J t.1*coordinateHeight J t.2)) + (by unfold tripleHeight coordinateHeight; positivity) (hleft t) (hright t) + exact hh.trans_eq (by dsimp only [C]; ring) + calc + _ ≤ ∫ t : Frequency × (Fin 6 → ℝ),C*(tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) := by + apply norm_integral_le_of_norm_le (hDensity.const_mul C) + filter_upwards with t + rw [norm_mul] + exact (mul_le_mul_of_nonneg_left (hb t) (norm_nonneg _)).trans_eq (by ring) + _ = _ := integral_const_mul _ _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondAllModes.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAllModes.lean new file mode 100644 index 0000000000000000000000000000000000000000..3430e82c5f873fd62b81a335bd990051b3a7c697 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAllModes.lean @@ -0,0 +1,134 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondOriginalBound +import OAI.NumberTheory.DirichletL.Descent.SecondSectorAssembly + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondAllModesUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondFullModeSum {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (w : MarkedSecondSource ι Jo 0 → ℂ) + (t : Frequency × (Fin 6 → ℝ)) : ℂ := + ∑ uv : Eisˣ × Eisˣ,∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + ∑ x∈secondSourceSector source sector uv, + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t + +theorem secondFullModeSum_physical {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (w : MarkedSecondSource ι Jo 0 → ℂ) + (t : Frequency × (Fin 6 → ℝ)) : + secondFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X w t = + ∑ uv : Eisˣ × Eisˣ,∑ x∈secondSourceSector source sector uv, + (w x*actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x)* + ∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t := by + unfold secondFullModeSum + apply Finset.sum_congr rfl + intro uv huv + simp only [Finset.mul_sum] + symm + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro J₁ hJ₁ + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro J₂ hJ₂ + apply Finset.sum_congr rfl + intro x hx + ring + +theorem actual_second_all_modes_bound + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a,‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) + (hrows : ∀ x∈source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hslots₁ : slots₁.card ≤ K) (hslots₂ : slots₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x∈source,‖w x‖ ≤ 1) + (A : ℝ) (hA : 0 ≤ A) + (hleft : ∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ A) + (hright : ∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ A) : + ‖secondFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X w t‖ ≤ + 36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ := by + let mass := ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ + have hbound (uv : Eisˣ × Eisˣ) (J₁ : Finset σ) (hJ₁ : J₁∈slots₁.powerset) + (J₂ : Finset σ) (hJ₂ : J₂∈slots₂.powerset) : + ‖∑ x∈secondSourceSector source sector uv, + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x*w x* + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ A*mass := by + have hsub : secondSourceSector source sector uv ⊆ source := Finset.filter_subset _ _ + have ht := actualSecondTriples_mono p 1 1 hsub + have h := actual_second_mode_original_bound p hp hcop hg hpr hinj hc uv.1 uv.2 + (secondSourceSector source sector uv) (hs.mono p hsub) pool Ψ hΨ m z + slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + (fun i hi => ha₁ i (Finset.mem_powerset.mp hJ₁ hi)) + (fun i hi => ha₂ i (Finset.mem_powerset.mp hJ₂ hi)) ω₁ ω₂ G E V B X R t labels + (fun x hx => hlabels x (hsub hx)) (fun x hx => hrows x (hsub hx)) K ho + ((Finset.card_le_card (Finset.mem_powerset.mp hJ₁)).trans hslots₁) + ((Finset.card_le_card (Finset.mem_powerset.mp hJ₂)).trans hslots₂) + w (fun x hx => hw x (hsub hx)) A hA + (fun γ hγ => hleft J₁ hJ₁ γ (ht hγ)) (fun γ hγ => hright J₂ hJ₂ γ (ht hγ)) + exact h.trans (mul_le_mul_of_nonneg_left (Finset.sum_le_sum_of_subset_of_nonneg ht + (fun γ _ _ => tripleDivisorWeight_nonneg K γ)) hA) + calc + _ ≤ ∑ uv : Eisˣ × Eisˣ,∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + ‖∑ x∈secondSourceSector source sector uv, + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x*w x* + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t‖ := by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro uv huv + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro J₁ hJ₁ + exact norm_sum_le _ _ + _ ≤ ∑ _uv : Eisˣ × Eisˣ,∑ _J₁∈slots₁.powerset,∑ _J₂∈slots₂.powerset,A*mass := by + apply Finset.sum_le_sum + intro uv huv + apply Finset.sum_le_sum + intro J₁ hJ₁ + exact Finset.sum_le_sum (fun J₂ hJ₂ => hbound uv J₁ hJ₁ J₂ hJ₂) + _ = _ := by + simp only [Finset.sum_const,Finset.card_univ,Finset.card_powerset,nsmul_eq_mul, + second_unit_sector_card,Nat.cast_pow,Nat.cast_ofNat,mass] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondAssignedSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAssignedSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..5bb0c8956fdc61c5c1f7a4d8532eb41a8db5d257 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAssignedSource.lean @@ -0,0 +1,160 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondCanonicalSplit +import OAI.NumberTheory.DirichletL.Descent.SlotAssignments + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + +def pairedSlotAssignment (J₁ J₂ : Finset σ) + (q : (∀ i ∈ J₁, ι) × (∀ i ∈ J₂, ι)) : Fin (J₁.card+J₂.card) → ι := + Fin.addCases (indexedSlotAssignment J₁ q.1) (indexedSlotAssignment J₂ q.2) + +omit [DecidableEq ι] [DecidableEq σ] in +theorem pairedSlotAssignment_injective (J₁ J₂ : Finset σ) : + Function.Injective (pairedSlotAssignment (ι:=ι) J₁ J₂) := by + intro q r h + apply Prod.ext + · apply indexedSlotAssignment_injective J₁ + funext j + simpa only [pairedSlotAssignment,Fin.addCases_left] using congrFun h (Fin.castAdd J₂.card j) + · apply indexedSlotAssignment_injective J₂ + funext j + simpa only [pairedSlotAssignment,Fin.addCases_right] using congrFun h (Fin.natAdd J₁.card j) + +def pairedSlotWeight (J₁ J₂ : Finset σ) (a₁ a₂ : σ → ι → ℂ) + (q : (∀ i ∈ J₁, ι) × (∀ i ∈ J₂, ι)) : ℂ := + star (slotAssignmentWeight J₁ a₁ q.1)*slotAssignmentWeight J₂ a₂ q.2 + +theorem paired_primeMark_assignments (J₁ J₂ : Finset σ) + (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) (A : Finset ι) : + star (primeMark J₁ L₁ a₁ A)*primeMark J₂ L₂ a₂ A = + ∑ q ∈ (J₁.pi (fun i => L₁ i∩A)) ×ˢ (J₂.pi (fun i => L₂ i∩A)), + pairedSlotWeight J₁ J₂ a₁ a₂ q := by + rw [primeMark_supported_assignments,primeMark_supported_assignments] + simp only [star_sum,Finset.sum_product,pairedSlotWeight,Finset.sum_mul,Finset.mul_sum] + exact Finset.sum_comm + +theorem pairedSlotWeight_norm_le_one (J₁ J₂ : Finset σ) + (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) (A : Finset ι) + (q : (∀ i ∈ J₁, ι) × (∀ i ∈ J₂, ι)) + (hq : q ∈ (J₁.pi (fun i => L₁ i∩A)) ×ˢ (J₂.pi (fun i => L₂ i∩A))) + (ha₁ : ∀ i ∈ J₁, ∀ p ∈ L₁ i, ‖a₁ i p‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ p ∈ L₂ i, ‖a₂ i p‖ ≤ 1) : + ‖pairedSlotWeight J₁ J₂ a₁ a₂ q‖ ≤ 1 := by + rw [pairedSlotWeight,norm_mul,norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) + (slotAssignmentWeight_norm_le_one J₁ L₁ a₁ A q.1 (Finset.mem_product.mp hq).1 ha₁)).trans + (slotAssignmentWeight_norm_le_one J₂ L₂ a₂ A q.2 (Finset.mem_product.mp hq).2 ha₂) + +def attachSecondSlots {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo 0) + (newAssigned : Fin Jn → ι) : MarkedSecondSource ι Jo Jn where + cube := x.cube + firstCommon := x.firstCommon + firstDivisor := x.firstDivisor + second := x.second + quotient := x.quotient + oldAssigned := x.oldAssigned + newAssigned := newAssigned + +omit [DecidableEq ι] in +theorem attachSecondSlots_injective {Jo Jn : ℕ} : + Function.Injective (fun q : MarkedSecondSource ι Jo 0 × (Fin Jn → ι) => attachSecondSlots q.1 q.2) := by + intro q r h + apply Prod.ext + · apply MarkedSecondSource.ext + · exact congrArg (fun z : MarkedSecondSource ι Jo Jn => z.cube) h + · exact congrArg (fun z : MarkedSecondSource ι Jo Jn => z.firstCommon) h + · exact congrArg (fun z : MarkedSecondSource ι Jo Jn => z.firstDivisor) h + · exact congrArg (fun z : MarkedSecondSource ι Jo Jn => z.second) h + · exact congrArg (fun z : MarkedSecondSource ι Jo Jn => z.quotient) h + · exact congrArg (fun z : MarkedSecondSource ι Jo Jn => z.oldAssigned) h + · funext i; exact Fin.elim0 i + · exact congrArg MarkedSecondSource.newAssigned h + +def attachPairedSlots {Jo : ℕ} (J₁ J₂ : Finset σ) + (q : MarkedSecondSource ι Jo 0 × ((∀ i ∈ J₁, ι) × (∀ i ∈ J₂, ι))) : + MarkedSecondSource ι Jo (J₁.card+J₂.card) := + attachSecondSlots q.1 (pairedSlotAssignment J₁ J₂ q.2) + +omit [DecidableEq ι] [DecidableEq σ] in +theorem attachPairedSlots_injective {Jo : ℕ} (J₁ J₂ : Finset σ) : + Function.Injective (attachPairedSlots (ι:=ι) (Jo:=Jo) J₁ J₂) := by + intro q r h + have he := @attachSecondSlots_injective ι Jo (J₁.card+J₂.card) + (q.1,pairedSlotAssignment J₁ J₂ q.2) (r.1,pairedSlotAssignment J₁ J₂ r.2) h + exact Prod.ext (congrArg (fun z : MarkedSecondSource ι Jo 0 × (Fin (J₁.card+J₂.card) → ι) => z.1) he) + (pairedSlotAssignment_injective J₁ J₂ + (congrArg (fun z : MarkedSecondSource ι Jo 0 × (Fin (J₁.card+J₂.card) → ι) => z.2) he)) + +def assignedSecondSource {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) : + Finset (MarkedSecondSource ι Jo (J₁.card+J₂.card)) := + ((source ×ˢ ((J₁.pi (fun i => L₁ i)) ×ˢ (J₂.pi (fun i => L₂ i)))).filter + (fun q => ∀ j, pairedSlotAssignment J₁ J₂ q.2 j ∈ q.1.second.sourceCommon∪q.1.second.overlap)).image + (attachPairedSlots J₁ J₂) + +theorem mem_assignedSecondSource {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) + (x : MarkedSecondSource ι Jo (J₁.card+J₂.card)) : + x ∈ assignedSecondSource source J₁ J₂ L₁ L₂ ↔ + ∃ y ∈ source, ∃ q₁ ∈ J₁.pi (fun i => L₁ i∩(y.second.sourceCommon∪y.second.overlap)), + ∃ q₂ ∈ J₂.pi (fun i => L₂ i∩(y.second.sourceCommon∪y.second.overlap)), + attachPairedSlots J₁ J₂ (y,(q₁,q₂)) = x := by + constructor + · intro hx + obtain ⟨⟨y,q₁,q₂⟩,hmem,rfl⟩ := Finset.mem_image.mp hx + obtain ⟨hmem,hs⟩ := Finset.mem_filter.mp hmem + obtain ⟨hy,hq⟩ := Finset.mem_product.mp hmem + obtain ⟨hq₁,hq₂⟩ := Finset.mem_product.mp hq + refine ⟨y,hy,q₁,Finset.mem_pi.mpr ?_,q₂,Finset.mem_pi.mpr ?_,rfl⟩ + · intro i hi + refine Finset.mem_inter.mpr ⟨Finset.mem_pi.mp hq₁ i hi,?_⟩ + simpa [pairedSlotAssignment,indexedSlotAssignment] using hs (Fin.castAdd J₂.card (J₁.equivFin ⟨i,hi⟩)) + · intro i hi + refine Finset.mem_inter.mpr ⟨Finset.mem_pi.mp hq₂ i hi,?_⟩ + simpa [pairedSlotAssignment,indexedSlotAssignment] using hs (Fin.natAdd J₁.card (J₂.equivFin ⟨i,hi⟩)) + · rintro ⟨y,hy,q₁,hq₁,q₂,hq₂,rfl⟩ + apply Finset.mem_image.mpr + refine ⟨(y,(q₁,q₂)),Finset.mem_filter.mpr ⟨Finset.mem_product.mpr ⟨hy,Finset.mem_product.mpr ⟨?_,?_⟩⟩,?_⟩,rfl⟩ + · exact Finset.mem_pi.mpr (fun i hi => (Finset.mem_inter.mp (Finset.mem_pi.mp hq₁ i hi)).1) + · exact Finset.mem_pi.mpr (fun i hi => (Finset.mem_inter.mp (Finset.mem_pi.mp hq₂ i hi)).1) + · intro j + refine Fin.addCases (fun k => ?_) (fun k => ?_) j + · simpa only [pairedSlotAssignment,Fin.addCases_left] using + (Finset.mem_inter.mp (indexedSlotAssignment_support J₁ L₁ _ q₁ hq₁ k)).2 + · simpa only [pairedSlotAssignment,Fin.addCases_right] using + (Finset.mem_inter.mp (indexedSlotAssignment_support J₂ L₂ _ q₂ hq₂ k)).2 + +theorem assignedSecondSource_conditions (p : ι → Eis) [∀ i, (Ideal.span {p i}).IsMaximal] + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) : + ActualSecondSourceConditions p (assignedSecondSource source J₁ J₂ L₁ L₂) := by + have hmem : ∀ x ∈ assignedSecondSource source J₁ J₂ L₁ L₂, + ∃ y ∈ source, ∃ q, attachPairedSlots J₁ J₂ (y,q)=x ∧ + ∀ j, pairedSlotAssignment J₁ J₂ q j ∈ y.second.sourceCommon∪y.second.overlap := by + intro x hx + obtain ⟨⟨y,q⟩,hmem,he⟩ := Finset.mem_image.mp hx + obtain ⟨hmem,hq⟩ := Finset.mem_filter.mp hmem + exact ⟨y,(Finset.mem_product.mp hmem).1,q,he,hq⟩ + constructor + all_goals + intro x hx + obtain ⟨y,hy,q,rfl,hq⟩ := hmem x hx + · exact hs.admissible y hy + · exact hs.common_disjoint y hy + · exact hs.first_divisor y hy + · exact hs.second_divisor y hy + · exact hs.old_support y hy + · exact hq + · exact hs.quotient_nonzero y hy + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondAssignedSum.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAssignedSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..8b54644d2623b66e9057e863b7b702296a2903cc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondAssignedSum.lean @@ -0,0 +1,126 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondAssignedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +noncomputable section +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + +omit [DecidableEq ι] [DecidableEq σ] in +lemma indexedSlotAssignment_apply (I : Finset σ) (q : ∀ i ∈ I,ι) (i : σ) (hi : i ∈ I) : + indexedSlotAssignment I q (I.equivFin ⟨i,hi⟩) = q i hi := by + exact congrArg (fun j : I => q j.val j.property) ((I.equivFin).symm_apply_apply ⟨i,hi⟩) + +def eraseSecondSlots {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) : MarkedSecondSource ι Jo 0 where + cube := x.cube + firstCommon := x.firstCommon + firstDivisor := x.firstDivisor + second := x.second + quotient := x.quotient + oldAssigned := x.oldAssigned + newAssigned := Fin.elim0 + +omit [DecidableEq ι] in +@[simp] theorem erase_attachSecondSlots {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo 0) (a : Fin Jn → ι) : + eraseSecondSlots (attachSecondSlots x a) = x := by + apply MarkedSecondSource.ext <;> try rfl + funext i + exact Fin.elim0 i + +def assignedSecondCoefficient {Jo : ℕ} (J₁ J₂ : Finset σ) (a₁ a₂ : σ → ι → ℂ) + (x : MarkedSecondSource ι Jo (J₁.card+J₂.card)) : ℂ := + star (slotAssignmentWeight J₁ a₁ + (fun i hi => x.newAssigned (Fin.castAdd J₂.card (J₁.equivFin ⟨i,hi⟩)))) * + slotAssignmentWeight J₂ a₂ + (fun i hi => x.newAssigned (Fin.natAdd J₁.card (J₂.equivFin ⟨i,hi⟩))) + +omit [DecidableEq ι] [DecidableEq σ] in +@[simp] theorem assignedSecondCoefficient_attach {Jo : ℕ} + (J₁ J₂ : Finset σ) (a₁ a₂ : σ → ι → ℂ) + (x : MarkedSecondSource ι Jo 0) (q : (∀ i ∈ J₁,ι) × (∀ i ∈ J₂,ι)) : + assignedSecondCoefficient J₁ J₂ a₁ a₂ (attachPairedSlots J₁ J₂ (x,q)) = + pairedSlotWeight J₁ J₂ a₁ a₂ q := by + simp only [assignedSecondCoefficient,attachPairedSlots,attachSecondSlots, + pairedSlotAssignment,Fin.addCases_left,Fin.addCases_right,indexedSlotAssignment_apply,pairedSlotWeight] + +theorem paired_assignment_filter (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) (A : Finset ι) : + ((J₁.pi L₁) ×ˢ (J₂.pi L₂)).filter (fun q => ∀ j, pairedSlotAssignment J₁ J₂ q j ∈ A) = + (J₁.pi (fun i => L₁ i∩A)) ×ˢ (J₂.pi (fun i => L₂ i∩A)) := by + ext q + constructor + · intro hq + obtain ⟨hmem,hs⟩ := Finset.mem_filter.mp hq + obtain ⟨hq₁,hq₂⟩ := Finset.mem_product.mp hmem + apply Finset.mem_product.mpr + constructor + · apply Finset.mem_pi.mpr + intro i hi + refine Finset.mem_inter.mpr ⟨Finset.mem_pi.mp hq₁ i hi,?_⟩ + simpa only [pairedSlotAssignment,Fin.addCases_left,Fin.addCases_right,indexedSlotAssignment_apply] using hs (Fin.castAdd J₂.card (J₁.equivFin ⟨i,hi⟩)) + · apply Finset.mem_pi.mpr + intro i hi + refine Finset.mem_inter.mpr ⟨Finset.mem_pi.mp hq₂ i hi,?_⟩ + simpa only [pairedSlotAssignment,Fin.addCases_left,Fin.addCases_right,indexedSlotAssignment_apply] using hs (Fin.natAdd J₁.card (J₂.equivFin ⟨i,hi⟩)) + · intro hq + obtain ⟨hq₁,hq₂⟩ := Finset.mem_product.mp hq + refine Finset.mem_filter.mpr ⟨Finset.mem_product.mpr ⟨?_,?_⟩,?_⟩ + · exact Finset.mem_pi.mpr (fun i hi => (Finset.mem_inter.mp (Finset.mem_pi.mp hq₁ i hi)).1) + · exact Finset.mem_pi.mpr (fun i hi => (Finset.mem_inter.mp (Finset.mem_pi.mp hq₂ i hi)).1) + · intro j + refine Fin.addCases (fun k => ?_) (fun k => ?_) j + · simpa only [pairedSlotAssignment,Fin.addCases_left] using + (Finset.mem_inter.mp (indexedSlotAssignment_support J₁ L₁ _ q.1 hq₁ k)).2 + · simpa only [pairedSlotAssignment,Fin.addCases_right] using + (Finset.mem_inter.mp (indexedSlotAssignment_support J₂ L₂ _ q.2 hq₂ k)).2 + +theorem assignedSecondSource_sum {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) + (F : MarkedSecondSource ι Jo (J₁.card+J₂.card) → ℂ) : + ∑ x ∈ assignedSecondSource source J₁ J₂ L₁ L₂, F x = + ∑ y ∈ source, ∑ q ∈ + (J₁.pi (fun i => L₁ i∩(y.second.sourceCommon∪y.second.overlap))) ×ˢ + (J₂.pi (fun i => L₂ i∩(y.second.sourceCommon∪y.second.overlap))), + F (attachPairedSlots J₁ J₂ (y,q)) := by + rw [assignedSecondSource,Finset.sum_image (fun q _ r _ h => attachPairedSlots_injective J₁ J₂ h), + Finset.sum_filter,Finset.sum_product] + apply Finset.sum_congr rfl + intro y hy + rw [←Finset.sum_filter] + dsimp only + rw [paired_assignment_filter] + +theorem assignedSecondSource_sum_marks {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (w P : MarkedSecondSource ι Jo 0 → ℂ) : + (∑ y ∈ source, w y * (star (primeMark J₁ L₁ a₁ (y.second.sourceCommon∪y.second.overlap)) * + primeMark J₂ L₂ a₂ (y.second.sourceCommon∪y.second.overlap)) * P y) = + ∑ x ∈ assignedSecondSource source J₁ J₂ L₁ L₂, + (w (eraseSecondSlots x)*assignedSecondCoefficient J₁ J₂ a₁ a₂ x) * P (eraseSecondSlots x) := by + rw [assignedSecondSource_sum] + apply Finset.sum_congr rfl + intro y hy + rw [paired_primeMark_assignments] + simp only [Finset.mul_sum,Finset.sum_mul] + apply Finset.sum_congr rfl + intro q hq + rw [assignedSecondCoefficient_attach] + simp only [attachPairedSlots,erase_attachSecondSlots] + +theorem assignedSecondCoefficient_norm_le_one {Jo : ℕ} + (source : Finset (MarkedSecondSource ι Jo 0)) (J₁ J₂ : Finset σ) + (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ p ∈ L₁ i, ‖a₁ i p‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ p ∈ L₂ i, ‖a₂ i p‖ ≤ 1) + (x : MarkedSecondSource ι Jo (J₁.card+J₂.card)) + (hx : x ∈ assignedSecondSource source J₁ J₂ L₁ L₂) : + ‖assignedSecondCoefficient J₁ J₂ a₁ a₂ x‖ ≤ 1 := by + obtain ⟨y,hy,q₁,hq₁,q₂,hq₂,rfl⟩ := (mem_assignedSecondSource source J₁ J₂ L₁ L₂ x).mp hx + rw [assignedSecondCoefficient_attach] + exact pairedSlotWeight_norm_le_one J₁ J₂ L₁ L₂ a₁ a₂ _ (q₁,q₂) + (Finset.mem_product.mpr ⟨hq₁,hq₂⟩) ha₁ ha₂ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondBalancedPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBalancedPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..49ba7200ad35003d51cdafb5db5318c73604c531 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBalancedPhysical.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeIntegral +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondBalancedPhysicalUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +universe u₁ u₂ +variable {ι : Type u₁} {σ : Type u₂} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_balanced_profile_children + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∃ sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ, + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (G E V B X Y R L : ℝ) + (U : Fin 6 → ℝ → ℂ) (density : Frequency × (Fin 6 → ℝ) → ℂ) + (w : MarkedSecondSource ι Jo 0 → ℂ), + 0 < G → 0 < E → 0 < V → 0 < B → 0 < X → Integrable density → + (∀ y : Fin 6 → ℝ,(Real.exp (-6*L):ℂ)*secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ U + (Y*B/(E*V^2*X^2)) y = ∫ t : Frequency × (Fin 6 → ℝ),density t* + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₁ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₁ (primeProductNorm p N/X) = 1) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₂ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₂ (primeProductNorm p N/X) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/X) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X) ≠ 0 → ∀ i, + U i (secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B X i) = 1) → + (Real.exp (-6*L):ℂ) * ((Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G*V*X))) = + ((Y : ℂ)*secondRayCoefficient z*((E*V*X : ℝ):ℂ)⁻¹) * + ∫ t : Frequency × (Fin 6 → ℝ),density t * + ∑ uv : Eisˣ × Eisˣ,∑ x ∈ secondSourceSector source sector uv, + (w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + ∑ J₁ ∈ slots₁.powerset,∑ J₂ ∈ slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t := by + obtain ⟨sector,hsector⟩ := actual_second_modes_common_sectors p hp hcop hg hpr (σ:=σ) source hs + refine ⟨sector,?_⟩ + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B X Y R L + U density w hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + have hn : ∀ x ∈ source,(secondInheritedProfile p x Ψ m z).divisor ≠ 0 ∧ + (secondInheritedProfile p x Ψ m z).frequency ≠ 0 := by + intro x hx + refine ⟨primeSubsetGenerator_ne_zero _ _,?_⟩ + have hh := (mem_nonzeroChildFrequencyBall _ (actualSecondMultiplier_ne_zero p x) R _).mp (hrows x hx) + intro he + change x.second.frequency = 0 at he + simp only [he,mul_zero,map_zero,norm_zero,zero_pow (by omega : 2 ≠ 0),lt_self_iff_false] at hh + exact hh.1 + have he := actual_second_balanced_source p hp hcop hg source pool + (fun x : MarkedSecondSource ι Jo 0 => secondInheritedProfile p x Ψ m z) + (fun x : MarkedSecondSource ι Jo 0 => w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ U G E V B X Y L + hG hE hV hB hX density hDensity hsep hn hω₁ hω₂ hcut + calc + _ = ((Y:ℂ)*secondRayCoefficient z) * ((Real.exp (-6*L):ℂ)* + ∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G*V*X)) := by ring + _ = _ := by + rw [he] + rw [←mul_assoc] + apply congrArg (fun a : ℂ => ((Y:ℂ)*secondRayCoefficient z*((E*V*X:ℝ):ℂ)⁻¹)*a) + apply integral_congr_ae + filter_upwards with t + apply congrArg (fun a : ℂ => density t*a) + exact hsector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondBalancedSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBalancedSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..212cbd693bb945a699f2f6dd8593f2814e3f3b80 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBalancedSource.lean @@ -0,0 +1,80 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDensityAssembly +import OAI.NumberTheory.DirichletL.Inversion.SecondProfileUniform + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem balanced_density_integrable (g : Fin 6 → 𝓢(ℝ,ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ,ℂ)) + (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) : + Integrable (InverseSecondProfileUniform.density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L) := by + exact (full_density_integrable _ _ _ _).const_mul _ + +theorem balanced_density_weighted_integrable (g : Fin 6 → 𝓢(ℝ,ℂ)) (g₁ g₂ b₃ : 𝓢(ℝ,ℂ)) + (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ L : ℝ) (J : ℕ) : + Integrable (fun t : Frequency × (Fin 6 → ℝ) => tripleHeight J t.1*coordinateHeight J t.2* + ‖InverseSecondProfileUniform.density g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L t‖) := + InverseSecondProfileUniform.density_weighted_integrable g g₁ g₂ b₃ ρ c₁ c₂ θ₁ θ₂ L J + +variable {κ ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_balanced_source (source : Finset κ) (F : Finset ι) + (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (V : Fin 6 → ℝ → ℂ) + (G₀ E₀ V₀ K₀ X₀ Y L : ℝ) + (hG : 0 < G₀) (hE : 0 < E₀) (hV : 0 < V₀) (hK : 0 < K₀) (hX : 0 < X₀) + (density : Frequency × (Fin 6 → ℝ) → ℂ) (hDensity : Integrable density) + (hsep : ∀ y : Fin 6 → ℝ, + (Real.exp (-6*L):ℂ) * secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ V + (Y*K₀/(E₀*V₀^2*X₀^2)) y = + ∫ t : Frequency × (Fin 6 → ℝ), density t * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) + (hn : ∀ j ∈ source,(x j).divisor ≠ 0 ∧ (x j).frequency ≠ 0) + (hω₁ : ∀ j ∈ source, ∀ N ∈ (F\(x j).overlap).powerset, + W₁ (primeProductNorm p (x j).common*primeProductNorm p (x j).overlap*primeProductNorm p N/(G₀*V₀*X₀)) ≠ 0 → + ω₁ (primeProductNorm p N/X₀) = 1) + (hω₂ : ∀ j ∈ source, ∀ N ∈ (F\(x j).overlap).powerset, + W₂ (primeProductNorm p (x j).common*primeProductNorm p (x j).overlap*primeProductNorm p N/(G₀*V₀*X₀)) ≠ 0 → + ω₂ (primeProductNorm p N/X₀) = 1) + (hcut : ∀ j ∈ secondProfileIndices source F x, + ω₁ (primeProductNorm p j.2.1/X₀) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X₀) ≠ 0 → ∀ i, + V i (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀ i) = 1) : + (Real.exp (-6*L):ℂ) * (∑ j ∈ source,w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀:ℝ):ℂ)⁻¹ * ∫ t : Frequency × (Fin 6 → ℝ),density t * + ∑ j ∈ source,w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ t := by + apply actualSecondFreshRows_normalized_density p hp hcop hg source F x w + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ Y G₀ E₀ V₀ K₀ X₀ density hDensity + intro j hj + obtain ⟨hjS,hN,hM⟩ := (mem_secondProfileIndices source F x j).mp hj + have h1 : star (W₁ (primeProductNorm p (x j.1).common*primeProductNorm p (x j.1).overlap* + primeProductNorm p j.2.1/(G₀*V₀*X₀))) ≠ 0 → star (ω₁ (primeProductNorm p j.2.1/X₀)) = 1 := by + intro hh + rw [hω₁ j.1 hjS j.2.1 hN (star_ne_zero.mp hh),star_one] + have h2 := hω₂ j.1 hjS j.2.2 hM + have h3 : star (ω₁ (primeProductNorm p j.2.1/X₀)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X₀) ≠ 0 → ∀ i, + V i (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀ i) = 1 := + fun ha hb => hcut j hj (star_ne_zero.mp ha) hb + have he := InverseSecondProfileUniform.fresh_physical_profile + (fun x => star (W₁ x)) W₂ Φ V G₀ E₀ V₀ K₀ X₀ Y L hG hE hV hK hX + (fun x => star (ω₁ x)) ω₂ (secondActualNorms p (x j.1) j.2.1 j.2.2) + (secondActualNorms_pos p hp (x j.1) (hn j.1 hjS).1 (hn j.1 hjS).2 j.2.1 j.2.2) + (by simpa [secondActualNorms] using h1) + (by simpa [secondActualNorms] using h2) + (by simpa [secondActualNorms] using h3) + rw [hsep] at he + simpa [secondActualNorms] using he + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..8cbf69dcc5d3fc57a98f484ecf3f3a8cffbbb281 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergy.lean @@ -0,0 +1,109 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows + +namespace OAI + +noncomputable section +open scoped BigOperators Classical ContDiff SchwartzMap + +namespace SevenEighths.InverseMoment +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory InverseInitialClippedColumns +open InverseSecondProfileUniform InverseAmbientProfileTower +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_second_fixed_block_recursive + (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) (m₁ m₂ bcap : ℝ) + (lo hi : Fin 4→ℝ) (B₀ : Fin 6→ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) (hcap : 1≤bcap) + (hlo : ∀ i,0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (G E V B Y R L Z N Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,∀ i,InverseSecondChildWindows.actualOuterRatios p x G E V B i∈Set.Icc (lo i) (hi i)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨ω₁,ω₂,U₀,M₀,af,bf,haf,habf,hωc₁,hωc₂,hωs₁,hωs₂,hM,hUc,hUs,hwindows⟩ := + InverseSecondChildWindows.actual_second_child_windows g₁ g₂ m₁ m₂ bcap lo hi B₀ + hm₁ hm₂ hcap hg₁ hg₂ hlo hhi hB₀ + obtain ⟨C,hC,henergy⟩ := actual_second_deleted_moving_mass_recursive (ι:=ι) (σ:=σ) + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hUs hg₁ hg₂ Aker J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,habf,hωc₁,hωc₂,hωs₁,hωs₂,C,hC,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + G E V B Y R L Z N Vlabel εchild ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hblock hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + obtain ⟨hω₁,hω₂,hcut⟩ := hwindows p hp source pool Ψ m z G E V B (Z^N) ρ c₁ c₂ θ₁ θ₂ + hG hE hV hB hX hρ hc₁ hc₁b hc₂ hc₂b hblock + exact henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ ω₁ ω₂ G E V B Y R L Z N Vlabel εchild + ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergyWindowOrder.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergyWindowOrder.lean new file mode 100644 index 0000000000000000000000000000000000000000..64473f276a7ed21efba46ce8a1199fea8d879931 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergyWindowOrder.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows + +namespace OAI + +noncomputable section +open scoped BigOperators Classical ContDiff SchwartzMap + +namespace SevenEighths.InverseMoment +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory InverseInitialClippedColumns +open InverseSecondProfileUniform InverseAmbientProfileTower +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_second_fixed_block_recursive_window_order + (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) (m₁ m₂ bcap : ℝ) + (lo hi : Fin 4→ℝ) (B₀ : Fin 6→ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) (hcap : 1≤bcap) + (hlo : ∀ i,0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (G E V B Y R L Z N Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,∀ i,InverseSecondChildWindows.actualOuterRatios p x G E V B i∈Set.Icc (lo i) (hi i)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨ω₁,ω₂,U₀,M₀,af,bf,haf,habf,hωc₁,hωc₂,hωs₁,hωs₂,hM,hUc,hUs,hwindows⟩ := + InverseSecondChildWindows.actual_second_child_windows g₁ g₂ m₁ m₂ bcap lo hi B₀ + hm₁ hm₂ hcap hg₁ hg₂ hlo hhi hB₀ + refine ⟨ω₁,ω₂,af,bf,haf,habf,hωc₁,hωc₂,hωs₁,hωs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩ := actual_second_deleted_moving_mass_recursive (ι:=ι) (σ:=σ) + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hUs hg₁ hg₂ Aker J K εmass hεmass + refine ⟨C,hC,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + G E V B Y R L Z N Vlabel εchild ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hblock hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + obtain ⟨hω₁,hω₂,hcut⟩ := hwindows p hp source pool Ψ m z G E V B (Z^N) ρ c₁ c₂ θ₁ θ₂ + hG hE hV hB hX hρ hc₁ hc₁b hc₂ hc₂b hblock + exact henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ ω₁ ω₂ G E V B Y R L Z N Vlabel εchild + ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergyWindowOrderUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergyWindowOrderUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..182976cb3d5a06a9881d9ff421eea9cb82f2257a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondBlockEnergyWindowOrderUniform.lean @@ -0,0 +1,112 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondBlockEnergyWindowOrder +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingMassUniform +import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows + +namespace OAI + +noncomputable section +open scoped BigOperators Classical ContDiff SchwartzMap + +namespace SevenEighths.InverseMoment +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory InverseInitialClippedColumns +open InverseSecondProfileUniform InverseAmbientProfileTower +local notation "Eis" => ActualEisensteinCubic.O +theorem actual_second_fixed_block_recursive_window_order_uniform_types + (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) (m₁ m₂ bcap : ℝ) + (lo hi : Fin 4→ℝ) (B₀ : Fin 6→ℝ) + (hm₁ : 0≤m₁) (hm₂ : 0≤m₂) (hcap : 1≤bcap) + (hlo : ∀ i,0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (G E V B Y R L Z N Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,∀ i,InverseSecondChildWindows.actualOuterRatios p x G E V B i∈Set.Icc (lo i) (hi i)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨ω₁,ω₂,U₀,M₀,af,bf,haf,habf,hωc₁,hωc₂,hωs₁,hωs₂,hM,hUc,hUs,hwindows⟩ := + InverseSecondChildWindows.actual_second_child_windows g₁ g₂ m₁ m₂ bcap lo hi B₀ + hm₁ hm₂ hcap hg₁ hg₂ hlo hhi hB₀ + refine ⟨ω₁,ω₂,af,bf,haf,habf,hωc₁,hωc₂,hωs₁,hωs₂,?_⟩ + intro J + obtain ⟨C,hC,henergy⟩ := actual_second_deleted_moving_mass_recursive_uniform_types + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hUs hg₁ hg₂ Aker J K εmass hεmass + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + G E V B Y R L Z N Vlabel εchild ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hblock hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + obtain ⟨hω₁,hω₂,hcut⟩ := hwindows p hp source pool Ψ m z G E V B (Z^N) ρ c₁ c₂ θ₁ θ₂ + hG hE hV hB hX hρ hc₁ hc₁b hc₂ hc₂b hblock + exact henergy p hp hcop hg hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ ω₁ ω₂ G E V B Y R L Z N Vlabel εchild + ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalChild.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalChild.lean new file mode 100644 index 0000000000000000000000000000000000000000..c358c178efb412f254e1ffdf6433668c6d00af4e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalChild.lean @@ -0,0 +1,135 @@ +import OAI.NumberTheory.DirichletL.Descent.ActualSecondEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondFixedFamily + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseSecondFibers +open InverseInitialArithmetic (sourceIdeal sourceIdeal_gen) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +include hp + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem primaryGenerator_primeProduct + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) (S : Finset ι) (v : ι → ℕ) : + primaryGenerator (Ideal.span {primeProduct p S v}) = primeProduct p S v := by + apply primaryGenerator_span _ (primeProduct_ne_zero p hp S v) + unfold primeProduct + induction S using Finset.induction_on with + | empty => simp + | @insert i S hi ih => + rw [Finset.prod_insert hi] + have hpow : ConcretePrimeRowBridge.goodLambda^2 ∣ p i^v i-1 := by + simpa only [one_pow] using (hpr i).trans (sub_dvd_pow_sub_pow (p i) 1 (v i)) + have he : p i^v i*(∏ j ∈ S,p j^v j)-1 = + (p i^v i-1)*(∏ j ∈ S,p j^v j)+((∏ j ∈ S,p j^v j)-1) := by ring + rw [he] + exact dvd_add (dvd_mul_of_dvd_left hpow _) ih + +def actualSecondPuncture (m : Eis) (γ : OuterTriple) : Eis := + (m*primaryGenerator γ.q0)*primaryGenerator γ.residual + +def actualSecondRawLabel {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) : Eis := + ((∏ i ∈ x.firstCommon,p i)*jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)* + primeSubsetGenerator (fun i => Ideal.span {p i}) x.second.divisor * ∏ i ∈ x.second.overlap,p i + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_mask_span (F : Finset ι) (Ψ : Eis →* ℂ) + (m₁ m₂ f k : Eis) (he : Ideal.span {m₁}=Ideal.span {m₂}) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) (W : ℝ → ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg F Ψ m₁ f k slots lists a W X = + finiteCanonicalMarkedRow p hp hcop hg F Ψ m₂ f k slots lists a W X := + fixedChildRow_congr_mask_span p hp hcop hg F Ψ he _ f k + +theorem actual_second_puncture_span + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (u v : Eisˣ) (m : Eis) : + Ideal.span {((m*b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)* + secondExpansionQuotient p x.second)} = + Ideal.span {actualSecondPuncture m (actualSecondChild p u v x).1} := by + change Ideal.span {(m*b0Label p _ _ _ _)*secondExpansionQuotient p x.second} = + Ideal.span {(m*primaryGenerator (Ideal.span {b0Label p _ _ _ _}))* + primaryGenerator (sourceIdeal p (x.second.sourceCommon\x.second.divisor))} + rw [show primaryGenerator (Ideal.span {b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}) = + b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit from primaryGenerator_primeProduct p hp hpr _ _, + sourceIdeal_gen p hp hpr,secondExpansionQuotient_of_subset p x.second hE] + simp only [←Ideal.span_singleton_mul_span_singleton,secondMaskQuotient_span, + FiniteGaussPhase.span_finset_prod] + +theorem actual_second_generator_sectors + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) : + ∃ u v : Eisˣ, + actualSecondRawLabel p x = (u:Eis)*primaryGenerator (actualSecondChild p u v x).2.1 ∧ + primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor * + primeSubsetGenerator (fun i => Ideal.span {p i}) x.second.divisor = + (v:Eis)*(primaryGenerator (sourceIdeal p x.firstDivisor)*primaryGenerator (sourceIdeal p x.second.divisor)) := by + let L := (markedSecondOriginal p x).J * sourceIdeal p x.firstCommon * + sourceIdeal p x.second.divisor * sourceIdeal p x.second.overlap + have hs (S : Finset ι) : Ideal.span {primeSubsetGenerator (fun i => Ideal.span {p i}) S} = sourceIdeal p S := by + simp only [primeSubsetGenerator,ConcretePrimeRowBridge.span_idealGenerator,sourceIdeal] + exact (FiniteGaussPhase.span_finset_prod S p).symm + have hl : Ideal.span {actualSecondRawLabel p x} = L := by + unfold actualSecondRawLabel L + simp only [←Ideal.span_singleton_mul_span_singleton,hs,sourceIdeal,markedSecondOriginal,cubeSecondSource] + ring + have hgp (S : Finset ι) : primaryGenerator (sourceIdeal p S) ≠ 0 := by + rw [sourceIdeal_gen p hp hpr] + exact Finset.prod_ne_zero_iff.mpr (fun i _ => hp i) + have hL : primaryGenerator L ≠ 0 := by + dsimp only [L] + rw [primaryGenerator_mul,primaryGenerator_mul,primaryGenerator_mul] + apply mul_ne_zero (mul_ne_zero (mul_ne_zero ?_ (hgp _)) (hgp _)) (hgp _) + change primaryGenerator (Ideal.span {jLabel p _ _ _ _}) ≠ 0 + rw [show primaryGenerator (Ideal.span {jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}) = + jLabel p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit from primaryGenerator_primeProduct p hp hpr _ _] + exact primeProduct_ne_zero p hp _ _ + obtain ⟨u,v,hu,hv⟩ := exists_second_generator_sectors (actualSecondRawLabel p x) + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor) + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.second.divisor) + L (sourceIdeal p x.firstDivisor) (sourceIdeal p x.second.divisor) + hl (hs _) (hs _) hL (hgp _) (hgp _) + exact ⟨u,v,hu,hv⟩ + +theorem actual_second_canonical_child + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) : + ∃ u v : Eisˣ, ∀ (F : Finset ι) (Ψ : Eis →* ℂ) (m k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) (W : ℝ → ℂ) (X : ℝ), + finiteCanonicalMarkedRow p hp hcop hg F Ψ + ((m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)*secondExpansionQuotient p x.second) + (actualSecondRawLabel p x) + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor * + primeSubsetGenerator (fun i => Ideal.span {p i}) x.second.divisor * k) + slots lists a W X = + secondCanonicalPolynomial p hp hcop hg F (fun _ => Ψ) (actualSecondPuncture m) + slots lists a (fun _ => W) X + (actualSecondChild p u v {x with second := {x.second with frequency := k}}) := by + obtain ⟨u,v,hu,hv⟩ := actual_second_generator_sectors p hp hpr x + refine ⟨u,v,?_⟩ + intro F Ψ m k slots lists a W X + rw [secondCanonical_generator_transport p hp hcop hg F Ψ _ _ _ _ _ _ _ _ u v hu hv] + exact finiteCanonicalMarkedRow_mask_span p hp hcop hg F Ψ _ _ _ _ + (actual_second_puncture_span p hp hpr x hE u v m) slots lists a W X + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalSplit.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalSplit.lean new file mode 100644 index 0000000000000000000000000000000000000000..409afd7704cfa0124dd7816fbb0cc15b1a93bcf9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalSplit.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondCanonicalChild +import OAI.NumberTheory.DirichletL.Descent.SecondSourceProfile + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseSecondFibers +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def actualMarkedSecondProfileData {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) (A₁ A₂ : Finset ι) : SecondProfileData ι := + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor + let c := (∏ i ∈ x.firstCommon,p i)*jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + expansionProfileData p Ψ (m*b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit*d) + c d z A₁ A₂ x.second + +theorem actual_second_split_child_uniform + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hCB : Disjoint x.firstCommon x.cube.support) + (hD : x.firstDivisor ⊆ x.firstCommon∪x.cube.support) + (hE : x.second.divisor ⊆ x.second.sourceCommon) : + ∃ u v : Eisˣ, ∀ (F : Finset ι) (Ψ : Eis →* ℂ) (m k : Eis) + (A : Finset ι), A ⊆ (x.cube.support∪x.firstCommon)∪x.second.sourceCommon → + ∀ (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) (W : ℝ → ℂ) (X : ℝ), + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) x.second.divisor + let c := (∏ i ∈ x.firstCommon,p i)*jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + canonicalMarkedSplit p hp hcop hg F x.second.overlap A Ψ + (m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit*d) + (secondExpansionQuotient p x.second) c d e k slots lists a W + (primeProductNorm p x.second.overlap*X) = + ∑ J ∈ slots.powerset, primeMark J lists a (A∪x.second.overlap) * + secondCanonicalPolynomial p hp hcop hg F (fun _ => Ψ) (actualSecondPuncture m) + (slots\J) lists a (fun _ => W) X + (actualSecondChild p u v {x with second := {x.second with frequency := k}}) := by + obtain ⟨u,v,hchild⟩ := actual_second_canonical_child p hp hcop hg hpr (σ:=σ) x hE + refine ⟨u,v,?_⟩ + intro F Ψ m k A hA slots lists a W X + dsimp only + rw [secondExpansionQuotient_of_subset p x.second hE] + rw [actual_second_split_fixed_family p hp hcop hg F x.cube.support x.firstCommon + x.firstDivisor x.second.sourceCommon x.second.divisor x.second.overlap A hCB hD hE hA + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + x.cube.support_pos Ψ m k slots lists a W X] + apply Finset.sum_congr rfl + intro J hJ + congr 1 + simpa only [actualSecondRawLabel,secondExpansionQuotient_of_subset p x.second hE] using + hchild F Ψ m k (slots\J) lists a W X + +theorem actual_second_separated_pair_canonical + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hCB : Disjoint x.firstCommon x.cube.support) + (hD : x.firstDivisor ⊆ x.firstCommon∪x.cube.support) + (hE : x.second.divisor ⊆ x.second.sourceCommon) : + ∃ u v : Eisˣ, ∀ (F : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (A₁ A₂ : Finset ι), A₁ ⊆ x.cube.support∪x.firstCommon → A₂ ⊆ x.cube.support∪x.firstCommon → + ∀ (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G₀ E₀ V₀ K₀ X₀ : ℝ) (t : JointLogSeparation.Frequency × (Fin 6 → ℝ)), + let h := profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2 + let data := actualMarkedSecondProfileData p x Ψ m z A₁ A₂ + secondSeparatedPair p hp hcop hg F data slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ t = + secondOuterPhase h (secondRelativeLog (secondActualNorms p data ∅ ∅) G₀ E₀ V₀ K₀ X₀) * + ∑ J₁ ∈ slots₁.powerset, ∑ J₂ ∈ slots₂.powerset, + (star (primeMark J₁ lists₁ a₁ ((A₁∪x.second.sourceCommon)∪x.second.overlap)) * + primeMark J₂ lists₂ a₂ ((A₂∪x.second.sourceCommon)∪x.second.overlap)) * + star (secondCanonicalPolynomial p hp hcop hg F (fun _ => secondRayMinus Ψ z) + (actualSecondPuncture m) (slots₁\J₁) lists₁ a₁ (fun _ => childLogTest ω₁ (-h 4)) X₀ + (actualSecondChild p u v x)) * + secondCanonicalPolynomial p hp hcop hg F (fun _ => secondRayPlus Ψ z) + (actualSecondPuncture m) (slots₂\J₂) lists₂ a₂ (fun _ => childLogTest ω₂ (h 5)) X₀ + (actualSecondChild p u v {x with second := {x.second with frequency := -x.second.frequency}}) := by + obtain ⟨u,v,hsplit⟩ := actual_second_split_child_uniform p hp hcop hg hpr (σ:=σ) x hCB hD hE + refine ⟨u,v,?_⟩ + intro F Ψ m z A₁ A₂ hA₁ hA₂ slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ t + dsimp only + have hA (A : Finset ι) (ha : A ⊆ x.cube.support∪x.firstCommon) : + A∪x.second.sourceCommon ⊆ (x.cube.support∪x.firstCommon)∪x.second.sourceCommon := + Finset.union_subset_union_left ha + unfold secondSeparatedPair + dsimp only [actualMarkedSecondProfileData,expansionProfileData] + rw [hsplit F (secondRayMinus Ψ z) m x.second.frequency _ (hA A₁ hA₁), + hsplit F (secondRayPlus Ψ z) m (-x.second.frequency) _ (hA A₂ hA₂)] + simp only [star_sum,star_mul,Finset.sum_mul,Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro J₁ hJ₁ + apply Finset.sum_congr rfl + intro J₂ hJ₂ + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..e1b45100be95525f0b4fd4d5ddfac6928d17e2e1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCanonicalTail.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondMarkedTail +import OAI.NumberTheory.DirichletL.Descent.SecondFreshTruncation +import OAI.NumberTheory.DirichletL.Descent.SecondCutoffScale + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InversePrincipalEnergy InverseSecondPrincipalCaller +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem first_fresh_canonical_error (ε : ℝ) (hε : 0<ε) (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (Ct Cm : ℝ), 0Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (_hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i})≠2) + (F D Bset : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis→*ℂ), + (∀ z,‖Ψ z‖≤1) → ∀ (m : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (coeff : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i∈slots,∀ k∈lists i,‖coeff i k‖≤1) → + (∀ i∈slots,Disjoint (lists i) D) → + ∀ (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0 childFrequencyBall + (d*primeSubsetGenerator (fun i=>Ideal.span {p i}) E) + (Z^(childM M ell A t (g G) (theta E) V j eta)) + ‖firstFreshSecondPoisson p hp hg hinj F D Bset v ε₁ ε₂ negative χ Ψ m + (primeMark slots lists coeff) om X c d r height Y - + truncatedSecondSource p hp hg hinj F Ψ₀ m₀ c₀ d H₀ rowMajorant Y K‖ ≤ + (128*(X*Real.exp Wbound))^4 * + ((Cm*(X*Real.exp Wbound)^ε*SchwartzMap.seminorm ℝ 0 0 om)^2 * + (Y*(Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant)* + (1+(X*Real.exp Wbound)^3/Y)^2/(1+H)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_second_correlated_tail order + obtain ⟨Cm,hCm,hmark⟩ := marked_radial_uniform_bound ε hε + refine ⟨s,Ct,Cm,hCt,hCm,?_⟩ + intro ι σ _ _ p hp _ hcop hg hinj hc F D Bset v ε₁ ε₂ negative χ Ψ hΨ m + slots lists coeff hslots hcoeff hD om a b ha hs X height Wbound Z M n ell V delta A B j t eta tau + hX hZ hL hb hLscale c d hd hdN r g theta hgN heN Y H H₀ Ψ₀ m₀ c₀ K + have hY : 0(firstCoreTwist_norm_le negative χ Ψ r z).trans (hΨ z)) + m₀ c₀ d hd H₀ rowMajorant _ Y H (X*Real.exp Wbound) + (fun G E=>Z^(childM M ell A t (g G) (theta E) V j eta)) + (by positivity) hY hH hL hcoef + · exact markedRadial_support p slots lists coeff ∅ _ X Wbound hX hVsupp + · intro G hG E + exact second_correlated_radius_childM p hp d G E.val Z M n ell V delta A B j t (g G) + (theta E.val) eta tau (X*Real.exp Wbound) hZ (zero_le_one.trans hL) + hdN (heN G hG E) (hgN G hG) hLscale + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCauchy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCauchy.lean new file mode 100644 index 0000000000000000000000000000000000000000..f1ac02425294c4d0bd18fbc0cd8ebd1f1a67fe4d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCauchy.lean @@ -0,0 +1,119 @@ +import OAI.NumberTheory.DirichletL.Descent.TripleMass +import OAI.NumberTheory.DirichletL.Descent.Canonical + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open SevenEighths.InverseSecondFibers IdealMobiusDivisorSum CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def secondLabelEnergy (K : ℕ) (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (F : SecondChild → ℂ) (γ : OuterTriple) : ℝ := + ∑ f ∈ labels, ((idealDivisors f).card : ℝ)^(9+4*K) * + ∑ k ∈ rows, ‖F (γ,f,k)‖^2 + +lemma secondLabelEnergy_nonneg (K : ℕ) (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (F : SecondChild → ℂ) (γ : OuterTriple) : 0 ≤ secondLabelEnergy K labels rows F γ := by + unfold secondLabelEnergy; positivity + +theorem second_weighted_count {Jo Jn : ℕ} (source : Finset (SecondTuple Jo Jn)) + (oldLists : Fin Jo → Finset SmoothMobiusCorrection.PrimeIdeal) + (newLists : Fin Jn → Finset SmoothMobiusCorrection.PrimeIdeal) + (keep : SecondTuple Jo Jn → Prop) + (hvalid : ∀ x ∈ originalSource source oldLists newLists keep, + Valid x (secondChild x).1 (secondChild x).2.1 (secondChild x).2.2) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hf : ∀ f ∈ labels, f ≠ 0) + (houter : ∀ γ ∈ sourceTriples source oldLists newLists keep, + γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0) + (hchild : ∀ x ∈ originalSource source oldLists newLists keep, + (secondChild x).2.1 ∈ labels ∧ (secondChild x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hn : Jn ≤ 2*K) + (w : SecondTuple Jo Jn → ℂ) + (hw : ∀ x ∈ originalSource source oldLists newLists keep, ‖w x‖ ≤ 1) + (F G : SecondChild → ℂ) : + ‖∑ x ∈ originalSource source oldLists newLists keep, + w x * F (secondChild x) * star (G (secondChild x))‖ ≤ + Real.sqrt (∑ γ ∈ sourceTriples source oldLists newLists keep, + tripleDivisorWeight K γ * secondLabelEnergy K labels rows F γ) * + Real.sqrt (∑ γ ∈ sourceTriples source oldLists newLists keep, + tripleDivisorWeight K γ * secondLabelEnergy K labels rows G γ) := by + have hF := second_energy_projection source oldLists newLists keep hvalid labels rows hf houter hchild + K ho hn (fun x => ‖w x‖) hw F + have hG := second_energy_projection source oldLists newLists keep hvalid labels rows hf houter hchild + K ho hn (fun x => ‖w x‖) hw G + apply (DescentWeightedCauchy.weighted_cauchy (originalSource source oldLists newLists keep) + w (F ∘ secondChild) (G ∘ secondChild)).trans + exact mul_le_mul (Real.sqrt_le_sqrt hF) (Real.sqrt_le_sqrt hG) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + +theorem second_weighted_count_of_child_bound {Jo Jn : ℕ} (source : Finset (SecondTuple Jo Jn)) + (oldLists : Fin Jo → Finset SmoothMobiusCorrection.PrimeIdeal) + (newLists : Fin Jn → Finset SmoothMobiusCorrection.PrimeIdeal) + (keep : SecondTuple Jo Jn → Prop) + (hvalid : ∀ x ∈ originalSource source oldLists newLists keep, + Valid x (secondChild x).1 (secondChild x).2.1 (secondChild x).2.2) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hf : ∀ f ∈ labels, f ≠ 0) + (houter : ∀ γ ∈ sourceTriples source oldLists newLists keep, + γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0) + (hchild : ∀ x ∈ originalSource source oldLists newLists keep, + (secondChild x).2.1 ∈ labels ∧ (secondChild x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hn : Jn ≤ 2*K) + (w : SecondTuple Jo Jn → ℂ) + (hw : ∀ x ∈ originalSource source oldLists newLists keep, ‖w x‖ ≤ 1) + (F G : SecondChild → ℂ) (E : ℝ) (hE : 0 ≤ E) + (hF : ∀ γ ∈ sourceTriples source oldLists newLists keep, secondLabelEnergy K labels rows F γ ≤ E) + (hG : ∀ γ ∈ sourceTriples source oldLists newLists keep, secondLabelEnergy K labels rows G γ ≤ E) : + ‖∑ x ∈ originalSource source oldLists newLists keep, + w x * F (secondChild x) * star (G (secondChild x))‖ ≤ + E * ∑ γ ∈ sourceTriples source oldLists newLists keep, tripleDivisorWeight K γ := by + have hb (P : SecondChild → ℂ) + (hP : ∀ γ ∈ sourceTriples source oldLists newLists keep, secondLabelEnergy K labels rows P γ ≤ E) : + (∑ γ ∈ sourceTriples source oldLists newLists keep, + tripleDivisorWeight K γ * secondLabelEnergy K labels rows P γ) ≤ + E * ∑ γ ∈ sourceTriples source oldLists newLists keep, tripleDivisorWeight K γ := by + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro γ hγ + simpa only [mul_comm] using mul_le_mul_of_nonneg_left (hP γ hγ) (tripleDivisorWeight_nonneg K γ) + apply (second_weighted_count source oldLists newLists keep hvalid labels rows hf houter hchild K ho hn w hw F G).trans + calc + _ ≤ Real.sqrt (E * ∑ γ ∈ sourceTriples source oldLists newLists keep, tripleDivisorWeight K γ) * + Real.sqrt (E * ∑ γ ∈ sourceTriples source oldLists newLists keep, tripleDivisorWeight K γ) := + mul_le_mul (Real.sqrt_le_sqrt (hb F hF)) (Real.sqrt_le_sqrt (hb G hG)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + _ = _ := Real.mul_self_sqrt (mul_nonneg hE (Finset.sum_nonneg (fun γ _ => tripleDivisorWeight_nonneg K γ))) + +def secondCanonicalPolynomial {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (pool : Finset ι) (Ψ : OuterTriple → Eis →* ℂ) (puncture : OuterTriple → Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : OuterTriple → ℝ → ℂ) (X : ℝ) (c : SecondChild) : ℂ := + finiteCanonicalMarkedRow p hp hcop hg pool (Ψ c.1) (puncture c.1) + (primaryGenerator c.2.1) c.2.2 slots lists a (W c.1) X + +theorem secondCanonicalPolynomial_actual_columns {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (pool : Finset ι) (Ψ : OuterTriple → Eis →* ℂ) (puncture : OuterTriple → Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : OuterTriple → ℝ → ℂ) (X : ℝ) (c : SecondChild) : + secondCanonicalPolynomial p hp hcop hg pool Ψ puncture slots lists a W X c = + ∑ U ∈ pool.powerset, + columnWeight (CanonicalRowCompletion.rowTwist (Ψ c.1) (puncture c.1) + (primaryGenerator c.2.1) c.2.2) (Ideal.span {∏ i ∈ U, p i}) * + (primeMark slots lists a U * W c.1 (FirstPassCubeLabels.primeProductNorm p U / X)) := + finiteCanonicalMarkedRow_actual_columns p hp hcop hg hpr pool (Ψ c.1) (puncture c.1) + (primaryGenerator c.2.1) c.2.2 slots lists a (W c.1) X + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCellParameters.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCellParameters.lean new file mode 100644 index 0000000000000000000000000000000000000000..aba7a6cba0bd4d3e53b81ffddd1199b27893e7d4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCellParameters.lean @@ -0,0 +1,121 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondCellPhysical +import OAI.NumberTheory.DirichletL.Descent.PhysicalBlockBudget + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseInitialArithmetic +open ConcreteTraceCRT (eisEmbedding) +local notation "O" => ActualEisensteinCubic.O + +def secondCellExponent (Z:ℝ) (d:BlockIndex) (i:Fin 4):ℝ:=Real.logb Z (scales d i) + +theorem secondCellExponent_nonneg (Z:ℝ) (d:BlockIndex) (i:Fin 4) (hZ:1x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2* + primeProductNorm p x.firstCommon*primeProductNorm p x.second.divisor* + primeProductNorm p x.second.overlap := by + have hn(S:Finset ι):(Ideal.absNorm (sourceIdeal p S):ℝ)=primeProductNorm p S:=by + simpa only [sourceIdeal,primeProductNorm,map_prod] using + (eisEmbedding_norm_sq_eq_absNorm_span (∏i∈S,p i)).symm + change (Ideal.absNorm (Ideal.span {jLabel p x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit} * + sourceIdeal p x.firstCommon * sourceIdeal p x.second.divisor * sourceIdeal p x.second.overlap):ℝ)=_ + simp only [map_mul,Nat.cast_mul,hn,←eisEmbedding_norm_sq_eq_absNorm_span] + +theorem actual_cell_child_label_bound {ι:Type*} [DecidableEq ι] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + {Jo Jn:ℕ} (source:Finset (MarkedSecondSource ι Jo Jn)) + (hk:∀x∈source,x.second.frequency≠0) (d:BlockIndex) + (x:MarkedSecondSource ι Jo Jn) (hx:x∈cell p source d) (u v:Oˣ): + (Ideal.absNorm (actualSecondChild p u v x).2.1:ℝ)≤ + 4*‖eisEmbedding (jLabel p x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2* + primeProductNorm p x.firstCommon*scales d 1*scales d 2 := by + have hE:= (cell_ratios p hp source hk d x hx 1).2.le + have hV:= (cell_ratios p hp source hk d x hx 2).2.le + have he:primeProductNorm p x.second.divisor≤2*scales d 1:= + (div_le_iff₀ (dyadScale_pos _)).mp hE + have hv:primeProductNorm p x.second.overlap≤2*scales d 2:= + (div_le_iff₀ (dyadScale_pos _)).mp hV + rw [actual_second_child_label_norm] + calc + _ ≤ ‖eisEmbedding (jLabel p x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2* + primeProductNorm p x.firstCommon*(2*scales d 1)*(2*scales d 2) := by + have hc0 := (primeProductNorm_pos p hp x.firstCommon).le + have hv0 := (primeProductNorm_pos p hp x.second.overlap).le + have hs0 := (dyadScale_pos (d 1)).le + gcongr + _ = _ := by ring + +theorem actual_cell_child_label_power {ι:Type*} [DecidableEq ι] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + {Jo Jn:ℕ} (source:Finset (MarkedSecondSource ι Jo Jn)) + (hk:∀x∈source,x.second.frequency≠0) (d:BlockIndex) + (x:MarkedSecondSource ι Jo Jn) (hx:x∈cell p source d) (u v:Oˣ) + (Z B j eta:ℝ) (hZ:1x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2≤Z^(j+eta)) : + (Ideal.absNorm (actualSecondChild p u v x).2.1:ℝ)≤ + Z^(secondFormalLabel B (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) := by + have hz:0 ActualEisensteinCubic.O + +def secondCellColumnExponent (Z X:ℝ) (d:BlockIndex):ℝ := + Real.logb Z (X/(scales d 0*scales d 2)) + +theorem second_cell_column_scale (Z X:ℝ) (d:BlockIndex) (hZ:1Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (pool:Finset ι) (x:SecondProfileData ι) (slots₁ slots₂:Finset σ) + (lists₁ lists₂:σ→Finset ι) (a₁ a₂:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0star (positiveSource (conjugateProfile g) 1 (-θ) y)) (positiveSource g 1 θ) Φ Y + (scales d 0*scales d 2*Z^(secondCellColumnExponent Z X d)) := by + rw [second_cell_physical_scale Z X d hZ hX] + exact actual_priority_profile_common p hp hcop hg pool x slots₁ slots₂ lists₁ lists₂ a₁ a₂ + om lo hi hlo hs negative t Φ Y X hX + +theorem actual_priority_cells {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + {Jo:ℕ} (source:Finset (MarkedSecondSource ι Jo 0)) + (pool:Finset ι) (Ψ:O→*ℂ) (m:O) (ray:SecondRayIndex) + (slots₁ slots₂:Finset σ) (lists₁ lists₂:σ→Finset ι) (a₁ a₂:σ→ι→ℂ) + (deleted₁ deleted₂:MarkedSecondSource ι Jo 0→Finset ι) + (w:MarkedSecondSource ι Jo 0→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + (principalWindow om lo hi hlo hs negative t) (principalWindow om lo hi hlo hs negative t) Φ Y X) = + ∑d∈keys p source,(Y:ℂ)*secondRayCoefficient ray * + (∑x∈cell p source d,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) ray x)* + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m ray) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + (fun y=>star (positiveSource (conjugateProfile g) 1 (-θ) y)) (positiveSource g 1 θ) Φ Y + (scales d 0*scales d 2*Z^(secondCellColumnExponent Z X d))) := by + intro g θ + refine (physical_source_partition p hp hcop hg source pool Ψ m ray slots₁ slots₂ lists₁ lists₂ + a₁ a₂ deleted₁ deleted₂ w (principalWindow om lo hi hlo hs negative t) + (principalWindow om lo hi hlo hs negative t) Φ Y X).trans ?_ + apply Finset.sum_congr rfl + intro d hd + apply congrArg ((Y : ℂ) * secondRayCoefficient ray * ·) + apply Finset.sum_congr rfl + intro x hx + exact congrArg ((w x * actualSecondSignedWeight p hp hcop hg Ψ + (m * ConcretePrimeRowBridge.idealGenerator x.quotient) ray x) * ·) + (actual_priority_cell_profile p hp hcop hg pool (secondInheritedProfile p x Ψ m ray) + slots₁ slots₂ _ _ a₁ a₂ om lo hi hlo hs negative t Φ Y X Z hX hZ d) + +theorem actual_source_block_ratios {ι:Type*} [DecidableEq ι] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + {Jo Jn:ℕ} (source:Finset (MarkedSecondSource ι Jo Jn)) (d:BlockIndex) + (hcell:∀x∈source,index p x=d) (hk:∀x∈source,x.second.frequency≠0) : + ∀x∈source,∀i,InverseSecondChildWindows.actualOuterRatios p x + (scales d 0) (scales d 1) (scales d 2) (scales d 3) i∈Set.Icc 1 2 := by + intro x hx i + have hxcell:x∈cell p source d:=(mem_cell p source d x).mpr ⟨hx,hcell x hx⟩ + have hr:=cell_ratios p hp source hk d x hxcell i + have he:InverseSecondChildWindows.actualOuterRatios p x + (scales d 0) (scales d 1) (scales d 2) (scales d 3) i=outerNorms p x i/scales d i := by + fin_cases i <;> simp [InverseSecondChildWindows.actualOuterRatios,outerNorms, + primeSubsetGenerator_norm_eq_productNorm] + rw [he] + exact ⟨hr.1,hr.2.le⟩ + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCenterSector.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCenterSector.lean new file mode 100644 index 0000000000000000000000000000000000000000..76d4d8dc2b302211c08c6c063372b2e8c2863f8a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCenterSector.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondVariableCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondFibers +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι γ δ κ : Type*} [DecidableEq ι] [DecidableEq γ] [DecidableEq δ] [DecidableEq κ] + +def secondCenterLabel (gIndex : Finset ι→γ) (thetaIndex : Finset ι→δ) + (other : Finset ι→SecondExpansionData ι→κ) (residual : Finset ι) + (x : SecondExpansionData ι) : γ × δ × κ := + (gIndex x.sourceCommon,thetaIndex x.divisor,other residual x) + +theorem second_center_sector_rows (p : ι→Eis) + {Jo : ℕ} (parent : SecondParentSource ι Jo) (pool residual : Finset ι) + (gIndex : Finset ι→γ) (thetaIndex : Finset ι→δ) + (other : Finset ι→SecondExpansionData ι→κ) (R : γ→δ→ℝ) + (j : γ × δ × κ) (x : MarkedSecondSource ι Jo 0) + (hx : x∈(secondDyadicSector pool + (secondVariableCutoff p parent (fun G E=>R (gIndex G) (thetaIndex E))) residual + (secondCenterLabel gIndex thetaIndex other) j).image (attachSecondExpansion parent)) : + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R j.1 j.2.1) := by + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + have hlabel := (Finset.mem_filter.mp hy).2 + have hg : gIndex y.sourceCommon=j.1 := congrArg Prod.fst hlabel + have ht : thetaIndex y.divisor=j.2.1 := congrArg (fun a : γ×δ×κ=>a.2.1) hlabel + obtain ⟨hy,_⟩ := Finset.mem_filter.mp hy + obtain ⟨hy,_⟩ := Finset.mem_filter.mp hy + have hs := ((mem_secondExpansionPool _ _ _).mp hy).2.2.2 + change y.frequency ∈ nonzeroChildFrequencyBall + (actualSecondMultiplier p (attachSecondExpansion parent y)) (R (gIndex y.sourceCommon) (thetaIndex y.divisor)) at hs + change y.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p (attachSecondExpansion parent y)) (R j.1 j.2.1) + simpa only [hg,ht] using hs + +theorem second_center_sector_empty (p : ι→Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + {Jo : ℕ} (parent : SecondParentSource ι Jo) (pool residual : Finset ι) + (gIndex : Finset ι→γ) (thetaIndex : Finset ι→δ) + (other : Finset ι→SecondExpansionData ι→κ) (R : γ→δ→ℝ) + (j : γ × δ × κ) (hR : R j.1 j.2.1<1) : + secondDyadicSector pool + (secondVariableCutoff p parent (fun G E=>R (gIndex G) (thetaIndex E))) residual + (secondCenterLabel gIndex thetaIndex other) j = ∅ := by + apply Finset.eq_empty_iff_forall_notMem.mpr + intro y hy + have hs := second_center_sector_rows p parent pool residual gIndex thetaIndex other R j + (attachSecondExpansion parent y) (Finset.mem_image.mpr ⟨y,hy,rfl⟩) + have ha : actualSecondMultiplier p (attachSecondExpansion parent y) ≠ 0 := + mul_ne_zero (primeSubsetGenerator_ne_zero _ _) (primeSubsetGenerator_ne_zero _ _) + rw [nonzeroChildFrequencyBall_empty _ ha _ hR] at hs + exact Finset.notMem_empty _ hs + +theorem second_center_sector_nonnegative (p : ι→Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + {Jo : ℕ} (parent : SecondParentSource ι Jo) (pool residual : Finset ι) + (gIndex : Finset ι→γ) (thetaIndex : Finset ι→δ) + (other : Finset ι→SecondExpansionData ι→κ) (M : γ→δ→ℝ) (Z : ℝ) (hZ : 1Z^(M (gIndex G) (thetaIndex E)))) residual + (secondCenterLabel gIndex thetaIndex other) j).Nonempty) : 0≤M j.1 j.2.1 := by + by_contra hn + have hlt : Z^(M j.1 j.2.1)<1 := Real.rpow_lt_one_of_one_lt_of_neg hZ (lt_of_not_ge hn) + rw [second_center_sector_empty p parent pool residual gIndex thetaIndex other + (fun a b=>Z^(M a b)) j hlt] at hne + exact Finset.not_nonempty_empty hne + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCorrelatedCutoff.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCorrelatedCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..a76d2bcb026dde26b6377bc2b601e723897e3fb6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCorrelatedCutoff.lean @@ -0,0 +1,95 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondWholeCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstCauchyArithmetic CompletedGauss FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem second_correlated_column_denominator {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (G E S T : Finset ι) (hGS : Disjoint G S) (hGT : Disjoint G T) + (L : ℝ) (hL : 0 ≤ L) + (hS : primeProductNorm p (G ∪ S) ≤ L) + (hT : primeProductNorm p (G ∪ T) ≤ L) : + (primeProductNorm p E)^2 * (primeProductNorm p S * primeProductNorm p T) ≤ + (primeProductNorm p E/primeProductNorm p G)^2 * L^2 := by + have hG0 := (primeProductNorm_pos p hp G).ne' + have hbound := second_whole_column_denominator p hp G G S T Finset.Subset.rfl hGS hGT L hL hS hT + calc + _ = (primeProductNorm p E/primeProductNorm p G)^2 * + ((primeProductNorm p G)^2 * (primeProductNorm p S*primeProductNorm p T)) := by + field_simp + _ ≤ _ := mul_le_mul_of_nonneg_left hbound (sq_nonneg _) + +def correlatedSecondRadius {ι : Type*} [DecidableEq ι] (p : ι → O) + (d : O) (G E : Finset ι) (L Y H : ℝ) : ℝ := + ‖eisEmbedding d‖^2 * (primeProductNorm p E/primeProductNorm p G)^2 * L^2 * H / Y + +theorem full_second_correlated_tail (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (Ct : ℝ), 0 < Ct ∧ + ∀ {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) + (F : Finset ι) (Ψ : O →* ℂ) (_hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (_hd : d ≠ 0) (Hcol : Finset ι → ℂ) (W : 𝓢(ℝ, ℂ)) + (B Y H L : ℝ) (R : Finset ι → Finset ι → ℝ), 0 ≤ B → 0 < Y → 0 ≤ H → 1 ≤ L → + (∀ U, ‖Hcol U‖ ≤ B) → + (∀ U, Hcol U ≠ 0 → primeProductNorm p U ≤ L) → + (∀ G ∈ F.powerset, ∀ E : G.powerset, + correlatedSecondRadius p d G E.val L Y H ≤ R G E.val) → + ‖secondSourceTail p hp hg hinj F Ψ m c d Hcol W Y + (fun G E => childFrequencyBall + (d*primeSubsetGenerator (fun i => Ideal.span {p i}) E) (R G E))‖ ≤ + (128*L)^4 * (B^2 * + (Y*(Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)* + (1+L^3/Y)^2/(1+H)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_second_supported_tail order + refine ⟨s,Ct,hCt,?_⟩ + intro ι _ p hp _ hg hinj hc F Ψ hΨ m c d hd Hcol W B Y H L R hB hY hH hL hcol hsupp hR + apply htail p hp hg hinj hc F Ψ hΨ m c d Hcol W B Y H L hB hY hH hL hcol hsupp + intro G hG E S hS T hT hST hw k hk + obtain ⟨hGS,hGT⟩ := residualPairWeight_test_ne_zero p hg Ψ Ψ m c d _ _ S T hw + have hdGS : Disjoint G S := Finset.disjoint_left.mpr (by + intro i hiG hiS + exact (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hS) hiS)).2 hiG) + have hdGT : Disjoint G T := Finset.disjoint_left.mpr (by + intro i hiG hiT + exact (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hT) hiT)).2 hiG) + have hden := second_correlated_column_denominator p hp G E.val S T hdGS hdGT L (zero_le_one.trans hL) + (hsupp _ hGS) (hsupp _ hGT) + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) E.val + have he : e ≠ 0 := primeSubsetGenerator_ne_zero _ _ + have hde := mul_ne_zero hd he + have hdN : 0 < ‖eisEmbedding d‖^2 := SecondPassIntegration.elementNorm_pos d hd + have heN : 0 < ‖eisEmbedding e‖^2 := SecondPassIntegration.elementNorm_pos e he + have henorm : ‖eisEmbedding e‖^2 = primeProductNorm p E.val := + primeSubsetGenerator_norm_eq_productNorm p E.val + have hkR := (outside_childFrequencyBall (d*e) hde (R G E.val) k hk).le + have hR' : ‖eisEmbedding d‖^2 * (primeProductNorm p E.val/primeProductNorm p G)^2 * L^2 * H ≤ + Y * (‖eisEmbedding d‖^2 * ‖eisEmbedding e‖^2 * ‖eisEmbedding k‖^2) := by + have hh := (div_le_iff₀ hY).mp (hR G hG E) + have hh' := mul_le_mul_of_nonneg_right hkR hY.le + simp only [map_mul,norm_mul,mul_pow] at hh' + nlinarith + have hbound : H * (‖eisEmbedding e‖^2 * + (primeProductNorm p S * primeProductNorm p T)) ≤ Y*‖eisEmbedding k‖^2 := by + apply (mul_le_mul_iff_right₀ (mul_pos hdN heN)).mp + have hh := mul_le_mul_of_nonneg_left hden (mul_nonneg hdN.le hH) + rw [←henorm] at hh + rw [←henorm] at hR' + nlinarith [hh,hR'] + rw [active_norm_sq_disjoint p S T hST,div_mul_eq_mul_div] + apply (le_div_iff₀ (mul_pos heN (mul_pos (primeProductNorm_pos p hp S) + (primeProductNorm_pos p hp T)))).mpr + exact hbound + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondCutoffScale.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCutoffScale.lean new file mode 100644 index 0000000000000000000000000000000000000000..6fbfc574356750fbe42f39a888ce3a2db837976b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondCutoffScale.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondCorrelatedCutoff +import OAI.NumberTheory.DirichletL.Descent.PhysicalExponents + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem second_correlated_radius_bound {ι : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (d : O) (G E : Finset ι) + (Z delta theta g s Hc eta tau L : ℝ) (hZ : 0 ActualEisensteinCubic.O +local instance inverseSecondDeletedAllIntegralUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_deleted_all_modes_integral + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a,‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (hd₁ : ∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (hd₂ : ∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (ha₁ : ∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) + (hrows : ∀ x∈source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hslots₁ : slots₁.card ≤ K) (hslots₂ : slots₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x∈source,‖w x‖ ≤ 1) + (A : ℝ) (hA : 0 ≤ A) (J : ℕ) + (density : Frequency × (Fin 6 → ℝ) → ℂ) + (hDensity : Integrable (fun t : Frequency × (Fin 6 → ℝ) => + tripleHeight J t.1*coordinateHeight J t.2*‖density t‖)) + (hleft : ∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ A*(tripleHeight J t.1*coordinateHeight J t.2)) + (hright : ∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ A*(tripleHeight J t.1*coordinateHeight J t.2)) : + ‖∫ t : Frequency × (Fin 6 → ℝ),density t*secondDeletedFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B X w t‖ ≤ + (36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖density t‖ := by + let C := 36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ + have hb (t : Frequency × (Fin 6 → ℝ)) : + ‖secondDeletedFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B X w t‖ ≤ C*(tripleHeight J t.1*coordinateHeight J t.2) := by + have hh := actual_second_deleted_all_modes_bound p hp hcop hg hpr hinj hc source hs sector pool Ψ hΨ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ hd₁ hd₂ ha₁ ha₂ ω₁ ω₂ G E V B X R t labels hlabels hrows + K ho hslots₁ hslots₂ w hw (A*(tripleHeight J t.1*coordinateHeight J t.2)) + (by unfold tripleHeight coordinateHeight; positivity) (hleft t) (hright t) + exact hh.trans_eq (by dsimp only [C]; ring) + calc + _ ≤ ∫ t : Frequency × (Fin 6 → ℝ),C*(tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) := by + apply norm_integral_le_of_norm_le (hDensity.const_mul C) + filter_upwards with t + rw [norm_mul] + exact (mul_le_mul_of_nonneg_left (hb t) (norm_nonneg _)).trans_eq (by ring) + _ = _ := integral_const_mul _ _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedAllModes.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedAllModes.lean new file mode 100644 index 0000000000000000000000000000000000000000..89fe9efd983b12cffed6d6305600449d8cdefae9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedAllModes.lean @@ -0,0 +1,142 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedOriginalBound +import OAI.NumberTheory.DirichletL.Descent.SecondSectorAssembly + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedAllModesUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondDeletedFullModeSum {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (w : MarkedSecondSource ι Jo 0 → ℂ) + (t : Frequency × (Fin 6 → ℝ)) : ℂ := + ∑ uv : Eisˣ × Eisˣ,∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + ∑ x∈secondSourceSector source sector uv, + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t + +theorem secondDeletedFullModeSum_physical {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (w : MarkedSecondSource ι Jo 0 → ℂ) + (t : Frequency × (Fin 6 → ℝ)) : + secondDeletedFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B X w t = + ∑ uv : Eisˣ × Eisˣ,∑ x∈secondSourceSector source sector uv, + (w x*actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x)* + ∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t := by + unfold secondDeletedFullModeSum + apply Finset.sum_congr rfl + intro uv huv + simp only [Finset.mul_sum] + symm + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro J₁ hJ₁ + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro J₂ hJ₂ + apply Finset.sum_congr rfl + intro x hx + ring + +theorem actual_second_deleted_all_modes_bound + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a,‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (hd₁ : ∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (hd₂ : ∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (ha₁ : ∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) + (hrows : ∀ x∈source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hslots₁ : slots₁.card ≤ K) (hslots₂ : slots₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x∈source,‖w x‖ ≤ 1) + (A : ℝ) (hA : 0 ≤ A) + (hleft : ∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ A) + (hright : ∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ A) : + ‖secondDeletedFullModeSum p hp hcop hg source sector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B X w t‖ ≤ + 36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ := by + let mass := ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ + have hbound (uv : Eisˣ × Eisˣ) (J₁ : Finset σ) (hJ₁ : J₁∈slots₁.powerset) + (J₂ : Finset σ) (hJ₂ : J₂∈slots₂.powerset) : + ‖∑ x∈secondSourceSector source sector uv, + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x*w x* + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ A*mass := by + have hsub : secondSourceSector source sector uv ⊆ source := Finset.filter_subset _ _ + have ht := actualSecondTriples_mono p 1 1 hsub + have h := actual_second_deleted_mode_original_bound p hp hcop hg hpr hinj hc uv.1 uv.2 + (secondSourceSector source sector uv) (hs.mono p hsub) pool Ψ hΨ m z + slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + (fun x hx=>hd₁ x (hsub hx)) (fun x hx=>hd₂ x (hsub hx)) + (fun i hi => ha₁ i (Finset.mem_powerset.mp hJ₁ hi)) + (fun i hi => ha₂ i (Finset.mem_powerset.mp hJ₂ hi)) ω₁ ω₂ G E V B X R t labels + (fun x hx => hlabels x (hsub hx)) (fun x hx => hrows x (hsub hx)) K ho + ((Finset.card_le_card (Finset.mem_powerset.mp hJ₁)).trans hslots₁) + ((Finset.card_le_card (Finset.mem_powerset.mp hJ₂)).trans hslots₂) + w (fun x hx => hw x (hsub hx)) A hA + (fun γ hγ => hleft J₁ hJ₁ γ (ht hγ)) (fun γ hγ => hright J₂ hJ₂ γ (ht hγ)) + exact h.trans (mul_le_mul_of_nonneg_left (Finset.sum_le_sum_of_subset_of_nonneg ht + (fun γ _ _ => tripleDivisorWeight_nonneg K γ)) hA) + calc + _ ≤ ∑ uv : Eisˣ × Eisˣ,∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + ‖∑ x∈secondSourceSector source sector uv, + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x*w x* + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t‖ := by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro uv huv + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro J₁ hJ₁ + exact norm_sum_le _ _ + _ ≤ ∑ _uv : Eisˣ × Eisˣ,∑ _J₁∈slots₁.powerset,∑ _J₂∈slots₂.powerset,A*mass := by + apply Finset.sum_le_sum + intro uv huv + apply Finset.sum_le_sum + intro J₁ hJ₁ + exact Finset.sum_le_sum (fun J₂ hJ₂ => hbound uv J₁ hJ₁ J₂ hJ₂) + _ = _ := by + simp only [Finset.sum_const,Finset.card_univ,Finset.card_powerset,nsmul_eq_mul, + second_unit_sector_card,Nat.cast_pow,Nat.cast_ofNat,mass] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedModeEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedModeEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..f1891821d26573475d51fc2eae9061503398d15f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedModeEnergy.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeParentLists +import OAI.NumberTheory.DirichletL.Descent.SecondVaryingSupported +import OAI.NumberTheory.DirichletL.Descent.SecondPhysicalRows + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_deleted_mode_branch_energy + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (hd₁ : ∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (hd₂ : ∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ lists₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ lists₂ i, ‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x ∈ source,(actualSecondChild p u v x).2.1 ∈ labels) + (hrows : ∀ x ∈ source, + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x ∈ source,‖w x‖ ≤ 1) : + ‖∑ x ∈ source,actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (varyingAssignedSource source J₁ J₂ lists₁ lists₂ + (fun x i=>lists₁ i\deleted₁ x) (fun x i=>lists₂ i\deleted₂ x)), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ) * + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (varyingAssignedSource source J₁ J₂ lists₁ lists₂ + (fun x i=>lists₁ i\deleted₁ x) (fun x i=>lists₂ i\deleted₂ x)), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ) := by + let phase := fun x => w x * secondModeOuter p x Ψ m z G E V B X t + have hphase : ∀ x ∈ source,‖phase x‖ ≤ 1 := by + intro x hx + simpa only [phase,norm_mul,secondModeOuter,secondOuterPhase_norm,mul_one] using hw x hx + have hchild : ∀ x ∈ source, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ nonzeroChildFrequencyBall 1 R := by + intro x hx + exact ⟨hlabels x hx,(actual_second_row_ball p hp hpr x u v R).mp (hrows x hx)⟩ + have he := actual_second_supported_varying_lists_energy p hp hcop hg hpr hinj hc + u v source hs Ψ hΨ (fun x => m*ConcretePrimeRowBridge.idealGenerator x.quotient) z + J₁ J₂ lists₁ lists₂ (fun x i=>lists₁ i\deleted₁ x) (fun x i=>lists₂ i\deleted₂ x) + (fun _ _ _ _=>Finset.sdiff_subset) (fun _ _ _ _=>Finset.sdiff_subset) a₁ a₂ ha₁ ha₂ labels (nonzeroChildFrequencyBall 1 R) hchild + K ho hJ₁ hJ₂ phase hphase + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) + apply le_trans (le_of_eq ?_) he + congr 1 + apply Finset.sum_congr rfl + intro x hx + rw [secondModeBranch_parent_lists_restore p hp hcop hg hpr x (hs.admissible x hx) + (hs.second_divisor x hx) u v (deleted₁ x) (deleted₂ x) (hd₁ x hx) (hd₂ x hx)] + dsimp only [phase] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..993dd36bd2e789c7e0b5cdbda8a1517a37478b0d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingEnergy.lean @@ -0,0 +1,119 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedPhysicalRecursive +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedMovingPhysicalUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +open InverseSecondProfileUniform InverseAmbientProfileTower +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] +theorem actual_second_deleted_moving_physical_recursive + (U₀ : Fin 6 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 6 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ C : ℝ,0 ≤ C ∧ ∀ (p : ι → Eis) (hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (ω₁ ω₂ : ℝ → ℂ) (G E V B Y R L Z N Vlabel εchild : ℝ) + (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (K : ℕ) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (fun x => star (positiveSource g₁ c₁ θ₁ x)) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₁ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (positiveSource g₂ c₂ θ₂) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₂ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/(Z^N)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/(Z^N)) ≠ 0 → ∀ i, + U₀ i ((secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B (Z^N) i)+ρ i) = 1) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨C,hC,hmeasure⟩ := InverseSecondProfileUniform.second_profile_common_measure + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + refine ⟨C,hC,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B Y R L Z N Vlabel εchild ρ c₁ c₂ θ₁ θ₂ w labels K A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hRad : 0 < Y*B/(E*V^2*(Z^N)^2) := by positivity + obtain ⟨b₃,hb₃⟩ := hmeasure (Y*B/(E*V^2*(Z^N)^2)) hRad + obtain ⟨hsep,hWeighted,hMoment⟩ := hb₃ ρ c₁ c₂ θ₁ θ₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + let g := fun i => rooted (U₀ i) (M₀ i) (InverseClippingProfiles.secondBalancedSlope i) (hU i) + let f₁ := rooted g₁ m₁ (-(1/2:ℝ)) hg₁ + let f₂ := rooted g₂ m₂ (-(1/2:ℝ)) hg₂ + let den := density g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have hden : Integrable den := balanced_density_integrable g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have he := actual_second_deleted_physical_recursive p hp hcop hg hpr hinj hc source hs + pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) ω₁ ω₂ Φ + G E V B Y R L Z N Vlabel εchild (fun i y => U₀ i (y+ρ i)) den w labels K J A + hd₁ hd₂ hZ hG hE hV hB hX hden (by simpa only [star_star] using hsep) + hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hWeighted hleft hright + have hd : (∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖den t‖) ≤ + C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker := by + apply (le_div_iff₀ (by positivity)).mpr + exact (mul_comm _ _).le.trans hMoment + exact he.trans (mul_le_mul_of_nonneg_left + (mul_le_mul_of_nonneg_left hd (by + apply mul_nonneg + · positivity + · exact Finset.sum_nonneg (fun γ _ => tripleDivisorWeight_nonneg K γ))) (by positivity)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingEnergyUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingEnergyUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..708d7ad13592cc8dfcf3ac10e94185d4dee56eaa --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingEnergyUniform.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingEnergy + +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedPhysicalRecursive +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedMovingPhysicalUnitsUniform : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +open InverseSecondProfileUniform InverseAmbientProfileTower +theorem actual_second_deleted_moving_physical_recursive_uniform_types + (U₀ : Fin 6 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 6 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J : ℕ) : + ∃ C : ℝ,0 ≤ C ∧ ∀ {ι σ : Type} [DecidableEq ι] [DecidableEq σ] (p : ι → Eis) (hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (ω₁ ω₂ : ℝ → ℂ) (G E V B Y R L Z N Vlabel εchild : ℝ) + (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (K : ℕ) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (fun x => star (positiveSource g₁ c₁ θ₁ x)) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₁ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (positiveSource g₂ c₂ θ₂) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₂ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/(Z^N)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/(Z^N)) ≠ 0 → ∀ i, + U₀ i ((secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B (Z^N) i)+ρ i) = 1) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨C,hC,hmeasure⟩ := InverseSecondProfileUniform.second_profile_common_measure + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + refine ⟨C,hC,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B Y R L Z N Vlabel εchild ρ c₁ c₂ θ₁ θ₂ w labels K A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hRad : 0 < Y*B/(E*V^2*(Z^N)^2) := by positivity + obtain ⟨b₃,hb₃⟩ := hmeasure (Y*B/(E*V^2*(Z^N)^2)) hRad + obtain ⟨hsep,hWeighted,hMoment⟩ := hb₃ ρ c₁ c₂ θ₁ θ₂ L hρ hc₁ hc₂ hc₁b hc₂b hL + let g := fun i => rooted (U₀ i) (M₀ i) (InverseClippingProfiles.secondBalancedSlope i) (hU i) + let f₁ := rooted g₁ m₁ (-(1/2:ℝ)) hg₁ + let f₂ := rooted g₂ m₂ (-(1/2:ℝ)) hg₂ + let den := density g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have hden : Integrable den := balanced_density_integrable g f₁ f₂ b₃ ρ c₁ c₂ θ₁ θ₂ L + have he := actual_second_deleted_physical_recursive p hp hcop hg hpr hinj hc source hs + pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) ω₁ ω₂ Φ + G E V B Y R L Z N Vlabel εchild (fun i y => U₀ i (y+ρ i)) den w labels K J A + hd₁ hd₂ hZ hG hE hV hB hX hden (by simpa only [star_star] using hsep) + hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hWeighted hleft hright + have hd : (∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖den t‖) ≤ + C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker := by + apply (le_div_iff₀ (by positivity)).mpr + exact (mul_comm _ _).le.trans hMoment + exact he.trans (mul_le_mul_of_nonneg_left + (mul_le_mul_of_nonneg_left hd (by + apply mul_nonneg + · positivity + · exact Finset.sum_nonneg (fun γ _ => tripleDivisorWeight_nonneg K γ))) (by positivity)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..6969a5f987adddcd4d346e2f13df23ae4ff36960 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingMass.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondOriginalMass +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedMovingMassUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +open InverseSecondProfileUniform InverseAmbientProfileTower +variable {ι σ : Type} [DecidableEq ι] [DecidableEq σ] +theorem actual_second_deleted_moving_mass_recursive + (U₀ : Fin 6 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 6 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J K : ℕ) (εmass : ℝ) (hεmass : 0 < εmass) : + ∃ C : ℝ,0 ≤ C ∧ ∀ (p : ι → Eis) (hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (ω₁ ω₂ : ℝ → ℂ) (G E V B Y R L Z N Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (fun x => star (positiveSource g₁ c₁ θ₁ x)) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₁ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (positiveSource g₂ c₂ θ₂) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₂ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/(Z^N)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/(Z^N)) ≠ 0 → ∀ i, + U₀ i ((secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B (Z^N) i)+ρ i) = 1) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨Cp,hCp,hmoving⟩ := actual_second_deleted_moving_physical_recursive (ι:=ι) (σ:=σ) + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + obtain ⟨Cm,hCm,hmass⟩ := actual_second_original_mass K εmass hεmass + refine ⟨Cp*Cm,mul_nonneg hCp hCm.le,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B Y R L Z N Vlabel εchild ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have he := hmoving p hp hcop hg hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ ω₁ ω₂ G E V B Y R L Z N Vlabel εchild + ρ c₁ c₂ θ₁ θ₂ w labels K A hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hm := hmass p hp source 1 1 Z ell Ractive j tcount gcount theta eta hZ + hs.quotient_nonzero hs.second_divisor hcube₁ hcube₂ hactive hj hquot hcommon hdiv + have hfac : 0 ≤ 36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild)) := by positivity + have hh : 0 ≤ Cp*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker := by positivity + have hpref : 0 ≤ Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N):ℝ):ℂ)⁻¹‖ := by positivity + have hb := mul_le_mul_of_nonneg_left + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hm hfac) hh) hpref + exact he.trans (hb.trans_eq (by ring)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingMassUniform.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingMassUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..7e3bc2097268950bd21c4e456f5cd5bdf49d0946 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedMovingMassUniform.lean @@ -0,0 +1,121 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingMass +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingEnergyUniform +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedMovingEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondOriginalMass +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedMovingMassUnitsUniform : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +open InverseSecondProfileUniform InverseAmbientProfileTower +theorem actual_second_deleted_moving_mass_recursive_uniform_types + (U₀ : Fin 6 → 𝓢(ℝ,ℂ)) (g₁ g₂ Φ : 𝓢(ℝ,ℂ)) + (M₀ B₀ : Fin 6 → ℝ) (m₁ m₂ bcap : ℝ) + (hM : ∀ i,0 ≤ M₀ i) (hB₀ : ∀ i,0 ≤ B₀ i) + (hU : ∀ i,Function.support (U₀ i) ⊆ Set.Icc (-M₀ i) (M₀ i)) + (hg₁ : Function.support g₁ ⊆ Set.Icc (-m₁) m₁) + (hg₂ : Function.support g₂ ⊆ Set.Icc (-m₂) m₂) (Aker J K : ℕ) (εmass : ℝ) (hεmass : 0 < εmass) : + ∃ C : ℝ,0 ≤ C ∧ ∀ {ι σ : Type} [DecidableEq ι] [DecidableEq σ] (p : ι → Eis) (hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (_hs : ActualSecondSourceConditions p source), + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (ω₁ ω₂ : ℝ → ℂ) (G E V B Y R L Z N Vlabel εchild : ℝ) + (ell Ractive j tcount gcount theta eta : ℝ) (ρ : Fin 6 → ℝ) (c₁ c₂ θ₁ θ₂ : ℝ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ i,|ρ i| ≤ B₀ i) → 1 ≤ c₁ → 1 ≤ c₂ → c₁ ≤ bcap → c₂ ≤ bcap → 0 ≤ L → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → 0 < Y → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (fun x => star (positiveSource g₁ c₁ θ₁ x)) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₁ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + (positiveSource g₂ c₂ θ₂) (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₂ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/(Z^N)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/(Z^N)) ≠ 0 → ∀ i, + U₀ i ((secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B (Z^N) i)+ρ i) = 1) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ x∈source,primeProductNorm p x.second.sourceCommon ≤ Z^(gcount+eta)) → + (∀ x∈source,Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ (fun x => star (positiveSource g₁ c₁ θ₁ x)) (positiveSource g₂ c₂ θ₂) Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + Z^((ell+Ractive/2-j+tcount+gcount-theta+11*eta/2)*(1+εmass)))* + (C*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker)) := by + obtain ⟨Cp,hCp,hmoving⟩ := actual_second_deleted_moving_physical_recursive_uniform_types + U₀ g₁ g₂ Φ M₀ B₀ m₁ m₂ bcap hM hB₀ hU hg₁ hg₂ Aker J + obtain ⟨Cm,hCm,hmass⟩ := actual_second_original_mass K εmass hεmass + refine ⟨Cp*Cm,mul_nonneg hCp hCm.le,?_⟩ + intro ι σ _ _ p hp _ hcop hg hpr hinj hc Jo source hs pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ + ω₁ ω₂ G E V B Y R L Z N Vlabel εchild ell Ractive j tcount gcount theta eta ρ c₁ c₂ θ₁ θ₂ w labels A + hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hcube₁ hcube₂ hactive hj hquot hcommon hdiv + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have he := hmoving p hp hcop hg hpr hinj hc source hs pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ ω₁ ω₂ G E V B Y R L Z N Vlabel εchild + ρ c₁ c₂ θ₁ θ₂ w labels K A hd₁ hd₂ hρ hc₁ hc₂ hc₁b hc₂b hL hZ hG hE hV hB hX hY + hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hleft hright + have hm := hmass p hp source 1 1 Z ell Ractive j tcount gcount theta eta hZ + hs.quotient_nonzero hs.second_divisor hcube₁ hcube₂ hactive hj hquot hcommon hdiv + have hfac : 0 ≤ 36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild)) := by positivity + have hh : 0 ≤ Cp*((1+‖θ₁‖)^InverseClippingProfiles.momentOrder J * + (1+‖θ₂‖)^InverseClippingProfiles.momentOrder J) / + (1+Y*B/(E*V^2*(Z^N)^2))^Aker := by positivity + have hpref : 0 ≤ Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N):ℝ):ℂ)⁻¹‖ := by positivity + have hb := mul_le_mul_of_nonneg_left + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hm hfac) hh) hpref + exact he.trans (hb.trans_eq (by ring)) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedOriginalBound.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedOriginalBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e243d5f738de69fe598ecd9596e4eab7b2b8bdc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedOriginalBound.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeIntegral +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedModeEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondWholeMass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_deleted_mode_original_bound + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a,‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (hd₁ : ∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (hd₂ : ∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ + (Ideal.span {p i}:Ideal Eis)∣x.quotient) + (ha₁ : ∀ i∈J₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i∈J₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) + (hrows : ∀ x∈source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x∈source,‖w x‖ ≤ 1) + (A : ℝ) (hA : 0 ≤ A) + (hleft : ∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ A) + (hright : ∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ A) : + ‖∑ x∈source,actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ A * ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ := by + have hlabels' : ∀ x∈source,(actualSecondChild p u v x).2.1 ∈ labels := by + intro x hx + rw [actualSecondChild_label_units] + exact hlabels x hx + have hΓ := (actualSecondTriples_mono p u v + (show varyingAssignedSource source J₁ J₂ lists₁ lists₂ + (fun x i=>lists₁ i\deleted₁ x) (fun x i=>lists₂ i\deleted₂ x)⊆ + assignedSecondSource source J₁ J₂ lists₁ lists₂ from Finset.filter_subset _ _)).trans + (assigned_second_triples_subset p u v source J₁ J₂ lists₁ lists₂) + apply (actual_second_deleted_mode_branch_energy p hp hcop hg hpr hinj hc u v source hs pool Ψ hΨ m z + slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ hd₁ hd₂ ha₁ ha₂ ω₁ ω₂ G E V B X R t labels + hlabels' hrows K ho hJ₁ hJ₂ w hw).trans + apply (second_geometric_energy_of_bound K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + _ _ _ A hA (fun γ hγ => hright γ (hΓ hγ)) (fun γ hγ => hleft γ (hΓ hγ))).trans + exact mul_le_mul_of_nonneg_left + (Finset.sum_le_sum_of_subset_of_nonneg hΓ (fun γ _ _=>tripleDivisorWeight_nonneg K γ)) hA + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedPhysicalEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedPhysicalEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..531b8e8fd5aa4b74195582a44741b2ba03e63308 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedPhysicalEnergy.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedAllIntegral +import OAI.NumberTheory.DirichletL.Descent.SecondVaryingPhysical +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedPhysicalEnergyUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_deleted_physical_energy + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (G E V B X Y R L : ℝ) + (U : Fin 6 → ℝ → ℂ) (density : Frequency × (Fin 6 → ℝ) → ℂ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (K J : ℕ) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + 0 < G → 0 < E → 0 < V → 0 < B → 0 < X → Integrable density → + (∀ y : Fin 6 → ℝ,(Real.exp (-6*L):ℂ)*secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ U + (Y*B/(E*V^2*X^2)) y = ∫ t : Frequency × (Fin 6 → ℝ),density t* + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₁ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₁ (primeProductNorm p N/X) = 1) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₂ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₂ (primeProductNorm p N/X) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/X) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X) ≠ 0 → ∀ i, + U i (secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B X i) = 1) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Integrable (fun t : Frequency × (Fin 6 → ℝ) => + tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ + A*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ + A*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ W₁ W₂ Φ Y (G*V*X))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*X : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) := by + obtain ⟨sector,hsector⟩ := actual_second_varying_balanced_profile_children p hp hcop hg hpr (σ:=σ) source hs + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ W₁ W₂ ω₁ ω₂ Φ G E V B X Y R L + U density w labels K J A hd₁ hd₂ hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hWeighted hleft hright + have he := hsector pool Ψ m z slots₁ slots₂ (fun x i=>lists₁ i\deleted₁ x) (fun x i=>lists₂ i\deleted₂ x) a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B X Y R L + U density w hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + have hb := actual_second_deleted_all_modes_integral p hp hcop hg hpr hinj hc source hs sector pool Ψ hΨ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ hd₁ hd₂ ha₁ ha₂ ω₁ ω₂ G E V B X R labels hlabels hrows + K ho hslots₁ hslots₂ w hw A hA J density hWeighted hleft hright + have hi : (∫ t : Frequency × (Fin 6 → ℝ),density t * + ∑ uv : Eisˣ × Eisˣ,∑ x∈secondSourceSector source sector uv, + (w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x)* + ∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t) = + ∫ t : Frequency × (Fin 6 → ℝ),density t*secondDeletedFullModeSum p hp hcop hg source sector pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ ω₁ ω₂ G E V B X w t := by + apply integral_congr_ae + filter_upwards with t + rw [secondDeletedFullModeSum_physical] + rw [hi] at he + have hexp : Real.exp (6*L)*Real.exp (-6*L) = 1 := by + rw [←Real.exp_add] + ring_nf + exact Real.exp_zero + have hn := congrArg norm he + conv_lhs at hn => rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] + conv_rhs at hn => rw [norm_mul] + have hn' := congrArg (fun a : ℝ => Real.exp (6*L)*a) hn + rw [←mul_assoc,hexp,one_mul] at hn' + rw [←mul_assoc] at hn' + rw [hn'] + exact mul_le_mul_of_nonneg_left hb (by positivity) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedPhysicalRecursive.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedPhysicalRecursive.lean new file mode 100644 index 0000000000000000000000000000000000000000..16124d698dfb816aa9d80d3634c4edf8dbdbf3e5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDeletedPhysicalRecursive.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedPhysicalEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondNormalizedEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondDeletedPhysicalRecursiveUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_deleted_physical_recursive + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (deleted₁ deleted₂ : MarkedSecondSource ι Jo 0→Finset ι) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (G E V B Y R L Z N Vlabel εchild : ℝ) + (U : Fin 6 → ℝ → ℂ) (density : Frequency × (Fin 6 → ℝ) → ℂ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (K J : ℕ) (A : ℝ), + (∀ x∈source,∀ i∈deleted₁ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + (∀ x∈source,∀ i∈deleted₂ x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient) → + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → Integrable density → + (∀ y : Fin 6 → ℝ,(Real.exp (-6*L):ℂ)*secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ U + (Y*B/(E*V^2*(Z^N)^2)) y = ∫ t : Frequency × (Fin 6 → ℝ),density t* + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + W₁ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₁ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + W₂ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₂ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/(Z^N)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/(Z^N)) ≠ 0 → ∀ i, + U i (secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B (Z^N) i) = 1) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Integrable (fun t : Frequency × (Fin 6 → ℝ) => + tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (fun i=>lists₁ i\deleted₁ x) (fun i=>lists₂ i\deleted₂ x) a₁ a₂ W₁ W₂ Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) := by + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ W₁ W₂ ω₁ ω₂ Φ G E V B Y R L Z N Vlabel εchild + U density w labels K J A hd₁ hd₂ hZ hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hWeighted hleft hright + have he (H : ℝ) : Z^(max 0 N+Vlabel)*(A*Z^(max 0 N+Vlabel+εchild)*H) = + (A*Z^(2*(max 0 N+Vlabel)+εchild))*H := by + calc + _ = A*(Z^(max 0 N+Vlabel)*Z^(max 0 N+Vlabel+εchild))*H := by ring + _ = _ := by rw [←Real.rpow_add hZ]; congr 2; ring_nf + apply actual_second_deleted_physical_energy p hp hcop hg hpr hinj hc source hs + pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ deleted₁ deleted₂ W₁ W₂ ω₁ ω₂ Φ G E V B (Z^N) Y R L + U density w labels K J (A*Z^(2*(max 0 N+Vlabel)+εchild)) + hd₁ hd₂ hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels + ho hslots₁ hslots₂ (mul_nonneg hA (Real.rpow_pos_of_pos hZ _).le) hWeighted + · intro t J₁ hJ₁ γ hγ + rw [second_left_normalized_energy p hp hcop hg K (labels.filter Squarefree) + (nonzeroChildFrequencyBall 1 R) γ pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ Z N Vlabel hZ t] + rw [normalized_child_energy_radical_puncture p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedPuncture m γ)] + exact (mul_le_mul_of_nonneg_left (hleft t J₁ hJ₁ γ hγ) (Real.rpow_pos_of_pos hZ _).le).trans_eq (he _) + · intro t J₂ hJ₂ γ hγ + rw [second_right_normalized_energy p hp hcop hg K (labels.filter Squarefree) + R γ pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ Z N Vlabel hZ t] + rw [normalized_child_energy_radical_puncture p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedPuncture m γ)] + exact (mul_le_mul_of_nonneg_left (hright t J₂ hJ₂ γ hγ) (Real.rpow_pos_of_pos hZ _).le).trans_eq (he _) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondDensityAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDensityAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..89a9d126aa9973ab0626e0775d4d0881320c9ace --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondDensityAssembly.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondFreshAssembly +import OAI.NumberTheory.DirichletL.Descent.DensityAssembly + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory FourierBridge JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actualSecondFreshRows_integral_density {κ : Type*} + (source : Finset κ) (F : Finset ι) (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y G₀ E₀ V₀ K₀ X₀ : ℝ) + (density : Frequency × (Fin 6 → ℝ) → ℂ) (hDensity : Integrable density) + (he : ∀ j ∈ secondProfileIndices source F x, + secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (secondActualNorms p (x j.1) j.2.1 j.2.2) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀)) * + ∫ v : Frequency × (Fin 6 → ℝ), density v * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2) : + (∑ j ∈ source, w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∫ v : Frequency × (Fin 6 → ℝ), + density v * + ∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v := by + rw [actualSecondProfileRows_eq_indexed] + have hc (v : Frequency × (Fin 6 → ℝ)) : + (∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v) = + ∑ j ∈ secondProfileIndices source F x, + ((w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ j.2.1 j.2.2) * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀))) * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2 := by + simp_rw [← actual_second_full_mode_columns] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + simp_rw [hc] + rw [← density_finite_sum _ density hDensity,Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + rw [he j hj] + ring + +theorem actualSecondFreshRows_normalized_density {κ : Type*} + (source : Finset κ) (F : Finset ι) (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y G₀ E₀ V₀ K₀ X₀ : ℝ) + (density : Frequency × (Fin 6 → ℝ) → ℂ) (hDensity : Integrable density) (normalization : ℂ) + (he : ∀ j ∈ secondProfileIndices source F x, + normalization * secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (secondActualNorms p (x j.1) j.2.1 j.2.2) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀)) * + ∫ v : Frequency × (Fin 6 → ℝ), density v * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2) : + normalization * (∑ j ∈ source, w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∫ v : Frequency × (Fin 6 → ℝ), + density v * + ∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v := by + rw [actualSecondProfileRows_eq_indexed] + have hc (v : Frequency × (Fin 6 → ℝ)) : + (∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v) = + ∑ j ∈ secondProfileIndices source F x, + ((w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ j.2.1 j.2.2) * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀))) * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2 := by + simp_rw [← actual_second_full_mode_columns] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + simp_rw [hc] + rw [← density_finite_sum _ density hDensity] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + calc + _ = (w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ j.2.1 j.2.2) * + (normalization * secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y + (secondActualNorms p (x j.1) j.2.1 j.2.2)) := by ring + _ = _ := by rw [he j hj]; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..631ddb1add6fbcf73988d6b8e15685f0128b9d21 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondEnergy.lean @@ -0,0 +1,113 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondFibers +import OAI.NumberTheory.DirichletL.Descent.InitializationEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss SevenEighths.InverseSecondFibers IdealMobiusDivisorSum +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +abbrev SecondChild := OuterTriple × Ideal Eis × Eis + +def secondChild {Jo Jn : ℕ} (x : SecondTuple Jo Jn) : SecondChild := + (x.outer, x.core 0 * x.core 1 * x.core 2 * x.commonResidual, + primaryGenerator (x.core 7) * primaryGenerator (x.core 2) * x.frequency) + +def secondDivisorWeight (K : ℕ) (c : SecondChild) : ℝ := + ((idealDivisors c.2.1).card : ℝ) ^ (9 + 4*K) * + ((idealDivisors c.1.q0).card : ℝ) ^ (5 + 2*K) * + ((idealDivisors c.1.quotient).card : ℝ) ^ (2*K) * + ((idealDivisors c.1.residual).card : ℝ) ^ (2*K) + +theorem secondChild_eq_iff_valid {Jo Jn : ℕ} (x : SecondTuple Jo Jn) + (hx : Valid x (secondChild x).1 (secondChild x).2.1 (secondChild x).2.2) + (c : SecondChild) : secondChild x = c ↔ Valid x c.1 c.2.1 c.2.2 := by + constructor + · intro he + simpa only [he] using hx + · intro hv + apply Prod.ext hv.outer_eq + exact Prod.ext hv.label hv.row_eq + +theorem secondChild_fiber_weight {Jo Jn : ℕ} (source : Finset (SecondTuple Jo Jn)) + (oldLists : Fin Jo → Finset SmoothMobiusCorrection.PrimeIdeal) + (newLists : Fin Jn → Finset SmoothMobiusCorrection.PrimeIdeal) + (keep : SecondTuple Jo Jn → Prop) + (hvalid : ∀ x ∈ originalSource source oldLists newLists keep, + Valid x (secondChild x).1 (secondChild x).2.1 (secondChild x).2.2) + (c : SecondChild) (hf : c.2.1 ≠ 0) (hq : c.1.q0 ≠ 0) + (ht : c.1.quotient ≠ 0) (hr : c.1.residual ≠ 0) + (K : ℕ) (ho : Jo ≤ 2*K) (hn : Jn ≤ 2*K) + (w : SecondTuple Jo Jn → ℝ) + (hw : ∀ x ∈ originalSource source oldLists newLists keep, w x ≤ 1) : + (∑ x ∈ (originalSource source oldLists newLists keep).filter (fun x => secondChild x = c), w x) ≤ + secondDivisorWeight K c := by + have hfilter : (originalSource source oldLists newLists keep).filter (fun x => secondChild x = c) = + secondFiber source oldLists newLists keep c.1 c.2.1 c.2.2 := by + apply Finset.filter_congr + intro x hx + exact secondChild_eq_iff_valid x (hvalid x hx) c + calc + _ ≤ ∑ _x ∈ (originalSource source oldLists newLists keep).filter (fun x => secondChild x = c), (1 : ℝ) := + Finset.sum_le_sum (fun x hx => hw x (Finset.mem_filter.mp hx).1) + _ = ((secondFiber source oldLists newLists keep c.1 c.2.1 c.2.2).card : ℝ) := by rw [hfilter]; simp + _ ≤ secondDivisorWeight K c := by + have hh := secondFiber_card_le source oldLists newLists keep c.1 c.2.1 c.2.2 hf hq ht hr K ho hn + dsimp only [secondDivisorWeight] + exact_mod_cast hh + +theorem second_energy_projection {Jo Jn : ℕ} (source : Finset (SecondTuple Jo Jn)) + (oldLists : Fin Jo → Finset SmoothMobiusCorrection.PrimeIdeal) + (newLists : Fin Jn → Finset SmoothMobiusCorrection.PrimeIdeal) + (keep : SecondTuple Jo Jn → Prop) + (hvalid : ∀ x ∈ originalSource source oldLists newLists keep, + Valid x (secondChild x).1 (secondChild x).2.1 (secondChild x).2.2) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hf : ∀ f ∈ labels, f ≠ 0) + (houter : ∀ γ ∈ sourceTriples source oldLists newLists keep, + γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0) + (hchild : ∀ x ∈ originalSource source oldLists newLists keep, + (secondChild x).2.1 ∈ labels ∧ (secondChild x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hn : Jn ≤ 2*K) + (w : SecondTuple Jo Jn → ℝ) + (hw : ∀ x ∈ originalSource source oldLists newLists keep, w x ≤ 1) + (F : SecondChild → ℂ) : + (∑ x ∈ originalSource source oldLists newLists keep, w x * ‖F (secondChild x)‖ ^ 2) ≤ + ∑ γ ∈ sourceTriples source oldLists newLists keep, + ((idealDivisors γ.q0).card : ℝ) ^ (5 + 2*K) * + ((idealDivisors γ.quotient).card : ℝ) ^ (2*K) * + ((idealDivisors γ.residual).card : ℝ) ^ (2*K) * + ∑ f ∈ labels, ((idealDivisors f).card : ℝ) ^ (9 + 4*K) * + ∑ k ∈ rows, ‖F (γ, f, k)‖ ^ 2 := by + have hmaps : ∀ x ∈ originalSource source oldLists newLists keep, + secondChild x ∈ sourceTriples source oldLists newLists keep ×ˢ (labels ×ˢ rows) := by + intro x hx + exact Finset.mem_product.mpr ⟨Finset.mem_image.mpr ⟨x, hx, rfl⟩, + Finset.mem_product.mpr (hchild x hx)⟩ + have hfiber : ∀ c ∈ sourceTriples source oldLists newLists keep ×ˢ (labels ×ˢ rows), + (∑ x ∈ (originalSource source oldLists newLists keep).filter (fun x => secondChild x = c), w x) ≤ + secondDivisorWeight K c := by + intro c hc + obtain ⟨hγ, hfk⟩ := Finset.mem_product.mp hc + obtain ⟨hq, ht, hr⟩ := houter c.1 hγ + exact secondChild_fiber_weight source oldLists newLists keep hvalid c + (hf c.2.1 (Finset.mem_product.mp hfk).1) hq ht hr K ho hn w hw + have he := fiber_energy_bound (originalSource source oldLists newLists keep) + (sourceTriples source oldLists newLists keep ×ˢ (labels ×ˢ rows)) secondChild w + (secondDivisorWeight K) (fun c => ‖F c‖ ^ 2) hmaps (fun _ _ => sq_nonneg _) hfiber + apply he.trans_eq + simp only [Finset.sum_product, secondDivisorWeight, Finset.mul_sum] + apply Finset.sum_congr rfl + intro γ hγ + apply Finset.sum_congr rfl + intro f hfm + apply Finset.sum_congr rfl + intro k hk + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondFiniteMeasure.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFiniteMeasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..0ae1dc83c71accec08434da8dff2c35275591f87 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFiniteMeasure.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondKernelMeasure +import OAI.NumberTheory.DirichletL.Descent.ProfileIntegral + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section + +universe u + +theorem second_finite_source_common_measure + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (V : Fin 6 → ℝ → ℂ) (M : Fin 6 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ G₀ E₀ V₀ K₀ X₀ Y : ℝ, + 0 < G₀ → 0 < E₀ → 0 < V₀ → 0 < K₀ → 0 < X₀ → 0 < Y → + ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ {κ : Type u} (source : Finset κ) (c : κ → ℂ) (q : κ → Fin 6 → ℝ), + (∀ x ∈ source, ∀ i, 0 < q x i) → + (∀ x ∈ source, ∀ i, V i (secondRelativeLog (q x) G₀ E₀ V₀ K₀ X₀ i) = 1) → + (∑ x ∈ source, c x * secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (q x)) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + ∫ p : Frequency × (Fin 6 → ℝ), + fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p * + ∑ x ∈ source, c x * pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (q x) G₀ E₀ V₀ K₀ X₀) p.1 p.2) ∧ + Integrable (fun p : Frequency × (Fin 6 → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ∧ + (1 + Y*K₀/(E₀*V₀^2*X₀^2))^A * (∫ p : Frequency × (Fin 6 → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ≤ C := by + obtain ⟨b₁,b₂,C,hC,hsep⟩ := second_norm_kernel_common_measure + W₁ W₂ a b ha hs₁ hs₂ hW₁ hW₂ Φ V M hV hS hM hbox A J + refine ⟨b₁,b₂,C,hC,?_⟩ + intro G₀ E₀ V₀ K₀ X₀ Y hG hE hV₀ hK hX hY + obtain ⟨b₃,he,hi,hbound⟩ := hsep G₀ E₀ V₀ K₀ X₀ Y hG hE hV₀ hK hX hY + refine ⟨b₃,?_,hi,hbound⟩ + intro κ source c q hq hcut + have hpoint (x : κ) (hx : x ∈ source) : + secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (q x) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∫ p : Frequency × (Fin 6 → ℝ), + fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (q x) G₀ E₀ V₀ K₀ X₀) p.1 p.2 := by + rw [he (q x) (hq x hx) (hcut x hx),full_density_mode_fubini] + simp only [pureProfileMode_height] + calc + _ = ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∑ x ∈ source, c x * + ∫ p : Frequency × (Fin 6 → ℝ), + fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (q x) G₀ E₀ V₀ K₀ X₀) p.1 p.2 := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + rw [hpoint x hx] + ring + _ = _ := by rw [full_density_finite_sum] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondFixedFamily.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFixedFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..6801481b2ad2586248e0749e703f497a5f31c891 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFixedFamily.lean @@ -0,0 +1,143 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceEncoding + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem secondChildColumn_drop_puncture (Ψ : Eis →* ℂ) (m d f k : Eis) + (hd : d ∣ m*f) (H : Finset ι → ℂ) (S : Finset ι) : + secondChildColumn p hp hcop hg Ψ (m*d) f k H S = + secondChildColumn p hp hcop hg Ψ m f k H S := by + by_cases hz : ∃ i ∈ S, d ∈ Ideal.span {p i} + · obtain ⟨i,hi,hdI⟩ := hz + have hr : m*f ∈ Ideal.span {p i} := by + obtain ⟨a,ha⟩ := hd + rw [ha] + exact Ideal.mul_mem_right _ _ hdI + have hl : (m*d)*f ∈ Ideal.span {p i} := by + exact Ideal.mul_mem_right _ _ (Ideal.mul_mem_left _ _ hdI) + rw [secondChildColumn_zero_of_mask_label_mem p hp hcop hg Ψ (m*d) f k H S i hi hl, + secondChildColumn_zero_of_mask_label_mem p hp hcop hg Ψ m f k H S i hi hr] + · have hm : rowCoprimeMask (fun i => Ideal.span {p i}) S d = 1 := by + simp only [rowCoprimeMask,ite_eq_right hz] + simp only [secondChildColumn,FirstPassCubeLabels.mask_mul _ hg S,hm,mul_one] + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_drop_puncture (F : Finset ι) (Ψ : Eis →* ℂ) + (m d f k : Eis) (hd : d ∣ m*f) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) (W : ℝ → ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg F Ψ (m*d) f k slots lists a W X = + finiteCanonicalMarkedRow p hp hcop hg F Ψ m f k slots lists a W X := by + simp only [finiteCanonicalMarkedRow,fixedChildRow,secondChildColumn_drop_puncture p hp hcop hg Ψ m d f k hd] + +theorem canonicalMarkedSplit_original_lists (F V A : Finset ι) (Ψ : Eis →* ℂ) + (m r c d e k : Eis) (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) + (hA : ∀ i ∈ A, (m*r)*(c*e*∏ j ∈ V,p j) ∈ Ideal.span {p i}) : + canonicalMarkedSplit p hp hcop hg F V A Ψ m r c d e k slots lists a W X = + ∑ J ∈ slots.powerset, primeMark J lists a (A∪V) * + finiteCanonicalMarkedRow p hp hcop hg F Ψ (m*r) + (c*e*∏ j ∈ V,p j) (d*e*k) (slots\J) lists a W (X/primeProductNorm p V) := by + unfold canonicalMarkedSplit + apply Finset.sum_congr rfl + intro J hJ + rw [finiteCanonicalMarkedRow_restore_lists p hp hcop hg F A Ψ (m*r) + (c*e*∏ j ∈ V,p j) (d*e*k) (slots\J) lists a W (X/primeProductNorm p V) hA] + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem actual_first_divisor_dvd_child + (B C D V : Finset ι) (hCB : Disjoint C B) (hD : D ⊆ C∪B) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ i ∈ B, 0 < v i) + (m r e : Eis) : + primeSubsetGenerator (fun i => Ideal.span {p i}) D ∣ + ((m*b0Label p B v ε₁ ε₂)*r)* + (((∏ i ∈ C,p i)*jLabel p B v ε₁ ε₂)*e*∏ i ∈ V,p i) := by + have hd := poisson_mask_generator_dvd p D (C∪B) hD + rw [Finset.prod_union hCB] at hd + have hb := cubeRadical_dvd_jLabel_b0 p B v ε₁ ε₂ hv + change (∏ i ∈ B,p i) ∣ jLabel p B v ε₁ ε₂*b0Label p B v ε₁ ε₂ at hb + apply (hd.trans (mul_dvd_mul_left (∏ i ∈ C,p i) hb)).trans + refine ⟨m*r*e*∏ i ∈ V,p i,?_⟩ + ring + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem actual_second_extracted_support_killed + (B C G E V A : Finset ι) (hEG : E ⊆ G) (hA : A ⊆ (B∪C)∪G) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ i ∈ B, 0 < v i) (m : Eis) : + ∀ i ∈ A, + ((m*b0Label p B v ε₁ ε₂)*secondMaskQuotient p E G hEG)* + (((∏ j ∈ C,p j)*jLabel p B v ε₁ ε₂)* + primeSubsetGenerator (fun j => Ideal.span {p j}) E*∏ j ∈ V,p j) ∈ Ideal.span {p i} := by + let r := secondMaskQuotient p E G hEG + let e := primeSubsetGenerator (fun j => Ideal.span {p j}) E + let T := ((m*b0Label p B v ε₁ ε₂)*r)* + (((∏ j ∈ C,p j)*jLabel p B v ε₁ ε₂)*e*∏ j ∈ V,p j) + have hb : (∏ j ∈ B,p j) ∣ T := by + apply (cubeRadical_dvd_jLabel_b0 p B v ε₁ ε₂ hv).trans + refine ⟨m*r*(∏ j ∈ C,p j)*e*∏ j ∈ V,p j,?_⟩ + dsimp [T] + ring + have hc : (∏ j ∈ C,p j) ∣ T := by + refine ⟨m*b0Label p B v ε₁ ε₂*r*jLabel p B v ε₁ ε₂*e*∏ j ∈ V,p j,?_⟩ + dsimp [T] + ring + have hg' : (∏ j ∈ G,p j) ∣ T := by + rw [secondMaskQuotient_spec p E G hEG] + refine ⟨m*b0Label p B v ε₁ ε₂*(∏ j ∈ C,p j)*jLabel p B v ε₁ ε₂*∏ j ∈ V,p j,?_⟩ + dsimp [T,r,e] + ring + intro i hi + apply Ideal.mem_span_singleton.mpr + change p i ∣ T + rcases Finset.mem_union.mp (hA hi) with hi|hi + · rcases Finset.mem_union.mp hi with hi|hi + · exact (Finset.dvd_prod_of_mem p hi).trans hb + · exact (Finset.dvd_prod_of_mem p hi).trans hc + · exact (Finset.dvd_prod_of_mem p hi).trans hg' + +theorem actual_second_split_fixed_family + (F B C D G E V A : Finset ι) (hCB : Disjoint C B) (hD : D ⊆ C∪B) + (hEG : E ⊆ G) (hA : A ⊆ (B∪C)∪G) + (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) (hv : ∀ i ∈ B, 0 < v i) + (Ψ : Eis →* ℂ) (m k : Eis) (slots : Finset σ) (lists : σ → Finset ι) + (a : σ → ι → ℂ) (W : ℝ → ℂ) (X : ℝ) : + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) D + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) E + let r := secondMaskQuotient p E G hEG + let c := (∏ i ∈ C,p i)*jLabel p B v ε₁ ε₂ + canonicalMarkedSplit p hp hcop hg F V A Ψ + (m*b0Label p B v ε₁ ε₂*d) r c d e k slots lists a W (primeProductNorm p V*X) = + ∑ J ∈ slots.powerset, primeMark J lists a (A∪V) * + finiteCanonicalMarkedRow p hp hcop hg F Ψ ((m*b0Label p B v ε₁ ε₂)*r) + (c*e*∏ i ∈ V,p i) (d*e*k) (slots\J) lists a W X := by + dsimp only + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) D + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) E + let r := secondMaskQuotient p E G hEG + let c := (∏ i ∈ C,p i)*jLabel p B v ε₁ ε₂ + have hd := actual_first_divisor_dvd_child p B C D V hCB hD v ε₁ ε₂ hv m r e + have hk := actual_second_extracted_support_killed p B C G E V A hEG hA v ε₁ ε₂ hv m + have hm : (m*b0Label p B v ε₁ ε₂*d)*r = ((m*b0Label p B v ε₁ ε₂)*r)*d := by ring + have hX : primeProductNorm p V*X/primeProductNorm p V = X := by + field_simp [(primeProductNorm_pos p hp V).ne'] + unfold canonicalMarkedSplit + rw [show m*b0Label p B v ε₁ ε₂*primeSubsetGenerator (fun i => Ideal.span {p i}) D * + secondMaskQuotient p E G hEG = ((m*b0Label p B v ε₁ ε₂)*r)*d from hm] + rw [hX] + apply Finset.sum_congr rfl + intro J hJ + rw [finiteCanonicalMarkedRow_drop_puncture p hp hcop hg F Ψ _ d _ _ hd] + rw [finiteCanonicalMarkedRow_restore_lists p hp hcop hg F A Ψ _ _ _ (slots\J) lists a W X hk] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..4c7658de491b8cb8c11d381d140cb6e185431ccc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshAssembly.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSeparatedColumns +import OAI.NumberTheory.DirichletL.Descent.SecondFreshMeasure + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory FourierBridge JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondSeparatedPair (F : Finset ι) (x : SecondProfileData ι) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G₀ E₀ V₀ K₀ X₀ : ℝ) (v : Frequency × (Fin 6 → ℝ)) : ℂ := + let h := profileHeight secondLeftSlope secondRightSlope secondKernelSlope v.1 v.2 + secondOuterPhase h + (secondRelativeLog (secondActualNorms p x ∅ ∅) G₀ E₀ V₀ K₀ X₀) * + star (canonicalMarkedSplit p hp hcop hg F x.overlap x.extractedLeft x.rayLeft + x.puncture x.quotient x.oldLabel x.oldDivisor x.divisor x.frequency + slots₁ lists₁ a₁ (childLogTest ω₁ (-h 4)) (primeProductNorm p x.overlap*X₀)) * + canonicalMarkedSplit p hp hcop hg F x.overlap x.extractedRight x.rayRight + x.puncture x.quotient x.oldLabel x.oldDivisor x.divisor (-x.frequency) + slots₂ lists₂ a₂ (childLogTest ω₂ (h 5)) (primeProductNorm p x.overlap*X₀) + +theorem actual_second_full_mode_columns (F : Finset ι) (x : SecondProfileData ι) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G₀ E₀ V₀ K₀ X₀ : ℝ) (v : Frequency × (Fin 6 → ℝ)) : + (∑ N ∈ (F \ x.overlap).powerset, ∑ M ∈ (F \ x.overlap).powerset, + secondActualCoefficient p hp hcop hg x slots₁ slots₂ lists₁ lists₂ a₁ a₂ N M * + (star (ω₁ (primeProductNorm p N/X₀)) * ω₂ (primeProductNorm p M/X₀)) * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p x N M) G₀ E₀ V₀ K₀ X₀) v.1 v.2) = + secondSeparatedPair p hp hcop hg F x slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v := by + let h := profileHeight secondLeftSlope secondRightSlope secondKernelSlope v.1 v.2 + let O := secondOuterPhase h (secondRelativeLog (secondActualNorms p x ∅ ∅) G₀ E₀ V₀ K₀ X₀) + calc + _ = O * (∑ N ∈ (F \ x.overlap).powerset, ∑ M ∈ (F \ x.overlap).powerset, + secondActualCoefficient p hp hcop hg x slots₁ slots₂ lists₁ lists₂ a₁ a₂ N M * + (star (ω₁ (primeProductNorm p N/X₀)) * ω₂ (primeProductNorm p M/X₀)) * + logPhase (h 4) (Real.log (primeProductNorm p N/X₀)) * + logPhase (h 5) (Real.log (primeProductNorm p M/X₀))) := by + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro M hM + have hm : pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p x N M) G₀ E₀ V₀ K₀ X₀) v.1 v.2 = + O * logPhase (h 4) (Real.log (primeProductNorm p N/X₀)) * + logPhase (h 5) (Real.log (primeProductNorm p M/X₀)) := by + rw [second_mode_split] + simp [secondOuterPhase,secondRelativeLog,secondRelativeNorm,secondActualNorms,O,h] + rw [hm] + ring + _ = _ := by + rw [actual_second_columns_separated] + simp only [secondSeparatedPair,h,O,mul_assoc] + +theorem actualSecondFreshRows_integral {κ : Type*} + (source : Finset κ) (F : Finset ι) (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y G₀ E₀ V₀ K₀ X₀ : ℝ) + (g : Fin 6 → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) + (he : ∀ j ∈ secondProfileIndices source F x, + secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (secondActualNorms p (x j.1) j.2.1 j.2.2) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀)) * + ∫ v : Frequency × (Fin 6 → ℝ), fullProfileDensity g b₁ b₂ b₃ v * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2) : + (∑ j ∈ source, w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∫ v : Frequency × (Fin 6 → ℝ), + fullProfileDensity g b₁ b₂ b₃ v * + ∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v := by + rw [actualSecondProfileRows_eq_indexed] + have hc (v : Frequency × (Fin 6 → ℝ)) : + (∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v) = + ∑ j ∈ secondProfileIndices source F x, + ((w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ j.2.1 j.2.2) * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀))) * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2 := by + simp_rw [← actual_second_full_mode_columns] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + simp_rw [hc] + rw [← full_density_finite_sum,Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + rw [he j hj] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshMeasure.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshMeasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..2f7b2206e91b8af66780c0e590d947168f8ddb64 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshMeasure.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondKernelMeasure + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section + +theorem second_fresh_kernel_common_measure + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (V : Fin 6 → ℝ → ℂ) (M : Fin 6 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ G₀ E₀ V₀ K₀ X₀ Y : ℝ, + 0 < G₀ → 0 < E₀ → 0 < V₀ → 0 < K₀ → 0 < X₀ → 0 < Y → + ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ (ω₁ ω₂ : ℝ → ℂ) (q : Fin 6 → ℝ), (∀ i, 0 < q i) → + (W₁ (q 0*q 2*q 4/(G₀*V₀*X₀)) ≠ 0 → ω₁ (q 4/X₀) = 1) → + (W₂ (q 0*q 2*q 5/(G₀*V₀*X₀)) ≠ 0 → ω₂ (q 5/X₀) = 1) → + (ω₁ (q 4/X₀) ≠ 0 → ω₂ (q 5/X₀) ≠ 0 → + ∀ i, V i (secondRelativeLog q G₀ E₀ V₀ K₀ X₀ i) = 1) → + secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y q = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * (ω₁ (q 4/X₀)*ω₂ (q 5/X₀)) * + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : Fin 6 → ℝ, + fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + (∏ i, logPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope + (t₁,t₂,t₃) u i) (secondRelativeLog q G₀ E₀ V₀ K₀ X₀ i))) ∧ + Integrable (fun p : Frequency × (Fin 6 → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ∧ + (1 + Y*K₀/(E₀*V₀^2*X₀^2))^A * (∫ p : Frequency × (Fin 6 → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ≤ C := by + obtain ⟨b₁,b₂,C,hC,hsep⟩ := second_norm_kernel_common_measure + W₁ W₂ a b ha hs₁ hs₂ hW₁ hW₂ Φ V M hV hS hM hbox A J + refine ⟨b₁,b₂,C,hC,?_⟩ + intro G₀ E₀ V₀ K₀ X₀ Y hG hE hV₀ hK hX hY + obtain ⟨b₃,he,hi,hbound⟩ := hsep G₀ E₀ V₀ K₀ X₀ Y hG hE hV₀ hK hX hY + refine ⟨b₃,?_,hi,hbound⟩ + intro ω₁ ω₂ q hq hω₁ hω₂ hcut + by_cases hw₁ : ω₁ (q 4/X₀) = 0 + · have hW : W₁ (q 0*q 2*q 4/(G₀*V₀*X₀)) = 0 := by + by_contra hn + have hh := hω₁ hn + rw [hw₁] at hh + exact zero_ne_one hh + simp only [secondNormProfile,hW,hw₁,mul_zero,zero_mul,zero_div] + by_cases hw₂ : ω₂ (q 5/X₀) = 0 + · have hW : W₂ (q 0*q 2*q 5/(G₀*V₀*X₀)) = 0 := by + by_contra hn + have hh := hω₂ hn + rw [hw₂] at hh + exact zero_ne_one hh + simp only [secondNormProfile,hW,hw₂,mul_zero,zero_mul,zero_div] + have hm : secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y q = + (ω₁ (q 4/X₀)*ω₂ (q 5/X₀)) * + secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y q := by + by_cases h1 : W₁ (q 0*q 2*q 4/(G₀*V₀*X₀)) = 0 + · simp only [secondNormProfile,h1,mul_zero,zero_mul,zero_div] + by_cases h2 : W₂ (q 0*q 2*q 5/(G₀*V₀*X₀)) = 0 + · simp only [secondNormProfile,h2,mul_zero,zero_mul,zero_div] + simp only [hω₁ h1,hω₂ h2,one_mul] + rw [hm,he q hq (hcut hw₁ hw₂)] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshTruncation.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshTruncation.lean new file mode 100644 index 0000000000000000000000000000000000000000..87ec18465c3bfaaabb26be4fde1bb7277b71a191 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondFreshTruncation.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondPrincipalCaller +import OAI.NumberTheory.DirichletL.Descent.SecondParentInput + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InversePrincipalEnergy InverseSecondPrincipalCaller +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] +variable (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem first_fresh_radial_truncated + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i})≠2) + (F D B : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis→*ℂ) (m : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (coeff : σ→ι→ℂ) + (hD : ∀ i∈slots,Disjoint (lists i) D) + (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0 ActualEisensteinCubic.O +variable {ι σ κ : Type*} [DecidableEq ι] [DecidableEq σ] [DecidableEq κ] [Fintype κ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem first_parent_full_second_source + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (parent : SecondParentSource ι Jo) (F D : Finset ι) + (hq : parent.quotient = sourceIdeal p D) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (coeff : σ→ι→ℂ) + (hD : ∀ i∈slots,Disjoint (lists i) D) + (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0 parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit negative χ Ψ m (primeMark slots lists coeff) om X + (∏ i∈parent.firstCommon,p i) (secondParentDivisor p parent) core height Y = + truncatedSecondZero p hg F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K + + (∑ ray : SecondRayIndex,∑ residual∈F.powerset,∑ j : κ, + (Y : ℂ)*secondRayCoefficient ray * + ∑ x∈(secondDyadicSector F K residual label j).image (attachSecondExpansion parent), + actualSecondSignedWeight p hp hcop hg Ψ₀ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) ray x * + actualSecondProfileRow p hp hcop hg F (secondInheritedProfile p x Ψ₀ m ray) + slots slots lists lists coeff coeff V V rowMajorant Y X) + + secondSourceTail p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K := by + intro Ψ₀ V H₀ K + have htest : H₀=(fun U=>primeMark slots lists coeff U*V (primeProductNorm p U/X)) := by + funext U + simp only [H₀,markedRadial,Finset.empty_union] + have hret := truncated_second_attached_variable p hp hcop hg hinj hc hpr parent F Ψ₀ m + slots lists coeff V rowMajorant X Y R label + rw [←htest] at hret + calc + _ = truncatedSecondSource p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K + + secondSourceTail p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K := + first_fresh_parent_radial_truncated p hp hg hinj hc parent F D hq negative χ Ψ m + slots lists coeff hD om a b ha hs X height Y hX hY core K + _ = _ := congrArg (fun v=>v + secondSourceTail p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K) hret + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondGenerator.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondGenerator.lean new file mode 100644 index 0000000000000000000000000000000000000000..aeb60ea4e2046ca7c84bea2bbddcd41a4d50257e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondGenerator.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Descent.GeneratorTransport +import OAI.NumberTheory.DirichletL.Descent.SecondFreshAssembly + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def secondUnitFrequency (u v : Eisˣ) (k : Eis) : Eis := ((u^4*v:Eisˣ):Eis)*k + +lemma secondUnitFrequency_injective (u v : Eisˣ) : Function.Injective (secondUnitFrequency u v) := by + intro a b hab + exact mul_left_cancel₀ (Units.ne_zero (u^4*v)) hab + +lemma secondUnitFrequency_norm (u v : Eisˣ) (k : Eis) : + ‖ConcreteTraceCRT.eisEmbedding (secondUnitFrequency u v k)‖ = + ‖ConcreteTraceCRT.eisEmbedding k‖ := + GaussGeneratorTransport.norm_eisEmbedding_unit_mul (u^4*v) k + +lemma secondUnitFrequency_neg (u v : Eisˣ) (k : Eis) : + secondUnitFrequency u v (-k) = -secondUnitFrequency u v k := by + simp only [secondUnitFrequency,mul_neg] + +variable {ι σ : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem secondCanonical_generator_transport + (F : Finset ι) (Ψ : Eis →* ℂ) (m label d e k : Eis) + (L D E : Ideal Eis) (u v : Eisˣ) + (hl : label = (u:Eis)*primaryGenerator L) + (hd : d*e = (v:Eis)*(primaryGenerator D*primaryGenerator E)) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg F Ψ m label (d*e*k) slots lists a W X = + finiteCanonicalMarkedRow p hp hcop hg F Ψ m (primaryGenerator L) + (primaryGenerator D*primaryGenerator E*secondUnitFrequency u v k) slots lists a W X := by + rw [hl,finiteCanonicalMarkedRow_label_transfer,hd] + congr 1 + unfold secondUnitFrequency + change (u:Eis)^4*((v:Eis)*(primaryGenerator D*primaryGenerator E)*k) = + primaryGenerator D*primaryGenerator E*(((u:Eis)^4*(v:Eis))*k) + ring + +theorem secondCanonical_row_norm (D E : Ideal Eis) (u v : Eisˣ) (d e k : Eis) + (hd : d*e = (v:Eis)*(primaryGenerator D*primaryGenerator E)) : + ‖ConcreteTraceCRT.eisEmbedding + (primaryGenerator D*primaryGenerator E*secondUnitFrequency u v k)‖ = + ‖ConcreteTraceCRT.eisEmbedding (d*e*k)‖ := by + rw [hd] + have hl : primaryGenerator D*primaryGenerator E*secondUnitFrequency u v k = + ((u^4*v:Eisˣ):Eis)*(primaryGenerator D*primaryGenerator E*k) := by + unfold secondUnitFrequency + ring + rw [hl,GaussGeneratorTransport.norm_eisEmbedding_unit_mul] + have hr : (v:Eis)*(primaryGenerator D*primaryGenerator E)*k = + (v:Eis)*(primaryGenerator D*primaryGenerator E*k) := by ring + rw [hr,GaussGeneratorTransport.norm_eisEmbedding_unit_mul] + +theorem exists_second_generator_sectors (label d e : Eis) (L D E : Ideal Eis) + (hl : Ideal.span {label} = L) (hd : Ideal.span {d} = D) (he : Ideal.span {e} = E) + (hL : primaryGenerator L ≠ 0) (hD : primaryGenerator D ≠ 0) (hE : primaryGenerator E ≠ 0) : + ∃ u v : Eisˣ, label = (u:Eis)*primaryGenerator L ∧ + d*e = (v:Eis)*(primaryGenerator D*primaryGenerator E) := by + obtain ⟨u,hu⟩ := generator_eq_unit_primary L label hl hL + have hspan : Ideal.span {d*e} = D*E := by + rw [← Ideal.span_singleton_mul_span_singleton,hd,he] + obtain ⟨v,hv⟩ := generator_eq_unit_primary (D*E) (d*e) hspan + (by rw [primaryGenerator_mul]; exact mul_ne_zero hD hE) + exact ⟨u,v,hu,by simpa only [primaryGenerator_mul] using hv⟩ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondInheritedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondInheritedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..41f387ae05e7e2afc7946f46f28d1a729931e6ef --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondInheritedEnergy.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSupportedEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondPuncture + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_supported_marked_energy_varying_puncture + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : MarkedSecondSource ι Jo 0 → Eis) (z : SecondRayIndex) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ L₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ L₂ i, ‖a₂ i q‖ ≤ 1) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hchild : ∀ x ∈ source, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (phase : MarkedSecondSource ι Jo 0 → ℂ) (hphase : ∀ x ∈ source, ‖phase x‖ ≤ 1) + (F G : SecondChild → ℂ) : + ‖∑ x ∈ source, (actualSecondSignedWeight p hp hcop hg Ψ (m x) z x * phase x) * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))‖ ≤ + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource + source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows F γ) * + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource + source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows G γ) := by + let S := source.filter (fun x => actualSecondSignedWeight p hp hcop hg Ψ (m x) z x ≠ 0) + have hsub : S ⊆ source := Finset.filter_subset _ _ + have he : (∑ x ∈ source, (actualSecondSignedWeight p hp hcop hg Ψ (m x) z x * phase x) * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))) = + ∑ x ∈ S, (actualSecondSignedWeight p hp hcop hg Ψ (m x) z x * phase x) * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x)) := by + symm + apply Finset.sum_subset hsub + intro x hx hnx + have hz : actualSecondSignedWeight p hp hcop hg Ψ (m x) z x = 0 := by + by_contra hh + exact hnx (Finset.mem_filter.mpr ⟨hx,hh⟩) + simp only [hz,zero_mul] + rw [he] + have hb := actual_second_marked_weighted_count p hp hcop hpr hinj u v S + (hs.mono p hsub) J₁ J₂ L₁ L₂ a₁ a₂ ha₁ ha₂ (labels.filter Squarefree) rows + (by + intro x hx + have hx0 := hsub hx + refine ⟨Finset.mem_filter.mpr ⟨(hchild x hx0).1,?_⟩,(hchild x hx0).2⟩ + exact actual_second_nonzero_weight_squarefree p hp hcop hg Ψ (m x) z x + (hs.common_disjoint x hx0) (hs.second_divisor x hx0) (Finset.mem_filter.mp hx).2 u v) + K ho hJ₁ hJ₂ (fun x => actualSecondSignedWeight p hp hcop hg Ψ (m x) z x*phase x) + (by + intro x hx + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) + (actualSecondSignedWeight_norm_le_one p hp hcop hg hinj hc Ψ hΨ (m x) z x)).trans + (hphase x (hsub hx))) F G + apply hb.trans + have hΓ := actualSecondTriples_mono p u v (assignedSecondSource_mono hsub J₁ J₂ L₁ L₂) + have hsum (P : SecondChild → ℂ) : + (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource S J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows P γ) ≤ + ∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows P γ := by + apply Finset.sum_le_sum_of_subset_of_nonneg hΓ + intro γ _ _ + exact mul_nonneg (tripleDivisorWeight_nonneg K γ) (secondLabelEnergy_nonneg _ _ _ _ _) + exact mul_le_mul (Real.sqrt_le_sqrt (hsum F)) (Real.sqrt_le_sqrt (hsum G)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondKernelMeasure.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondKernelMeasure.lean new file mode 100644 index 0000000000000000000000000000000000000000..bee7f25f25cee428a3fba0877c990b548379024a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondKernelMeasure.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondProfileIdentity + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section + +def secondRelativeNorm (q : Fin 6 → ℝ) (G E V K X : ℝ) : Fin 6 → ℝ := + ![q 0/G,q 1/E,q 2/V,q 3/K,q 4/X,q 5/X] + +def secondRelativeLog (q : Fin 6 → ℝ) (G E V K X : ℝ) (i : Fin 6) : ℝ := + Real.log (secondRelativeNorm q G E V K X i) + +lemma secondRelativeNorm_pos (q : Fin 6 → ℝ) (hq : ∀ i, 0 < q i) + (G E V K X : ℝ) (hG : 0 < G) (hE : 0 < E) (hV : 0 < V) (hK : 0 < K) (hX : 0 < X) : + ∀ i, 0 < secondRelativeNorm q G E V K X i := by + intro i + fin_cases i + · exact div_pos (hq 0) hG + · exact div_pos (hq 1) hE + · exact div_pos (hq 2) hV + · exact div_pos (hq 3) hK + · exact div_pos (hq 4) hX + · exact div_pos (hq 5) hX + +lemma secondNormProfile_eq_full_of_windows (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 6 → ℝ → ℂ) (R : ℝ) (q : Fin 6 → ℝ) (hq : ∀ i, 0 < q i) + (hV : ∀ i, V i (Real.log (q i)) = 1) : + secondNormProfile W₁ W₂ Φ (fun _ _ => 1) R q = + secondPoissonProfile W₁ W₂ Φ V R (fun i => Real.log (q i)) := by + rw [secondPoissonProfile_log W₁ W₂ Φ V R q hq] + simp only [secondNormProfile, hV, Finset.prod_const_one] + +theorem second_norm_kernel_common_measure + (W₁ W₂ : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs₁ : Function.support W₁ ⊆ Set.Icc a b) (hs₂ : Function.support W₂ ⊆ Set.Icc a b) + (hW₁ : ContDiff ℝ ∞ W₁) (hW₂ : ContDiff ℝ ∞ W₂) + (Φ : 𝓢(ℝ, ℂ)) (V : Fin 6 → ℝ → ℂ) (M : Fin 6 → ℝ) + (hV : ∀ i, ContDiff ℝ ∞ (V i)) (hS : ∀ i, HasCompactSupport (V i)) + (hM : ∀ i, 0 ≤ M i) (hbox : ∀ i y, V i y ≠ 0 → |y| ≤ M i) (A J : ℕ) : + ∃ (b₁ b₂ : 𝓢(ℝ, ℂ)) (C : ℝ), 0 ≤ C ∧ + ∀ G₀ E₀ V₀ K₀ X₀ Y : ℝ, + 0 < G₀ → 0 < E₀ → 0 < V₀ → 0 < K₀ → 0 < X₀ → 0 < Y → + ∃ b₃ : 𝓢(ℝ, ℂ), + (∀ (q : Fin 6 → ℝ), (∀ i, 0 < q i) → + (∀ i, V i (secondRelativeLog q G₀ E₀ V₀ K₀ X₀ i) = 1) → + secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y q = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : Fin 6 → ℝ, + fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + (∏ i, logPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope + (t₁,t₂,t₃) u i) (secondRelativeLog q G₀ E₀ V₀ K₀ X₀ i))) ∧ + Integrable (fun p : Frequency × (Fin 6 → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ∧ + (1 + Y*K₀/(E₀*V₀^2*X₀^2))^A * (∫ p : Frequency × (Fin 6 → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * + ‖fullProfileDensity (secondRootSchwartz V hV hS) b₁ b₂ b₃ p‖) ≤ C := by + obtain ⟨b₁,b₂,C,hC,hsep⟩ := second_full_profile_common_measure + W₁ W₂ a b ha hs₁ hs₂ hW₁ hW₂ Φ V M hV hS hM hbox A J + refine ⟨b₁,b₂,C,hC,?_⟩ + intro G₀ E₀ V₀ K₀ X₀ Y hG hE hV₀ hK hX hY + obtain ⟨b₃,he,hi,hbound⟩ := hsep (Y*K₀/(E₀*V₀^2*X₀^2)) (by positivity) + refine ⟨b₃,?_,hi,hbound⟩ + intro q hq hcut + rw [secondNormProfile_nominal W₁ W₂ Φ G₀ E₀ V₀ K₀ X₀ Y hG hE hV₀ hK hX q hq] + change ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * secondNormProfile W₁ W₂ Φ (fun _ _ => 1) + (Y*K₀/(E₀*V₀^2*X₀^2)) (secondRelativeNorm q G₀ E₀ V₀ K₀ X₀) = _ + rw [secondNormProfile_eq_full_of_windows W₁ W₂ Φ V _ _ + (secondRelativeNorm_pos q hq G₀ E₀ V₀ K₀ X₀ hG hE hV₀ hK hX) hcut, he] + rfl + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondMarkedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondMarkedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..fe7da351ae599e6f7e66ad402fd2ab8358797575 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondMarkedEnergy.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondAssignedSum + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actualSecondChild_erase {Jo Jn : ℕ} (u v : Eisˣ) (x : MarkedSecondSource ι Jo Jn) : + actualSecondChild p u v (eraseSecondSlots x) = actualSecondChild p u v x := rfl + +theorem actualSecondChild_neg_frequency {Jo Jn : ℕ} (u v : Eisˣ) (x : MarkedSecondSource ι Jo Jn) : + actualSecondChild p u v {x with second := {x.second with frequency := -x.second.frequency}} = + ((actualSecondChild p u v x).1,(actualSecondChild p u v x).2.1,-(actualSecondChild p u v x).2.2) := by + simp only [actualSecondChild,secondChild,originalSecondTuple,markedSecondOriginal,cubeSecondSource, + secondUnitFrequency_neg,mul_neg] + +include hp hcop in +theorem actual_second_marked_weighted_count + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ L₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ L₂ i, ‖a₂ i q‖ ≤ 1) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hchild : ∀ x ∈ source, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x ∈ source, ‖w x‖ ≤ 1) + (F G : SecondChild → ℂ) : + ‖∑ x ∈ source, w x * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))‖ ≤ + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K labels rows F γ) * + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K labels rows G γ) := by + let S := assignedSecondSource source J₁ J₂ L₁ L₂ + let w' := fun x : MarkedSecondSource ι Jo (J₁.card+J₂.card) => + w (eraseSecondSlots x)*assignedSecondCoefficient J₁ J₂ a₁ a₂ x + have hs' : ActualSecondSourceConditions p S := assignedSecondSource_conditions p source hs J₁ J₂ L₁ L₂ + have herase : ∀ x ∈ S, eraseSecondSlots x ∈ source := by + intro x hx + obtain ⟨y,hy,q₁,hq₁,q₂,hq₂,rfl⟩ := (mem_assignedSecondSource source J₁ J₂ L₁ L₂ x).mp hx + simpa only [attachPairedSlots,erase_attachSecondSlots] using hy + have hw' : ∀ x ∈ S, ‖w' x‖ ≤ 1 := by + intro x hx + rw [show w' x = w (eraseSecondSlots x)*assignedSecondCoefficient J₁ J₂ a₁ a₂ x from rfl,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (hw _ (herase x hx))).trans + (assignedSecondCoefficient_norm_le_one source J₁ J₂ L₁ L₂ a₁ a₂ ha₁ ha₂ x hx) + have hc' : ∀ x ∈ S, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ rows := by + intro x hx + simpa only [actualSecondChild_erase] using hchild (eraseSecondSlots x) (herase x hx) + have he := assignedSecondSource_sum_marks source J₁ J₂ L₁ L₂ a₁ a₂ w + (fun x => F (actualSecondChild p u v x)*star (G (actualSecondChild p u v x))) + simp only [actualSecondChild_erase,←mul_assoc] at he + simp only [←mul_assoc] + rw [he] + exact actual_second_weighted_count p hp hpr hcop hinj u v S hs' labels rows hc' K ho + (by omega) w' hw' F G + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondMarkedTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondMarkedTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..2829a89bcb50fc4b68145aca4b33fbb02c400149 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondMarkedTail.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondWholeCutoff +import OAI.NumberTheory.DirichletL.Inversion.SecondPrincipalCaller + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstCauchyArithmetic CompletedGauss FirstPassCubeLabels SecondPassArithmetic +open InversePrincipalEnergy InverseSecondPrincipalCaller +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem marked_radial_uniform_bound (ε : ℝ) (hε : 0 < ε) : + ∃ Cm : ℝ, 0 < Cm ∧ ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → O) (_hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (_hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i ∈ slots, ∀ k ∈ lists i, ‖a i k‖ ≤ 1) → + ∀ (A : Finset ι) (V : 𝓢(ℝ,ℂ)) (X M : ℝ), 0 < X → + (∀ u, V u ≠ 0 → u ≤ Real.exp M) → + ∀ U, ‖markedRadial p slots lists a A V X U‖ ≤ + (2:ℝ)^A.card * Cm * (X*Real.exp M)^ε * SchwartzMap.seminorm ℝ 0 0 V := by + obtain ⟨Cm,hCm,hmark⟩ := finite_primeMark_extracted_bound ε hε + refine ⟨Cm,hCm,?_⟩ + intro ι σ _ _ p hp _ hcop slots lists a hslots ha A V X M hX hV U + by_cases hz : V (primeProductNorm p U/X) = 0 + · simp only [markedRadial,hz,mul_zero,norm_zero] + positivity + · have hn : primeProductNorm p U ≤ X*Real.exp M := by + simpa only [mul_comm] using (div_le_iff₀ hX).mp (hV _ hz) + have hn0 : 0 ≤ primeProductNorm p U := (primeProductNorm_pos p hp U).le + rw [markedRadial,norm_mul] + apply (mul_le_mul (hmark p hp hcop slots lists a hslots ha A U) + (V.norm_le_seminorm ℝ _) (norm_nonneg _) (by positivity)).trans + gcongr + +theorem full_marked_second_tail (ε : ℝ) (hε : 0 < ε) (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (Ct Cm : ℝ), 0 < Ct ∧ 0 < Cm ∧ + ∀ {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (_hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) + (F : Finset ι) (Ψ : O →* ℂ) (_hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (_hd : d ≠ 0) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i ∈ slots, ∀ k ∈ lists i, ‖a i k‖ ≤ 1) → + ∀ (A : Finset ι) (V W : 𝓢(ℝ,ℂ)) (X M Y H R : ℝ), + 0 < X → 0 < Y → 0 ≤ H → 1 ≤ X*Real.exp M → + (∀ u, V u ≠ 0 → u ≤ Real.exp M) → + wholeSecondRadius d (X*Real.exp M) Y H ≤ R → + ‖secondSourceTail p hp hg hinj F Ψ m c d (markedRadial p slots lists a A V X) W Y + (fun _ E => childFrequencyBall (d*primeSubsetGenerator (fun i => Ideal.span {p i}) E) R)‖ ≤ + (128*(X*Real.exp M))^4 * + (((2:ℝ)^A.card * Cm * (X*Real.exp M)^ε * SchwartzMap.seminorm ℝ 0 0 V)^2 * + (Y*(Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)* + (1+(X*Real.exp M)^3/Y)^2/(1+H)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_second_whole_column_tail order + obtain ⟨Cm,hCm,hmark⟩ := marked_radial_uniform_bound ε hε + refine ⟨s,Ct,Cm,hCt,hCm,?_⟩ + intro ι σ _ _ p hp _ hcop hg hinj hc F Ψ hΨ m c d hd slots lists a hslots ha A V W X M Y H R hX hY hH hL hV hR + apply htail p hp hg hinj hc F Ψ hΨ m c d hd (markedRadial p slots lists a A V X) W + _ Y H (X*Real.exp M) R (by positivity) hY hH hL + · exact hmark p hp hcop slots lists a hslots ha A V X M hX hV + · exact markedRadial_support p slots lists a A V X M hX hV + · exact hR + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeCanonical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeCanonical.lean new file mode 100644 index 0000000000000000000000000000000000000000..0c6a62474758f91c0739c1769e5a4e6d75732d73 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeCanonical.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSectorAssembly +import OAI.NumberTheory.DirichletL.Descent.SecondInheritedEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseSecondFibers JointLogSeparation +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondInheritedProfile {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) : SecondProfileData ι := + actualMarkedSecondProfileData p x Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z ∅ ∅ + +def secondModeLeft (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (ω : ℝ → ℂ) (X : ℝ) (t : Frequency × (Fin 6 → ℝ)) : SecondChild → ℂ := + secondCanonicalPolynomial p hp hcop hg pool (fun _ => secondRayMinus Ψ z) + (actualSecondInheritedPuncture m) slots lists a + (fun _ => childLogTest ω (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) X + +def secondModeRight (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (ω : ℝ → ℂ) (X : ℝ) (t : Frequency × (Fin 6 → ℝ)) (c : SecondChild) : ℂ := + secondCanonicalPolynomial p hp hcop hg pool (fun _ => secondRayPlus Ψ z) + (actualSecondInheritedPuncture m) slots lists a + (fun _ => childLogTest ω ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) X + (c.1,c.2.1,-c.2.2) + +def secondModeOuter {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (G E V B X : ℝ) (t : Frequency × (Fin 6 → ℝ)) : ℂ := + secondOuterPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) + (secondRelativeLog (secondActualNorms p (secondInheritedProfile p x Ψ m z) ∅ ∅) G E V B X) + +def secondModeBranch {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (t : Frequency × (Fin 6 → ℝ)) : ℂ := + secondModeOuter p x Ψ m z G E V B X t * + (star (primeMark J₁ lists₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ lists₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + star (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t (actualSecondChild p u v x)) * + secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t (actualSecondChild p u v x) + +theorem second_inherited_mode_canonical {Jo Jn : ℕ} + (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) + (hx : SecondPairCanonicalAt (σ:=σ) p hp hcop hg x u v) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (t : Frequency × (Fin 6 → ℝ)) : + secondSeparatedPair p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t = + ∑ J₁ ∈ slots₁.powerset,∑ J₂ ∈ slots₂.powerset, + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t := by + have he := hx pool Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z ∅ ∅ + (Finset.empty_subset _) (Finset.empty_subset _) slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t + dsimp only at he + have hq : (actualSecondChild p u v x).1.quotient = x.quotient := rfl + simpa only [secondInheritedProfile,secondModeBranch,secondModeOuter,secondModeLeft,secondModeRight, + secondCanonicalPolynomial,actualSecondInheritedPuncture,actualSecondChild_neg_frequency, + Finset.empty_union,Finset.mul_sum,mul_assoc,hq] using he + +theorem actual_second_modes_common_sectors + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∃ sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ, + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (w : MarkedSecondSource ι Jo 0 → ℂ), + (∑ x ∈ source,w x * secondSeparatedPair p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t) = + ∑ uv : Eisˣ × Eisˣ, ∑ x ∈ secondSourceSector source sector uv, w x * + ∑ J₁ ∈ slots₁.powerset,∑ J₂ ∈ slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t := by + obtain ⟨sector,hsector⟩ := exists_second_uniform_sectors p hp hcop hg hpr (σ:=σ) source hs + refine ⟨sector,?_⟩ + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t w + rw [secondSourceSector_partition source sector] + apply Finset.sum_congr rfl + intro uv huv + apply Finset.sum_congr rfl + intro x hx + obtain ⟨hx,hxs⟩ := Finset.mem_filter.mp hx + congr 1 + have hh := hsector x hx + rw [hxs] at hh + exact second_inherited_mode_canonical p hp hcop hg x uv.1 uv.2 hh + pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..1f1e1323a90d0b78426cc9d4c4c8c3086f4a5714 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeEnergy.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeCanonical +import OAI.NumberTheory.DirichletL.Descent.SecondPhysicalRows + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_mode_branch_energy + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ lists₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ lists₂ i, ‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x ∈ source,(actualSecondChild p u v x).2.1 ∈ labels) + (hrows : ∀ x ∈ source, + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x ∈ source,‖w x‖ ≤ 1) : + ‖∑ x ∈ source,actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ lists₁ lists₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ) * + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ lists₁ lists₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ) := by + let phase := fun x => w x * secondModeOuter p x Ψ m z G E V B X t + have hphase : ∀ x ∈ source,‖phase x‖ ≤ 1 := by + intro x hx + simpa only [phase,norm_mul,secondModeOuter,secondOuterPhase_norm,mul_one] using hw x hx + have hchild : ∀ x ∈ source, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ nonzeroChildFrequencyBall 1 R := by + intro x hx + exact ⟨hlabels x hx,(actual_second_row_ball p hp hpr x u v R).mp (hrows x hx)⟩ + have he := actual_second_supported_marked_energy_varying_puncture p hp hcop hg hpr hinj hc + u v source hs Ψ hΨ (fun x => m*ConcretePrimeRowBridge.idealGenerator x.quotient) z + J₁ J₂ lists₁ lists₂ a₁ a₂ ha₁ ha₂ labels (nonzeroChildFrequencyBall 1 R) hchild + K ho hJ₁ hJ₂ phase hphase + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) + apply le_trans (le_of_eq ?_) he + congr 1 + apply Finset.sum_congr rfl + intro x hx + dsimp only [secondModeBranch,phase] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeIntegral.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeIntegral.lean new file mode 100644 index 0000000000000000000000000000000000000000..9afbdfc89abaa73f4e618c020e3aaf37e69d9c58 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeIntegral.lean @@ -0,0 +1,104 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem second_geometric_energy_of_bound (K : ℕ) (labels : Finset (Ideal Eis)) + (rows : Finset Eis) (Γ : Finset OuterTriple) (F G : SecondChild → ℂ) + (E : ℝ) (hE : 0 ≤ E) + (hF : ∀ γ ∈ Γ,secondLabelEnergy K labels rows F γ ≤ E) + (hG : ∀ γ ∈ Γ,secondLabelEnergy K labels rows G γ ≤ E) : + Real.sqrt (∑ γ ∈ Γ,tripleDivisorWeight K γ*secondLabelEnergy K labels rows F γ) * + Real.sqrt (∑ γ ∈ Γ,tripleDivisorWeight K γ*secondLabelEnergy K labels rows G γ) ≤ + E * ∑ γ ∈ Γ,tripleDivisorWeight K γ := by + have hb (P : SecondChild → ℂ) (hP : ∀ γ ∈ Γ,secondLabelEnergy K labels rows P γ ≤ E) : + (∑ γ ∈ Γ,tripleDivisorWeight K γ*secondLabelEnergy K labels rows P γ) ≤ + E * ∑ γ ∈ Γ,tripleDivisorWeight K γ := by + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro γ hγ + simpa only [mul_comm] using mul_le_mul_of_nonneg_left (hP γ hγ) (tripleDivisorWeight_nonneg K γ) + calc + _ ≤ Real.sqrt (E*∑ γ ∈ Γ,tripleDivisorWeight K γ) * + Real.sqrt (E*∑ γ ∈ Γ,tripleDivisorWeight K γ) := + mul_le_mul (Real.sqrt_le_sqrt (hb F hF)) (Real.sqrt_le_sqrt (hb G hG)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + _ = _ := Real.mul_self_sqrt (mul_nonneg hE (Finset.sum_nonneg (fun γ _ => tripleDivisorWeight_nonneg K γ))) + +theorem actual_second_mode_integral_of_child_bound + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ lists₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ lists₂ i, ‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x ∈ source,(actualSecondChild p u v x).2.1 ∈ labels) + (hrows : ∀ x ∈ source, + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x ∈ source,‖w x‖ ≤ 1) + (gwin : Fin 6 → 𝓢(ℝ,ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ,ℂ)) (A : ℝ) (hA : 0 ≤ A) (J : ℕ) + (hleft : ∀ t : Frequency × (Fin 6 → ℝ), + ∀ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ lists₁ lists₂), + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ + A*(tripleHeight J t.1*coordinateHeight J t.2)) + (hright : ∀ t : Frequency × (Fin 6 → ℝ), + ∀ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ lists₁ lists₂), + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ + A*(tripleHeight J t.1*coordinateHeight J t.2)) : + ‖∫ t : Frequency × (Fin 6 → ℝ),fullProfileDensity gwin b₁ b₂ b₃ t * + ∑ x ∈ source,actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ + (A * ∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ lists₁ lists₂), + tripleDivisorWeight K γ) * + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2* + ‖fullProfileDensity gwin b₁ b₂ b₃ t‖ := by + let Γ := actualSecondTriples p u v (assignedSecondSource source J₁ J₂ lists₁ lists₂) + let mass := ∑ γ ∈ Γ,tripleDivisorWeight K γ + let H := fun t : Frequency × (Fin 6 → ℝ) => tripleHeight J t.1*coordinateHeight J t.2 + have hH (t : Frequency × (Fin 6 → ℝ)) : 0 ≤ H t := by + unfold H tripleHeight coordinateHeight + positivity + have hb (t : Frequency × (Fin 6 → ℝ)) : + ‖∑ x ∈ source,actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ (A*H t)*mass := by + apply (actual_second_mode_branch_energy p hp hcop hg hpr hinj hc u v source hs pool Ψ hΨ m z + slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ ha₁ ha₂ ω₁ ω₂ G E V B X R t + labels hlabels hrows K ho hJ₁ hJ₂ w hw).trans + exact second_geometric_energy_of_bound K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + Γ _ _ (A*H t) (mul_nonneg hA (hH t)) (hright t) (hleft t) + have hi := (fullProfileDensity_weighted_integrable gwin b₁ b₂ b₃ J).const_mul (A*mass) + calc + _ ≤ ∫ t : Frequency × (Fin 6 → ℝ),(A*mass)*(tripleHeight J t.1*coordinateHeight J t.2* + ‖fullProfileDensity gwin b₁ b₂ b₃ t‖) := by + apply norm_integral_le_of_norm_le hi + filter_upwards with t + rw [norm_mul] + exact (mul_le_mul_of_nonneg_left (hb t) (norm_nonneg _)).trans_eq (by dsimp only [H]; ring) + _ = _ := by rw [integral_const_mul] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeParentLists.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeParentLists.lean new file mode 100644 index 0000000000000000000000000000000000000000..bbe33258205f7c26f055e53583b6f4a09f9a1dc0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondModeParentLists.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondParentLists +import OAI.NumberTheory.DirichletL.Descent.SecondModeCanonical + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic SecondPassArithmetic FirstPassCubeLabels FirstCauchyArithmetic +open InverseInitialArithmetic CompletedGauss InverseSecondFibers JointLogSeparation +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +include hp in +theorem actual_second_canonical_label_span + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Oˣ) : + Ideal.span {actualSecondRawLabel p x}= + Ideal.span {primaryGenerator (actualSecondChild p u v x).2.1} := by + obtain ⟨u₀,v₀,hl,hv⟩ := actual_second_generator_sectors p hp hpr x + rw [hl,←Ideal.span_singleton_mul_span_singleton] + simp only [Ideal.span_singleton_eq_top.mpr (Units.isUnit u₀),Ideal.top_mul] + rfl + +theorem secondCanonicalPolynomial_parent_lists_restore + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (hb : x.cube.Admissible) + (hE : x.second.divisor⊆x.second.sourceCommon) (u v : Oˣ) + (deleted : Finset ι) + (hdeleted : ∀ i∈deleted,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal O)∣x.quotient) + (pool : Finset ι) (Ψ : OuterTriple→O→*ℂ) (m : O) + (slots : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (W : OuterTriple→ℝ→ℂ) (X : ℝ) (k : O) : + secondCanonicalPolynomial p hp hcop hg pool Ψ (actualSecondInheritedPuncture m) + slots (fun j=>lists j\deleted) a W X ((actualSecondChild p u v x).1, + (actualSecondChild p u v x).2.1,k) = + secondCanonicalPolynomial p hp hcop hg pool Ψ (actualSecondInheritedPuncture m) + slots lists a W X ((actualSecondChild p u v x).1,(actualSecondChild p u v x).2.1,k) := by + apply finiteCanonicalMarkedRow_restore_lists p hp hcop hg + intro i hi + have hk := actual_parent_deleted_prime_killed p x hb hE m i (hdeleted i hi) + have he : Ideal.span {actualSecondRawInheritedPuncture p m x*actualSecondRawLabel p x}= + Ideal.span {actualSecondInheritedPuncture m (actualSecondChild p u v x).1* + primaryGenerator (actualSecondChild p u v x).2.1} := by + rw [←Ideal.span_singleton_mul_span_singleton,←Ideal.span_singleton_mul_span_singleton, + actual_second_canonical_label_span p hp hpr x u v] + congr 1 + exact actual_second_puncture_span p hp hpr x hE u v + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) + have hk' : Ideal.span {actualSecondRawInheritedPuncture p m x*actualSecondRawLabel p x}≤Ideal.span {p i} := + Ideal.span_le.mpr (by intro z hz; rcases Set.mem_singleton_iff.mp hz with rfl; exact hk) + rw [he] at hk' + exact hk' (Ideal.subset_span (by simp)) + +theorem secondModeBranch_parent_lists_restore + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (hb : x.cube.Admissible) + (hE : x.second.divisor⊆x.second.sourceCommon) (u v : Oˣ) + (deleted₁ deleted₂ : Finset ι) + (hd₁ : ∀ i∈deleted₁,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal O)∣x.quotient) + (hd₂ : ∀ i∈deleted₂,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal O)∣x.quotient) + (pool : Finset ι) (Ψ : O→*ℂ) (m : O) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ→Finset ι) (a₁ a₂ : σ→ι→ℂ) + (ω₁ ω₂ : ℝ→ℂ) (G E V B X : ℝ) (t : Frequency×(Fin 6→ℝ)) : + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ + (fun i=>lists₁ i\deleted₁) (fun i=>lists₂ i\deleted₂) a₁ a₂ ω₁ ω₂ G E V B X t = + secondModeOuter p x Ψ m z G E V B X t * + (star (primeMark J₁ (fun i=>lists₁ i\deleted₁) a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ (fun i=>lists₂ i\deleted₂) a₂ (x.second.sourceCommon∪x.second.overlap)) * + star (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t (actualSecondChild p u v x)) * + secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t (actualSecondChild p u v x) := by + unfold secondModeBranch secondModeLeft secondModeRight + rw [secondCanonicalPolynomial_parent_lists_restore p hp hcop hg hpr x hb hE u v deleted₁ hd₁, + secondCanonicalPolynomial_parent_lists_restore p hp hcop hg hpr x hb hE u v deleted₂ hd₂] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondNormalizedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondNormalizedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..377f106e3d4e8f0a550b8ae750e2560cd4cee128 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondNormalizedEnergy.lean @@ -0,0 +1,100 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeEnergy +import OAI.NumberTheory.DirichletL.Inversion.InitialClippedColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open JointLogSeparation IdealMobiusDivisorSum InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +lemma child_ball_neg (R : ℝ) (k : Eis) : + -k ∈ nonzeroChildFrequencyBall 1 R ↔ k ∈ nonzeroChildFrequencyBall 1 R := by + simp only [mem_nonzeroChildFrequencyBall _ one_ne_zero,one_mul,map_neg,norm_neg] + +lemma child_ball_sum_neg {β : Type*} [AddCommMonoid β] (R : ℝ) (F : Eis → β) : + ∑ k ∈ nonzeroChildFrequencyBall 1 R,F (-k) = + ∑ k ∈ nonzeroChildFrequencyBall 1 R,F k := by + apply Finset.sum_bij (fun k _ => -k) + · intro k hk + exact (child_ball_neg R k).mpr hk + · intro a ha b hb he + exact neg_injective he + · intro b hb + exact ⟨-b,(child_ball_neg R b).mpr hb,neg_neg b⟩ + · intro k hk + rfl + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondLabelWeight (K : ℕ) (f : Ideal Eis) : ℝ := ((idealDivisors f).card : ℝ)^(9+4*K) + +theorem second_left_normalized_energy + (K : ℕ) (labels : Finset (Ideal Eis)) (rows : Finset Eis) (γ : OuterTriple) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (ω : ℝ → ℂ) (Z N V : ℝ) (hZ : 0 < Z) (t : Frequency × (Fin 6 → ℝ)) : + secondLabelEnergy K labels rows (secondModeLeft p hp hcop hg pool Ψ m z slots lists a ω (Z^N) t) γ = + Z^(max 0 N+V) * normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedPuncture m γ) slots lists a labels rows (secondLabelWeight K) + (clippedTest ω (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+V) := by + exact initial_columnEnergy_clipping_normalized p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedPuncture m γ) slots lists a labels rows (secondLabelWeight K) ω hZ N V _ + +theorem second_right_normalized_energy + (K : ℕ) (labels : Finset (Ideal Eis)) (R : ℝ) (γ : OuterTriple) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (ω : ℝ → ℂ) (Z N V : ℝ) (hZ : 0 < Z) (t : Frequency × (Fin 6 → ℝ)) : + secondLabelEnergy K labels (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z slots lists a ω (Z^N) t) γ = + Z^(max 0 N+V) * normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedPuncture m γ) slots lists a labels (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+V) := by + have he : secondLabelEnergy K labels (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z slots lists a ω (Z^N) t) γ = + columnEnergy p hp hcop hg pool (secondRayPlus Ψ z) (actualSecondInheritedPuncture m γ) + slots lists a labels (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (childLogTest ω ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) (Z^N) := by + unfold secondLabelEnergy columnEnergy + apply Finset.sum_congr rfl + intro f hf + simp only [secondLabelWeight,secondModeRight,secondCanonicalPolynomial] + apply congrArg (fun a : ℝ => ((idealDivisors f).card : ℝ)^(9+4*K)*a) + exact child_ball_sum_neg (β:=ℝ) R (fun k => ‖finiteCanonicalMarkedRow p hp hcop hg pool + (secondRayPlus Ψ z) (actualSecondInheritedPuncture m γ) (primaryGenerator f) k + slots lists a (childLogTest ω ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) (Z^N)‖^2) + rw [he] + exact initial_columnEnergy_clipping_normalized p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedPuncture m γ) slots lists a labels (nonzeroChildFrequencyBall 1 R) + (secondLabelWeight K) ω hZ N V _ + +omit [DecidableEq σ] in +theorem normalized_child_energy_radical_puncture + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) (D : Ideal Eis → ℝ) + (W : ℝ → ℂ) (X Z F : ℝ) : + normalizedColumnEnergy p hp hcop hg pool Ψ m slots lists a labels rows D W X Z F = + normalizedColumnEnergy p hp hcop hg pool Ψ + (ConcretePrimeRowBridge.idealGenerator (Ideal.span {m}).radical) + slots lists a labels rows D W X Z F := by + unfold normalizedColumnEnergy + apply Finset.sum_congr rfl + intro f hf + apply congrArg (fun x : ℝ => D f*x) + apply Finset.sum_congr rfl + intro k hk + rw [finiteCanonicalMarkedRow_radical_puncture p hp hcop hg pool Ψ m (primaryGenerator f) k slots lists a W X] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondOriginalBound.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondOriginalBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..45997a98554146665ff0c5bccdfdfb7de9fa67c7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondOriginalBound.lean @@ -0,0 +1,59 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeIntegral +import OAI.NumberTheory.DirichletL.Descent.SecondWholeMass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_mode_original_bound + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (pool : Finset ι) (Ψ : Eis →* ℂ) (hΨ : ∀ a,‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ J₁ J₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i∈J₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i∈J₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X R : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (labels : Finset (Ideal Eis)) + (hlabels : ∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) + (hrows : ∀ x∈source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (w : MarkedSecondSource ι Jo 0 → ℂ) (hw : ∀ x∈source,‖w x‖ ≤ 1) + (A : ℝ) (hA : 0 ≤ A) + (hleft : ∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ A) + (hright : ∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ A) : + ‖∑ x∈source,actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * w x * + secondModeBranch p hp hcop hg x u v pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t‖ ≤ A * ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ := by + have hlabels' : ∀ x∈source,(actualSecondChild p u v x).2.1 ∈ labels := by + intro x hx + rw [actualSecondChild_label_units] + exact hlabels x hx + have hΓ := assigned_second_triples_subset p u v source J₁ J₂ lists₁ lists₂ + apply (actual_second_mode_branch_energy p hp hcop hg hpr hinj hc u v source hs pool Ψ hΨ m z + slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ ha₁ ha₂ ω₁ ω₂ G E V B X R t labels + hlabels' hrows K ho hJ₁ hJ₂ w hw).trans + apply (second_geometric_energy_of_bound K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + _ _ _ A hA (fun γ hγ => hright γ (hΓ hγ)) (fun γ hγ => hleft γ (hΓ hγ))).trans + exact mul_le_mul_of_nonneg_left (assigned_second_mass_le_original p u v source J₁ J₂ lists₁ lists₂ K) hA + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondOriginalMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondOriginalMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..9238fe0404db25c81925cd8e6e382dfe26305c85 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondOriginalMass.lean @@ -0,0 +1,49 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondActualMass + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseInitialArithmetic (sourceIdeal) +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem actual_second_original_mass (K : ℕ) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {ι : Type} [DecidableEq ι] (p : ι → Eis) + (_hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) (u v : Eisˣ) + (Z ell R j t g theta eta : ℝ), 0 < Z → + (∀ x ∈ source, x.quotient ≠ 0) → + (∀ x ∈ source, x.second.divisor ⊆ x.second.sourceCommon) → + (∀ x ∈ source, ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x ∈ source, ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x ∈ source, primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(R+eta)) → + (∀ x ∈ source, Z^(j-eta) ≤ ‖eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x ∈ source, (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) → + (∀ x ∈ source, primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) → + (∀ x ∈ source, Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) → + (∑ γ ∈ actualSecondTriples p u v source,tripleDivisorWeight K γ) ≤ + C*Z^((ell+R/2-j+t+g-theta+11*eta/2)*(1+ε)) := by + obtain ⟨C,hC,hb⟩ := actual_second_normalized_mass K ε hε + refine ⟨C,hC,?_⟩ + intro ι _ p hp _ Jo Jn source u v Z ell R j t g theta eta hZ ht hE h1 h2 ha hJ hT hG hD + have hm := hb p hp source u v Z ell R j t g theta eta hZ ht hE h1 h2 ha hJ hT hG hD + let c := ell+R/2-j+t+g-theta+11*eta/2 + calc + _ = Z^c * (Z^(-c)*(∑ γ∈actualSecondTriples p u v source,tripleDivisorWeight K γ)) := by + rw [←mul_assoc,←Real.rpow_add hZ,add_neg_cancel,Real.rpow_zero,one_mul] + _ ≤ Z^c*(C*Z^(c*ε)) := mul_le_mul_of_nonneg_left hm (Real.rpow_pos_of_pos hZ _).le + _ = _ := by + rw [mul_left_comm,←Real.rpow_add hZ] + congr 2 + dsimp only [c] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..a8538cba68e2ac61449c0046f1ae149880ab9b99 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentAssembly.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceAttachment + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondFibers +open InverseInitialArithmetic (sourceIdeal) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + +omit [DecidableEq ι] in +@[simp] theorem secondParentOf_attach {Jo : ℕ} (parent : SecondParentSource ι Jo) + (x : SecondExpansionData ι) : secondParentOf (attachSecondExpansion parent x) = parent := rfl + +def attachedSecondFamily {Jo : ℕ} (parents : Finset (SecondParentSource ι Jo)) + (source : SecondParentSource ι Jo → Finset (SecondExpansionData ι)) : + Finset (MarkedSecondSource ι Jo 0) := + parents.biUnion (fun parent => (source parent).image (attachSecondExpansion parent)) + +omit [DecidableEq ι] in +theorem mem_attachedSecondFamily {Jo : ℕ} (parents : Finset (SecondParentSource ι Jo)) + (source : SecondParentSource ι Jo → Finset (SecondExpansionData ι)) + (x : MarkedSecondSource ι Jo 0) : + x∈attachedSecondFamily parents source ↔ + secondParentOf x∈parents ∧ x.second∈source (secondParentOf x) := by + simp only [attachedSecondFamily,Finset.mem_biUnion,Finset.mem_image] + constructor + · rintro ⟨parent,hp,y,hy,rfl⟩ + exact ⟨hp,hy⟩ + · rintro ⟨hp,hx⟩ + exact ⟨secondParentOf x,hp,x.second,hx,attachSecondExpansion_recover x⟩ + +omit [DecidableEq ι] in +theorem sum_attachedSecondFamily {Jo : ℕ} (parents : Finset (SecondParentSource ι Jo)) + (source : SecondParentSource ι Jo → Finset (SecondExpansionData ι)) + {A : Type*} [AddCommMonoid A] (H : MarkedSecondSource ι Jo 0 → A) : + ∑ x∈attachedSecondFamily parents source,H x = + ∑ parent∈parents,∑ x∈source parent,H (attachSecondExpansion parent x) := by + unfold attachedSecondFamily + rw [Finset.sum_biUnion] + · apply Finset.sum_congr rfl + intro parent hp + exact Finset.sum_image (fun x hx y hy he => attachSecondExpansion_injective parent he) + · intro a ha b hb hab + apply Finset.disjoint_left.mpr + intro x hx hy + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + obtain ⟨z,hz,he⟩ := Finset.mem_image.mp hy + exact hab (congrArg secondParentOf he).symm + +variable (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem attached_family_conditions {Jo : ℕ} (parents : Finset (SecondParentSource ι Jo)) + (source : SecondParentSource ι Jo → Finset (SecondExpansionData ι)) + (ha : ∀ parent∈parents,parent.cube.Admissible) + (hC : ∀ parent∈parents,Disjoint parent.firstCommon parent.cube.support) + (hD : ∀ parent∈parents,parent.firstDivisor ⊆ parent.firstCommon∪parent.cube.support) + (hE : ∀ parent∈parents,∀ x∈source parent,x.divisor ⊆ x.sourceCommon) + (hold : ∀ parent∈parents,∀ i,(parent.oldAssigned i).val ∣ + sourceIdeal p parent.cube.support*sourceIdeal p parent.firstCommon*parent.quotient) + (hq : ∀ parent∈parents,parent.quotient ≠ 0) : + ActualSecondSourceConditions p (attachedSecondFamily parents source) := by + have h (x : MarkedSecondSource ι Jo 0) (hx : x∈attachedSecondFamily parents source) := + (mem_attachedSecondFamily parents source x).mp hx + constructor + · intro x hx; exact ha (secondParentOf x) (h x hx).1 + · intro x hx; exact hC (secondParentOf x) (h x hx).1 + · intro x hx; exact hD (secondParentOf x) (h x hx).1 + · intro x hx; exact hE (secondParentOf x) (h x hx).1 x.second (h x hx).2 + · intro x hx i; exact hold (secondParentOf x) (h x hx).1 i + · intro x hx i; exact Fin.elim0 i + · intro x hx; exact hq (secondParentOf x) (h x hx).1 + +theorem secondExpansionSource_whole_parent_family + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (parents : Finset (SecondParentSource ι Jo)) + (source : SecondParentSource ι Jo → Finset (SecondExpansionData ι)) + (hE : ∀ parent∈parents,∀ x∈source parent,x.divisor ⊆ x.sourceCommon) + (w : SecondParentSource ι Jo → ℂ) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (X Y : ℝ) : + (∑ parent∈parents,w parent*secondExpansionSource p hp hcop hg pool Ψ + (secondParentPuncture p m parent) (secondParentLabel p parent) (secondParentDivisor p parent) + z (source parent) + (fun U => primeMark slots₁ lists₁ a₁ U*W₁ (primeProductNorm p U/X)) + (fun U => primeMark slots₂ lists₂ a₂ U*W₂ (primeProductNorm p U/X)) Φ Y) = + (Y : ℂ)*secondRayCoefficient z * + ∑ x∈attachedSecondFamily parents source, + (w (secondParentOf x)*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x)* + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y X := by + rw [sum_attachedSecondFamily] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro parent hparent + rw [secondExpansionSource_attached p hp hcop hg hinj hpr parent (source parent) (hE parent hparent)] + rw [Finset.sum_image (fun x hx y hy he => attachSecondExpansion_injective parent he)] + simp only [Finset.mul_sum,secondParentOf_attach] + apply Finset.sum_congr rfl + intro x hx + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentInput.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentInput.lean new file mode 100644 index 0000000000000000000000000000000000000000..f4889410e4457d92733ae1367c11c9510d6cb2b8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentInput.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceAttachment +import OAI.NumberTheory.DirichletL.Inversion.SecondPrincipalCaller + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondFibers RayFourExpansion +open InverseInitialArithmetic (sourceIdeal) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +omit [DecidableEq ι] in +theorem secondInputCoefficient_old_divisor_mask (Ψ : Eis →* ℂ) (m c d : Eis) + (H : Finset ι → ℂ) (S : Finset ι) : + secondInputCoefficient p hg Ψ (m*d) c d H S = secondInputCoefficient p hg Ψ m c d H S := by + rw [secondInputCoefficient_fixed_mask p hg Ψ m d c d H S] + have hd := row_power_mul_mask_power (fun i => Ideal.span {p i}) hg S d 1 1 (by decide) + simp only [pow_one] at hd + unfold secondInputCoefficient + calc + _ = Ψ (∏ i∈S,p i)*rowCoprimeMask (fun i => Ideal.span {p i}) S m* + finiteSquarefreeRow (fun i => Ideal.span {p i}) hg S c^4* + (finiteSquarefreeRow (fun i => Ideal.span {p i}) hg S d* + rowCoprimeMask (fun i => Ideal.span {p i}) S d)*H S := by ring + _ = _ := by rw [hd] + +theorem inputConjugateRow_old_divisor_mask (F : Finset ι) (Ψ : Eis →* ℂ) (m c d : Eis) + (H : Finset ι → ℂ) (k : Eis) : + inputConjugateRow p hg F Ψ (m*d) c d H k = inputConjugateRow p hg F Ψ m c d H k := by + simp only [inputConjugateRow,FirstCauchyArithmetic.supportConjugateSum,secondInputCoefficient_old_divisor_mask] + +theorem inputConjugateRow_puncture_span (F : Finset ι) (Ψ : Eis →* ℂ) (m₁ m₂ c d : Eis) + (hspan : Ideal.span {m₁} = (Ideal.span {m₂} : Ideal Eis)) (H : Finset ι → ℂ) (k : Eis) : + inputConjugateRow p hg F Ψ m₁ c d H k = inputConjugateRow p hg F Ψ m₂ c d H k := by + simp only [inputConjugateRow,FirstCauchyArithmetic.supportConjugateSum,secondInputCoefficient, + rowCoprimeMask_eq_of_span_eq (fun i => Ideal.span {p i}) _ hspan] + +theorem fresh_input_parent_mask {Jo : ℕ} (parent : SecondParentSource ι Jo) + (F D : Finset ι) (hq : parent.quotient = sourceIdeal p D) + (Ψ : Eis →* ℂ) (m : Eis) (H : Finset ι → ℂ) (k : Eis) : + inputConjugateRow p hg F Ψ + ((m*b0Label p parent.cube.support (fun i => parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit)*∏ i∈D,p i) + (secondParentLabel p parent) (secondParentDivisor p parent) H k = + inputConjugateRow p hg F Ψ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H k := by + rw [←inputConjugateRow_old_divisor_mask] + apply inputConjugateRow_puncture_span + let b := b0Label p parent.cube.support (fun i => parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit + let d := secondParentDivisor p parent + change Ideal.span {((m*b)*(∏ i∈D,p i))*d} = + (Ideal.span {(m*ConcretePrimeRowBridge.idealGenerator parent.quotient)*b*d} : Ideal Eis) + rw [show ((m*b)*(∏ i∈D,p i))*d = (m*b*d)*(∏ i∈D,p i) by ring, + show (m*ConcretePrimeRowBridge.idealGenerator parent.quotient)*b*d = + (m*b*d)*ConcretePrimeRowBridge.idealGenerator parent.quotient by ring] + simp only [←Ideal.span_singleton_mul_span_singleton, + ConcretePrimeRowBridge.span_idealGenerator,hq,sourceIdeal] + +theorem first_fresh_parent_truncated + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (parent : SecondParentSource ι Jo) (F D : Finset ι) + (hq : parent.quotient = sourceIdeal p D) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (H : Finset ι → ℂ) (ω : ℝ → ℂ) (X t Y : ℝ) (hY : 0 < Y) (core : FirstCoreIndex) + (K : Finset ι → Finset ι → Finset Eis) : + let Ψ₀ := firstCoreTwist negative χ Ψ core + let H₀ := firstCoreTest H (fun u => ω (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) negative (-t) D + firstFreshSecondPoisson p hp hg hinj F D parent.cube.support + (fun i => parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit negative χ Ψ m H ω X + (∏ i∈parent.firstCommon,p i) (secondParentDivisor p parent) core t Y = + truncatedSecondSource p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K + + secondSourceTail p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K := by + intro Ψ₀ H₀ + rw [firstFreshSecondPoisson_fixed_pool p hp hg hinj hc (hY:=hY)] + rw [←inputConjugateRow_smoothed_second_poisson p hg hp hinj hc _ _ _ _ _ _ _ _ hY] + change (∑' k : Eis,rowMajorant (‖ConcreteTraceCRT.eisEmbedding k‖^2/Y)* + (‖inputConjugateRow p hg F Ψ₀ + ((m*b0Label p parent.cube.support (fun i => parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit)*∏ i∈D,p i) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ k‖^2 : ℝ)) = _ + simp_rw [fresh_input_parent_mask p hg parent F D hq Ψ₀ m H₀] + exact inputConjugateRow_eq_truncated_add_tail p hp hg hinj hc F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y hY K + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentLists.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentLists.lean new file mode 100644 index 0000000000000000000000000000000000000000..8613b3428c2614f5c8ebe1b386e54b608fa88fc8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentLists.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondPuncture + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseInitialArithmetic (sourceIdeal) +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] + (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def actualSecondRawInheritedPuncture {Jo Jn : ℕ} (m : O) (x : MarkedSecondSource ι Jo Jn) : O := + ((m*ConcretePrimeRowBridge.idealGenerator x.quotient)*b0Label p x.cube.support + (fun i=>x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)* + secondExpansionQuotient p x.second + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem actual_parent_deleted_prime_killed {Jo Jn : ℕ} + (x : MarkedSecondSource ι Jo Jn) (_hb : x.cube.Admissible) + (hE : x.second.divisor⊆x.second.sourceCommon) (m : O) (i : ι) + (hi : i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal O)∣x.quotient) : + actualSecondRawInheritedPuncture p m x*actualSecondRawLabel p x∈Ideal.span {p i} := by + rcases hi with hi|hi + · have hv : ∀ j∈x.cube.support,0x.cube.leftExponent j+x.cube.rightExponent j) x.cube.leftBit x.cube.rightBit hv + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) i hi + simpa only [actualSecondRawInheritedPuncture,actualSecondRawLabel, + secondExpansionQuotient_of_subset p x.second hE] using hk + · have hq : ConcretePrimeRowBridge.idealGenerator x.quotient∈Ideal.span {p i} := by + apply (Ideal.dvd_iff_le.mp hi) + have hmem : ConcretePrimeRowBridge.idealGenerator x.quotient∈ + Ideal.span {ConcretePrimeRowBridge.idealGenerator x.quotient} := Ideal.subset_span (by simp) + simpa only [ConcretePrimeRowBridge.span_idealGenerator] using hmem + unfold actualSecondRawInheritedPuncture + exact Ideal.mul_mem_right _ _ (Ideal.mul_mem_right _ _ + (Ideal.mul_mem_right _ _ (Ideal.mul_mem_left _ _ hq))) + +theorem actual_second_parent_lists_restore {Jo Jn : ℕ} + (x : MarkedSecondSource ι Jo Jn) (hb : x.cube.Admissible) + (hE : x.second.divisor⊆x.second.sourceCommon) + (deleted : Finset ι) + (hdeleted : ∀ i∈deleted,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal O)∣x.quotient) + (pool : Finset ι) (Ψ : O→*ℂ) (m k : O) (slots : Finset σ) + (lists : σ→Finset ι) (a : σ→ι→ℂ) (W : ℝ→ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg pool Ψ + (actualSecondRawInheritedPuncture p m x) (actualSecondRawLabel p x) k + slots (fun j=>lists j\deleted) a W X = + finiteCanonicalMarkedRow p hp hcop hg pool Ψ + (actualSecondRawInheritedPuncture p m x) (actualSecondRawLabel p x) k + slots lists a W X := by + apply finiteCanonicalMarkedRow_restore_lists p hp hcop hg + exact fun i hi=>actual_parent_deleted_prime_killed p x hb hE m i (hdeleted i hi) + +theorem actual_second_parent_lists_restore_quotient {Jo Jn : ℕ} + (x : MarkedSecondSource ι Jo Jn) (hb : x.cube.Admissible) + (hE : x.second.divisor⊆x.second.sourceCommon) (D : Finset ι) + (hq : x.quotient=sourceIdeal p D) (deleted : Finset ι) + (hdeleted : deleted⊆(x.cube.support∪x.firstCommon)∪D) + (pool : Finset ι) (Ψ : O→*ℂ) (m k : O) (slots : Finset σ) + (lists : σ→Finset ι) (a : σ→ι→ℂ) (W : ℝ→ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg pool Ψ + (actualSecondRawInheritedPuncture p m x) (actualSecondRawLabel p x) k + slots (fun j=>lists j\deleted) a W X = + finiteCanonicalMarkedRow p hp hcop hg pool Ψ + (actualSecondRawInheritedPuncture p m x) (actualSecondRawLabel p x) k + slots lists a W X := by + apply actual_second_parent_lists_restore p hp hcop hg x hb hE deleted + intro i hi + rcases Finset.mem_union.mp (hdeleted hi) with hi|hi + · exact Or.inl hi + · right + rw [hq] + exact InverseInitialArithmetic.source_prime_dvd p D i hi + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentRadial.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentRadial.lean new file mode 100644 index 0000000000000000000000000000000000000000..261486529b77d99655c2b52d57a45c497b32b135 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondParentRadial.lean @@ -0,0 +1,67 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondFreshTruncation + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondFibers RayFourExpansion +open InverseInitialArithmetic (sourceIdeal) +open InversePrincipalEnergy InverseSecondPrincipalCaller +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem first_fresh_parent_radial_truncated + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (parent : SecondParentSource ι Jo) (F D : Finset ι) + (hq : parent.quotient = sourceIdeal p D) + (negative : Bool) (χ : RayCharacter) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ→Finset ι) (coeff : σ→ι→ℂ) + (hD : ∀ i∈slots,Disjoint (lists i) D) + (om : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0 parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit negative χ Ψ m (primeMark slots lists coeff) om X + (∏ i∈parent.firstCommon,p i) (secondParentDivisor p parent) core t Y = + truncatedSecondSource p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K + + secondSourceTail p hp hg hinj F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y K := by + intro Ψ₀ H₀ + let H := firstCoreTest (primeMark slots lists coeff) (fun u=>om (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) negative (-t) D + let m₀ := (m*b0Label p parent.cube.support + (fun i=>parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit)*∏ i∈D,p i + have he (k : Eis) : inputConjugateRow p hg F Ψ₀ m₀ + (secondParentLabel p parent) (secondParentDivisor p parent) H k = + inputConjugateRow p hg F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ k := by + calc + _ = inputConjugateRow p hg F Ψ₀ m₀ (secondParentLabel p parent) + (secondParentDivisor p parent) H₀ k := by + unfold inputConjugateRow FirstCauchyArithmetic.supportConjugateSum + apply Finset.sum_congr rfl + intro U hU + rw [firstCoreTest_coefficient p hp hg hinj slots lists coeff D U hD om a b ha hs negative X t hX] + _ = _ := fresh_input_parent_mask p hg parent F D hq Ψ₀ m H₀ k + rw [firstFreshSecondPoisson_fixed_pool p hp hg hinj hc (hY:=hY)] + rw [←inputConjugateRow_smoothed_second_poisson p hg hp hinj hc _ _ _ _ _ _ _ _ hY] + change (∑' k : Eis,rowMajorant (‖ConcreteTraceCRT.eisEmbedding k‖^2/Y)* + (‖inputConjugateRow p hg F Ψ₀ m₀ (secondParentLabel p parent) + (secondParentDivisor p parent) H k‖^2 : ℝ)) = _ + simp_rw [he] + exact inputConjugateRow_eq_truncated_add_tail p hp hg hinj hc F Ψ₀ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) H₀ rowMajorant Y hY K + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondPass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPass.lean new file mode 100644 index 0000000000000000000000000000000000000000..323d039187244115a9136d7bd1dd7696649768cd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPass.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Descent.Canonical +import OAI.NumberTheory.DirichletL.Descent.SecondEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +omit [DecidableEq σ] in +theorem marked_input_smoothed_second_poisson + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (F A : Finset ι) (Ψ : Eis →* ℂ) (m c d : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (H : Finset ι → ℂ) (W : 𝓢(ℝ, ℂ)) (Y : ℝ) (hY : 0 < Y) : + (∑' z : Eis, W (‖eisEmbedding z‖ ^ 2 / Y) * + (‖inputConjugateRow p hg F Ψ m c d + (fun U => H U * primeMark slots lists a (A ∪ U)) z‖ ^ 2 : ℝ)) = + ∑ G ∈ F.powerset, ∑ U ∈ (F \ G).powerset, ∑ V ∈ (F \ G).powerset, + if Disjoint U V then overlapPairWeight p hg Ψ m c d + (fun U => H U * primeMark slots lists a (A ∪ U)) G U V * + maskedSecondDual p hg hp hinj G U V W Y else 0 := + inputConjugateRow_smoothed_second_poisson p hg hp hinj hc F Ψ m c d _ W Y hY + +def canonicalMarkedSplit (F V A : Finset ι) (Ψ : Eis →* ℂ) (m r c d e k : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : ℂ := + ∑ J ∈ slots.powerset, primeMark J lists a (A ∪ V) * + finiteCanonicalMarkedRow p hp hcop hg F Ψ (m * r) + (c * e * ∏ i ∈ V, p i) (d * e * k) + (slots \ J) (fun i => lists i \ A) a W (X / primeProductNorm p V) + +theorem secondActualPair_marked_children + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda ^ 2 ∣ p i - 1) + (F A₁ A₂ : Finset ι) (Ψ₁ Ψ₂ : Eis →* ℂ) (m r c d e k : Eis) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) + (a₁ a₂ : σ → ι → ℂ) (W₁ W₂ : ℝ → ℂ) (X₁ X₂ : ℝ) : + secondActualPair p hp hg hinj F Ψ₁ Ψ₂ m r c d e k + (fun U => primeMark slots₁ lists₁ a₁ (A₁ ∪ U) * W₁ (primeProductNorm p U / X₁)) + (fun U => primeMark slots₂ lists₂ a₂ (A₂ ∪ U) * W₂ (primeProductNorm p U / X₂)) = + ∑ z : SecondRayIndex, ∑ V ∈ F.powerset, + secondTotalWeight p hp hcop hg Ψ₁ Ψ₂ m r c d e k (z, V) * + star (canonicalMarkedSplit p hp hcop hg F V A₁ (secondRayMinus Ψ₁ z) + m r c d e k slots₁ lists₁ a₁ W₁ X₁) * + canonicalMarkedSplit p hp hcop hg F V A₂ (secondRayPlus Ψ₂ z) + m r c d e (-k) slots₂ lists₂ a₂ W₂ X₂ := by + rw [secondActualPair_eq_children p hp hcop hg hinj hc hpr] + simp only [secondChildSum_marked_fixed_pool, canonicalMarkedSplit] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..831836ce9bef8e84bc7bf53c95c18bcd6feba8a3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalEnergy.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondAllIntegral +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedPhysical +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondPhysicalEnergyUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_balanced_physical_energy + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (G E V B X Y R L : ℝ) + (U : Fin 6 → ℝ → ℂ) (density : Frequency × (Fin 6 → ℝ) → ℂ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (K J : ℕ) (A : ℝ), + 0 < G → 0 < E → 0 < V → 0 < B → 0 < X → Integrable density → + (∀ y : Fin 6 → ℝ,(Real.exp (-6*L):ℂ)*secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ U + (Y*B/(E*V^2*X^2)) y = ∫ t : Frequency × (Fin 6 → ℝ),density t* + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₁ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₁ (primeProductNorm p N/X) = 1) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₂ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₂ (primeProductNorm p N/X) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/X) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X) ≠ 0 → ∀ i, + U i (secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B X i) = 1) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Integrable (fun t : Frequency × (Fin 6 → ℝ) => + tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeLeft p hp hcop hg pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ X t) γ ≤ + A*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + secondLabelEnergy K (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) + (secondModeRight p hp hcop hg pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ X t) γ ≤ + A*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G*V*X))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*X : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*A* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) := by + obtain ⟨sector,hsector⟩ := actual_second_balanced_profile_children p hp hcop hg hpr (σ:=σ) source hs + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B X Y R L + U density w labels K J A hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hWeighted hleft hright + have he := hsector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B X Y R L + U density w hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + have hb := actual_second_all_modes_integral p hp hcop hg hpr hinj hc source hs sector pool Ψ hΨ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ha₁ ha₂ ω₁ ω₂ G E V B X R labels hlabels hrows + K ho hslots₁ hslots₂ w hw A hA J density hWeighted hleft hright + have hi : (∫ t : Frequency × (Fin 6 → ℝ),density t * + ∑ uv : Eisˣ × Eisˣ,∑ x∈secondSourceSector source sector uv, + (w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x)* + ∑ J₁∈slots₁.powerset,∑ J₂∈slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ lists₁ lists₂ a₁ a₂ + ω₁ ω₂ G E V B X t) = + ∫ t : Frequency × (Fin 6 → ℝ),density t*secondFullModeSum p hp hcop hg source sector pool Ψ m z + slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X w t := by + apply integral_congr_ae + filter_upwards with t + rw [secondFullModeSum_physical] + rw [hi] at he + have hexp : Real.exp (6*L)*Real.exp (-6*L) = 1 := by + rw [←Real.exp_add] + ring_nf + exact Real.exp_zero + have hn := congrArg norm he + conv_lhs at hn => rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_pos (Real.exp_pos _)] + conv_rhs at hn => rw [norm_mul] + have hn' := congrArg (fun a : ℝ => Real.exp (6*L)*a) hn + rw [←mul_assoc,hexp,one_mul] at hn' + rw [←mul_assoc] at hn' + rw [hn'] + exact mul_le_mul_of_nonneg_left hb (by positivity) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalRecursive.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalRecursive.lean new file mode 100644 index 0000000000000000000000000000000000000000..543b22464bad1c77d1c9c6a294f6784cdbfe7417 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalRecursive.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondPhysicalEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondNormalizedEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondBalancedSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap InverseInitialClippedColumns +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondPhysicalRecursiveUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_balanced_physical_recursive + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (G E V B Y R L Z N Vlabel εchild : ℝ) + (U : Fin 6 → ℝ → ℂ) (density : Frequency × (Fin 6 → ℝ) → ℂ) + (w : MarkedSecondSource ι Jo 0 → ℂ) + (labels : Finset (Ideal Eis)) (K J : ℕ) (A : ℝ), + 0 < Z → 0 < G → 0 < E → 0 < V → 0 < B → 0 < (Z^N) → Integrable density → + (∀ y : Fin 6 → ℝ,(Real.exp (-6*L):ℂ)*secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ U + (Y*B/(E*V^2*(Z^N)^2)) y = ∫ t : Frequency × (Fin 6 → ℝ),density t* + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + W₁ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₁ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ x ∈ source,∀ Q ∈ (pool\x.second.overlap).powerset, + W₂ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p Q/(G*V*(Z^N))) ≠ 0 → ω₂ (primeProductNorm p Q/(Z^N)) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/(Z^N)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/(Z^N)) ≠ 0 → ∀ i, + U i (secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B (Z^N) i) = 1) → + (∀ a,‖Ψ a‖ ≤ 1) → (∀ x∈source,‖w x‖ ≤ 1) → + (∀ i∈slots₁,∀ q∈lists₁ i,‖a₁ i q‖ ≤ 1) → + (∀ i∈slots₂,∀ q∈lists₂ i,‖a₂ i q‖ ≤ 1) → + (∀ x∈source,(actualSecondChild p 1 1 x).2.1 ∈ labels) → + Jo ≤ 2*K → slots₁.card ≤ K → slots₂.card ≤ K → 0 ≤ A → + Integrable (fun t : Frequency × (Fin 6 → ℝ) => + tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈slots₁.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₁\J₁) lists₁ a₁ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 N-N)) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈slots₂.powerset,∀ γ∈actualSecondTriples p 1 1 source, + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedRadicalPuncture m γ) (slots₂\J₂) lists₂ a₂ + (labels.filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 N-N)) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 N)) Z (max 0 N+Vlabel) ≤ + A*Z^(max 0 N+Vlabel+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + ‖(Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y (G*V*(Z^N)))‖ ≤ + (Real.exp (6*L)*‖(Y : ℂ)*secondRayCoefficient z*((E*V*(Z^N) : ℝ):ℂ)⁻¹‖)* + ((36*(2:ℝ)^slots₁.card*(2:ℝ)^slots₂.card*(A*Z^(2*(max 0 N+Vlabel)+εchild))* + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ)* + ∫ t : Frequency × (Fin 6 → ℝ),tripleHeight J t.1*coordinateHeight J t.2*‖density t‖) := by + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B Y R L Z N Vlabel εchild + U density w labels K J A hZ hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + hΨ hw ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hWeighted hleft hright + have he (H : ℝ) : Z^(max 0 N+Vlabel)*(A*Z^(max 0 N+Vlabel+εchild)*H) = + (A*Z^(2*(max 0 N+Vlabel)+εchild))*H := by + calc + _ = A*(Z^(max 0 N+Vlabel)*Z^(max 0 N+Vlabel+εchild))*H := by ring + _ = _ := by rw [←Real.rpow_add hZ]; congr 2; ring_nf + apply actual_second_balanced_physical_energy p hp hcop hg hpr hinj hc source hs + pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B (Z^N) Y R L + U density w labels K J (A*Z^(2*(max 0 N+Vlabel)+εchild)) + hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut hΨ hw ha₁ ha₂ hlabels + ho hslots₁ hslots₂ (mul_nonneg hA (Real.rpow_pos_of_pos hZ _).le) hWeighted + · intro t J₁ hJ₁ γ hγ + rw [second_left_normalized_energy p hp hcop hg K (labels.filter Squarefree) + (nonzeroChildFrequencyBall 1 R) γ pool Ψ m z (slots₁\J₁) lists₁ a₁ ω₁ Z N Vlabel hZ t] + rw [normalized_child_energy_radical_puncture p hp hcop hg pool (secondRayMinus Ψ z) + (actualSecondInheritedPuncture m γ)] + exact (mul_le_mul_of_nonneg_left (hleft t J₁ hJ₁ γ hγ) (Real.rpow_pos_of_pos hZ _).le).trans_eq (he _) + · intro t J₂ hJ₂ γ hγ + rw [second_right_normalized_energy p hp hcop hg K (labels.filter Squarefree) + R γ pool Ψ m z (slots₂\J₂) lists₂ a₂ ω₂ Z N Vlabel hZ t] + rw [normalized_child_energy_radical_puncture p hp hcop hg pool (secondRayPlus Ψ z) + (actualSecondInheritedPuncture m γ)] + exact (mul_le_mul_of_nonneg_left (hright t J₂ hJ₂ γ hγ) (Real.rpow_pos_of_pos hZ _).le).trans_eq (he _) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalRows.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..7a3a07e0fe5a48908ab2a7af206cb05dedc7e9de --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPhysicalRows.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSupportedEnergy +import OAI.NumberTheory.DirichletL.Descent.ChildCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseInitialArithmetic (sourceIdeal sourceIdeal_gen) +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) + (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + +def actualSecondMultiplier {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) : Eis := + primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor * + primeSubsetGenerator (fun i => Ideal.span {p i}) x.second.divisor + +omit [DecidableEq ι] in +theorem actualSecondMultiplier_ne_zero {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) : + actualSecondMultiplier p x ≠ 0 := by + apply mul_ne_zero + · exact primeSubsetGenerator_ne_zero _ _ + · exact primeSubsetGenerator_ne_zero _ _ + +include hp in + +theorem actual_second_row_norm_sq + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) : + ‖eisEmbedding (actualSecondChild p u v x).2.2‖^2 = + ‖eisEmbedding (actualSecondMultiplier p x*x.second.frequency)‖^2 := by + change ‖eisEmbedding (primaryGenerator (sourceIdeal p x.firstDivisor)* + primaryGenerator (sourceIdeal p x.second.divisor)*secondUnitFrequency u v x.second.frequency)‖^2 = _ + rw [sourceIdeal_gen p hp hpr,sourceIdeal_gen p hp hpr] + simp only [map_mul,norm_mul,mul_pow,secondUnitFrequency_norm,actualSecondMultiplier, + primeSubsetGenerator_norm_eq_productNorm,primeProductNorm] + +include hp in + +theorem actual_second_row_ball + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) (R : ℝ) : + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R ↔ + (actualSecondChild p u v x).2.2 ∈ nonzeroChildFrequencyBall 1 R := by + rw [mem_nonzeroChildFrequencyBall _ (actualSecondMultiplier_ne_zero p x), + mem_nonzeroChildFrequencyBall _ one_ne_zero,one_mul,actual_second_row_norm_sq p hp hpr] + +omit [DecidableEq ι] in +theorem actual_second_row_radius_one + {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) (R : ℝ) + (hsource : source.Nonempty) + (hrows : ∀ x ∈ source, + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) : 1 ≤ R := by + obtain ⟨x,hx⟩ := hsource + by_contra hR + have he := nonzeroChildFrequencyBall_empty _ (actualSecondMultiplier_ne_zero p x) R (lt_of_not_ge hR) + simpa [he] using hrows x hx + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondProfileIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondProfileIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..34ebdf437a3b2c2fa0c9ca57019cca3ddc8db582 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondProfileIdentity.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Descent.FullProfile +import OAI.NumberTheory.DirichletL.Descent.Canonical + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open EisensteinSchwartzPoisson +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def secondNormProfile (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 6 → ℝ → ℂ) (R : ℝ) (q : Fin 6 → ℝ) : ℂ := + (∏ i, V i (Real.log (q i))) * W₁ (q 0*q 2*q 4) * W₂ (q 0*q 2*q 5) * + paperRadialFourier Φ (R*q 3/(q 1*(q 2)^2*q 4*q 5)) / + ((q 1:ℂ)*(q 2:ℂ)*(Real.sqrt (q 4):ℂ)*(Real.sqrt (q 5):ℂ)) + +lemma secondPoissonProfile_log (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (V : Fin 6 → ℝ → ℂ) (R : ℝ) (q : Fin 6 → ℝ) (hq : ∀ i, 0 < q i) : + secondPoissonProfile W₁ W₂ Φ V R (fun i => Real.log (q i)) = + secondNormProfile W₁ W₂ Φ V R q := by + have hleft : (∑ i, secondLeftSlope i * Real.log (q i)) = + Real.log (q 0)+Real.log (q 2)+Real.log (q 4) := by + simp [Fin.sum_univ_succ,secondLeftSlope]; ring + have hright : (∑ i, secondRightSlope i * Real.log (q i)) = + Real.log (q 0)+Real.log (q 2)+Real.log (q 5) := by + simp [Fin.sum_univ_succ,secondRightSlope]; ring + have hker : (∑ i, secondKernelSlope i * Real.log (q i)) = + Real.log (q 3) - (Real.log (q 1)+Real.log (q 2)+Real.log (q 2)+Real.log (q 4)+Real.log (q 5)) := by + simp [Fin.sum_univ_succ,secondKernelSlope]; ring + unfold secondPoissonProfile secondNormProfile + rw [hleft,hright,hker] + simp only [Real.exp_add,Real.exp_sub,Real.exp_log (hq _)] + have hk : R * (q 3/(q 1*q 2*q 2*q 4*q 5)) = R*q 3/(q 1*(q 2)^2*q 4*q 5) := by ring + rw [hk] + simp only [Fin.prod_univ_succ,secondRootWindows,inverseNormWindow,inverseRootWindow, + Matrix.cons_val_zero,Matrix.cons_val_succ,Fin.isValue,Real.exp_log (hq _),Fin.prod_univ_zero,mul_one] + simp only [Fin.succ, Fin.val_mk] + norm_num + ring + +theorem secondSourcePairKernel_profile {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) + (G V N M : Finset ι) (hVN : Disjoint V N) (hVM : Disjoint V M) + (e k : Eis) (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y : ℝ) : + (‖eisEmbedding e‖^2 : ℂ)⁻¹ * secondSourcePairKernel p e k + (fun U => W₁ (primeProductNorm p G * primeProductNorm p U)) + (fun U => W₂ (primeProductNorm p G * primeProductNorm p U)) Φ Y (V ∪ N) (V ∪ M) = + secondNormProfile (fun x => star (W₁ x)) W₂ Φ (fun _ _ => 1) Y + ![primeProductNorm p G, ‖eisEmbedding e‖^2, primeProductNorm p V, + ‖eisEmbedding k‖^2, primeProductNorm p N, primeProductNorm p M] := by + have hs (S : Finset ι) : ‖eisEmbedding (∏ i ∈ S, p i)‖ = Real.sqrt (primeProductNorm p S) := by + simp only [primeProductNorm, Real.sqrt_sq_eq_abs, abs_of_nonneg (norm_nonneg _)] + have hV : 0 ≤ primeProductNorm p V := (primeProductNorm_pos p hp V).le + have hroots : Real.sqrt (primeProductNorm p V*primeProductNorm p N) * + Real.sqrt (primeProductNorm p V*primeProductNorm p M) = + primeProductNorm p V * Real.sqrt (primeProductNorm p N) * Real.sqrt (primeProductNorm p M) := by + rw [Real.sqrt_mul hV, Real.sqrt_mul hV] + calc + _ = (Real.sqrt (primeProductNorm p V))^2 * Real.sqrt (primeProductNorm p N) * Real.sqrt (primeProductNorm p M) := by ring + _ = _ := by rw [Real.sq_sqrt hV] + unfold secondSourcePairKernel secondNormProfile + simp only [hs,primeProductNorm_union p V N hVN,primeProductNorm_union p V M hVM, + Matrix.cons_val_zero, Fin.isValue, Finset.prod_const_one, one_mul] + have harg : Y * ‖eisEmbedding k‖^2 / + (‖eisEmbedding e‖^2 * (primeProductNorm p V*primeProductNorm p N * + (primeProductNorm p V*primeProductNorm p M))) = + Y * ‖eisEmbedding k‖^2 / (‖eisEmbedding e‖^2 * (primeProductNorm p V)^2 * + primeProductNorm p N * primeProductNorm p M) := by ring + rw [harg] + rw [← Complex.ofReal_mul, hroots] + push_cast + ring_nf + +theorem secondNormProfile_nominal (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) + (G₀ E₀ V₀ K₀ X₀ Y : ℝ) + (_hG : 0 < G₀) (hE : 0 < E₀) (hV : 0 < V₀) (hK : 0 < K₀) (hX : 0 < X₀) + (q : Fin 6 → ℝ) (hq : ∀ i, 0 < q i) : + secondNormProfile (fun x => W₁ (x/(G₀*V₀*X₀))) + (fun x => W₂ (x/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y q = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + secondNormProfile W₁ W₂ Φ (fun _ _ => 1) + (Y*K₀/(E₀*V₀^2*X₀^2)) + ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] := by + have hleft : (q 0/G₀)*(q 2/V₀)*(q 4/X₀) = q 0*q 2*q 4/(G₀*V₀*X₀) := by ring + have hright : (q 0/G₀)*(q 2/V₀)*(q 5/X₀) = q 0*q 2*q 5/(G₀*V₀*X₀) := by ring + have harg : (Y*K₀/(E₀*V₀^2*X₀^2))*(q 3/K₀)/ + ((q 1/E₀)*(q 2/V₀)^2*(q 4/X₀)*(q 5/X₀)) = + Y*q 3/(q 1*(q 2)^2*q 4*q 5) := by + field_simp + have hroot : Real.sqrt (q 4/X₀)*Real.sqrt (q 5/X₀) = + Real.sqrt (q 4)*Real.sqrt (q 5)/X₀ := by + rw [Real.sqrt_div (hq 4).le,Real.sqrt_div (hq 5).le] + rw [div_mul_div_comm, ← pow_two, Real.sq_sqrt hX.le] + have hc0 : ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] (0:Fin 6) = q 0/G₀ := rfl + have hc1 : ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] (1:Fin 6) = q 1/E₀ := rfl + have hc2 : ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] (2:Fin 6) = q 2/V₀ := rfl + have hc3 : ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] (3:Fin 6) = q 3/K₀ := rfl + have hc4 : ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] (4:Fin 6) = q 4/X₀ := rfl + have hc5 : ![q 0/G₀,q 1/E₀,q 2/V₀,q 3/K₀,q 4/X₀,q 5/X₀] (5:Fin 6) = q 5/X₀ := rfl + unfold secondNormProfile + simp only [Finset.prod_const_one,one_mul,hc0,hc1,hc2,hc3,hc4,hc5] + rw [hleft,hright,harg] + have hrootC : (Real.sqrt (q 4/X₀):ℂ)*(Real.sqrt (q 5/X₀):ℂ) = + (Real.sqrt (q 4):ℂ)*(Real.sqrt (q 5):ℂ)/(X₀:ℂ) := by exact_mod_cast hroot + rw [show (↑(q 1/E₀):ℂ)*↑(q 2/V₀)*↑(Real.sqrt (q 4/X₀))*↑(Real.sqrt (q 5/X₀)) = + (↑(q 1/E₀):ℂ)*↑(q 2/V₀)*(↑(Real.sqrt (q 4/X₀))*↑(Real.sqrt (q 5/X₀))) from by ring, + hrootC] + have hEc : (E₀:ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hE.ne' + have hVc : (V₀:ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hV.ne' + have hXc : (X₀:ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hX.ne' + push_cast + field_simp [hEc,hVc,hXc] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondPuncture.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPuncture.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ca8e5942a1b56b0d2d07834b0943d7d6c1d3d31 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPuncture.lean @@ -0,0 +1,170 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSquarefree + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseInitialArithmetic (sourceIdeal sourceIdeal_gen sourceIdeal_ne_zero) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +omit [DecidableEq ι] in +theorem rowCoprimeMask_radical_generator (S : Finset ι) (a : Eis) : + rowCoprimeMask (fun i => Ideal.span {p i}) S a = + rowCoprimeMask (fun i => Ideal.span {p i}) S + (ConcretePrimeRowBridge.idealGenerator (Ideal.span {a}).radical) := by + have he (i : ι) : a ∈ Ideal.span {p i} ↔ + ConcretePrimeRowBridge.idealGenerator (Ideal.span {a}).radical ∈ Ideal.span {p i} := by + rw [←Ideal.span_singleton_le_iff_mem,←Ideal.span_singleton_le_iff_mem, + ConcretePrimeRowBridge.span_idealGenerator] + exact (inferInstance : (Ideal.span {p i}).IsPrime).radical_le_iff.symm + simp only [rowCoprimeMask,he] + +omit [DecidableEq σ] in +theorem finiteCanonicalMarkedRow_radical_puncture (F : Finset ι) (Ψ : Eis →* ℂ) + (m f k : Eis) (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (X : ℝ) : + finiteCanonicalMarkedRow p hp hcop hg F Ψ m f k slots lists a W X = + finiteCanonicalMarkedRow p hp hcop hg F Ψ + (ConcretePrimeRowBridge.idealGenerator (Ideal.span {m}).radical) f k slots lists a W X := by + simp only [finiteCanonicalMarkedRow,fixedChildRow,secondChildColumn, + ←rowCoprimeMask_radical_generator p] + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem sourceIdeal_le_radical_primeProduct (B : Finset ι) (v : ι → ℕ) : + sourceIdeal p B ≤ (Ideal.span {primeProduct p B v} : Ideal Eis).radical := by + simp only [sourceIdeal,primeProduct,FiniteGaussPhase.span_finset_prod,←Ideal.span_singleton_pow] + induction B using Finset.induction_on with + | empty => simp + | @insert i B hi ih => + rw [Finset.prod_insert hi,Finset.prod_insert hi,Ideal.radical_mul] + apply le_inf + · apply Ideal.mul_le_left.trans + by_cases hv : v i = 0 + · rw [hv,pow_zero,Ideal.one_eq_top] + exact le_trans le_top Ideal.le_radical + · rw [Ideal.radical_pow _ hv] + exact Ideal.le_radical + · exact Ideal.mul_le_right.trans ih + +theorem actual_second_q0_radical_norm (hp : ∀ i, p i ≠ 0) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) : + (Ideal.absNorm (actualSecondChild p u v x).1.q0.radical : ℝ) ≤ + primeProductNorm p x.cube.support := by + have hd := Ideal.absNorm_dvd_absNorm_of_le (sourceIdeal_le_radical_primeProduct p x.cube.support + (fun i => b0Exponent (x.cube.leftExponent i+x.cube.rightExponent i) (x.cube.leftBit i) (x.cube.rightBit i))) + have hb := Nat.le_of_dvd (Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (sourceIdeal_ne_zero p hp x.cube.support))) hd + change (Ideal.absNorm (Ideal.span {b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}).radical : ℝ) ≤ _ + have he : (Ideal.absNorm (sourceIdeal p x.cube.support) : ℝ) = primeProductNorm p x.cube.support := by + simpa only [sourceIdeal,primeProductNorm,map_prod] using + (eisEmbedding_norm_sq_eq_absNorm_span (∏ i ∈ x.cube.support,p i)).symm + rw [←he] + exact_mod_cast hb + +def actualSecondRadicalPuncture (m : Eis) (γ : InverseSecondFibers.OuterTriple) : Eis := + ConcretePrimeRowBridge.idealGenerator (Ideal.span {actualSecondPuncture m γ}).radical + +theorem secondCanonicalPolynomial_radical_puncture + (F : Finset ι) (Ψ : InverseSecondFibers.OuterTriple → Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : InverseSecondFibers.OuterTriple → ℝ → ℂ) (X : ℝ) (c : SecondChild) : + secondCanonicalPolynomial p hp hcop hg F Ψ (actualSecondPuncture m) slots lists a W X c = + secondCanonicalPolynomial p hp hcop hg F Ψ (actualSecondRadicalPuncture m) slots lists a W X c := + finiteCanonicalMarkedRow_radical_puncture p hp hcop hg F (Ψ c.1) _ _ _ slots lists a (W c.1) X + +theorem radical_product_norm_le (I J B R : Ideal Eis) (hI : I ≠ 0) (hB : B ≠ 0) + (hR : R ≠ 0) (hBJ : B ≤ J.radical) : + (Ideal.absNorm (I*J*R).radical : ℝ) ≤ + (Ideal.absNorm I.radical : ℝ)*Ideal.absNorm B*Ideal.absNorm R := by + have hi : I.radical ≠ 0 := by + intro he + apply hI + exact le_antisymm (he ▸ Ideal.le_radical) bot_le + have hle : I.radical*B*R ≤ (I*J*R).radical := by + rw [Ideal.radical_mul,Ideal.radical_mul] + refine le_inf (le_inf ?_ ?_) ?_ + · exact Ideal.mul_le_left.trans Ideal.mul_le_left + · exact (Ideal.mul_le_left.trans Ideal.mul_le_right).trans hBJ + · exact Ideal.mul_le_right.trans Ideal.le_radical + have hb := Nat.le_of_dvd (Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (mul_ne_zero (mul_ne_zero hi hB) hR))) (Ideal.absNorm_dvd_absNorm_of_le hle) + simpa only [map_mul,Nat.cast_mul] using (show (Ideal.absNorm (I*J*R).radical : ℝ) ≤ + Ideal.absNorm (I.radical*B*R) from by exact_mod_cast hb) + +include hp in + +theorem actual_second_radical_puncture_norm + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) : + ‖ConcreteTraceCRT.eisEmbedding (actualSecondRadicalPuncture m (actualSecondChild p u v x).1)‖^2 ≤ + (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) * + primeProductNorm p x.cube.support * primeProductNorm p (x.second.sourceCommon\x.second.divisor) := by + have hspan : Ideal.span {actualSecondPuncture m (actualSecondChild p u v x).1} = + (Ideal.span {m} : Ideal Eis) * + Ideal.span {b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit} * sourceIdeal p (x.second.sourceCommon\x.second.divisor) := by + rw [←actual_second_puncture_span p hp hpr x hE u v m] + simp only [←Ideal.span_singleton_mul_span_singleton,secondExpansionQuotient_of_subset p x.second hE, + secondMaskQuotient_span,sourceIdeal,FiniteGaussPhase.span_finset_prod] + rw [eisEmbedding_norm_sq_eq_absNorm_span] + simp only [actualSecondRadicalPuncture,ConcretePrimeRowBridge.span_idealGenerator,hspan] + have hn (S : Finset ι) : (Ideal.absNorm (sourceIdeal p S) : ℝ)=primeProductNorm p S := by + simpa only [sourceIdeal,primeProductNorm,map_prod] using + (eisEmbedding_norm_sq_eq_absNorm_span (∏ i ∈ S,p i)).symm + rw [←hn x.cube.support,←hn (x.second.sourceCommon\x.second.divisor)] + exact radical_product_norm_le _ _ _ _ (Ideal.span_singleton_eq_bot.not.mpr hm) + (sourceIdeal_ne_zero p hp _) (sourceIdeal_ne_zero p hp _) + (sourceIdeal_le_radical_primeProduct p _ _) + +def actualSecondInheritedPuncture (m : Eis) (γ : InverseSecondFibers.OuterTriple) : Eis := + actualSecondPuncture (m*ConcretePrimeRowBridge.idealGenerator γ.quotient) γ + +def actualSecondInheritedRadicalPuncture (m : Eis) (γ : InverseSecondFibers.OuterTriple) : Eis := + actualSecondRadicalPuncture (m*ConcretePrimeRowBridge.idealGenerator γ.quotient) γ + +include hp in + +theorem actual_second_inherited_puncture_norm + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) : + ‖ConcreteTraceCRT.eisEmbedding (actualSecondInheritedRadicalPuncture m (actualSecondChild p u v x).1)‖^2 ≤ + (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) * Ideal.absNorm x.quotient * + primeProductNorm p x.cube.support * primeProductNorm p (x.second.sourceCommon\x.second.divisor) := by + have hm' := mul_ne_zero hm (ConcretePrimeRowBridge.idealGenerator_ne_zero x.quotient ht) + have hb := actual_second_radical_puncture_norm p hp hpr x hE u v + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) hm' + change ‖ConcreteTraceCRT.eisEmbedding (actualSecondRadicalPuncture + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) (actualSecondChild p u v x).1)‖^2 ≤ _ + apply hb.trans + have ho : (Ideal.absNorm (Ideal.span {m*ConcretePrimeRowBridge.idealGenerator x.quotient}).radical : ℝ) ≤ + (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ)*Ideal.absNorm x.quotient := by + rw [←Ideal.span_singleton_mul_span_singleton,ConcretePrimeRowBridge.span_idealGenerator] + simpa only [mul_one,map_one,Nat.cast_one] using radical_product_norm_le (Ideal.span {m}) 1 1 x.quotient + (Ideal.span_singleton_eq_bot.not.mpr hm) one_ne_zero ht Ideal.le_radical + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right ho (primeProductNorm_pos p hp _).le) (primeProductNorm_pos p hp _).le + +include hp in + +theorem actualSecondTriples_q0_radical_bound + {Jo Jn : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo Jn)) (B : ℝ) + (hB : ∀ x ∈ source, primeProductNorm p x.cube.support ≤ B) : + ∀ γ ∈ actualSecondTriples p u v source, (Ideal.absNorm γ.q0.radical : ℝ) ≤ B := by + intro γ hγ + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hγ + exact (actual_second_q0_radical_norm p hp x u v).trans (hB x hx) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondPunctureBudget.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPunctureBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..e630be5b83314737c89bec04adc4805c74127b23 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondPunctureBudget.lean @@ -0,0 +1,66 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondPuncture + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) (hp : ∀ i, p i ≠ 0) + [∀ i, (Ideal.span {p i}).IsMaximal] + +include hp in +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem second_residual_norm_eq_div (E G : Finset ι) (hE : E ⊆ G) : + primeProductNorm p (G\E) = primeProductNorm p G/primeProductNorm p E := by + have he : primeProductNorm p G = primeProductNorm p E*primeProductNorm p (G\E) := by + rw [←primeProductNorm_union p E (G\E) Finset.disjoint_sdiff,Finset.union_sdiff_of_subset hE] + rw [he] + field_simp [(primeProductNorm_pos p hp E).ne'] + +include hp in + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem second_residual_norm_power_bound (E G : Finset ι) (hE : E ⊆ G) + (Z g theta eta : ℝ) (hZ : 0 < Z) + (hg : primeProductNorm p G ≤ Z^(g+eta)) + (hd : Z^(theta-eta) ≤ primeProductNorm p E) : + primeProductNorm p (G\E) ≤ Z^(g-theta+2*eta) := by + rw [second_residual_norm_eq_div p hp E G hE] + calc + _ ≤ Z^(g+eta)/Z^(theta-eta) := div_le_div₀ (Real.rpow_pos_of_pos hZ _).le hg + (Real.rpow_pos_of_pos hZ _) hd + _ = Z^((g+eta)-(theta-eta)) := (Real.rpow_sub hZ _ _).symm + _ = _ := by congr 1; ring + +include hp in + +theorem actual_second_puncture_power_budget + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) + (Z Q ell t g theta eta : ℝ) (hZ : 0 < Z) + (hQ : (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) ≤ Z^Q) + (hB : primeProductNorm p x.cube.support ≤ Z^(ell+eta)) + (hT : (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + ‖ConcreteTraceCRT.eisEmbedding (actualSecondInheritedRadicalPuncture m (actualSecondChild p u v x).1)‖^2 ≤ + Z^(Q+ell+t+g-theta+4*eta) := by + have hr := second_residual_norm_power_bound p hp _ _ hE Z g theta eta hZ hG hD + apply (actual_second_inherited_puncture_norm p hp hpr x hE ht u v m hm).trans + calc + _ ≤ (Z^Q*Z^(t+eta))*Z^(ell+eta)*Z^(g-theta+2*eta) := by + have hb0 := (primeProductNorm_pos p hp x.cube.support).le + have hr0 := (primeProductNorm_pos p hp (x.second.sourceCommon\x.second.divisor)).le + gcongr + _ = Z^((Q+(t+eta))+(ell+eta)+(g-theta+2*eta)) := by + rw [←Real.rpow_add hZ,←Real.rpow_add hZ,←Real.rpow_add hZ] + _ = _ := by congr 1; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondRapidTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondRapidTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..4573322ce00bf950cff0976ce89bada295d9c66e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondRapidTail.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondTailAbsorption + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem full_second_rapid_correlated_tail (Lcap tau saving : ℝ) + (hLcap : 0≤Lcap) (htau : 0Ideal.span {p i})) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (F : Finset ι) (Ψ : O→*ℂ), (∀ a,‖Ψ a‖≤1) → + ∀ (m c d : O),d≠0 → ∀ (Hcol : Finset ι→ℂ) (W : 𝓢(ℝ,ℂ)) + (Z B Y L : ℝ) (R : Finset ι→Finset ι→ℝ), + 1≤Z → 0≤B → 0childFrequencyBall (d*primeSubsetGenerator (fun i=>Ideal.span {p i}) E) (R G E))‖≤ + C*B^2*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)*Z^(-saving) := by + obtain ⟨order,horder⟩ := choose_second_tail_order Lcap tau saving hLcap htau + obtain ⟨s,Ct,hCt,htail⟩ := full_second_correlated_tail order + refine ⟨s,(4*128^4)*Ct,by positivity,?_⟩ + intro ι _ p hp _ hg hinj hc F Ψ hΨ m c d hd Hcol W Z B Y L R hZ hB hY hL hy hyi hl hcol hsupp hR + have hz : 0 ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def SecondPairCanonicalAt {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) : Prop := +∀ (F : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (A₁ A₂ : Finset ι), A₁ ⊆ x.cube.support∪x.firstCommon → A₂ ⊆ x.cube.support∪x.firstCommon → + ∀ (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G₀ E₀ V₀ K₀ X₀ : ℝ) (t : JointLogSeparation.Frequency × (Fin 6 → ℝ)), + let h := profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2 + let data := actualMarkedSecondProfileData p x Ψ m z A₁ A₂ + secondSeparatedPair p hp hcop hg F data slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ t = + secondOuterPhase h (secondRelativeLog (secondActualNorms p data ∅ ∅) G₀ E₀ V₀ K₀ X₀) * + ∑ J₁ ∈ slots₁.powerset, ∑ J₂ ∈ slots₂.powerset, + (star (primeMark J₁ lists₁ a₁ ((A₁∪x.second.sourceCommon)∪x.second.overlap)) * + primeMark J₂ lists₂ a₂ ((A₂∪x.second.sourceCommon)∪x.second.overlap)) * + star (secondCanonicalPolynomial p hp hcop hg F (fun _ => secondRayMinus Ψ z) + (actualSecondPuncture m) (slots₁\J₁) lists₁ a₁ (fun _ => childLogTest ω₁ (-h 4)) X₀ + (actualSecondChild p u v x)) * + secondCanonicalPolynomial p hp hcop hg F (fun _ => secondRayPlus Ψ z) + (actualSecondPuncture m) (slots₂\J₂) lists₂ a₂ (fun _ => childLogTest ω₂ (h 5)) X₀ + (actualSecondChild p u v {x with second := {x.second with frequency := -x.second.frequency}}) + +theorem exists_second_uniform_sectors + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∃ sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ, + ∀ x ∈ source, SecondPairCanonicalAt (σ:=σ) p hp hcop hg x (sector x).1 (sector x).2 := by + have he (x : {x // x ∈ source}) := + actual_second_separated_pair_canonical p hp hcop hg hpr (σ:=σ) x.val + (hs.common_disjoint x.val x.property) (hs.first_divisor x.val x.property) + (hs.second_divisor x.val x.property) + choose u v hu using he + let sector := fun x => if hx : x ∈ source then (u ⟨x,hx⟩,v ⟨x,hx⟩) else (1,1) + refine ⟨sector,?_⟩ + intro x hx + simpa only [sector,dite_eq_left hx,SecondPairCanonicalAt] using hu ⟨x,hx⟩ + +def secondSourceSector {Jo Jn : ℕ} (source : Finset (MarkedSecondSource ι Jo Jn)) + (sector : MarkedSecondSource ι Jo Jn → Eisˣ × Eisˣ) (uv : Eisˣ × Eisˣ) : + Finset (MarkedSecondSource ι Jo Jn) := source.filter (fun x => sector x = uv) + +omit [DecidableEq ι] in +theorem secondSourceSector_partition {Jo Jn : ℕ} + (source : Finset (MarkedSecondSource ι Jo Jn)) + (sector : MarkedSecondSource ι Jo Jn → Eisˣ × Eisˣ) (H : MarkedSecondSource ι Jo Jn → ℂ) : + ∑ x ∈ source,H x = ∑ uv : Eisˣ × Eisˣ,∑ x ∈ secondSourceSector source sector uv,H x := + (Finset.sum_fiberwise source sector H).symm + +theorem second_unit_sector_card : Fintype.card (Eisˣ × Eisˣ) = 36 := by + have hc : Fintype.card Eisˣ = 6 := by + simpa only [Nat.card_eq_fintype_card] using PrimaryIdealUnitReindex.card_units_eq_six + rw [Fintype.card_prod,hc] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSeparatedColumns.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSeparatedColumns.lean new file mode 100644 index 0000000000000000000000000000000000000000..79df5c0016ab7e0e091ba292169a6f8ed3185244 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSeparatedColumns.lean @@ -0,0 +1,80 @@ +import OAI.NumberTheory.DirichletL.Descent.ActualSecondUniform +import OAI.NumberTheory.DirichletL.Descent.FreshWindows + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open FourierBridge JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def secondOuterPhase (h y : Fin 6 → ℝ) : ℂ := + logPhase (h 0) (y 0) * logPhase (h 1) (y 1) * + logPhase (h 2) (y 2) * logPhase (h 3) (y 3) + +def childLogTest (ω : ℝ → ℂ) (h : ℝ) (y : ℝ) : ℂ := + ω y * logPhase h (Real.log y) + +lemma second_mode_split (y : Fin 6 → ℝ) (t : Frequency) (u : Fin 6 → ℝ) : + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t u = + secondOuterPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope t u) y * + logPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope t u 4) (y 4) * + logPhase (profileHeight secondLeftSlope secondRightSlope secondKernelSlope t u 5) (y 5) := by + rw [pureProfileMode_height] + simp only [Fin.prod_univ_succ, secondOuterPhase] + simp only [Fin.succ, Fin.val_mk] + norm_num + ring + +lemma secondOuterPhase_norm (h y : Fin 6 → ℝ) : ‖secondOuterPhase h y‖ = 1 := by + simp only [secondOuterPhase,norm_mul,logPhase_norm,mul_one] + +lemma second_fresh_scale {ι : Type*} [DecidableEq ι] (p : ι → Eis) + (hp : ∀ i, p i ≠ 0) (V N : Finset ι) (hVN : Disjoint V N) (X : ℝ) : + primeProductNorm p (V ∪ N)/(primeProductNorm p V*X) = primeProductNorm p N/X := by + rw [primeProductNorm_union p V N hVN] + field_simp [(primeProductNorm_pos p hp V).ne'] + +theorem actual_second_columns_separated {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (F : Finset ι) (x : SecondProfileData ι) (slots₁ slots₂ : Finset σ) + (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (X : ℝ) (h₁ h₂ : ℝ) : + (∑ N ∈ (F \ x.overlap).powerset, ∑ M ∈ (F \ x.overlap).powerset, + secondActualCoefficient p hp hcop hg x slots₁ slots₂ lists₁ lists₂ a₁ a₂ N M * + (star (ω₁ (primeProductNorm p N/X)) * ω₂ (primeProductNorm p M/X)) * + logPhase h₁ (Real.log (primeProductNorm p N/X)) * + logPhase h₂ (Real.log (primeProductNorm p M/X))) = + star (canonicalMarkedSplit p hp hcop hg F x.overlap x.extractedLeft x.rayLeft + x.puncture x.quotient x.oldLabel x.oldDivisor x.divisor x.frequency + slots₁ lists₁ a₁ (childLogTest ω₁ (-h₁)) (primeProductNorm p x.overlap*X)) * + canonicalMarkedSplit p hp hcop hg F x.overlap x.extractedRight x.rayRight + x.puncture x.quotient x.oldLabel x.oldDivisor x.divisor (-x.frequency) + slots₂ lists₂ a₂ (childLogTest ω₂ h₂) (primeProductNorm p x.overlap*X) := by + rw [← secondChildKernelPair_separated_marked] + unfold secondChildKernelPair + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro M hM + have hVN : Disjoint x.overlap N := by + apply Finset.disjoint_left.mpr + intro i hi hiN + exact (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hN) hiN)).2 hi + have hVM : Disjoint x.overlap M := by + apply Finset.disjoint_left.mpr + intro i hi hiM + exact (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hM) hiM)).2 hi + dsimp only + rw [second_fresh_scale p hp x.overlap N hVN,second_fresh_scale p hp x.overlap M hVM] + simp only [secondActualCoefficient,childLogTest,secondChildColumn, + star_mul,SecondPassIntegration.logPhase_conjugate,neg_neg,mul_one] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSharpPuncture.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSharpPuncture.lean new file mode 100644 index 0000000000000000000000000000000000000000..ec259828315ddb3d3c2a297ff7a6a910ef059941 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSharpPuncture.lean @@ -0,0 +1,155 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondAdmissible + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseInitialArithmetic (sourceIdeal sourceIdeal_gen sourceIdeal_ne_zero) +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) (hp : ∀ i, p i ≠ 0) + [∀ i, (Ideal.span {p i}).IsMaximal] + +include hp in + +theorem actual_second_radical_puncture_q0_norm + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) : + ‖ConcreteTraceCRT.eisEmbedding (actualSecondRadicalPuncture m (actualSecondChild p u v x).1)‖^2 ≤ + (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) * + (Ideal.absNorm (actualSecondChild p u v x).1.q0 : ℝ) * primeProductNorm p (x.second.sourceCommon\x.second.divisor) := by + have hspan : Ideal.span {actualSecondPuncture m (actualSecondChild p u v x).1} = + (Ideal.span {m} : Ideal Eis) * + Ideal.span {b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit} * sourceIdeal p (x.second.sourceCommon\x.second.divisor) := by + rw [←actual_second_puncture_span p hp hpr x hE u v m] + simp only [←Ideal.span_singleton_mul_span_singleton,secondExpansionQuotient_of_subset p x.second hE, + secondMaskQuotient_span,sourceIdeal,FiniteGaussPhase.span_finset_prod] + rw [eisEmbedding_norm_sq_eq_absNorm_span] + simp only [actualSecondRadicalPuncture,ConcretePrimeRowBridge.span_idealGenerator,hspan] + have hn (S : Finset ι) : (Ideal.absNorm (sourceIdeal p S) : ℝ)=primeProductNorm p S := by + simpa only [sourceIdeal,primeProductNorm,map_prod] using + (eisEmbedding_norm_sq_eq_absNorm_span (∏ i ∈ S,p i)).symm + rw [←hn (x.second.sourceCommon\x.second.divisor)] + exact radical_product_norm_le _ _ _ _ (Ideal.span_singleton_eq_bot.not.mpr hm) + (Ideal.span_singleton_eq_bot.not.mpr (primeProduct_ne_zero p hp _ _)) + (sourceIdeal_ne_zero p hp _) Ideal.le_radical + +include hp in + +theorem actual_second_inherited_puncture_q0_norm + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) : + ‖ConcreteTraceCRT.eisEmbedding (actualSecondInheritedRadicalPuncture m (actualSecondChild p u v x).1)‖^2 ≤ + (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) * Ideal.absNorm x.quotient * + (Ideal.absNorm (actualSecondChild p u v x).1.q0 : ℝ) * primeProductNorm p (x.second.sourceCommon\x.second.divisor) := by + have hm' := mul_ne_zero hm (ConcretePrimeRowBridge.idealGenerator_ne_zero x.quotient ht) + have hb := actual_second_radical_puncture_q0_norm p hp hpr x hE u v + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) hm' + change ‖ConcreteTraceCRT.eisEmbedding (actualSecondRadicalPuncture + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) (actualSecondChild p u v x).1)‖^2 ≤ _ + apply hb.trans + have ho : (Ideal.absNorm (Ideal.span {m*ConcretePrimeRowBridge.idealGenerator x.quotient}).radical : ℝ) ≤ + (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ)*Ideal.absNorm x.quotient := by + rw [←Ideal.span_singleton_mul_span_singleton,ConcretePrimeRowBridge.span_idealGenerator] + simpa only [mul_one,map_one,Nat.cast_one] using radical_product_norm_le (Ideal.span {m}) 1 1 x.quotient + (Ideal.span_singleton_eq_bot.not.mpr hm) one_ne_zero ht Ideal.le_radical + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right ho (Nat.cast_nonneg _)) (primeProductNorm_pos p hp _).le + +include hp in + +theorem actual_second_q0_cube_bound + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) + (B : ℝ) (hB : 0 ≤ B) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) : + (Ideal.absNorm (actualSecondChild p u v x).1.q0 : ℝ) ≤ B := by + change (Ideal.absNorm (Ideal.span {b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}) : ℝ) ≤ B + rw [←eisEmbedding_norm_sq_eq_absNorm_span] + exact (cube_label_norm_bounds p hp _ _ _ _ _ x.cube.support_pos B hB h1 h2).2.1 + +include hp in +theorem actual_second_puncture_power_from_cubes + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) + (Z Q ell t g theta eta : ℝ) (hZ : 0 < Z) + (hQ : (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) ≤ Z^Q) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) + (hT : (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + ‖eisEmbedding (actualSecondInheritedRadicalPuncture m (actualSecondChild p u v x).1)‖^2 ≤ + Z^(Q+ell+t+g-theta+4*eta) := by + have hr := second_residual_norm_power_bound p hp _ _ hE Z g theta eta hZ hG hD + have hb := actual_second_q0_cube_bound p hp x u v _ (Real.rpow_pos_of_pos hZ _).le h1 h2 + apply (actual_second_inherited_puncture_q0_norm p hp hpr x hE ht u v m hm).trans + calc + _ ≤ (Z^Q*Z^(t+eta))*Z^(ell+eta)*Z^(g-theta+2*eta) := by + have hr0 := (primeProductNorm_pos p hp (x.second.sourceCommon\x.second.divisor)).le + gcongr + _ = Z^((Q+(t+eta))+(ell+eta)+(g-theta+2*eta)) := by + rw [←Real.rpow_add hZ,←Real.rpow_add hZ,←Real.rpow_add hZ] + _ = _ := by congr 1; ring + +include hp in +theorem actual_second_puncture_width_from_cubes + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) + (Z Q ell t g theta eta : ℝ) (hZ : 1 < Z) + (hQ : (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) ≤ Z^Q) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) + (hT : (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + actualSecondPunctureWidth Z m (actualSecondChild p u v x).1 ≤ Q+ell+t+g-theta+4*eta := by + have hp0 := actual_second_inherited_puncture_ne_zero p hp hpr x ht u v m hm + have hr0 := radicalGenerator_ne_zero _ hp0 + change actualSecondInheritedRadicalPuncture m (actualSecondChild p u v x).1 ≠ 0 at hr0 + apply (Real.logb_le_iff_le_rpow hZ (sq_pos_of_pos + (norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero hr0)))).mpr + exact actual_second_puncture_power_from_cubes p hp hpr x hE ht u v m hm + Z Q ell t g theta eta (zero_lt_one.trans hZ) hQ h1 h2 hT hG hD + +include hp in + +theorem actual_second_child_margins_from_cubes + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) (ht0 : x.quotient ≠ 0) + (u v : Eisˣ) (m : Eis) (hm : m ≠ 0) + (Z F M Q z c ell A t g theta V j delta eta : ℝ) (hZ : 1 < Z) + (hparent : CanonicalMargins F M Q z c) + (hA : 0 ≤ A) (ht : 0 ≤ t) (hV : 0 ≤ V) (hj : 0 ≤ j) (hdelta : 0 ≤ delta) (heta : 0 ≤ eta) + (hQ : (Ideal.absNorm (Ideal.span {m} : Ideal Eis).radical : ℝ) ≤ Z^Q) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) + (hT : (Ideal.absNorm x.quotient : ℝ) ≤ Z^(t+eta)) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + CanonicalMargins (childF F ell A t g theta V j delta) + (childM M ell A t g theta V j eta) + (actualSecondPunctureWidth Z m (actualSecondChild p u v x).1) z (c-7*eta) := by + apply child_margins hparent hA ht hV hj + (actual_second_common_center p hp x hE Z g theta eta hZ hG hD) hdelta heta + have hwidth := actual_second_puncture_width_from_cubes p hp hpr x hE ht0 u v m hm + Z Q ell t g theta eta hZ hQ h1 h2 hT hG hD + unfold decrease + linarith + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceAttachment.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceAttachment.lean new file mode 100644 index 0000000000000000000000000000000000000000..c40cb506c2b197f650c19e5d7e06f6a010275744 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceAttachment.lean @@ -0,0 +1,152 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondPhysicalRecursive + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondFibers +open InverseInitialArithmetic (sourceIdeal) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + +@[ext] structure SecondParentSource (ι : Type*) (Jo : ℕ) where + cube : CubeCoordinates ι + firstCommon : Finset ι + firstDivisor : Finset ι + quotient : Ideal Eis + oldAssigned : Fin Jo → SmoothMobiusCorrection.PrimeIdeal + +def attachSecondExpansion {Jo : ℕ} (parent : SecondParentSource ι Jo) + (x : SecondExpansionData ι) : MarkedSecondSource ι Jo 0 where + cube := parent.cube + firstCommon := parent.firstCommon + firstDivisor := parent.firstDivisor + second := x + quotient := parent.quotient + oldAssigned := parent.oldAssigned + newAssigned := Fin.elim0 + +def secondParentOf {Jo : ℕ} (x : MarkedSecondSource ι Jo 0) : SecondParentSource ι Jo where + cube := x.cube + firstCommon := x.firstCommon + firstDivisor := x.firstDivisor + quotient := x.quotient + oldAssigned := x.oldAssigned + +omit [DecidableEq ι] in +theorem attachSecondExpansion_injective {Jo : ℕ} (parent : SecondParentSource ι Jo) : + Function.Injective (attachSecondExpansion parent) := by + intro x y h + exact congrArg MarkedSecondSource.second h + +omit [DecidableEq ι] in +theorem attachSecondExpansion_recover {Jo : ℕ} (x : MarkedSecondSource ι Jo 0) : + attachSecondExpansion (secondParentOf x) x.second = x := by + apply MarkedSecondSource.ext <;> try rfl + funext i + exact Fin.elim0 i + +def secondSourceParentEquiv {Jo : ℕ} : + SecondParentSource ι Jo × SecondExpansionData ι ≃ MarkedSecondSource ι Jo 0 where + toFun x := attachSecondExpansion x.1 x.2 + invFun x := (secondParentOf x,x.second) + left_inv x := by cases x; rfl + right_inv := attachSecondExpansion_recover + +variable (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondParentLabel {Jo : ℕ} (parent : SecondParentSource ι Jo) : Eis := + (∏ i∈parent.firstCommon,p i)*jLabel p parent.cube.support + (fun i => parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit + +def secondParentDivisor {Jo : ℕ} (parent : SecondParentSource ι Jo) : Eis := + primeSubsetGenerator (fun i => Ideal.span {p i}) parent.firstDivisor + +def secondParentPuncture {Jo : ℕ} (m : Eis) (parent : SecondParentSource ι Jo) : Eis := + (m*ConcretePrimeRowBridge.idealGenerator parent.quotient)* + b0Label p parent.cube.support (fun i => parent.cube.leftExponent i+parent.cube.rightExponent i) + parent.cube.leftBit parent.cube.rightBit*secondParentDivisor p parent + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem attached_source_conditions {Jo : ℕ} (parent : SecondParentSource ι Jo) + (source : Finset (SecondExpansionData ι)) + (ha : parent.cube.Admissible) (hC : Disjoint parent.firstCommon parent.cube.support) + (hD : parent.firstDivisor ⊆ parent.firstCommon∪parent.cube.support) + (hE : ∀ x∈source,x.divisor ⊆ x.sourceCommon) + (hold : ∀ i,(parent.oldAssigned i).val ∣ + sourceIdeal p parent.cube.support*sourceIdeal p parent.firstCommon*parent.quotient) + (hq : parent.quotient ≠ 0) : + ActualSecondSourceConditions p (source.image (attachSecondExpansion parent)) := by + constructor + · intro x hx + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact ha + · intro x hx + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact hC + · intro x hx + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact hD + · intro x hx + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact hE y hy + · intro x hx + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact hold + · intro x hx i + exact Fin.elim0 i + · intro x hx + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact hq + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem attached_inherited_profile {Jo : ℕ} (parent : SecondParentSource ι Jo) + (x : SecondExpansionData ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) : + secondInheritedProfile p (attachSecondExpansion parent x) Ψ m z = + expansionProfileData p Ψ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) z ∅ ∅ x := rfl + +theorem attached_signed_weight {Jo : ℕ} (parent : SecondParentSource ι Jo) + (x : SecondExpansionData ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) : + actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator (attachSecondExpansion parent x).quotient) z + (attachSecondExpansion parent x) = + secondSignedSourceWeight p hp hcop hg Ψ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) z x := rfl + +theorem secondExpansionSource_attached + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (parent : SecondParentSource ι Jo) + (source : Finset (SecondExpansionData ι)) (hE : ∀ x∈source,x.divisor ⊆ x.sourceCommon) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (X Y : ℝ) : + secondExpansionSource p hp hcop hg pool Ψ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) z source + (fun U => primeMark slots₁ lists₁ a₁ U*W₁ (primeProductNorm p U/X)) + (fun U => primeMark slots₂ lists₂ a₂ U*W₂ (primeProductNorm p U/X)) Φ Y = + (Y : ℂ)*secondRayCoefficient z * + ∑ x∈source.image (attachSecondExpansion parent), + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y X := by + have he := secondExpansionSource_signed_profile p hp hcop hg hinj hpr pool Ψ + (secondParentPuncture p m parent) (secondParentLabel p parent) (secondParentDivisor p parent) + z source hE ∅ ∅ slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ X Y + simp only [Finset.empty_union] at he + rw [he] + congr 1 + rw [Finset.sum_image (fun x hx y hy h => attachSecondExpansion_injective parent h)] + apply Finset.sum_congr rfl + intro x hx + rw [attached_inherited_profile,attached_signed_weight] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceEncoding.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceEncoding.lean new file mode 100644 index 0000000000000000000000000000000000000000..570cc069a6f6040f62b27ba302f1056964021668 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceEncoding.lean @@ -0,0 +1,127 @@ +import OAI.NumberTheory.DirichletL.Descent.CubeSource + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseSecondFibers +open InverseInitialArithmetic (sourceIdeal sourceIdeal_injective) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +@[ext] structure MarkedSecondSource (ι : Type*) (Jo Jn : ℕ) where + cube : CubeCoordinates ι + firstCommon : Finset ι + firstDivisor : Finset ι + second : SecondExpansionData ι + quotient : Ideal Eis + oldAssigned : Fin Jo → SmoothMobiusCorrection.PrimeIdeal + newAssigned : Fin Jn → ι + +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) + [∀ i, (Ideal.span {p i}).IsMaximal] + +def markedSecondOriginal {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) : SecondOriginalSource ι Jo Jn := + cubeSecondSource p x.cube.support x.firstCommon x.firstDivisor + x.second.sourceCommon x.second.divisor x.second.overlap + x.cube.leftExponent x.cube.rightExponent x.cube.leftBit x.cube.rightBit + x.quotient x.second.frequency x.oldAssigned x.newAssigned + +theorem markedSecondOriginal_injOn (hp : ∀ i, p i ≠ 0) + (hinj : Function.Injective (fun i => Ideal.span {p i})) {Jo Jn : ℕ} : + Set.InjOn (markedSecondOriginal (Jo:=Jo) (Jn:=Jn) p) {x | x.cube.Admissible} := by + intro x hx y hy hxy + have hc : x.cube = y.cube := by + apply cubeDivisorKey_injective_on_product p hp hinj hx hy + · simpa only [markedSecondOriginal,cubeSecondSource,cubeProductIdeal] using + congrArg (fun z : SecondOriginalSource ι Jo Jn => z.b1*z.b2) hxy + · funext i + fin_cases i + · simpa [markedSecondOriginal,cubeSecondSource,cubeDivisorKey] using + congrArg SecondOriginalSource.b1 hxy + · simpa [markedSecondOriginal,cubeSecondSource,cubeDivisorKey] using + congrArg SecondOriginalSource.A1 hxy + · simpa [markedSecondOriginal,cubeSecondSource,cubeDivisorKey] using + congrArg SecondOriginalSource.A2 hxy + apply MarkedSecondSource.ext hc + · exact sourceIdeal_injective p hinj (congrArg SecondOriginalSource.C hxy) + · exact sourceIdeal_injective p hinj (congrArg SecondOriginalSource.dK hxy) + · apply SecondExpansionData.ext + · exact congrArg SecondOriginalSource.common hxy + · exact congrArg SecondOriginalSource.divisor hxy + · exact congrArg SecondOriginalSource.overlap hxy + · exact congrArg SecondOriginalSource.frequency hxy + · exact congrArg SecondOriginalSource.quotient hxy + · exact congrArg SecondOriginalSource.oldAssigned hxy + · exact congrArg SecondOriginalSource.newAssigned hxy + +theorem markedSecondTuple_injOn (hp : ∀ i, p i ≠ 0) + (hinj : Function.Injective (fun i => Ideal.span {p i})) {Jo Jn : ℕ} (u v : Eisˣ) : + Set.InjOn (fun x : MarkedSecondSource ι Jo Jn => originalSecondTuple p u v (markedSecondOriginal p x)) + {x | x.cube.Admissible} := by + intro x hx y hy he + exact markedSecondOriginal_injOn p hp hinj hx hy + (originalSecondTuple_injective p hinj u v he) + +theorem markedSecondOriginal_valid (hp : ∀ i, p i ≠ 0) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hCB : Disjoint x.firstCommon x.cube.support) + (hD : x.firstDivisor ⊆ x.firstCommon∪x.cube.support) + (hE : x.second.divisor ⊆ x.second.sourceCommon) + (hold : ∀ i, (x.oldAssigned i).val ∣ + sourceIdeal p x.cube.support*sourceIdeal p x.firstCommon*x.quotient) + (hnew : ∀ i, x.newAssigned i ∈ x.second.sourceCommon∪x.second.overlap) : + SecondOriginalValid (markedSecondOriginal p x) := + cubeSecondSource_valid_original_slots p hp hpr hcop x.cube.support x.firstCommon x.firstDivisor + x.second.sourceCommon x.second.divisor x.second.overlap hCB hD hE + x.cube.leftExponent x.cube.rightExponent x.cube.leftBit x.cube.rightBit x.cube.support_pos + x.quotient x.second.frequency x.oldAssigned x.newAssigned hold hnew + +theorem actual_marked_second_source_fiber (hp : ∀ i, p i ≠ 0) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + {Jo Jn : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo Jn)) + (ha : ∀ x ∈ source, x.cube.Admissible) + (hCB : ∀ x ∈ source, Disjoint x.firstCommon x.cube.support) + (hD : ∀ x ∈ source, x.firstDivisor ⊆ x.firstCommon∪x.cube.support) + (hE : ∀ x ∈ source, x.second.divisor ⊆ x.second.sourceCommon) + (hold : ∀ x ∈ source, ∀ i, (x.oldAssigned i).val ∣ + sourceIdeal p x.cube.support*sourceIdeal p x.firstCommon*x.quotient) + (hnew : ∀ x ∈ source, ∀ i, x.newAssigned i ∈ x.second.sourceCommon∪x.second.overlap) + (γ : OuterTriple) (f : Ideal Eis) (k : Eis) + (hf : f ≠ 0) (hq : γ.q0 ≠ 0) (ht : γ.quotient ≠ 0) (hr : γ.residual ≠ 0) + (K : ℕ) (ho : Jo ≤ 2*K) (hn : Jn ≤ 2*K) : + (source.filter (fun x => secondChild (originalSecondTuple p u v (markedSecondOriginal p x)) = (γ,f,k))).card ≤ + (IdealMobiusDivisorSum.idealDivisors f).card^(9+4*K) * + (IdealMobiusDivisorSum.idealDivisors γ.q0).card^(5+2*K) * + (IdealMobiusDivisorSum.idealDivisors γ.quotient).card^(2*K) * + (IdealMobiusDivisorSum.idealDivisors γ.residual).card^(2*K) := by + classical + let encode := fun x : MarkedSecondSource ι Jo Jn => originalSecondTuple p u v (markedSecondOriginal p x) + let S := source.filter (fun x => secondChild (encode x) = (γ,f,k)) + have hvalid : ∀ x ∈ source, + Valid (encode x) (secondChild (encode x)).1 (secondChild (encode x)).2.1 (secondChild (encode x)).2.2 := by + intro x hx + exact originalSecondTuple_valid p hp hpr u v (markedSecondOriginal p x) + (markedSecondOriginal_valid p hp hpr hcop x (hCB x hx) (hD x hx) (hE x hx) (hold x hx) (hnew x hx)) + have hv : ∀ y ∈ S.image encode, Valid y γ f k := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + obtain ⟨hxs,he⟩ := Finset.mem_filter.mp hx + simpa only [he] using hvalid x hxs + have hi : Set.InjOn encode (S : Set (MarkedSecondSource ι Jo Jn)) := by + intro x hx y hy he + exact markedSecondTuple_injOn p hp hinj u v + (ha x (Finset.mem_filter.mp hx).1) (ha y (Finset.mem_filter.mp hy).1) he + have hb := valid_tuple_card_le_slot_cap (S.image encode) γ f k hf hq ht hr hv K ho hn + rw [Finset.card_image_iff.mpr hi] at hb + exact hb + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceProfile.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..625cc4fc4c296302445c3051dc35b1c6532152e9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceProfile.lean @@ -0,0 +1,83 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSeparatedColumns + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def expansionProfileData (Ψ : Eis →* ℂ) (m c d : Eis) (z : SecondRayIndex) + (A₁ A₂ : Finset ι) (x : SecondExpansionData ι) : SecondProfileData ι where + common := x.sourceCommon + overlap := x.overlap + extractedLeft := A₁ ∪ x.sourceCommon + extractedRight := A₂ ∪ x.sourceCommon + rayLeft := secondRayMinus Ψ z + rayRight := secondRayPlus Ψ z + puncture := m + quotient := secondExpansionQuotient p x + oldLabel := c + oldDivisor := d + divisor := primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor + frequency := x.frequency + +def expansionProfileWeight (Ψ : Eis →* ℂ) (m c d : Eis) (z : SecondRayIndex) + (Y : ℝ) (x : SecondExpansionData ι) : ℂ := + (Y : ℂ) * (‖secondInputCoefficient p hg Ψ m c d (fun _ => 1) x.sourceCommon‖^2 : ℝ) * + (UniqueFactorizationMonoid.moebius (∏ i ∈ x.divisor, Ideal.span {p i}) : ℂ) * + secondTotalWeight p hp hcop hg Ψ Ψ m (secondExpansionQuotient p x) c d + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) x.frequency (z,x.overlap) + +theorem secondExpansionSource_marked_profile + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (F : Finset ι) (Ψ : Eis →* ℂ) (m c d : Eis) (z : SecondRayIndex) + (source : Finset (SecondExpansionData ι)) + (hE : ∀ x ∈ source, x.divisor ⊆ x.sourceCommon) + (A₁ A₂ : Finset ι) (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) + (a₁ a₂ : σ → ι → ℂ) (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (X Y : ℝ) : + secondExpansionSource p hp hcop hg F Ψ m c d z source + (fun U => primeMark slots₁ lists₁ a₁ (A₁ ∪ U) * W₁ (primeProductNorm p U/X)) + (fun U => primeMark slots₂ lists₂ a₂ (A₂ ∪ U) * W₂ (primeProductNorm p U/X)) Φ Y = + ∑ x ∈ source, expansionProfileWeight p hp hcop hg Ψ m c d z Y x * + actualSecondProfileRow p hp hcop hg F (expansionProfileData p Ψ m c d z A₁ A₂ x) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y X := by + unfold secondExpansionSource + apply Finset.sum_congr rfl + intro x hx + have he := hE x hx + have hc := weighted_secondRayChild_congr_off_common p hp hcop hg hinj hpr + x.sourceCommon x.divisor he F x.overlap Ψ Ψ m c d x.frequency z + (secondSourcePairKernel p (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) x.frequency + (fun U => primeMark slots₁ lists₁ a₁ (A₁ ∪ (x.sourceCommon ∪ U)) * + W₁ (primeProductNorm p (x.sourceCommon ∪ U)/X)) + (fun U => primeMark slots₂ lists₂ a₂ (A₂ ∪ (x.sourceCommon ∪ U)) * + W₂ (primeProductNorm p (x.sourceCommon ∪ U)/X)) Φ Y) + (secondSourcePairKernel p (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) x.frequency + (fun U => primeMark slots₁ lists₁ a₁ ((A₁ ∪ x.sourceCommon) ∪ U) * + W₁ (primeProductNorm p x.sourceCommon * primeProductNorm p U/X)) + (fun U => primeMark slots₂ lists₂ a₂ ((A₂ ∪ x.sourceCommon) ∪ U) * + W₂ (primeProductNorm p x.sourceCommon * primeProductNorm p U/X)) Φ Y) + (by + intro S T hGS hGT + simp only [secondSourcePairKernel,primeProductNorm_union p x.sourceCommon S hGS, + primeProductNorm_union p x.sourceCommon T hGT,Finset.union_assoc]) + dsimp only at hc + rw [← secondExpansionQuotient_of_subset p x he] at hc + rw [hc] + simp only [expansionProfileWeight,actualSecondProfileRow,expansionProfileData, + secondSourceCommonCoefficient,Complex.ofReal_pow] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceSize.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceSize.lean new file mode 100644 index 0000000000000000000000000000000000000000..0a4a0228cd652e43e6cdbc00447bdabe6e81e56d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSourceSize.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstSourceSize +import OAI.NumberTheory.DirichletL.Descent.SecondCanonicalTail + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + +include hp in +theorem first_source_height_bounds (b : CubeCoordinates ι) (C D : Finset ι) + (hCB : Disjoint C b.support) + (hD : D⊆C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit) + (Z M Mmax Fmax r ell V delta B j eta tau : ℝ) (hZ : 1b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2) : + -Mmax≤firstPhysicalHeight M r ell V delta B j+12*eta+tau ∧ + firstPhysicalHeight M r ell V delta B j+12*eta+tau≤3*Fmax+16*eta+tau := by + have hz : 0 linarith + +include hp in + +theorem second_source_scalar_caps (b : CubeCoordinates ι) (C D : Finset ι) + (hCB : Disjoint C b.support) + (hD : D⊆C∪cubePrincipalSupport b.support b.leftExponent b.rightExponent b.leftBit b.rightBit) + (Z M Mmax Fmax r ell V delta B j eta tau A t L : ℝ) (hZ : 1b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit)‖^2) + (hL : L≤Z^(r-A-B-t+4*eta)) : + let Y := Z^(firstPhysicalHeight M r ell V delta B j+12*eta+tau) + let cap := Mmax+3*Fmax+16*eta+tau + Y≤Z^cap ∧ Y⁻¹≤Z^cap ∧ L≤Z^cap := by + dsimp only + have hz : 0 ActualEisensteinCubic.O + +@[ext] structure SecondOriginalSource (ι : Type*) (Jo Jn : ℕ) where + q0 : Ideal Eis + quotient : Ideal Eis + J : Ideal Eis + C : Ideal Eis + s : Ideal Eis + b1 : Ideal Eis + A1 : Ideal Eis + A2 : Ideal Eis + dK : Ideal Eis + J2 : Ideal Eis + b2 : Ideal Eis + common : Finset ι + divisor : Finset ι + overlap : Finset ι + frequency : Eis + oldAssigned : Fin Jo → SmoothMobiusCorrection.PrimeIdeal + newAssigned : Fin Jn → ι + +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) + [∀ i, (Ideal.span {p i}).IsMaximal] + +def originalSecondTuple {Jo Jn : ℕ} (u v : Eisˣ) (x : SecondOriginalSource ι Jo Jn) : SecondTuple Jo Jn where + outer := ⟨x.q0,x.quotient,sourceIdeal p (x.common \ x.divisor)⟩ + core := ![x.J,x.C,sourceIdeal p x.divisor,x.s,x.b1,x.A1,x.A2,x.dK] + commonResidual := sourceIdeal p x.overlap + cubeResidual := x.J2 + secondCube := x.b2 + extractedCommon := sourceIdeal p x.common + frequency := secondUnitFrequency u v x.frequency + oldAssigned := x.oldAssigned + newAssigned := fun i => sourcePrime p (x.newAssigned i) + +structure SecondOriginalValid {Jo Jn : ℕ} (x : SecondOriginalSource ι Jo Jn) : Prop where + j_split : x.s*x.J2 = x.J + b_split : x.b1*x.b2 = x.q0^2*x.J2^2*x.s + a1 : x.A1 ∣ (x.b1*x.b2).radical + a2 : x.A2 ∣ (x.b1*x.b2).radical + first_divisor : x.dK ∣ x.C*(x.b1*x.b2).radical + first_generator : primaryGenerator x.dK ≠ 0 + second_subset : x.divisor ⊆ x.common + old_support : ∀ i, (x.oldAssigned i).val ∣ x.q0*x.J*x.C*x.quotient + new_support : ∀ i, x.newAssigned i ∈ x.common ∪ x.overlap + +theorem originalSecondTuple_valid (hp : ∀ i, p i ≠ 0) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + {Jo Jn : ℕ} (u v : Eisˣ) (x : SecondOriginalSource ι Jo Jn) (hx : SecondOriginalValid x) : + Valid (originalSecondTuple p u v x) + (secondChild (originalSecondTuple p u v x)).1 + (secondChild (originalSecondTuple p u v x)).2.1 + (secondChild (originalSecondTuple p u v x)).2.2 := by + have hproduct : sourceIdeal p x.divisor * sourceIdeal p (x.common \ x.divisor) = + sourceIdeal p x.common := by + rw [←sourceIdeal_union p x.divisor (x.common \ x.divisor) + (Finset.disjoint_left.mpr (fun i hi hj => (Finset.mem_sdiff.mp hj).2 hi)), + Finset.union_sdiff_of_subset hx.second_subset] + refine ⟨rfl,rfl,hx.j_split,hx.b_split,hx.a1,hx.a2,hx.first_divisor,?_,hx.first_generator,?_,rfl,?_,?_⟩ + · exact hproduct + · change primaryGenerator (sourceIdeal p x.divisor) ≠ 0 + rw [sourceIdeal_gen p hp hpr] + exact Finset.prod_ne_zero_iff.mpr (fun i _ => hp i) + · intro i + apply (hx.old_support i).trans + change x.q0*x.J*x.C*x.quotient ∣ + x.q0*(x.J*x.C*sourceIdeal p x.divisor*sourceIdeal p x.overlap)*x.quotient + refine ⟨sourceIdeal p x.divisor*sourceIdeal p x.overlap,?_⟩ + ring + · intro i + change (sourcePrime p (x.newAssigned i)).val ∣ + (x.J*x.C*sourceIdeal p x.divisor*sourceIdeal p x.overlap)*sourceIdeal p (x.common \ x.divisor) + have hslot : (sourcePrime p (x.newAssigned i)).val ∣ + sourceIdeal p x.common*sourceIdeal p x.overlap := by + rcases Finset.mem_union.mp (hx.new_support i) with hi|hi + · exact dvd_mul_of_dvd_left (source_prime_dvd p x.common _ hi) _ + · exact dvd_mul_of_dvd_right (source_prime_dvd p x.overlap _ hi) _ + apply hslot.trans + refine ⟨x.J*x.C,?_⟩ + rw [←hproduct] + ring + +theorem originalSecondTuple_injective + (hinj : Function.Injective (fun i => Ideal.span {p i})) + {Jo Jn : ℕ} (u v : Eisˣ) : + Function.Injective (originalSecondTuple (Jo:=Jo) (Jn:=Jn) p u v) := by + intro x y hxy + have hi := sourceIdeal_injective p hinj + have hcore (i : Fin 8) := congrArg (fun z : SecondTuple Jo Jn => z.core i) hxy + apply SecondOriginalSource.ext + · exact congrArg (fun z : SecondTuple Jo Jn => z.outer.q0) hxy + · exact congrArg (fun z : SecondTuple Jo Jn => z.outer.quotient) hxy + · exact hcore 0 + · exact hcore 1 + · exact hcore 3 + · exact hcore 4 + · exact hcore 5 + · exact hcore 6 + · exact hcore 7 + · exact congrArg SecondTuple.cubeResidual hxy + · exact congrArg SecondTuple.secondCube hxy + · exact hi (congrArg SecondTuple.extractedCommon hxy) + · exact hi (hcore 2) + · exact hi (congrArg SecondTuple.commonResidual hxy) + · exact secondUnitFrequency_injective u v (congrArg SecondTuple.frequency hxy) + · exact congrArg SecondTuple.oldAssigned hxy + · funext i + apply hinj + exact congrArg (fun z : SecondTuple Jo Jn => (z.newAssigned i).val) hxy + +theorem original_second_source_fiber_bound (hp : ∀ i, p i ≠ 0) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + {Jo Jn : ℕ} (u v : Eisˣ) (source : Finset (SecondOriginalSource ι Jo Jn)) + (hs : ∀ x ∈ source, SecondOriginalValid x) + (γ : OuterTriple) (f : Ideal Eis) (k : Eis) + (hf : f ≠ 0) (hq : γ.q0 ≠ 0) (ht : γ.quotient ≠ 0) (hr : γ.residual ≠ 0) + (K : ℕ) (ho : Jo ≤ 2*K) (hn : Jn ≤ 2*K) : + (source.filter (fun x => secondChild (originalSecondTuple p u v x) = (γ,f,k))).card ≤ + (IdealMobiusDivisorSum.idealDivisors f).card^(9+4*K) * + (IdealMobiusDivisorSum.idealDivisors γ.q0).card^(5+2*K) * + (IdealMobiusDivisorSum.idealDivisors γ.quotient).card^(2*K) * + (IdealMobiusDivisorSum.idealDivisors γ.residual).card^(2*K) := by + classical + let S := source.filter (fun x => secondChild (originalSecondTuple p u v x) = (γ,f,k)) + have hv : ∀ y ∈ S.image (originalSecondTuple p u v), Valid y γ f k := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + obtain ⟨hxs,he⟩ := Finset.mem_filter.mp hx + have hh := originalSecondTuple_valid p hp hpr u v x (hs x hxs) + simpa only [he] using hh + have hb := valid_tuple_card_le_slot_cap (S.image (originalSecondTuple p u v)) + γ f k hf hq ht hr hv K ho hn + rw [Finset.card_image_of_injective S (originalSecondTuple_injective p hinj u v)] at hb + exact hb + +theorem originalSecondTuple_row_norm {Jo Jn : ℕ} (u v : Eisˣ) + (x : SecondOriginalSource ι Jo Jn) (d e : Eis) + (hde : d*e = (v:Eis)*(primaryGenerator x.dK*primaryGenerator (sourceIdeal p x.divisor))) : + ‖ConcreteTraceCRT.eisEmbedding (secondChild (originalSecondTuple p u v x)).2.2‖ = + ‖ConcreteTraceCRT.eisEmbedding (d*e*x.frequency)‖ := by + exact secondCanonical_row_norm x.dK (sourceIdeal p x.divisor) u v d e x.frequency hde + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSquarefree.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSquarefree.lean new file mode 100644 index 0000000000000000000000000000000000000000..afbb3f8fbe58d23f4536aced2793cba156c396b0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSquarefree.lean @@ -0,0 +1,178 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondMarkedEnergy +import OAI.NumberTheory.DirichletL.Descent.SecondWeights + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic CompletedGauss +open InverseInitialArithmetic (sourceIdeal sourcePrime sourceIdeal_dvd) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +include hcop in +omit [DecidableEq ι] in +theorem sourceIdeal_squarefree (S : Finset ι) : Squarefree (sourceIdeal p S) := by + rw [sourceIdeal,FiniteGaussPhase.span_finset_prod] + apply Finset.squarefree_prod_of_pairwise_isCoprime + · intro i hi j hj hij + exact (hcop hij).isRelPrime + · intro i hi + exact (sourcePrime p i).property.squarefree + +include hcop in +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem sourceIdeal_coprime_of_disjoint (S T : Finset ι) (hST : Disjoint S T) : + IsCoprime (sourceIdeal p S) (sourceIdeal p T) := by + simp only [sourceIdeal,FiniteGaussPhase.span_finset_prod] + apply IsCoprime.prod_left + intro i hi + apply IsCoprime.prod_right + intro j hj + exact hcop (fun he => Finset.disjoint_left.mp hST hi (he.symm ▸ hj)) + +omit [DecidableEq ι] in +lemma prime_span_coprime_of_not_mem (i : ι) (c : Eis) (hc : c ∉ Ideal.span {p i}) : + IsCoprime (Ideal.span {p i}) (Ideal.span {c} : Ideal Eis) := by + apply Ideal.isCoprime_iff_sup_eq.mpr + by_contra hne + have he := (inferInstance : (Ideal.span {p i}).IsMaximal).eq_of_le hne le_sup_left + apply hc + rw [he] + exact (show Ideal.span {c} ≤ (Ideal.span {p i} : Ideal Eis) ⊔ Ideal.span {c} from le_sup_right) + (Ideal.subset_span (by simp)) + +omit [DecidableEq ι] in +theorem sourceIdeal_coprime_of_not_mem (S : Finset ι) (c : Eis) + (hc : ∀ i ∈ S, c ∉ Ideal.span {p i}) : + IsCoprime (sourceIdeal p S) (Ideal.span {c} : Ideal Eis) := by + rw [sourceIdeal,FiniteGaussPhase.span_finset_prod] + exact IsCoprime.prod_left (fun i hi => prime_span_coprime_of_not_mem p i c (hc i hi)) + +omit [DecidableEq ι] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem jLabel_span_dvd_source (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) : + (Ideal.span {jLabel p B v ε₁ ε₂} : Ideal Eis) ∣ sourceIdeal p B := by + apply span_dvd_of_element_dvd + change (∏ i ∈ B,p i^bit (retained (parity (v i)) (ε₁ i) (ε₂ i))) ∣ ∏ i ∈ B,p i + apply Finset.prod_dvd_prod_of_dvd + intro i hi + cases retained (parity (v i)) (ε₁ i) (ε₂ i) <;> simp [bit] + +omit [DecidableEq ι] in +theorem secondInputCoefficient_zero_of_label_mem (Ψ : Eis →* ℂ) (m c d : Eis) + (H : Finset ι → ℂ) (S : Finset ι) (i : ι) (hi : i ∈ S) (hc : c ∈ Ideal.span {p i}) : + secondInputCoefficient p hg Ψ m c d H S = 0 := by + have hz : rowCoprimeMask (fun i => Ideal.span {p i}) S c = 0 := by + simp only [rowCoprimeMask,ite_eq_left (show ∃ i ∈ S,c ∈ Ideal.span {p i} from ⟨i,hi,hc⟩)] + have hr := row_zero_of_mask_zero (fun i => Ideal.span {p i}) hg S c hz + simp only [secondInputCoefficient,hr,zero_pow (by decide : (4:ℕ) ≠ 0),mul_zero,zero_mul] + +theorem secondPreColumn_zero_of_mask_label_mem (Ψ : Eis →* ℂ) (m c d e k : Eis) + (H : Finset ι → ℂ) (S : Finset ι) (i : ι) (hi : i ∈ S) + (hc : m*c ∈ Ideal.span {p i}) : secondPreColumn p hp hcop hg Ψ m c d e k H S = 0 := by + rcases (inferInstance : (Ideal.span {p i}).IsPrime).mem_or_mem hc with hm|hc + · have hz : rowCoprimeMask (fun i => Ideal.span {p i}) S m = 0 := by + simp only [rowCoprimeMask,ite_eq_left (show ∃ i ∈ S,m ∈ Ideal.span {p i} from ⟨i,hi,hm⟩)] + simp only [secondPreColumn,hz,mul_zero,zero_mul] + · have hz : rowCoprimeMask (fun i => Ideal.span {p i}) S c = 0 := by + simp only [rowCoprimeMask,ite_eq_left (show ∃ i ∈ S,c ∈ Ideal.span {p i} from ⟨i,hi,hc⟩)] + have hr := row_zero_of_mask_zero (fun i => Ideal.span {p i}) hg S c hz + simp only [secondPreColumn,hr,zero_pow (by decide : (4:ℕ) ≠ 0),mul_zero,zero_mul] + +theorem secondSignedSourceWeight_nonzero_masks + (Ψ : Eis →* ℂ) (m c d : Eis) (z : SecondRayIndex) (x : SecondExpansionData ι) + (hE : x.divisor ⊆ x.sourceCommon) + (hw : secondSignedSourceWeight p hp hcop hg Ψ m c d z x ≠ 0) : + IsCoprime (sourceIdeal p x.sourceCommon) (Ideal.span {c}) ∧ + IsCoprime (sourceIdeal p x.overlap) (sourceIdeal p x.sourceCommon * Ideal.span {c}) := by + constructor + · apply sourceIdeal_coprime_of_not_mem p + intro i hi hc + have hz := secondInputCoefficient_zero_of_label_mem p hg Ψ m c d (fun _ => 1) x.sourceCommon i hi hc + apply hw + simp only [secondSignedSourceWeight,hz,norm_zero,zero_pow (by decide : (2:ℕ) ≠ 0), + Complex.ofReal_zero,zero_mul] + · change IsCoprime (sourceIdeal p x.overlap) (Ideal.span {∏ i ∈ x.sourceCommon,p i} * Ideal.span {c}) + rw [Ideal.span_singleton_mul_span_singleton] + apply sourceIdeal_coprime_of_not_mem p + intro i hi hc + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor + let r := secondExpansionQuotient p x + have her : e*r = ∏ j ∈ x.sourceCommon,p j := by + dsimp only [r] + rw [secondExpansionQuotient_of_subset p x hE] + exact (secondMaskQuotient_spec p _ _ hE).symm + have hmc : (m*(e*r))*c ∈ Ideal.span {p i} := by + rw [her,mul_assoc] + exact Ideal.mul_mem_left _ m hc + have hz := secondPreColumn_zero_of_mask_label_mem p hp hcop hg (secondRayPlus Ψ z) + (m*(e*r)) c d e (-x.frequency) (fun _ => 1) x.overlap i hi hmc + dsimp only [e,r] at hz + apply hw + simp only [secondSignedSourceWeight,secondCommonWeight,hz,mul_zero] + +def actualSecondSignedWeight {Jo Jn : ℕ} (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (x : MarkedSecondSource ι Jo Jn) : ℂ := + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor + let c := (∏ i ∈ x.firstCommon,p i)*jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + secondSignedSourceWeight p hp hcop hg Ψ + (m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit*d) c d z x.second + +theorem actualSecondSignedWeight_norm_le_one + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo Jn : ℕ} (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (x : MarkedSecondSource ι Jo Jn) : ‖actualSecondSignedWeight p hp hcop hg Ψ m z x‖ ≤ 1 := + secondSignedSourceWeight_norm_le_one p hp hcop hg hinj hc Ψ hΨ _ _ _ z x.second + +theorem actual_second_nonzero_weight_squarefree + {Jo Jn : ℕ} (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (x : MarkedSecondSource ι Jo Jn) + (hCB : Disjoint x.firstCommon x.cube.support) + (hE : x.second.divisor ⊆ x.second.sourceCommon) + (hw : actualSecondSignedWeight p hp hcop hg Ψ m z x ≠ 0) (u v : Eisˣ) : + Squarefree (actualSecondChild p u v x).2.1 := by + let J : Ideal Eis := Ideal.span {jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit} + let C := sourceIdeal p x.firstCommon + let E := sourceIdeal p x.second.divisor + let G := sourceIdeal p x.second.sourceCommon + let V := sourceIdeal p x.second.overlap + have hj : J ∣ sourceIdeal p x.cube.support := jLabel_span_dvd_source p _ _ _ _ + have hJ : Squarefree J := (sourceIdeal_squarefree p hcop x.cube.support).squarefree_of_dvd hj + have hC : Squarefree C := sourceIdeal_squarefree p hcop _ + have hG : Squarefree G := sourceIdeal_squarefree p hcop _ + have hV : Squarefree V := sourceIdeal_squarefree p hcop _ + have hJC : IsCoprime J C := + (sourceIdeal_coprime_of_disjoint p hcop x.cube.support x.firstCommon hCB.symm).of_isCoprime_of_dvd_left hj + have hdg : E ∣ G := sourceIdeal_dvd p _ _ hE + have hcspan : Ideal.span {(∏ i ∈ x.firstCommon,p i)*jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit} = C*J := + (Ideal.span_singleton_mul_span_singleton _ _).symm + obtain ⟨hgmask,hvmask⟩ := secondSignedSourceWeight_nonzero_masks p hp hcop hg Ψ _ _ _ z x.second hE hw + rw [hcspan] at hgmask hvmask + change IsCoprime G (C*J) at hgmask + change IsCoprime V (G*(C*J)) at hvmask + have heJC : IsCoprime E (J*C) := by + simpa only [mul_comm] using hgmask.of_isCoprime_of_dvd_left hdg + have hdiv : J*C*E ∣ G*(C*J) := by + obtain ⟨r,hr⟩ := hdg + refine ⟨r,?_⟩ + rw [hr] + ring + have hvJCE := hvmask.of_isCoprime_of_dvd_right hdiv + change Squarefree (J*C*E*V) + exact squarefree_mul_iff.mpr ⟨hvJCE.symm.isRelPrime, + squarefree_mul_iff.mpr ⟨heJC.symm.isRelPrime, + squarefree_mul_iff.mpr ⟨hJC.isRelPrime,hJ,hC⟩,hG.squarefree_of_dvd hdg⟩,hV⟩ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondSupportedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSupportedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..62f94715c2a5d65a80ce89b2ab572a14bc3a5846 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondSupportedEnergy.lean @@ -0,0 +1,119 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSquarefree + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem ActualSecondSourceConditions.mono {Jo Jn : ℕ} + {S T : Finset (MarkedSecondSource ι Jo Jn)} (h : ActualSecondSourceConditions p S) + (hTS : T ⊆ S) : ActualSecondSourceConditions p T where + admissible x hx := h.admissible x (hTS hx) + common_disjoint x hx := h.common_disjoint x (hTS hx) + first_divisor x hx := h.first_divisor x (hTS hx) + second_divisor x hx := h.second_divisor x (hTS hx) + old_support x hx := h.old_support x (hTS hx) + new_support x hx := h.new_support x (hTS hx) + quotient_nonzero x hx := h.quotient_nonzero x (hTS hx) + +def actualSecondSurvivingSource {Jo : ℕ} (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (source : Finset (MarkedSecondSource ι Jo 0)) : Finset (MarkedSecondSource ι Jo 0) := + source.filter (fun x => actualSecondSignedWeight p hp hcop hg Ψ m z x ≠ 0) + +theorem assignedSecondSource_mono {Jo : ℕ} + {S T : Finset (MarkedSecondSource ι Jo 0)} (hST : S ⊆ T) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) : + assignedSecondSource S J₁ J₂ L₁ L₂ ⊆ assignedSecondSource T J₁ J₂ L₁ L₂ := by + intro x hx + obtain ⟨y,hy,q₁,hq₁,q₂,hq₂,he⟩ := (mem_assignedSecondSource S J₁ J₂ L₁ L₂ x).mp hx + exact (mem_assignedSecondSource T J₁ J₂ L₁ L₂ x).mpr ⟨y,hST hy,q₁,hq₁,q₂,hq₂,he⟩ + +theorem actualSecondTriples_mono {Jo Jn : ℕ} (u v : Eisˣ) + {S T : Finset (MarkedSecondSource ι Jo Jn)} (hST : S ⊆ T) : + actualSecondTriples p u v S ⊆ actualSecondTriples p u v T := + Finset.image_subset_image hST + +theorem actual_second_supported_marked_energy + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : Eis) (z : SecondRayIndex) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ L₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ L₂ i, ‖a₂ i q‖ ≤ 1) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hchild : ∀ x ∈ source, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (phase : MarkedSecondSource ι Jo 0 → ℂ) (hphase : ∀ x ∈ source, ‖phase x‖ ≤ 1) + (F G : SecondChild → ℂ) : + ‖∑ x ∈ source, (actualSecondSignedWeight p hp hcop hg Ψ m z x * phase x) * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))‖ ≤ + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource + source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows F γ) * + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource + source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows G γ) := by + let S := actualSecondSurvivingSource p hp hcop hg Ψ m z source + have hsub : S ⊆ source := Finset.filter_subset _ _ + have he : (∑ x ∈ source, (actualSecondSignedWeight p hp hcop hg Ψ m z x * phase x) * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))) = + ∑ x ∈ S, (actualSecondSignedWeight p hp hcop hg Ψ m z x * phase x) * + (star (primeMark J₁ L₁ a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ L₂ a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x)) := by + symm + apply Finset.sum_subset hsub + intro x hx hnx + have hz : actualSecondSignedWeight p hp hcop hg Ψ m z x = 0 := by + by_contra hh + exact hnx (Finset.mem_filter.mpr ⟨hx,hh⟩) + simp only [hz,zero_mul] + rw [he] + have hb := actual_second_marked_weighted_count p hp hcop hpr hinj u v S + (hs.mono p hsub) J₁ J₂ L₁ L₂ a₁ a₂ ha₁ ha₂ (labels.filter Squarefree) rows + (by + intro x hx + have hx0 := hsub hx + refine ⟨Finset.mem_filter.mpr ⟨(hchild x hx0).1,?_⟩,(hchild x hx0).2⟩ + exact actual_second_nonzero_weight_squarefree p hp hcop hg Ψ m z x + (hs.common_disjoint x hx0) (hs.second_divisor x hx0) (Finset.mem_filter.mp hx).2 u v) + K ho hJ₁ hJ₂ (fun x => actualSecondSignedWeight p hp hcop hg Ψ m z x*phase x) + (by + intro x hx + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) + (actualSecondSignedWeight_norm_le_one p hp hcop hg hinj hc Ψ hΨ m z x)).trans + (hphase x (hsub hx))) F G + apply hb.trans + have hΓ := actualSecondTriples_mono p u v (assignedSecondSource_mono hsub J₁ J₂ L₁ L₂) + have hsum (P : SecondChild → ℂ) : + (∑ γ ∈ actualSecondTriples p u v (assignedSecondSource S J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows P γ) ≤ + ∑ γ ∈ actualSecondTriples p u v (assignedSecondSource source J₁ J₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows P γ := by + apply Finset.sum_le_sum_of_subset_of_nonneg hΓ + intro γ _ _ + exact mul_nonneg (tripleDivisorWeight_nonneg K γ) (secondLabelEnergy_nonneg _ _ _ _ _) + exact mul_le_mul (Real.sqrt_le_sqrt (hsum F)) (Real.sqrt_le_sqrt (hsum G)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondTailAbsorption.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondTailAbsorption.lean new file mode 100644 index 0000000000000000000000000000000000000000..65019612e0d14f5fe91b55e25061640f49b66b4c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondTailAbsorption.lean @@ -0,0 +1,57 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceSize + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section + +lemma second_tail_fixed_cap (Y L cap B P H : ℝ) (order : ℕ) + (hY : 0 ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + +include hinj in +theorem residualPairWeight_bounded_test + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m c d : O) + (Hcol : Finset ι → ℂ) (B : ℝ) (hB : 0 ≤ B) + (hcol : ∀ U, ‖Hcol U‖ ≤ B) (G S T : Finset ι) : + ‖residualPairWeight p hg Ψ Ψ m c d + (fun U => Hcol (G ∪ U)) (fun U => Hcol (G ∪ U)) S T‖ ≤ B^2 := by + simp only [residualPairWeight, norm_mul, norm_star, sourceSupportMobius_norm p hinj, one_mul] + have hS := (secondInputCoefficient_norm_le_test p hg Ψ hΨ m c d + (fun U => Hcol (G ∪ U)) S).trans (hcol _) + have hT := (secondInputCoefficient_norm_le_test p hg Ψ hΨ m c d + (fun U => Hcol (G ∪ U)) T).trans (hcol _) + simpa only [pow_two] using mul_le_mul hS hT (norm_nonneg _) hB + +include hp hinj +theorem residualTailCost_bounded_test + (F G E : Finset ι) (hEG : E ⊆ G) (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (Hcol : Finset ι → ℂ) (B Y H lengthScale P : ℝ) (A : ℕ) + (hB : 0 ≤ B) (hY : 0 < Y) (hH : 0 ≤ H) (hP : 0 ≤ P) (hL : 1 ≤ lengthScale) + (hcol : ∀ U, ‖Hcol U‖ ≤ B) (hsupport : ∀ U, Hcol U ≠ 0 → primeProductNorm p U ≤ lengthScale) : + residualTailCost p hg F G Ψ Ψ m c d + (fun S => Hcol (G∪S)) + (fun S => Hcol (G∪S)) + (primeSubsetGenerator (fun i => Ideal.span {p i}) E) Y H A P ≤ + if primeProductNorm p G ≤ lengthScale then + (128*lengthScale)^2 * (B^2 * + (Y*P*(1+lengthScale^3/Y)^2/(1+H)^A)) else 0 := by + let C := B^2 * (Y*P*(1+lengthScale^3/Y)^2/(1+H)^A) + have hC : 0 ≤ C := by dsimp [C]; positivity + let w := residualPairWeight p hg Ψ Ψ m c d + (fun S => Hcol (G∪S)) + (fun S => Hcol (G∪S)) + have hsupp (S T : Finset ι) (hw : w S T ≠ 0) : + primeProductNorm p G ≤ lengthScale ∧ primeProductNorm p E ≤ lengthScale ∧ + primeProductNorm p S ≤ lengthScale ∧ primeProductNorm p T ≤ lengthScale := by + obtain ⟨hS,hT⟩ := residualPairWeight_test_ne_zero p hg Ψ Ψ m c d _ _ S T hw + have hGS := hsupport (G ∪ S) hS + have hGT := hsupport (G ∪ T) hT + have hG := (primeProductNorm_mono p hp Finset.subset_union_left).trans hGS + exact ⟨hG, (primeProductNorm_mono p hp hEG).trans hG, + (primeProductNorm_mono p hp Finset.subset_union_right).trans hGS, + (primeProductNorm_mono p hp Finset.subset_union_right).trans hGT⟩ + by_cases hG : primeProductNorm p G ≤ lengthScale + · rw [ite_eq_left hG] + calc + _ ≤ ∑ S ∈ (F\G).powerset, ∑ T ∈ (F\G).powerset, + if primeProductNorm p S ≤ lengthScale ∧ primeProductNorm p T ≤ lengthScale then C else 0 := by + unfold residualTailCost + apply Finset.sum_le_sum + intro S hS + apply Finset.sum_le_sum + intro T hT + by_cases hd : Disjoint S T + · rw [ite_eq_left hd] + dsimp only + by_cases hw : w S T = 0 + · change ‖w S T‖ * _ ≤ _ + rw [hw, norm_zero, zero_mul] + split_ifs <;> positivity + · obtain ⟨_,hE,hSn,hTn⟩ := hsupp S T hw + rw [ite_eq_left ⟨hSn,hTn⟩] + have hn2 : ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2 = + primeProductNorm p S * primeProductNorm p T := active_norm_sq_disjoint p S T hd + have hn : 1 ≤ ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖ := by + have hpS := primeProductNorm_ge_one p hp S + have hpT := primeProductNorm_ge_one p hp T + have hpST : 1 ≤ primeProductNorm p S * primeProductNorm p T := one_le_mul_of_one_le_of_one_le hpS hpT + rw [← hn2] at hpST + nlinarith [norm_nonneg (eisEmbedding (∏ i : activeSupport T S, p i.val))] + have hNe : 0 < ‖eisEmbedding (primeSubsetGenerator (fun i => Ideal.span {p i}) E)‖^2 := + SecondPassIntegration.elementNorm_pos _ (primeSubsetGenerator_ne_zero _ _) + have hden : ‖eisEmbedding (primeSubsetGenerator (fun i => Ideal.span {p i}) E)‖^2 * + ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2 ≤ lengthScale^3 := by + rw [primeSubsetGenerator_norm_eq_productNorm, hn2] + have hST := mul_le_mul hSn hTn (FirstPassCubeLabels.primeProductNorm_pos p hp T).le + (zero_le_one.trans hL) + have hEST := mul_le_mul hE hST + (mul_nonneg (FirstPassCubeLabels.primeProductNorm_pos p hp S).le + (FirstPassCubeLabels.primeProductNorm_pos p hp T).le) (zero_le_one.trans hL) + nlinarith + have hscalar := tail_radial_scalar_le Y + (‖eisEmbedding (primeSubsetGenerator (fun i => Ideal.span {p i}) E)‖^2) + (‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖) lengthScale H P A hY hNe hn hL hden hH hP + exact mul_le_mul (residualPairWeight_bounded_test p hg hinj Ψ hΨ m c d Hcol B hB hcol G S T) + hscalar (by positivity) (sq_nonneg _) + · rw [ite_eq_right hd] + split_ifs <;> positivity + _ = ((boundedPrimeSupports p (F\G) lengthScale).card : ℝ)^2 * C := + sum_pair_indicator (F\G).powerset (fun S => primeProductNorm p S ≤ lengthScale) C + _ ≤ (128*lengthScale)^2 * C := by + exact mul_le_mul_of_nonneg_right + (pow_le_pow_left₀ (by positivity) (boundedPrimeSupports_card p hinj (F\G) lengthScale hL) 2) hC + · rw [ite_eq_right hG] + have hz : residualTailCost p hg F G Ψ Ψ m c d + (fun S => Hcol (G∪S)) + (fun S => Hcol (G∪S)) + (primeSubsetGenerator (fun i => Ideal.span {p i}) E) Y H A P = 0 := by + unfold residualTailCost + apply Finset.sum_eq_zero + intro S hS + apply Finset.sum_eq_zero + intro T hT + by_cases hd : Disjoint S T + · rw [ite_eq_left hd] + have hw : w S T = 0 := by + by_contra hw + exact hG (hsupp S T hw).1 + change ‖w S T‖ * _ = 0 + rw [hw, norm_zero, zero_mul] + · rw [ite_eq_right hd] + exact hz.le + +theorem secondSourceTailCost_bounded_test + (F : Finset ι) (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (Hcol : Finset ι → ℂ) (B Y H lengthScale P : ℝ) (A : ℕ) + (hB : 0 ≤ B) (hY : 0 < Y) (hH : 0 ≤ H) (hP : 0 ≤ P) (hL : 1 ≤ lengthScale) + (hcol : ∀ U, ‖Hcol U‖ ≤ B) (hsupport : ∀ U, Hcol U ≠ 0 → primeProductNorm p U ≤ lengthScale) : + (∑ G ∈ F.powerset, ∑ E : G.powerset, ‖secondSourceCommonCoefficient p hg Ψ m c d G E.val‖ * + residualTailCost p hg F G Ψ Ψ m c d + (fun S => Hcol (G∪S)) + (fun S => Hcol (G∪S)) + (primeSubsetGenerator (fun i => Ideal.span {p i}) E.val) Y H A P) ≤ + (128*lengthScale)^4 * (B^2 * (Y*P*(1+lengthScale^3/Y)^2/(1+H)^A)) := by + let C := B^2 * (Y*P*(1+lengthScale^3/Y)^2/(1+H)^A) + have hC : 0 ≤ C := by dsimp [C]; positivity + have h128 : 0 ≤ 128*lengthScale := by positivity + calc + _ ≤ ∑ G ∈ F.powerset, if primeProductNorm p G ≤ lengthScale then (128*lengthScale)^3*C else 0 := by + apply Finset.sum_le_sum + intro G hG + by_cases hGn : primeProductNorm p G ≤ lengthScale + · rw [ite_eq_left hGn] + have heq : boundedPrimeSupports p G lengthScale = G.powerset := by + apply Finset.filter_eq_self.mpr + intro E hE + exact (primeProductNorm_mono p hp (Finset.mem_powerset.mp hE)).trans hGn + have hcard : (G.powerset.card : ℝ) ≤ 128*lengthScale := by + simpa only [heq] using boundedPrimeSupports_card p hinj G lengthScale hL + calc + _ ≤ ∑ E : G.powerset, (128*lengthScale)^2*C := by + apply Finset.sum_le_sum + intro E hE + have hr := residualTailCost_bounded_test p hp hg hinj F G E.val (Finset.mem_powerset.mp E.property) + Ψ hΨ m c d Hcol B Y H lengthScale P A hB hY hH hP hL hcol hsupport + rw [ite_eq_left hGn] at hr + have hc := secondSourceCommonCoefficient_norm_le_one p hp hg hinj Ψ hΨ m c d G E.val + exact (mul_le_mul_of_nonneg_left hr (norm_nonneg _)).trans + (by simpa only [one_mul] using mul_le_mul_of_nonneg_right hc (mul_nonneg (sq_nonneg _) hC)) + _ = (G.powerset.card : ℝ)*((128*lengthScale)^2*C) := by + simp only [Finset.sum_const, Finset.card_univ, Fintype.card_coe, nsmul_eq_mul] + _ ≤ (128*lengthScale)*((128*lengthScale)^2*C) := mul_le_mul_of_nonneg_right hcard (mul_nonneg (sq_nonneg _) hC) + _ = _ := by ring + · rw [ite_eq_right hGn] + apply Finset.sum_nonpos + intro E hE + have hr := residualTailCost_bounded_test p hp hg hinj F G E.val (Finset.mem_powerset.mp E.property) + Ψ hΨ m c d Hcol B Y H lengthScale P A hB hY hH hP hL hcol hsupport + rw [ite_eq_right hGn] at hr + exact mul_nonpos_of_nonneg_of_nonpos (norm_nonneg _) hr + _ = ((boundedPrimeSupports p F lengthScale).card : ℝ)*((128*lengthScale)^3*C) := by + rw [← Finset.sum_filter] + simp only [boundedPrimeSupports, Finset.sum_const, nsmul_eq_mul] + _ ≤ (128*lengthScale)*((128*lengthScale)^3*C) := + mul_le_mul_of_nonneg_right (boundedPrimeSupports_card p hinj F lengthScale hL) + (mul_nonneg (pow_nonneg h128 _) hC) + _ = _ := by ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondTripleBounds.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondTripleBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..6e00c60e42efac624df56d6fdfa9cbb139441219 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondTripleBounds.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondPunctureBudget + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι → Eis) + (hp : ∀ i, p i ≠ 0) + +include hp in + +theorem actual_second_common_center + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor ⊆ x.second.sourceCommon) + (Z g theta eta : ℝ) (hZ : 1 < Z) + (hG : primeProductNorm p x.second.sourceCommon ≤ Z^(g+eta)) + (hD : Z^(theta-eta) ≤ primeProductNorm p x.second.divisor) : + -2*eta ≤ g-theta := by + have hh : Z^(theta-eta) ≤ Z^(g+eta) := + hD.trans ((primeProductNorm_mono p hp hE).trans hG) + have hh' := (Real.rpow_le_rpow_left_iff hZ).mp hh + linarith + +include hp in + +theorem actual_second_label_center + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (Z ell j eta : ℝ) (hZ : 1 < Z) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) + (hJ : Z^(j-eta) ≤ ‖eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) : + j ≤ 2*ell+3*eta := by + have hb := (cube_label_norm_bounds p hp x.cube.support x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit x.cube.support_pos (Z^(ell+eta)) + (Real.rpow_pos_of_pos (zero_lt_one.trans hZ) _).le h1 h2).1 + have hh := hJ.trans hb + rw [←Real.rpow_mul_natCast (zero_lt_one.trans hZ).le] at hh + have hh' := (Real.rpow_le_rpow_left_iff hZ).mp hh + norm_num at hh' + linarith + +variable [∀ i, (Ideal.span {p i}).IsMaximal] + +include hp in + +theorem actual_second_q0_power_bound + {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) (u v : Eisˣ) + (Z ell R j eta : ℝ) (hZ : 0 < Z) + (h1 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) + (h2 : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) + (hactive : primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(R+eta)) + (hJ : Z^(j-eta) ≤ ‖eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) : + (Ideal.absNorm (actualSecondChild p u v x).1.q0 : ℝ) ≤ Z^(ell+R/2-j+5*eta/2) := by + have hb := (cube_label_norm_bounds p hp x.cube.support x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit x.cube.support_pos (Z^(ell+eta)) + (Real.rpow_pos_of_pos hZ _).le h1 h2).2.2 + have ha : ‖eisEmbedding (∏ i ∈ cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖ ≤ + Z^((R+eta)/2) := by + apply (sq_le_sq₀ (norm_nonneg _) (Real.rpow_pos_of_pos hZ _).le).mp + rw [←Real.rpow_mul_natCast hZ.le] + norm_num + simpa only [primeProductNorm,map_prod,norm_prod] using hactive + change (Ideal.absNorm (Ideal.span {b0Label p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit}) : ℝ) ≤ _ + rw [←eisEmbedding_norm_sq_eq_absNorm_span] + apply hb.trans + calc + _ ≤ (Z^(ell+eta)*Z^((R+eta)/2))/Z^(j-eta) := + div_le_div₀ (by positivity) (mul_le_mul_of_nonneg_left ha (by positivity)) + (Real.rpow_pos_of_pos hZ _) hJ + _ = Z^((ell+eta)+(R+eta)/2-(j-eta)) := by + rw [←Real.rpow_add hZ,←Real.rpow_sub hZ] + _ = _ := by congr 1; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVariableCutoff.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVariableCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..195f2809b1363477aa904e9639bb3454f3dd0a92 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVariableCutoff.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceAttachment + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic InverseSecondFibers +open InverseInitialArithmetic (sourceIdeal) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ κ : Type*} [DecidableEq ι] [DecidableEq σ] [DecidableEq κ] +variable (p : ι → Eis) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondVariableCutoff {Jo : ℕ} (parent : SecondParentSource ι Jo) (R : Finset ι → Finset ι → ℝ) + (G E : Finset ι) : Finset Eis := + childFrequencyBall (secondParentDivisor p parent*primeSubsetGenerator (fun i => Ideal.span {p i}) E) (R G E) + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem second_variable_original_support {Jo : ℕ} (parent : SecondParentSource ι Jo) + (pool residual : Finset ι) (R : Finset ι → Finset ι → ℝ) + (label : Finset ι → SecondExpansionData ι → κ) (j : κ) + (x : SecondExpansionData ι) + (hx : x∈secondDyadicSector pool (secondVariableCutoff p parent R) residual label j) : + x.sourceCommon ⊆ pool ∧ x.divisor ⊆ x.sourceCommon ∧ x.overlap ⊆ pool ∧ + x.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p (attachSecondExpansion parent x)) (R x.sourceCommon x.divisor) := by + obtain ⟨hx,hlabel⟩ := Finset.mem_filter.mp hx + obtain ⟨hx,hresidual⟩ := Finset.mem_filter.mp hx + exact (mem_secondExpansionPool _ _ _).mp hx + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem second_variable_attached_rows {Jo : ℕ} (parent : SecondParentSource ι Jo) + (pool residual : Finset ι) (R : Finset ι → Finset ι → ℝ) + (label : Finset ι → SecondExpansionData ι → κ) (j : κ) + (x : MarkedSecondSource ι Jo 0) + (hx : x∈(secondDyadicSector pool (secondVariableCutoff p parent R) residual label j).image + (attachSecondExpansion parent)) : + x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) (R x.second.sourceCommon x.second.divisor) := by + obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx + exact (second_variable_original_support p parent pool residual R label j y hy).2.2.2 + +theorem truncated_second_attached_variable [Fintype κ] + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i,ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (parent : SecondParentSource ι Jo) + (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) + (slots : Finset σ) (lists : σ → Finset ι) (a : σ → ι → ℂ) + (W : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (X Y : ℝ) (R : Finset ι → Finset ι → ℝ) + (label : Finset ι → SecondExpansionData ι → κ) : + truncatedSecondSource p hp hg hinj pool Ψ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) + (fun U => primeMark slots lists a U*W (primeProductNorm p U/X)) Φ Y + (secondVariableCutoff p parent R) = + truncatedSecondZero p hg pool Ψ (secondParentPuncture p m parent) + (secondParentLabel p parent) (secondParentDivisor p parent) + (fun U => primeMark slots lists a U*W (primeProductNorm p U/X)) Φ Y + (secondVariableCutoff p parent R) + + ∑ z : SecondRayIndex,∑ residual∈pool.powerset,∑ j : κ, + (Y : ℂ)*secondRayCoefficient z * + ∑ x∈(secondDyadicSector pool (secondVariableCutoff p parent R) residual label j).image + (attachSecondExpansion parent), + actualSecondSignedWeight p hp hcop hg Ψ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots slots lists lists a a W W Φ Y X := by + rw [truncatedSecondSource_eq_zero_add_dyadic p hp hcop hg hinj hc hpr + pool Ψ (secondParentPuncture p m parent) (secondParentLabel p parent) (secondParentDivisor p parent) + (fun U => primeMark slots lists a U*W (primeProductNorm p U/X)) Φ Y (secondVariableCutoff p parent R) label] + congr 1 + apply Finset.sum_congr rfl + intro z hz + apply Finset.sum_congr rfl + intro residual hresidual + apply Finset.sum_congr rfl + intro j hj + exact secondExpansionSource_attached p hp hcop hg hinj hpr parent _ + (fun x hx => (second_variable_original_support p parent pool residual R label j x hx).2.1) + pool Ψ m z slots slots lists lists a a W W Φ X Y + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVariablePrincipal.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVariablePrincipal.lean new file mode 100644 index 0000000000000000000000000000000000000000..4ce4e177dc4e1bacf6447f3aa0d894e0b948a045 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVariablePrincipal.lean @@ -0,0 +1,80 @@ +import OAI.NumberTheory.DirichletL.Inversion.SecondPrincipalCaller +import OAI.NumberTheory.DirichletL.Descent.FirstRetainedFamily + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic FourierBridge +open SecondPassIntegration CompletedHeight InversePrincipalEnergy RayFourExpansion +open InverseSecondPrincipalCaller +local notation "Eis" => ActualEisensteinCubic.O + +theorem first_retained_radius_one {ι : Type*} [DecidableEq ι] + (p : ι→Eis) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (labels : Finset (Ideal Eis)) (b : CubeCoordinates ι) (Y : ℝ) + (hlabels : ∀ f∈labels,f≠0) (hne : (firstRetainedSource p labels b Y).Nonempty) : 1≤Y := by + obtain ⟨x,hx⟩ := hne + obtain ⟨hf,hk⟩ := (mem_firstRetainedSource p labels b Y x).mp hx + have hm : firstPhysicalMultiplier p b.support b.leftExponent b.rightExponent b.leftBit b.rightBit x.1≠0 := by + unfold firstPhysicalMultiplier + exact mul_ne_zero (pow_ne_zero _ (ConcretePrimeRowBridge.idealGenerator_ne_zero _ (hlabels _ hf))) + (primeProduct_ne_zero p hp _ _) + by_contra hy + rw [nonzeroChildFrequencyBall_empty _ hm Y (lt_of_not_ge hy)] at hk + exact Finset.notMem_empty _ hk + +theorem firstCore_variable_principal_energy (ε : ℝ) (hε : 0<ε) : + ∃ (s : Finset (ℕ×ℕ)) (C : ℝ),0Ideal.span {p i})) + (_hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (slots : Finset σ) (lists : σ→Finset ι) (coeff : σ→ι→ℂ), + (slots : Set σ).PairwiseDisjoint lists → + (∀ i∈slots,∀ k∈lists i,‖coeff i k‖≤1) → + ∀ (F D B : Finset ι) (v : ι→ℕ) (ε₁ ε₂ : ι→Bool), + (∀ i∈slots,Disjoint (lists i) D) → + ∀ (negative : Bool) (χ : RayCharacter) (Ψ : Eis→*ℂ), + (∀ z,‖Ψ z‖≤1) → ∀ (m c d : Eis),d≠0 → ∀ (r : FirstCoreIndex) + (om W : 𝓢(ℝ,ℂ)) (a b : ℝ) (_ha : 0om (Real.exp u)) + (columnLog p (primeProductNorm p D*X)) negative (-t) D + let Ψ₀ := firstCoreTwist negative χ Ψ r + let m₀ := (m*b0Label p B v ε₁ ε₂)*∏ i∈D,p i + let c₀ := c*jLabel p B v ε₁ ε₂ + ‖truncatedSecondZero p hg F Ψ₀ m₀ c₀ d H W Y (fun G E=>secondPhysicalCutoff p d (R G E) G E)‖ + + ‖principalRestoration p hg hinj hp F Ψ₀ m₀ c₀ d H W Y (fun G E=>secondPhysicalMask p d (R G E) G E)‖ ≤ + C*(s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W * (SchwartzMap.seminorm ℝ 0 0 om)^2)* + Y*(X*Real.exp M)^(1+ε) := by + obtain ⟨s,C,hC,hbound⟩ := marked_principal_energy ε hε + refine ⟨s,C,hC,?_⟩ + intro ι σ _ _ p hp _ hg hinj hcop slots lists coeff hslots hcoeff F D B v ε₁ ε₂ hD + negative χ Ψ hΨ m c d hd r om W a b ha hs M t X Y R hb hX hY hR H Ψ₀ m₀ c₀ + let V := principalWindow om a b ha hs negative t + let H₀ := markedRadial p slots lists coeff ∅ V X + have he (U : Finset ι) : secondInputCoefficient p hg Ψ₀ m₀ c₀ d H U= + secondInputCoefficient p hg Ψ₀ m₀ c₀ d H₀ U := + firstCoreTest_coefficient p hp hg hinj slots lists coeff D U hD om a b ha hs negative X t hX Ψ₀ + (m*b0Label p B v ε₁ ε₂) c₀ d + rw [zero_congr_input p hg F Ψ₀ m₀ c₀ d H H₀ he, + restoration_congr_input p hp hg hinj F Ψ₀ m₀ c₀ d H H₀ he] + have hz : ∀ G∈F.powerset,∀ E∈G.powerset,(0:Eis)∈secondPhysicalCutoff p d (R G E) G E := by + intro G hG E hE + exact zero_mem_childFrequencyBall _ (mul_ne_zero hd (primeSubsetGenerator_ne_zero _ _)) _ (hR G E) + have hbnd := hbound p hp hg hinj hcop slots lists coeff hslots hcoeff ∅ F Ψ₀ + (fun z=>(firstCoreTwist_norm_le negative χ Ψ r z).trans (hΨ z)) m₀ c₀ d V W X M Y + hX hY (principalWindow_upper om a b ha hs M hb negative t) + (fun G E=>secondPhysicalCutoff p d (R G E) G E) hz + (fun G E=>secondPhysicalMask p d (R G E) G E) + (fun G _ E k=>secondPhysicalMask_norm_le_one p d (R G E.val) G E.val k.val) + simpa only [H₀,V,Finset.card_empty,pow_zero,mul_one,principalWindow_seminorm_zero] using hbnd + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingBalanced.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingBalanced.lean new file mode 100644 index 0000000000000000000000000000000000000000..c563690369b595b478bec18bf619d99de57afa02 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingBalanced.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondVaryingDensity +import OAI.NumberTheory.DirichletL.Inversion.SecondProfileUniform + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {κ ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_varying_balanced_source (source : Finset κ) (F : Finset ι) + (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : κ → σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (V : Fin 6 → ℝ → ℂ) + (G₀ E₀ V₀ K₀ X₀ Y L : ℝ) + (hG : 0 < G₀) (hE : 0 < E₀) (hV : 0 < V₀) (hK : 0 < K₀) (hX : 0 < X₀) + (density : Frequency × (Fin 6 → ℝ) → ℂ) (hDensity : Integrable density) + (hsep : ∀ y : Fin 6 → ℝ, + (Real.exp (-6*L):ℂ) * secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ V + (Y*K₀/(E₀*V₀^2*X₀^2)) y = + ∫ t : Frequency × (Fin 6 → ℝ), density t * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) + (hn : ∀ j ∈ source,(x j).divisor ≠ 0 ∧ (x j).frequency ≠ 0) + (hω₁ : ∀ j ∈ source, ∀ N ∈ (F\(x j).overlap).powerset, + W₁ (primeProductNorm p (x j).common*primeProductNorm p (x j).overlap*primeProductNorm p N/(G₀*V₀*X₀)) ≠ 0 → + ω₁ (primeProductNorm p N/X₀) = 1) + (hω₂ : ∀ j ∈ source, ∀ N ∈ (F\(x j).overlap).powerset, + W₂ (primeProductNorm p (x j).common*primeProductNorm p (x j).overlap*primeProductNorm p N/(G₀*V₀*X₀)) ≠ 0 → + ω₂ (primeProductNorm p N/X₀) = 1) + (hcut : ∀ j ∈ secondProfileIndices source F x, + ω₁ (primeProductNorm p j.2.1/X₀) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X₀) ≠ 0 → ∀ i, + V i (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀ i) = 1) : + (Real.exp (-6*L):ℂ) * (∑ j ∈ source,w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀:ℝ):ℂ)⁻¹ * ∫ t : Frequency × (Fin 6 → ℝ),density t * + ∑ j ∈ source,w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ t := by + apply actualSecondVaryingFreshRows_normalized_density p hp hcop hg source F x w + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ Y G₀ E₀ V₀ K₀ X₀ density hDensity + intro j hj + obtain ⟨hjS,hN,hM⟩ := (mem_secondProfileIndices source F x j).mp hj + have h1 : star (W₁ (primeProductNorm p (x j.1).common*primeProductNorm p (x j.1).overlap* + primeProductNorm p j.2.1/(G₀*V₀*X₀))) ≠ 0 → star (ω₁ (primeProductNorm p j.2.1/X₀)) = 1 := by + intro hh + rw [hω₁ j.1 hjS j.2.1 hN (star_ne_zero.mp hh),star_one] + have h2 := hω₂ j.1 hjS j.2.2 hM + have h3 : star (ω₁ (primeProductNorm p j.2.1/X₀)) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X₀) ≠ 0 → ∀ i, + V i (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀ i) = 1 := + fun ha hb => hcut j hj (star_ne_zero.mp ha) hb + have he := InverseSecondProfileUniform.fresh_physical_profile + (fun x => star (W₁ x)) W₂ Φ V G₀ E₀ V₀ K₀ X₀ Y L hG hE hV hK hX + (fun x => star (ω₁ x)) ω₂ (secondActualNorms p (x j.1) j.2.1 j.2.2) + (secondActualNorms_pos p hp (x j.1) (hn j.1 hjS).1 (hn j.1 hjS).2 j.2.1 j.2.2) + (by simpa [secondActualNorms] using h1) + (by simpa [secondActualNorms] using h2) + (by simpa [secondActualNorms] using h3) + rw [hsep] at he + simpa [secondActualNorms] using he + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingDensity.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingDensity.lean new file mode 100644 index 0000000000000000000000000000000000000000..6be08ad1e0cc600ef671623d0d1ea8676a278dc2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingDensity.lean @@ -0,0 +1,122 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondFreshAssembly +import OAI.NumberTheory.DirichletL.Descent.DensityAssembly + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open MeasureTheory FourierBridge JointLogSeparation ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actualSecondVaryingFreshRows_integral_density {κ : Type*} + (source : Finset κ) (F : Finset ι) (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : κ → σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y G₀ E₀ V₀ K₀ X₀ : ℝ) + (density : Frequency × (Fin 6 → ℝ) → ℂ) (hDensity : Integrable density) + (he : ∀ j ∈ secondProfileIndices source F x, + secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (secondActualNorms p (x j.1) j.2.1 j.2.2) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀)) * + ∫ v : Frequency × (Fin 6 → ℝ), density v * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2) : + (∑ j ∈ source, w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∫ v : Frequency × (Fin 6 → ℝ), + density v * + ∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v := by + have hindexed : (∑ j∈source,w j*actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ∑ j∈secondProfileIndices source F x, + (w j.1*secondActualCoefficient p hp hcop hg (x j.1) slots₁ slots₂ + (lists₁ j.1) (lists₂ j.1) a₁ a₂ j.2.1 j.2.2)* + secondNormProfile (fun z=>star (W₁ (z/(G₀*V₀*X₀)))) + (fun z=>W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _=>1) Y + (secondActualNorms p (x j.1) j.2.1 j.2.2) := by + simp_rw [actualSecondProfileRow_eq_whole] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + rw [hindexed] + have hc (v : Frequency × (Fin 6 → ℝ)) : + (∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v) = + ∑ j ∈ secondProfileIndices source F x, + ((w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ (lists₁ j.1) (lists₂ j.1) a₁ a₂ j.2.1 j.2.2) * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀))) * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2 := by + simp_rw [← actual_second_full_mode_columns] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + simp_rw [hc] + rw [← density_finite_sum _ density hDensity,Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + rw [he j hj] + ring + +theorem actualSecondVaryingFreshRows_normalized_density {κ : Type*} + (source : Finset κ) (F : Finset ι) (x : κ → SecondProfileData ι) (w : κ → ℂ) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : κ → σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y G₀ E₀ V₀ K₀ X₀ : ℝ) + (density : Frequency × (Fin 6 → ℝ) → ℂ) (hDensity : Integrable density) (normalization : ℂ) + (he : ∀ j ∈ secondProfileIndices source F x, + normalization * secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y (secondActualNorms p (x j.1) j.2.1 j.2.2) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀)) * + ∫ v : Frequency × (Fin 6 → ℝ), density v * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2) : + normalization * (∑ j ∈ source, w j * actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ((E₀*V₀*X₀ : ℝ):ℂ)⁻¹ * ∫ v : Frequency × (Fin 6 → ℝ), + density v * + ∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v := by + have hindexed : (∑ j∈source,w j*actualSecondProfileRow p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ W₁ W₂ Φ Y (G₀*V₀*X₀)) = + ∑ j∈secondProfileIndices source F x, + (w j.1*secondActualCoefficient p hp hcop hg (x j.1) slots₁ slots₂ + (lists₁ j.1) (lists₂ j.1) a₁ a₂ j.2.1 j.2.2)* + secondNormProfile (fun z=>star (W₁ (z/(G₀*V₀*X₀)))) + (fun z=>W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _=>1) Y + (secondActualNorms p (x j.1) j.2.1 j.2.2) := by + simp_rw [actualSecondProfileRow_eq_whole] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + rw [hindexed] + have hc (v : Frequency × (Fin 6 → ℝ)) : + (∑ j ∈ source, w j * secondSeparatedPair p hp hcop hg F (x j) + slots₁ slots₂ (lists₁ j) (lists₂ j) a₁ a₂ ω₁ ω₂ G₀ E₀ V₀ K₀ X₀ v) = + ∑ j ∈ secondProfileIndices source F x, + ((w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ (lists₁ j.1) (lists₂ j.1) a₁ a₂ j.2.1 j.2.2) * + (star (ω₁ (primeProductNorm p j.2.1/X₀)) * ω₂ (primeProductNorm p j.2.2/X₀))) * + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope + (secondRelativeLog (secondActualNorms p (x j.1) j.2.1 j.2.2) G₀ E₀ V₀ K₀ X₀) v.1 v.2 := by + simp_rw [← actual_second_full_mode_columns] + simp only [secondProfileIndices,Finset.sum_sigma,Finset.sum_product,Finset.mul_sum,mul_assoc] + simp_rw [hc] + rw [← density_finite_sum _ density hDensity] + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro j hj + calc + _ = (w j.1 * secondActualCoefficient p hp hcop hg (x j.1) + slots₁ slots₂ (lists₁ j.1) (lists₂ j.1) a₁ a₂ j.2.1 j.2.2) * + (normalization * secondNormProfile (fun z => star (W₁ (z/(G₀*V₀*X₀)))) + (fun z => W₂ (z/(G₀*V₀*X₀))) Φ (fun _ _ => 1) Y + (secondActualNorms p (x j.1) j.2.1 j.2.2)) := by ring + _ = _ := by rw [he j hj]; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingLists.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingLists.lean new file mode 100644 index 0000000000000000000000000000000000000000..7101823b53fabb8de035a50615e16d85f34a4c77 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingLists.lean @@ -0,0 +1,143 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSupportedEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMoment +open InverseSecondFibers +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + +def varyingAssignedGate {Jo : ℕ} (J₁ J₂ : Finset σ) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) + (x : MarkedSecondSource ι Jo (J₁.card+J₂.card)) : Prop := + (∀ i hi,x.newAssigned (Fin.castAdd J₂.card (J₁.equivFin ⟨i,hi⟩))∈L₁ (eraseSecondSlots x) i) ∧ + (∀ i hi,x.newAssigned (Fin.natAdd J₁.card (J₂.equivFin ⟨i,hi⟩))∈L₂ (eraseSecondSlots x) i) + +omit [DecidableEq ι] in +lemma varyingAssignedGate_attach {Jo : ℕ} (J₁ J₂ : Finset σ) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) + (x : MarkedSecondSource ι Jo 0) (q : (∀ i∈J₁,ι)×(∀ i∈J₂,ι)) : + varyingAssignedGate J₁ J₂ L₁ L₂ (attachPairedSlots J₁ J₂ (x,q)) ↔ + q.1∈J₁.pi (L₁ x) ∧ q.2∈J₂.pi (L₂ x) := by + simp only [varyingAssignedGate,attachPairedSlots,erase_attachSecondSlots] + simp only [attachSecondSlots,pairedSlotAssignment, + Fin.addCases_left,Fin.addCases_right,indexedSlotAssignment_apply,Finset.mem_pi] + +def varyingAssignedSource {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (base₁ base₂ : σ→Finset ι) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) := + (assignedSecondSource source J₁ J₂ base₁ base₂).filter (varyingAssignedGate J₁ J₂ L₁ L₂) + +theorem varyingAssignedSource_mono {Jo : ℕ} + {S T : Finset (MarkedSecondSource ι Jo 0)} (hST : S⊆T) + (J₁ J₂ : Finset σ) (base₁ base₂ : σ→Finset ι) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) : + varyingAssignedSource S J₁ J₂ base₁ base₂ L₁ L₂⊆ + varyingAssignedSource T J₁ J₂ base₁ base₂ L₁ L₂ := by + exact Finset.filter_subset_filter _ (assignedSecondSource_mono hST J₁ J₂ base₁ base₂) + +theorem varyingAssignedSource_sum {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (base₁ base₂ : σ→Finset ι) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) + (hL₁ : ∀ x∈source,∀ i∈J₁,L₁ x i⊆base₁ i) + (hL₂ : ∀ x∈source,∀ i∈J₂,L₂ x i⊆base₂ i) + (F : MarkedSecondSource ι Jo (J₁.card+J₂.card)→ℂ) : + ∑ x∈varyingAssignedSource source J₁ J₂ base₁ base₂ L₁ L₂,F x = + ∑ y∈source,∑ q∈(J₁.pi (fun i=>L₁ y i∩(y.second.sourceCommon∪y.second.overlap)))×ˢ + (J₂.pi (fun i=>L₂ y i∩(y.second.sourceCommon∪y.second.overlap))),F (attachPairedSlots J₁ J₂ (y,q)) := by + rw [varyingAssignedSource,Finset.sum_filter,assignedSecondSource_sum] + apply Finset.sum_congr rfl + intro y hy + rw [←Finset.sum_filter] + congr 1 + ext q + simp only [Finset.mem_filter,Finset.mem_product,varyingAssignedGate_attach,Finset.mem_pi,Finset.mem_inter] + constructor + · rintro ⟨⟨h₁,h₂⟩,h₃,h₄⟩ + exact ⟨fun i hi=>⟨h₃ i hi,(h₁ i hi).2⟩,fun i hi=>⟨h₄ i hi,(h₂ i hi).2⟩⟩ + · rintro ⟨h₁,h₂⟩ + exact ⟨⟨fun i hi=>⟨hL₁ y hy i hi (h₁ i hi).1,(h₁ i hi).2⟩, + fun i hi=>⟨hL₂ y hy i hi (h₂ i hi).1,(h₂ i hi).2⟩⟩, + fun i hi=>(h₁ i hi).1,fun i hi=>(h₂ i hi).1⟩ + +theorem varyingAssignedSource_sum_marks {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (base₁ base₂ : σ→Finset ι) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) + (hL₁ : ∀ x∈source,∀ i∈J₁,L₁ x i⊆base₁ i) + (hL₂ : ∀ x∈source,∀ i∈J₂,L₂ x i⊆base₂ i) + (a₁ a₂ : σ→ι→ℂ) (w P : MarkedSecondSource ι Jo 0→ℂ) : + (∑ y∈source,w y*(star (primeMark J₁ (L₁ y) a₁ (y.second.sourceCommon∪y.second.overlap))* + primeMark J₂ (L₂ y) a₂ (y.second.sourceCommon∪y.second.overlap))*P y) = + ∑ x∈varyingAssignedSource source J₁ J₂ base₁ base₂ L₁ L₂, + (w (eraseSecondSlots x)*assignedSecondCoefficient J₁ J₂ a₁ a₂ x)*P (eraseSecondSlots x) := by + rw [varyingAssignedSource_sum source J₁ J₂ base₁ base₂ L₁ L₂ hL₁ hL₂] + apply Finset.sum_congr rfl + intro y hy + rw [paired_primeMark_assignments] + simp only [Finset.mul_sum,Finset.sum_mul] + apply Finset.sum_congr rfl + intro q hq + rw [assignedSecondCoefficient_attach] + simp only [attachPairedSlots,erase_attachSecondSlots] + +variable (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem actual_second_varying_lists_weighted_count + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + {Jo : ℕ} (u v : Oˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (J₁ J₂ : Finset σ) (base₁ base₂ : σ→Finset ι) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) + (hL₁ : ∀ x∈source,∀ i∈J₁,L₁ x i⊆base₁ i) + (hL₂ : ∀ x∈source,∀ i∈J₂,L₂ x i⊆base₂ i) + (a₁ a₂ : σ→ι→ℂ) + (ha₁ : ∀ i∈J₁,∀ q∈base₁ i,‖a₁ i q‖≤1) + (ha₂ : ∀ i∈J₂,∀ q∈base₂ i,‖a₂ i q‖≤1) + (labels : Finset (Ideal O)) (rows : Finset O) + (hchild : ∀ x∈source,(actualSecondChild p u v x).2.1∈labels ∧ (actualSecondChild p u v x).2.2∈rows) + (K : ℕ) (ho : Jo≤2*K) (hJ₁ : J₁.card≤K) (hJ₂ : J₂.card≤K) + (w : MarkedSecondSource ι Jo 0→ℂ) (hw : ∀ x∈source,‖w x‖≤1) (F G : SecondChild→ℂ) : + ‖∑ x∈source,w x*(star (primeMark J₁ (L₁ x) a₁ (x.second.sourceCommon∪x.second.overlap))* + primeMark J₂ (L₂ x) a₂ (x.second.sourceCommon∪x.second.overlap))* + F (actualSecondChild p u v x)*star (G (actualSecondChild p u v x))‖ ≤ + Real.sqrt (∑ γ∈actualSecondTriples p u v (varyingAssignedSource source J₁ J₂ base₁ base₂ L₁ L₂), + tripleDivisorWeight K γ*secondLabelEnergy K labels rows F γ)* + Real.sqrt (∑ γ∈actualSecondTriples p u v (varyingAssignedSource source J₁ J₂ base₁ base₂ L₁ L₂), + tripleDivisorWeight K γ*secondLabelEnergy K labels rows G γ) := by + let S := varyingAssignedSource source J₁ J₂ base₁ base₂ L₁ L₂ + have hsub : S⊆assignedSecondSource source J₁ J₂ base₁ base₂ := Finset.filter_subset _ _ + have hs' : ActualSecondSourceConditions p S := + (assignedSecondSource_conditions p source hs J₁ J₂ base₁ base₂).mono p hsub + have herase : ∀ x∈S,eraseSecondSlots x∈source := by + intro x hx + obtain ⟨y,hy,q₁,hq₁,q₂,hq₂,rfl⟩ := (mem_assignedSecondSource source J₁ J₂ base₁ base₂ x).mp (hsub hx) + simpa only [attachPairedSlots,erase_attachSecondSlots] using hy + let w' := fun x : MarkedSecondSource ι Jo (J₁.card+J₂.card)=> + w (eraseSecondSlots x)*assignedSecondCoefficient J₁ J₂ a₁ a₂ x + have hw' : ∀ x∈S,‖w' x‖≤1 := by + intro x hx + rw [show w' x=w (eraseSecondSlots x)*assignedSecondCoefficient J₁ J₂ a₁ a₂ x from rfl,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (hw _ (herase x hx))).trans + (assignedSecondCoefficient_norm_le_one source J₁ J₂ base₁ base₂ a₁ a₂ ha₁ ha₂ x (hsub hx)) + have hc' : ∀ x∈S,(actualSecondChild p u v x).2.1∈labels ∧ (actualSecondChild p u v x).2.2∈rows := by + intro x hx + simpa only [actualSecondChild_erase] using hchild (eraseSecondSlots x) (herase x hx) + have he := varyingAssignedSource_sum_marks source J₁ J₂ base₁ base₂ L₁ L₂ hL₁ hL₂ a₁ a₂ w + (fun x=>F (actualSecondChild p u v x)*star (G (actualSecondChild p u v x))) + simp only [actualSecondChild_erase,←mul_assoc] at he + simp only [←mul_assoc] + rw [he] + exact actual_second_weighted_count p hp hpr hcop hinj u v S hs' labels rows hc' K ho + (by omega) w' hw' F G + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..3ad84a9b892e5bf4bf0fb5ea1b4a4234f8e5a84f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingPhysical.lean @@ -0,0 +1,124 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondModeIntegral +import OAI.NumberTheory.DirichletL.Descent.SecondVaryingBalanced + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical ContDiff +open InverseSecondFibers ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open JointLogSeparation MeasureTheory SchwartzMap +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +local instance inverseSecondVaryingPhysicalUnits : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units +universe u₁ u₂ +variable {ι : Type u₁} {σ : Type u₂} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_varying_modes_common_sectors + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∃ sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ, + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : MarkedSecondSource ι Jo 0 → σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (ω₁ ω₂ : ℝ → ℂ) (G E V B X : ℝ) (t : Frequency × (Fin 6 → ℝ)) + (w : MarkedSecondSource ι Jo 0 → ℂ), + (∑ x ∈ source,w x * secondSeparatedPair p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (lists₁ x) (lists₂ x) a₁ a₂ ω₁ ω₂ G E V B X t) = + ∑ uv : Eisˣ × Eisˣ, ∑ x ∈ secondSourceSector source sector uv, w x * + ∑ J₁ ∈ slots₁.powerset,∑ J₂ ∈ slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (lists₁ x) (lists₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t := by + obtain ⟨sector,hsector⟩ := exists_second_uniform_sectors p hp hcop hg hpr (σ:=σ) source hs + refine ⟨sector,?_⟩ + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t w + rw [secondSourceSector_partition source sector] + apply Finset.sum_congr rfl + intro uv huv + apply Finset.sum_congr rfl + intro x hx + obtain ⟨hx,hxs⟩ := Finset.mem_filter.mp hx + congr 1 + have hh := hsector x hx + rw [hxs] at hh + exact second_inherited_mode_canonical p hp hcop hg x uv.1 uv.2 hh + pool Ψ m z slots₁ slots₂ (lists₁ x) (lists₂ x) a₁ a₂ ω₁ ω₂ G E V B X t + +theorem actual_second_varying_balanced_profile_children + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + {Jo : ℕ} (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) : + ∃ sector : MarkedSecondSource ι Jo 0 → Eisˣ × Eisˣ, + ∀ (pool : Finset ι) (Ψ : Eis →* ℂ) (m : Eis) (z : SecondRayIndex) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : MarkedSecondSource ι Jo 0 → σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ ω₁ ω₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (G E V B X Y R L : ℝ) + (U : Fin 6 → ℝ → ℂ) (density : Frequency × (Fin 6 → ℝ) → ℂ) + (w : MarkedSecondSource ι Jo 0 → ℂ), + 0 < G → 0 < E → 0 < V → 0 < B → 0 < X → Integrable density → + (∀ y : Fin 6 → ℝ,(Real.exp (-6*L):ℂ)*secondPoissonProfile (fun x => star (W₁ x)) W₂ Φ U + (Y*B/(E*V^2*X^2)) y = ∫ t : Frequency × (Fin 6 → ℝ),density t* + pureProfileMode secondLeftSlope secondRightSlope secondKernelSlope y t.1 t.2) → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₁ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₁ (primeProductNorm p N/X) = 1) → + (∀ x ∈ source,∀ N ∈ (pool\x.second.overlap).powerset, + W₂ (primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap* + primeProductNorm p N/(G*V*X)) ≠ 0 → ω₂ (primeProductNorm p N/X) = 1) → + (∀ j ∈ secondProfileIndices source pool (fun x => secondInheritedProfile p x Ψ m z), + ω₁ (primeProductNorm p j.2.1/X) ≠ 0 → ω₂ (primeProductNorm p j.2.2/X) ≠ 0 → ∀ i, + U i (secondRelativeLog (secondActualNorms p (secondInheritedProfile p j.1 Ψ m z) j.2.1 j.2.2) + G E V B X i) = 1) → + (Real.exp (-6*L):ℂ) * ((Y : ℂ)*secondRayCoefficient z * + (∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (lists₁ x) (lists₂ x) a₁ a₂ W₁ W₂ Φ Y (G*V*X))) = + ((Y : ℂ)*secondRayCoefficient z*((E*V*X : ℝ):ℂ)⁻¹) * + ∫ t : Frequency × (Fin 6 → ℝ),density t * + ∑ uv : Eisˣ × Eisˣ,∑ x ∈ secondSourceSector source sector uv, + (w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + ∑ J₁ ∈ slots₁.powerset,∑ J₂ ∈ slots₂.powerset, + secondModeBranch p hp hcop hg x uv.1 uv.2 pool Ψ m z slots₁ slots₂ J₁ J₂ (lists₁ x) (lists₂ x) a₁ a₂ + ω₁ ω₂ G E V B X t := by + obtain ⟨sector,hsector⟩ := actual_second_varying_modes_common_sectors p hp hcop hg hpr (σ:=σ) source hs + refine ⟨sector,?_⟩ + intro pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ G E V B X Y R L + U density w hG hE hV hB hX hDensity hsep hrows hω₁ hω₂ hcut + have hn : ∀ x ∈ source,(secondInheritedProfile p x Ψ m z).divisor ≠ 0 ∧ + (secondInheritedProfile p x Ψ m z).frequency ≠ 0 := by + intro x hx + refine ⟨primeSubsetGenerator_ne_zero _ _,?_⟩ + have hh := (mem_nonzeroChildFrequencyBall _ (actualSecondMultiplier_ne_zero p x) R _).mp (hrows x hx) + intro he + change x.second.frequency = 0 at he + simp only [he,mul_zero,map_zero,norm_zero,zero_pow (by omega : 2 ≠ 0),lt_self_iff_false] at hh + exact hh.1 + have he := actual_second_varying_balanced_source p hp hcop hg source pool + (fun x : MarkedSecondSource ι Jo 0 => secondInheritedProfile p x Ψ m z) + (fun x : MarkedSecondSource ι Jo 0 => w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ ω₁ ω₂ Φ U G E V B X Y L + hG hE hV hB hX density hDensity hsep hn hω₁ hω₂ hcut + calc + _ = ((Y:ℂ)*secondRayCoefficient z) * ((Real.exp (-6*L):ℂ)* + ∑ x ∈ source,(w x*actualSecondSignedWeight p hp hcop hg Ψ + (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x) * + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ m z) + slots₁ slots₂ (lists₁ x) (lists₂ x) a₁ a₂ W₁ W₂ Φ Y (G*V*X)) := by ring + _ = _ := by + rw [he] + rw [←mul_assoc] + apply congrArg (fun a : ℂ => ((Y:ℂ)*secondRayCoefficient z*((E*V*X:ℝ):ℂ)⁻¹)*a) + apply integral_congr_ae + filter_upwards with t + apply congrArg (fun a : ℂ => density t*a) + exact hsector pool Ψ m z slots₁ slots₂ lists₁ lists₂ a₁ a₂ ω₁ ω₂ G E V B X t _ + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingSupported.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingSupported.lean new file mode 100644 index 0000000000000000000000000000000000000000..d26a0243a36ad9d605a7fe6f7cd878d02260b6d1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondVaryingSupported.lean @@ -0,0 +1,95 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondVaryingLists +import OAI.NumberTheory.DirichletL.Descent.SecondPuncture + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +theorem actual_second_supported_varying_lists_energy + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (u v : Eisˣ) (source : Finset (MarkedSecondSource ι Jo 0)) + (hs : ActualSecondSourceConditions p source) + (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m : MarkedSecondSource ι Jo 0 → Eis) (z : SecondRayIndex) + (J₁ J₂ : Finset σ) (base₁ base₂ : σ → Finset ι) + (L₁ L₂ : MarkedSecondSource ι Jo 0→σ→Finset ι) + (hL₁ : ∀ x∈source,∀ i∈J₁,L₁ x i⊆base₁ i) + (hL₂ : ∀ x∈source,∀ i∈J₂,L₂ x i⊆base₂ i) (a₁ a₂ : σ → ι → ℂ) + (ha₁ : ∀ i ∈ J₁, ∀ q ∈ base₁ i, ‖a₁ i q‖ ≤ 1) + (ha₂ : ∀ i ∈ J₂, ∀ q ∈ base₂ i, ‖a₂ i q‖ ≤ 1) + (labels : Finset (Ideal Eis)) (rows : Finset Eis) + (hchild : ∀ x ∈ source, (actualSecondChild p u v x).2.1 ∈ labels ∧ + (actualSecondChild p u v x).2.2 ∈ rows) + (K : ℕ) (ho : Jo ≤ 2*K) (hJ₁ : J₁.card ≤ K) (hJ₂ : J₂.card ≤ K) + (phase : MarkedSecondSource ι Jo 0 → ℂ) (hphase : ∀ x ∈ source, ‖phase x‖ ≤ 1) + (F G : SecondChild → ℂ) : + ‖∑ x ∈ source, (actualSecondSignedWeight p hp hcop hg Ψ (m x) z x * phase x) * + (star (primeMark J₁ (L₁ x) a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ (L₂ x) a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))‖ ≤ + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (varyingAssignedSource + source J₁ J₂ base₁ base₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows F γ) * + Real.sqrt (∑ γ ∈ actualSecondTriples p u v (varyingAssignedSource + source J₁ J₂ base₁ base₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows G γ) := by + let S := source.filter (fun x => actualSecondSignedWeight p hp hcop hg Ψ (m x) z x ≠ 0) + have hsub : S ⊆ source := Finset.filter_subset _ _ + have he : (∑ x ∈ source, (actualSecondSignedWeight p hp hcop hg Ψ (m x) z x * phase x) * + (star (primeMark J₁ (L₁ x) a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ (L₂ x) a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x))) = + ∑ x ∈ S, (actualSecondSignedWeight p hp hcop hg Ψ (m x) z x * phase x) * + (star (primeMark J₁ (L₁ x) a₁ (x.second.sourceCommon∪x.second.overlap)) * + primeMark J₂ (L₂ x) a₂ (x.second.sourceCommon∪x.second.overlap)) * + F (actualSecondChild p u v x) * star (G (actualSecondChild p u v x)) := by + symm + apply Finset.sum_subset hsub + intro x hx hnx + have hz : actualSecondSignedWeight p hp hcop hg Ψ (m x) z x = 0 := by + by_contra hh + exact hnx (Finset.mem_filter.mpr ⟨hx,hh⟩) + simp only [hz,zero_mul] + rw [he] + have hb := actual_second_varying_lists_weighted_count p hp hpr hcop hinj u v S + (hs.mono p hsub) J₁ J₂ base₁ base₂ L₁ L₂ + (fun x hx=>hL₁ x (hsub hx)) (fun x hx=>hL₂ x (hsub hx)) a₁ a₂ ha₁ ha₂ (labels.filter Squarefree) rows + (by + intro x hx + have hx0 := hsub hx + refine ⟨Finset.mem_filter.mpr ⟨(hchild x hx0).1,?_⟩,(hchild x hx0).2⟩ + exact actual_second_nonzero_weight_squarefree p hp hcop hg Ψ (m x) z x + (hs.common_disjoint x hx0) (hs.second_divisor x hx0) (Finset.mem_filter.mp hx).2 u v) + K ho hJ₁ hJ₂ (fun x => actualSecondSignedWeight p hp hcop hg Ψ (m x) z x*phase x) + (by + intro x hx + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) + (actualSecondSignedWeight_norm_le_one p hp hcop hg hinj hc Ψ hΨ (m x) z x)).trans + (hphase x (hsub hx))) F G + apply hb.trans + have hΓ := actualSecondTriples_mono p u v (varyingAssignedSource_mono hsub J₁ J₂ base₁ base₂ L₁ L₂) + have hsum (P : SecondChild → ℂ) : + (∑ γ ∈ actualSecondTriples p u v (varyingAssignedSource S J₁ J₂ base₁ base₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows P γ) ≤ + ∑ γ ∈ actualSecondTriples p u v (varyingAssignedSource source J₁ J₂ base₁ base₂ L₁ L₂), + tripleDivisorWeight K γ * secondLabelEnergy K (labels.filter Squarefree) rows P γ := by + apply Finset.sum_le_sum_of_subset_of_nonneg hΓ + intro γ _ _ + exact mul_nonneg (tripleDivisorWeight_nonneg K γ) (secondLabelEnergy_nonneg _ _ _ _ _) + exact mul_le_mul (Real.sqrt_le_sqrt (hsum F)) (Real.sqrt_le_sqrt (hsum G)) + (Real.sqrt_nonneg _) (Real.sqrt_nonneg _) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondWeights.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..ebbef942e1a11e1db5f04a1112ad601dd0ec4f5a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWeights.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSourceProfile + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + +def secondSignedSourceWeight (Ψ : Eis →* ℂ) (m c d : Eis) (z : SecondRayIndex) + (x : SecondExpansionData ι) : ℂ := + (‖secondInputCoefficient p hg Ψ m c d (fun _ => 1) x.sourceCommon‖^2 : ℝ) * + (UniqueFactorizationMonoid.moebius (∏ i ∈ x.divisor, Ideal.span {p i}) : ℂ) * + secondCommonWeight p hp hcop hg (secondRayMinus Ψ z) (secondRayPlus Ψ z) + m (secondExpansionQuotient p x) c d (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) + x.frequency (-x.frequency) x.overlap + +theorem expansionProfileWeight_eq_signed (Ψ : Eis →* ℂ) (m c d : Eis) + (z : SecondRayIndex) (Y : ℝ) (x : SecondExpansionData ι) : + expansionProfileWeight p hp hcop hg Ψ m c d z Y x = + (Y : ℂ)*secondRayCoefficient z*secondSignedSourceWeight p hp hcop hg Ψ m c d z x := by + simp only [expansionProfileWeight,secondSignedSourceWeight,secondTotalWeight] + ring + +theorem secondSignedSourceWeight_norm_le_one + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + (Ψ : Eis →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (m c d : Eis) (z : SecondRayIndex) + (x : SecondExpansionData ι) : + ‖secondSignedSourceWeight p hp hcop hg Ψ m c d z x‖ ≤ 1 := by + have hinput : ‖secondInputCoefficient p hg Ψ m c d (fun _ => 1) x.sourceCommon‖^2 ≤ 1 := by + simpa only [one_pow] using pow_le_pow_left₀ (norm_nonneg _) + ((secondInputCoefficient_norm_le p hg Ψ m c d x.sourceCommon).trans (hΨ _)) 2 + have hμ := QuadraticInitialBound.norm_ideal_moebius_le_one + (∏ i ∈ x.divisor,Ideal.span {p i}) + have hcommon := secondCommonWeight_norm_le p hp hcop hg hinj hc + (secondRayMinus Ψ z) (secondRayPlus Ψ z) m (secondExpansionQuotient p x) c d + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) x.frequency (-x.frequency) x.overlap + have hc1 : ‖secondCommonWeight p hp hcop hg (secondRayMinus Ψ z) (secondRayPlus Ψ z) + m (secondExpansionQuotient p x) c d (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) + x.frequency (-x.frequency) x.overlap‖ ≤ 1 := by + apply hcommon.trans + exact (mul_le_of_le_one_left (norm_nonneg _) + ((secondRayMinus_norm_le Ψ z _).trans (hΨ _))).trans + ((secondRayPlus_norm_le Ψ z _).trans (hΨ _)) + simp only [secondSignedSourceWeight,norm_mul,Complex.norm_real,Real.norm_eq_abs] + rw [abs_of_nonneg (sq_nonneg (‖secondInputCoefficient p hg Ψ m c d (fun _ => 1) x.sourceCommon‖))] + exact (mul_le_of_le_one_left (norm_nonneg _) + ((mul_le_of_le_one_left (norm_nonneg _) hinput).trans hμ)).trans hc1 + +theorem secondExpansionSource_signed_profile + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i - 1) + (F : Finset ι) (Ψ : Eis →* ℂ) (m c d : Eis) (z : SecondRayIndex) + (source : Finset (SecondExpansionData ι)) (hE : ∀ x ∈ source, x.divisor ⊆ x.sourceCommon) + (A₁ A₂ : Finset ι) (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) + (a₁ a₂ : σ → ι → ℂ) (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (X Y : ℝ) : + secondExpansionSource p hp hcop hg F Ψ m c d z source + (fun U => primeMark slots₁ lists₁ a₁ (A₁ ∪ U) * W₁ (primeProductNorm p U/X)) + (fun U => primeMark slots₂ lists₂ a₂ (A₂ ∪ U) * W₂ (primeProductNorm p U/X)) Φ Y = + (Y : ℂ)*secondRayCoefficient z * + ∑ x ∈ source, secondSignedSourceWeight p hp hcop hg Ψ m c d z x * + actualSecondProfileRow p hp hcop hg F (expansionProfileData p Ψ m c d z A₁ A₂ x) + slots₁ slots₂ lists₁ lists₂ a₁ a₂ W₁ W₂ Φ Y X := by + rw [secondExpansionSource_marked_profile p hp hcop hg hinj hpr (hE := hE)] + simp only [expansionProfileWeight_eq_signed,Finset.mul_sum,mul_assoc] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeCutoff.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..e942865f258efccdad69495f9fb035e1a173fb4f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeCutoff.lean @@ -0,0 +1,97 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondWholeTail + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstCauchyArithmetic CompletedGauss FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem second_whole_column_denominator {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] (G E S T : Finset ι) + (hEG : E ⊆ G) (hGS : Disjoint G S) (hGT : Disjoint G T) + (L : ℝ) (hL : 0 ≤ L) + (hS : primeProductNorm p (G ∪ S) ≤ L) + (hT : primeProductNorm p (G ∪ T) ≤ L) : + (primeProductNorm p E)^2 * (primeProductNorm p S * primeProductNorm p T) ≤ L^2 := by + have hE := primeProductNorm_mono p hp hEG + have hE0 := (primeProductNorm_pos p hp E).le + have hS0 := (primeProductNorm_pos p hp S).le + have hT0 := (primeProductNorm_pos p hp T).le + rw [primeProductNorm_union p G S hGS] at hS + rw [primeProductNorm_union p G T hGT] at hT + calc + _ ≤ (primeProductNorm p G)^2 * (primeProductNorm p S * primeProductNorm p T) := + mul_le_mul_of_nonneg_right (pow_le_pow_left₀ hE0 hE 2) (mul_nonneg hS0 hT0) + _ = (primeProductNorm p G * primeProductNorm p S) * + (primeProductNorm p G * primeProductNorm p T) := by ring + _ ≤ L*L := mul_le_mul hS hT (mul_nonneg (primeProductNorm_pos p hp G).le hT0) hL + _ = _ := by ring + +def wholeSecondRadius (d : O) (L Y H : ℝ) : ℝ := ‖eisEmbedding d‖^2 * L^2 * H / Y + +theorem full_second_whole_column_tail (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (Ct : ℝ), 0 < Ct ∧ + ∀ {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) + (F : Finset ι) (Ψ : O →* ℂ) (_hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (_hd : d ≠ 0) (Hcol : Finset ι → ℂ) (W : 𝓢(ℝ, ℂ)) + (B Y H L R : ℝ), 0 ≤ B → 0 < Y → 0 ≤ H → 1 ≤ L → + (∀ U, ‖Hcol U‖ ≤ B) → + (∀ U, Hcol U ≠ 0 → primeProductNorm p U ≤ L) → + wholeSecondRadius d L Y H ≤ R → + ‖secondSourceTail p hp hg hinj F Ψ m c d Hcol W Y + (fun _ E => childFrequencyBall + (d*primeSubsetGenerator (fun i => Ideal.span {p i}) E) R)‖ ≤ + (128*L)^4 * (B^2 * + (Y*(Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)* + (1+L^3/Y)^2/(1+H)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_second_supported_tail order + refine ⟨s,Ct,hCt,?_⟩ + intro ι _ p hp _ hg hinj hc F Ψ hΨ m c d hd Hcol W B Y H L R hB hY hH hL hcol hsupp hR + apply htail p hp hg hinj hc F Ψ hΨ m c d Hcol W B Y H L hB hY hH hL hcol hsupp + intro G hG E S hS T hT hST hw k hk + obtain ⟨hGS,hGT⟩ := residualPairWeight_test_ne_zero p hg Ψ Ψ m c d _ _ S T hw + have hdGS : Disjoint G S := Finset.disjoint_left.mpr (by + intro i hiG hiS + exact (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hS) hiS)).2 hiG) + have hdGT : Disjoint G T := Finset.disjoint_left.mpr (by + intro i hiG hiT + exact (Finset.mem_sdiff.mp ((Finset.mem_powerset.mp hT) hiT)).2 hiG) + have hden := second_whole_column_denominator p hp G E.val S T + (Finset.mem_powerset.mp E.property) hdGS hdGT L (zero_le_one.trans hL) + (hsupp _ hGS) (hsupp _ hGT) + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) E.val + have he : e ≠ 0 := primeSubsetGenerator_ne_zero _ _ + have hde := mul_ne_zero hd he + have hdN : 0 < ‖eisEmbedding d‖^2 := SecondPassIntegration.elementNorm_pos d hd + have heN : 0 < ‖eisEmbedding e‖^2 := SecondPassIntegration.elementNorm_pos e he + have henorm : ‖eisEmbedding e‖^2 = primeProductNorm p E.val := + primeSubsetGenerator_norm_eq_productNorm p E.val + have hkR := (outside_childFrequencyBall (d*e) hde R k hk).le + have hR' : ‖eisEmbedding d‖^2 * L^2 * H ≤ + Y * (‖eisEmbedding d‖^2 * ‖eisEmbedding e‖^2 * ‖eisEmbedding k‖^2) := by + have hh := (div_le_iff₀ hY).mp hR + have hh' := mul_le_mul_of_nonneg_right hkR hY.le + simp only [map_mul,norm_mul,mul_pow] at hh' + nlinarith + have hbound : H * (‖eisEmbedding e‖^2 * + (primeProductNorm p S * primeProductNorm p T)) ≤ Y*‖eisEmbedding k‖^2 := by + apply (mul_le_mul_iff_right₀ (mul_pos hdN heN)).mp + have hh := mul_le_mul_of_nonneg_left hden (mul_nonneg hdN.le hH) + rw [←henorm] at hh + nlinarith [hh,hR'] + rw [active_norm_sq_disjoint p S T hST,div_mul_eq_mul_div] + apply (le_div_iff₀ (mul_pos heN (mul_pos (primeProductNorm_pos p hp S) + (primeProductNorm_pos p hp T)))).mpr + exact hbound + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeKernel.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeKernel.lean new file mode 100644 index 0000000000000000000000000000000000000000..a6b2b9104afd6b0082e2313e846f20fe108bf2d1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeKernel.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondProfileIdentity + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +lemma secondSourcePairKernel_mark_factors {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (e k : Eis) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (A₁ A₂ : Finset ι) (H₁ H₂ : Finset ι → ℂ) (W : 𝓢(ℝ,ℂ)) (Y : ℝ) (S T : Finset ι) : + secondSourcePairKernel p e k + (fun U => primeMark slots₁ lists₁ a₁ (A₁ ∪ U)*H₁ U) + (fun U => primeMark slots₂ lists₂ a₂ (A₂ ∪ U)*H₂ U) W Y S T = + star (primeMark slots₁ lists₁ a₁ (A₁ ∪ S)) * primeMark slots₂ lists₂ a₂ (A₂ ∪ T) * + secondSourcePairKernel p e k H₁ H₂ W Y S T := by + simp only [secondSourcePairKernel,star_mul] + ring + +theorem secondChildKernelPair_whole_profile {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (F G V A₁ A₂ : Finset ι) (Ψ₁ Ψ₂ : Eis →* ℂ) (m r c d e k : Eis) + (slots₁ slots₂ : Finset σ) (lists₁ lists₂ : σ → Finset ι) (a₁ a₂ : σ → ι → ℂ) + (W₁ W₂ : ℝ → ℂ) (Φ : 𝓢(ℝ,ℂ)) (Y : ℝ) : + (‖eisEmbedding e‖^2 : ℂ)⁻¹ * secondChildKernelPair p hp hcop hg F V Ψ₁ Ψ₂ + m r c d e k (-k) + (secondSourcePairKernel p e k + (fun U => primeMark slots₁ lists₁ a₁ (A₁ ∪ U)*W₁ (primeProductNorm p G*primeProductNorm p U)) + (fun U => primeMark slots₂ lists₂ a₂ (A₂ ∪ U)*W₂ (primeProductNorm p G*primeProductNorm p U)) Φ Y) = + ∑ N ∈ (F \ V).powerset, ∑ M ∈ (F \ V).powerset, + (star (secondChildColumn p hp hcop hg Ψ₁ (m*r) (c*e*∏ i ∈ V,p i) + (d*e*k) (fun _ => 1) N) * + secondChildColumn p hp hcop hg Ψ₂ (m*r) (c*e*∏ i ∈ V,p i) + (d*e*(-k)) (fun _ => 1) M) * + (star (primeMark slots₁ lists₁ a₁ (A₁ ∪ (V ∪ N))) * + primeMark slots₂ lists₂ a₂ (A₂ ∪ (V ∪ M))) * + secondNormProfile (fun x => star (W₁ x)) W₂ Φ (fun _ _ => 1) Y + ![primeProductNorm p G,‖eisEmbedding e‖^2,primeProductNorm p V, + ‖eisEmbedding k‖^2,primeProductNorm p N,primeProductNorm p M] := by + unfold secondChildKernelPair + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro N hN + apply Finset.sum_congr rfl + intro M hM + have hVN : Disjoint V N := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hN) disjoint_sdiff_self_right + have hVM : Disjoint V M := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hM) disjoint_sdiff_self_right + rw [secondSourcePairKernel_mark_factors] + have hp := secondSourcePairKernel_profile p hp G V N M hVN hVM e k W₁ W₂ Φ Y + rw [← hp] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..017fb9f7614a649763b16d179f5566a99c9e2aa3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeMass.lean @@ -0,0 +1,47 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSupportedEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open InverseSecondFibers +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] + (p : ι → Eis) [∀ i,(Ideal.span {p i}).IsMaximal] + +theorem actualSecondChild_outer_units {Jo Jn : ℕ} (u v : Eisˣ) + (x : MarkedSecondSource ι Jo Jn) : + (actualSecondChild p u v x).1 = (actualSecondChild p 1 1 x).1 := rfl + +theorem actualSecondChild_label_units {Jo Jn : ℕ} (u v : Eisˣ) + (x : MarkedSecondSource ι Jo Jn) : + (actualSecondChild p u v x).2.1 = (actualSecondChild p 1 1 x).2.1 := rfl + +theorem actualSecondTriples_units {Jo Jn : ℕ} (u v : Eisˣ) + (source : Finset (MarkedSecondSource ι Jo Jn)) : + actualSecondTriples p u v source = actualSecondTriples p 1 1 source := rfl + +theorem assigned_second_triples_subset {Jo : ℕ} (u v : Eisˣ) + (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) : + actualSecondTriples p u v (assignedSecondSource source J₁ J₂ L₁ L₂) ⊆ + actualSecondTriples p 1 1 source := by + intro γ hγ + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hγ + obtain ⟨y,hy,q₁,hq₁,q₂,hq₂,rfl⟩ := (mem_assignedSecondSource source J₁ J₂ L₁ L₂ x).mp hx + exact Finset.mem_image.mpr ⟨y,hy,rfl⟩ + +theorem assigned_second_mass_le_original {Jo : ℕ} (u v : Eisˣ) + (source : Finset (MarkedSecondSource ι Jo 0)) + (J₁ J₂ : Finset σ) (L₁ L₂ : σ → Finset ι) (K : ℕ) : + (∑ γ∈actualSecondTriples p u v (assignedSecondSource source J₁ J₂ L₁ L₂),tripleDivisorWeight K γ) ≤ + ∑ γ∈actualSecondTriples p 1 1 source,tripleDivisorWeight K γ := by + exact Finset.sum_le_sum_of_subset_of_nonneg + (assigned_second_triples_subset p u v source J₁ J₂ L₁ L₂) + (fun γ _ _ => tripleDivisorWeight_nonneg K γ) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeTail.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..0109720803c47903a9b72b9f83cf6be8da686b61 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SecondWholeTail.lean @@ -0,0 +1,103 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondTailCost +import OAI.NumberTheory.DirichletL.Descent.ChildCutoff + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap +open ActualEisensteinCubic FirstCauchyArithmetic CompletedGauss FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O + +theorem full_second_supported_tail (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (Ct : ℝ), 0 < Ct ∧ + ∀ {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) + (F : Finset ι) (Ψ : O →* ℂ) (_hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (Hcol : Finset ι → ℂ) (W : 𝓢(ℝ, ℂ)) + (B Y H lengthScale : ℝ), 0 ≤ B → 0 < Y → 0 ≤ H → 1 ≤ lengthScale → + (∀ U, ‖Hcol U‖ ≤ B) → + (∀ U, Hcol U ≠ 0 → primeProductNorm p U ≤ lengthScale) → + ∀ K : Finset ι → Finset ι → Finset O, + (∀ G ∈ F.powerset, ∀ E : G.powerset, + ∀ S ∈ (F\G).powerset, ∀ T ∈ (F\G).powerset, Disjoint S T → + residualPairWeight p hg Ψ Ψ m c d (fun U => Hcol (G∪U)) (fun U => Hcol (G∪U)) S T ≠ 0 → + ∀ k : O, k ∉ K G E.val → + H ≤ (Y / (‖eisEmbedding (primeSubsetGenerator (fun i => Ideal.span {p i}) E.val)‖^2 * + ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2)) * ‖eisEmbedding k‖^2) → + ‖secondSourceTail p hp hg hinj F Ψ m c d Hcol W Y K‖ ≤ + (128*lengthScale)^4 * (B^2 * + (Y*(Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)* + (1+lengthScale^3/Y)^2/(1+H)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_uniform_secondSourceTail_bound order + refine ⟨s,Ct,hCt,?_⟩ + intro ι _ p hp _ hg hinj hc F Ψ hΨ m c d Hcol W B Y H lengthScale hB hY hH hL hcol hsupp K hK + exact (htail p hp hg hinj hc F Ψ m c d Hcol W Y H hY hH K hK).trans + (secondSourceTailCost_bounded_test p hp hg hinj F Ψ hΨ m c d Hcol B Y H lengthScale + (Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) order hB hY hH (by positivity) hL hcol hsupp) + +def supportedSecondRadius (d : O) (lengthScale Y H : ℝ) : ℝ := + childOuterRadius Y (‖eisEmbedding d‖^2 * lengthScale) lengthScale lengthScale lengthScale H + +lemma supportedSecondRadius_eq (d : O) (lengthScale Y H : ℝ) : + supportedSecondRadius d lengthScale Y H = ‖eisEmbedding d‖^2 * lengthScale^4 * H / Y := by + unfold supportedSecondRadius childOuterRadius + ring + +theorem full_second_child_supported_tail (order : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (Ct : ℝ), 0 < Ct ∧ + ∀ {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) + (F : Finset ι) (Ψ : O →* ℂ) (_hΨ : ∀ a, ‖Ψ a‖ ≤ 1) + (m c d : O) (_hd : d ≠ 0) (Hcol : Finset ι → ℂ) (W : 𝓢(ℝ, ℂ)) + (B Y H lengthScale R : ℝ), 0 ≤ B → 0 < Y → 0 ≤ H → 1 ≤ lengthScale → + (∀ U, ‖Hcol U‖ ≤ B) → + (∀ U, Hcol U ≠ 0 → primeProductNorm p U ≤ lengthScale) → + supportedSecondRadius d lengthScale Y H ≤ R → + ‖secondSourceTail p hp hg hinj F Ψ m c d Hcol W Y + (fun _ E => childFrequencyBall + (d*primeSubsetGenerator (fun i => Ideal.span {p i}) E) R)‖ ≤ + (128*lengthScale)^4 * (B^2 * + (Y*(Ct*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W)* + (1+lengthScale^3/Y)^2/(1+H)^order)) := by + obtain ⟨s,Ct,hCt,htail⟩ := full_second_supported_tail order + refine ⟨s,Ct,hCt,?_⟩ + intro ι _ p hp _ hg hinj hc F Ψ hΨ m c d hd Hcol W B Y H lengthScale R hB hY hH hL hcol hsupp hR + apply htail p hp hg hinj hc F Ψ hΨ m c d Hcol W B Y H lengthScale hB hY hH hL hcol hsupp + intro G hG E S hS T hT hST hw k hk + obtain ⟨hGS,hGT⟩ := residualPairWeight_test_ne_zero p hg Ψ Ψ m c d _ _ S T hw + have hGS' := hsupp (G ∪ S) hGS + have hGT' := hsupp (G ∪ T) hGT + have hGn := (primeProductNorm_mono p hp Finset.subset_union_left).trans hGS' + have hEn := (primeProductNorm_mono p hp (Finset.mem_powerset.mp E.property)).trans hGn + have hSn := (primeProductNorm_mono p hp Finset.subset_union_right).trans hGS' + have hTn := (primeProductNorm_mono p hp Finset.subset_union_right).trans hGT' + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) E.val + have he : e ≠ 0 := primeSubsetGenerator_ne_zero _ _ + have hde : d*e ≠ 0 := mul_ne_zero hd he + have hdN : 0 < ‖eisEmbedding d‖^2 := SecondPassIntegration.elementNorm_pos d hd + have hL0 : 0 < lengthScale := lt_of_lt_of_le zero_lt_one hL + have heN : ‖eisEmbedding e‖^2 ≤ lengthScale := by + simpa only [e,primeSubsetGenerator_norm_eq_productNorm] using hEn + have hdeN : ‖eisEmbedding (d*e)‖^2 ≤ ‖eisEmbedding d‖^2 * lengthScale := by + simp only [map_mul,norm_mul,mul_pow] + exact mul_le_mul_of_nonneg_left heN (sq_nonneg _) + apply childFrequencyBall_raw_tail p hp Y (‖eisEmbedding d‖^2*lengthScale) + lengthScale lengthScale lengthScale H hY (mul_pos hdN hL0) hL0 hL0 hL0 hH + (d*e) e hde he hdeN heN S T hST hSn hTn k + intro hsmall + apply hk + apply (mem_childFrequencyBall (d*e) hde R k).mpr + exact ((mem_childFrequencyBall (d*e) hde _ k).mp hsmall).trans hR + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Sharp.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Sharp.lean new file mode 100644 index 0000000000000000000000000000000000000000..9b2bb5fbabd594ef3c7cf6dfe05c65d62edf62f3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Sharp.lean @@ -0,0 +1,107 @@ +import OAI.NumberTheory.DirichletL.Descent.HybridBound +import OAI.NumberTheory.DirichletL.CubicSieve.Sharp + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +theorem hybrid_sharp_cubic_factor (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → 1 ≤ L → + (K * N * B) ^ (ε / 2) * CubicSieve.sieveNorm N (2 * L) ≤ + C * (K * N * B * L) ^ ε * (N + L + (N * L) ^ (2 / 3 : ℝ)) := by + obtain ⟨C, hC, hb⟩ := CubicSieve.sieveNorm_sharp (ε / 2) (by positivity) + refine ⟨2 * C * (2 : ℝ) ^ (ε / 2), by positivity, ?_⟩ + intro K N B L hK hN hB hL + have hK0 : 0 < K := by linarith + have hN0 : 0 < N := by linarith + have hB0 : 0 < B := by linarith + have hL0 : 0 < L := by linarith + let Q := K * N * B * L + have hQ0 : 0 < Q := by dsimp only [Q]; positivity + have hKNB : K * N * B ≤ Q := le_mul_of_one_le_right (by positivity) hL + have hNL : N * L ≤ Q := by + have hKB : 1 ≤ K * B := one_le_mul_of_one_le_of_one_le hK hB + have hh := le_mul_of_one_le_left (by positivity : 0 ≤ N * L) hKB + convert hh using 1 ; dsimp only [Q] ; ring + have hdouble (t : ℝ) : (N * (2 * L)) ^ t = (2 : ℝ) ^ t * (N * L) ^ t := by + rw [show N * (2 * L) = 2 * (N * L) by ring, Real.mul_rpow (by norm_num) (by positivity)] + have h23 : (2 : ℝ) ^ (2 / 3 : ℝ) ≤ 2 := by + calc + _ ≤ (2 : ℝ) ^ (1 : ℝ) := Real.rpow_le_rpow_of_exponent_le (by norm_num) (by norm_num) + _ = 2 := Real.rpow_one _ + have hshape : N + 2 * L + (N * (2 * L)) ^ (2 / 3 : ℝ) ≤ + 2 * (N + L + (N * L) ^ (2 / 3 : ℝ)) := by + rw [hdouble] + have hh := mul_le_mul_of_nonneg_right h23 (Real.rpow_nonneg (by positivity : 0 ≤ N * L) (2 / 3 : ℝ)) + linarith + have hcost : (K * N * B) ^ (ε / 2) * (N * L) ^ (ε / 2) ≤ Q ^ ε := by + calc + _ ≤ Q ^ (ε / 2) * Q ^ (ε / 2) := by + exact mul_le_mul (Real.rpow_le_rpow (by positivity) hKNB (by positivity)) + (Real.rpow_le_rpow (by positivity) hNL (by positivity)) + (Real.rpow_nonneg (by positivity) _) (Real.rpow_nonneg hQ0.le _) + _ = _ := by rw [← Real.rpow_add hQ0]; congr 1; ring + have hh := hb N (2 * L) hN (by linarith) + calc + _ ≤ (K * N * B) ^ (ε / 2) * + (C * (N * (2 * L)) ^ (ε / 2) * (N + 2 * L + (N * (2 * L)) ^ (2 / 3 : ℝ))) := + mul_le_mul_of_nonneg_left hh (Real.rpow_nonneg (by positivity) _) + _ ≤ (K * N * B) ^ (ε / 2) * + (C * (N * (2 * L)) ^ (ε / 2) * (2 * (N + L + (N * L) ^ (2 / 3 : ℝ)))) := by + gcongr + _ = (2 * C * (2 : ℝ) ^ (ε / 2)) * + ((K * N * B) ^ (ε / 2) * (N * L) ^ (ε / 2)) * (N + L + (N * L) ^ (2 / 3 : ℝ)) := by + rw [hdouble] + ring + _ ≤ _ := by gcongr + +theorem supportedHybridRow_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → 1 ≤ L → + ∀ (rows : Finset (Ideal Eis)) (S : Finset (Ideal Eis × Ideal Eis)) + (Pset : Finset (Ideal Eis)) (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ S, Squarefree p.1 ∧ primaryGenerator p.1 ≠ 0 ∧ primaryGenerator p.2 ≠ 0 ∧ + (Ideal.absNorm p.1 : ℝ) ≤ N ∧ (Ideal.absNorm p.2 : ℝ) ≤ B) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → (∀ p ∈ S, ‖beta p.1 p.2‖ ≤ 1) → + (∑ k ∈ rows, ‖supportedHybridRow S Pset a beta k‖ ^ 2) ≤ + C * (K * N * B * L) ^ ε * (K + N * B) * B * (N + L + (N * L) ^ (2 / 3 : ℝ)) := by + obtain ⟨C0, hC0, he⟩ := supportedHybridRow_energy_sieve_norm (ε / 2) (by positivity) + obtain ⟨C1, hC1, hc⟩ := hybrid_sharp_cubic_factor ε hε + refine ⟨C0 * C1, mul_pos hC0 hC1, ?_⟩ + intro K N B L hK hN hB hL rows S Pset a beta hrows hS hP ha hbeta + apply (he K N B L hK hN hB rows S Pset a beta hrows hS hP ha hbeta).trans + have hh := mul_le_mul_of_nonneg_left (hc K N B L hK hN hB hL) + (show 0 ≤ C0 * (K + N * B) * B by positivity) + convert hh using 1 <;> ring + +theorem hybridRow_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → 1 ≤ L → + ∀ (rows nset bset Pset : Finset (Ideal Eis)) + (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ b ∈ bset, primaryGenerator b ≠ 0 ∧ (Ideal.absNorm b : ℝ) ≤ B) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → (∀ n ∈ nset, ∀ b ∈ bset, ‖beta n b‖ ≤ 1) → + (∑ k ∈ rows, ‖hybridRow Pset nset bset a beta k‖ ^ 2) ≤ + C * (K * N * B * L) ^ ε * (K + N * B) * B * (N + L + (N * L) ^ (2 / 3 : ℝ)) := by + obtain ⟨C0, hC0, he⟩ := hybridRow_energy_sieve_norm (ε / 2) (by positivity) + obtain ⟨C1, hC1, hc⟩ := hybrid_sharp_cubic_factor ε hε + refine ⟨C0 * C1, mul_pos hC0 hC1, ?_⟩ + intro K N B L hK hN hB hL rows nset bset Pset a beta hrows hn hb hP ha hbeta + apply (he K N B L hK hN hB rows nset bset Pset a beta hrows hn hb hP ha hbeta).trans + have hh := mul_le_mul_of_nonneg_left (hc K N B L hK hN hB hL) + (show 0 ≤ C0 * (K + N * B) * B by positivity) + convert hh using 1 <;> ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ShortCompletionEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ShortCompletionEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e0266e9f34897cea0a53e10700620813b079d2d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ShortCompletionEnergy.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Descent.ReopenedBins + +namespace OAI + +namespace SevenEighths.InverseMoment +noncomputable section +open scoped BigOperators Classical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ConcretePrimeRowBridge CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O + +theorem markedShortCompletedSum_eq (Ψ : O →* ℂ) (W : ℝ → ℂ) (X H₀ : ℝ) (mark : Ideal O→ℂ) : + markedShortCompletedSum Ψ W X H₀ mark = ∑H∈shortCubeRange H₀, + (UniqueFactorizationMonoid.moebius H:ℂ)*cubeWeight Ψ H* + markedCompletedT Ψ W (X/(Ideal.absNorm H:ℝ)^3) (fun I=>mark (H^3*I)) := by + unfold markedShortCompletedSum + rw [tsum_eq_sum (s:=shortCubeRange H₀)] + · exact Finset.sum_congr rfl (fun H hH => ite_eq_left ((mem_shortCubeRange H₀ H).mp hH).2) + · intro H hH + by_cases hz : H=0 + · simp [hz] + · have hn : ¬(Ideal.absNorm H:ℝ) hH ((mem_shortCubeRange H₀ H).mpr ⟨hz,hn⟩) + exact ite_eq_right hn + +theorem marked_short_completed_energy {κ : Type*} [Fintype κ] + (Ψ : κ → O →* ℂ) (hΨ : ∀k z,‖Ψ k z‖≤1) + (mark : κ→Ideal O→ℂ) (W : ℝ → ℂ) (X H₀ A : ℝ) (hA : 0≤A) + (hcompleted : ∀H∈shortCubeRange H₀, + (∑k,‖markedCompletedT (Ψ k) W (X/(Ideal.absNorm H:ℝ)^3) (fun I=>mark k (H^3*I))‖^2)≤A) : + (∑k,‖markedShortCompletedSum (Ψ k) W X H₀ (mark k)‖^2)≤ + A*(256*(columnDyadicLength H₀+1:ℝ))^2 := by + let S := shortCubeRange H₀ + let lengthScale : ℝ := ∑H∈S,1/(Ideal.absNorm H:ℝ) + have hS (H : Ideal O) (hH : H∈S) : H≠0 := ((mem_shortCubeRange H₀ H).mp hH).1 + have hn (H : Ideal O) (hH : H∈S) : 0<(Ideal.absNorm H:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun hz => hS H hH (Ideal.absNorm_eq_zero_iff.mp hz)) + have hL : 0≤lengthScale := Finset.sum_nonneg (fun H hH => by positivity) + have hb (k : κ) : ‖markedShortCompletedSum (Ψ k) W X H₀ (mark k)‖^2≤ + lengthScale*∑H∈S,(1/(Ideal.absNorm H:ℝ))*‖markedCompletedT (Ψ k) W (X/(Ideal.absNorm H:ℝ)^3) (fun I=>mark k (H^3*I))‖^2 := by + rw [markedShortCompletedSum_eq] + apply (ideal_reciprocal_cauchy S hS _).trans + apply mul_le_mul_of_nonneg_left _ hL + apply Finset.sum_le_sum + intro H hH + rw [norm_mul] + calc + _ ≤ (Ideal.absNorm H:ℝ)*((1/(Ideal.absNorm H:ℝ))*‖markedCompletedT (Ψ k) W (X/(Ideal.absNorm H:ℝ)^3) (fun I=>mark k (H^3*I))‖)^2 := by + gcongr + exact cube_inverse_weight_norm (Ψ k) (hΨ k) H + _ = _ := by field_simp [(hn H hH).ne'] + have hsum : (∑k,‖markedShortCompletedSum (Ψ k) W X H₀ (mark k)‖^2)≤A*lengthScale^2 := by + calc + _ ≤ ∑k,lengthScale*∑H∈S,(1/(Ideal.absNorm H:ℝ))*‖markedCompletedT (Ψ k) W (X/(Ideal.absNorm H:ℝ)^3) (fun I=>mark k (H^3*I))‖^2 := + Finset.sum_le_sum (fun k _ => hb k) + _ = lengthScale*∑H∈S,(1/(Ideal.absNorm H:ℝ))*∑k,‖markedCompletedT (Ψ k) W (X/(Ideal.absNorm H:ℝ)^3) (fun I=>mark k (H^3*I))‖^2 := by + rw [←Finset.mul_sum,Finset.sum_comm] + congr 1 + apply Finset.sum_congr rfl + intro H hH + rw [←Finset.mul_sum] + _ ≤ lengthScale*∑H∈S,(1/(Ideal.absNorm H:ℝ))*A := by + gcongr with H hH + exact hcompleted H hH + _ = A*lengthScale^2 := by rw [←Finset.sum_mul]; change lengthScale*(lengthScale*A)=A*lengthScale^2; ring + have hbound : lengthScale≤256*(columnDyadicLength H₀+1:ℝ) := + finite_inverse_norm_sum S H₀ hS (fun H hH => ((mem_shortCubeRange H₀ H).mp hH).2.le) + exact hsum.trans (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ hL hbound 2) hA) + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ShortReflectedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ShortReflectedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..c62cfec2e73b4799b89b751ca61bbe998b335694 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ShortReflectedEnergy.lean @@ -0,0 +1,113 @@ +import OAI.NumberTheory.DirichletL.Descent.ShortCompletionEnergy +import OAI.NumberTheory.DirichletL.Reflection.CubeCompletedEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open InverseTerminalWidths InverseReflectedPhase CompletedHeight +local notation "Eis"=>ActualEisensteinCubic.O +universe v + +def tupleDivisibilityMark {σ:Type v} [Fintype σ] [DecidableEq σ] + (lists:σ→Finset (Ideal Eis)) (w:∀i,lists i→ℂ) (A:Ideal Eis):ℂ := + ∑p:∀i,lists i,(∏i,w i (p i))*∏i,if (p i).val∣A then (1:ℂ) else 0 + +theorem completed_tuple_mark {σ:Type v} [Fintype σ] [DecidableEq σ] + (lists:σ→Finset (Ideal Eis)) (w:∀i,lists i→ℂ) + (Ψ:Eis→*ℂ) (W:ℝ→ℂ) (hW:HasCompactSupport W) + (X:ℝ) (hX:0tupleDivisibilityMark lists w (H^3*A))= + ∑p:∀i,lists i,(∏i,w i (p i))*markedCompletedT Ψ W X + (fun A=>∏i,if (p i).val∣H^3*A then (1:ℂ) else 0) := by + unfold tupleDivisibilityMark + rw [markedCompletedT_finset_sum Finset.univ Ψ W hW X hX] + simp only [markedCompletedT_const_mul] + +theorem short_cube_exact_scale (Z N:ℝ) (hZ:1hH (Ideal.absNorm_eq_zero_iff.mp hn)) + rw [Real.rpow_sub hz,show 3*Real.logb Z (Ideal.absNorm H:ℝ)=Real.logb Z (Ideal.absNorm H:ℝ)*3 by ring, + show Z^(Real.logb Z (Ideal.absNorm H:ℝ)*3)=(Z^(Real.logb Z (Ideal.absNorm H:ℝ)))^3 from + Real.rpow_mul_natCast hz.le _ 3,Real.rpow_logb hz (ne_of_gt hZ) hn] + +theorem canonical_short_completed_energy (q:ℕ) (hq:q≠0) + (lo hi:ℝ) (hlo:0Disjoint (lists i) (lists j)) → + (∀i,∀P∈lists i,P.IsMaximal) → + (∀i,∀P∈lists i,ConcretePrimeRowBridge.goodLambda∉P) → + (∀i,∀P∈lists i,Prime P) → (∀i,∀P∈lists i,ringChar (Eis⧸P)≠2) → + (∀i,1≤H i) → (∀i,∀P∈lists i,(Ideal.absNorm P:ℝ)≤H i) → (∏i,H i)≤Z^z₀ → + ∀(Ψ:Eis→*ℂ),(∀n,‖Ψ n‖≤1) → + CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ → + ∀(u:Eisˣ)(θ:ℝ)(w:∀i,lists i→ℂ),(∀i P,‖w i P‖≤1) → + (∑I∈parents,‖markedShortCompletedSum + (rowTwist Ψ (ActualFiber.maskElement q m) (ConcretePrimeRowBridge.idealGenerator F) + (u.val*ConcretePrimeRowBridge.idealGenerator I)) (normTwistedSource W θ) + (Z^N) (Z^hcut) (tupleDivisibilityMark lists w)‖^2)≤ + C*(1+‖θ‖)^degree*Z^(N+V-cstar/64)*(256*(columnDyadicLength (Z^hcut)+1:ℝ))^2 := by + obtain ⟨degree,C,Z₀,hC,hZ₀,he⟩:=canonical_cube_shifted_completed_energy q hq lo hi hlo W hWs hW + L cstar eta hL hcstar heta heta1 hetac rmax + refine ⟨degree,C,Z₀,hC,hZ₀,?_⟩ + intro σ _ _ F hF m hm Z N V M z₀ margin hcut d hZ hN hM hMc hVc hzc hcutc hFn hRn + hmargin hreserve hVd hcutd hd parents hparents hcard lists H hdis hmax hgood hprime hodd hH1 hH hprod + Ψ hΨ hperiod u θ w hw + have hZ1:1tupleDivisibilityMark lists w (J^3*A))‖^2)≤ + C*(1+‖θ‖)^degree*Z^(N+V-cstar/64):=by + obtain ⟨hJ0,hJnorm⟩:=(mem_shortCubeRange _ J).mp hJ + have hn:0<(Ideal.absNorm J:ℝ):=by exact_mod_cast Nat.pos_of_ne_zero (fun hn=>hJ0 (Ideal.absNorm_eq_zero_iff.mp hn)) + have hc:Real.logb Z (Ideal.absNorm J:ℝ)≤hcut:= + (Real.logb_le_iff_le_rpow hZ1 hn).mpr hJnorm.le + have hjpow:(Ideal.absNorm J:ℝ)≤Z^(Real.logb Z (Ideal.absNorm J:ℝ)):=by + rw [Real.rpow_logb hz (ne_of_gt hZ1) hn] + have h:=he F hF m hm Z N V M z₀ margin (Real.logb Z (Ideal.absNorm J:ℝ)) d + hZ hN hM hMc hVc hzc (hc.trans hcutc) hFn hRn hmargin hreserve hVd (hc.trans hcutd) hd + parents hparents hcard lists H hdis hmax hgood hprime hodd hH1 hH hprod Ψ hΨ hperiod J hJ0 hjpow u θ w hw + rw [short_cube_exact_scale Z N hZ1 J hJ0] at h + simpa only [completed_tuple_mark lists w _ _ htw _ (div_pos (Real.rpow_pos_of_pos hz _) (pow_pos hn _)) J] using h + have hh:=marked_short_completed_energy + (fun I:parents=>rowTwist Ψ (ActualFiber.maskElement q m) (ConcretePrimeRowBridge.idealGenerator F) + (u.val*ConcretePrimeRowBridge.idealGenerator I.val)) + (fun I n=>rowTwist_norm Ψ hΨ _ _ _ n) (fun _=>tupleDivisibilityMark lists w) + (normTwistedSource W θ) (Z^N) (Z^hcut) (C*(1+‖θ‖)^degree*Z^(N+V-cstar/64)) + (by positivity) (fun J hJ=>by + rw [Finset.sum_coe_sort parents (fun I:Ideal Eis=>‖markedCompletedT + (rowTwist Ψ (ActualFiber.maskElement q m) (ConcretePrimeRowBridge.idealGenerator F) + (u.val*ConcretePrimeRowBridge.idealGenerator I)) (normTwistedSource W θ) + (Z^N/(Ideal.absNorm J:ℝ)^3) (fun A=>tupleDivisibilityMark lists w (J^3*A))‖^2)] + exact hcompleted J hJ) + rw [Finset.sum_coe_sort parents (fun I:Ideal Eis=>‖markedShortCompletedSum + (rowTwist Ψ (ActualFiber.maskElement q m) (ConcretePrimeRowBridge.idealGenerator F) + (u.val*ConcretePrimeRowBridge.idealGenerator I)) (normTwistedSource W θ) + (Z^N) (Z^hcut) (tupleDivisibilityMark lists w)‖^2)] at hh + exact hh + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/ShortReflectedPower.lean b/lean/OAI/NumberTheory/DirichletL/Descent/ShortReflectedPower.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e9d5becdcfaa660b457084a72ea45057991c6f0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/ShortReflectedPower.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Descent.ShortReflectedEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open InverseTerminalWidths InverseReflectedPhase CompletedHeight +local notation "Eis"=>ActualEisensteinCubic.O +universe v + +theorem short_harmonic_small_power (L e:ℝ) (hL:0≤L) (he:0Disjoint (lists i) (lists j)) → + (∀i,∀P∈lists i,P.IsMaximal) → + (∀i,∀P∈lists i,ConcretePrimeRowBridge.goodLambda∉P) → + (∀i,∀P∈lists i,Prime P) → (∀i,∀P∈lists i,ringChar (Eis⧸P)≠2) → + (∀i,1≤H i) → (∀i,∀P∈lists i,(Ideal.absNorm P:ℝ)≤H i) → (∏i,H i)≤Z^z₀ → + ∀(Ψ:Eis→*ℂ),(∀n,‖Ψ n‖≤1) → + CanonicalCoefficientClass.FactorsModulo (CanonicalCoefficientClass.fixedBaseConductor q) Ψ → + ∀(u:Eisˣ)(θ:ℝ)(w:∀i,lists i→ℂ),(∀i P,‖w i P‖≤1) → + (∑I∈parents,‖markedShortCompletedSum + (rowTwist Ψ (ActualFiber.maskElement q m) (ConcretePrimeRowBridge.idealGenerator F) + (u.val*ConcretePrimeRowBridge.idealGenerator I)) (normTwistedSource W θ) + (Z^N) (Z^hcut) (tupleDivisibilityMark lists w)‖^2)≤ + C*(1+‖θ‖)^degree*Z^(N+V-cstar/128) := by + obtain ⟨degree,C,Z₀,hC,hZ₀,he⟩:=canonical_short_completed_energy q hq lo hi hlo W hWs hW + L cstar eta hL hcstar heta heta1 hetac rmax + obtain ⟨B,hB,hbound⟩:=short_harmonic_small_power L (cstar/128) hL (by positivity) + refine ⟨degree,C*B,Z₀,mul_pos hC hB,hZ₀,?_⟩ + intro σ _ _ F hF m hm Z N V M z₀ margin hcut d hZ hN hM hMc hVc hzc hcut0 hcutc hFn hRn + hmargin hreserve hVd hcutd hd parents hparents hcard lists H hdis hmax hgood hprime hodd hH1 hH hprod + Ψ hΨ hperiod u θ w hw + have hz:0 s) (fun _ => b) (fun _ => f) (s.card : ℝ) + (by simp) (by simpa using hb) (by simp) + simpa using h + +theorem bounded_coefficient_sum_sq {C : Type*} [Fintype C] + (b f : C → ℂ) (hb : ∀ c, ‖b c‖ ≤ 1) : + ‖∑ c, b c * f c‖ ^ 2 ≤ (Fintype.card C : ℝ) * ∑ c, ‖f c‖ ^ 2 := by + classical + simpa using bounded_finset_coefficient_sum_sq Finset.univ b f (by simpa using hb) + +theorem positive_triple_enlarge {M H C : Type*} + [DecidableEq M] [DecidableEq H] [DecidableEq C] + (pairs : Finset (M × H)) (cset : M → Finset C) + (hs : Finset H) (mc : Finset (M × C)) (E : H → M → C → ℝ) + (hh : ∀ p ∈ pairs, p.2 ∈ hs) + (hm : ∀ p ∈ pairs, ∀ c ∈ cset p.1, (p.1, c) ∈ mc) + (hE : ∀ h m c, 0 ≤ E h m c) : + (∑ p ∈ pairs, ∑ c ∈ cset p.1, E p.2 p.1 c) ≤ + ∑ h ∈ hs, ∑ u ∈ mc, E h u.1 u.2 := by + let f : (Σ _p : M × H, C) → H × (M × C) := fun p => (p.1.2, (p.1.1, p.2)) + have hf : Function.Injective f := by + have hi : Function.LeftInverse + (fun u : H × (M × C) => (⟨(u.2.1, u.1), u.2.2⟩ : Σ _p : M × H, C)) f := by + rintro ⟨⟨m, h⟩, c⟩ + rfl + exact hi.injective + have hmapped : ((pairs.sigma (fun p => cset p.1)).image f) ⊆ hs ×ˢ mc := by + intro u hu + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hu + have hp' := Finset.mem_sigma.mp hp + exact Finset.mem_product.mpr ⟨hh p.1 hp'.1, hm p.1 hp'.1 p.2 hp'.2⟩ + have hb := Finset.sum_le_sum_of_injOn f hf.injOn hmapped + (f := fun p : Σ _p : M × H, C => E p.1.2 p.1.1 p.2) + (g := fun u : H × (M × C) => E u.1 u.2.1 u.2.2) + (by intros; exact le_rfl) (by intro u _ _; exact hE _ _ _) + simpa only [Finset.sum_sigma, Finset.sum_product] using hb + +theorem column_fiber_sieve {K X Y : Type*} [DecidableEq X] [DecidableEq Y] + (rows : Finset K) (source : Finset X) (target : Finset Y) + (φ : X → Y) (q : K → Y → ℂ) (a : X → ℂ) (Q D : ℝ) (hQ : 0 ≤ Q) + (hφ : ∀ x ∈ source, φ x ∈ target) + (hfiber : ∀ y ∈ target, ((source.filter (fun x => φ x = y)).card : ℝ) ≤ D) + (hsieve : ∀ f : Y → ℂ, + (∑ k ∈ rows, ‖∑ y ∈ target, q k y * f y‖ ^ 2) ≤ + Q * ∑ y ∈ target, ‖f y‖ ^ 2) : + (∑ k ∈ rows, ‖∑ x ∈ source, q k (φ x) * a x‖ ^ 2) ≤ + Q * D * ∑ x ∈ source, ‖a x‖ ^ 2 := by + let f : Y → ℂ := fun y => ∑ x ∈ source with φ x = y, a x + have he (k : K) : (∑ x ∈ source, q k (φ x) * a x) = + ∑ y ∈ target, q k y * f y := by + rw [← Finset.sum_fiberwise_of_maps_to hφ] + apply Finset.sum_congr rfl + intro y hy + dsimp only [f] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + rw [(Finset.mem_filter.mp hx).2] + have hf := finite_expansion_energy target source + (fun y => source.filter (fun x => φ x = y)) (fun _ _ => 1) (fun _ => a) D + (fun _ _ => Finset.filter_subset _ _) (by simp) hfiber + have hf' : (∑ y ∈ target, ‖f y‖ ^ 2) ≤ D * ∑ x ∈ source, ‖a x‖ ^ 2 := by + have hrhs : (∑ x ∈ source, ∑ y ∈ target, + if x ∈ source.filter (fun x => φ x = y) then ‖a x‖ ^ 2 else 0) = + ∑ x ∈ source, ‖a x‖ ^ 2 := by + apply Finset.sum_congr rfl + intro x hx + simp [hx, hφ x hx] + rw [hrhs] at hf + simpa only [one_mul, f] using hf + simp_rw [he] + exact (hsieve f).trans (by + calc + _ ≤ Q * (D * ∑ x ∈ source, ‖a x‖ ^ 2) := mul_le_mul_of_nonneg_left hf' hQ + _ = _ := by ring) + +theorem quadratic_cubic_composition + {K M H C P : Type*} [Fintype K] [Fintype M] [Fintype H] [Fintype C] [Fintype P] + (q : K → M → H → ℂ) (χ : M → C → P → ℂ) + (a : H → P → ℂ) (beta : C → M → H → ℂ) (Q S : ℝ) (hQ : 0 ≤ Q) + (hbeta : ∀ c m h, ‖beta c m h‖ ≤ 1) + (hquadratic : ∀ f : M → H → ℂ, + (∑ k, ‖∑ m, ∑ h, q k m h * f m h‖ ^ 2) ≤ Q * ∑ m, ∑ h, ‖f m h‖ ^ 2) + (hcubic : ∀ u : P → ℂ, + (∑ m, ∑ c, ‖∑ p, u p * χ m c p‖ ^ 2) ≤ S * ∑ p, ‖u p‖ ^ 2) : + (∑ k, ‖∑ m, ∑ h, q k m h * + (∑ c, beta c m h * (∑ p, a h p * χ m c p))‖ ^ 2) ≤ + Q * (Fintype.card C : ℝ) * S * ∑ h, ∑ p, ‖a h p‖ ^ 2 := by + classical + apply (hquadratic (fun m h => ∑ c, beta c m h * (∑ p, a h p * χ m c p))).trans + have hcauchy : + (∑ m, ∑ h, ‖∑ c, beta c m h * (∑ p, a h p * χ m c p)‖ ^ 2) ≤ + (Fintype.card C : ℝ) * ∑ h, ∑ m, ∑ c, ‖∑ p, a h p * χ m c p‖ ^ 2 := by + calc + _ ≤ ∑ m, ∑ h, (Fintype.card C : ℝ) * + ∑ c, ‖∑ p, a h p * χ m c p‖ ^ 2 := by + apply Finset.sum_le_sum + intro m _ + apply Finset.sum_le_sum + intro h _ + exact bounded_coefficient_sum_sq _ _ (fun c => hbeta c m h) + _ = _ := by + simp only [← Finset.mul_sum] + congr 1 + exact Finset.sum_comm + have hcs : (∑ h, ∑ m, ∑ c, ‖∑ p, a h p * χ m c p‖ ^ 2) ≤ + S * ∑ h, ∑ p, ‖a h p‖ ^ 2 := by + rw [Finset.mul_sum] + exact Finset.sum_le_sum fun h _ => hcubic (a h) + calc + _ ≤ Q * ((Fintype.card C : ℝ) * + ∑ h, ∑ m, ∑ c, ‖∑ p, a h p * χ m c p‖ ^ 2) := + mul_le_mul_of_nonneg_left hcauchy hQ + _ ≤ Q * ((Fintype.card C : ℝ) * (S * ∑ h, ∑ p, ‖a h p‖ ^ 2)) := + mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left hcs (Nat.cast_nonneg _)) hQ + _ = _ := by ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SlotAssignments.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SlotAssignments.lean new file mode 100644 index 0000000000000000000000000000000000000000..e2d19b76e962b42302e6e3b8af62ed54c67bf94f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SlotAssignments.lean @@ -0,0 +1,58 @@ +import OAI.NumberTheory.DirichletL.Descent.Marks +import Mathlib.Data.Fintype.EquivFin + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +noncomputable section +variable {σ ι : Type*} [DecidableEq σ] [DecidableEq ι] + +def slotAssignmentWeight (I : Finset σ) (a : σ → ι → ℂ) + (q : ∀ i ∈ I, ι) : ℂ := ∏ i ∈ I.attach, a i.val (q i.val i.property) + +theorem primeMark_supported_assignments (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A : Finset ι) : + primeMark I L a A = ∑ q ∈ I.pi (fun i => L i ∩ A), slotAssignmentWeight I a q := by + simp only [primeMark,primeSlot,Finset.sum_ite_mem,slotAssignmentWeight] + exact Finset.prod_sum I (fun i => L i ∩ A) a + +theorem slotAssignmentWeight_norm_le_one (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A : Finset ι) (q : ∀ i ∈ I, ι) + (hq : q ∈ I.pi (fun i => L i ∩ A)) + (ha : ∀ i ∈ I, ∀ p ∈ L i, ‖a i p‖ ≤ 1) : ‖slotAssignmentWeight I a q‖ ≤ 1 := by + rw [slotAssignmentWeight,norm_prod] + apply Finset.prod_le_one₀ (fun _ _ => norm_nonneg _) + intro i _ + exact ha i.val i.property _ (Finset.mem_inter.mp (Finset.mem_pi.mp hq i.val i.property)).1 + +def indexedSlotAssignment (I : Finset σ) (q : ∀ i ∈ I, ι) : Fin I.card → ι := + fun j => q ((I.equivFin).symm j).val ((I.equivFin).symm j).property + +omit [DecidableEq σ] [DecidableEq ι] in +theorem indexedSlotAssignment_injective (I : Finset σ) : + Function.Injective (indexedSlotAssignment (ι:=ι) I) := by + intro q r h + funext i hi + have he := congrFun h (I.equivFin ⟨i,hi⟩) + simpa [indexedSlotAssignment] using he + +theorem indexedSlotAssignment_support (I : Finset σ) (L : σ → Finset ι) + (A : Finset ι) (q : ∀ i ∈ I, ι) (hq : q ∈ I.pi (fun i => L i ∩ A)) + (j : Fin I.card) : + indexedSlotAssignment I q j ∈ L ((I.equivFin).symm j).val ∩ A := + Finset.mem_pi.mp hq _ _ + +theorem primeMark_indexed_assignments (I : Finset σ) (L : σ → Finset ι) + (a : σ → ι → ℂ) (A : Finset ι) : + primeMark I L a A = + ∑ r ∈ (I.pi (fun i => L i ∩ A)).image (indexedSlotAssignment I), + slotAssignmentWeight I a (fun i hi => r (I.equivFin ⟨i,hi⟩)) := by + rw [Finset.sum_image (fun q _ r _ h => indexedSlotAssignment_injective I h)] + simpa only [indexedSlotAssignment,Equiv.symm_apply_apply] using + primeMark_supported_assignments I L a A + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SlotProducts.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SlotProducts.lean new file mode 100644 index 0000000000000000000000000000000000000000..3e34908285db1f93c70b97c6312513aff3f2aa58 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SlotProducts.lean @@ -0,0 +1,129 @@ +import OAI.NumberTheory.DirichletL.Descent.HybridBound + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O +variable {ι : Type*} [Fintype ι] [DecidableEq ι] + +def slotTupleProduct (p : ι → Ideal Eis) : Ideal Eis := ∏ i, p i + +theorem slotTupleProduct_injective_on + (L : ι → Finset (Ideal Eis)) (hL : Pairwise (fun i j => Disjoint (L i) (L j))) + (hp : ∀ i, ∀ P ∈ L i, Prime P) : + Set.InjOn (slotTupleProduct (ι := ι)) {p | ∀ i, p i ∈ L i} := by + intro p hpL q hqL he + funext i + change (∏ i, p i) = ∏ i, q i at he + have hdiv : p i ∣ ∏ j, q j := by + rw [← he] + exact Finset.dvd_prod_of_mem p (Finset.mem_univ i) + obtain ⟨j, hj, hd⟩ := ((hp i (p i) (hpL i)).dvd_finsetProd_iff q).mp hdiv + have hpq : p i = q j := associated_iff_eq.mp + ((hp i (p i) (hpL i)).associated_of_dvd (hp j (q j) (hqL j)) hd) + have hij : i = j := by + by_contra hne + exact Finset.disjoint_left.mp (hL hne) (hpL i) (hpq.symm ▸ hqL j) + simpa only [← hij] using hpq + +omit [DecidableEq ι] in +theorem slotTupleProduct_admissible + (L : ι → Finset (Ideal Eis)) (hL : Pairwise (fun i j => Disjoint (L i) (L j))) + (hp : ∀ i, ∀ P ∈ L i, Prime P) + (hgen : ∀ i, ∀ P ∈ L i, primaryGenerator P ≠ 0) + (p : ι → Ideal Eis) (hpL : ∀ i, p i ∈ L i) : + CubicSieve.Admissible (slotTupleProduct p) := by + constructor + · apply Finset.squarefree_prod_of_pairwise_isCoprime + · intro i hi j hj hij + have hpi := hp i (p i) (hpL i) + have hpj := hp j (p j) (hpL j) + let : (p i).IsMaximal := (Ideal.isPrime_of_prime hpi).isMaximal hpi.ne_zero + let : (p j).IsMaximal := (Ideal.isPrime_of_prime hpj).isMaximal hpj.ne_zero + apply (Ideal.isCoprime_of_isMaximal ?_).isRelPrime + intro he + exact Finset.disjoint_left.mp (hL hij) (hpL i) (he.symm ▸ hpL j) + · intro i hi + exact (hp i (p i) (hpL i)).squarefree + · change primaryGeneratorHom (∏ i, p i) ≠ 0 + rw [map_prod] + exact Finset.prod_ne_zero_iff.mpr (fun i _ => hgen i (p i) (hpL i)) + +def slotProductCoefficient (tuples : Finset (ι → Ideal Eis)) + (a : (ι → Ideal Eis) → ℂ) (P : Ideal Eis) : ℂ := + ∑ p ∈ tuples, if slotTupleProduct p = P then a p else 0 + +omit [DecidableEq ι] in +theorem slotProductCoefficient_at_product + (tuples : Finset (ι → Ideal Eis)) + (hinj : Set.InjOn slotTupleProduct (↑tuples : Set (ι → Ideal Eis))) + (a : (ι → Ideal Eis) → ℂ) (p : ι → Ideal Eis) (hp : p ∈ tuples) : + slotProductCoefficient tuples a (slotTupleProduct p) = a p := by + unfold slotProductCoefficient + rw [Finset.sum_eq_single p] + · simp + · intro q hq hqp + exact ite_eq_right (fun he => hqp (hinj hq hp he)) + · exact fun hn => (hn hp).elim + +omit [DecidableEq ι] in +theorem active_slot_hybrid_reindex + (tuples : Finset (ι → Ideal Eis)) + (hinj : Set.InjOn slotTupleProduct (↑tuples : Set (ι → Ideal Eis))) + (nset bset : Finset (Ideal Eis)) (a : (ι → Ideal Eis) → ℂ) + (beta : Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) : + (∑ p ∈ tuples, a p / (Real.sqrt (Ideal.absNorm (slotTupleProduct p) : ℝ) : ℂ) * + (if IsCoprime k (slotTupleProduct p) then 1 else 0) * + hybridInner nset bset beta k (slotTupleProduct p)) = + hybridRow (tuples.image slotTupleProduct) nset bset (slotProductCoefficient tuples a) beta k := by + rw [hybridRow, Finset.sum_image hinj] + apply Finset.sum_congr rfl + intro p hp + rw [slotProductCoefficient_at_product tuples hinj a p hp] + +theorem active_slot_hybrid_energy (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ K N B V : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → + ∀ (L : ι → Finset (Ideal Eis)), + Pairwise (fun i j => Disjoint (L i) (L j)) → + (∀ i, ∀ P ∈ L i, Prime P) → (∀ i, ∀ P ∈ L i, primaryGenerator P ≠ 0) → + ∀ (tuples : Finset (ι → Ideal Eis)), (∀ p ∈ tuples, ∀ i, p i ∈ L i) → + (∀ p ∈ tuples, V ≤ (Ideal.absNorm (slotTupleProduct p) : ℝ) ∧ + (Ideal.absNorm (slotTupleProduct p) : ℝ) ≤ 2 * V) → + ∀ (rows nset bset : Finset (Ideal Eis)) (a : (ι → Ideal Eis) → ℂ) + (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N) → + (∀ b ∈ bset, primaryGenerator b ≠ 0 ∧ (Ideal.absNorm b : ℝ) ≤ B) → + (∀ p ∈ tuples, ‖a p‖ ≤ 1) → (∀ n ∈ nset, ∀ b ∈ bset, ‖beta n b‖ ≤ 1) → + (∑ k ∈ rows, ‖∑ p ∈ tuples, + a p / (Real.sqrt (Ideal.absNorm (slotTupleProduct p) : ℝ) : ℂ) * + (if IsCoprime k (slotTupleProduct p) then 1 else 0) * + hybridInner nset bset beta k (slotTupleProduct p)‖ ^ 2) ≤ + C * (K * N * B) ^ ε * (K + N * B) * B * CubicSieve.sieveNorm N (2 * V) := by + obtain ⟨C, hC, he⟩ := hybridRow_energy_sieve_norm ε hε + refine ⟨C, hC, ?_⟩ + intro K N B V hK hN hB L hL hp hgen tuples htuples hnorm rows nset bset a beta + hrows hn hb ha hbeta + have hinj : Set.InjOn slotTupleProduct (↑tuples : Set (ι → Ideal Eis)) := + (slotTupleProduct_injective_on L hL hp).mono htuples + have hP : ∀ P ∈ tuples.image slotTupleProduct, + CubicSieve.Admissible P ∧ V ≤ (Ideal.absNorm P : ℝ) ∧ (Ideal.absNorm P : ℝ) ≤ 2 * V := by + intro P hP + obtain ⟨p, hpT, rfl⟩ := Finset.mem_image.mp hP + exact ⟨slotTupleProduct_admissible L hL hp hgen p (htuples p hpT), hnorm p hpT⟩ + have hcoeff : ∀ P ∈ tuples.image slotTupleProduct, ‖slotProductCoefficient tuples a P‖ ≤ 1 := by + intro P hP + obtain ⟨p, hpT, rfl⟩ := Finset.mem_image.mp hP + rw [slotProductCoefficient_at_product tuples hinj a p hpT] + exact ha p hpT + simp_rw [active_slot_hybrid_reindex tuples hinj nset bset a beta] + exact he K N B V hK hN hB rows nset bset (tuples.image slotTupleProduct) + (slotProductCoefficient tuples a) beta hrows hn hb hP hcoeff hbeta + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SourceDepth.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SourceDepth.lean new file mode 100644 index 0000000000000000000000000000000000000000..9f1b8f64adb3e7159e837756014415e19c74f493 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SourceDepth.lean @@ -0,0 +1,80 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondSharpPuncture + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open ConcreteTraceCRT (eisEmbedding) +noncomputable section +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + +include hp in + +theorem actual_second_childF_upper {Jo Jn : ℕ} (x : MarkedSecondSource ι Jo Jn) + (hE : x.second.divisor⊆x.second.sourceCommon) + (Z F ell A t g theta V j delta eta : ℝ) (hZ : 1x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) : + childF F ell A t g theta V j delta≤F+11*eta := + childF_upper hA ht hell hV + (actual_second_common_center p hp x hE Z g theta eta hZ hG hD) + (actual_second_label_center p hp x Z ell j eta hZ h1 h2 hJ) hdelta + +include hp in + +theorem actual_source_path_lengths + (Jo Jn : ℕ→ℕ) (x : (k : ℕ)→MarkedSecondSource ι (Jo k) (Jn k)) + (F M ell A t g theta V j delta : ℕ→ℝ) (Z eta d : ℝ) (hZ : 1(x k).cube.leftExponent i+(x k).cube.rightExponent i) + (x k).cube.leftBit (x k).cube.rightBit)‖^2) + (hF : ∀ k simp + | succ n ih => + have hlt : nhsource k (Nat.lt_trans hk hlt)) + (fun k hk=>hF k (Nat.lt_trans hk hlt)) (fun k hk=>hM k (Nat.lt_trans hk hlt)) + have hf := actual_second_childF_upper p hp (x n) he Z (F n) (ell n) (A n) (t n) + (g n) (theta n) (V n) (j n) (delta n) eta hZ ha ht hl hv hd hg hdiv h1 h2 hj + have hm := actual_second_row_decrease p hp (x n) he Z (M n) (ell n) (A n) (t n) + (g n) (theta n) (V n) (j n) eta d hZ ha ht hterm heta hg hdiv h1 h2 hj + rw [←hF n hlt] at hf + rw [←hM n hlt] at hm + push_cast + constructor <;> linarith [hi.1,hi.2] + +theorem source_depth_caps (F M N V F0 M0 eta : ℝ) (n D : ℕ) (hn : n≤D) + (heta : 0≤eta) (hF : F≤F0+11*(n:ℝ)*eta) (_hM : 0≤M) (hMm : M≤M0) + (hN : 0≤N) (hV : 0≤V) (hsum : F=N+V) : + N≤F0+11*(D:ℝ)*eta ∧ V≤F0+11*(D:ℝ)*eta ∧ M≤M0 := by + have hn' : (n:ℝ)≤D := by exact_mod_cast hn + have hmul := mul_le_mul_of_nonneg_right hn' heta + constructor + · linarith + constructor + · linarith + · exact hMm + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/SourceHybrid.lean b/lean/OAI/NumberTheory/DirichletL/Descent/SourceHybrid.lean new file mode 100644 index 0000000000000000000000000000000000000000..e1e07284163d4821e932d39b971052a63957e17d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/SourceHybrid.lean @@ -0,0 +1,164 @@ +import OAI.NumberTheory.DirichletL.Descent.FixedSquare + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CanonicalQuadraticSieve CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def sourceGridCoefficient (beta : Ideal Eis → Ideal Eis → ℂ) + (t c m h : Ideal Eis) : ℂ := beta (c * m) ((c * h) * t ^ 2) + +theorem reconstructed_fixed_square_grid + (D : Finset HybridColumnData) (t : Ideal Eis) (hD : ∀ d ∈ D, d.square = t) + (Pset : Finset (Ideal Eis)) (a : Ideal Eis → ℂ) + (beta : Ideal Eis → Ideal Eis → ℂ) (k : Ideal Eis) : + (∑ d ∈ D, ∑ P ∈ Pset, reconstructedHybridTerm a beta k P d) = + (if IsCoprime k t then 1 else 0) * + maskedGridHybridRow (hybridGridSupport D) Pset a (sourceGridCoefficient beta t) t k := by + unfold maskedGridHybridRow hybridGridSupport + rw [Finset.sum_image] + · simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + apply Finset.sum_congr rfl + intro P hP + simp only [reconstructedHybridTerm, HybridColumnData.gridIndex, + sourceGridCoefficient, hD d hd] + ac_rfl + · intro d hd e he hg + exact HybridColumnData.gridIndex_injective_on_square t (hD d hd) (hD e he) hg + +theorem reconstructed_fixed_square_energy_le + (D : Finset HybridColumnData) (t : Ideal Eis) (hD : ∀ d ∈ D, d.square = t) + (rows Pset : Finset (Ideal Eis)) (a : Ideal Eis → ℂ) + (beta : Ideal Eis → Ideal Eis → ℂ) : + (∑ k ∈ rows, ‖∑ d ∈ D, ∑ P ∈ Pset, reconstructedHybridTerm a beta k P d‖ ^ 2) ≤ + ∑ k ∈ rows, + ‖maskedGridHybridRow (hybridGridSupport D) Pset a (sourceGridCoefficient beta t) t k‖ ^ 2 := by + apply Finset.sum_le_sum + intro k hk + rw [reconstructed_fixed_square_grid D t hD Pset a beta k] + by_cases hkt : IsCoprime k t + · simp only [hkt, ite_true, one_mul, le_refl] + · simp only [hkt, ite_false, zero_mul, norm_zero, zero_pow (by norm_num : 2 ≠ 0)] + exact sq_nonneg _ + +theorem finite_double_row_energy {I J : Type*} [Fintype I] [Fintype J] + (rows : Finset (Ideal Eis)) (F : I → J → Ideal Eis → ℂ) (E : ℝ) (_hE : 0 ≤ E) + (hF : ∀ i j, (∑ k ∈ rows, ‖F i j k‖ ^ 2) ≤ E) : + (∑ k ∈ rows, ‖∑ i, ∑ j, F i j k‖ ^ 2) ≤ + ((Fintype.card I : ℝ) * (Fintype.card J : ℝ)) ^ 2 * E := by + have hk (k : Ideal Eis) : + ‖∑ i, ∑ j, F i j k‖ ^ 2 ≤ + ((Fintype.card I : ℝ) * (Fintype.card J : ℝ)) * + ∑ i, ∑ j, ‖F i j k‖ ^ 2 := by + simpa only [one_mul, Fintype.sum_prod_type, Fintype.card_prod, Nat.cast_mul] using + bounded_coefficient_sum_sq (fun _ : I × J => 1) (fun u => F u.1 u.2 k) (by simp) + calc + _ ≤ ∑ k ∈ rows, ((Fintype.card I : ℝ) * (Fintype.card J : ℝ)) * + ∑ i, ∑ j, ‖F i j k‖ ^ 2 := Finset.sum_le_sum (fun k _ => hk k) + _ = ((Fintype.card I : ℝ) * (Fintype.card J : ℝ)) * + ∑ i, ∑ j, ∑ k ∈ rows, ‖F i j k‖ ^ 2 := by + rw [← Finset.mul_sum, Finset.sum_comm] + congr 1 + apply Finset.sum_congr rfl + intro i hi + rw [Finset.sum_comm] + _ ≤ ((Fintype.card I : ℝ) * (Fintype.card J : ℝ)) * ∑ _i : I, ∑ _j : J, E := by + gcongr with i hi j hj + exact hF i j + _ = _ := by simp; ring + +theorem supportedHybridRow_energy_log (ε : ℝ) (hε : 0 < ε) : + ∃ C₀ : ℝ, 0 < C₀ ∧ ∀ K N B L : ℝ, 1 ≤ K → 1 ≤ N → 1 ≤ B → + ∀ (rows : Finset (Ideal Eis)) (S : Finset (Ideal Eis × Ideal Eis)) + (Pset : Finset (Ideal Eis)) (a : Ideal Eis → ℂ) (beta : Ideal Eis → Ideal Eis → ℂ), + (∀ k ∈ rows, Admissible k ∧ (Ideal.absNorm k : ℝ) ≤ K) → + (∀ p ∈ S, Squarefree p.1 ∧ primaryGenerator p.1 ≠ 0 ∧ primaryGenerator p.2 ≠ 0 ∧ + (Ideal.absNorm p.1 : ℝ) ≤ N ∧ (Ideal.absNorm p.2 : ℝ) ≤ B) → + (∀ P ∈ Pset, CubicSieve.Admissible P ∧ L ≤ (Ideal.absNorm P : ℝ) ∧ + (Ideal.absNorm P : ℝ) ≤ 2 * L) → + (∀ P ∈ Pset, ‖a P‖ ≤ 1) → (∀ p ∈ S, ‖beta p.1 p.2‖ ≤ 1) → + (∑ k ∈ rows, ‖supportedHybridRow S Pset a beta k‖ ^ 2) ≤ + C₀ * K ^ ε * (K * (N * B) * N) ^ ε * (K + N * B) * B * + CubicSieve.sieveNorm N (2 * L) * (columnDyadicLength K + 1 : ℝ) ^ 2 * + (columnDyadicLength N + 1 : ℝ) ^ 2 * (columnDyadicLength B + 1 : ℝ) ^ 2 := by + obtain ⟨C₁, hC₁, hfixed⟩ := hybrid_fixed_square_grid_energy ε hε + refine ⟨256 ^ 2 * C₁, by positivity, ?_⟩ + intro K N B L hK hN hB rows S Pset a beta hrows hS hP ha hbeta + let nset := S.image Prod.fst + let E := C₁ * K ^ ε * (K * (N * B) * N) ^ ε * (K + N * B) * B * + CubicSieve.sieveNorm N (2 * L) * (columnDyadicLength K + 1 : ℝ) ^ 2 + let F (j : Fin (columnDyadicLength B + 1)) (i : Fin (columnDyadicLength N + 1)) + (k : Ideal Eis) : ℂ := + ∑ t ∈ divisorDyadicBin (hybridSquarePool S) B j, + ∑ d ∈ hybridCommonBlock S N i t, ∑ P ∈ Pset, reconstructedHybridTerm a beta k P d + have hs : 0 ≤ CubicSieve.sieveNorm N (2 * L) := sq_nonneg _ + have hE : 0 ≤ E := by dsimp only [E]; positivity + have hnset : ∀ n ∈ nset, CubicSieve.Admissible n ∧ (Ideal.absNorm n : ℝ) ≤ N := by + intro n hn + obtain ⟨p, hp, rfl⟩ := Finset.mem_image.mp hn + exact ⟨⟨(hS p hp).1, (hS p hp).2.1⟩, (hS p hp).2.2.2.1⟩ + have hBsup : ∀ p ∈ S, (Ideal.absNorm p.2 : ℝ) ≤ B := fun p hp => (hS p hp).2.2.2.2 + have hlen : ∀ p ∈ S, (Ideal.absNorm p.1 : ℝ) ≤ N ∧ (Ideal.absNorm p.2 : ℝ) ≤ B := + fun p hp => (hS p hp).2.2.2 + have hlabel (j : Fin (columnDyadicLength B + 1)) + (i : Fin (columnDyadicLength N + 1)) : + (∑ k ∈ rows, ‖F j i k‖ ^ 2) ≤ 256 ^ 2 * E := by + let Td := divisorDyadicScale j.val + have hTd : 0 < Td := by dsimp only [Td]; linarith [divisorDyadicScale_ge_one j.val] + have htEnergy (t : Ideal Eis) (ht : t ∈ divisorDyadicBin (hybridSquarePool S) B j) : + (∑ k ∈ rows, ‖∑ d ∈ hybridCommonBlock S N i t, + ∑ P ∈ Pset, reconstructedHybridTerm a beta k P d‖ ^ 2) ≤ E / Td ^ 2 := by + let D := hybridCommonBlock S N i t + have hD (d : HybridColumnData) (hd : d ∈ D) : + d.square = t ∧ divisorDyadicScale i.val ≤ (Ideal.absNorm d.common : ℝ) ∧ + (Ideal.absNorm d.common : ℝ) ≤ 2 * divisorDyadicScale i.val ∧ + d.common * d.residualN ∈ nset ∧ + (Ideal.absNorm ((d.common * d.residualB) * d.square ^ 2) : ℝ) ≤ B := by + obtain ⟨hdS, hdt, hdi⟩ := Finset.mem_filter.mp hd + have hdorig := (mem_hybridColumnSupport S d).mp hdS + have hb := hybridCommonBlock_bounds S N B (by linarith) (by linarith) hlen i j t ht d hd + exact ⟨hdt, hb.1, hb.2.1, Finset.mem_image.mpr ⟨d.reconstruct, hdorig, rfl⟩, + hBsup d.reconstruct hdorig⟩ + have hβ : ∀ d ∈ D, ‖sourceGridCoefficient beta t d.common d.residualN d.residualB‖ ≤ 1 := by + intro d hd + have hdo := (mem_hybridColumnSupport S d).mp (Finset.mem_filter.mp hd).1 + simpa only [sourceGridCoefficient, ← (hD d hd).1, HybridColumnData.reconstruct] using + hbeta d.reconstruct hdo + have hfix := hfixed K N B L (divisorDyadicScale i.val) Td hK hN hB + (divisorDyadicScale_ge_one i.val) (divisorDyadicScale_ge_one j.val) t + (divisorDyadicBin_bounds (hybridSquarePool S) B (hybridSquarePool_bounds S B hBsup) j t ht).1 + rows nset Pset D a (sourceGridCoefficient beta t) hrows hnset hP ha hD hβ + apply (reconstructed_fixed_square_energy_le D t (fun d hd => (hD d hd).1) rows Pset a beta).trans + convert hfix using 1 ; dsimp only [E] ; ring + have he := hybrid_square_dyad_energy S B hBsup j rows + (fun t k => ∑ d ∈ hybridCommonBlock S N i t, + ∑ P ∈ Pset, reconstructedHybridTerm a beta k P d) + (E / Td ^ 2) (div_nonneg hE (sq_nonneg _)) htEnergy + calc + _ ≤ (256 * Td) ^ 2 * (E / Td ^ 2) := he + _ = 256 ^ 2 * E := by field_simp + have hrow (k : Ideal Eis) (hk : k ∈ rows) : + supportedHybridRow S Pset a beta k = ∑ j, ∑ i, F j i k := by + rw [supportedHybridRow_reconstruct S Pset + (fun p hp => ⟨(hS p hp).1, + primaryGenerator_ne_zero_ideal p.2 (hS p hp).2.2.1, + (hS p hp).2.1, (hS p hp).2.2.1⟩) + (fun P hPP => (hP P hPP).1.2) a beta k (hrows k hk).1] + exact hybrid_dyadic_reindex S N B _ + calc + _ = ∑ k ∈ rows, ‖∑ j, ∑ i, F j i k‖ ^ 2 := + Finset.sum_congr rfl (fun k hk => congrArg (fun z : ℂ => ‖z‖ ^ 2) (hrow k hk)) + _ ≤ ((Fintype.card (Fin (columnDyadicLength B + 1)) : ℝ) * + (Fintype.card (Fin (columnDyadicLength N + 1)) : ℝ)) ^ 2 * (256 ^ 2 * E) := + finite_double_row_energy rows F (256 ^ 2 * E) (by positivity) hlabel + _ = _ := by simp only [Fintype.card_fin, Nat.cast_add, Nat.cast_one, E]; ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/TripleMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/TripleMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..7147df556e5134271929edcdea823eea75a33aea --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/TripleMass.lean @@ -0,0 +1,110 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondEnergy + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open SevenEighths.InverseSecondFibers IdealMobiusDivisorSum +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +def tripleDivisorWeight (K : ℕ) (γ : OuterTriple) : ℝ := + ((idealDivisors γ.q0).card : ℝ)^(5+2*K) * + ((idealDivisors γ.quotient).card : ℝ)^(2*K) * + ((idealDivisors γ.residual).card : ℝ)^(2*K) + +lemma tripleDivisorWeight_nonneg (K : ℕ) (γ : OuterTriple) : + 0 ≤ tripleDivisorWeight K γ := by unfold tripleDivisorWeight; positivity + +theorem ideal_divisor_power_small (j : ℕ) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ I : Ideal Eis, I ≠ 0 → + ((idealDivisors I).card : ℝ)^j ≤ C*(Ideal.absNorm I : ℝ)^ε := by + have hj : 0 < (j+1 : ℝ) := by positivity + obtain ⟨C,hC,hb⟩ := IdealDivisorBound.ideal_divisor_small_power (ε/(j+1)) (div_pos hε hj) + refine ⟨C^(j+1), by positivity, ?_⟩ + intro I hI + have hcard : (1 : ℝ) ≤ (idealDivisors I).card := by + exact_mod_cast InverseInitialFibers.divisor_card_pos I hI + calc + _ ≤ ((idealDivisors I).card : ℝ)^(j+1) := pow_le_pow_right₀ hcard (by omega) + _ ≤ (C*(Ideal.absNorm I : ℝ)^(ε/(j+1)))^(j+1) := + pow_le_pow_left₀ (by positivity) (hb I hI) _ + _ = C^(j+1)*(Ideal.absNorm I : ℝ)^ε := by + rw [mul_pow] + congr 1 + rw [← Real.rpow_natCast, ← Real.rpow_mul (by positivity)] + congr 1 + push_cast + field_simp + +theorem tripleDivisorWeight_small (K : ℕ) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ γ : OuterTriple, + γ.q0 ≠ 0 → γ.quotient ≠ 0 → γ.residual ≠ 0 → + tripleDivisorWeight K γ ≤ + C*((Ideal.absNorm γ.q0 : ℝ)*Ideal.absNorm γ.quotient*Ideal.absNorm γ.residual)^ε := by + obtain ⟨Cq,hCq,hq⟩ := ideal_divisor_power_small (5+2*K) ε hε + obtain ⟨Ct,hCt,ht⟩ := ideal_divisor_power_small (2*K) ε hε + refine ⟨Cq*Ct*Ct, by positivity, ?_⟩ + intro γ hq0 ht0 hr0 + unfold tripleDivisorWeight + calc + _ ≤ (Cq*(Ideal.absNorm γ.q0 : ℝ)^ε) * + (Ct*(Ideal.absNorm γ.quotient : ℝ)^ε) * + (Ct*(Ideal.absNorm γ.residual : ℝ)^ε) := by + gcongr + · exact hq γ.q0 hq0 + · exact ht γ.quotient ht0 + · exact ht γ.residual hr0 + _ = _ := by + rw [Real.mul_rpow (by positivity : 0 ≤ (Ideal.absNorm γ.q0 : ℝ)*Ideal.absNorm γ.quotient) + (by positivity), Real.mul_rpow (by positivity) (by positivity)] + ring + +theorem outerTriple_card (Γ : Finset OuterTriple) (B T R : ℝ) + (hB : 1 ≤ B) (hT : 1 ≤ T) (hR : 1 ≤ R) + (hzero : ∀ γ ∈ Γ, γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0) + (hnorm : ∀ γ ∈ Γ, (Ideal.absNorm γ.q0 : ℝ) ≤ B ∧ + (Ideal.absNorm γ.quotient : ℝ) ≤ T ∧ (Ideal.absNorm γ.residual : ℝ) ≤ R) : + (Γ.card : ℝ) ≤ 128^3*B*T*R := by + let f : OuterTriple → Ideal Eis × Ideal Eis × Ideal Eis := fun γ => (γ.q0,γ.quotient,γ.residual) + have hf : Function.Injective f := by + intro γ δ h + exact OuterTriple.ext (congrArg Prod.fst h) + (congrArg (fun z => z.2.1) h) (congrArg (fun z => z.2.2) h) + have hc := DescentFiberCost.fixed_triple_count (Γ.image f) B T R hB hT hR + (fun x hx => by obtain ⟨γ,hγ,rfl⟩ := Finset.mem_image.mp hx; exact hzero γ hγ) + (fun x hx => by obtain ⟨γ,hγ,rfl⟩ := Finset.mem_image.mp hx; exact hnorm γ hγ) + simpa only [Finset.card_image_of_injective _ hf] using hc + +theorem triple_normalized_mass (K : ℕ) (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ (Γ : Finset OuterTriple) (B T R : ℝ), + 1 ≤ B → 1 ≤ T → 1 ≤ R → + (∀ γ ∈ Γ, γ.q0 ≠ 0 ∧ γ.quotient ≠ 0 ∧ γ.residual ≠ 0) → + (∀ γ ∈ Γ, (Ideal.absNorm γ.q0 : ℝ) ≤ B ∧ + (Ideal.absNorm γ.quotient : ℝ) ≤ T ∧ (Ideal.absNorm γ.residual : ℝ) ≤ R) → + (B*T*R)⁻¹ * (∑ γ ∈ Γ, tripleDivisorWeight K γ) ≤ C*(B*T*R)^ε := by + obtain ⟨C,hC,hb⟩ := tripleDivisorWeight_small K ε hε + refine ⟨128^3*C, by positivity, ?_⟩ + intro Γ B T R hB hT hR hz hn + have hpos : 0 < B*T*R := by positivity + have hw : ∀ γ ∈ Γ, tripleDivisorWeight K γ ≤ C*(B*T*R)^ε := by + intro γ hγ + obtain ⟨hq,ht,hr⟩ := hz γ hγ + apply (hb γ hq ht hr).trans + gcongr + · exact (hn γ hγ).1 + · exact (hn γ hγ).2.1 + · exact (hn γ hγ).2.2 + have hs : (∑ γ ∈ Γ, tripleDivisorWeight K γ) ≤ + (128^3*B*T*R)*(C*(B*T*R)^ε) := by + calc + _ ≤ ∑ _γ ∈ Γ, C*(B*T*R)^ε := Finset.sum_le_sum hw + _ = (Γ.card : ℝ)*(C*(B*T*R)^ε) := by simp + _ ≤ _ := mul_le_mul_of_nonneg_right (outerTriple_card Γ B T R hB hT hR hz hn) (by positivity) + apply (mul_le_mul_of_nonneg_left hs (inv_nonneg.mpr hpos.le)).trans_eq + field_simp + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/TwoPassScalar.lean b/lean/OAI/NumberTheory/DirichletL/Descent/TwoPassScalar.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ca5a89778f6282eae6eb87e15c04bd8efefb8fc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/TwoPassScalar.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Descent.FirstTwoPassEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators + +namespace SevenEighths.InverseMoment + +theorem two_pass_scalar (C Cz Ct Γ A Z F M r ell eta tau _pi epsFirst loss Lcap saving lossFinal H:ℝ) + (hC:0≤C)(hCz:0≤Cz)(hCt:0≤Ct)(hA:0≤A)(hZ:1≤Z)(hH:1≤H) + (hM:M-ell≤F) + (hprincipal:3*eta+epsFirst*(5*ell+2*r+7*eta)≤lossFinal) + (hretained:loss+(2*Lcap+15*eta+tau)*epsFirst+epsFirst≤lossFinal) + (htail: -saving≤F+lossFinal): + Cz*Γ^2*Z^(M-ell+3*eta+epsFirst*(5*ell+2*r+7*eta))+ + C*Γ^2*(1+A)*Z^(F+loss)*H*Z^((2*Lcap+15*eta+tau)*epsFirst+epsFirst)+Ct*Γ^2*Z^(-saving)≤ + (C+Cz+Ct)*Γ^2*(1+A)*H*Z^(F+lossFinal) :=by + have hz:0ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] {Jo:ℕ} +variable (p:ι→Eis) [∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def priorityZeroParent (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) (slots assigned:Finset σ) + (lists:σ→Finset ι) (a:σ→ι→ℂ) (V:𝓢(ℝ,ℂ)) (X Y:ℝ) + (R:Finset ι→Finset ι→ℝ) (y:SecondParentSource ι Jo):ℂ:= + truncatedSecondZero p hg pool Ψ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) + (InversePrincipalEnergy.markedRadial p (slots\assigned) + (residualLists p negative (fun i=>lists i\extra y.cube) y) a ∅ V X) + rowMajorant Y (secondVariableCutoff p y R) + +def priorityTailParent (hp:∀i,p i≠0) (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) (slots assigned:Finset σ) + (lists:σ→Finset ι) (a:σ→ι→ℂ) (V:𝓢(ℝ,ℂ)) (X Y:ℝ) + (R:Finset ι→Finset ι→ℝ) (y:SecondParentSource ι Jo):ℂ:= + secondSourceTail p hp hg hinj pool Ψ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) + (InversePrincipalEnergy.markedRadial p (slots\assigned) + (residualLists p negative (fun i=>lists i\extra y.cube) y) a ∅ V X) + rowMajorant Y (secondVariableCutoff p y R) + +theorem whole_priority_signed_branches + (hp:∀i,p i≠0) (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (cube:CubeCoordinates ι) (C E:Finset ι) (old:Fin Jo→SmoothMobiusCorrection.PrimeIdeal) + (selector:Finset ι→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0R) + (∑D∈pool.powerset,(priorityOuter p hg cube negative Ψ m selector ray core D:ℂ)* + (‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2:ℝ)* + wholePriorityPoisson p hp hg hinj pool cube C E (extra cube) negative Ψ m slots assigned lists a om X t Y ray core D)= + (∑D∈pool.powerset,(priorityOuter p hg cube negative Ψ m selector ray core D:ℂ)* + (‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2:ℝ)* + priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p (fixedPoint cube C E old D)))+ + (∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * ∑x∈source, + sourceWeight p hg cube negative Ψ m selector ray core assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a V X Y z x)+ + (∑D∈pool.powerset,(priorityOuter p hg cube negative Ψ m selector ray core D:ℂ)* + (‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2:ℝ)* + priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p (fixedPoint cube C E old D))) := by + intro V Ψ₀ parents source + rw [whole_priority_complex_slice p hp hg hcop hinj hc hpr pool cube C E extra old negative Ψ m + slots assigned lists a selector om lo hi hlo hs X t Y hX hY ray core R (fun _ _=>())] + rw [fullPhysical_unified p hg hp hcop hinj extra pool] + dsimp only + rw [←whole_assigned_source_original p hg hinj extra pool cube C E old selector negative Ψ m ray core assigned lists a + (priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R), + ←whole_assigned_source_original p hg hinj extra pool cube C E old selector negative Ψ m ray core assigned lists a + (priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R)] + rfl + +theorem whole_priority_slice_bound + (hp:∀i,p i≠0) (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (hc:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (hpr:∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (cube:CubeCoordinates ι) (C E:Finset ι) (old:Fin Jo→SmoothMobiusCorrection.PrimeIdeal) + (selector:Finset ι→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0R) + ‖∑D∈pool.powerset,(priorityOuter p hg cube negative Ψ m selector ray core D:ℂ)* + (‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2:ℝ)* + wholePriorityPoisson p hp hg hinj pool cube C E (extra cube) negative Ψ m slots assigned lists a om X t Y ray core D‖≤ + (∑D∈pool.powerset,priorityOuter p hg cube negative Ψ m selector ray core D* + ‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2* + ‖priorityZeroParent p hg extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p (fixedPoint cube C E old D))‖)+ + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * ∑x∈source, + sourceWeight p hg cube negative Ψ m selector ray core assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a V X Y z x‖+ + (∑D∈pool.powerset,priorityOuter p hg cube negative Ψ m selector ray core D* + ‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2* + ‖priorityTailParent p hg hp hinj extra pool negative Ψ₀ m slots assigned lists a V X Y R (parent p (fixedPoint cube C E old D))‖) := by + intro V Ψ₀ parents source + rw [whole_priority_signed_branches p hg hp hcop hinj hc hpr extra pool cube C E old selector negative + Ψ m ray core slots assigned lists a om lo hi hlo hs X t Y hX hY R] + have hn (H:Finset ι→ℂ): + ‖∑D∈pool.powerset,(priorityOuter p hg cube negative Ψ m selector ray core D:ℂ)* + (‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2:ℝ)*H D‖≤ + ∑D∈pool.powerset,priorityOuter p hg cube negative Ψ m selector ray core D* + ‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2*‖H D‖:=by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro D hD + rw [norm_mul,norm_mul,Complex.norm_real,Complex.norm_real, + Real.norm_of_nonneg (by unfold priorityOuter;positivity),Real.norm_of_nonneg (sq_nonneg _)] + exact (norm_add_le _ _).trans (add_le_add ((norm_add_le _ _).trans (add_le_add (hn _) (le_refl _))) (hn _)) + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityCollapse.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityCollapse.lean new file mode 100644 index 0000000000000000000000000000000000000000..b41a78f6f62576f94b1f8d18bd300fb85b415a9b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityCollapse.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityRays +import OAI.NumberTheory.DirichletL.Descent.WholePriorityPrincipal +import OAI.NumberTheory.DirichletL.Inversion.WholePriorityRapidTail + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseInitialArithmetic InverseFirstPriorityParents InverseMomentWholePriorityParents +open InverseWholePriorityValidSource InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] {Jo:ℕ} +variable (p:ι→Eis) [∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem whole_assigned_source_original + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (cube:CubeCoordinates ι) (C E:Finset ι) (old:Fin Jo→SmoothMobiusCorrection.PrimeIdeal) + (selector:Finset ι→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (H:SecondParentSource ι Jo→ℂ): + (∑y∈activeParents p extra pool cube C E old selector negative assigned lists, + coefficient p assigned a (fun x=>(priorityOuter p hg cube negative Ψ m selector ray core x.quotientSupport:ℂ)) y * + H (forgetAppended y))= + ∑D∈pool.powerset,(priorityOuter p hg cube negative Ψ m selector ray core D:ℂ)* + (‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2:ℝ)* + H (parent p (fixedPoint cube C E old D)) := by + rw [activeParents,←wholePaired_parent_sq_sum p (fun x=>extra x.cube) hinj, + sum_activeFixedSource] + rw [Finset.sum_filter] + apply Finset.sum_congr rfl + intro D hD + by_cases hs:selector D≠0 + · rw [ite_eq_left hs] + simp only [fixedPoint,wholeExtractedSupport,extractedSupport,Finset.union_assoc] + · rw [ite_eq_right hs,priorityOuter_zero p hg cube negative Ψ m selector ray core D (not_ne_iff.mp hs)] + simp + +theorem whole_assigned_source_norm + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (cube:CubeCoordinates ι) (C E:Finset ι) (old:Fin Jo→SmoothMobiusCorrection.PrimeIdeal) + (selector:Finset ι→ℂ) (negative:Bool) (Ψ:Eis→*ℂ) (m:Eis) + (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (H:SecondParentSource ι Jo→ℂ): + ‖∑y∈activeParents p extra pool cube C E old selector negative assigned lists, + coefficient p assigned a (fun x=>(priorityOuter p hg cube negative Ψ m selector ray core x.quotientSupport:ℂ)) y * + H (forgetAppended y)‖≤ + ∑D∈pool.powerset,priorityOuter p hg cube negative Ψ m selector ray core D* + ‖primeMark assigned lists a ((extra cube∪((if negative then cube.rightDivisor else cube.leftDivisor)∪C))∪D)‖^2* + ‖H (parent p (fixedPoint cube C E old D))‖ := by + rw [whole_assigned_source_original p hg hinj] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro D hD + rw [norm_mul,norm_mul,Complex.norm_real,Complex.norm_real, + Real.norm_of_nonneg (by unfold priorityOuter;positivity),Real.norm_of_nonneg (sq_nonneg _)] + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..16cd263631efbdc320ab69ecc18674dcc727aa57 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityEnergy.lean @@ -0,0 +1,149 @@ +import OAI.NumberTheory.DirichletL.Descent.PriorityRetainedBound +import OAI.NumberTheory.DirichletL.Inversion.WholePriorityRetainedSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem whole_priority_retained_fixed_ray + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (cube:CubeCoordinates ι) (firstCommon firstDivisor:Finset ι) + (old:Fin Jo→SmoothMobiusCorrection.PrimeIdeal) (selector:Finset ι→ℂ) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) + (_hcube:cube.Admissible) (_hcommon:Disjoint firstCommon cube.support) + (_hdivisor:firstDivisor⊆firstCommon∪cube.support) + (_hold:∀D∈pool.powerset,selector D≠0 → ∀i,(old i).val∣ + sourceIdeal p cube.support*sourceIdeal p firstCommon*sourceIdeal p D) + (_hextra:extra cube⊆cube.support), + let source:=unifiedSource p pool + (activeParents p extra pool cube firstCommon firstDivisor old selector negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀(z:SecondRayIndex) + (Y R L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀D∈pool.powerset,‖selector D‖≤1) → + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖(Y:ℂ)*secondRayCoefficient z * + ∑x∈source,sourceWeight p hg cube negative Ψ m selector ray core assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*‖secondRayCoefficient z‖*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,Cbin,hC,hCbin,he⟩:= + actual_priority_retained_bound (ι:=ι) (σ:=σ) om rowMajorant lo hi hlo hsupport negative + caps hcaps B₀ hB₀ J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,coefficientBound*C,Cbin,mul_nonneg coefficientBound_pos.le hC,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool cube firstCommon firstDivisor old selector + Ψ m ray core slots assigned lists a cutoff hcube hcommon hdivisor hold hextra source Ψ₀ z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + hselector haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hsource:ActualSecondSourceConditions p source:= + active_conditions p hp extra pool cube firstCommon firstDivisor old selector hcube hcommon hdivisor + hold hextra negative assigned lists cutoff + have hd:∀x∈source,∀i∈InverseMomentWholeRetainedSource.deleted p extra negative x, + i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal Eis)∣x.quotient:= + active_deleted_support p hinj extra pool cube firstCommon firstDivisor old selector hcube hcommon + hdivisor hold hextra negative assigned lists cutoff + have hw:∀x∈source,‖normalizedWeight p hg cube negative Ψ m selector ray core assigned a x‖≤1:= + fun x hx=>normalizedWeight_norm p hg hinj extra pool cube firstCommon firstDivisor old selector + negative Ψ m ray core assigned lists a haassigned hselector (fun D hD hD0=>hΨ _) cutoff x hx + have hΨ₀:∀n,‖Ψ₀ n‖≤1:=fun n=>(firstCoreTwist_norm_le negative (if negative then ray.1 else ray.2) + Ψ core n).trans (hΨ n) + have he₀:=he p hp hcop hg hpr hinj hc source hsource pool Ψ₀ m z (slots\assigned) (slots\assigned) + lists lists a a (InverseMomentWholeRetainedSource.deleted p extra negative) + (InverseMomentWholeRetainedSource.deleted p extra negative) + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t + (normalizedWeight p hg cube negative Ψ m selector ray core assigned a) labels A + hd hd hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ₀ hw + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + have hrow:∀x:MarkedSecondSource ι (Jo+(assigned.card+assigned.card)) 0,wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x= + actualSecondSignedWeight p hp hcop hg Ψ₀ (m*ConcretePrimeRowBridge.idealGenerator x.quotient) z x* + actualSecondProfileRow p hp hcop hg pool (secondInheritedProfile p x Ψ₀ m z) + (slots\assigned) (slots\assigned) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) + (fun i=>lists i\InverseMomentWholeRetainedSource.deleted p extra negative x) a a + (principalWindow om lo hi hlo hsupport negative t) (principalWindow om lo hi hlo hsupport negative t) + rowMajorant Y X:=fun x=>wholeRow_eq p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a _ X Y z x + rw [source_sum_normalized p hg cube negative Ψ m selector ray core assigned a source] + rw [show (Y:ℂ)*secondRayCoefficient z*((coefficientBound:ℂ)* + ∑x∈source,normalizedWeight p hg cube negative Ψ m selector ray core assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x)= + (coefficientBound:ℂ)*((Y:ℂ)*secondRayCoefficient z* + ∑x∈source,normalizedWeight p hg cube negative Ψ m selector ray core assigned a x* + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x) by ring] + rw [norm_mul,Complex.norm_real,Real.norm_of_nonneg coefficientBound_pos.le] + simp_rw [hrow,←mul_assoc] + convert mul_le_mul_of_nonneg_left he₀ coefficientBound_pos.le using 1 <;> ring_nf + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityMass.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..e1a9d9980fe3d2587226f559aa73ad168c50676b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityMass.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityBranches + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InverseSecondPrincipalCaller InversePrincipalEnergy +local notation "O"=>ActualEisensteinCubic.O + +theorem whole_priority_weighted_branch (ε:ℝ) (hε:0<ε): + ∃Cb:ℝ,0Ideal.span {p i}))) + (pool:Finset ι) (b:CubeCoordinates ι) (C extra:Finset ι) (negative:Bool) + (Ψ:O→*ℂ) (m:O) (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (selector:Finset ι→ℂ) (B:ℝ), + (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → + (∀u,‖Ψ u‖≤1) → 0≤B → + ∀U:(RayCharacter×RayCharacter)→Finset ι→FirstCoreIndex→Finset σ→ℝ, + (∀r D core J,J∈slots.powerset → 0≤U r D core J) → + (∀r D core J,J∈slots.powerset → U r D core J≤B) → + (32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑D∈pool.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑core:FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative Ψ m D core‖* + ∑J∈slots.powerset,‖primeMark J lists a + ((extra∪((if negative then b.rightDivisor else b.leftDivisor)∪C))∪D)‖^2*U r D core J ≤ + Cb*(4:ℝ)^slots.card*B* + (∑D∈pool.powerset,‖selector D‖*(primeProductNorm p + ((extra∪((if negative then b.rightDivisor else b.leftDivisor)∪C))∪D))^(2*ε)):=by + obtain ⟨Cm,hCm,hmark⟩:=finite_primeMark_small_power ε hε + refine ⟨((32*512:ℝ)^2*512)*Cm^2,by positivity,?_⟩ + intro ι σ _ _ p hp _ hg hcop pool b C extra negative Ψ m slots lists a selector B hslots ha hΨ hB U hU0 hU + let A:=extra∪((if negative then b.rightDivisor else b.leftDivisor)∪C) + have hm (J:Finset σ) (hJ:J∈slots.powerset) (D:Finset ι) : + ‖primeMark J lists a (A∪D)‖^2≤Cm^2*(primeProductNorm p (A∪D))^(2*ε) := by + have hj:=Finset.mem_powerset.mp hJ + have hh:=hmark p hp hcop J lists a (fun i hi j hj' hij=>hslots (hj hi) (hj hj') hij) (fun i hi=>ha i (hj hi)) (A∪D) + have he:((primeProductNorm p (A∪D))^ε)^2=(primeProductNorm p (A∪D))^(2*ε):=by + rw [←Real.rpow_natCast,←Real.rpow_mul (primeProductNorm_pos p hp _).le] + congr 1;ring + calc + _≤(Cm*(primeProductNorm p (A∪D))^ε)^2:=pow_le_pow_left₀ (norm_nonneg _) hh 2 + _= _:=by rw [mul_pow,he] + have hn (D:Finset ι) : 0≤primeProductNorm p (A∪D):=(primeProductNorm_pos p hp _).le + calc + _≤(32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑D∈pool.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑core:FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative Ψ m D core‖* + ((2:ℝ)^slots.card*(Cm^2*(primeProductNorm p (A∪D))^(2*ε)*B)) := by + gcongr with r hr D hD core hc + calc + _≤∑J∈slots.powerset,Cm^2*(primeProductNorm p (A∪D))^(2*ε)*B := by + apply Finset.sum_le_sum + intro J hJ + exact mul_le_mul (hm J hJ D) (hU r D core J hJ) (hU0 r D core J hJ) (mul_nonneg (sq_nonneg _) (Real.rpow_nonneg (hn D) _)) + _= _:=by simp only [Finset.sum_const,Finset.card_powerset,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + _≤(32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑D∈pool.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)* + ((32*512)*((2:ℝ)^slots.card*(Cm^2*(primeProductNorm p (A∪D))^(2*ε)*B))) := by + gcongr with r hr D hD + rw [←Finset.sum_mul] + exact mul_le_mul_of_nonneg_right (firstCoreOuter_mass p hg b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative Ψ m D (hΨ _)) (mul_nonneg (pow_nonneg (by norm_num) _) + (mul_nonneg (mul_nonneg (sq_nonneg _) (Real.rpow_nonneg (hn D) _)) hB)) + _= ((32*512:ℝ)^2)*((2:ℝ)^slots.card)^2*Cm^2*B* + (∑r:RayCharacter×RayCharacter,‖crossCoeff r.1 r.2‖)* + (∑D∈pool.powerset,‖selector D‖*(primeProductNorm p (A∪D))^(2*ε)) := by + simp only [Finset.mul_sum,Finset.sum_mul] + rw [Finset.sum_comm (s:=pool.powerset)] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + ring + _≤ ((32*512:ℝ)^2)*((2:ℝ)^slots.card)^2*Cm^2*B*512* + (∑D∈pool.powerset,‖selector D‖*(primeProductNorm p (A∪D))^(2*ε)) := by + apply mul_le_mul_of_nonneg_right + · apply mul_le_mul_of_nonneg_left + · simpa only [Fintype.sum_prod_type] using crossCoeff_sum_norm_le + · positivity + · exact Finset.sum_nonneg (fun D hD=>mul_nonneg (norm_nonneg _) (Real.rpow_nonneg (hn D) _)) + _= _ := by + have he:((2:ℝ)^slots.card)^2=(4:ℝ)^slots.card:=by rw [←pow_mul,pow_mul'];norm_num + rw [he] + dsimp only [A] + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityParentBounds.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityParentBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e2e67a53f346489ec10a3bd4300d1985ae8ea15 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityParentBounds.lean @@ -0,0 +1,113 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityMass + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InverseSecondPrincipalCaller InversePrincipalEnergy InversePrioritySecondSource +local notation "O"=>ActualEisensteinCubic.O + +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] + (p:ι→O) [∀i,(Ideal.span {p i}).IsMaximal] + +omit [DecidableEq σ] [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem parent_residual_lists_subset {Jo:ℕ} (extra:CubeCoordinates ι→Finset ι) + (negative:Bool) (lists:σ→Finset ι) (y:SecondParentSource ι Jo) (i:σ): + residualLists p negative (fun i=>lists i\extra y.cube) y i⊆lists i:= +by + intro k hk + exact (Finset.mem_sdiff.mp (Finset.mem_sdiff.mp hk).1).1 + +omit [∀ (i : ι), (Ideal.span {p i}).IsMaximal] in +theorem parent_residual_lists_pairwise {Jo:ℕ} (extra:CubeCoordinates ι→Finset ι) + (negative:Bool) (slots assigned:Finset σ) (lists:σ→Finset ι) (y:SecondParentSource ι Jo) + (hslots:(slots:Set σ).PairwiseDisjoint lists): + ((slots\assigned:Finset σ):Set σ).PairwiseDisjoint (residualLists p negative (fun i=>lists i\extra y.cube) y):=by + intro i hi j hj hij + exact (hslots (Finset.mem_sdiff.mp hi).1 (Finset.mem_sdiff.mp hj).1 hij).mono + (parent_residual_lists_subset p extra negative lists y i) + (parent_residual_lists_subset p extra negative lists y j) + +theorem priority_zero_parent_uniform (ε:ℝ) (hε:0<ε): + ∃(s:Finset (ℕ×ℕ))(C:ℝ),0Ideal.span {p i})) + (_hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) (negative:Bool) + (Ψ:O→*ℂ) (m:O) (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ), + (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → (∀u,‖Ψ u‖≤1) → + ∀(om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0lists i\extra y.cube) y i,‖a i k‖≤1:=by + intro i hi k hk + exact ha i (Finset.mem_sdiff.mp hi).1 k (parent_residual_lists_subset p extra negative lists y i hk) + have hz:∀G∈pool.powerset,∀E∈G.powerset,(0:O)∈secondVariableCutoff p y R G E:=by + intro G hG E hE + exact zero_mem_childFrequencyBall _ + (mul_ne_zero (primeSubsetGenerator_ne_zero _ _) (primeSubsetGenerator_ne_zero _ _)) _ (hR G E) + have hb:=hbound p hp hg hinj hcop (slots\assigned) + (residualLists p negative (fun i=>lists i\extra y.cube) y) a hpair hcoeff ∅ pool Ψ hΨ + (secondParentPuncture p m y) (secondParentLabel p y) (secondParentDivisor p y) + (principalWindow om lo hi hlo hs negative t) rowMajorant X M Y hX hY + (principalWindow_upper om lo hi hlo hs M hhi negative t) (secondVariableCutoff p y R) hz + (fun _ _ _=>0) (by intros; simp) + have hb':‖priorityZeroParent p hg extra pool negative Ψ m slots assigned lists a + (principalWindow om lo hi hlo hs negative t) X Y R y‖≤_:= + (le_add_of_nonneg_right (norm_nonneg _)).trans hb + simpa only [Finset.card_empty,pow_zero,mul_one,principalWindow_seminorm_zero,mul_assoc] using hb' + +theorem priority_tail_parent_uniform (Lcap tau saving:ℝ)(hLcap:0≤Lcap)(htau:0Ideal.span {p i})) + (_hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (_hc:∀i,ringChar (O⧸Ideal.span {p i})≠2) + (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) (negative:Bool) + (Ψ:O→*ℂ) (m:O) (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ), + (slots:Set σ).PairwiseDisjoint lists → (∀i∈slots,∀k∈lists i,‖a i k‖≤1) → (∀u,‖Ψ u‖≤1) → + ∀(om:𝓢(ℝ,ℂ))(lo hi:ℝ)(hlo:0lists i\extra y.cube) y i,‖a i k‖≤1:=by + intro i hi k hk + exact ha i (Finset.mem_sdiff.mp hi).1 k (parent_residual_lists_subset p extra negative lists y i hk) + exact hbound p hp hcop hg hinj hc pool Ψ hΨ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) (primeSubsetGenerator_ne_zero _ _) + (slots\assigned) _ a hpair hcoeff om rowMajorant lo hi hlo hs negative t X M Y Z R + hX hhi hZ hY hscale hy hyi hx hR + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityParents.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityParents.lean new file mode 100644 index 0000000000000000000000000000000000000000..409c0330894bdbf408fdd8df8e281447374c0d5c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityParents.lean @@ -0,0 +1,158 @@ +import OAI.NumberTheory.DirichletL.Inversion.FirstPriorityParents +import OAI.NumberTheory.DirichletL.Descent.FirstWholeCubePriority + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMomentWholePriorityParents +open ActualEisensteinCubic SecondPassArithmetic FirstPassCubeLabels FirstCauchyArithmetic +open InverseMoment InverseInitialArithmetic InverseFirstPriorityParents +local notation "O" => ActualEisensteinCubic.O +variable {ι σ : Type*} [DecidableEq ι] [DecidableEq σ] {Jo : ℕ} + +def wholeExtractedSupport (extra : Source ι Jo→Finset ι) + (negative : Bool) (x : Source ι Jo) : Finset ι := extra x∪extractedSupport negative x + +variable (p : ι→O) [∀ i,(Ideal.span {p i}).IsMaximal] + +def wholeAssignmentSource (extra : Source ι Jo→Finset ι) (source : Finset (Source ι Jo)) (negative : Bool) + (J : Finset σ) (lists : σ→Finset ι) : + Finset (Source ι Jo × ((∀ i∈J,ι)×(∀ i∈J,ι))) := + (source ×ˢ ((J.pi lists)×ˢ(J.pi lists))).filter + (fun q=>∀ i,pairedSlotAssignment J J q.2 i∈wholeExtractedSupport extra negative q.1) + +def wholeAssignedParents (extra : Source ι Jo→Finset ι) (source : Finset (Source ι Jo)) (negative : Bool) + (J : Finset σ) (lists : σ→Finset ι) : Finset (SecondParentSource ι (Jo+(J.card+J.card))) := + (wholeAssignmentSource extra source negative J lists).image (attach p J) + +theorem sum_wholeAssignmentSource (extra : Source ι Jo→Finset ι) {A : Type*} [AddCommMonoid A] + (source : Finset (Source ι Jo)) (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) + (H : Source ι Jo × ((∀ i∈J,ι)×(∀ i∈J,ι))→A) : + ∑ q∈wholeAssignmentSource extra source negative J lists,H q = + ∑ x∈source,∑ q∈(J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x))×ˢ + (J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x)),H (x,q) := by + rw [wholeAssignmentSource,Finset.sum_filter,Finset.sum_product] + apply Finset.sum_congr rfl + intro x hx + rw [←Finset.sum_filter] + dsimp only + rw [paired_assignment_filter] + +theorem sum_wholeAssignedParents (extra : Source ι Jo→Finset ι) (hinj : Function.Injective (fun i=>Ideal.span {p i})) + {A : Type*} [AddCommMonoid A] (source : Finset (Source ι Jo)) (negative : Bool) + (J : Finset σ) (lists : σ→Finset ι) (H : SecondParentSource ι (Jo+(J.card+J.card))→A) : + ∑ y∈wholeAssignedParents p extra source negative J lists,H y = + ∑ x∈source,∑ q∈(J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x))×ˢ + (J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x)),H (attach p J (x,q)) := by + rw [wholeAssignedParents,Finset.sum_image (fun _ _ _ _ h=>attach_injective p hinj J h)] + exact sum_wholeAssignmentSource extra source negative J lists _ + +theorem wholePaired_parent_sum (extra : Source ι Jo→Finset ι) (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (source : Finset (Source ι Jo)) (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) + (a : σ→ι→ℂ) (w : Source ι Jo→ℂ) (H : SecondParentSource ι Jo→ℂ) : + (∑ x∈source,w x*(star (primeMark J lists a (wholeExtractedSupport extra negative x))* + primeMark J lists a (wholeExtractedSupport extra negative x))*H (parent p x)) = + ∑ y∈wholeAssignedParents p extra source negative J lists, + coefficient p J a w y*H (forgetAppended y) := by + rw [sum_wholeAssignedParents p extra hinj] + apply Finset.sum_congr rfl + intro x hx + rw [paired_primeMark_assignments] + simp only [Finset.mul_sum,Finset.sum_mul,coefficient_attach p hinj,forget_attach] + +theorem wholePaired_parent_sq_sum (extra : Source ι Jo→Finset ι) (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (source : Finset (Source ι Jo)) (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) + (a : σ→ι→ℂ) (w : Source ι Jo→ℂ) (H : SecondParentSource ι Jo→ℂ) : + (∑ x∈source,w x*(‖primeMark J lists a (wholeExtractedSupport extra negative x)‖^2 : ℝ)*H (parent p x)) = + ∑ y∈wholeAssignedParents p extra source negative J lists, + coefficient p J a w y*H (forgetAppended y) := by + simpa only [Complex.sq_norm,Complex.normSq_eq_conj_mul_self,starRingEnd_apply] using + wholePaired_parent_sum p extra hinj source negative J lists a w H + +lemma mem_wholeAssignmentSource (extra : Source ι Jo→Finset ι) (source : Finset (Source ι Jo)) (negative : Bool) + (J : Finset σ) (lists : σ→Finset ι) + (x : Source ι Jo) (q : (∀ i∈J,ι)×(∀ i∈J,ι)) : + (x,q)∈wholeAssignmentSource extra source negative J lists ↔ x∈source ∧ + q∈(J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x))×ˢ + (J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x)) := by + rw [←paired_assignment_filter] + simp only [wholeAssignmentSource,Finset.mem_filter,Finset.mem_product] + tauto + +theorem mem_wholeAssignedParents (extra : Source ι Jo→Finset ι) (source : Finset (Source ι Jo)) (negative : Bool) + (J : Finset σ) (lists : σ→Finset ι) (y : SecondParentSource ι (Jo+(J.card+J.card))) : + y∈wholeAssignedParents p extra source negative J lists ↔ + ∃ x∈source,∃ q∈(J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x))×ˢ + (J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x)),attach p J (x,q)=y := by + simp only [wholeAssignedParents,Finset.mem_image] + constructor + · rintro ⟨⟨x,q⟩,hq,he⟩ + exact ⟨x,(mem_wholeAssignmentSource extra source negative J lists x q).mp hq |>.1, + q,(mem_wholeAssignmentSource extra source negative J lists x q).mp hq |>.2,he⟩ + · rintro ⟨x,hx,q,hq,he⟩ + exact ⟨(x,q),(mem_wholeAssignmentSource extra source negative J lists x q).mpr ⟨hx,hq⟩,he⟩ + +theorem whole_extracted_prime_dvd (extra : Source ι Jo→Finset ι) + (x : Source ι Jo) (hx : x.cube.Admissible) (he : extra x⊆x.cube.support) + (negative : Bool) (i : ι) (hi : i∈wholeExtractedSupport extra negative x) : + (sourcePrime p i).val∣sourceIdeal p x.cube.support*sourceIdeal p x.firstCommon* + sourceIdeal p x.quotientSupport := by + obtain hi|hi := Finset.mem_union.mp hi + · exact dvd_mul_of_dvd_left (dvd_mul_of_dvd_left (source_prime_dvd p _ i (he hi)) _) _ + · exact extracted_prime_dvd p x hx negative i hi + +theorem whole_attach_old_support (extra : Source ι Jo→Finset ι) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) + (x : Source ι Jo) (hx : SourceValid p x) (he : extra x⊆x.cube.support) + (q : (∀ i∈J,ι)×(∀ i∈J,ι)) + (hq : q∈(J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x))×ˢ + (J.pi (fun i=>lists i∩wholeExtractedSupport extra negative x))) : + ∀ i,((attach p J (x,q)).oldAssigned i).val∣ + sourceIdeal p (attach p J (x,q)).cube.support* + sourceIdeal p (attach p J (x,q)).firstCommon*(attach p J (x,q)).quotient := by + have hh : ∀ i,pairedSlotAssignment J J q i∈wholeExtractedSupport extra negative x := by + have hf : q∈((J.pi lists)×ˢ(J.pi lists)).filter + (fun q=>∀ i,pairedSlotAssignment J J q i∈wholeExtractedSupport extra negative x) := by + rwa [paired_assignment_filter] + exact (Finset.mem_filter.mp hf).2 + intro i + refine Fin.addCases (fun k=>?_) (fun k=>?_) i + · simpa only [attach,appendParent,parent,Fin.addCases_left] using hx.old_support k + · simpa only [attach,appendParent,parent,Fin.addCases_right] using + whole_extracted_prime_dvd p extra x hx.admissible he negative _ (hh k) + +theorem whole_assigned_family_conditions (hp : ∀ i,p i≠0) + (extra : Source ι Jo→Finset ι) + (source : Finset (Source ι Jo)) (hs : ∀ x∈source,SourceValid p x) + (he : ∀ x∈source,extra x⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) + (expansion : SecondParentSource ι (Jo+(J.card+J.card))→Finset (SecondExpansionData ι)) + (hE : ∀ y∈wholeAssignedParents p extra source negative J lists, + ∀ x∈expansion y,x.divisor⊆x.sourceCommon) : + ActualSecondSourceConditions p + (attachedSecondFamily (wholeAssignedParents p extra source negative J lists) expansion) := by + apply attached_family_conditions p _ _ + · intro y hy + obtain ⟨x,hx,q,hq,rfl⟩ := (mem_wholeAssignedParents p extra source negative J lists y).mp hy + exact (hs x hx).admissible + · intro y hy + obtain ⟨x,hx,q,hq,rfl⟩ := (mem_wholeAssignedParents p extra source negative J lists y).mp hy + exact (hs x hx).common_disjoint + · intro y hy + obtain ⟨x,hx,q,hq,rfl⟩ := (mem_wholeAssignedParents p extra source negative J lists y).mp hy + exact (hs x hx).first_divisor + · exact hE + · intro y hy + obtain ⟨x,hx,q,hq,rfl⟩ := (mem_wholeAssignedParents p extra source negative J lists y).mp hy + exact whole_attach_old_support p extra negative J lists x (hs x hx) (he x hx) q hq + · intro y hy + obtain ⟨x,hx,q,hq,rfl⟩ := (mem_wholeAssignedParents p extra source negative J lists y).mp hy + exact sourceIdeal_ne_zero p hp x.quotientSupport + +end SevenEighths.InverseMomentWholePriorityParents + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..87109ec04d52b4e395d4c4fbe05cc59af98ebc96 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityPhysical.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityParents +import OAI.NumberTheory.DirichletL.Inversion.PrioritySecondSource + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMomentWholePriorityPhysical +open ActualEisensteinCubic SecondPassArithmetic FirstPassCubeLabels FirstCauchyArithmetic +open InverseMoment InverseInitialArithmetic InverseFirstPriorityParents +open InverseMomentWholePriorityParents InversePrioritySecondSource +open InversePrincipalEnergy InverseSecondPrincipalCaller RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +variable {ι σ κ : Type*} [DecidableEq ι] [DecidableEq σ] [DecidableEq κ] [Fintype κ] +variable {Jo : ℕ} (p : ι→O) (hp : ∀ i,p i≠0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def fullPhysical (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) + (negative : Bool) (Ψ : O→*ℂ) (m : O) + (slots J : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (V : 𝓢(ℝ,ℂ)) (X Y : ℝ) (r : RayCharacter×RayCharacter) (core : FirstCoreIndex) + (R : Finset ι→Finset ι→ℝ) (label : Finset ι→SecondExpansionData ι→κ) + (y : SecondParentSource ι Jo) : ℂ := + let Ψ₀ := firstCoreTwist negative (if negative then r.1 else r.2) Ψ core + let ll := fun i=>lists i\extra y.cube + let H := markedRadial p (slots\J) (residualLists p negative ll y) a ∅ V X + let K := secondVariableCutoff p y R + truncatedSecondZero p hg pool Ψ₀ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) H rowMajorant Y K + + (∑ ray : SecondRayIndex,∑ residual∈pool.powerset,∑ j : κ, + (Y:ℂ)*secondRayCoefficient ray * + ∑ x∈(secondDyadicSector pool K residual label j).image (attachSecondExpansion y), + retainedRow p hp hcop hg pool negative Ψ₀ m slots J ll a V X Y ray x) + + secondSourceTail p hp hg hinj pool Ψ₀ (secondParentPuncture p m y) + (secondParentLabel p y) (secondParentDivisor p y) H rowMajorant Y K + +theorem whole_parent_full + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) + (negative : Bool) (Ψ : O→*ℂ) (m : O) + (slots J : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (om : 𝓢(ℝ,ℂ)) (lo hi : ℝ) (hlo : 0lists i\extra y.cube) a om X t Y r core y = + fullPhysical p hp hcop hg hinj extra pool negative Ψ m slots J lists a + (principalWindow om lo hi hlo hs negative t) X Y r core R label y := + parentPoisson_full p hp hcop hg hinj hc hpr y pool hq negative Ψ m slots J + (fun i=>lists i\extra y.cube) a om lo hi hlo hs X t Y hX hY r core R label + +omit [DecidableEq σ] in +theorem whole_residual_lists_attach + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (extra : CubeCoordinates ι→Finset ι) (negative : Bool) + (J : Finset σ) (lists : σ→Finset ι) + (q : Source ι Jo×((∀ i∈J,ι)×(∀ i∈J,ι))) : + residualLists p negative (fun i=>lists i\extra (attach p J q).cube) (attach p J q)= + fun i=>lists i\wholeExtractedSupport (fun x=>extra x.cube) negative q.1 := by + rw [residualLists_attach p hinj] + funext i + ext k + simp only [Finset.mem_sdiff,wholeExtractedSupport,Finset.mem_union] + change (k ∈ lists i ∧ k ∉ extra q.1.cube) ∧ k ∉ extractedSupport negative q.1 ↔ _ + tauto + +theorem whole_signed_source_full + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (hc : ∀ i,ringChar (O⧸Ideal.span {p i})≠2) + (hpr : ∀ i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (extra : CubeCoordinates ι→Finset ι) (pool : Finset ι) + (source : Finset (Source ι Jo)) (w : Source ι Jo→ℂ) + (negative : Bool) (Ψ : O→*ℂ) (m : O) + (slots J : Finset σ) (lists : σ→Finset ι) (a : σ→ι→ℂ) + (om : 𝓢(ℝ,ℂ)) (lo hi : ℝ) (hlo : 0extra x.cube) negative x)‖^2:ℝ)* + parentPoisson p hp hg hinj pool negative Ψ m slots J + (fun i=>lists i\extra x.cube) a om X t Y r core (parent p x)) = + ∑ y∈wholeAssignedParents p (fun x=>extra x.cube) source negative J lists, + coefficient p J a w y * + fullPhysical p hp hcop hg hinj extra pool negative Ψ m slots J lists a + (principalWindow om lo hi hlo hs negative t) X Y r core R label y := by + have he := wholePaired_parent_sq_sum p (fun x=>extra x.cube) hinj source negative J lists a w + (fun y=>parentPoisson p hp hg hinj pool negative Ψ m slots J + (fun i=>lists i\extra y.cube) a om X t Y r core y) + refine he.trans ?_ + apply Finset.sum_congr rfl + intro y hy + obtain ⟨x,hx,q,hq,rfl⟩ := + (mem_wholeAssignedParents p (fun x=>extra x.cube) source negative J lists y).mp hy + rw [forget_attach] + apply congrArg (coefficient p J a w (attach p J (x,q))* ·) + have hquot : (attach p J (x,q)).quotient=sourceIdeal p (quotientSupport p (attach p J (x,q))) := by + rw [quotientSupport_attach p hinj];rfl + exact whole_parent_full p hp hcop hg hinj hc hpr extra pool negative Ψ m slots J lists a + om lo hi hlo hs X t Y hX hY r core R label (attach p J (x,q)) hquot + +end SevenEighths.InverseMomentWholePriorityPhysical + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityPrincipal.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityPrincipal.lean new file mode 100644 index 0000000000000000000000000000000000000000..2fc8f105e8063f097a797b8aaa234b96e4a2a982 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityPrincipal.lean @@ -0,0 +1,137 @@ +import OAI.NumberTheory.DirichletL.Descent.SecondVariablePrincipal +import OAI.NumberTheory.DirichletL.Descent.FirstWholeCubePriority +import OAI.NumberTheory.DirichletL.Descent.FirstWholeMarkedColumns + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic RayFourExpansion +open InverseSecondPrincipalCaller InversePrincipalEnergy +local notation "O" => ActualEisensteinCubic.O +variable {ι σ:Type*} [DecidableEq ι] [DecidableEq σ] + (p:ι→O) (hp:∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hg:∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +def wholePriorityPrincipalEnergy + (hinj:Function.Injective (fun i=>Ideal.span {p i})) + (pool:Finset ι) (b:CubeCoordinates ι) (C extra:Finset ι) (negative:Bool) + (Ψ:O→*ℂ) (m d:O) (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (selector:Finset ι→ℂ) (om W:𝓢(ℝ,ℂ)) (X t Y:ℝ) + (R:Finset ι→Finset ι→Finset ι→ℝ) : ℝ := + let A:=extra∪((if negative then b.rightDivisor else b.leftDivisor)∪C) + (32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑D∈pool.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑core:FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative Ψ m D core‖* + ∑J∈slots.powerset,‖primeMark J lists a (A∪D)‖^2* + (let H:=firstCoreTest (primeMark (slots\J) (fun i=>lists i\(A∪D)) a) + (fun u=>om (Real.exp u)) (columnLog p (primeProductNorm p D*X)) negative (-t) D + let Ψ₀:=firstCoreTwist negative (if negative then r.1 else r.2) Ψ core + let m₀:=(m*b0Label p b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit)*∏i∈D,p i + let c₀:=(∏i∈C,p i)*jLabel p b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit + ‖truncatedSecondZero p hg pool Ψ₀ m₀ c₀ d H W Y + (fun G E=>secondPhysicalCutoff p d (R D G E) G E)‖+ + ‖principalRestoration p hg hinj hp pool Ψ₀ m₀ c₀ d H W Y + (fun G E=>secondPhysicalMask p d (R D G E) G E)‖) + +theorem whole_priority_principal_bound (ε:ℝ) (hε:0<ε) : + ∃ (s:Finset (ℕ×ℕ)) (Cp:ℝ),0Ideal.span {p i})) + (_hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (pool:Finset ι) (b:CubeCoordinates ι) (C extra:Finset ι) (negative:Bool) + (Ψ:O→*ℂ) (m d:O) (slots:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (selector:Finset ι→ℂ) (om W:𝓢(ℝ,ℂ)) (lo hi:ℝ) + (_hlo:0hslots (hj hi) (hj hj') hij) (fun i hi=>ha i (hj hi)) (A∪D) + have he:((primeProductNorm p (A∪D))^ε)^2=(primeProductNorm p (A∪D))^(2*ε):=by + rw [←Real.rpow_natCast,←Real.rpow_mul (primeProductNorm_pos p hp _).le] + congr 1;ring + calc + _≤(Cm*(primeProductNorm p (A∪D))^ε)^2:=pow_le_pow_left₀ (norm_nonneg _) hh 2 + _= _:=by rw [mul_pow,he] + have hn (D:Finset ι) : 0≤primeProductNorm p (A∪D):=(primeProductNorm_pos p hp _).le + unfold wholePriorityPrincipalEnergy + dsimp only + have hinner (r:RayCharacter×RayCharacter) (D:Finset ι) (core:FirstCoreIndex) (J:Finset σ) + (hJ:J∈slots.powerset) := hprinc p hp hg hinj hcop (slots\J) (fun i=>lists i\(A∪D)) a + (residual_lists_pairwise slots J lists A D hslots) (residual_coeff_bound slots J lists a A D ha) + pool D b.support (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit + (fun i _=>residual_lists_avoid lists A D i) negative (if negative then r.1 else r.2) Ψ hΨ + m (∏i∈C,p i) d hd core om W lo hi hlo hs M t X Y (R D) hhi hX hY (hR D) + change _≤_ + calc + _≤(32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑D∈pool.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)*∑core:FirstCoreIndex, + ‖firstCoreOuter p hg b.support (fun i=>b.leftExponent i+b.rightExponent i) + b.leftBit b.rightBit negative Ψ m D core‖* + ((2:ℝ)^slots.card*(Cm^2*(primeProductNorm p (A∪D))^(2*ε)*P)) := by + gcongr with r hr D hD core hc + calc + _≤∑J∈slots.powerset,Cm^2*(primeProductNorm p (A∪D))^(2*ε)*P := by + apply Finset.sum_le_sum + intro J hJ + exact mul_le_mul (hm J hJ D) (hinner r D core J hJ) (by positivity) (mul_nonneg (sq_nonneg _) (Real.rpow_nonneg (hn D) _)) + _= _:=by simp only [Finset.sum_const,Finset.card_powerset,nsmul_eq_mul,Nat.cast_pow,Nat.cast_ofNat] + _≤(32*512)*(2:ℝ)^slots.card*∑r:RayCharacter×RayCharacter,∑D∈pool.powerset, + (‖crossCoeff r.1 r.2‖*‖selector D‖)* + ((32*512)*((2:ℝ)^slots.card*(Cm^2*(primeProductNorm p (A∪D))^(2*ε)*P))) := by + gcongr with r hr D hD + rw [←Finset.sum_mul] + exact mul_le_mul_of_nonneg_right (firstCoreOuter_mass p hg b.support + (fun i=>b.leftExponent i+b.rightExponent i) b.leftBit b.rightBit negative Ψ m D (hΨ _)) (mul_nonneg (pow_nonneg (by norm_num) _) + (mul_nonneg (mul_nonneg (sq_nonneg _) (Real.rpow_nonneg (hn D) _)) hP)) + _= ((32*512:ℝ)^2)*((2:ℝ)^slots.card)^2*Cm^2*P* + (∑r:RayCharacter×RayCharacter,‖crossCoeff r.1 r.2‖)* + (∑D∈pool.powerset,‖selector D‖*(primeProductNorm p (A∪D))^(2*ε)) := by + simp only [Finset.mul_sum,Finset.sum_mul] + rw [Finset.sum_comm (s:=pool.powerset)] + apply Finset.sum_congr rfl + intro r hr + apply Finset.sum_congr rfl + intro D hD + ring + _≤ ((32*512:ℝ)^2)*((2:ℝ)^slots.card)^2*Cm^2*P*512* + (∑D∈pool.powerset,‖selector D‖*(primeProductNorm p (A∪D))^(2*ε)) := by + apply mul_le_mul_of_nonneg_right + · apply mul_le_mul_of_nonneg_left + · simpa only [Fintype.sum_prod_type] using crossCoeff_sum_norm_le + · positivity + · exact Finset.sum_nonneg (fun D hD=>mul_nonneg (norm_nonneg _) (Real.rpow_nonneg (hn D) _)) + _= _ := by + have he:((2:ℝ)^slots.card)^2=(4:ℝ)^slots.card:=by rw [←pow_mul,pow_mul'];norm_num + rw [he] + dsimp only [P,A] + ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityRays.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityRays.lean new file mode 100644 index 0000000000000000000000000000000000000000..d88ad31e96bc9d05aaab1775848e0eed967c756c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholePriorityRays.lean @@ -0,0 +1,132 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace SevenEighths.InverseMoment +open ActualEisensteinCubic FirstPassCubeLabels SecondPassArithmetic +open InverseSecondSourceBlocks InverseSecondPrincipalCaller InverseSecondProfileUniform +open FourierBridge CompletedHeight SecondPassIntegration JointLogSeparation +open InverseInitialClippedColumns InverseSecondFibers InverseInitialArithmetic +open InverseWholePriorityRetainedSource RayFourExpansion FirstCauchyArithmetic +local notation "Eis"=>ActualEisensteinCubic.O +variable {ι σ:Type} [DecidableEq ι] [DecidableEq σ] +theorem whole_priority_retained_all_rays + (om:𝓢(ℝ,ℂ)) (lo hi:ℝ) (hlo:0 Ideal.span {p i}))) + (hg : ∀ i,ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p i}) + (_hpr : ∀ i, ConcretePrimeRowBridge.goodLambda^2 ∣ p i-1) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀ i, ringChar (Eis ⧸ Ideal.span {p i}) ≠ 2) + {Jo : ℕ} (extra:CubeCoordinates ι→Finset ι) (pool:Finset ι) + (cube:CubeCoordinates ι) (firstCommon firstDivisor:Finset ι) + (old:Fin Jo→SmoothMobiusCorrection.PrimeIdeal) (selector:Finset ι→ℂ) + (Ψ:Eis→*ℂ) (m:Eis) (ray:RayCharacter×RayCharacter) (core:FirstCoreIndex) + (slots assigned:Finset σ) (lists:σ→Finset ι) (a:σ→ι→ℂ) + (cutoff:SecondParentSource ι (Jo+(assigned.card+assigned.card))→Finset ι→Finset ι→ℝ) + (_hcube:cube.Admissible) (_hcommon:Disjoint firstCommon cube.support) + (_hdivisor:firstDivisor⊆firstCommon∪cube.support) + (_hold:∀D∈pool.powerset,selector D≠0 → ∀i,(old i).val∣ + sourceIdeal p cube.support*sourceIdeal p firstCommon*sourceIdeal p D) + (_hextra:extra cube⊆cube.support), + let source:=unifiedSource p pool + (activeParents p extra pool cube firstCommon firstDivisor old selector negative assigned lists) cutoff + let Ψ₀:=firstCoreTwist negative (if negative then ray.1 else ray.2) Ψ core + ∀ + (Y R L Z X εchild : ℝ) (Vlabel:BlockIndex→ℝ) + (ell Ractive j tcount eta : ℝ) (M r V delta Acol Bfirst tau pi b : ℝ) (ρ : Fin 6 → ℝ) (t : ℝ) + (labels : BlockIndex→Finset (Ideal Eis)) (A : ℝ), + (∀D∈pool.powerset,‖selector D‖≤1) → + (∀i∈assigned,∀k∈lists i,‖a i k‖≤1) → + (∀ i,|ρ i| ≤ B₀ i) → 0 ≤ L → + 1 < Z → 0 < X → 0 < Y → 0≤eta → 2≤Z^eta → + (∀ x ∈ source,x.second.frequency ∈ nonzeroChildFrequencyBall (actualSecondMultiplier p x) R) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,‖ConcreteTraceCRT.eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ Z^(ell+eta)) → + (∀ x∈source,primeProductNorm p (cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit) ≤ Z^(Ractive+eta)) → + (∀ x∈source,Z^(j-eta) ≤ ‖ConcreteTraceCRT.eisEmbedding (jLabel p x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit)‖^2) → + (∀ x∈source,(Ideal.absNorm x.quotient : ℝ) ≤ Z^(tcount+eta)) → + (∀ a,‖Ψ a‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ i∈(slots\assigned),∀ q∈lists i,‖a i q‖ ≤ 1) → + (∀ d∈keys p source,∀ x∈cell p source d,(actualSecondChild p 1 1 x).2.1 ∈ labels d) → + Jo+(assigned.card+assigned.card) ≤ 2*K → (slots\assigned).card ≤ K → (slots\assigned).card ≤ K → 0 ≤ A → + Y=Z^(firstPhysicalHeight M r ell V delta Bfirst j+12*eta+tau) → + X=Z^(r-Acol-Bfirst-tcount) → L=eta*Real.log Z → + (∀d,Vlabel d=secondFormalLabel Bfirst (secondCellExponent Z d 1) (secondCellExponent Z d 2) j+4*eta) → + 2≤Z → 1≤b → b≤Z^(6*eta) → + (∀x∈source,∀i,outerNorms p x i≤Z^(caps i)) → + (∀x∈source,primeProductNorm p x.second.sourceCommon*primeProductNorm p x.second.overlap≤b*X) → + (∀d∈keys p source,εmass*(secondCount ell Ractive j tcount (secondCellExponent Z d 0) + (secondCellExponent Z d 1)+11*eta/2)≤pi) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₁∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayMinus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₁) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₁ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) (-(profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 4)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (∀ z:SecondRayIndex,∀ d∈keys p source,∀ t : Frequency × (Fin 6 → ℝ),∀ J₂∈(slots\assigned).powerset,∀ γ∈actualSecondTriples p 1 1 (cell p source d), + normalizedColumnEnergy p hp hcop hg pool (secondRayPlus Ψ₀ z) + (actualSecondInheritedRadicalPuncture m γ) ((slots\assigned)\J₂) lists a + ((labels d).filter Squarefree) (nonzeroChildFrequencyBall 1 R) (secondLabelWeight K) + (clippedTest ω₂ (Z^(max 0 (secondCellColumnExponent Z X d)-(secondCellColumnExponent Z X d))) ((profileHeight secondLeftSlope secondRightSlope secondKernelSlope t.1 t.2) 5)) + (Z^(max 0 (secondCellColumnExponent Z X d))) Z (max 0 (secondCellColumnExponent Z X d)+(Vlabel d)) ≤ + A*Z^(max 0 (secondCellColumnExponent Z X d)+(Vlabel d)+εchild)*(tripleHeight J t.1*coordinateHeight J t.2)) → + (Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)))* + ‖∑z:SecondRayIndex,(Y:ℂ)*secondRayCoefficient z * + ∑x∈source,sourceWeight p hg cube negative Ψ m selector ray core assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x‖ ≤ + C*A*(1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)* + (1+Cbin*Real.log Z)^4*Z^(r+3*ell+V+48*eta+tau+pi+εchild) := by + obtain ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C,Cbin,hC,hCbin,he⟩:= + whole_priority_retained_fixed_ray (ι:=ι) (σ:=σ) om lo hi hlo hsupport negative + caps hcaps B₀ hB₀ J K εmass hεmass + refine ⟨ω₁,ω₂,af,bf,haf,hab,hc₁,hc₂,hs₁,hs₂,C*(512*32^2),Cbin,by positivity,hCbin,?_⟩ + intro p hp _ hcop hg hpr hinj hc Jo extra pool cube firstCommon firstDivisor old selector + Ψ m ray core slots assigned lists a cutoff hcube hcommon hdivisor hold hextra source Ψ₀ + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + hselector haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass hleft hright + let P:=Z^(firstKappa M r ell V delta Acol Bfirst Ractive)*Real.exp ((9/2:ℝ)*(eta*Real.log Z)) + let H:= (1+‖t‖)^(2*InverseClippingProfiles.momentOrder J)*(1+Cbin*Real.log Z)^4* + Z^(r+3*ell+V+48*eta+tau+pi+εchild) + let S:SecondRayIndex→ℂ:=fun z=>(Y:ℂ)*secondRayCoefficient z * + ∑x∈source,sourceWeight p hg cube negative Ψ m selector ray core assigned a x * + wholeRow p hp hcop hg extra pool negative Ψ₀ m slots assigned lists a + (principalWindow om lo hi hlo hsupport negative t) X Y z x + have hP:0≤P:=by dsimp [P];positivity + have hH:0≤H:=by dsimp [H];positivity + have hz (z:SecondRayIndex):P*‖S z‖≤C*A*H*‖secondRayCoefficient z‖:=by + have h:=he p hp hcop hg hpr hinj hc extra pool cube firstCommon firstDivisor old selector + Ψ m ray core slots assigned lists a cutoff hcube hcommon hdivisor hold hextra z + Y R L Z X εchild Vlabel ell Ractive j tcount eta M r V delta Acol Bfirst tau pi b ρ t labels A + hselector haassigned hρ hL hZ hX hY heta hbin hrows hcube₁ hcube₂ hactive hj hquot hΨ + ha₁ ha₂ hlabels ho hslots₁ hslots₂ hA hYe hXe hLe hVe hZ2 hb hthreshold hnorm hgeom hmass + (hleft z) (hright z) + convert h using 1 ; dsimp only [P,S,H] ; ring + calc + _≤P*∑z:SecondRayIndex,‖S z‖:=mul_le_mul_of_nonneg_left (norm_sum_le _ _) hP + _=∑z:SecondRayIndex,P*‖S z‖:=Finset.mul_sum _ _ _ + _≤∑z:SecondRayIndex,C*A*H*‖secondRayCoefficient z‖:=Finset.sum_le_sum (fun z _=>hz z) + _=C*A*H*(∑z:SecondRayIndex,‖secondRayCoefficient z‖):=(Finset.mul_sum _ _ _).symm + _≤C*A*H*(512*32^2):=mul_le_mul_of_nonneg_left secondRayCoefficient_mass (by positivity) + _= _:=by dsimp [H];ring + +end SevenEighths.InverseMoment + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WholeRetainedSource.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WholeRetainedSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..092a5a9f27ef2f6dc04610072d898f05136459ac --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WholeRetainedSource.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Descent.WholePriorityPhysical +import OAI.NumberTheory.DirichletL.Descent.SecondDeletedModeEnergy + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.InverseMomentWholeRetainedSource +open ActualEisensteinCubic SecondPassArithmetic InverseMoment InverseInitialArithmetic +open InverseFirstPriorityParents InversePrioritySecondSource InverseMomentWholePriorityParents +local notation "O" => ActualEisensteinCubic.O +variable {ι σ κ : Type*} [DecidableEq ι] [DecidableEq σ] [DecidableEq κ] +variable {Jo : ℕ} (p : ι→O) [∀ i,(Ideal.span {p i}).IsMaximal] + +def deleted (extra : CubeCoordinates ι→Finset ι) (negative : Bool) + (x : MarkedSecondSource ι Jo 0) : Finset ι := + extra x.cube∪(((if negative then x.cube.rightDivisor else x.cube.leftDivisor)∪x.firstCommon)∪ + quotientSupport p (secondParentOf x)) + +theorem retained_conditions (hp : ∀ i,p i≠0) + (extra : CubeCoordinates ι→Finset ι) + (source : Finset (Source ι Jo)) (hs : ∀ x∈source,SourceValid p x) + (hextra : ∀ x∈source,extra x.cube⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (R : SecondParentSource ι (Jo+(J.card+J.card))→Finset ι→Finset ι→ℝ) + (label : SecondParentSource ι (Jo+(J.card+J.card))→Finset ι→SecondExpansionData ι→κ) + (residual : Finset ι) (j : κ) : + ActualSecondSourceConditions p + (retainedPool p pool (wholeAssignedParents p (fun x=>extra x.cube) source negative J lists) + R label residual j) := by + apply whole_assigned_family_conditions p hp (fun x=>extra x.cube) source hs hextra negative J lists + intro y hy x hx + exact (second_variable_original_support p y pool residual (R y) (label y) j x hx).2.1 + +theorem retained_deleted_support + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (extra : CubeCoordinates ι→Finset ι) + (source : Finset (Source ι Jo)) (hs : ∀ x∈source,SourceValid p x) + (hextra : ∀ x∈source,extra x.cube⊆x.cube.support) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) (pool : Finset ι) + (R : SecondParentSource ι (Jo+(J.card+J.card))→Finset ι→Finset ι→ℝ) + (label : SecondParentSource ι (Jo+(J.card+J.card))→Finset ι→SecondExpansionData ι→κ) + (residual : Finset ι) (j : κ) (x : MarkedSecondSource ι (Jo+(J.card+J.card)) 0) + (hx : x∈retainedPool p pool (wholeAssignedParents p (fun x=>extra x.cube) source negative J lists) + R label residual j) : + ∀ i∈deleted p extra negative x,i∈x.cube.support∪x.firstCommon ∨ (Ideal.span {p i}:Ideal O)∣x.quotient := by + have hy := ((mem_retainedPool p pool _ R label residual j x).mp hx).1 + obtain ⟨s,hs₀,q,hq,he⟩ := (mem_wholeAssignedParents p (fun x=>extra x.cube) source negative J lists _).mp hy + have hc : x.cube=s.cube := (congrArg SecondParentSource.cube he).symm + have hC : x.firstCommon=s.firstCommon := (congrArg SecondParentSource.firstCommon he).symm + have ht : x.quotient=sourceIdeal p s.quotientSupport := (congrArg SecondParentSource.quotient he).symm + have hqs : quotientSupport p (secondParentOf x)=s.quotientSupport := by + rw [←he,quotientSupport_attach p hinj] + intro i hi + change i∈extra x.cube∪(((if negative then x.cube.rightDivisor else x.cube.leftDivisor)∪x.firstCommon)∪ + quotientSupport p (secondParentOf x)) at hi + rw [hc,hC,hqs] at hi + rcases Finset.mem_union.mp hi with hi|hi + · exact Or.inl (Finset.mem_union_left _ (hc.symm ▸ hextra s hs₀ hi)) + · rcases Finset.mem_union.mp hi with hi|hi + · left + rw [hc,hC] + rcases Finset.mem_union.mp hi with hi|hi + · apply Finset.mem_union_left + cases negative <;> simp only [Bool.false_eq_true,ite_false,ite_true] at hi + · exact (hs s hs₀).admissible.1 hi + · exact (hs s hs₀).admissible.2 hi + · exact Finset.mem_union_right _ hi + · right + rw [ht] + exact source_prime_dvd p _ i hi + +theorem whole_coefficient_norm + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (extra : Source ι Jo→Finset ι) (source : Finset (Source ι Jo)) + (negative : Bool) (J : Finset σ) (lists : σ→Finset ι) + (a : σ→ι→ℂ) (w : Source ι Jo→ℂ) (B : ℝ) + (ha : ∀ i∈J,∀ k∈lists i,‖a i k‖≤1) (hw : ∀ x∈source,‖w x‖≤B) + (y : SecondParentSource ι (Jo+(J.card+J.card))) + (hy : y∈wholeAssignedParents p extra source negative J lists) : + ‖coefficient p J a w y‖≤B := by + obtain ⟨x,hx,q,hq,rfl⟩ := (mem_wholeAssignedParents p extra source negative J lists y).mp hy + rw [coefficient_attach p hinj,norm_mul] + exact (mul_le_of_le_one_right (norm_nonneg _) (pairedSlotWeight_norm_le_one J J lists lists a a + _ q hq ha ha)).trans (hw x hx) + +end SevenEighths.InverseMomentWholeRetainedSource + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/Widths.lean b/lean/OAI/NumberTheory/DirichletL/Descent/Widths.lean new file mode 100644 index 0000000000000000000000000000000000000000..379aed26208623bc8eb27ad570846f18fd7f11a9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/Widths.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Foundation + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical +open CompletedGauss +noncomputable section +local notation "Eis" => ActualEisensteinCubic.O + +lemma actual_ideal_norm_pos (I : Ideal Eis) (hI : I ≠ 0) : 0 < (Ideal.absNorm I : ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun hz => hI (Ideal.absNorm_eq_zero_iff.mp hz)) + +theorem actual_residual_norm_width (I Q : Ideal Eis) (hI : I ≠ 0) : + (Ideal.absNorm (rowResidualPart I Q) : ℝ) * + (Ideal.absNorm (rowPowerfulPart I) : ℝ) ≤ (Ideal.absNorm I : ℝ) := by + have hm : 1 ≤ (Ideal.absNorm (rowMaskPart I Q) : ℝ) := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (fun hz => + squarefreeMaskPart_ne_zero (rowSimplePart I) Q (Ideal.absNorm_eq_zero_iff.mp hz)) + have he := congrArg (fun J : Ideal Eis => (Ideal.absNorm J : ℝ)) + (row_powerful_mask_residual_product I Q hI) + simp only [map_mul, Nat.cast_mul] at he + calc + _ ≤ (Ideal.absNorm (rowPowerfulPart I) : ℝ) * + (Ideal.absNorm (rowMaskPart I Q) : ℝ) * (Ideal.absNorm (rowResidualPart I Q) : ℝ) := by + have hh := mul_le_mul_of_nonneg_left hm + (show 0 ≤ (Ideal.absNorm (rowResidualPart I Q) : ℝ) * + (Ideal.absNorm (rowPowerfulPart I) : ℝ) by positivity) + nlinarith [hh] + _ = _ := he + +theorem actual_common_width_charge {ι : Type*} [Fintype ι] + (I F Q : Ideal Eis) (hI : I ≠ 0) (hQ : Q ≠ 0) + (P : ι → Ideal Eis) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (fun i j => IsCoprime (P i) (P j))) + (hpool : ∀ i, P i ∣ I * Q) + (hres : ∀ i, ¬ P i ∣ rowResidualPart I Q) (e : ι → Fin 3) : + (Ideal.absNorm (rowResidualPart I Q) : ℝ)^2 * + reflectionConductorCost P (fun i => completedLocalExponent I F (P i)) e ≤ + (Ideal.absNorm I : ℝ)^2 / (Ideal.absNorm (rowPowerfulPart I) : ℝ) * + (Ideal.absNorm Q : ℝ) := by + have hp := actual_ideal_norm_pos (rowPowerfulPart I) (rowPowerfulPart_ne_zero I) + have hm := actual_ideal_norm_pos (rowMaskPart I Q) + (squarefreeMaskPart_ne_zero (rowSimplePart I) Q) + have he := rowResidualPart_norm I Q hI + calc + _ ≤ (Ideal.absNorm (rowResidualPart I Q) : ℝ)^2 * + ((Ideal.absNorm (rowPowerfulPart I) : ℝ) * + (Ideal.absNorm (rowMaskPart I Q) : ℝ)^2 * (Ideal.absNorm Q : ℝ)) := + mul_le_mul_of_nonneg_left (reflectionConductorCost_bound I F Q hI hQ P hcop hpool hres e) + (sq_nonneg _) + _ = _ := by rw [he]; field_simp + +theorem actual_common_width_charge_label_puncture {ι : Type*} [Fintype ι] + (I F rho S : Ideal Eis) (hI : I ≠ 0) (hF : F ≠ 0) (hrho : rho ≠ 0) (hS : S ≠ 0) + (P : ι → Ideal Eis) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (fun i j => IsCoprime (P i) (P j))) + (hpool : ∀ i, P i ∣ I * (S * F * rho)) + (hres : ∀ i, ¬ P i ∣ rowResidualPart I (S * F * rho)) (e : ι → Fin 3) : + (Ideal.absNorm (rowResidualPart I (S * F * rho)) : ℝ)^2 * + reflectionConductorCost P (fun i => completedLocalExponent I F (P i)) e ≤ + (Ideal.absNorm S : ℝ) * + ((Ideal.absNorm I : ℝ)^2 / (Ideal.absNorm (rowPowerfulPart I) : ℝ)) * + (Ideal.absNorm F : ℝ) * (Ideal.absNorm rho : ℝ) := by + convert actual_common_width_charge I F (S * F * rho) hI + (mul_ne_zero (mul_ne_zero hS hF) hrho) P hcop hpool hres e using 1 + simp only [map_mul, Nat.cast_mul] + ring + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Descent/WindowFourier.lean b/lean/OAI/NumberTheory/DirichletL/Descent/WindowFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..c554c4a828059ea5576e2a923ae1bc074c5cfd3c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Descent/WindowFourier.lean @@ -0,0 +1,138 @@ +import OAI.NumberTheory.DirichletL.Descent.ActualProfiles +import Mathlib.MeasureTheory.Integral.Pi + +namespace OAI + +namespace SevenEighths.InverseMoment +open scoped BigOperators Classical SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge JointLogSeparation +noncomputable section + +variable {ι : Type*} [Fintype ι] + +def coordinateDensity (g : ι → 𝓢(ℝ, ℂ)) (t : ι → ℝ) : ℂ := + ∏ i, (𝓕 (g i)) (t i) + +def coordinatePhase (t y : ι → ℝ) : ℂ := ∏ i, logPhase (t i) (y i) + +theorem coordinate_fourier_inversion (g : ι → 𝓢(ℝ, ℂ)) (y : ι → ℝ) : + (∏ i, g i (y i)) = ∫ t : ι → ℝ, coordinateDensity g t * coordinatePhase t y := by + simp only [coordinateDensity, coordinatePhase, ← Finset.prod_mul_distrib] + have hp := integral_fintype_prod_volume_eq_prod (E := fun _ : ι => ℝ) + (fun (i : ι) (t : ℝ) => (𝓕 (g i) : 𝓢(ℝ, ℂ)) t * logPhase t (y i)) + rw [hp] + apply Finset.prod_congr rfl + intro i hi + simpa only [mul_comm] using schwartz_logPhase_inversion (g i) (y i) + +theorem coordinate_density_weighted_integrable (g : ι → 𝓢(ℝ, ℂ)) (J : ℕ) : + Integrable (fun t : ι → ℝ => (∏ i, (1 + ‖t i‖)^J) * ‖coordinateDensity g t‖) := by + have hi (i : ι) := AnalyticBridge.schwartz_fourier_one_plus_integrable (g i) J + convert Integrable.fintype_prod hi using 1 + funext t + simp only [coordinateDensity, norm_prod, Finset.prod_mul_distrib] + +theorem coordinate_density_weighted_integral (g : ι → 𝓢(ℝ, ℂ)) (J : ℕ) : + (∫ t : ι → ℝ, (∏ i, (1 + ‖t i‖)^J) * ‖coordinateDensity g t‖) = + ∏ i, ∫ t : ℝ, (1 + ‖t‖)^J * ‖(𝓕 (g i)) t‖ := by + simp only [coordinateDensity, norm_prod, ← Finset.prod_mul_distrib] + exact integral_fintype_prod_volume_eq_prod (E := fun _ : ι => ℝ) + (fun i t => (1 + ‖t‖)^J * ‖(𝓕 (g i)) t‖) + +def pureProfileMode (a₁ a₂ ak : ι → ℝ) (y : ι → ℝ) + (t : Frequency) (u : ι → ℝ) : ℂ := + ∏ i, logPhase (u i) (y i) * logPhase t.1 (a₁ i * y i) * + logPhase t.2.1 (a₂ i * y i) * logPhase t.2.2 (ak i * y i) + +theorem profileMode_coordinate_separation (g : ι → 𝓢(ℝ, ℂ)) + (a₁ a₂ ak : ι → ℝ) (y : ι → ℝ) (t : Frequency) : + profileMode (fun i => g i) a₁ a₂ ak y t = + ∫ u : ι → ℝ, coordinateDensity g u * pureProfileMode a₁ a₂ ak y t u := by + simp only [profileMode, pureProfileMode, Finset.prod_mul_distrib] + simp only [← mul_assoc] + rw [integral_mul_const, integral_mul_const, integral_mul_const] + have he := coordinate_fourier_inversion g y + simp only [coordinatePhase] at he + rw [← he] + + theorem pureProfileMode_norm (a₁ a₂ ak : ι → ℝ) (y : ι → ℝ) + (t : Frequency) (u : ι → ℝ) : ‖pureProfileMode a₁ a₂ ak y t u‖ = 1 := by + simp [pureProfileMode, norm_prod, logPhase_norm] + +def fullProfileDensity (g : ι → 𝓢(ℝ, ℂ)) (b₁ b₂ b₃ : 𝓢(ℝ, ℂ)) + (p : Frequency × (ι → ℝ)) : ℂ := + tripleCoefficient b₁ b₂ b₃ p.1 * coordinateDensity g p.2 + +def tripleHeight (J : ℕ) (t : Frequency) : ℝ := + (1 + ‖t.1‖)^J * (1 + ‖t.2.1‖)^J * (1 + ‖t.2.2‖)^J + +def coordinateHeight (J : ℕ) (u : ι → ℝ) : ℝ := ∏ i, (1 + ‖u i‖)^J + +theorem fullProfileDensity_weighted_integrable (g : ι → 𝓢(ℝ, ℂ)) + (b₁ b₂ b₃ : 𝓢(ℝ, ℂ)) (J : ℕ) : + Integrable (fun p : Frequency × (ι → ℝ) => + tripleHeight J p.1 * coordinateHeight J p.2 * ‖fullProfileDensity g b₁ b₂ b₃ p‖) := by + convert (tripleCoefficient_weighted_integrable b₁ b₂ b₃ J).mul_prod + (coordinate_density_weighted_integrable g J) using 1 + funext p + simp only [tripleHeight, coordinateHeight, fullProfileDensity, norm_mul] + ring + +theorem fullProfileDensity_weighted_integral (g : ι → 𝓢(ℝ, ℂ)) + (b₁ b₂ b₃ : 𝓢(ℝ, ℂ)) (J : ℕ) : + (∫ p : Frequency × (ι → ℝ), + tripleHeight J p.1 * coordinateHeight J p.2 * ‖fullProfileDensity g b₁ b₂ b₃ p‖) = + (∫ t : Frequency, tripleHeight J t * ‖tripleCoefficient b₁ b₂ b₃ t‖) * + (∏ i, ∫ u : ℝ, (1 + ‖u‖)^J * ‖(𝓕 (g i)) u‖) := by + have he (p : Frequency × (ι → ℝ)) : + tripleHeight J p.1 * coordinateHeight J p.2 * ‖fullProfileDensity g b₁ b₂ b₃ p‖ = + (tripleHeight J p.1 * ‖tripleCoefficient b₁ b₂ b₃ p.1‖) * + (coordinateHeight J p.2 * ‖coordinateDensity g p.2‖) := by + simp only [fullProfileDensity, norm_mul] + ring + simp_rw [he] + simp only [Measure.volume_eq_prod] + rw [integral_prod_mul (fun t : Frequency => tripleHeight J t * ‖tripleCoefficient b₁ b₂ b₃ t‖) + (fun u : ι → ℝ => coordinateHeight J u * ‖coordinateDensity g u‖)] + simp only [coordinateHeight] + rw [coordinate_density_weighted_integral g J] + +theorem profile_integral_coordinate_absorption (g : ι → 𝓢(ℝ, ℂ)) + (b₁ b₂ b₃ : 𝓢(ℝ, ℂ)) (a₁ a₂ ak y : ι → ℝ) : + (∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, + tripleCoefficient b₁ b₂ b₃ (t₁,t₂,t₃) * + profileMode (fun i => g i) a₁ a₂ ak y (t₁,t₂,t₃)) = + ∫ t₁ : ℝ, ∫ t₂ : ℝ, ∫ t₃ : ℝ, ∫ u : ι → ℝ, + fullProfileDensity g b₁ b₂ b₃ ((t₁,t₂,t₃),u) * + pureProfileMode a₁ a₂ ak y (t₁,t₂,t₃) u := by + apply integral_congr_ae + filter_upwards with t₁ + apply integral_congr_ae + filter_upwards with t₂ + apply integral_congr_ae + filter_upwards with t₃ + rw [profileMode_coordinate_separation, ← integral_const_mul] + apply integral_congr_ae + filter_upwards with u + simp only [fullProfileDensity] + ring + +def profileHeight (a₁ a₂ ak : ι → ℝ) (t : Frequency) (u : ι → ℝ) (i : ι) : ℝ := + u i + a₁ i * t.1 + a₂ i * t.2.1 + ak i * t.2.2 + +lemma logPhase_scaled_coordinate (t a y : ℝ) : logPhase t (a*y) = logPhase (a*t) y := by + unfold logPhase + congr 1 + push_cast + ring + +theorem pureProfileMode_height (a₁ a₂ ak y : ι → ℝ) (t : Frequency) (u : ι → ℝ) : + pureProfileMode a₁ a₂ ak y t u = ∏ i, logPhase (profileHeight a₁ a₂ ak t u i) (y i) := by + apply Finset.prod_congr rfl + intro i hi + simp only [profileHeight, logPhase_add_frequency, logPhase_scaled_coordinate] + +end +end SevenEighths.InverseMoment + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector.lean b/lean/OAI/NumberTheory/DirichletL/Detector.lean new file mode 100644 index 0000000000000000000000000000000000000000..f92afb283513e01713f9ea5af83d8f2305342c5d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector.lean @@ -0,0 +1,131 @@ +import Mathlib.Analysis.SpecialFunctions.Pow.Real +import Mathlib.Analysis.Complex.Norm +import Mathlib.Algebra.Order.BigOperators.Group.Finset +import Mathlib.Data.Finset.Max +import Mathlib.Algebra.Order.Floor.Semiring +import Mathlib.Tactic.Linarith +import Mathlib.Tactic.Ring + +namespace OAI + +namespace SevenEighths.Detector + +theorem exists_small_increment (M : ℕ → ℝ) {n : ℕ} (hn : 0 < n) + {lo hi e : ℝ} (hlo : lo ≤ M 0) (hhi : M n ≤ hi) + (hwidth : hi - lo ≤ n * e) : + ∃ i < n, M (i + 1) - M i ≤ e := by + by_contra h + have hinc : ∀ i ∈ Finset.range n, e < M (i + 1) - M i := by + intro i hi + exact lt_of_not_ge (fun hle => h ⟨i, Finset.mem_range.mp hi, hle⟩) + have hs := Finset.sum_lt_sum_of_nonempty (Finset.nonempty_range_iff.mpr (Nat.ne_of_gt hn)) hinc + simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul, + Finset.sum_range_sub] at hs + linarith + +theorem buffered_bin_of_rounding {x y a e : ℝ} + (hround : a ≤ x ∧ x < a + e) (hstep : y - x ≤ e) : + a ≤ x ∧ x < a + e ∧ y < a + 2 * e := by + exact ⟨hround.1, hround.2, by linarith [hround.2]⟩ + +theorem exists_grid_rounding {base x e : ℝ} (he : 0 < e) (hx : base ≤ x) : + ∃ k : ℕ, base + e * k ≤ x ∧ x < base + e * k + e := by + let k := ⌊(x - base) / e⌋₊ + have hnonneg : 0 ≤ (x - base) / e := div_nonneg (sub_nonneg.mpr hx) he.le + have hlo := Nat.floor_le hnonneg + have hhi := Nat.lt_floor_add_one ((x - base) / e) + have hlo' := (le_div_iff₀ he).mp hlo + have hhi' := (div_lt_iff₀ he).mp hhi + refine ⟨k, ?_, ?_⟩ <;> dsimp [k] <;> nlinarith + +theorem exists_buffered_bin (M : ℕ → ℝ) {n : ℕ} (hn : 0 < n) + {e : ℝ} (he : 0 < e) + (hbound : ∀ j ≤ n, (51 / 100 : ℝ) ≤ M j ∧ M j ≤ 1) + (hwidth : (49 / 100 : ℝ) ≤ n * e) : + ∃ i < n, ∃ k : ℕ, + let a : ℝ := 51 / 100 + e * k + a ≤ 1 ∧ a ≤ M i ∧ M i < a + e ∧ M (i + 1) < a + 2 * e := by + obtain ⟨i, hi, hstep⟩ := exists_small_increment M hn (e := e) + (hbound 0 (Nat.zero_le _)).1 (hbound n le_rfl).2 (by linarith) + obtain ⟨k, hklo, hkhi⟩ := exists_grid_rounding he (hbound i hi.le).1 + refine ⟨i, hi, k, ?_, hklo, hkhi, ?_⟩ + · exact hklo.trans (hbound i hi.le).2 + · linarith + +theorem maximal_zero_of_floor_lt {ι : Type*} (L : ι → ℂ → ℂ) + (zeros : Finset (ι × ℂ)) {floor M : ℝ} + (hzero : ∀ p ∈ zeros, L p.1 p.2 = 0) + (hmax : M ∈ insert floor (zeros.image (fun p => p.2.re))) + (hfloor : floor < M) : + ∃ χ ρ, (χ, ρ) ∈ zeros ∧ L χ ρ = 0 ∧ ρ.re = M := by + classical + rcases Finset.mem_insert.mp hmax with h | h + · exact False.elim ((ne_of_gt hfloor) h) + · obtain ⟨⟨χ, ρ⟩, hp, heq⟩ := Finset.mem_image.mp h + exact ⟨χ, ρ, hp, hzero _ hp, heq⟩ + +theorem simultaneous_saturation {U δ r m ε A B : ℝ} + (hU : 1 < U) (hδ : (1 / 50 : ℝ) ≤ δ) (hε : 0 ≤ ε) + (hA : 0 ≤ A) (hB : 0 ≤ B) + (hprod : U ^ (δ * (r + m) - ε) ≤ A * B) + (hupperA : A ≤ U ^ (δ * r + ε)) + (hupperB : B ≤ U ^ (δ * min m (1 - m) + ε)) : + m ≤ 1 / 2 + 75 * ε ∧ + U ^ (δ * r - 2 * ε) ≤ A ∧ U ^ (δ * m - 2 * ε) ≤ B := by + have hU0 : 0 < U := by linarith + have hδ0 : 0 ≤ δ := by linarith + have hBcoarse : B ≤ U ^ (δ * m + ε) := by + apply hupperB.trans + exact Real.rpow_le_rpow_of_exponent_le hU.le + (by have h := mul_le_mul_of_nonneg_left (min_le_left m (1 - m)) hδ0; linarith) + have hpupper : A * B ≤ U ^ (δ * r + ε + (δ * min m (1 - m) + ε)) := by + rw [Real.rpow_add hU0] + exact mul_le_mul hupperA hupperB hB (Real.rpow_nonneg hU0.le _) + have hexp := (Real.rpow_le_rpow_left_iff hU).mp (hprod.trans hpupper) + have hlength : m ≤ 1 / 2 + 75 * ε := by + by_cases hm : m ≤ 1 / 2 + · linarith + · have hmin : min m (1 - m) = 1 - m := min_eq_right (by linarith) + rw [hmin] at hexp + have hm0 : 0 ≤ m - 1 / 2 := by linarith + have hmul := mul_le_mul_of_nonneg_right hδ hm0 + nlinarith + have hlowerA : U ^ (δ * r - 2 * ε) ≤ A := by + have hp : U ^ (δ * r - 2 * ε) * U ^ (δ * m + ε) ≤ + A * U ^ (δ * m + ε) := by + calc + _ = U ^ (δ * (r + m) - ε) := by rw [← Real.rpow_add hU0]; congr 1; ring + _ ≤ A * B := hprod + _ ≤ _ := mul_le_mul_of_nonneg_left hBcoarse hA + have hpos := Real.rpow_pos_of_pos hU0 (δ * m + ε) + nlinarith + have hlowerB : U ^ (δ * m - 2 * ε) ≤ B := by + have hp : U ^ (δ * m - 2 * ε) * U ^ (δ * r + ε) ≤ + B * U ^ (δ * r + ε) := by + calc + _ = U ^ (δ * (r + m) - ε) := by rw [← Real.rpow_add hU0]; congr 1; ring + _ ≤ A * B := hprod + _ ≤ _ := by simpa [mul_comm] using mul_le_mul_of_nonneg_right hupperA hB + have hpos := Real.rpow_pos_of_pos hU0 (δ * r + ε) + nlinarith + exact ⟨hlength, hlowerA, hlowerB⟩ + +theorem inverse_length_of_saturation {r m t ε κ : ℝ} + (hsupport : t - κ ≤ r + m) (hplain : m ≤ 1 / 2 + 75 * ε) : + t - 1 / 2 - 75 * ε - κ ≤ r := by linarith + +theorem complex_simultaneous_saturation {U δ r m ε : ℝ} {M S : ℂ} + (hU : 1 < U) (hδ : (1 / 50 : ℝ) ≤ δ) (hε : 0 ≤ ε) + (hprod : U ^ (δ * (r + m) - ε) ≤ ‖M * S‖ ^ 2) + (hupperM : ‖M‖ ^ 2 ≤ U ^ (δ * r + ε)) + (hupperS : ‖S‖ ^ 2 ≤ U ^ (δ * min m (1 - m) + ε)) : + m ≤ 1 / 2 + 75 * ε ∧ + U ^ (δ * r - 2 * ε) ≤ ‖M‖ ^ 2 ∧ + U ^ (δ * m - 2 * ε) ≤ ‖S‖ ^ 2 := by + apply simultaneous_saturation hU hδ hε (sq_nonneg _) (sq_nonneg _) + _ hupperM hupperS + simpa only [norm_mul, mul_pow] using hprod + +end SevenEighths.Detector + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Basic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Basic.lean new file mode 100644 index 0000000000000000000000000000000000000000..5538171b0e1898289e3bb82428388c30acddd320 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Basic.lean @@ -0,0 +1,58 @@ +import Mathlib.Analysis.SpecialFunctions.Pow.Real +import Mathlib.Analysis.Complex.Norm +import Mathlib.Algebra.BigOperators.GroupWithZero.Finset +import Mathlib.Tactic.FieldSimp +import Mathlib.Tactic.Positivity +import Mathlib.Tactic.Ring + +namespace OAI + +namespace SevenEighths.Probe +noncomputable section + +def principalScalar {ι : Type*} (slots : Finset ι) (Z ℓ : ℝ) (S : ι → ℝ) : ℝ := + (-1) ^ slots.card * Z ^ (-ℓ / 6) * ∏ i ∈ slots, S i + +theorem principalScalar_ne_zero {ι : Type*} (slots : Finset ι) + {Z ℓ : ℝ} {S : ι → ℝ} (hZ : 0 < Z) + (hS : ∀ i ∈ slots, 0 < S i) : principalScalar slots Z ℓ S ≠ 0 := by + unfold principalScalar + apply mul_ne_zero + · exact mul_ne_zero (pow_ne_zero _ (by norm_num)) + (ne_of_gt (Real.rpow_pos_of_pos hZ _)) + · exact ne_of_gt (Finset.prod_pos hS) + +def normalizedProbe (I A : ℝ → ℂ) (c : ℂ) (Z : ℝ) : ℂ := I Z / (c * A Z) + +theorem normalizedProbe_error (I A f : ℝ → ℂ) {c : ℂ} {Z : ℝ} + (hc : c ≠ 0) (hA : A Z ≠ 0) : + normalizedProbe I A c Z - f Z = (I Z - (c * A Z) * f Z) / (c * A Z) := by + unfold normalizedProbe + field_simp + +theorem norm_div_bound {I B : ℂ} {Z C D a ε : ℝ} (hZ : 0 < Z) + (hI : ‖I‖ ≤ C * Z ^ a) (hB : ‖B⁻¹‖ ≤ D * Z ^ ε) : + ‖I / B‖ ≤ (C * D) * Z ^ (a + ε) := by + rw [div_eq_mul_inv, norm_mul, Real.rpow_add hZ] + calc + ‖I‖ * ‖B⁻¹‖ ≤ (C * Z ^ a) * (D * Z ^ ε) := + mul_le_mul hI hB (norm_nonneg _) ((norm_nonneg _).trans hI) + _ = C * D * (Z ^ a * Z ^ ε) := by ring + +theorem common_normalization_bounds (I A f : ℝ → ℂ) {c : ℂ} + {Z C_low C_high D a b ε : ℝ} (hZ : 0 < Z) + (hc : c ≠ 0) (hA : A Z ≠ 0) + (hrecip : ‖(c * A Z)⁻¹‖ ≤ D * Z ^ ε) + (hlow : ‖I Z‖ ≤ C_low * Z ^ a) + (hhigh : ‖I Z - (c * A Z) * f Z‖ ≤ C_high * Z ^ b) : + ‖normalizedProbe I A c Z‖ ≤ (C_low * D) * Z ^ (a + ε) ∧ + ‖normalizedProbe I A c Z - f Z‖ ≤ (C_high * D) * Z ^ (b + ε) := by + constructor + · exact norm_div_bound hZ hlow hrecip + · rw [normalizedProbe_error I A f hc hA] + exact norm_div_bound hZ hhigh hrecip + +end +end SevenEighths.Probe + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Calibration.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Calibration.lean new file mode 100644 index 0000000000000000000000000000000000000000..f67676aea3b2ce2a644590437bc69dd316bf707c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Calibration.lean @@ -0,0 +1,192 @@ +import OAI.NumberTheory.DirichletL.Detector.Physical +import Mathlib.Algebra.Group.Pi.Units + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss ConcreteTraceCRT ConcretePrimeRowBridge CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +def crtCharacter {ι T : Type*} [Fintype ι] [CommRing T] + (R : ι → Type*) [∀ i, Field (R i)] (e : T ≃+* ∀ i, R i) + (χ : ∀ i, MulChar (R i) ℂ) : MulChar T ℂ where + toFun x := ∏ i, χ i (e x i) + map_one' := by simp + map_mul' x y := by simp [Finset.prod_mul_distrib] + map_nonunit' x hx := by + have he : ¬∀ i, IsUnit (e x i) := by + intro h + apply hx + have hu := (Pi.isUnit_iff.mpr h).map e.symm.toMonoidHom + simpa using hu + obtain ⟨i, hi⟩ := not_forall.mp he + apply Finset.prod_eq_zero (Finset.mem_univ i) + exact (χ i).map_nonunit hi + +theorem crtCharacter_pow_six {ι T : Type*} [Fintype ι] [CommRing T] + (R : ι → Type*) [∀ i, Field (R i)] (e : T ≃+* ∀ i, R i) + (χ : ∀ i, MulChar (R i) ℂ) (hχ : ∀ i, χ i ^ 6 = 1) : + crtCharacter R e χ ^ 6 = 1 := by + apply MulChar.ext + intro x + rw [MulChar.pow_apply' _ (by decide : (6 : ℕ) ≠ 0), MulChar.one_apply x.isUnit] + change (∏ i, χ i (e x i)) ^ 6 = 1 + rw [← Finset.prod_pow] + apply Finset.prod_eq_one + intro i _ + have hu : IsUnit (e x i) := (Pi.isUnit_iff.mp (x.isUnit.map e.toMonoidHom)) i + have he := congrArg (fun f : MulChar (R i) ℂ => f (e x i)) (hχ i) + simpa only [MulChar.pow_apply' _ (by decide : (6 : ℕ) ≠ 0), MulChar.one_apply hu] using he + +theorem residue_char_ne_two_of_lambda_mem (P : Ideal O) [P.IsMaximal] + (hg : goodLambda ∈ P) : ringChar (O ⧸ P) ≠ 2 := by + let : Field (O ⧸ P) := Ideal.Quotient.field _ + intro hc + have hd : goodLambda ∣ (3 : O) := + (dvd_pow_self goodLambda (by decide : (2 : ℕ) ≠ 0)).trans lambda_sq_dvd_three + obtain ⟨k, hk⟩ := hd + have h3m : (3 : O) ∈ P := by rw [hk]; exact P.mul_mem_right k hg + have h3 : (3 : O ⧸ P) = 0 := by + simpa only [map_ofNat] using Ideal.Quotient.eq_zero_iff_mem.mpr h3m + have h2 : (2 : O ⧸ P) = 0 := by + exact (ringChar.spec (O ⧸ P) 2).mpr (by rw [hc]) + have h1 : (1 : O ⧸ P) = 0 := by linear_combination h3 - h2 + exact one_ne_zero h1 + +theorem exists_local_calibration (P : Ideal O) [P.IsMaximal] : + ∃ χ : MulChar (O ⧸ P) ℂ, χ ≠ 1 ∧ χ ^ 6 = 1 := by + let : Field (O ⧸ P) := Ideal.Quotient.field _ + let : Fintype (O ⧸ P) := Fintype.ofFinite _ + by_cases hg : goodLambda ∉ P + · refine ⟨actualSextic P hg ^ 2, ?_, ?_⟩ + · intro h + exact ((MulChar.ringHomComp_ne_one_iff eisEmbedding_injective).mpr + (cubicChar_ne_one P hg)) ((canonicalSextic_pow_two P hg).symm.trans h) + · calc + (actualSextic P hg ^ 2) ^ 6 = actualSextic P hg ^ (2 * 6) := (pow_mul _ 2 6).symm + _ = actualSextic P hg ^ (6 * 2) := rfl + _ = (actualSextic P hg ^ 6) ^ 2 := pow_mul _ 6 2 + _ = (1 : MulChar (O ⧸ P) ℂ) ^ 2 := + congrArg (fun χ : MulChar (O ⧸ P) ℂ => χ ^ 2) + (CanonicalRowCompletion.actualSextic_sixth_one P hg) + _ = 1 := one_pow 2 + · have hchar := residue_char_ne_two_of_lambda_mem P (not_not.mp hg) + let χ : MulChar (O ⧸ P) ℂ := (quadraticChar (O ⧸ P)).ringHomComp (Int.castRingHom ℂ) + refine ⟨χ, ?_, ?_⟩ + · exact (MulChar.ringHomComp_ne_one_iff Int.cast_injective).mpr (quadraticChar_ne_one hchar) + · have h2 : χ ^ 2 = 1 := by + dsimp only [χ] + rw [MulChar.ringHomComp_pow, (quadraticChar_isQuadratic (O ⧸ P)).sq_eq_one, + MulChar.ringHomComp_one] + rw [show (6 : ℕ) = 2 * 3 by decide, pow_mul, h2, one_pow] + +def localCalibration (P : Ideal O) [P.IsMaximal] : MulChar (O ⧸ P) ℂ := + Classical.choose (exists_local_calibration P) + +theorem localCalibration_nonprincipal (P : Ideal O) [P.IsMaximal] : + localCalibration P ≠ 1 := (Classical.choose_spec (exists_local_calibration P)).1 + +theorem localCalibration_pow_six (P : Ideal O) [P.IsMaximal] : + localCalibration P ^ 6 = 1 := (Classical.choose_spec (exists_local_calibration P)).2 + +def calibrationFromPrimes {ι : Type*} [Fintype ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime P)) : CalibrationData := by + letI (i : ι) : Field (O ⧸ P i) := Ideal.Quotient.field _ + exact { + excluded := Finset.univ.image P + generator := finitePrimeModulus P + generator_ne_zero := finitePrimeModulus_ne_zero P + residue := crtCharacter (fun i => O ⧸ P i) + ((Ideal.quotEquivOfEq (span_finitePrimeModulus P)).trans + (IdealGaussCRT.quotientProdEquivPi P hcop)) (fun i => localCalibration (P i)) } + +theorem calibrationFromPrimes_pow_six {ι : Type*} [Fintype ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime P)) : + (calibrationFromPrimes P hcop).residue ^ 6 = 1 := by + let (i : ι) : Field (O ⧸ P i) := Ideal.Quotient.field _ + exact crtCharacter_pow_six _ _ _ (fun i => localCalibration_pow_six (P i)) + +theorem calibrationFromPrimes_tau_norm {ι : Type*} [Fintype ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime P)) : + ‖(calibrationFromPrimes P hcop).tau‖ = 1 := by + let b := finitePrimeModulus P + have hb : b ≠ 0 := finitePrimeModulus_ne_zero P + let : Finite (O ⧸ Ideal.span {b}) := ConcreteTraceCRT.finite_quotient_span hb + let : Fintype (O ⧸ Ideal.span {b}) := Fintype.ofFinite _ + let (i : ι) : Field (O ⧸ P i) := Ideal.Quotient.field _ + let (i : ι) : Fintype (O ⧸ P i) := Fintype.ofFinite _ + let e : (O ⧸ Ideal.span {b}) ≃+* ∀ i, O ⧸ P i := + (Ideal.quotEquivOfEq (span_finitePrimeModulus P)).trans + (IdealGaussCRT.quotientProdEquivPi P hcop) + let ψ := quotientTrace b hb + have hψ : ψ.IsPrimitive := GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive b hb + have hg := IdealGaussCRT.norm_gauss_finite_crt_sq (fun i => O ⧸ P i) e + (fun i => localCalibration (P i)) ψ (fun i => localCalibration_nonprincipal (P i)) + (fun i => IdealGaussCRT.coordinateAddChar_isPrimitive _ e ψ hψ i) + have hcard : (Fintype.card (O ⧸ Ideal.span {b}) : ℝ) = elementNorm b := by + rw [← Nat.card_eq_fintype_card] + rfl + rw [hcard] at hg + have hQ : 0 < elementNorm b := by + unfold elementNorm + exact_mod_cast Nat.pos_of_ne_zero + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hb)) + have hn : ‖∑ x : O ⧸ Ideal.span {b}, (∏ i, localCalibration (P i) (e x i)) * ψ x‖ = + Real.sqrt (elementNorm b) := by + have hs := Real.sq_sqrt hQ.le + have hs0 := Real.sqrt_nonneg (elementNorm b) + have hn0 := norm_nonneg (∑ x : O ⧸ Ideal.span {b}, (∏ i, localCalibration (P i) (e x i)) * ψ x) + nlinarith + change ‖(∑' d : O ⧸ Ideal.span {b}, (∏ i, localCalibration (P i) (e d i)) * ψ d) / + (Real.sqrt (elementNorm b) : ℂ)‖ = 1 + rw [tsum_fintype, norm_div, hn, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (Real.sqrt_nonneg _), div_self (Real.sqrt_pos.mpr hQ).ne'] + +theorem calibrationFromPrimes_tau_ne_zero {ι : Type*} [Fintype ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime P)) : + (calibrationFromPrimes P hcop).tau ≠ 0 := by + exact norm_ne_zero_iff.mp (by rw [calibrationFromPrimes_tau_norm]; norm_num) + +def calibrationForSet (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) : CalibrationData := by + letI (P : S) : P.val.IsMaximal := hS P.val P.property + exact calibrationFromPrimes (fun P : S => P.val) + (fun P Q hPQ => Ideal.isCoprime_of_isMaximal (fun h => hPQ (Subtype.ext h))) + +theorem calibrationForSet_excluded (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) : + (calibrationForSet S hS).excluded = S := by + change Finset.univ.image (fun P : S => P.val) = S + ext P + simp + +theorem calibrationForSet_span (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) : + Ideal.span {(calibrationForSet S hS).generator} = ∏ P ∈ S, P := by + change Ideal.span {finitePrimeModulus (fun P : S => P.val)} = _ + rw [span_finitePrimeModulus] + exact Finset.prod_coe_sort S (fun P : Ideal O => P) + +theorem calibrationForSet_pow_six (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) : + (calibrationForSet S hS).residue ^ 6 = 1 := by + let (P : S) : P.val.IsMaximal := hS P.val P.property + unfold calibrationForSet + apply calibrationFromPrimes_pow_six + +theorem calibrationForSet_tau_norm (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) : + ‖(calibrationForSet S hS).tau‖ = 1 := by + let (P : S) : P.val.IsMaximal := hS P.val P.property + unfold calibrationForSet + apply calibrationFromPrimes_tau_norm + +theorem calibrationForSet_tau_ne_zero (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) : + (calibrationForSet S hS).tau ≠ 0 := by + exact norm_ne_zero_iff.mp (by rw [calibrationForSet_tau_norm]; norm_num) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationCRT.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationCRT.lean new file mode 100644 index 0000000000000000000000000000000000000000..dbb1ccf9839d6adcec0b6291b647458fe9955e89 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationCRT.lean @@ -0,0 +1,118 @@ +import OAI.NumberTheory.DirichletL.Moments.FirstPoisson +import OAI.NumberTheory.DirichletL.Detector.CalibrationFourier +import OAI.NumberTheory.DirichletL.Detector.PhysicalCoefficient + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein +open CenteredMomentCorrelation CenteredMomentCommonSupport CenteredMomentFourier +open CenteredMomentFirstPoisson +local notation "O" => ActualEisensteinCubic.O + +theorem coprime_mixed_fourier (a b : O) (ha : a ≠ 0) (hb : b ≠ 0) + (hcop : IsCoprime a b) + [Fintype (Residue a)] [Fintype (Residue b)] [Fintype (Residue (a * b))] + (χa : MulChar (Residue a) ℂ) (F : Residue b → ℂ) + (h : Residue (a * b)) : + (∑ x : Residue (a * b), + χa (frequencyReduction a (a * b) (dvd_mul_right a b) x) * + F (frequencyReduction b (a * b) (dvd_mul_left b a) x) * + quotientTrace (a * b) (mul_ne_zero ha hb) (h * x)) = + χa (Ideal.Quotient.mk _ b) * + residueGauss a ha χa (frequencyReduction a (a*b) (dvd_mul_right a b) h) * + (∑ y : Residue b, F (Ideal.Quotient.mk _ a*y) * + quotientTrace b hb (frequencyReduction b (a*b) (dvd_mul_left b a) h*y)) := by + let ua := residueUnit a b hcop + let ub := residueUnit b a hcop.symm + let e : Residue a × Residue b ≃ Residue (a * b) := + (ua.mulLeft.prodCongr ub.mulLeft).trans (principalCRT a b hcop).toEquiv.symm + have heproj (x : Residue a × Residue b) : principalCRT a b hcop (e x) = + ((ua : Residue a) * x.1, (ub : Residue b) * x.2) := by + change (principalCRT a b hcop).toEquiv + ((principalCRT a b hcop).toEquiv.symm ((ua : Residue a) * x.1, (ub : Residue b) * x.2)) = _ + exact (principalCRT a b hcop).toEquiv.apply_symm_apply _ + have he (x : Residue a × Residue b) : e x = + scaledResidue a b (a * b) rfl x.1 + scaledResidue b a (a * b) (mul_comm a b) x.2 := by + apply (principalCRT a b hcop).injective + rw [heproj, map_add, principalCRT_scaled_left, principalCRT_scaled_right] + simp only [Prod.mk_add_mk, add_zero, zero_add, ua, ub, residueUnit_coe] + have hproj (x : Residue (a * b)) : + (frequencyReduction a (a * b) (dvd_mul_right a b) x, + frequencyReduction b (a * b) (dvd_mul_left b a) x) = principalCRT a b hcop x := by + obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x + simp only [frequencyReduction_mk, principalCRT_mk] + have hprojA (x : Residue a × Residue b) : + frequencyReduction a (a * b) (dvd_mul_right a b) (e x) = Ideal.Quotient.mk _ b * x.1 := by + have ht := congrArg Prod.fst (hproj (e x)) + rw [heproj] at ht + simpa only [ua, residueUnit_coe] using ht + have hprojB (x : Residue a × Residue b) : + frequencyReduction b (a * b) (dvd_mul_left b a) (e x) = Ideal.Quotient.mk _ a * x.2 := by + have ht := congrArg Prod.snd (hproj (e x)) + rw [heproj] at ht + simpa only [ub, residueUnit_coe] using ht + rw [← e.sum_comp] + simp_rw [hprojA, hprojB] + simp only [map_mul, he, mul_add, AddChar.map_add_eq_mul, + quotientTrace_scaled a b (a * b) rfl ha hb (mul_ne_zero ha hb), + quotientTrace_scaled b a (a * b) (mul_comm a b) hb ha (mul_ne_zero ha hb)] + simp only [Fintype.sum_prod_type, residueGauss, tsum_fintype] + rw [Finset.sum_comm] + simp only [Finset.mul_sum, Finset.sum_mul] + apply Finset.sum_congr rfl + intro y _ + apply Finset.sum_congr rfl + intro x _ + ring + +theorem calibration_mixed_fourier (S : Finset (Ideal O)) (hS : ∀ P∈S, P.IsMaximal) + (b : O) (hb : b≠0) (hcop : IsCoprime (calibrationForSet S hS).generator b) + (F : Residue b → ℂ) (H : O) : + let C := calibrationForSet S hS + (∑' x : Residue (C.generator*b), + C.residue (frequencyReduction C.generator (C.generator*b) (dvd_mul_right _ _) x) * + F (frequencyReduction b (C.generator*b) (dvd_mul_left _ _) x) * + quotientTrace (C.generator*b) (mul_ne_zero C.generator_ne_zero hb) (Ideal.Quotient.mk _ H*x)) = + C.residueMonoid b * star (C.residueMonoid H) * (Real.sqrt (elementNorm C.generator):ℂ) * C.tau * + (∑' y : Residue b, F (Ideal.Quotient.mk _ C.generator*y) * + quotientTrace b hb (Ideal.Quotient.mk _ H*y)) := by + dsimp only + let C := calibrationForSet S hS + let := finite_quotient_span C.generator_ne_zero + let := finite_quotient_span hb + let := finite_quotient_span (mul_ne_zero C.generator_ne_zero hb) + let : Fintype (Residue C.generator) := Fintype.ofFinite _ + let : Fintype (Residue b) := Fintype.ofFinite _ + let : Fintype (Residue (C.generator*b)) := Fintype.ofFinite _ + rw [tsum_fintype, coprime_mixed_fourier _ _ C.generator_ne_zero hb hcop] + change C.residueMonoid b * calibrationGauss C H * _ = _ + rw [calibrationForSet_gauss] + rw [tsum_fintype] + dsimp only [C] + simp only [frequencyReduction_mk] + ring + +theorem calibration_mixed_fourier_zero (S : Finset (Ideal O)) (hS : ∀ P∈S, P.IsMaximal) + (b : O) (hb : b≠0) (hcop : IsCoprime (calibrationForSet S hS).generator b) + (F : Residue b → ℂ) (H : O) (hH : ¬IsCoprime (calibrationForSet S hS).generator H) : + let C := calibrationForSet S hS + (∑' x : Residue (C.generator*b), + C.residue (frequencyReduction C.generator (C.generator*b) (dvd_mul_right _ _) x) * + F (frequencyReduction b (C.generator*b) (dvd_mul_left _ _) x) * + quotientTrace (C.generator*b) (mul_ne_zero C.generator_ne_zero hb) (Ideal.Quotient.mk _ H*x)) = 0 := by + dsimp only + rw [calibration_mixed_fourier S hS b hb hcop F H] + have hz : (calibrationForSet S hS).residueMonoid H=0 := by + change (calibrationForSet S hS).residue (Ideal.Quotient.mk _ H)=0 + apply MulChar.map_nonunit + exact fun h => hH ((isUnit_quotient_span_iff _ _).mp h) + rw [hz, star_zero] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationCancellation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationCancellation.lean new file mode 100644 index 0000000000000000000000000000000000000000..35ca6ccf3a61aef9b492cbe8241ab68f1e137d54 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationCancellation.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Detector.CalibrationRemoval +import OAI.NumberTheory.DirichletL.Detector.CalibrationSupport + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalRowCompletion CanonicalQuadraticSieve CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +lemma Xi_apply (C : CalibrationData) (a : O) : + C.Xi a = C.residueMonoid a * idealRowHom C.generator (Ideal.span {a}) := rfl + +theorem calibration_coefficient_cancel (S : Finset (Ideal O)) (hS : ∀ P∈S, P.IsMaximal) + (A s : O) (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (H : O) + (hH : IsCoprime (calibrationForSet S hS).generator H) : + let C := calibrationForSet S hS + actualCongruenceCoefficient C A s (supportedElement_ne_zero A hA) H * + idealRowHom C.generator (Ideal.span {s}) / + ((Real.sqrt (elementNorm C.generator):ℂ)*C.tau*C.residueMonoid s*star (C.residueMonoid H)) * + (C.Xi A)⁻¹ = bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H := by + dsimp only + let C := calibrationForSet S hS + have hcA : IsCoprime C.generator A := hcop.of_mul_right_left + have hcs : IsCoprime C.generator s := hcop.of_mul_right_right + have hXA : C.Xi A≠0 := by + intro h + have hn := C.Xi_norm_one A hA hcA + rw [h, norm_zero] at hn + norm_num at hn + have hXs : C.Xi s≠0 := by + intro h + have hn := C.Xi_norm_one s hs hcs + rw [h, norm_zero] at hn + norm_num at hn + rw [Xi_apply] at hXA hXs + have hηA := left_ne_zero_of_mul hXA + have hκA := right_ne_zero_of_mul hXA + have hηs := left_ne_zero_of_mul hXs + have hκs := right_ne_zero_of_mul hXs + have hηH : C.residueMonoid H≠0 := + C.residue.apply_ne_zero_iff.mpr ((isUnit_quotient_span_iff C.generator H).mpr hH) + have hηHstar : star (C.residueMonoid H)≠0 := star_ne_zero.mpr hηH + have hτ : C.tau≠0 := calibrationForSet_tau_ne_zero S hS + have hq : 0 ActualEisensteinCubic.O + +def calibrationGauss (C : CalibrationData) (h : O) : ℂ := + ∑' d : O ⧸ Ideal.span {C.generator}, C.residue d * + quotientTrace C.generator C.generator_ne_zero + (Ideal.Quotient.mk (Ideal.span {C.generator}) h * d) + +theorem calibrationGauss_one (C : CalibrationData) : + calibrationGauss C 1 = (Real.sqrt (elementNorm C.generator) : ℂ) * C.tau := by + have hn : 0 < elementNorm C.generator := by + unfold elementNorm + exact_mod_cast Nat.pos_of_ne_zero + (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr C.generator_ne_zero)) + have hc : (Real.sqrt (elementNorm C.generator) : ℂ) ≠ 0 := by + exact_mod_cast (Real.sqrt_pos.mpr hn).ne' + simp only [calibrationGauss, map_one, one_mul, CalibrationData.tau] + field_simp + +theorem calibrationFromPrimes_gauss {ι : Type*} [Fintype ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime P)) (h : O) : + calibrationGauss (calibrationFromPrimes P hcop) h = + ((calibrationFromPrimes P hcop).residueMonoid h)⁻¹ * + calibrationGauss (calibrationFromPrimes P hcop) 1 := by + let b := finitePrimeModulus P + have hb : b ≠ 0 := finitePrimeModulus_ne_zero P + let : Finite (O ⧸ Ideal.span {b}) := ConcreteTraceCRT.finite_quotient_span hb + let : Fintype (O ⧸ Ideal.span {b}) := Fintype.ofFinite _ + let (i : ι) : Field (O ⧸ P i) := Ideal.Quotient.field _ + let (i : ι) : Fintype (O ⧸ P i) := Fintype.ofFinite _ + let e : (O ⧸ Ideal.span {b}) ≃+* ∀ i, O ⧸ P i := + (Ideal.quotEquivOfEq (span_finitePrimeModulus P)).trans + (IdealGaussCRT.quotientProdEquivPi P hcop) + let ψ := quotientTrace b hb + have ht := IdealGaussCRT.gauss_transform_finite_crt_scalar (fun i => O ⧸ P i) e + (fun i => localCalibration (P i)) ψ (fun i => localCalibration_nonprincipal (P i)) + (Ideal.Quotient.mk (Ideal.span {b}) h) + change (∑' d : O ⧸ Ideal.span {b}, (∏ i, localCalibration (P i) (e d i)) * + ψ (Ideal.Quotient.mk (Ideal.span {b}) h * d)) = + (∏ i, localCalibration (P i) (e (Ideal.Quotient.mk (Ideal.span {b}) h) i))⁻¹ * + ∑' d : O ⧸ Ideal.span {b}, (∏ i, localCalibration (P i) (e d i)) * + ψ (Ideal.Quotient.mk (Ideal.span {b}) 1 * d) + simpa only [tsum_fintype, map_one, one_mul] using ht + +theorem calibrationForSet_gauss (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) + (h : O) : + calibrationGauss (calibrationForSet S hS) h = + star ((calibrationForSet S hS).residueMonoid h) * + (Real.sqrt (elementNorm (calibrationForSet S hS).generator) : ℂ) * + (calibrationForSet S hS).tau := by + let C := calibrationForSet S hS + let : Finite (O ⧸ Ideal.span {C.generator}) := + ConcreteTraceCRT.finite_quotient_span C.generator_ne_zero + have hc : star (C.residueMonoid h) = (C.residueMonoid h)⁻¹ := by + exact (MulChar.star_apply' C.residue (Ideal.Quotient.mk _ h)).trans + (MulChar.inv_apply_eq_inv' _ _) + have he : calibrationGauss C h = (C.residueMonoid h)⁻¹ * calibrationGauss C 1 := by + let (P : S) : P.val.IsMaximal := hS P.val P.property + unfold C calibrationForSet + apply calibrationFromPrimes_gauss + rw [he, calibrationGauss_one, ← hc] + ring + +theorem calibrationForSet_residue_sixth (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) + (a : O) (ha : IsCoprime (calibrationForSet S hS).generator a) : + (calibrationForSet S hS).residueMonoid a ^ 6 = 1 := by + let C := calibrationForSet S hS + have hu := (isUnit_quotient_span_iff C.generator a).mpr ha + have h6 := congrArg (fun χ : MulChar (O ⧸ Ideal.span {C.generator}) ℂ => + χ (Ideal.Quotient.mk _ a)) (calibrationForSet_pow_six S hS) + change C.residue (Ideal.Quotient.mk _ a) ^ 6 = 1 + simpa only [MulChar.pow_apply' _ (by decide : (6 : ℕ) ≠ 0), MulChar.one_apply hu] using h6 + +theorem calibrationForSet_quotient_conjugate (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, P.IsMaximal) (s k u a : O) + (hs : IsCoprime (calibrationForSet S hS).generator s) + (ha : IsCoprime (calibrationForSet S hS).generator a) + (hrel : s * k = u * a ^ 6) : + star ((calibrationForSet S hS).residueMonoid k) = + star ((calibrationForSet S hS).residueMonoid u) * + (calibrationForSet S hS).residueMonoid s := by + let C := calibrationForSet S hS + let : Finite (O ⧸ Ideal.span {C.generator}) := + ConcreteTraceCRT.finite_quotient_span C.generator_ne_zero + have hc (x : O) : star (C.residueMonoid x) = (C.residueMonoid x)⁻¹ := by + exact (MulChar.star_apply' C.residue (Ideal.Quotient.mk _ x)).trans + (MulChar.inv_apply_eq_inv' _ _) + have hu := (isUnit_quotient_span_iff C.generator s).mpr hs + have hsn : C.residueMonoid s ≠ 0 := C.residue.apply_ne_zero_iff.mpr hu + have he := congrArg C.residueMonoid hrel + simp only [map_mul, map_pow] at he + have h6 : C.residueMonoid a ^ 6 = 1 := calibrationForSet_residue_sixth S hS a ha + rw [h6, mul_one] at he + have hk : C.residueMonoid k = (C.residueMonoid s)⁻¹ * C.residueMonoid u := by + rw [← he, ← mul_assoc, inv_mul_cancel₀ hsn, one_mul] + change star (C.residueMonoid k) = star (C.residueMonoid u) * C.residueMonoid s + rw [hc k, hc u, hk, mul_inv_rev, inv_inv] + +theorem calibrationForSet_gauss_sixth_row (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, P.IsMaximal) (s k u a : O) + (hs : IsCoprime (calibrationForSet S hS).generator s) + (ha : IsCoprime (calibrationForSet S hS).generator a) + (hrel : s * k = u * a ^ 6) : + calibrationGauss (calibrationForSet S hS) k = + star ((calibrationForSet S hS).residueMonoid u) * + (calibrationForSet S hS).residueMonoid s * + (Real.sqrt (elementNorm (calibrationForSet S hS).generator) : ℂ) * + (calibrationForSet S hS).tau := by + rw [calibrationForSet_gauss, + calibrationForSet_quotient_conjugate S hS s k u a hs ha hrel] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationRemoval.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationRemoval.lean new file mode 100644 index 0000000000000000000000000000000000000000..d672bbf9e4dc9756683957368dc913afde06ebb1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationRemoval.lean @@ -0,0 +1,107 @@ +import OAI.NumberTheory.DirichletL.Detector.FrequencySupport +import OAI.NumberTheory.DirichletL.Detector.PhysicalReopen + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CubicEisenstein GaussianShiftedPartition CanonicalRowCompletion +open CanonicalQuadraticSieve ConcreteTraceCRT +open CenteredMomentCommonSupport CenteredMomentFourier CenteredMomentSupportedCorrelation +local notation "O" => ActualEisensteinCubic.O + +lemma sexticGauss_unit_scale (s : O) (hs : Supported (Ideal.span {s})) + (b h : O) (hcop : IsCoprime b s) : + sexticGauss s (supportedElement_ne_zero s hs) (b*h) = + (idealRowHom b (Ideal.span {s}))⁻¹ * sexticGauss s (supportedElement_ne_zero s hs) h := by + let := finite_quotient_span (supportedElement_ne_zero s hs) + let : Fintype (Residue s) := Fintype.ofFinite _ + let χ := supportedModulusCharacter s hs + let ψ := quotientTrace s (supportedElement_ne_zero s hs) + let u := residueUnit s b hcop.symm + have he := gaussSum_mulShift_eq χ (ψ.mulShift (Ideal.Quotient.mk _ h)) u + simp only [gaussSum, AddChar.mulShift_apply, MulChar.inv_apply_eq_inv', u, residueUnit_coe, + χ, supportedModulusCharacter_mk] at he + rw [← residueGauss_supported_mk s hs (b*h), ← residueGauss_supported_mk s hs h] + simp only [residueGauss, tsum_fintype, map_mul] + simpa only [ψ, mul_assoc, mul_comm, mul_left_comm] using he + +lemma movingQuotient_unit_scale (A s : O) (hs : Supported (Ideal.span {s})) + (b : O) (hcop : IsCoprime b s) (x : Residue (A*s)) : + movingQuotient A s (supportedElement_ne_zero s hs) (Ideal.Quotient.mk _ b*x) = + idealRowHom b (Ideal.span {A}) * (idealRowHom b (Ideal.span {s}))⁻¹ * + movingQuotient A s (supportedElement_ne_zero s hs) x := by + obtain ⟨m,rfl⟩ := Ideal.Quotient.mk_surjective x + rw [← map_mul, movingQuotient_mk, movingQuotient_mk, idealRowHom_argument_mul] + rw [show -(b*m)=b*(-m) by ring, sexticGauss_unit_scale s hs b (-m) hcop] + ring + +def barePhysicalFourier (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : ℂ := + elementFourier (A*s) (mul_ne_zero hA hs) + (fun m => idealRowHom m (Ideal.span {A}) * sexticGauss s hs (-m)) H + +theorem actualPhysicalFourier_calibration_factor (S : Finset (Ideal O)) + (hS : ∀ P∈S, P.IsMaximal) (A s : O) (hA : A≠0) + (hs : Supported (Ideal.span {s})) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (H : O) : + let C := calibrationForSet S hS + actualPhysicalFourier C A s hA (supportedElement_ne_zero s hs) H = + (C.residueMonoid (A*s) * star (C.residueMonoid H) * + (Real.sqrt (elementNorm C.generator):ℂ) * C.tau * + idealRowHom C.generator (Ideal.span {A}) * (idealRowHom C.generator (Ideal.span {s}))⁻¹) * + barePhysicalFourier A s hA (supportedElement_ne_zero s hs) H := by + dsimp only + let C := calibrationForSet S hS + have hcs : IsCoprime C.generator s := hcop.of_mul_right_right + rw [physicalFourier_eq_mixed, calibration_mixed_fourier S hS (A*s) + (mul_ne_zero hA (supportedElement_ne_zero s hs)) hcop] + dsimp only [C] at hcs ⊢ + simp_rw [movingQuotient_unit_scale A s hs (calibrationForSet S hS).generator hcs] + simp only [mul_assoc, tsum_mul_left] + rfl + +def bareCongruenceCoefficient (A s : O) (hA : A≠0) (H : O) : ℂ := + congruenceCoefficient A s hA (outerQuotient A) (outerQuotient s) H + +lemma barePhysicalFourier_eq (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : + barePhysicalFourier A s hA hs H = + (Ideal.absNorm (Ideal.span {s}):ℂ)*bareCongruenceCoefficient A s hA H := by + unfold bareCongruenceCoefficient + rw [← fullFourier_eq_congruence A s hA hs] + unfold barePhysicalFourier elementFourier fullFourier + apply tsum_congr + intro m + rw [rawFourier_outer] + have he : conductorReduction A s m = Ideal.Quotient.mk (Ideal.span {A}) (representative (A*s) m) := by + conv_lhs => rw [← representative_spec (A*s) m] + rfl + rw [he] + unfold outerQuotient + rw [sexticGauss_coefficient_mk] + +theorem actualCongruenceCoefficient_calibration_factor (S : Finset (Ideal O)) + (hS : ∀ P∈S, P.IsMaximal) (A s : O) (hA : A≠0) + (hs : Supported (Ideal.span {s})) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (H : O) : + let C := calibrationForSet S hS + actualCongruenceCoefficient C A s hA H = + (C.residueMonoid (A*s) * star (C.residueMonoid H) * + (Real.sqrt (elementNorm C.generator):ℂ) * C.tau * + idealRowHom C.generator (Ideal.span {A}) * (idealRowHom C.generator (Ideal.span {s}))⁻¹) * + bareCongruenceCoefficient A s hA H := by + dsimp only + have he := actualPhysicalFourier_calibration_factor S hS A s hA hs hcop H + dsimp only at he + rw [actualPhysicalFourier_eq, barePhysicalFourier_eq] at he + have hn : (Ideal.absNorm (Ideal.span {s}):ℂ)≠0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr (supportedElement_ne_zero s hs)) + apply mul_left_cancel₀ hn + rw [he] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationSupport.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..baf9bfe9ce10753ac500f2f6f58b910ea6c57dc6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CalibrationSupport.lean @@ -0,0 +1,45 @@ +import OAI.NumberTheory.DirichletL.Detector.Calibration +import OAI.NumberTheory.DirichletL.Detector.PhysicalAnalytic + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve ProbeRow +local notation "O" => ActualEisensteinCubic.O + +theorem calibrationForSet_coprime_iff (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) + (a : O) : IsCoprime (calibrationForSet S hS).generator a ↔ ∀ P ∈ S, a ∉ P := by + rw [← Ideal.isCoprime_span_singleton_iff, calibrationForSet_span, IsCoprime.prod_left_iff] + constructor + · intro h P hP + let : P.IsMaximal := hS P hP + exact (SixthPowerAverage.prime_coprime_span_iff P a).mp (h P hP) + · intro h P hP + let : P.IsMaximal := hS P hP + exact (SixthPowerAverage.prime_coprime_span_iff P a).mpr (h P hP) + +theorem calibrationForSet_coprime_of_excluded (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, P.IsMaximal) (a : O) + (hmask : ∀ P ∈ S, ¬P ∣ Ideal.span {a}) : + IsCoprime (calibrationForSet S hS).generator a := by + apply (calibrationForSet_coprime_iff S hS a).mpr + intro P hP ha + apply hmask P hP + exact Ideal.dvd_iff_le.mpr (Ideal.span_le.mpr (Set.singleton_subset_iff.mpr ha)) + +theorem source_rowCoefficient_apply (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀ P ∈ S, P.IsMaximal) + (s : O) (hs : Supported (Ideal.span {s})) (m a : O) + (ha : Supported (Ideal.span {a})) (hmask : ∀ P ∈ S, ¬P ∣ Ideal.span {a}) : + rowCoefficient η (calibrationForSet S hS).Xi s hs m a = + HeckeFamily.elementCoeff η a * ((calibrationForSet S hS).Xi a)⁻¹ * + sexticReciprocityPhase a s * idealRowHom m (Ideal.span {a}) := + calibrated_rowCoefficient_apply η (calibrationForSet S hS) s hs m a ha + (calibrationForSet_coprime_of_excluded S hS a hmask) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CanonicalPhysicalRows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CanonicalPhysicalRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..78406ef7df1fb87c0a0ae38577b18e98e308c1ef --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CanonicalPhysicalRows.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Detector.CanonicalSlots +import OAI.NumberTheory.DirichletL.PrimeRows.PhysicalDyad + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve HeckeInverseAmplification +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem compensatedPhysicalProbe_canonical_slots {K : ℕ} (η : HeckeFamily.Character) + (C : CalibrationData) (W0 W1 : ℝ→ℂ) (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (X Y Z : ℝ) : + compensatedPhysicalProbe η C W0 W1 (fun i=>canonicalSlotSupport (T i)) W Yp X Y Z= + ∑P : (∀i,↥(T i)),(∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + compensatedTuple η C W0 W1 (fun i=>primaryGenerator (P i).val.val) X Y Z := + sum_canonical_weighted_tuples T hT W Yp (fun p=>compensatedTuple η C W0 W1 p X Y Z) + +theorem finitePhysicalRows_canonical_slots {K : ℕ} (S : Finset Id) (hmax : ∀P∈S,P.IsMaximal) + (η : HeckeFamily.Character) (R : Finset FreeRow) (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : + ProbeHighRowFamily.finitePhysicalRows S hmax η R T W Yp W0 W1 X Y Z= + ∑p : (∀i,↥(canonicalSlotSupport (T i))), + (∏i,W i (elementNorm (p i).val/Yp i))* + ∑u∈R,rowIntegral η S (calibrationForSet S hmax) (fun i=>(p i).val) W0 W1 X Y Z u := by + rw [sum_canonical_weighted_tuples T hT W Yp + (fun p=>∑u∈R,rowIntegral η S (calibrationForSet S hmax) p W0 W1 X Y Z u)] + unfold ProbeHighRowFamily.finitePhysicalRows + simp_rw [Finset.mul_sum] + exact Finset.sum_comm + +theorem compensatedPhysicalProbe_eq_canonical_rows {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (hSne : S.Nonempty) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→Supported P.val) + (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0canonicalSlotSupport (T i)) W Yp X Y Z= + ∑'u : FreeRow,∑P : (∀i,↥(T i)),(∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + rowIntegral η S (calibrationForSet S hS) (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z u := by + have hn (P : ∀i,↥(T i)) (i : Fin K) : primaryGenerator (P i).val.val≠0 := + supported_primaryGenerator_ne_zero _ (hT i _ (P i).property) + have hs (P : ∀i,↥(T i)) : Summable (fun u : FreeRow=> + (∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + rowIntegral η S (calibrationForSet S hS) (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z u) := + (rowIntegral_summable η S _ _ (hn P) W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ).mul_left _ + rw [compensatedPhysicalProbe_canonical_slots η _ W0 W1 T hT W Yp] + calc + _ = ∑P : (∀i,↥(T i)),∑'u : FreeRow,(∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + rowIntegral η S (calibrationForSet S hS) (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z u := by + apply Finset.sum_congr rfl + intro P hP + rw [compensatedTuple_eq_row_triple η S hS hpS hbad hSne W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + _ (hn P) X Y Z hX hY hZ, + compensatedRowTripleIntegral_eq_tsum η S _ _ (hn P) W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ] + exact tsum_mul_left.symm + _ = _ := (Summable.tsum_finsetSum (fun P _=>hs P)).symm + +theorem finitePhysicalRows_original_primary_slots {K : ℕ} (S : Finset Id) + (hmax : ∀P∈S,P.IsMaximal) (η : HeckeFamily.Character) (R : Finset FreeRow) + (A : Fin K→Finset O) (hp : ∀i a,a∈A i→Prime (Ideal.span {a})) + (hs : ∀i a,a∈A i→Supported (Ideal.span {a})) + (hn : ∀i a,a∈A i→ConcretePrimeRowBridge.goodLambda^2∣a-1) + (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : + ProbeHighRowFamily.finitePhysicalRows S hmax η R + (fun i=>idealSlotOfPrimary (A i) (hp i)) W Yp W0 W1 X Y Z= + ∑p : (∀i,↥(A i)),(∏i,W i (elementNorm (p i).val/Yp i))* + ∑u∈R,rowIntegral η S (calibrationForSet S hmax) (fun i=>(p i).val) W0 W1 X Y Z u := by + rw [sum_original_primary_weighted_tuples A hp hs hn W Yp + (fun p=>∑u∈R,rowIntegral η S (calibrationForSet S hmax) p W0 W1 X Y Z u)] + unfold ProbeHighRowFamily.finitePhysicalRows + simp_rw [Finset.mul_sum] + exact Finset.sum_comm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CanonicalSlots.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CanonicalSlots.lean new file mode 100644 index 0000000000000000000000000000000000000000..0ae88f818a6c8f6b2c8dd4d5254ce34a14b026cf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CanonicalSlots.lean @@ -0,0 +1,181 @@ +import OAI.NumberTheory.DirichletL.Detector.TuplePrime + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def canonicalSlotSupport (T : Finset PrimeIdeal) : Finset O := + T.image (fun P=>primaryGenerator P.val) + +lemma primaryPrime_injective {P Q : PrimeIdeal} (hP : Supported P.val) (hQ : Supported Q.val) + (h : primaryGenerator P.val=primaryGenerator Q.val) : P=Q := by + apply Subtype.ext + have hh := congrArg (fun a : O=>Ideal.span {a}) h + simpa only [span_primaryGenerator_of_supported _ hP,span_primaryGenerator_of_supported _ hQ] using hh + +lemma canonicalSlotSupport_nonzero (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (a : O) (ha : a∈canonicalSlotSupport T) : a≠0 := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp ha + exact supported_primaryGenerator_ne_zero P.val (hT P hP) + +def canonicalSlotEquiv (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) : + ↥T ≃ ↥(canonicalSlotSupport T) := + Equiv.ofBijective + (fun P=>⟨primaryGenerator P.val.val,Finset.mem_image.mpr ⟨P.val,P.property,rfl⟩⟩) + ⟨by + intro P Q h + apply Subtype.ext + exact primaryPrime_injective (hT P.val P.property) (hT Q.val Q.property) (congrArg Subtype.val h),by + intro a + obtain ⟨P,hP,he⟩ := Finset.mem_image.mp a.property + exact ⟨⟨P,hP⟩,Subtype.ext he⟩⟩ + +@[simp] lemma canonicalSlotEquiv_val (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (P : T) : (canonicalSlotEquiv T hT P).val=primaryGenerator P.val.val := rfl + +lemma canonicalSlotEquiv_span (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (P : T) : Ideal.span {(canonicalSlotEquiv T hT P).val}=P.val.val := + span_primaryGenerator_of_supported _ (hT P.val P.property) + +lemma canonicalSlotEquiv_norm (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (P : T) : elementNorm (canonicalSlotEquiv T hT P).val=(Ideal.absNorm P.val.val:ℝ) := + primaryTuple_norm P.val (hT P.val P.property) + +def canonicalTupleEquiv {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) : + (∀i,↥(T i)) ≃ (∀i,↥(canonicalSlotSupport (T i))) := + Equiv.piCongrRight (fun i=>canonicalSlotEquiv (T i) (hT i)) + +@[simp] lemma canonicalTupleEquiv_val {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (P : ∀i,↥(T i)) (i : Fin K) : + (canonicalTupleEquiv T hT P i).val=primaryGenerator (P i).val.val := rfl + +theorem sum_canonical_element_tuples {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) + (F : (Fin K→O)→ℂ) : + (∑p : (∀i,↥(canonicalSlotSupport (T i))),F (fun i=>(p i).val))= + ∑P : (∀i,↥(T i)),F (fun i=>primaryGenerator (P i).val.val) := by + exact ((canonicalTupleEquiv T hT).sum_comp (fun p=>F (fun i=>(p i).val))).symm + +lemma canonicalSlotSupport_disjoint (T U : Finset PrimeIdeal) + (hT : ∀P∈T,Supported P.val) (hU : ∀P∈U,Supported P.val) (hdis : Disjoint T U) : + Disjoint (canonicalSlotSupport T) (canonicalSlotSupport U) := by + apply Finset.disjoint_left.mpr + intro a ha hb + obtain ⟨P,hP,hPa⟩ := Finset.mem_image.mp ha + obtain ⟨Q,hQ,hQa⟩ := Finset.mem_image.mp hb + have he : P=Q := primaryPrime_injective (hT P hP) (hU Q hQ) (hPa.trans hQa.symm) + exact Finset.disjoint_left.mp hdis hP (he.symm ▸ hQ) + +lemma idealTuple_injective_of_disjoint {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) (P : ∀i,↥(T i)) : + Function.Injective (fun i=>(P i).val) := by + intro i j he + by_contra hij + apply Finset.disjoint_left.mp (hdis hij) (P i).property + rw [show (P i).val=(P j).val from he] + exact (P j).property + +lemma canonicalElementTuple_injective_of_disjoint {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) + (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) (P : ∀i,↥(T i)) : + Function.Injective (fun i=>primaryGenerator (P i).val.val) := by + intro i j he + apply idealTuple_injective_of_disjoint T hdis P + exact primaryPrime_injective (hT i _ (P i).property) (hT j _ (P j).property) he + +theorem sum_canonical_weighted_tuples {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (W : Fin K→ℝ→ℂ) (Y : Fin K→ℝ) + (F : (Fin K→O)→ℂ) : + (∑p : (∀i,↥(canonicalSlotSupport (T i))), + (∏i,W i (elementNorm (p i).val/Y i))*F (fun i=>(p i).val))= + ∑P : (∀i,↥(T i)),(∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Y i))* + F (fun i=>primaryGenerator (P i).val.val) := by + rw [sum_canonical_element_tuples T hT (fun p=>(∏i,W i (elementNorm (p i)/Y i))*F p)] + apply Finset.sum_congr rfl + intro P hP + simp only [primaryTuple_norm (P _).val (hT _ _ (P _).property)] + +def idealSlotOfPrimary (A : Finset O) (hp : ∀a∈A,Prime (Ideal.span {a})) : Finset PrimeIdeal := + A.attach.image (fun a : A => (⟨Ideal.span {a.val}, hp a.val a.property⟩ : PrimeIdeal)) + +lemma idealSlotOfPrimary_supported (A : Finset O) (hp : ∀a∈A,Prime (Ideal.span {a})) + (hs : ∀a∈A,Supported (Ideal.span {a})) : + ∀P∈idealSlotOfPrimary A hp,Supported P.val := by + intro P hP + obtain ⟨a,ha,rfl⟩ := Finset.mem_image.mp hP + exact hs a.val a.property + +lemma primarySlotNormalization (A : Finset O) (hp : ∀a∈A,Prime (Ideal.span {a})) + (hs : ∀a∈A,Supported (Ideal.span {a})) + (hprimary : ∀a∈A,ConcretePrimeRowBridge.goodLambda^2∣a-1) : + canonicalSlotSupport (idealSlotOfPrimary A hp)=A := by + have hg (a : A) : primaryGenerator (Ideal.span {a.val})=a.val := by + apply primaryGenerator_span a.val + · intro hz + have hn := (hs a.val a.property).1 + exact hn (by simp [hz]) + · exact hprimary a.val a.property + apply Finset.ext + intro a + constructor + · intro ha + obtain ⟨P,hP,hPa⟩ := Finset.mem_image.mp ha + obtain ⟨b,hb,rfl⟩ := Finset.mem_image.mp hP + change primaryGenerator (Ideal.span {b.val})=a at hPa + rw [hg b] at hPa + exact hPa ▸ b.property + · intro ha + apply Finset.mem_image.mpr + refine ⟨⟨Ideal.span {a},hp a ha⟩,?_,?_⟩ + · exact Finset.mem_image.mpr ⟨⟨a,ha⟩,by simp,rfl⟩ + · exact hg ⟨a,ha⟩ + +lemma canonicalSlotSupport_disjoint_iff (T U : Finset PrimeIdeal) + (hT : ∀P∈T,Supported P.val) (hU : ∀P∈U,Supported P.val) : + Disjoint (canonicalSlotSupport T) (canonicalSlotSupport U)↔Disjoint T U := by + constructor + · intro h + apply Finset.disjoint_left.mpr + intro P hP hQ + exact Finset.disjoint_left.mp h (Finset.mem_image.mpr ⟨P,hP,rfl⟩) + (Finset.mem_image.mpr ⟨P,hQ,rfl⟩) + · exact canonicalSlotSupport_disjoint T U hT hU + +lemma originalPrimarySlots_disjoint (A B : Finset O) + (hAp : ∀a∈A,Prime (Ideal.span {a})) (hBp : ∀b∈B,Prime (Ideal.span {b})) + (hAs : ∀a∈A,Supported (Ideal.span {a})) (hBs : ∀b∈B,Supported (Ideal.span {b})) + (hAn : ∀a∈A,ConcretePrimeRowBridge.goodLambda^2∣a-1) + (hBn : ∀b∈B,ConcretePrimeRowBridge.goodLambda^2∣b-1) (h : Disjoint A B) : + Disjoint (idealSlotOfPrimary A hAp) (idealSlotOfPrimary B hBp) := by + apply (canonicalSlotSupport_disjoint_iff _ _ + (idealSlotOfPrimary_supported A hAp hAs) (idealSlotOfPrimary_supported B hBp hBs)).mp + simpa only [primarySlotNormalization A hAp hAs hAn,primarySlotNormalization B hBp hBs hBn] using h + +theorem sum_original_primary_weighted_tuples {K : ℕ} (A : Fin K→Finset O) + (hp : ∀i a,a∈A i→Prime (Ideal.span {a})) + (hs : ∀i a,a∈A i→Supported (Ideal.span {a})) + (hn : ∀i a,a∈A i→ConcretePrimeRowBridge.goodLambda^2∣a-1) + (W : Fin K→ℝ→ℂ) (Y : Fin K→ℝ) (F : (Fin K→O)→ℂ) : + (∑p : (∀i,↥(A i)),(∏i,W i (elementNorm (p i).val/Y i))*F (fun i=>(p i).val))= + ∑P : (∀i,↥(idealSlotOfPrimary (A i) (hp i))), + (∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Y i))*F (fun i=>primaryGenerator (P i).val.val) := by + have he (i : Fin K) := primarySlotNormalization (A i) (hp i) (hs i) (hn i) + have hh := sum_canonical_weighted_tuples (fun i=>idealSlotOfPrimary (A i) (hp i)) + (fun i=>idealSlotOfPrimary_supported (A i) (hp i) (hs i)) W Y F + let G (B : Fin K→Finset O) : ℂ := + ∑p : (∀i,↥(B i)),(∏i,W i (elementNorm (p i).val/Y i))*F (fun i=>(p i).val) + have hfun : (fun i=>canonicalSlotSupport (idealSlotOfPrimary (A i) (hp i)))=A := funext he + change G (fun i=>canonicalSlotSupport (idealSlotOfPrimary (A i) (hp i)))=_ at hh + rw [hfun] at hh + exact hh + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralAllSlots.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralAllSlots.lean new file mode 100644 index 0000000000000000000000000000000000000000..9b447c9a877c39e63208a9a8dade505c6a7a6a93 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralAllSlots.lean @@ -0,0 +1,103 @@ +import OAI.NumberTheory.DirichletL.Detector.CentralBranchProduct +import OAI.NumberTheory.DirichletL.Detector.CentralRepeatedSubset +import OAI.NumberTheory.DirichletL.PrimeRows.CentralSlotSum + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeCentralAllSlots +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily ProbePhysical +open CanonicalQuadraticSieve CanonicalRowCompletion ProbeCentralRepeatedProduct +open ProbeCentralRepeatedSubset ProbeCentralBranchProduct +local notation "O" => HeckeFamily.O + +def phaseSlot (u : FreeRow) (T : Finset PrimeIdeal) (W : ℝ→ℂ) (Y : ℝ) (z : ℂ) : ℂ := + ∑P:T,W ((P.val.val.absNorm:ℝ)/Y)*(P.val.val.absNorm:ℂ)^(z-1)*(-star (idealRowHom u.val P.val.val)) + +theorem actual_three_branch_slots (N : ℕ) (e eps c d B : ℝ) + (he : 0phaseSlot u (T j) (W j) (Y j) z + let E : Fin N→ℂ := fun j=>∑P:T j,W j ((P.val.val.absNorm:ℝ)/Y j)*(P.val.val.absNorm:ℂ)^(z-1)* + centralRegularError η u P.val (hs j P.val P.property) x w z + let F : Fin N→ℂ := fun j=>∑P:T j,W j ((P.val.val.absNorm:ℝ)/Y j)*(P.val.val.absNorm:ℂ)^(z-1)* + centralRepeatedTerm η u P.val (hs j P.val P.property) x w z + let yy : Fin N→ℝ := fun j=>(Y j)^(-(4/25:ℝ)) + have hU : 1≤U := by dsimp [U];exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr u.property.1)) + have hUp : 1≤U^eps := Real.one_le_rpow hU heps.le + have hR : 0≤R := by dsimp [R];exact mul_nonneg (mul_nonneg hCt.le (rowCost_nonneg _ _ _ _ _ _ _)) (Real.rpow_nonneg (zero_le_one.trans hU) _) + have hyy (j : Fin N) : 0≤yy j := Real.rpow_nonneg (zero_le_one.trans (hY j)) _ + have hE (j : Fin N) : ‖E j‖≤yy j*(Cr*U^eps) := by + have hb := hregular η u (T j) (fun P hP=>⟨hs j P hP,hQ j P hP,hη j P hP⟩) + (Y j) (hY j) (W j) (hWS j) (hW j) a e x w z ha ha1 he he1.le hx hw hz (hsmall j) + exact (norm_sum_le _ _).trans (hb.trans_eq (by dsimp [yy,U];ring)) + have hF (J : Finset (Fin N)) : L*(∏j∈J,‖F j‖)≤R*(∏j∈J,yy j) := by + have hb := hrepeated S hS hmax hbad u hu η twists T0 a i hT0 ha ha1 hbin T hs hdis hη hQ hsmall + W Y hY hWS hW x w z hx hw hz hwi J + have hp' : (∏j:J,‖F j.val‖)≤∏j:J,∑P:T j.val,‖W j.val ((P.val.val.absNorm:ℝ)/Y j.val)* + (P.val.val.absNorm:ℂ)^(z-1)*centralRepeatedTerm η u P.val (hs j.val P.val P.property) x w z‖ := by + apply Finset.prod_le_prod₀ (fun _ _=>norm_nonneg _) + intro j _ + exact norm_sum_le _ _ + have hh := (mul_le_mul_of_nonneg_left hp' (show 0≤L from norm_nonneg _)).trans hb + rw [Finset.prod_coe_sort J (fun j=>‖F j‖), + Finset.prod_coe_sort J (fun j=>(Y j)^(-(4/25:ℝ)))] at hh + exact hh + have hb := three_branch_bound L R (Cr*U^eps) A E F yy p (norm_nonneg _) hR (by positivity) hyy hp hphase hE hF + have heq : (∏j,∑P:T j,W j ((P.val.val.absNorm:ℝ)/Y j)*(P.val.val.absNorm:ℂ)^(z-1)* + centralNormalizedSlot η u P.val (hs j P.val P.property) x w z)=∏j,(A j+E j+F j) := by + apply Finset.prod_congr rfl + intro j _ + simp only [A,E,F,phaseSlot,centralNormalizedSlot_split,mul_add,Finset.sum_add_distrib] + rw [heq] + apply hb.trans + have hcoef : (Cr*U^eps+2)^N≤(Cr+2)^N*U^(eps*N) := by + have hh : Cr*U^eps+2≤(Cr+2)*U^eps := by nlinarith + have hp' := pow_le_pow_left₀ (show 0≤Cr*U^eps+2 by positivity) hh N + rw [mul_pow] at hp' + have heq : (U^eps)^N=U^(eps*N) := by + rw [←Real.rpow_natCast,←Real.rpow_mul (zero_le_one.trans hU)] + rwa [heq] at hp' + have hyprod : 0≤∏j,yy j := Finset.prod_nonneg (fun j _=>hyy j) + have hpprod : 0≤∏j,p j := Finset.prod_nonneg (fun j _=>zero_le_one.trans (hp j)) + calc + _ ≤ R*((Cr+2)^N*U^(eps*N))*(∏j,yy j)*(∏j,p j) := by gcongr + _ = _ := by + dsimp [R,yy] + have hh : U^eps*U^(eps*N)=U^(eps*(N+1)) := by rw [←Real.rpow_add (zero_lt_one.trans_le hU)];congr 1;ring + calc + _ = Ct*(Cr+2)^N*rowCost S hS u a e eps ((3*i+2:ℕ)*T0)*(U^eps*U^(eps*N))*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j) := by ring + _ = _ := by rw [hh] +end SevenEighths.ProbeCentralAllSlots + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralBranchProduct.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralBranchProduct.lean new file mode 100644 index 0000000000000000000000000000000000000000..f4b298e84deabb18d8214e8cbe5728f487335947 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralBranchProduct.lean @@ -0,0 +1,52 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.CentralExpansion + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeCentralBranchProduct + +theorem coupled_product_bound {ι : Type*} [Fintype ι] + (L R : ℝ) (f g y : ι→ℝ) (hf : ∀i,0≤f i) + (hsub : ∀J : Finset ι,L*(∏j ∈ J,g j)≤R*(∏j ∈ J,y j)) : + L*(∏j : ι, (f j+g j))≤R*(∏j : ι, (f j+y j)) := by + rw [Finset.prod_add,Finset.prod_add,Finset.mul_sum,Finset.mul_sum] + apply Finset.sum_le_sum + intro J hJ + calc + _ = (∏j ∈ J,f j)*(L*∏j ∈ Finset.univ\J,g j) := by ring + _ ≤ (∏j ∈ J,f j)*(R*∏j ∈ Finset.univ\J,y j) := + mul_le_mul_of_nonneg_left (hsub _) (Finset.prod_nonneg (fun j _=>hf j)) + _ = _ := by ring + +theorem three_branch_bound {N : ℕ} (L R E : ℝ) + (A B T : Fin N→ℂ) (y p : Fin N→ℝ) + (hL : 0≤L) (hR : 0≤R) (hE : 0≤E) (hy : ∀j,0≤y j) (hp : ∀j,1≤p j) + (hA : ∀j,‖A j‖≤y j*p j) (hB : ∀j,‖B j‖≤y j*E) + (hT : ∀J : Finset (Fin N),L*(∏j ∈ J,‖T j‖)≤R*(∏j ∈ J,y j)) : + L*‖∏j : Fin N, (A j+B j+T j)‖≤R*(E+2)^N*(∏j : Fin N, y j)*(∏j : Fin N,p j) := by + have hnorm : ‖∏j : Fin N, (A j+B j+T j)‖≤∏j : Fin N,((‖A j‖+‖B j‖)+‖T j‖) := by + rw [norm_prod] + apply Finset.prod_le_prod₀ (fun _ _=>norm_nonneg _) + intro j _ + exact (norm_add_le _ _).trans (add_le_add (norm_add_le _ _) le_rfl) + have hc := coupled_product_bound L R (fun j=>‖A j‖+‖B j‖) (fun j=>‖T j‖) y + (fun j=>add_nonneg (norm_nonneg _) (norm_nonneg _)) hT + have hpoint (j : Fin N) : (‖A j‖+‖B j‖)+y j≤y j*((E+2)*p j) := by + have h := hp j + have hp0 : 0≤p j := zero_le_one.trans h + have he := mul_nonneg (show 0≤E+1 by linarith) (show 0≤p j-1 by linarith) + have hm := mul_nonneg (hy j) he + nlinarith [hA j,hB j] + calc + _ ≤ L*(∏j : Fin N,((‖A j‖+‖B j‖)+‖T j‖)) := mul_le_mul_of_nonneg_left hnorm hL + _ ≤ R*(∏j : Fin N,((‖A j‖+‖B j‖)+y j)) := hc + _ ≤ R*(∏j : Fin N, y j*((E+2)*p j)) := by + apply mul_le_mul_of_nonneg_left _ hR + exact Finset.prod_le_prod₀ (fun j _=>add_nonneg (add_nonneg (norm_nonneg _) (norm_nonneg _)) (hy j)) (fun j _=>hpoint j) + _ = _ := by simp only [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_fin];ring +end SevenEighths.ProbeCentralBranchProduct + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralClassArithmetic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralClassArithmetic.lean new file mode 100644 index 0000000000000000000000000000000000000000..50ec9b6d6ad8ec4ea900e667db06d5708832e601 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralClassArithmetic.lean @@ -0,0 +1,118 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.CubeSlotExponent +import OAI.NumberTheory.DirichletL.Detector.CentralDyadicWeight + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ContDiff +open Filter Set +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification ProbePhysical ProbeMellinBoundary +open ProbeRaySlots HeckeDetectorPhysicalSelection +local notation "O" => HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +omit [NeZero M] in +private theorem classPoolOutside (S : Finset (Ideal O)) (N : ℕ) (c b : ℝ) (Y : Fin N→ℝ) : + ∀j P,P∈pool (RayQuotient.identityClass M H) S c b (Y j) → P.val∉S := + fun j P hP=>(mem_pool _ S c b (Y j) P).mp hP |>.2.2.2 + +theorem actual_class_cube_arithmetic (N n : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh δ margin loss : ℝ) + (he : 0Z^(ell j) + let T : Fin N→Finset PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + ∀t : HeightSpace,((|t.1.1|≤(3*i+1:ℕ)*Z^τ ∧ |t.2|≤(3*i+1:ℕ)*Z^τ) ∧ |t.1.2|≤(3*i+1:ℕ)*Z^τ) → + (∀u∈rows,weightedMean Finset.univ (fun j=>ell j/d) + (fun j=>HeckePrimeAmplitudeBins.amplitude (Y j) (a-1/2) mesh + (HeckePrimeRow.canonicalPrimeAmplitude M H u.val (W j) b (Y j) ((17/50:ℂ)+t.1.2*Complex.I)))=q) → + ‖cubeArithmeticSum S hS hmax η rows T (classPoolOutside M H S N c b Y) W Y a e t‖≤ + C*D*(η.modulus.absNorm:ℝ)^(2*eps)* + Z^(d*Rcount+v*(a-1/2+12*e+eps*(N+8)-17/50)+loss-2/75+q/6+mesh/6) := by + obtain ⟨C,hC,hbound⟩ := actual_fixed_cube_prime_bound M H hH N n e eps c b A R dmin dmax rmin τ ε κ cost mesh δ margin loss + he he1 heps hc hcb hA hR hdmin hdmax hdRange hrmin hτ hε hκ hcost hmesh hδ hbudget hgap hmargin hheight hloss + S hS hfirst hmax ell hell hello hellhi W hWs hW hWB + let AA : ℝ := max 1 ((2:ℝ)^(4/25+12*e+eps*(N+8))) + have hAA : 0Z^(ell j) + let T : Fin N→Finset PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + let z : ℂ := (17/50:ℂ)+t.1.2*Complex.I + let α : ℝ := a-1/2+12*e+eps*(N+8) + let F : FreeRow→ℝ := fun u=>‖∑P:(∀j,T j),calibratedTupleValue S hS hmax η u (fun j=>(P j).val) + (fun j=>classPoolOutside M H S N c b Y j _ (P j).property) W Y + (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I) (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I) z‖ + let E : ℝ := C*(η.modulus.absNorm:ℝ)^(2*eps)*Z^loss*Z^(-2/75+q/6+mesh/6) + have hE : 0≤E := by dsimp [E];positivity + have hF (u : FreeRow) (hu : u∈rows) : F u≤E*rowNorm u^α := by + rcases hrows u hu with ⟨hu1,hulo,hcal,huhi⟩ + have hh := hb d hd hd' u hu1 hulo hcal huhi a i hi ha ha' (hbin u hu) t ht + dsimp only at hh + let g : Fin N→ℝ := fun j=>HeckePrimeAmplitudeBins.amplitude (Y j) (a-1/2) mesh + (HeckePrimeRow.canonicalPrimeAmplitude M H u.val (W j) b (Y j) z) + have hp : (∏j,(Y j)^(-(4/25:ℝ)+g j+mesh))=Z^(-2/75+q/6+mesh/6) := by + rw [show (∏j,(Y j)^(-(4/25:ℝ)+g j+mesh))= + Z^(-(2/75:ℝ)+weightedMean Finset.univ (fun j=>ell j/d) g/6+mesh/6) from + source_slot_product Finset.univ ell g Z d mesh hZp hd0.ne' hellsum] + rw [show weightedMean Finset.univ (fun j=>ell j/d) g=q from hq u hu] + congr 1 ; ring + have hh' := hh.2 + rw [hp] at hh' + convert hh' using 1 ; dsimp [F,E,α,Y,z,g] ; ring + have hh := dyadic_weighted_rows_card α (17/50) E (Z^v) (D*(Z^d)^Rcount) hE + (Real.rpow_pos_of_pos hZp _) rows hcard hnorm F hF z (by simp [z]) + have hsum : ‖cubeArithmeticSum S hS hmax η rows T (classPoolOutside M H S N c b Y) W Y a e t‖≤ + ∑u∈rows,‖frequencyWeight z ⟨u.val,u.property.1⟩‖*F u := by + unfold cubeArithmeticSum + exact (norm_sum_le _ _).trans_eq (by apply Finset.sum_congr rfl;intro u hu;rw [norm_mul]) + have hAp : ProbeSelectedPrimeSums.annularPower 1 2 (α-17/50)≤AA := + annular_power_uniform _ _ (by dsimp [α];linarith) + apply (hsum.trans hh).trans + have hpow : (Z^d)^Rcount*Z^loss*Z^(-2/75+q/6+mesh/6)*(Z^v)^(α-17/50)= + Z^(d*Rcount+v*(a-1/2+12*e+eps*(N+8)-17/50)+loss-2/75+q/6+mesh/6) := by + simp_rw [←Real.rpow_mul hZp.le] + rw [←Real.rpow_add hZp,←Real.rpow_add hZp,←Real.rpow_add hZp] + congr 1 + dsimp [α] + ring + calc + _ ≤ (D*(Z^d)^Rcount)*E*AA*(Z^v)^(α-17/50) := by gcongr + _ = _ := by + dsimp [E] + calc + _ = (C*AA)*D*(η.modulus.absNorm:ℝ)^(2*eps)* + ((Z^d)^Rcount*Z^loss*Z^(-2/75+q/6+mesh/6)*(Z^v)^(α-17/50)) := by ring + _ = _ := by rw [hpow] +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralClassPartition.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralClassPartition.lean new file mode 100644 index 0000000000000000000000000000000000000000..a124df2b8d8f480d1b9efb38b032a768fc584053 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralClassPartition.lean @@ -0,0 +1,65 @@ +import OAI.NumberTheory.DirichletL.Detector.CentralClassArithmetic +import OAI.NumberTheory.DirichletL.Hecke.DetectorAmplitudeFirst +import OAI.NumberTheory.DirichletL.Hecke.DetectorClassBudget + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification ProbePhysical ProbeMellinBoundary +open HeckeDetectorAmplitudeFirst HeckeDetectorFiberPartition + +lemma sum_amplitudeRows {Slot : Type*} (rows : Finset FreeRow) (slots : Finset Slot) + (U cap mesh : ℝ) (hm : 0 HeckeFamily.O + +lemma cubeArithmeticSum_norm {K : ℕ} (S : Finset (Ideal O)) (hS : SourceExclusions S) + (hmax : ∀P∈S,P.IsMaximal) (η : Character) (R : Finset FreeRow) + (T : Fin K→Finset PrimeIdeal) (hT : ∀j P,P∈T j→P.val∉S) + (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) (a e : ℝ) (t : HeightSpace) + (A : FreeRow→ℝ) + (hA : ∀u∈R,‖∑P:(∀j,T j),calibratedTupleValue S hS hmax η u (fun j=>(P j).val) + (fun j=>hT j _ (P j).property) W Yp + (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I) (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I) + ((17/50:ℂ)+t.1.2*Complex.I)‖≤A u) : + ‖cubeArithmeticSum S hS hmax η R T hT W Yp a e t‖≤ + ∑u∈R,rowNorm u^(-(17/50:ℝ))*A u := by + unfold cubeArithmeticSum + refine (norm_sum_le _ _).trans (Finset.sum_le_sum fun u hu=>?_) + rw [norm_mul,frequencyWeight_ideal_norm] + have hz : (((17/50:ℂ)+t.1.2*Complex.I).re:ℝ)=17/50 := by simp + rw [hz] + exact mul_le_mul_of_nonneg_left (hA u hu) (Real.rpow_nonneg (by positivity) _) + +theorem actual_common_cube_norm (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0(P j).val) + (fun j=>hT j _ (P j).property) W Yp + (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I) (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I) + ((17/50:ℂ)+t.1.2*Complex.I)‖≤A u) → + ‖finiteCentralCubeRows S hS hmax η R T hT W Yp W0 W1 X Y Z e (fun _=>a) (fun _=>H)‖≤ + C*(X^(4/25:ℝ)*Z^(a+16*e-33/50)*Y^(-a-6*e))* + (∑u∈R,rowNorm u^(-(17/50:ℝ))*A u) := by + obtain ⟨D,hD,hprofile⟩ := profile_uniform_moments W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + 0 2 (17/50) (17/50) (-1) 1 (by norm_num) 0 + refine ⟨‖((1/(2*Real.pi):ℝ):ℂ)^3‖*D,mul_pos (norm_pos_iff.mpr (by + apply pow_ne_zero + exact_mod_cast (div_ne_zero one_ne_zero (mul_ne_zero (by norm_num) Real.pi_ne_zero)))) hD,?_⟩ + intro K ι _ e a B H i he he' ha ha' hB hH S hS hmax hfirst η R hR T hT ψ hbin W Yp X Y Z hX hY hZ A hA hb + let E : Set HeightSpace := {t | (|t.1.1|≤H ∧ |t.2|≤H) ∧ |t.1.2|≤H} + let V : HeightSpace→ℂ := fun t=>sourceMellinWeight W0 W1 X Y Z + (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I) (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I) + ((17/50:ℂ)+t.1.2*Complex.I) + let F := E.indicator (fun t=>V t*cubeArithmeticSum S hS hmax η R T hT W Yp a e t) + let mass : ℝ := ∑u∈R,rowNorm u^(-(17/50:ℝ))*A u + have hm : 0≤mass := Finset.sum_nonneg fun u hu=>mul_nonneg (Real.rpow_nonneg (by unfold rowNorm;positivity) _) (hA u hu) + let scale : ℝ := X^(4/25:ℝ)*Z^(a+16*e-33/50)*Y^(-a-6*e) + have hs : 0≤scale := by dsimp [scale];positivity + have hv (t : HeightSpace) : ‖V t‖=scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖ := by + have hxre : (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I).re=a+16*e := by simp + have hwre : (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I).re=1-a-6*e := by simp + have hzre : ((17/50:ℂ)+t.1.2*Complex.I).re=17/50 := by simp + dsimp [V] + rw [sourceMellinWeight_eq_scale,norm_mul,sourceScale_norm X Y Z hX hY hZ,hxre,hwre,hzre] + have hs0 : X^(1/2-(17/50:ℝ))*Z^((a+16*e)+17/50-1)*Y^((1-a-6*e)-1)=scale := by + rw [show (1/2-17/50:ℝ)=4/25 by norm_num, + show (a+16*e)+17/50-1=a+16*e-33/50 by ring, + show (1-a-6*e)-1=-a-6*e by ring] + rw [hs0] + simp [onLines] + have hp := hprofile (a+16*e) (by constructor <;> linarith) (17/50) ⟨le_rfl,le_rfl⟩ + (1-a-6*e) (by constructor <;> linarith) + simp only [pow_zero,one_mul] at hp + have hg : Integrable (fun t=>scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖*mass) heightMeasure := + (hp.1.const_mul scale).mul_const mass + have hf := cube_common_profile_integral e a B H i he he' ha ha' hB hH S hS hmax hfirst η R hR + T hT ψ hbin W Yp W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ + change Integrable F heightMeasure ∧ _ at hf + have hb' (t : HeightSpace) : ‖F t‖≤scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖*mass := by + by_cases ht : t∈E + · dsimp only [F] + rw [Set.indicator_of_mem ht,norm_mul,hv] + exact mul_le_mul_of_nonneg_left (cubeArithmeticSum_norm S hS hmax η R T hT W Yp a e t A (hb t ht)) (by positivity) + · dsimp only [F] + rw [Set.indicator_of_notMem ht,norm_zero] + positivity + rw [hf.2,norm_mul] + calc + _ ≤ ‖((1/(2*Real.pi):ℝ):ℂ)^3‖*(∫t,scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖*mass ∂heightMeasure) := + mul_le_mul_of_nonneg_left ((norm_integral_le_integral_norm _).trans (integral_mono hf.1.norm hg hb')) (norm_nonneg _) + _ = ‖((1/(2*Real.pi):ℝ):ℂ)^3‖*(scale*(∫t,‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖ ∂heightMeasure)*mass) := by + rw [integral_mul_const,integral_const_mul] + _ ≤ ‖((1/(2*Real.pi):ℝ):ℂ)^3‖*(scale*D*mass) := by gcongr;exact hp.2 + _ = _ := by dsimp [scale,mass];ring + +theorem actual_common_cube_aggregate_norm (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0a) (fun _=>H)‖≤ + C*(X^(4/25:ℝ)*Z^(a+16*e-33/50)*Y^(-a-6*e))* + A := by + obtain ⟨D,hD,hprofile⟩ := profile_uniform_moments W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + 0 2 (17/50) (17/50) (-1) 1 (by norm_num) 0 + refine ⟨‖((1/(2*Real.pi):ℝ):ℂ)^3‖*D,mul_pos (norm_pos_iff.mpr (by + apply pow_ne_zero + exact_mod_cast (div_ne_zero one_ne_zero (mul_ne_zero (by norm_num) Real.pi_ne_zero)))) hD,?_⟩ + intro K ι _ e a B H i he he' ha ha' hB hH S hS hmax hfirst η R hR T hT ψ hbin W Yp X Y Z hX hY hZ A hA hb + let E : Set HeightSpace := {t | (|t.1.1|≤H ∧ |t.2|≤H) ∧ |t.1.2|≤H} + let V : HeightSpace→ℂ := fun t=>sourceMellinWeight W0 W1 X Y Z + (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I) (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I) + ((17/50:ℂ)+t.1.2*Complex.I) + let F := E.indicator (fun t=>V t*cubeArithmeticSum S hS hmax η R T hT W Yp a e t) + let mass : ℝ := A + have hm : 0≤mass := hA + let scale : ℝ := X^(4/25:ℝ)*Z^(a+16*e-33/50)*Y^(-a-6*e) + have hs : 0≤scale := by dsimp [scale];positivity + have hv (t : HeightSpace) : ‖V t‖=scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖ := by + have hxre : (((a+16*e:ℝ):ℂ)+t.1.1*Complex.I).re=a+16*e := by simp + have hwre : (((1-a-6*e:ℝ):ℂ)+t.2*Complex.I).re=1-a-6*e := by simp + have hzre : ((17/50:ℂ)+t.1.2*Complex.I).re=17/50 := by simp + dsimp [V] + rw [sourceMellinWeight_eq_scale,norm_mul,sourceScale_norm X Y Z hX hY hZ,hxre,hwre,hzre] + have hs0 : X^(1/2-(17/50:ℝ))*Z^((a+16*e)+17/50-1)*Y^((1-a-6*e)-1)=scale := by + rw [show (1/2-17/50:ℝ)=4/25 by norm_num, + show (a+16*e)+17/50-1=a+16*e-33/50 by ring, + show (1-a-6*e)-1=-a-6*e by ring] + rw [hs0] + simp [onLines] + have hp := hprofile (a+16*e) (by constructor <;> linarith) (17/50) ⟨le_rfl,le_rfl⟩ + (1-a-6*e) (by constructor <;> linarith) + simp only [pow_zero,one_mul] at hp + have hg : Integrable (fun t=>scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖*mass) heightMeasure := + (hp.1.const_mul scale).mul_const mass + have hf := cube_common_profile_integral e a B H i he he' ha ha' hB hH S hS hmax hfirst η R hR + T hT ψ hbin W Yp W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ + change Integrable F heightMeasure ∧ _ at hf + have hb' (t : HeightSpace) : ‖F t‖≤scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖*mass := by + by_cases ht : t∈E + · dsimp only [F] + rw [Set.indicator_of_mem ht,norm_mul,hv] + exact mul_le_mul_of_nonneg_left (hb t ht) (by positivity) + · dsimp only [F] + rw [Set.indicator_of_notMem ht,norm_zero] + positivity + rw [hf.2,norm_mul] + calc + _ ≤ ‖((1/(2*Real.pi):ℝ):ℂ)^3‖*(∫t,scale*‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖*mass ∂heightMeasure) := + mul_le_mul_of_nonneg_left ((norm_integral_le_integral_norm _).trans (integral_mono hf.1.norm hg hb')) (norm_nonneg _) + _ = ‖((1/(2*Real.pi):ℝ):ℂ)^3‖*(scale*(∫t,‖onLines W0 W1 (a+16*e) (17/50) (1-a-6*e) t‖ ∂heightMeasure)*mass) := by + rw [integral_mul_const,integral_const_mul] + _ ≤ ‖((1/(2*Real.pi):ℝ):ℂ)^3‖*(scale*D*mass) := by gcongr;exact hp.2 + _ = _ := by dsimp [scale,mass];ring +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralDyadicWeight.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralDyadicWeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..1b99e355275651501ff245eddfad17cb701b335a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralDyadicWeight.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Detector.CentralCubeNorm +import OAI.NumberTheory.DirichletL.Detector.CentralExponent + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification ProbePhysical + +lemma dyadic_weighted_rows_card (α r C U B : ℝ) (hC : 0≤C) (hU : 0 linarith + +lemma relative_extend (δ d R q ζ : ℝ) (hζ : 0≤ζ) (hd : d≤13/16+ζ) + (hslo : 0≤R+δ/2-17/50) (hshi : R+δ/2-17/50≤2) : + relativeExponent δ d R q≤relativeExponent δ (13/16) R q+2*ζ := by + have hh := mul_le_mul_of_nonneg_right (show d-13/16≤ζ by linarith) hslo + have hh' := mul_le_mul_of_nonneg_left hshi hζ + unfold relativeExponent + nlinarith + +lemma balanced_source_margin (δ x R Δ loss ζ d : ℝ) + (hδ : 0≤δ) (hδ1 : δ≤5/6) (hx : 0≤x) (hx1 : x≤1/2) + (hR : R≤Endpoint.balancedRowCount δ (1/2-x)+Δ/4+loss) + (hζ : 0≤ζ) (hd : d≤13/16+ζ) + (hslo : 0≤R+δ/2-17/50) (hshi : R+δ/2-17/50≤2) : + sourceExponent ((1+δ)/2) d R (δ*x)-(3/16+Δ)≤ + -49/440640-(51/64)*Δ+(13/16)*loss+2*ζ := by + have hb := Endpoint.balanced_endpoint_margin hδ hδ1 + (show 0≤1/2-x by linarith) (show 1/2-x≤1/2 by linarith) + have he := relative_extend δ d R (δ*x) ζ hζ hd hslo hshi + rw [original_exponent_identity] + have hid : 2*((1+δ)/2)-1=δ := by ring + rw [hid] + unfold Endpoint.balancedExponent at hb + unfold relativeExponent at he ⊢ + nlinarith + +lemma high_source_margin (δ R q Δ loss ζ d : ℝ) + (hq : q≤δ/2) (hR : R≤1-δ+loss) + (hζ : 0≤ζ) (hd : d≤13/16+ζ) + (hslo : 0≤R+δ/2-17/50) (hshi : R+δ/2-17/50≤2) : + sourceExponent ((1+δ)/2) d R q-(3/16+Δ)≤ + -1/48-δ/16-Δ+(13/16)*loss+2*ζ := by + have he := relative_extend δ d R q ζ hζ hd hslo hshi + rw [original_exponent_identity] + have hid : 2*((1+δ)/2)-1=δ := by ring + rw [hid] + unfold relativeExponent at he ⊢ + nlinarith + +lemma floor_source_margin (q Δ ζ d : ℝ) (hq : q≤1/100) + (hζ : 0≤ζ) (hd : d≤13/16+ζ) : + sourceExponent (51/100) d 1 q-(3/16+Δ)≤-7/1200-Δ+2*ζ := by + have he := relative_extend (1/50) d 1 q ζ hζ hd (by norm_num) (by norm_num) + rw [original_exponent_identity] + norm_num only at * + unfold relativeExponent at he ⊢ + nlinarith + +lemma intermediate_source_margin (δ q Δ d : ℝ) (_hδ : 0≤δ) (hδ1 : δ≤5/6) + (hq : q≤δ/2) (hd : d≤1/2) : + sourceExponent ((1+δ)/2) d (76/75-(2/3)*δ) q-(3/16+Δ)≤-49/14400-Δ := by + have hs : 0≤(76/75-(2/3)*δ)+δ/2-17/50 := by linarith + have hm := mul_le_mul_of_nonneg_right hd hs + unfold sourceExponent + nlinarith + +def realLoss (N : ℕ) (d e eps heightLoss mesh : ℝ) : ℝ := + (105/8)*e+12*d*e+d*eps*(N+8)+heightLoss+mesh/6 + +lemma realLoss_bound (N : ℕ) (d e eps heightLoss mesh : ℝ) + (hd : d≤1) (he : 0≤e) (heps : 0≤eps) : + realLoss N d e eps heightLoss mesh≤26*e+(N+8)*eps+heightLoss+mesh/6 := by + have h1 := mul_le_mul_of_nonneg_right hd he + have h2 := mul_le_mul_of_nonneg_right hd (show 0≤eps*(N+8) by positivity) + unfold realLoss + nlinarith + +lemma physical_scale_identity (Z a e : ℝ) (hZ : 0 nlinarith + +lemma balanced_mixed_margin (δ x Δ loss ζ μ v d : ℝ) + (hδ : 0≤δ) (hd : δ≤5/6) (hx : 0≤x) (hx' : x≤1/2) + (hΔ : 0≤Δ) (hΔ' : Δ≤1/8) (hl : 0≤loss) (hl' : loss≤1/32) + (hζ : 0≤ζ) (hv : v≤13/16+ζ) (hμ : 0≤μ) (hdv : d-v≤μ) : + let R := Endpoint.balancedRowCount δ (1/2-x)+Δ/4+loss + mixedSourceExponent ((1+δ)/2) v d R (δ*x)-(3/16+Δ)≤ + -49/440640-(51/64)*Δ+(13/16)*loss+2*ζ+(3/2)*μ := by + dsimp only + let R := Endpoint.balancedRowCount δ (1/2-x)+Δ/4+loss + have hr := balanced_count_range δ x Δ loss hδ hd hx hx' hΔ hΔ' hl hl' + have hlo : 0≤R+δ/2-17/50 := by dsimp [R]; linarith [hr.1] + have hhi : R+δ/2-17/50≤2 := by dsimp [R]; linarith [hr.2] + have hm := balanced_source_margin δ x R Δ loss ζ v hδ hd hx hx' le_rfl hζ hv hlo hhi + have hs := mixed_source_slack ((1+δ)/2) v d R (δ*x) μ (3/2) + (by dsimp [R];linarith [hr.1]) hr.2 hμ hdv + linarith + +lemma high_mixed_margin (δ q Δ loss ζ μ v d : ℝ) + (hδ : 5/6≤δ) (hd : δ≤1) (hq : q≤δ/2) + (hl : 0≤loss) (hl' : loss≤1/32) + (hζ : 0≤ζ) (hv : v≤13/16+ζ) (hμ : 0≤μ) (hdv : d-v≤μ) : + mixedSourceExponent ((1+δ)/2) v d (1-δ+loss) q-(3/16+Δ)≤ + -1/48-δ/16-Δ+(13/16)*loss+2*ζ+μ := by + have hlo : 0≤(1-δ+loss)+δ/2-17/50 := by linarith + have hhi : (1-δ+loss)+δ/2-17/50≤2 := by linarith + have hm := high_source_margin δ (1-δ+loss) q Δ loss ζ v hq le_rfl hζ hv hlo hhi + have hs := mixed_source_slack ((1+δ)/2) v d (1-δ+loss) q μ 1 + (by linarith) (by linarith) hμ hdv + linarith + +lemma balanced_mixed_saving (δ x Δ loss ζ μ v d other saving : ℝ) + (hδ : 0≤δ) (hd : δ≤5/6) (hx : 0≤x) (hx' : x≤1/2) + (hΔ : 0≤Δ) (hΔ' : Δ≤1/8) (hl : 0≤loss) (hl' : loss≤1/32) + (hζ : 0≤ζ) (hv : v≤13/16+ζ) (hμ : 0≤μ) (hdv : d-v≤μ) + (hbudget : (13/16)*loss+2*ζ+(3/2)*μ+other+saving≤49/440640) : + mixedSourceExponent ((1+δ)/2) v d + (Endpoint.balancedRowCount δ (1/2-x)+Δ/4+loss) (δ*x)+other≤3/16+Δ-saving := by + have hm := balanced_mixed_margin δ x Δ loss ζ μ v d hδ hd hx hx' hΔ hΔ' hl hl' hζ hv hμ hdv + linarith +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralPrimeSum.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralPrimeSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ac360d09a04fe4e07da73b4330e586aef196645 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralPrimeSum.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Detector.CentralAllSlots +import OAI.NumberTheory.DirichletL.PrimeRows.CentralTargetCost + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeCentralPrimeSum +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily ProbePhysical +open CanonicalQuadraticSieve ProbeCentralAllSlots +local notation "O" => HeckeFamily.O + +theorem actual_central_prime_sum (N : ℕ) (e eps c d B : ℝ) + (he : 0(P j).val) + (fun j=>hPS j (P j).val (P j).property) W Y x w z‖ ≤ + C*(η.modulus.absNorm:ℝ)^(2*eps)*rowNorm u^(a-1/2+12*e+eps*(N+8))* + (3+(3*i+2:ℕ)*T0)^(2+4*eps)*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j) := by + obtain ⟨Ca,hCa,hall⟩ := actual_three_branch_slots N e eps c d B he he1 heps hc hd hB + obtain ⟨Cb,hCb,hcost⟩ := central_remaining_rowCost_bound e eps he he1 heps S hS hfirst + refine ⟨Ca*Cb,mul_pos hCa hCb,?_⟩ + intro u hu ι _ η twists T0 a i hT0 ha ha1 hbin T hPS hdis hη hQ hsmall W Y hY hWS hW x w z hx hw hz hxi hwi p hp hphase + let hs : ∀j P,P∈T j→Supported P.val := fun j P hP=>outside_prime_supported S hS.bad P (hPS j P hP) + have hinj (P : ∀j,T j) : Function.Injective (fun j=>(P j).val) := by + intro j l hh + change (P j).val=(P l).val at hh + by_contra hne + exact Finset.disjoint_left.mp (hdis j l hne) (P j).property (by rw [hh];exact (P l).property) + have ha' := hall S hS.prime hmax hS.bad u hu η twists T0 a i hT0 ha ha1 hbin T hs hdis hη hQ hsmall + W Y hY hWS hW x w z hx hw hz hwi p hp hphase + have hc' := hcost η u twists T0 a ((3*i+2:ℕ)*T0) i hT0 ha ha1 le_rfl hbin x w z hx hw hz hxi + have hN : 0Real.rpow_nonneg (zero_le_one.trans (hY j)) _) + have hpp : 0≤∏j,p j := Finset.prod_nonneg (fun j _=>zero_le_one.trans (hp j)) + rw [calibrated_prime_slots_separate S hS hmax η u T hPS hinj W Y a e x w z + hfirst ha ha1 he he1.le hx hw hz hQ hη hsmall,centralRowScalar_split,norm_mul,norm_mul] + have hn := mul_le_mul_of_nonneg_left ha' (norm_nonneg (centralRemainingScalar S hS η u x w z)) + have hc'' := mul_le_mul_of_nonneg_right hc' + (show 0≤Ca*rowNorm u^(eps*(N+1))*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j) by positivity) + have hpow : rowNorm u^(a-1/2+12*e+7*eps)*rowNorm u^(eps*(N+1))= + rowNorm u^(a-1/2+12*e+eps*(N+8)) := by + rw [←Real.rpow_add hN] + congr 1 + ring + calc + _ = ‖centralRemainingScalar S hS η u x w z‖* + (‖star ((calibrationForSet S hmax).residueMonoid u.val)*HeckeOrigin.continued (rowCharacter S hS.prime u) w‖* + ‖∏j,∑P:T j,W j ((P.val.val.absNorm:ℝ)/Y j)*(P.val.val.absNorm:ℂ)^(z-1)*centralNormalizedSlot η u P.val (hs j P.val P.property) x w z‖) := by ring + _ ≤ ‖centralRemainingScalar S hS η u x w z‖* + (Ca*ProbeCentralRepeatedProduct.rowCost S hS.prime u a e eps ((3*i+2:ℕ)*T0)* + rowNorm u^(eps*(N+1))*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j)) := hn + _ = (‖centralRemainingScalar S hS η u x w z‖*ProbeCentralRepeatedProduct.rowCost S hS.prime u a e eps ((3*i+2:ℕ)*T0))* + (Ca*rowNorm u^(eps*(N+1))*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j)) := by ring + _ ≤ (Cb*(η.modulus.absNorm:ℝ)^(2*eps)*rowNorm u^(a-1/2+12*e+7*eps)*(3+(3*i+2:ℕ)*T0)^(2+4*eps))* + (Ca*rowNorm u^(eps*(N+1))*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j)) := hc'' + _ = _ := by + calc + _ = Ca*Cb*(η.modulus.absNorm:ℝ)^(2*eps)*(rowNorm u^(a-1/2+12*e+7*eps)*rowNorm u^(eps*(N+1)))* + (3+(3*i+2:ℕ)*T0)^(2+4*eps)*(∏j,(Y j)^(-(4/25:ℝ)))*(∏j,p j) := by ring + _ = _ := by rw [hpow] +end SevenEighths.ProbeCentralPrimeSum + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedChoices.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedChoices.lean new file mode 100644 index 0000000000000000000000000000000000000000..daf67f7f387daa0b865a63a9cd84f94fdeca3ab2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedChoices.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.CentralSplit +import OAI.NumberTheory.DirichletL.Detector.SelectedPrimeSums + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeCentralRepeatedChoices +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily ProbePhysical +local notation "O" => HeckeFamily.O + +def activeChoices {k : ℕ} (u : FreeRow) (T : Fin k→Finset PrimeIdeal) + (W : Fin k→ℝ→ℂ) (Y : Fin k→ℝ) : Finset (∀j,T j) := + Finset.univ.filter (fun P=>∀j,repeatedRowPrime u (P j).val ∧ + W j (((P j).val.val.absNorm:ℝ)/Y j)≠0) + +lemma active_card_le_divisors {k : ℕ} (u : FreeRow) (T : Fin k→Finset PrimeIdeal) + (W : Fin k→ℝ→ℂ) (Y : Fin k→ℝ) : + (activeChoices u T W Y).card≤(IdealMobiusDivisorSum.idealDivisors (Ideal.span {u.val})).card^k := by + let U : Ideal O := Ideal.span {u.val} + have hU : U≠0 := Ideal.span_singleton_eq_bot.not.mpr u.property.1 + let f : activeChoices u T W Y→(Fin k→IdealMobiusDivisorSum.idealDivisors U) := + fun P j=>⟨(P.val j).val.val,(IdealMobiusDivisorSum.mem_idealDivisors hU).mpr + (((Finset.mem_filter.mp P.property).2 j).1.1)⟩ + have hf : Function.Injective f := by + intro P Q h + apply Subtype.ext + funext j + apply Subtype.ext + apply Subtype.ext + exact congrArg (fun g=>(g j).val) h + have hc := Fintype.card_le_of_injective f hf + simpa only [Fintype.card_coe,Fintype.card_fun,Fintype.card_fin] using hc + +theorem active_card_subpower (N : ℕ) (eps : ℝ) (heps : 0 HeckeFamily.O + +def rowCost (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) (u : FreeRow) + (a e eps T : ℝ) : ℝ := + ((ProbeRowRadicalConductor.fixedConductorConstant S:ℝ)*(Ideal.span {u.val}:Ideal O).absNorm)^(a-1/2+6*e)* + ((radical (rowCharacter S hS u).modulus).absNorm:ℝ)^(6*e+2*eps)* + (3+T)^2*(presentationComplexity (rowCharacter S hS u) T)^eps + +lemma rowCost_nonneg (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) (u : FreeRow) + (a e eps T : ℝ) : 0≤rowCost S hS u a e eps T := by + unfold rowCost presentationComplexity HeckeLogarithmic.complexity + positivity + +lemma repeated_weight_bound (η : Character) (u : FreeRow) (P : PrimeIdeal) + (hs : Supported P.val) (hη : IsCoprime P.val η.modulus) + (a e B Y : ℝ) (W : ℝ→ℂ) (x w z : ℂ) + (hB : 0≤B) (hW : ∀t,‖W t‖≤B) + (hQ : (480:ℝ)≤P.val.absNorm) (hsmall : 198*(P.val.absNorm:ℝ)^(-10*e)≤1/2) + (ha : (51/100:ℝ)≤a) (ha1 : a≤1) (he : 0(P j).val) := fun j l h=>hdis (Subtype.ext h) + have hdiv (j : Fin k) := actual_multiplicity_divisor u (primaryGenerator (P j).val) (supported_primeGenerator_prime (P j) (hs j)) + have hspan (j : Fin k) : (Ideal.span {primaryGenerator (P j).val}:Ideal O)=(P j).val := span_primaryGenerator_of_supported (P j).val (hs j) + have hb' := hb η twists T a i hT ha ha1 hbin k (fun j=>(P j).val) (fun j=>(P j).property) hi + (fun j=>multiplicity (primaryGenerator (P j).val) u.val) (fun j=>(hr j).2) + (fun j=>by have hd := (hdiv j).1;rw [hspan j] at hd;exact hd) w hw hwi + let q : Fin k→ℝ := fun j=>(P j).val.absNorm + have hq (j : Fin k) : 0norm_nonneg _) + (fun j (_:j∈Finset.univ)=>repeated_weight_bound η u (P j) (hs j) (hη j) + a e B (Y j) (W j) x w z hB (hW j) (hQ j) (hsmall j) ha ha1 he he1.le hx hw hz (hr j)) + simpa only [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_fin,mul_pow] using ht + have hbc : + ‖star ((calibrationForSet S hmax).residueMonoid u.val)*HeckeOrigin.continued (rowCharacter S hS u) w‖* + ∏j,q j^(-w.re) ≤ C*rowCost S hS u a e eps ((3*i+2:ℕ)*T)*∏j,q j^(-(1/2:ℝ)) := by + convert hb' using 1 ; dsimp only [rowCost,q] ; ring + have heq : (∏j,q j^z.re)*(∏j,q j^(-(1/2:ℝ)))=∏j,q j^(z.re-1/2) := by + rw [←Finset.prod_mul_distrib] + apply Finset.prod_congr rfl + intro j _ + rw [←Real.rpow_add (hq j)] + congr 1 + calc + _ ≤ ‖star ((calibrationForSet S hmax).residueMonoid u.val)*HeckeOrigin.continued (rowCharacter S hS u) w‖* + ((812*B)^k*(∏j,q j^z.re)*(∏j,q j^(-w.re))) := mul_le_mul_of_nonneg_left hp (norm_nonneg _) + _ = ((812*B)^k*(∏j,q j^z.re))*(‖star ((calibrationForSet S hmax).residueMonoid u.val)* + HeckeOrigin.continued (rowCharacter S hS u) w‖*∏j,q j^(-w.re)) := by ring + _ ≤ ((812*B)^k*(∏j,q j^z.re))*(C*rowCost S hS u a e eps ((3*i+2:ℕ)*T)*∏j,q j^(-(1/2:ℝ))) := + mul_le_mul_of_nonneg_left hbc (by positivity) + _ = _ := by rw [show ((812*B)^k*(∏j,q j^z.re))*(C*rowCost S hS u a e eps ((3*i+2:ℕ)*T)*∏j,q j^(-(1/2:ℝ)))= + C*(812*B)^k*rowCost S hS u a e eps ((3*i+2:ℕ)*T)*((∏j,q j^z.re)*(∏j,q j^(-(1/2:ℝ)))) by ring,heq] +end SevenEighths.ProbeCentralRepeatedProduct + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedSubset.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedSubset.lean new file mode 100644 index 0000000000000000000000000000000000000000..f0c885b08cf3ecc1846810cd9dc7716d271b5fd6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedSubset.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Detector.CentralRepeatedSum + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeCentralRepeatedSubset +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily ProbePhysical +open CanonicalQuadraticSieve ProbeCentralRepeatedProduct ProbeCentralRepeatedSum +local notation "O" => HeckeFamily.O + +theorem actual_repeated_subset (N : ℕ) (e eps c d B : ℝ) + (he : 0(E.symm j).val + have hi : Function.Injective idx := fun j l h=>E.symm.injective (Subtype.ext h) + have hk : k≤N := by + dsimp [k] + simpa only [Fintype.card_coe,Finset.card_univ,Fintype.card_fin] using J.card_le_univ + have hd' (P : ∀j,T (idx j)) : Function.Injective (fun j=>(P j).val) := by + intro j l heq + change (P j).val=(P l).val at heq + by_contra hne + have hdiff : idx j≠idx l := fun h=>hne (hi h) + exact Finset.disjoint_left.mp (hdis _ _ hdiff) (P j).property (by rw [heq];exact (P l).property) + have hb := hmain S hS hmax hbad u hu η twists T0 a i hT0 ha ha1 hbin k hk + (fun j=>T (idx j)) (fun j P hP=>hs (idx j) P hP) hd' + (fun j P hP=>hη (idx j) P hP) (fun j P hP=>hQ (idx j) P hP) + (fun j P hP=>hsmall (idx j) P hP) (fun j=>W (idx j)) (fun j=>Y (idx j)) + (fun j=>hY (idx j)) (fun j=>hWS (idx j)) (fun j=>hW (idx j)) x w z hx hw hz hwi + have hleft : (∏j:Fin k,∑P:T (idx j),‖W (idx j) ((P.val.val.absNorm:ℝ)/Y (idx j))*(P.val.val.absNorm:ℂ)^(z-1)* + centralRepeatedTerm η u P.val (hs (idx j) P.val P.property) x w z‖)= + ∏j:J,∑P:T j.val,‖W j.val ((P.val.val.absNorm:ℝ)/Y j.val)*(P.val.val.absNorm:ℂ)^(z-1)* + centralRepeatedTerm η u P.val (hs j.val P.val P.property) x w z‖ := + Fintype.prod_equiv E.symm _ _ (fun _=>rfl) + have hright : (∏j:Fin k,(Y (idx j))^(-(4/25:ℝ)))=∏j:J,(Y j.val)^(-(4/25:ℝ)) := + Fintype.prod_equiv E.symm _ _ (fun _=>rfl) + rw [hleft,hright] at hb + exact hb +end SevenEighths.ProbeCentralRepeatedSubset + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedSum.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..6b2b8be7f793d4572aae43e5a6156069595004b2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CentralRepeatedSum.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Detector.CentralRepeatedProduct +import OAI.NumberTheory.DirichletL.Detector.CentralRepeatedChoices + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeCentralRepeatedSum +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily ProbePhysical +open CanonicalQuadraticSieve ProbeCentralRepeatedProduct ProbeCentralRepeatedChoices +open ProbeSelectedPrimeSums +local notation "O" => HeckeFamily.O + +theorem actual_repeated_sum (N : ℕ) (e eps c d B : ℝ) + (he : 0(P j).val)) → + (∀j P,P∈T j→IsCoprime P.val η.modulus) → + (∀j P,P∈T j→(480:ℝ)≤P.val.absNorm) → + (∀j P,P∈T j→198*(P.val.absNorm:ℝ)^(-10*e)≤1/2) → + ∀(W : Fin k→ℝ→ℂ) (Y : Fin k→ℝ), + (∀j,1≤Y j) → (∀j,Function.support (W j)⊆Set.Icc c d) → (∀j t,‖W j t‖≤B) → + ∀x w z : ℂ,x.re=a+16*e → w.re=1-a-6*e → z.re=17/50 → |w.im|≤(3*i+2:ℕ)*T0 → + ‖star ((calibrationForSet S hmax).residueMonoid u.val)*HeckeOrigin.continued (rowCharacter S hS u) w‖* + (∏j,∑P:T j,‖W j ((P.val.val.absNorm:ℝ)/Y j)*(P.val.val.absNorm:ℂ)^(z-1)* + centralRepeatedTerm η u P.val (hs j P.val P.property) x w z‖) ≤ + C*rowCost S hS u a e eps ((3*i+2:ℕ)*T0)* + ((Ideal.span {u.val}:Ideal O).absNorm:ℝ)^eps*∏j,(Y j)^(-(4/25:ℝ)) := by + obtain ⟨C,hC,hprod⟩ := selected_repeated_product e eps he he1 heps + obtain ⟨D,hD,hcount⟩ := active_card_subpower N eps heps + let A := annularPower c d (-(4/25:ℝ)) + let E := (max 1 (812*B*A))^N + have hA : 0≤A := annularPower_nonneg c d _ hc + have hE : 0Real.rpow_nonneg (hY0 j).le _) + have hterm (P : ∀j,T j) (hP : P∈activeChoices u T W Y) : + L*(∏j,‖W j (((P j).val.val.absNorm:ℝ)/Y j)*((P j).val.val.absNorm:ℂ)^(z-1)* + centralRepeatedTerm η u (P j).val (hs j (P j).val (P j).property) x w z‖)≤ + C*E*R*∏j,(Y j)^(-(4/25:ℝ)) := by + have hp := (Finset.mem_filter.mp hP).2 + have hb := hprod S hS hmax hbad u hu η twists T0 a i hT0 ha ha1 hbin k + (fun j=>(P j).val) (fun j=>hs j (P j).val (P j).property) (hdis P) + (fun j=>hη j (P j).val (P j).property) (fun j=>hQ j (P j).val (P j).property) + (fun j=>hsmall j (P j).val (P j).property) (fun j=>(hp j).1) + B W Y hB hW x w z hx hw hz hwi + have hpow : (∏j,((P j).val.val.absNorm:ℝ)^(z.re-1/2))≤A^k*∏j,(Y j)^(-(4/25:ℝ)) := by + have hh := Finset.prod_le_prod₀ (s:=Finset.univ) (fun j _=>Real.rpow_nonneg (show (0:ℝ)≤(P j).val.val.absNorm by positivity) (-(4/25:ℝ))) + (fun j (_:j∈Finset.univ)=>annular_rpow c d (Y j) ((P j).val.val.absNorm:ℝ) (-(4/25:ℝ)) hc hd (hY0 j) + ((le_div_iff₀ (hY0 j)).mp (hWS j (hp j).2).1) + ((div_le_iff₀ (hY0 j)).mp (hWS j (hp j).2).2)) + norm_num only [hz,show (17/50:ℝ)-1/2=-(4/25:ℝ) by norm_num] at ⊢ + simpa only [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_fin] using hh + have hEbound : (812*B)^k*A^k≤E := by + rw [←mul_pow] + exact (pow_le_pow_left₀ (by positivity) (le_max_right 1 (812*B*A)) k).trans + (pow_le_pow_right₀ (le_max_left 1 _) hk) + calc + _ ≤ C*(812*B)^k*R*∏j,((P j).val.val.absNorm:ℝ)^(z.re-1/2) := hb + _ ≤ C*(812*B)^k*R*(A^k*∏j,(Y j)^(-(4/25:ℝ))) := + mul_le_mul_of_nonneg_left hpow (by positivity) + _ = C*((812*B)^k*A^k)*R*∏j,(Y j)^(-(4/25:ℝ)) := by ring + _ ≤ _ := by gcongr + rw [sum_products_restrict η u T hs W Y x w z,Finset.mul_sum] + have hh := Finset.sum_le_sum hterm + simp only [Finset.sum_const,nsmul_eq_mul] at hh + apply hh.trans + calc + _ ≤ (D*((Ideal.span {u.val}:Ideal O).absNorm:ℝ)^eps)*(C*E*R*∏j,(Y j)^(-(4/25:ℝ))) := + mul_le_mul_of_nonneg_right (hcount k hk u T W Y) (by positivity) + _ = _ := by dsimp [R];ring +end SevenEighths.ProbeCentralRepeatedSum + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CoefficientDirect.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CoefficientDirect.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ca8df3353d80d42337f85a8ceaa722e08714c68 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CoefficientDirect.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Detector.SourceCoefficient +import OAI.NumberTheory.DirichletL.Detector.FrequencySupport + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve ProbeRow ProbePhase +local notation "O" => ActualEisensteinCubic.O + +def calibratedHighCoefficient (C : CalibrationData) (η : HeckeFamily.Character) + (I : Ideal O) (hI : primaryGenerator I≠0) (A s : O) (hA : A≠0) (H : O) : ℂ := + actualCongruenceCoefficient C A s hA H * idealRowHom C.generator (Ideal.span {s}) / + ((Real.sqrt (elementNorm C.generator):ℂ)*C.tau*C.residueMonoid s) * + gaussTwo I hI * star (FiniteGaussPhase.angularFactor A * ProbePhase.G A) * + targetMonoid η A * (C.Xi A)⁻¹ * reciprocitySign A s + +lemma div_mul_frequency_cancel (a b c m : ℂ) (hc : c≠0) : + c*(a/(b*c)*m)=a/b*m := by + simp only [div_eq_mul_inv,mul_inv_rev] + calc + _ = (c*c⁻¹)*(a*b⁻¹*m) := by ring + _ = _ := by rw [mul_inv_cancel₀ hc,one_mul] + +theorem calibratedHighCoefficient_eq_bare (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) + (η : HeckeFamily.Character) (I : Ideal O) (hI : primaryGenerator I≠0) + (A s : O) (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (H : O) : + calibratedHighCoefficient (calibrationForSet S hS) η I hI A s (supportedElement_ne_zero A hA) H= + star ((calibrationForSet S hS).residueMonoid H)* + bareSourceCoefficient η I hI A s (supportedElement_ne_zero A hA) H := by + let C := calibrationForSet S hS + by_cases hH : IsCoprime C.generator H + · have hn : star (C.residueMonoid H)≠0 := by + apply star_ne_zero.mpr + exact C.residue.apply_ne_zero_iff.mpr ((CubicEisenstein.isUnit_quotient_span_iff C.generator H).mpr hH) + have he := sourceHighCoefficient_eq_bare S hS η I hI A s hA hs hcop H 1 (by simpa using hH) + simp only [one_pow,mul_one] at he + rw [←he] + unfold sourceHighCoefficient calibratedHighCoefficient + simp only [one_pow,mul_one] + symm + convert div_mul_frequency_cancel + (actualCongruenceCoefficient C A s (supportedElement_ne_zero A hA) H * idealRowHom C.generator (Ideal.span {s})) + ((Real.sqrt (elementNorm C.generator):ℂ)*C.tau*C.residueMonoid s) + (star (C.residueMonoid H)) + (gaussTwo I hI*star (FiniteGaussPhase.angularFactor A*ProbePhase.G A)*targetMonoid η A*(C.Xi A)⁻¹*reciprocitySign A s) + hn using 1 <;> dsimp only [C] <;> ring + · have hz := actualCongruenceCoefficient_zero_off_calibration S hS A s + (supportedElement_ne_zero A hA) (supportedElement_ne_zero s hs) hcop H hH + have hξ : C.residueMonoid H=0 := by + change C.residue (Ideal.Quotient.mk _ H)=0 + apply MulChar.map_nonunit + exact fun h=>hH ((CubicEisenstein.isUnit_quotient_span_iff _ _).mp h) + dsimp only [C] at hξ + simp only [calibratedHighCoefficient,hz,zero_mul,zero_div,hξ,star_zero] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CompensatedRows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CompensatedRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ced553ae9581c554c1d7915ec99d7dacee94819 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CompensatedRows.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialRows +import OAI.NumberTheory.DirichletL.Detector.TupleKernel + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary HeckeInverseAmplification +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : MeasurableSpace FreeRow := ⊤ +local instance : MeasurableSingletonClass FreeRow := ⟨fun _=>trivial⟩ + +def compensatedRowOnLines {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (p : Fin K→O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) + (u : NonzeroFrequency) (t : HeightSpace) : ℂ := + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + (∏i,(elementNorm (p i):ℂ)^(((2:ℂ)+t.1.2*Complex.I)-1))* + (star (C.residueMonoid u.val)*frequencyWeight ((2:ℂ)+t.1.2*Complex.I) u* + indexedCompensatedHigh η S p u.val ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)) + +lemma compensatedRows_counting_product_integrable {ρ : Type*} [Countable ρ] + [MeasurableSpace ρ] [MeasurableSingletonClass ρ] + (e : ρ→NonzeroFrequency) (he : Function.Injective e) + {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) + (p : Fin K→O) (hp : ∀i,p i≠0) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0compensatedRowOnLines η S C p W0 W1 X Y Z (e q.1) q.2) + ((Measure.count:Measure ρ).prod heightMeasure) := by + let F : Finset (Fin K)→ρ×HeightSpace→ℂ := fun J q=>tuplePhysicalScalar η p J* + (highRowOnLines η S C (Ideal.span {∏i∈Finset.univ\J,p i}) 3 3 2 (e q.1) q.2* + sourceMellinWeight W0 W1 (X/elementNorm (∏i∈J,p i)) (Y/elementNorm (∏i∈J,p i)) + (Z*elementNorm (∏i∈Finset.univ\J,p i)) + ((3:ℂ)+q.2.1.1*Complex.I) ((3:ℂ)+q.2.2*Complex.I) ((2:ℂ)+q.2.1.2*Complex.I)) + have hF (J : Finset (Fin K)) : Integrable (F J) ((Measure.count:Measure ρ).prod heightMeasure) := by + apply Integrable.const_mul + apply highRows_counting_product_integrable e he η S C _ 3 3 2 (by norm_num) (by norm_num) (by norm_num) + (fun t : HeightSpace=>sourceMellinWeight W0 W1 (X/elementNorm (∏i∈J,p i)) + (Y/elementNorm (∏i∈J,p i)) (Z*elementNorm (∏i∈Finset.univ\J,p i)) + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)) + · exact sourceMellinWeight_initial_integrable W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + _ _ _ (div_pos hX (tuple_norm_pos p hp J)) (div_pos hY (tuple_norm_pos p hp J)) + (mul_pos hZ (tuple_norm_pos p hp (Finset.univ\J))) 3 2 3 (by norm_num) + · exact sourceMellinWeight_initial_continuous W0 W1 a1 b1 ha1 hW1 + _ _ _ (div_pos hX (tuple_norm_pos p hp J)) (div_pos hY (tuple_norm_pos p hp J)) + (mul_pos hZ (tuple_norm_pos p hp (Finset.univ\J))) 3 2 3 (by norm_num) + have hi := integrable_finsetSum (Finset.univ:Finset (Fin K)).powerset (fun J _=>hF J) + apply hi.congr + apply Filter.Eventually.of_forall + intro q + symm + exact compensatedRow_kernel_subsets η S p hp (e q.1).val + (star (C.residueMonoid (e q.1).val)*frequencyWeight ((2:ℂ)+q.2.1.2*Complex.I) (e q.1)) + W0 W1 X Y Z hX hY hZ _ _ _ + +lemma counting_product_integral_tsum {ρ : Type*} [Countable ρ] + [MeasurableSpace ρ] [MeasurableSingletonClass ρ] + (F : ρ×HeightSpace→ℂ) + (hF : Integrable F ((Measure.count:Measure ρ).prod heightMeasure)) : + (∫t,∑'r,F (r,t) ∂heightMeasure)=∑'r,∫t,F (r,t) ∂heightMeasure := by + calc + _ = ∫t,∫r,F (r,t) ∂(Measure.count:Measure ρ) ∂heightMeasure := by + apply integral_congr_ae + filter_upwards [hF.prod_left_ae] with t ht + exact (integral_count_eq_tsum _ ht).symm + _ = ∫q,F q ∂((Measure.count:Measure ρ).prod heightMeasure) := (integral_prod_symm F hF).symm + _ = _ := by rw [integral_prod F hF,integral_count_eq_tsum _ hF.integral_prod_left] + +theorem compensatedRowTripleIntegral_eq_tsum {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (C : CalibrationData) (p : Fin K→O) (hp : ∀i,p i≠0) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0⟨u.val,u.property.1⟩ + have he : Function.Injective e := fun a b h=>Subtype.ext (congrArg (fun u : NonzeroFrequency=>u.val) h) + have hi := compensatedRows_counting_product_integrable e he η S C p hp W0 W1 + a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ + unfold compensatedRowTripleIntegral compensatedRowSeries + rw [tsum_mul_left] + congr 1 + rw [←counting_product_integral_tsum _ hi] + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp only + simp only [compensatedRowOnLines,e,tsum_mul_left,mul_assoc] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CompensatedTriple.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CompensatedTriple.lean new file mode 100644 index 0000000000000000000000000000000000000000..ad290a4ed8aca01f8c6cf684a4b568570f6c3db8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CompensatedTriple.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Detector.TuplePrincipal + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary CanonicalQuadraticSieve HeckeInverseAmplification +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def compensatedRowSeries {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (p : Fin K→O) (x w z : ℂ) : ℂ := + (∏i,(elementNorm (p i):ℂ)^(z-1))* + ∑'u : FreeRow,star (C.residueMonoid u.val)*frequencyWeight z ⟨u.val,u.property.1⟩* + indexedCompensatedHigh η S p u.val x w z + +def compensatedRowTripleIntegral {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (W0 W1 : SchwartzMap ℝ ℂ) (p : Fin K→O) (X Y Z : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3*∫t : HeightSpace, + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + compensatedRowSeries η S C p ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) ∂heightMeasure + +lemma tupleSourceTripleIntegral_eq_rows {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (W0 W1 : SchwartzMap ℝ ℂ) (p : Fin K→O) + (hp : ∀i,p i≠0) (X Y Z : ℝ) : + tupleSourceTripleIntegral η S C W0 W1 p X Y Z= + compensatedRowTripleIntegral η S C W0 W1 p X Y Z := by + unfold tupleSourceTripleIntegral compensatedRowTripleIntegral + congr 1 + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp only + congr 1 + exact tupleSourceSeries_eq_rows η S C p hp + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + +theorem compensatedTuple_eq_row_triple {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (hSne : S.Nonempty) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0(p i).val) X Y Z := by + unfold compensatedPhysicalProbe + apply Finset.sum_congr rfl + intro p _ + rw [compensatedTuple_eq_row_triple η S hS hpS hbad hSne W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + (fun i=>(p i).val) (fun i=>hp i (p i).val (p i).property) X Y Z hX hY hZ] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Compensation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Compensation.lean new file mode 100644 index 0000000000000000000000000000000000000000..93a2332f3e98d307c0e5f09d14f3175ca46ac9e7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Compensation.lean @@ -0,0 +1,45 @@ +import Mathlib.Analysis.Complex.Basic +import Mathlib.Analysis.SpecialFunctions.Pow.Real +import Mathlib.Data.Finset.Powerset +import Mathlib.Tactic.FinCases +import Mathlib.Tactic.Ring + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbeCompensation + +def tupleOperation {α : Type*} [CommMonoid α] {K : ℕ} + (p : Fin K → α) (q : α → ℝ) (η : α → ℂ) + (F : α → ℝ → ℝ → ℝ → ℂ) (X Y Z : ℝ) : ℂ := + ∑ J ∈ (Finset.univ : Finset (Fin K)).powerset, + (-1 : ℂ) ^ J.card * ((q (∏ i ∈ J, p i) ^ (-(3 / 2 : ℝ)) : ℝ) : ℂ) * + star (η (∏ i ∈ Finset.univ \ J, p i)) * + F (∏ i ∈ Finset.univ \ J, p i) + (X / q (∏ i ∈ J, p i)) (Y / q (∏ i ∈ J, p i)) + (Z * q (∏ i ∈ Finset.univ \ J, p i)) + +theorem tupleOperation_zero {α : Type*} [CommMonoid α] + (p : Fin 0 → α) (q : α → ℝ) (η : α → ℂ) + (hq : q 1 = 1) (hη : η 1 = 1) + (F : α → ℝ → ℝ → ℝ → ℂ) (X Y Z : ℝ) : + tupleOperation p q η F X Y Z = F 1 X Y Z := by + simp [tupleOperation, hq, hη] + +theorem tupleOperation_one {α : Type*} [CommMonoid α] + (p : Fin 1 → α) (q : α → ℝ) (η : α → ℂ) + (hq : q 1 = 1) (hη : η 1 = 1) + (F : α → ℝ → ℝ → ℝ → ℂ) (X Y Z : ℝ) : + tupleOperation p q η F X Y Z = + star (η (p 0)) * F (p 0) X Y (Z * q (p 0)) - + ((q (p 0) ^ (-(3 / 2 : ℝ)) : ℝ) : ℂ) * F 1 (X / q (p 0)) (Y / q (p 0)) Z := by + have hp : (Finset.univ : Finset (Fin 1)).powerset = {∅, {0}} := by decide + simp only [tupleOperation, hp] + simp [hq, hη] + ring + +end SevenEighths.ProbeCompensation +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CompensationActual.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CompensationActual.lean new file mode 100644 index 0000000000000000000000000000000000000000..ea68f9c5df76fb8131a14544e50952fa36b0876a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CompensationActual.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Detector.SpectralCompensation + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ProbeEuler ProbeLocal +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma initialPrime_denominators (η : HeckeFamily.Character) (P : PrimeIdeal) (x w z : ℂ) + (hx : 0 ActualEisensteinCubic.O + +def completedIndex (I J : Ideal O) : O := primaryGenerator I * primaryGenerator J ^ 3 + +def completedMask (S : Finset (Ideal O)) (D I J : Ideal O) : ℂ := + if D ∣ I * J ^ 3 ∧ ∀ p ∈ S, ¬p ∣ I * J ^ 3 then 1 else 0 + +def completedCorrection (I J : Ideal O) : ℂ := + rayMask (completedIndex I J) * + star (fixedGQuotientValue + (Ideal.Quotient.mk (Ideal.span {(4 : O)}) (completedIndex I J))) + +theorem completedCorrection_eq_phase (I J : Ideal O) : + completedCorrection I J = rayMask (completedIndex I J) * + star (ProbePhase.G (completedIndex I J)) := rfl + +theorem completedMask_norm_le_one (S : Finset (Ideal O)) (D I J : Ideal O) : + ‖completedMask S D I J‖ ≤ 1 := by + unfold completedMask + split_ifs <;> norm_num + +theorem completedCorrection_norm_le_two (I J : Ideal O) : + ‖completedCorrection I J‖ ≤ 2 := by + have hm : ‖rayMask (completedIndex I J)‖ ≤ 1 := by + unfold rayMask + split_ifs <;> norm_num + unfold completedCorrection + rw [norm_mul, norm_star] + exact (mul_le_mul hm (fixedGQuotientValue_norm_le_two _) (norm_nonneg _) (by norm_num)).trans_eq + (by norm_num) + +def markedSummand (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (W : ℝ → ℂ) (X : ℝ) (I J : Ideal O) : ℂ := + completedMask S D I J * summand Ψ W X I J + +def correctedSummand (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (W : ℝ → ℂ) (X : ℝ) (I J : Ideal O) : ℂ := + completedCorrection I J * markedSummand S D Ψ W X I J + +def markedCompletedT (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (W : ℝ → ℂ) (X : ℝ) : ℂ := + ∑' p : Ideal O × Ideal O, markedSummand S D Ψ W X p.1 p.2 + +def correctedCompletedT (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (W : ℝ → ℂ) (X : ℝ) : ℂ := + ∑' p : Ideal O × Ideal O, correctedSummand S D Ψ W X p.1 p.2 + +def correctionCoeff (χ : RayCharacter) : ℂ := + phaseCoeff (fun r => star (fixedGQuotientValue r)) χ + +theorem correctionCoeff_sum_norm_le : + (∑ χ : RayCharacter, ‖correctionCoeff χ‖) ≤ 32 := by + have h := phaseCoeff_sum_norm_le (fun r => star (fixedGQuotientValue r)) 2 + (fun u => by simpa only [norm_star] using fixedGQuotientValue_norm_le_two (u : RayRing)) + simpa only [correctionCoeff] using h.trans_eq (by norm_num : (16 : ℝ) * 2 = 32) + +theorem completedIndex_eq_primaryGenerator (I J : Ideal O) : + completedIndex I J = primaryGenerator (I * J ^ 3) := by + simp only [completedIndex, primaryGenerator_mul, CubicEisenstein.primaryGenerator_pow] + +theorem completedMask_zero_of_excluded (S : Finset (Ideal O)) (D I J p : Ideal O) + (hp : p ∈ S) (hpdiv : p ∣ I * J ^ 3) : completedMask S D I J = 0 := by + unfold completedMask + rw [ite_eq_right] + intro h + exact h.2 p hp hpdiv + +theorem completedMask_zero_of_not_marked (S : Finset (Ideal O)) (D I J : Ideal O) + (hD : ¬D ∣ I * J ^ 3) : completedMask S D I J = 0 := by + simp [completedMask, hD] + +theorem completedCorrection_expansion (I J : Ideal O) : + completedCorrection I J = + ∑ χ : RayCharacter, correctionCoeff χ * rayCharacter χ (completedIndex I J) := by + exact phase_expansion (fun r => star (fixedGQuotientValue r)) (completedIndex I J) + +theorem correctedSummand_ray_expansion (S : Finset (Ideal O)) (D I J : Ideal O) + (Ψ : O →* ℂ) (W : ℝ → ℂ) (X : ℝ) : + correctedSummand S D Ψ W X I J = + ∑ χ : RayCharacter, correctionCoeff χ * + markedSummand S D (rayMonoid χ * Ψ) W X I J := by + unfold correctedSummand + rw [completedCorrection_expansion, Finset.sum_mul] + apply Finset.sum_congr rfl + intro χ _ + unfold markedSummand + rw [CanonicalRowCompletion.summand_mul_fixed_twist] + simp only [rayMonoid_apply, completedIndex] + ring + +theorem markedSummand_summable (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) : + Summable (fun p : Ideal O × Ideal O => markedSummand S D Ψ W X p.1 p.2) := by + apply summable_of_hasFiniteSupport + apply (completedT_finite_support Ψ W hW X hX).subset + intro p hp + exact fun hz => hp (by simp only [markedSummand, hz, mul_zero]) + +theorem correctedSummand_summable (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) : + Summable (fun p : Ideal O × Ideal O => correctedSummand S D Ψ W X p.1 p.2) := by + apply summable_of_hasFiniteSupport + apply (completedT_finite_support Ψ W hW X hX).subset + intro p hp + exact fun hz => hp (by simp only [correctedSummand, markedSummand, hz, mul_zero]) + +theorem correctedCompletedT_ray_expansion (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) : + correctedCompletedT S D Ψ W X = + ∑ χ : RayCharacter, correctionCoeff χ * + markedCompletedT S D (rayMonoid χ * Ψ) W X := by + unfold correctedCompletedT + simp_rw [correctedSummand_ray_expansion] + rw [Summable.tsum_finsetSum (fun χ _ => + (markedSummand_summable S D (rayMonoid χ * Ψ) W hW X hX).mul_left (correctionCoeff χ))] + simp only [tsum_mul_left, markedCompletedT] + +theorem correctedCompletedT_norm_le (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (W : ℝ → ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 < X) + {B : ℝ} (hB : 0 ≤ B) + (hbound : ∀ χ : RayCharacter, ‖markedCompletedT S D (rayMonoid χ * Ψ) W X‖ ≤ B) : + ‖correctedCompletedT S D Ψ W X‖ ≤ 32 * B := by + rw [correctedCompletedT_ray_expansion S D Ψ W hW X hX] + calc + _ ≤ ∑ χ : RayCharacter, ‖correctionCoeff χ * + markedCompletedT S D (rayMonoid χ * Ψ) W X‖ := norm_sum_le _ _ + _ ≤ ∑ χ : RayCharacter, ‖correctionCoeff χ‖ * B := by + apply Finset.sum_le_sum + intro χ _ + rw [norm_mul] + exact mul_le_mul_of_nonneg_left (hbound χ) (norm_nonneg _) + _ = (∑ χ : RayCharacter, ‖correctionCoeff χ‖) * B := (Finset.sum_mul ..).symm + _ ≤ 32 * B := mul_le_mul_of_nonneg_right correctionCoeff_sum_norm_le hB + +end SevenEighths.ProbeCompleted +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CompletedCRTPhase.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CompletedCRTPhase.lean new file mode 100644 index 0000000000000000000000000000000000000000..4b5fddd026c3af49ac616753fcdf20dfd6f5c8df --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CompletedCRTPhase.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Detector.PairPhase + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhase +open ActualEisensteinCubic ActualEisensteinCoordinates CompletedGauss CubicEisenstein +open CanonicalRowCompletion CanonicalQuadraticSieve ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +lemma reciprocitySign_star (a b : O) : star (reciprocitySign a b)=reciprocitySign a b := by + simp only [reciprocitySign, star_intCast] + +theorem completed_cubic_pair_cancel (p q : O) (hp : Prime p) (hq : Prime q) + (hprimaryP : goodLambda^2∣p-1) (hprimaryQ : goodLambda^2∣q-1) + (hsP : Supported (Ideal.span {p})) (hsQ : Supported (Ideal.span {q})) + (hcop : IsCoprime (Ideal.span {p} : Ideal O) (Ideal.span {q})) + (e f l k : ℕ) : + sexticPair p q ^ ((e+3*l)*(f+3*k)) * sexticPair p q ^ (2*e*f) * + star (reciprocitySign (p^(e+3*l)) (q^(f+3*k))) = 1 := by + have hpodd := supported_residue_odd p hsP + have hqodd := supported_residue_odd q hsQ + have h3 := sexticPair_cube p q hp hq hprimaryP hprimaryQ hsP hsQ hcop + have h2 := reciprocitySign_sq p q hpodd hqodd + rw [reciprocitySign_star, reciprocitySign_pow_left p _ (odd_residue_pow q hqodd _) _, + reciprocitySign_pow_right p q hpodd, ← pow_mul, ← pow_add] + have hexp : (e+3*l)*(f+3*k)+2*e*f = 3*(e*f+e*k+f*l+3*l*k) := by ring + rw [hexp, pow_mul, h3, ← pow_add] + have hsum : e*f+e*k+f*l+3*l*k+(f+3*k)*(e+3*l) = + 2*(e*f+2*e*k+2*f*l+6*l*k) := by ring + rw [hsum, pow_mul, h2, one_pow] + +lemma sexticPair_mul_left (a b c : O) : + sexticPair (a*b) c = sexticPair a c * sexticPair b c := by + simp only [sexticPair, ← Ideal.span_singleton_mul_span_singleton, map_mul, + idealRowHom_argument_mul] + ring + +lemma sexticPair_mul_right (a b c : O) : + sexticPair a (b*c) = sexticPair a b * sexticPair a c := by + simp only [sexticPair, ← Ideal.span_singleton_mul_span_singleton, map_mul, + idealRowHom_argument_mul] + ring + +lemma sexticPair_cube_left (a b : O) : sexticPair (a^3) b=sexticPair a b^3 := by + rw [show a^3=a*a*a by ring, sexticPair_mul_left, sexticPair_mul_left] + ring + +lemma sexticPair_cube_right (a b : O) : sexticPair a (b^3)=sexticPair a b^3 := by + rw [show b^3=b*b*b by ring, sexticPair_mul_right, sexticPair_mul_right] + ring + +theorem sexticPair_cube_supported (a b : O) + (ha : Supported (Ideal.span {a})) (hb : Supported (Ideal.span {b})) + (hpa : goodLambda^2∣a-1) (hpb : goodLambda^2∣b-1) (hcop : IsCoprime a b) : + sexticPair a b^3 = reciprocitySign a b := by + have hr : idealRowHom b (Ideal.span {a}) = + reciprocitySign a b * idealRowHom a (Ideal.span {b}) := + idealRowHom_primary_reciprocity a b hpa hpb ha hb + have hc : IsCoprime (Ideal.span {b}:Ideal O) (Ideal.span {a}) := by + exact (Ideal.isCoprime_span_singleton_iff b a).mpr hcop.symm + have h6 := idealRowHom_sixth_mask a (Ideal.span {b}) hb + rw [idealRowHom_argument_pow _ _ _ hb, ite_eq_left hc] at h6 + have h2 := reciprocitySign_sq a b (supported_residue_odd a ha) (supported_residue_odd b hb) + calc + _ = reciprocitySign a b^3 * idealRowHom a (Ideal.span {b})^6 := by + unfold sexticPair + rw [hr] + ring + _ = _ := by rw [h6,mul_one,pow_succ,h2,one_mul] + +theorem completed_cubic_cross_cancel (c n d m : O) + (hc : Supported (Ideal.span {c})) (hn : Supported (Ideal.span {n})) + (hd : Supported (Ideal.span {d})) (hm : Supported (Ideal.span {m})) + (hpc : goodLambda^2∣c-1) (hpn : goodLambda^2∣n-1) + (hpd : goodLambda^2∣d-1) (hpm : goodLambda^2∣m-1) + (hcd : IsCoprime c d) (hcm : IsCoprime c m) + (hnd : IsCoprime n d) (hnm : IsCoprime n m) : + sexticPair (c*n^3) (d*m^3) * sexticPair c d^2 * + star (reciprocitySign (c*n^3) (d*m^3)) = 1 := by + have hcd3 := sexticPair_cube_supported c d hc hd hpc hpd hcd + have hcm3 := sexticPair_cube_supported c m hc hm hpc hpm hcm + have hnd3 := sexticPair_cube_supported n d hn hd hpn hpd hnd + have hnm3 := sexticPair_cube_supported n m hn hm hpn hpm hnm + have hRnm := reciprocitySign_sq n m (supported_residue_odd n hn) (supported_residue_odd m hm) + have he : sexticPair (c*n^3) (d*m^3)*sexticPair c d^2 = + reciprocitySign (c*n^3) (d*m^3) := by + calc + _ = sexticPair c d^3 * sexticPair c m^3 * sexticPair n d^3 * + (sexticPair n m^3)^3 := by + rw [sexticPair_mul_left, sexticPair_mul_right, sexticPair_mul_right, + sexticPair_cube_left, sexticPair_cube_left, sexticPair_cube_right, + sexticPair_cube_right] + ring + _ = reciprocitySign c d * reciprocitySign c m * reciprocitySign n d * reciprocitySign n m := by + rw [hcd3,hcm3,hnd3,hnm3,pow_succ,hRnm,one_mul] + _ = _ := by + rw [reciprocitySign_mul_left, reciprocitySign_mul_right, reciprocitySign_mul_right, + reciprocitySign_cube_right c m (supported_residue_odd c hc) (supported_residue_odd m hm), + reciprocitySign_symm (n^3) d, + reciprocitySign_cube_right d n (supported_residue_odd d hd) (supported_residue_odd n hn), + reciprocitySign_symm d n, + reciprocitySign_cube_right (n^3) m (odd_residue_pow n (supported_residue_odd n hn) 3) + (supported_residue_odd m hm), reciprocitySign_symm (n^3) m, + reciprocitySign_cube_right m n (supported_residue_odd m hm) (supported_residue_odd n hn), + reciprocitySign_symm m n] + ring + rw [he,reciprocitySign_star,←pow_two] + exact reciprocitySign_sq _ _ + (by simpa only [ActualEisensteinCoordinates.residue_mul] using + (EisensteinEPrimaryPhase.odd_mul _ _ (supported_residue_odd c hc) + (odd_residue_pow n (supported_residue_odd n hn) 3))) + (by simpa only [ActualEisensteinCoordinates.residue_mul] using + (EisensteinEPrimaryPhase.odd_mul _ _ (supported_residue_odd d hd) + (odd_residue_pow m (supported_residue_odd m hm) 3))) + +end SevenEighths.ProbePhase +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CompletedCoefficient.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CompletedCoefficient.lean new file mode 100644 index 0000000000000000000000000000000000000000..e63c978ba5a69d0de062f4360002362bafe51f76 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CompletedCoefficient.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Detector.ReciprocityCRT +import OAI.NumberTheory.DirichletL.Detector.CubicGaussCRT +import OAI.NumberTheory.DirichletL.Detector.CompletedCRTPhase + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ConcretePrimeRowBridge CubicEisenstein ProbePhase +local notation "O" => ActualEisensteinCubic.O + +lemma supported_completed (c n : O) (hc : Supported (Ideal.span {c})) + (hn : Supported (Ideal.span {n})) : Supported (Ideal.span {c*n^3}) := by + rw [← Ideal.span_singleton_mul_span_singleton, ← Ideal.span_singleton_pow] + apply (supported_mul_iff _ _).mpr + refine ⟨hc,?_⟩ + have hn2 := (supported_mul_iff _ _).mpr ⟨hn,hn⟩ + have hn3 := (supported_mul_iff _ _).mpr ⟨hn2,hn⟩ + simpa only [pow_succ, pow_zero, one_mul] using hn3 + +lemma primary_completed (c n : O) (hc : goodLambda^2∣c-1) + (hn : goodLambda^2∣n-1) : goodLambda^2∣c*n^3-1 := by + have h := dvd_add (dvd_mul_of_dvd_left hc (n^3)) + (dvd_mul_of_dvd_left hn (n^2+n+1)) + convert h using 1 ; ring + +def correctedFiniteCoefficient (I : Ideal O) (hI : primaryGenerator I≠0) + (A s : O) (hA : A≠0) (H : O) : ℂ := + gaussTwo I hI * star (G A) * reciprocityCoefficient A s hA H + +theorem correctedFiniteCoefficient_product (I J : Ideal O) + (hI : CubicSieve.Admissible I) (hJ : CubicSieve.Admissible J) + (hIJ : CubicSieve.Admissible (I*J)) (hIJcop : IsCoprime I J) + (n m s r : O) + (hc : Supported (Ideal.span {primaryGenerator I})) (hd : Supported (Ideal.span {primaryGenerator J})) + (hn : Supported (Ideal.span {n})) (hm : Supported (Ideal.span {m})) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hpc : goodLambda^2∣primaryGenerator I-1) (hpd : goodLambda^2∣primaryGenerator J-1) + (hpn : goodLambda^2∣n-1) (hpm : goodLambda^2∣m-1) + (hps : goodLambda^2∣s-1) (hpr : goodLambda^2∣r-1) + (hcop : IsCoprime ((primaryGenerator I*n^3)*s) ((primaryGenerator J*m^3)*r)) (H : O) : + let A := primaryGenerator I*n^3 + let B := primaryGenerator J*m^3 + let hA := supportedElement_ne_zero A (supported_completed _ _ hc hn) + let hB := supportedElement_ne_zero B (supported_completed _ _ hd hm) + correctedFiniteCoefficient (I*J) hIJ.2 (A*B) (s*r) (mul_ne_zero hA hB) H = + correctedFiniteCoefficient I hI.2 A s hA H * correctedFiniteCoefficient J hJ.2 B r hB H := by + dsimp only + let c := primaryGenerator I + let d := primaryGenerator J + let A := c*n^3 + let B := d*m^3 + have hAs := supported_completed c n hc hn + have hBs := supported_completed d m hd hm + have hAB : IsCoprime A B := hcop.of_mul_left_left.of_mul_right_left + have hnA : n∣A := by refine ⟨c*n^2,?_⟩; dsimp only [A]; ring + have hmB : m∣B := by refine ⟨d*m^2,?_⟩; dsimp only [B]; ring + have hcA : c∣A := dvd_mul_right c (n^3) + have hdB : d∣B := dvd_mul_right d (m^3) + have hcd : IsCoprime c d := (hAB.of_isCoprime_of_dvd_left hcA).of_isCoprime_of_dvd_right hdB + have hcm : IsCoprime c m := (hAB.of_isCoprime_of_dvd_left hcA).of_isCoprime_of_dvd_right hmB + have hnd : IsCoprime n d := (hAB.of_isCoprime_of_dvd_left hnA).of_isCoprime_of_dvd_right hdB + have hnm : IsCoprime n m := (hAB.of_isCoprime_of_dvd_left hnA).of_isCoprime_of_dvd_right hmB + have hphase := completed_cubic_cross_cancel c n d m hc hn hd hm hpc hpn hpd hpm hcd hcm hnd hnm + change sexticPair A B * sexticPair c d^2 * star (reciprocitySign A B)=1 at hphase + change gaussTwo (I*J) hIJ.2 * star (G (A*B)) * + reciprocityCoefficient (A*B) (s*r) _ H = + (gaussTwo I hI.2 * star (G A) * reciprocityCoefficient A s _ H) * + (gaussTwo J hJ.2 * star (G B) * reciprocityCoefficient B r _ H) + rw [gaussTwo_coprime_product_sextic I J hI hJ hIJ hIJcop, + G_mul A B (supported_residue_odd A hAs) (supported_residue_odd B hBs), + reciprocityCoefficient_product A B s r hAs hBs hs hr + (primary_completed c n hpc hpn) (primary_completed d m hpd hpm) hps hpr hcop H] + simp only [star_mul] + change (sexticPair c d^2 * gaussTwo I hI.2 * gaussTwo J hJ.2) * + (star (reciprocitySign A B)*(star (G B)*star (G A))) * + (sexticPair A B * reciprocityCoefficient A s _ H * reciprocityCoefficient B r _ H) = _ + calc + _ = (sexticPair A B * sexticPair c d^2 * star (reciprocitySign A B)) * + ((gaussTwo I hI.2 * star (G A) * reciprocityCoefficient A s _ H) * + (gaussTwo J hJ.2 * star (G B) * reciprocityCoefficient B r _ H)) := by ring + _ = _ := by rw [hphase,one_mul] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CongruenceScalar.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CongruenceScalar.lean new file mode 100644 index 0000000000000000000000000000000000000000..c34e088898f160c923843467aaefb24f46326ba2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CongruenceScalar.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Detector.Sextic + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CubicEisenstein GaussianShiftedPartition +local notation "O" => ActualEisensteinCubic.O + +def exactQuotient (a b : O) (h : b ∣ a) : O := Classical.choose h + +lemma exactQuotient_spec (a b : O) (h : b ∣ a) : a = b * exactQuotient a b h := + Classical.choose_spec h + +lemma exactQuotient_eq (a b c : O) (h : b ∣ a) (hb : b ≠ 0) (he : a = b*c) : + exactQuotient a b h = c := by + apply mul_left_cancel₀ hb + exact (exactQuotient_spec a b h).symm.trans he + +def positiveScalar (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n k j : ℕ) : ℂ := + if k = 0 then primePowerGauss p hp (χ^(n+1)) n (p^j) + else ∑' d : O ⧸ Ideal.span {p^k}, + if h : p^k ∣ p^j-p^(n+1)*representative (p^k) d then + (χ^k) (Ideal.Quotient.mk (Ideal.span {p}) (representative (p^k) d)) * + primePowerGauss p hp (χ^(n+1)) n + (exactQuotient (p^j-p^(n+1)*representative (p^k) d) (p^k) h) + else 0 + +@[simp] theorem positiveScalar_kzero (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n j : ℕ) : + positiveScalar p hp χ n 0 j = primePowerGauss p hp (χ^(n+1)) n (p^j) := by + simp only [positiveScalar, ite_true] + +theorem positiveScalar_kone_jzero (p : O) (hp : Prime p) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) : + positiveScalar p hp.ne_zero χ n 1 0 = 0 := by + simp only [positiveScalar, Nat.one_ne_zero, ite_false] + rw [pow_one] + simp only [pow_zero, pow_one] + refine (tsum_congr (g := fun _ => (0:ℂ)) ?_).trans tsum_zero + intro d + rw [dite_eq_right] + intro hd + have hd2 : p ∣ p^(n+1)*representative p d := + (dvd_pow_self p (by omega : n+1 ≠ 0)).mul_right _ + have hunit : p ∣ (1:O) := by + have := dvd_add hd hd2 + simpa only [sub_add_cancel] using this + exact hp.not_isUnit (isUnit_iff_dvd_one.mpr hunit) + +theorem positiveScalar_kone_convolution (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n j : ℕ) : + positiveScalar p hp χ n 1 (j+1) = scalarKOne p hp χ (χ^(n+1)) n (p^j) := by + simp only [positiveScalar, Nat.one_ne_zero, ite_false, scalarKOne] + rw [pow_one] + simp only [pow_one] + apply tsum_congr + intro d + have he : p^(j+1)-p^(n+1)*representative p d = p*(p^j-p^n*representative p d) := by + simp only [pow_succ] + ring + have hd : p ∣ p^(j+1)-p^(n+1)*representative p d := ⟨_,he⟩ + rw [dite_eq_left hd, exactQuotient_eq _ _ _ hd hp he, representative_spec] + +theorem positiveScalar_kone (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n j : ℕ) : + positiveScalar p hp χ n 1 (j+1) = + χ⁻¹ (-1) * primeGauss p hp χ 1 * primePowerGauss p hp (χ^n) n (p^j) := by + rw [positiveScalar_kone_convolution, scalarKOne_eq] + have he : χ^(n+1)*χ⁻¹ = χ^n := by rw [pow_succ, mul_assoc, mul_inv_cancel, mul_one] + rw [he] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/ContourShear.lean b/lean/OAI/NumberTheory/DirichletL/Detector/ContourShear.lean new file mode 100644 index 0000000000000000000000000000000000000000..8453f31b6d4d3360971294aa18f85f1b9a7f3bb9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/ContourShear.lean @@ -0,0 +1,51 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialFubini + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary + +def sourceHeightShear : HeightSpace ≃ᵐ HeightSpace where + toFun p := ((p.1.1+p.1.2,p.1.2),p.2) + invFun p := ((p.1.1-p.1.2,p.1.2),p.2) + left_inv p := by rcases p with ⟨⟨t,v⟩,w⟩;simp + right_inv p := by rcases p with ⟨⟨t,v⟩,w⟩;simp + measurable_toFun := by + change Measurable (fun p : HeightSpace=>((p.1.1+p.1.2,p.1.2),p.2)) + fun_prop + measurable_invFun := by + change Measurable (fun p : HeightSpace=>((p.1.1-p.1.2,p.1.2),p.2)) + fun_prop + +lemma sourceHeightShear_preserving : MeasurePreserving sourceHeightShear heightMeasure heightMeasure := by + exact (measurePreserving_add_prod (volume:Measure ℝ) volume).prod (MeasurePreserving.id volume) + +lemma sourceHeightShear_integral (F : HeightSpace→ℂ) : + (∫p,F (sourceHeightShear p) ∂heightMeasure)=∫p,F p ∂heightMeasure := + sourceHeightShear_preserving.integral_comp' F + +theorem source_contour_shear (F : ℂ→ℂ→ℂ→ℂ) (σ ξ υ : ℝ) : + (∫p : HeightSpace,F (((σ:ℂ)+p.1.1*Complex.I)+((ξ:ℂ)+p.1.2*Complex.I)-1) + ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I) ∂heightMeasure)= + ∫p : HeightSpace,F (((σ+ξ-1:ℝ):ℂ)+p.1.1*Complex.I) + ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I) ∂heightMeasure := by + have hh := sourceHeightShear_integral (fun p : HeightSpace=>F + (((σ+ξ-1:ℝ):ℂ)+p.1.1*Complex.I) ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I)) + convert hh using 1 + congr 1 + funext p + dsimp only [sourceHeightShear,MeasurableEquiv.coe_mk,Equiv.coe_fn_mk] + congr 2 ; push_cast ; ring + +lemma sourceMellinWeight_shear (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (t w z : ℂ) : + sourceMellinWeight W0 W1 X Y Z (t+1-z) w z= + (X:ℂ)^(1/2-z)*(Z:ℂ)^t*(Y:ℂ)^(w-1)*Complex.exp (t^2)* + mellin (EisensteinSchwartzPoisson.paperRadialFourier W0) z*mellin W1 w := by + simp only [sourceMellinWeight,show t+1-z+z-1=t by ring] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CorrectionBounds.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CorrectionBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..804835e23e577c2ae030ed8ce7efa72fb53ea11b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CorrectionBounds.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Detector.Euler +import OAI.NumberTheory.DirichletL.Detector.Local +import Mathlib.Analysis.SpecialFunctions.Pow.Deriv +import Mathlib.Analysis.Complex.LocallyUniformLimit + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeLocal + +lemma one_sub_ne_zero_of_norm_le_half (a : ℂ) (ha : ‖a‖ ≤ 1/2) : 1 - a ≠ 0 := by + intro h + have : a = 1 := by linear_combination -h + rw [this, norm_one] at ha + norm_num at ha + +lemma inv_one_sub_norm_le_two (a : ℂ) (ha : ‖a‖ ≤ 1/2) : ‖(1-a)⁻¹‖ ≤ 2 := by + have hl := norm_sub_norm_le (1 : ℂ) a + simp only [norm_one] at hl + have hd : 0 < ‖1-a‖ := by linarith + rw [norm_inv, ← one_div, div_le_iff₀ hd] + linarith + +theorem unramified_marked_error_bound (R V qInv K W D : ℂ) + (hR : ‖R‖ ≤ 1/2) (hV : ‖V‖ ≤ 1/2) (hq : ‖qInv‖ ≤ 1) (hD : ‖D‖ ≤ 1/2) : + ‖ProbeEuler.markedFactor R V qInv K (-D + W*R) 1 + D‖ ≤ + 12 * ‖R‖ * (1 + ‖W‖) + 4 * ‖K‖ * ‖V‖ := by + rw [ProbeEuler.unramified_marked_error R V qInv K W D + (one_sub_ne_zero_of_norm_le_half R hR) (one_sub_ne_zero_of_norm_le_half V hV), + div_eq_mul_inv, mul_inv, norm_mul, norm_mul] + have hnum : ‖R*((1-qInv)+(1-V)*(W-D))-K*V‖ ≤ + ‖R‖ * (2 + (1 + ‖V‖) * (‖W‖ + ‖D‖)) + ‖K‖ * ‖V‖ := by + calc + _ ≤ ‖R*((1-qInv)+(1-V)*(W-D))‖ + ‖K*V‖ := norm_sub_le _ _ + _ = ‖R‖ * ‖(1-qInv)+(1-V)*(W-D)‖ + ‖K‖*‖V‖ := by rw [norm_mul, norm_mul] + _ ≤ ‖R‖ * (‖1-qInv‖ + ‖1-V‖*‖W-D‖) + ‖K‖*‖V‖ := by + gcongr + simpa only [norm_mul] using norm_add_le (1-qInv) ((1-V)*(W-D)) + _ ≤ ‖R‖ * (2 + (1+‖V‖)*(‖W‖+‖D‖)) + ‖K‖*‖V‖ := by + gcongr + · calc ‖1-qInv‖ ≤ ‖(1:ℂ)‖+‖qInv‖ := norm_sub_le _ _ + _ ≤ 2 := by simp only [norm_one]; linarith + · simpa only [norm_one] using norm_sub_le (1:ℂ) V + · exact norm_sub_le W D + have hv := inv_one_sub_norm_le_two V hV + have hr := inv_one_sub_norm_le_two R hR + calc + _ ≤ (‖R‖ * (2 + (1 + ‖V‖) * (‖W‖ + ‖D‖)) + ‖K‖ * ‖V‖) * (2*2) := by + gcongr + _ ≤ 12 * ‖R‖ * (1+‖W‖) + 4*‖K‖*‖V‖ := by + have he : 2 + (1+‖V‖)*(‖W‖+‖D‖) ≤ 3*(1+‖W‖) := by + have : (1+‖V‖)*(‖W‖+‖D‖) ≤ (3/2:ℝ)*(‖W‖+1/2) := by gcongr ; linarith + nlinarith [norm_nonneg W] + nlinarith [mul_le_mul_of_nonneg_left he (norm_nonneg R)] + +theorem continuedCorrection_defect_bound (V W D Pstar : ℂ) + (hV : ‖V‖ ≤ 1/2) (hD : ‖D‖ ≤ 1/2) : + ‖continuedCorrection V W D Pstar - 1‖ ≤ + 2 * (‖D‖ * (‖V‖+‖W‖+‖V‖*‖W‖) + ‖V‖*‖W‖ + + 2*(1+‖W‖)*‖Pstar+D‖) := by + rw [continuedCorrection_defect _ _ _ _ (one_sub_ne_zero_of_norm_le_half D hD), + div_eq_mul_inv, norm_mul] + have hA : ‖V+W-V*W‖ ≤ ‖V‖+‖W‖+‖V‖*‖W‖ := by + calc + _ ≤ ‖V+W‖+‖V*W‖ := norm_sub_le _ _ + _ ≤ _ := by rw [norm_mul]; gcongr; exact norm_add_le V W + have hnum : ‖D*(V+W-V*W)-V*W+(1-V)*(1-W)*(Pstar+D)‖ ≤ + ‖D‖*(‖V‖+‖W‖+‖V‖*‖W‖)+‖V‖*‖W‖+2*(1+‖W‖)*‖Pstar+D‖ := by + calc + _ ≤ ‖D*(V+W-V*W)-V*W‖+‖(1-V)*(1-W)*(Pstar+D)‖ := norm_add_le _ _ + _ ≤ ‖D*(V+W-V*W)‖+‖V*W‖+‖(1-V)*(1-W)*(Pstar+D)‖ := by gcongr; exact norm_sub_le _ _ + _ = ‖D‖*‖V+W-V*W‖+‖V‖*‖W‖+‖1-V‖*‖1-W‖*‖Pstar+D‖ := by simp only [norm_mul] + _ ≤ _ := by + gcongr + · calc ‖1-V‖ ≤ 1+‖V‖ := by simpa only [norm_one] using norm_sub_le (1:ℂ) V + _ ≤ 2 := by linarith + · simpa only [norm_one] using norm_sub_le (1:ℂ) W + calc + _ ≤ (‖D‖*(‖V‖+‖W‖+‖V‖*‖W‖)+‖V‖*‖W‖+2*(1+‖W‖)*‖Pstar+D‖)*2 := by + gcongr + exact inv_one_sub_norm_le_two D hD + _ = _ := by ring + +end SevenEighths.ProbeLocal +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/CubicGaussCRT.lean b/lean/OAI/NumberTheory/DirichletL/Detector/CubicGaussCRT.lean new file mode 100644 index 0000000000000000000000000000000000000000..e9790d9a15a77015c4c0522d2ebde453e67ec991 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/CubicGaussCRT.lean @@ -0,0 +1,121 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalCRT +import OAI.NumberTheory.DirichletL.CubicSieve.Gauss +import OAI.NumberTheory.DirichletL.Detector.PairPhase + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalRowCompletion CanonicalQuadraticSieve +open CompletedGauss ConcreteTraceCRT CubicEisenstein GaussianShiftedPartition +open CenteredMomentCommonSupport CenteredMomentCorrelation CenteredMomentFourier CenteredMomentFirstPoisson +local notation "O" => ActualEisensteinCubic.O + +lemma gaussTwo_eq_elementFourier (I : Ideal O) (hI : CubicSieve.Admissible I) : + gaussTwo I hI.2 = + elementFourier (primaryGenerator I) hI.2 (CubicSieve.cubicRow I) 1 / + (‖eisEmbedding (primaryGenerator I)‖:ℂ) := by + let := finite_quotient_span hI.2 + let : Fintype (Residue (primaryGenerator I)) := Fintype.ofFinite _ + rw [CubicSieve.gaussTwo_eq_gaussSum I hI] + unfold gaussSum elementFourier + rw [tsum_fintype] + congr 1 + apply Finset.sum_congr rfl + intro x hx + have hc := CubicSieve.principalCubicCharacter_mk I hI (representative (primaryGenerator I) x) + rw [representative_spec] at hc + rw [hc] + simp only [map_one, one_mul] + rfl + +lemma residueGauss_principalCubicCharacter (I : Ideal O) (hI : CubicSieve.Admissible I) + [Fintype (Residue (primaryGenerator I))] : + residueGauss (primaryGenerator I) hI.2 (CubicSieve.principalCubicCharacter I hI) 1 = + elementFourier (primaryGenerator I) hI.2 (CubicSieve.cubicRow I) 1 := by + simp only [residueGauss, elementFourier, tsum_fintype, map_one, one_mul] + apply Finset.sum_congr rfl + intro x hx + have hc := CubicSieve.principalCubicCharacter_mk I hI (representative (primaryGenerator I) x) + rw [representative_spec] at hc + rw [hc] + +theorem gaussTwo_coprime_product (I J : Ideal O) + (hI : CubicSieve.Admissible I) (hJ : CubicSieve.Admissible J) + (hIJ : CubicSieve.Admissible (I*J)) (hcop : IsCoprime I J) : + gaussTwo (I*J) hIJ.2 = + (CubicSieve.cubicRow I (primaryGenerator J) * CubicSieve.cubicRow J (primaryGenerator I)) * + gaussTwo I hI.2 * gaussTwo J hJ.2 := by + let a := primaryGenerator I + let b := primaryGenerator J + have hc : IsCoprime a b := by + rw [← Ideal.isCoprime_span_singleton_iff] + simpa only [a,b,(primaryGenerator_spec I hI.2).1,(primaryGenerator_spec J hJ.2).1] using hcop + let := finite_quotient_span hI.2 + let := finite_quotient_span hJ.2 + let := finite_quotient_span (mul_ne_zero hI.2 hJ.2) + let : Fintype (Residue a) := Fintype.ofFinite _ + let : Fintype (Residue b) := Fintype.ofFinite _ + let : Fintype (Residue (a*b)) := Fintype.ofFinite _ + have he := coprime_character_fourier a b hI.2 hJ.2 hc + (CubicSieve.principalCubicCharacter I hI) (CubicSieve.principalCubicCharacter J hJ) 1 + simp only [map_one] at he + have hfour : elementFourier (a*b) (mul_ne_zero hI.2 hJ.2) + (CubicSieve.cubicRow (I*J)) 1 = + (CubicSieve.cubicRow I b * CubicSieve.cubicRow J a) * + elementFourier a hI.2 (CubicSieve.cubicRow I) 1 * + elementFourier b hJ.2 (CubicSieve.cubicRow J) 1 := by + unfold elementFourier + rw [tsum_fintype, tsum_fintype, tsum_fintype] + calc + _ = _ := by + apply Finset.sum_congr rfl + intro x hx + obtain ⟨m,rfl⟩ := Ideal.Quotient.mk_surjective x + rw [CubicSieve.cubicRow_mul] + have hi : CubicSieve.cubicRow I (representative (a*b) (Ideal.Quotient.mk _ m)) = + CubicSieve.cubicRow I m := by + rw [← CubicSieve.principalCubicCharacter_mk I hI, ← CubicSieve.principalCubicCharacter_mk I hI] + congr 1 + apply Ideal.Quotient.eq.mpr + have hx := Ideal.Quotient.eq.mp (representative_spec (a*b) (Ideal.Quotient.mk _ m)) + exact Ideal.mem_span_singleton.mpr ((dvd_mul_right a b).trans (Ideal.mem_span_singleton.mp hx)) + have hj : CubicSieve.cubicRow J (representative (a*b) (Ideal.Quotient.mk _ m)) = + CubicSieve.cubicRow J m := by + rw [← CubicSieve.principalCubicCharacter_mk J hJ, ← CubicSieve.principalCubicCharacter_mk J hJ] + congr 1 + apply Ideal.Quotient.eq.mpr + have hx := Ideal.Quotient.eq.mp (representative_spec (a*b) (Ideal.Quotient.mk _ m)) + exact Ideal.mem_span_singleton.mpr ((dvd_mul_left b a).trans (Ideal.mem_span_singleton.mp hx)) + rw [hi,hj] + simp only [frequencyReduction_mk, map_one, one_mul] + rw [CubicSieve.principalCubicCharacter_mk I hI m, CubicSieve.principalCubicCharacter_mk J hJ m] + _ = _ := he + _ = _ := by + rw [CubicSieve.principalCubicCharacter_mk I hI b, + CubicSieve.principalCubicCharacter_mk J hJ a, + residueGauss_principalCubicCharacter I hI, residueGauss_principalCubicCharacter J hJ] + simp only [elementFourier, tsum_fintype] + rfl + rw [gaussTwo_eq_elementFourier (I*J) hIJ, gaussTwo_eq_elementFourier I hI, + gaussTwo_eq_elementFourier J hJ] + have hgen : primaryGenerator (I*J)=a*b := primaryGenerator_mul I J + rw [elementFourier_congr _ (a*b) hIJ.2 (mul_ne_zero hI.2 hJ.2) _ 1 hgen, hfour] + rw [hgen, map_mul, norm_mul, Complex.ofReal_mul] + ring + +theorem gaussTwo_coprime_product_sextic (I J : Ideal O) + (hI : CubicSieve.Admissible I) (hJ : CubicSieve.Admissible J) + (hIJ : CubicSieve.Admissible (I*J)) (hcop : IsCoprime I J) : + gaussTwo (I*J) hIJ.2 = + ProbePhase.sexticPair (primaryGenerator I) (primaryGenerator J)^2 * + gaussTwo I hI.2 * gaussTwo J hJ.2 := by + rw [gaussTwo_coprime_product I J hI hJ hIJ hcop] + simp only [CubicSieve.cubicRow, ← idealRowHom_square, ProbePhase.sexticPair, + (primaryGenerator_spec I hI.2).1, (primaryGenerator_spec J hJ.2).1, mul_pow] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorBatch.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorBatch.lean new file mode 100644 index 0000000000000000000000000000000000000000..b9e09717ff6311fb7b7fff90a8ab14b86ded8072 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorBatch.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Detector.DetectorMomentData +import OAI.NumberTheory.DirichletL.Hecke.DetectorBatch + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification HeckeDetectorBatch HeckeDetectorSupportedWitness ProbePhysical +local notation "O" => HeckeFamily.O + +def retainedProjection (R : Finset FreeRow) (u0 : FreeRow) (u : FreeRow) : FreeRow := + if u∈R then u else u0 + +@[simp] theorem retainedProjection_of_mem (R : Finset FreeRow) (u0 u : FreeRow) (hu : u∈R) : + retainedProjection R u0 u=u := by simp [retainedProjection,hu] + +theorem retainedProjection_mem (R : Finset FreeRow) (u0 : FreeRow) (h0 : u0∈R) (u : FreeRow) : + retainedProjection R u0 u∈R := by + unfold retainedProjection + split_ifs with hu + · exact hu + · exact h0 + +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +def retainedSourceBatch {Slot : Type*} + (S : Finset (Ideal O)) (hS : SourceExclusions S) (η : Character) + (R : Finset FreeRow) (u0 : FreeRow) (h0 : u0∈R) + (U a ε tstar T allowance : ℝ) (i : ℕ) + (hw : ∀u∈R,SupportedWitness + (sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u)) U a ε tstar T allowance i) + (hrow : ∀u∈R,rowNorm u≤U) + (slots : Finset Slot) (profile : Slot→ℝ→ℂ) (upper widths : Slot→ℝ) (external : Slot→ℂ) + (mesh binWidth : ℝ) (hm : 0≤mesh) (hb : 0sourceDetectorFamily S hS.prime η (retainedProjection R u0 u) + (rayCubeFamily M H hH (retainedProjection R u0 u)) + witness := fun u=>hw (retainedProjection R u0 u) (retainedProjection_mem R u0 h0 u) + row_norm := hrow + data := sourceMomentData M H hH S hS.prime η + reverse := sourceMomentReverse M H + row_coeff := by + intro u hu j I + rw [retainedProjection_of_mem R u0 u hu] + exact source_family_moment_coeff M H hH S hS.prime hS.bad η u j I + slots := slots + profile := profile + upper := upper + widths := widths + external := external + mesh := mesh + binWidth := binWidth + mesh_nonneg := hm + binWidth_pos := hb + widths_pos := hwpos + widths_mesh := hwmesh + supply := hsupply + +lemma physical_slot_widths {N : ℕ} (ell : Fin N→ℝ) (d dmin mesh : ℝ) + (hdmin : 0 + (hsmall j).trans (mul_nonpos_of_nonneg_of_nonpos hdmin.le hm.le) + rw [hsum] at hn + norm_num at hn + refine ⟨fun j=>div_pos (hell j) hd0,fun j=>?_,?_⟩ + · apply (div_le_iff₀ hd0).mpr + exact (hsmall j).trans (by nlinarith) + · rw [←Finset.sum_div,hsum] + apply (le_div_iff₀ hd0).mpr + nlinarith + +lemma physical_slot_scale {N : ℕ} (ell : Fin N→ℝ) (Z d : ℝ) (hZ : 0HeckeFamily.O +variable (M:Ideal O)[NeZero M] +local instance:Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) +local instance:Fintype (Sum Bool (RayQuotient.Characters M H)):=Fintype.ofFinite _ + +private lemma raw_mono (data:RowData)(W:ℝ→ℂ)(c κ A B:ℝ) + (hAB:A≤B)(h:RawMoment data W c κ A):RawMoment data W c κ B:=by + intro X D hX hD hcap rows hrows + apply (h X D hX hD hcap rows hrows).trans + gcongr + +theorem source_batch_inverse_fields {Δ:ℝ}{D:Parameters.HighData Δ} + (S:SourceData D)(counts:CountParameters M H D.t): + ∃J:ℕ,∀η:Character,∃C:ℝ,0(S.w x:ℂ)) → B.upper=(fun _=>2) → + B.widths=(fun s=>D.ell s/d) → (∀s,(B.external s).re=17/50) → + ∀bin label left right,∀hne:(B.fiberRows bin label left right).Nonempty, + ∀height:ℝ,0≤height → + let F:=B.fiber bin label left right hne; + (∀n:ℕ,n≤2 → ∀s∈Set.Icc (0:ℝ) 1,∀t∈Set.Icc (-height) height, + let W:=twistProfile (logTest (orientedProfile F.reverse F.inverseProfile) n) s t; + RawMoment F.rowData W (if 2*a-1≤5/6 then counts.cB else counts.cH) + (if 2*a-1≤5/6 then counts.kB else counts.kH) (C*(1+height)^J) ∧ + RawMoment F.rowData (scaleProfile W) (if 2*a-1≤5/6 then counts.cB else counts.cH) + (if 2*a-1≤5/6 then counts.kB else counts.kH) (C*(1+height)^J)) ∧ + (∀selected:Finset (Fin D.N),selected⊆F.slots → + F.r+2*(∑s∈selected,F.widths s)<1 → 2*F.r+8*(∑s∈selected,F.widths s)<3 → + ∀n:ℕ,n≤2 → ∀s∈Set.Icc (0:ℝ) 1,∀t∈Set.Icc (-height) height, + (∑u∈F.rows,‖polynomial (F.family u F.label) true + ((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile) + ((Z^d)^F.r) s t*F.physicalProduct selected u‖^2)≤ + (C*(1+height)^J)*(Z^d)^(1+D.t)) := by + obtain ⟨Jr,hr⟩ := ProbeDetectorInverseRawField.source_batch_inverse_raw + M H hH S.S S.exclusions.prime D.t counts + obtain ⟨Jm,hm⟩ := ProbeDetectorInverseMarkedField.source_batch_inverse_marked M H hH S + refine ⟨Jr+Jm,?_⟩ + intro η + obtain ⟨Cr,hCr,hr⟩ := hr η + obtain ⟨Cm,hCm,hm⟩ := hm η + refine ⟨Cr+Cm,add_pos hCr hCm,?_⟩ + filter_upwards [hm] with Z hZ + refine ⟨hZ.1,?_⟩ + intro d hd a ε tstar T allowance i B hdata hprofile hupper hwidths hex + bin label left right hne height hheight F + have hU:0HeckeFamily.O + +variable (M:Ideal O)[NeZero M] +local instance:Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) +local instance:Fintype (Sum Bool (RayQuotient.Characters M H)):=Fintype.ofFinite _ + +theorem source_batch_inverse_marked {Δ:ℝ}{D:Parameters.HighData Δ} + (S:SourceData D): + ∃J:ℕ,∀η:Character,∃C:ℝ,0(S.w x:ℂ)) → B.upper=(fun _=>2) → + B.widths=(fun s=>D.ell s/d) → (∀s,(B.external s).re=17/50) → + ∀bin label left right,∀hne:(B.fiberRows bin label left right).Nonempty, + ∀height:ℝ,0≤height → + let F:=B.fiber bin label left right hne; + ∀selected:Finset (Fin D.N),selected⊆F.slots → + F.r+2*(∑s∈selected,F.widths s)<1 → 2*F.r+8*(∑s∈selected,F.widths s)<3 → + ∀n:ℕ,n≤2 → ∀s∈Set.Icc (0:ℝ) 1,∀t∈Set.Icc (-height) height, + (∑u∈F.rows,‖polynomial (F.family u F.label) true + ((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile) + ((Z^d)^F.r) s t*F.physicalProduct selected u‖^2)≤ + (C*(1+height)^J)*(Z^d)^(1+D.t) := by + obtain ⟨Jref,hreference⟩:=fiber_reference_energy S referenceWindow (1/18) (13/4) + (by norm_num) (by norm_num) + (fun x hx=>referenceWindow_support (subset_tsupport _ hx)) (referenceWindow.smooth ⊤) + D.t D.t_pos D.N + obtain ⟨J,Cfourier,hCfourier,hfourier⟩:=DetectorDictionaryInverseMarkedUniform.fiber_inverse_height_uniform Jref + refine ⟨J,?_⟩ + intro η + let data:=sourceMomentData M H hH S.S S.exclusions.prime η + choose C U₀ hC hU₀ hb using fun label=>hreference (data label) + let Csum:ℝ:=1+∑label,C label + have hCsum:0(hC label).le) + dsimp [Csum];linarith + have hClabel (label):C label≤Csum:=by + have hh:=Finset.single_le_sum (fun label (_:label∈Finset.univ)=>(hC label).le) (Finset.mem_univ label) + dsimp [Csum];linarith + have hscale:∀ᶠZ:ℝ in atTop,∀label,∀d:ℝ,(1/200:ℝ)≤d → U₀ label≤Z^d := by + apply Filter.eventually_all.mpr + intro label + exact HeckeDetectorDyadicGeometry.uniform_scale_threshold (1/200) (U₀ label) (by norm_num) + refine ⟨Cfourier*Csum,mul_pos hCfourier hCsum,?_⟩ + filter_upwards [eventually_gt_atTop (1:ℝ),hscale, + deleted_large_eventually data D.ell (fun s=>(D.slots_bounds s).1), + sourceMoment_fiber_prime_geometry_eventually M H hH S η D.t D.t_pos] with Z hZ hscale hlarge hgeom + refine ⟨hZ,?_⟩ + intro d hd a ε tstar T allowance i B hdata hprofile0 hupper hwidths hz bin label left right hne + height hheight F selected hselected hfirst hsecond n hn s hs t ht + have hd0:0(S.W:ℝ→ℂ)) := by + rw [hprofile0] + funext j x + exact (S.complex_eq x).symm + have hfd:F.rowData=data label:=by change B.data label=data label;rw [hdata] + have hfp (j):F.profile j=S.W:=by change B.profile j=S.W;rw [hprofile] + have hfu (j):F.upper j=2:=by change B.upper j=2;rw [hupper] + have hfw (j):F.widths j=D.ell j/d:=by change B.widths j=_;rw [hwidths] + have hfe (j):(F.external j).re≤1:=by change (B.external j).re≤1;rw [hz j];norm_num + have hdis:((Finset.univ:Finset selected):Set selected).PairwiseDisjoint (fiberLists F selected) := by + intro j hj k hk hjk + exact (hgeom.2 d hd a ε tstar T allowance i B hdata hprofile0 hupper hwidths hz + bin label left right hne).1 j k (fun he=>hjk (Subtype.ext he)) + have hlargeF:∀j∈selected,((DetectorDictionaryInverseRawInitialGates.deletedBase (data label)).modulus.absNorm:ℝ)< + (Z^d)^(F.widths j) := by + intro j hj + rw [hfw] + exact hlarge.2 d hd0 label j + have hr:0≤F.r:=Real.logb_nonneg hUone (one_le_pow₀ (by norm_num : (1:ℝ)≤2)) + have href (v:ℝ): + (∑u∈F.rows,‖polynomial (F.family u F.label) true (childLogTest referenceWindow v) + ((Z^d)^F.r) 0 0*F.physicalProduct selected u‖^2)≤ + (Csum*(Z^d)^(1+D.t))*(1+‖v‖)^(2*Jref) := by + have hh:=hb label (Z^d) (hscale label d hd) M H F selected hfd + (by simpa using Finset.card_le_univ selected) (fun j _=>hfp j) (fun j _=>hfu j) + (fun j hj=>(F.widths_pos j (hselected hj)).le) (fun j _=>hfe j) hdis hlargeF hr hfirst hsecond v + rw [(show 2*Jref=Jref*2 by omega),pow_mul] + + apply hh.trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + exact mul_le_mul_of_nonneg_right (hClabel label) (Real.rpow_nonneg hUp.le _) + have hh:=hfourier F selected hUp (Csum*(Z^d)^(1+D.t)) (by positivity) href + n hn s hs height t hheight ht + convert hh using 1 ; ring + +end SevenEighths.ProbeDetectorInverseMarkedField + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorInverseRawField.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorInverseRawField.lean new file mode 100644 index 0000000000000000000000000000000000000000..3f9b0f633ac50df262750c11fc31c9333c23670c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorInverseRawField.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawReference +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawUniform +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyCountParameters +import OAI.NumberTheory.DirichletL.Detector.DetectorMomentData + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.ProbeDetectorInverseRawField +open HeckeFamily HeckeDyadic HeckeInverseAmplification InverseMoment +open HeckeDetectorRawFiber HeckeDetectorBatch HeckeDetectorCoefficientTransfer +open HeckeDetectorInverseFiberCount DetectorDictionaryInverseClippedUniform +open ProbeHighRowFamily ProbeFinalAssembly + +private theorem raw_mono (data:RowData)(W:ℝ→ℂ)(c κ A B:ℝ) + (hAB:A≤B)(h:RawMoment data W c κ A):RawMoment data W c κ B:=by + intro H D hH hD hcap rows hrows + apply (h H D hH hD hcap rows hrows).trans + gcongr + +theorem fixed_raw_profiles (c κ:ℝ)(hc:0referenceWindow_support (subset_tsupport _ hx)) hc hκ + obtain ⟨K,C,hC,hfamily⟩:=DetectorDictionaryInverseRawUniform.raw_pair_height_uniform J + refine ⟨K,?_⟩ + intro data + obtain ⟨A,hA,href⟩:=hreference data + exact ⟨A*C,mul_pos hA hC,hfamily data c κ A hA.le href⟩ + +variable (M:Ideal O)[NeZero M] +local instance:Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) +local instance:Fintype (Sum Bool (RayQuotient.Characters M H)):=Fintype.ofFinite _ + +theorem source_batch_inverse_raw + (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(εm:ℝ)(counts:CountParameters M H εm): + ∃J:ℕ,∀η:Character,∃C:ℝ,0hB (data label)) + choose CH hCH hh using (fun label=>hHraw (data label)) + let C:ℝ:=1+(∑label,CB label)+(∑label,CH label) + have hsumB:0≤∑label,CB label:=Finset.sum_nonneg (fun j _=>(hCB j).le) + have hsumH:0≤∑label,CH label:=Finset.sum_nonneg (fun j _=>(hCH j).le) + have hC:0(hCB j).le) (Finset.mem_univ label) + dsimp [C];linarith + have hCHound (label):CH label≤C:=by + have he:=Finset.single_le_sum (fun j (_:j∈Finset.univ)=>(hCH j).le) (Finset.mem_univ label) + dsimp [C];linarith + refine ⟨C,hC,?_⟩ + intro Slot U a ε tstar T allowance i hU B hdata bin label left right hne height hheight n hn s hs t ht F W + have hd:F.rowData=data label:=by + change B.data label=data label + rw [hdata] + have hbase:1≤1+height:=by linarith + by_cases hbranch:2*a-1≤5/6 + · simp only [hbranch,ite_true] + have hpair:=hb label F.reverse n hn U hU tstar F.r s hs height t hheight ht + have hconstant:CB label*(1+height)^JB≤C*(1+height)^(JB+JH):= + mul_le_mul (hCBound label) (pow_le_pow_right₀ hbase (Nat.le_add_right _ _)) + (by positivity) hC.le + rw [hd] + exact ⟨raw_mono _ _ _ _ _ _ hconstant hpair.1,raw_mono _ _ _ _ _ _ hconstant hpair.2⟩ + · simp only [hbranch,ite_false] + have hpair:=hh label F.reverse n hn U hU tstar F.r s hs height t hheight ht + have hconstant:CH label*(1+height)^JH≤C*(1+height)^(JB+JH):= + mul_le_mul (hCHound label) (pow_le_pow_right₀ hbase (Nat.le_add_left _ _)) + (by positivity) hC.le + rw [hd] + exact ⟨raw_mono _ _ _ _ _ _ hconstant hpair.1,raw_mono _ _ _ _ _ _ hconstant hpair.2⟩ + +end SevenEighths.ProbeDetectorInverseRawField + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentData.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentData.lean new file mode 100644 index 0000000000000000000000000000000000000000..cf8832179002d3e866a90599e5d5b8bd44eacff7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentData.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.Moments +import OAI.NumberTheory.DirichletL.PrimeRows.CanonicalRayCube + +namespace OAI + +noncomputable section +open scoped Classical ComplexConjugate +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification HeckeRowClosure ProbePhysical +local notation "O" => HeckeFamily.O + +theorem momentData_product_raw (χ : Character) (u : FreeRow) (I : Ideal O) : + idealCoeff ((momentData χ).character (momentElement u)) I= + idealCoeff (χ.product (rawRow u)) I := by + have he : idealCoeff ((momentData χ).character (momentElement u))= + idealCoeff (χ.product (rawRow u)) := by + apply hom_eq_of_primes + intro P + rw [momentData_coeff,idealCoeff_product,rawRow_coeff,fixedSourcePrincipal_prime] + simp + exact congrArg (fun f : Ideal O→*₀ℂ=>f I) he + +theorem inverse_row_twist_moment_coeff (χ : Character) (u : FreeRow) (I : Ideal O) : + idealCoeff ((rawRow u).inverse.product χ) I= + conj (idealCoeff ((momentData χ.inverse).character (momentElement u)) I) := by + rw [momentData_product_raw,idealCoeff_product,idealCoeff_product, + idealCoeff_inverse_conj,idealCoeff_inverse_conj,map_mul] + simp only [starRingEnd_self_apply] + ring + +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +def sourceMomentData (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) (η : Character) : + Sum Bool (RayQuotient.Characters M H)→RowData := + Sum.elim (fun b=>if b then momentData (fixedSourcePrincipal S hS) + else momentData (η.inverse.excludePrimes S hS)) + (fun θ=>momentData (HeckeRayQuotient.character M H hH θ).inverse) + +def sourceMomentReverse : Sum Bool (RayQuotient.Characters M H)→Bool := + Sum.elim (fun b=>!b) (fun _=>true) + +theorem source_family_moment_coeff (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) + (hbad : CanonicalQuadraticSieve.fixedBadPrimes⊆S) (η : Character) + (u : FreeRow) (j : Sum Bool (RayQuotient.Characters M H)) (I : Ideal O) : + idealCoeff (sourceDetectorFamily S hS η u (rayCubeFamily M H hH u) j) I= + if sourceMomentReverse M H j then + conj (idealCoeff ((sourceMomentData M H hH S hS η j).character (momentElement u)) I) + else idealCoeff ((sourceMomentData M H hH S hS η j).character (momentElement u)) I := by + rcases j with b|θ + · cases b + · simpa [sourceMomentReverse,sourceMomentData] using denominator_moment_coeff S hS hbad η u I + · simpa [sourceMomentReverse,sourceMomentData] using numerator_moment_coeff S hS hbad u I + · exact inverse_row_twist_moment_coeff (HeckeRayQuotient.character M H hH θ) u I +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentFiberGates.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentFiberGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..8d0dadbc13aa509926785f2ec66790d66dd6f9eb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentFiberGates.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Detector.DetectorMomentGates +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyData + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators Topology +open Filter +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification InverseInitialDetectorSource +open HeckeDetectorBatch HeckeDetectorRawFiber HeckeDetectorFiberPartition +local notation "O"=>HeckeFamily.O +variable (M:Ideal O)[NeZero M] +local instance:Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem sourceMoment_fiber_large_eventually + (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character) + {Slot:Type*}[Fintype Slot](ell:Slot→ℝ)(hell:∀s,0ell s/d)→ + ∀bin j J K,∀hne:(B.fiberRows bin j J K).Nonempty,∀s:Slot, + ((baseCharacter (B.fiber bin j J K hne).rowData).modulus.absNorm:ℝ)< + 1*(Z^d)^((B.fiber bin j J K hne).widths s):=by + filter_upwards [sourceMoment_large_eventually M H hH S hS η ell hell] with Z hZ + refine ⟨hZ.1,?_⟩ + intro d hd a ε tstar T allowance i B hdata hw bin j J K hne s + change ((baseCharacter (B.data j)).modulus.absNorm:ℝ)<1*(Z^d)^(B.widths s) + rw [hdata,hw,one_mul] + exact hZ.2 d hd j s + +theorem sourceMoment_fiber_support {Δ:ℝ}{D:Parameters.HighData Δ} + (F:ProbeFinalAssembly.SourceData D) + {Slot:Type*}{U a ε tstar T allowance:ℝ}{i:ℕ} + (B:Batch M H (Sum Bool (RayQuotient.Characters M H)) Slot U a ε tstar T allowance i) + (hprofile:B.profile=(fun _=>(F.W:ℝ→ℂ)))(hupper:B.upper=(fun _=>2)) + (bin:B.Bin)(j:Sum Bool (RayQuotient.Characters M H)) + (J K:Fin (HeckeDetectorWitnessRows.dyadicLength U)) + (hne:(B.fiberRows bin j J K).Nonempty): + ∀s x,(B.fiber bin j J K hne).profile s x≠0→ + x∈Set.Icc 1 ((B.fiber bin j J K hne).upper s):=by + intro s x hx + change B.profile s x≠0 at hx + change x∈Set.Icc 1 (B.upper s) + rw [hprofile] at hx + rw [hupper] + exact F.complex_support hx + +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentGates.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..33214d13bacc13e27fd9a921bc90f307b87621a7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorMomentGates.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Detector.DetectorMomentData +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawFiberSource +import OAI.NumberTheory.DirichletL.Hecke.DetectorBatch +import OAI.NumberTheory.DirichletL.Inversion.InitialExcludedElement + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators Topology +open Filter +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification InverseInitialDetectorSource +open CanonicalCoefficientClass InverseInitialExcludedPeriod CanonicalQuadraticSieve +open InverseInitialRayAttachment CanonicalRowCompletion +local notation "O"=>HeckeFamily.O +variable (M:Ideal O)[NeZero M] +local instance:Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) +local instance:Fintype (Sum Bool (RayQuotient.Characters M H)):=Fintype.ofFinite _ + +def sourceMomentPeriod (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character):ℕ:= + ∏j:Sum Bool (RayQuotient.Characters M H), + (baseCharacter (sourceMomentData M H hH S hS η j)).period + +def sourceMomentConductorBound (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character):ℝ:= + 1+∑j:Sum Bool (RayQuotient.Characters M H), + ((baseCharacter (sourceMomentData M H hH S hS η j)).modulus.absNorm:ℝ) + +theorem sourceMomentPeriod_ne_zero (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character): + sourceMomentPeriod M H hH S hS η≠0:=by + exact Finset.prod_ne_zero_iff.mpr (fun j _=>Nat.ne_of_gt (Character.period_pos _)) + +theorem sourceMomentPeriod_le (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character) + (j:Sum Bool (RayQuotient.Characters M H)): + Ideal.span {(sourceMomentPeriod M H hH S hS η:O)}≤ + (baseCharacter (sourceMomentData M H hH S hS η j)).modulus:=by + apply Ideal.span_le.mpr + intro x hx + rcases Set.mem_singleton_iff.mp hx with rfl + have hd:(baseCharacter (sourceMomentData M H hH S hS η j)).period∣ + sourceMomentPeriod M H hH S hS η:=Finset.dvd_prod_of_mem _ (Finset.mem_univ j) + obtain ⟨n,hn⟩:=hd + rw [hn,Nat.cast_mul] + exact Ideal.mul_mem_right _ _ (Character.period_mem _) + +theorem sourceMomentConductorBound_pos (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character): + 0 + (Nat.cast_nonneg (α:=ℝ) (baseCharacter (sourceMomentData M H hH S hS η k)).modulus.absNorm)) + (Finset.mem_univ j) + unfold sourceMomentConductorBound + linarith + +theorem sourceMoment_deleted_base_gates (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character): + let q:=sourceMomentPeriod M H hH S hS η + deletedPeriod q≠0 ∧ reflectionExcludedPrimes (deletedPeriod q)=reflectionExcludedPrimes q ∧ + ∀j:Sum Bool (RayQuotient.Characters M H), + let χ:=(baseCharacter (sourceMomentData M H hH S hS η j)).excludePrimes + (reflectionExcludedPrimes q) (reflectionExcludedPrimes_prime q) + (∀x,‖elementCharacter (idealCoeff χ).toMonoidHom x‖≤1) ∧ + FactorsModulo (fixedBaseConductor (deletedPeriod q)) + (elementCharacter (idealCoeff χ).toMonoidHom):=by + dsimp only + let q:=sourceMomentPeriod M H hH S hS η + have hq:q≠0:=sourceMomentPeriod_ne_zero M H hH S hS η + refine ⟨deletedPeriod_ne_zero q hq,deleted_excluded_eq q hq,?_⟩ + intro j + exact (deleted_physical_base_gates _ q hq (sourceMomentPeriod_le M H hH S hS η j)).2.2 + +theorem sourceMoment_large_eventually (S:Finset (Ideal O))(hS:∀P∈S,Prime P)(η:Character) + {Slot:Type*}[Fintype Slot](ell:Slot→ℝ)(hell:∀s,0 HeckeFamily.O + +theorem sourceMoment_physical_scale (Z d ell : ℝ) (hZ : 0≤Z) (hd : d≠0) : + (Z^d)^(ell/d)=Z^ell := by + rw [←Real.rpow_mul hZ,mul_div_cancel₀ _ hd] + +theorem sourceMoment_separation_eventually {Slot : Type*} [Fintype Slot] + (ell : Slot→ℝ) (hinj : Function.Injective ell) : + ∀ᶠ Z : ℝ in atTop, 1≤Z ∧ ∀d : ℝ,0False.elim (h he)) + rcases lt_or_gt_of_ne (fun h=>he (hinj h)) with hlt|hlt + · filter_upwards [ProbeRaySlots.annular_power_separation 1 2 (ell s) (ell t) + (by norm_num) hlt] with Z hZ _ + exact Or.inl hZ + · filter_upwards [ProbeRaySlots.annular_power_separation 1 2 (ell t) (ell s) + (by norm_num) hlt] with Z hZ _ + exact Or.inr hZ + filter_upwards [hs,eventually_ge_atTop (1:ℝ)] with Z hs hZ + refine ⟨hZ,?_⟩ + intro d hd s t hst + simp only [sourceMoment_physical_scale Z d _ (by linarith) hd.ne'] + exact hs s t hst + +theorem sourceMoment_fixedBase_norm_one (data : RowData) (P : Ideal O) (hP : Prime P) + (hlarge : ((baseCharacter data).modulus.absNorm:ℝ)<(P.absNorm:ℝ)) : + ‖fixedBase data.η data.m data.f P‖=1 := by + rw [←baseCharacter_coeff] + exact PrincipalSignalComparison.idealCoeff_norm_one_of_coprime + (baseCharacter data) P hP.ne_zero + (ProbeRaySlots.prime_coprime_of_norm_gt (baseCharacter data) ⟨P,hP⟩ hlarge) + +theorem sourceMoment_primeProfile_norm {Δ : ℝ} {D : Parameters.HighData Δ} + (F : ProbeFinalAssembly.SourceData D) (X : ℝ) (ζ : ℂ) (hz : ζ.re≤1) + (P : Ideal O) : ‖primeProfile F.W X ζ P‖≤1 := by + by_cases hw : F.W ((P.absNorm:ℝ)/X)=0 + · simp [primeProfile,hw] + have hx := F.complex_support hw + have hp : 0<(P.absNorm:ℝ)/X := lt_of_lt_of_le (by norm_num) hx.1 + have hnorm : ‖F.W ((P.absNorm:ℝ)/X)‖≤1 := by + rw [F.complex_eq,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (F.bounded _).1] + exact (F.bounded _).2 + rw [primeProfile,norm_mul,Complex.norm_cpow_eq_rpow_re_of_pos hp] + have hr : ((P.absNorm:ℝ)/X)^((ζ-1).re)≤1 := + (Real.rpow_le_rpow_of_exponent_le hx.1 + (show (ζ-1).re≤0 by simp only [Complex.sub_re,Complex.one_re];linarith)).trans_eq + (Real.rpow_zero _) + simpa only [one_mul] using mul_le_mul hnorm hr (Real.rpow_nonneg hp.le _) (by norm_num : (0:ℝ)≤1) + +theorem sourceMoment_tuple_quotient {ι : Type*} [Fintype ι] + (data : RowData) (A : ι→ℂ) (p : ι→Ideal O) : + star (∏s,A s)/fixedBase data.η data.m data.f (∏s,p s)= + ∏s,star (A s)/fixedBase data.η data.m data.f (p s) := by + rw [map_prod,star_prod,Finset.prod_div_distrib] + +section Live +variable (M : Ideal O) (H : Subgroup (O ⧸ M)ˣ) + +theorem sourceMoment_live_disjoint {Δ : ℝ} {D : Parameters.HighData Δ} + (F : ProbeFinalAssembly.SourceData D) {ι : Type*} (ell : ι→ℝ) + (U : ℝ) (hU : 0 linarith [hs'.2.2.1,hs'.2.2.2,ht'.2.2.1,ht'.2.2.2] + +theorem sourceMoment_live_denominator {Δ : ℝ} {D : Parameters.HighData Δ} + (F : ProbeFinalAssembly.SourceData D) {ι : Type*} [Fintype ι] + (data : RowData) (U : ℝ) (ell : ι→ℝ) (hU : 0livePrimes M H F.W 2 (U^(ell s)))) : + ‖fixedBase data.η data.m data.f (∏s,p s)‖=1 := by + rw [map_prod,norm_prod] + apply Finset.prod_eq_one + intro s _ + have hs := livePrime_data M H F.W 1 2 (U^(ell s)) + (Real.rpow_pos_of_pos hU _) F.complex_support (p s) (Fintype.mem_piFinset.mp hp s) + exact sourceMoment_fixedBase_norm_one data (p s) hs.1 ((hlarge s).trans_le hs.2.2.1) + +theorem sourceMoment_live_quotient_norm {Δ : ℝ} {D : Parameters.HighData Δ} + (F : ProbeFinalAssembly.SourceData D) {ι : Type*} [Fintype ι] + (data : RowData) (U : ℝ) (ell : ι→ℝ) (ζ : ι→ℂ) (hU : 0livePrimes M H F.W 2 (U^(ell s)))) : + ‖star (∏s,primeProfile F.W (U^(ell s)) (ζ s) (p s))/ + fixedBase data.η data.m data.f (∏s,p s)‖≤1 := by + rw [norm_div,norm_star,sourceMoment_live_denominator M H F data U ell hU hlarge p hp, + div_one,norm_prod] + exact Finset.prod_le_one₀ (fun s _=>norm_nonneg _) + (fun s _=>sourceMoment_primeProfile_norm F _ _ (by rw [hz s];norm_num) _) +end Live + +theorem sourceMoment_capacity_eventually {Slot : Type*} [Fintype Slot] + (ell : Slot→ℝ) (hell : ∀s,0≤ell s) (ε : ℝ) (hε : 0<ε) : + ∀ᶠ Z : ℝ in atTop,1≤Z ∧ ∀d : ℝ,1/200≤d→ + (∀s,1≤2*(Z^d)^(ell s/d)) ∧ ∀selected : Finset Slot, + (∏s:selected,2*(Z^d)^(ell s/d))≤ + (Z^d)^((∑s:selected,ell s/d)+ε) := by + have ht := (tendsto_rpow_atTop (show 0<ε/200 by positivity)).eventually + (eventually_ge_atTop ((2:ℝ)^Fintype.card Slot)) + filter_upwards [ht,eventually_ge_atTop (1:ℝ)] with Z ht hZ + refine ⟨hZ,?_⟩ + intro d hd + have hd0 : 0(F.w x:ℂ))→B.upper=(fun _=>2)→ + B.widths=(fun s=>D.ell s/d)→(∀s,(B.external s).re=17/50)→ + ∀bin j J K,∀hne : (B.fiberRows bin j J K).Nonempty, + let f:=B.fiber bin j J K hne + (∀s t,s≠t→Disjoint + (livePrimes M H (f.profile s) (f.upper s) ((Z^d)^(f.widths s))) + (livePrimes M H (f.profile t) (f.upper t) ((Z^d)^(f.widths t)))) ∧ + ∀selected : Finset (Fin D.N), + (∀s:selected,1≤2*(Z^d)^(f.widths s)) ∧ + (∏s:selected,2*(Z^d)^(f.widths s))≤ + (Z^d)^((∑s:selected,f.widths s)+εg) ∧ + ∀p : selected→Ideal O, + p∈Fintype.piFinset (fun s:selected=> + livePrimes M H (f.profile s) (f.upper s) ((Z^d)^(f.widths s)))→ + Function.Injective p ∧ CanonicalQuadraticSieve.Admissible (∏s:selected,p s) ∧ + (∀s:selected,((p s).absNorm:ℝ)≤2*(Z^d)^(f.widths s)) ∧ + ‖fixedBase f.rowData.η f.rowData.m f.rowData.f (∏s:selected,p s)‖=1 ∧ + ‖star (∏s:selected,primeProfile (f.profile s) ((Z^d)^(f.widths s)) (f.external s) (p s))/ + fixedBase f.rowData.η f.rowData.m f.rowData.f (∏s:selected,p s)‖≤1 := by + filter_upwards [sourceMoment_separation_eventually D.ell D.slots_injective, + sourceMoment_capacity_eventually D.ell (fun s=>(D.slots_bounds s).1.le) εg hεg, + sourceMoment_fiber_large_eventually M H hH F.S F.exclusions.prime η + D.ell (fun s=>(D.slots_bounds s).1)] with Z hsep hcap hlarge + refine ⟨hsep.1,?_⟩ + intro d hd a ε tstar T allowance i B hdata hprofile0 hupper hwidths hz bin j J K hne + have hprofile : B.profile=(fun _=>(F.W:ℝ→ℂ)) := by + rw [hprofile0] + funext s x + exact (F.complex_eq x).symm + have hd0 : 0D.ell s/d) (Z^d) hu s t (hs s t hst) + · intro selected + change (∀s:selected,1≤2*(Z^d)^(B.widths s)) ∧ + (∏s:selected,2*(Z^d)^(B.widths s))≤(Z^d)^((∑s:selected,B.widths s)+εg) ∧ _ + refine ⟨?_,?_,?_⟩ + · rw [hwidths] + exact fun s=>hc.1 s + · rw [hwidths] + exact hc.2 selected + · intro p hp + have hp' : p∈Fintype.piFinset (fun s:selected=>livePrimes M H F.W 2 ((Z^d)^(D.ell s/d))) := by + change p∈Fintype.piFinset (fun s:selected=>livePrimes M H (B.profile s) (B.upper s) ((Z^d)^(B.widths s))) at hp + simpa only [hprofile,hupper,hwidths] using hp + have hl' : ∀s:selected,((baseCharacter (B.data j)).modulus.absNorm:ℝ)<1*(Z^d)^(D.ell s/d) := by + intro s + have hh:=hl s + change ((baseCharacter (B.data j)).modulus.absNorm:ℝ)<1*(Z^d)^(B.widths s) at hh + simpa only [hwidths] using hh + have hs' : ∀s t:selected,s≠t→2*(Z^d)^(D.ell s/d)<1*(Z^d)^(D.ell t/d) ∨ + 2*(Z^d)^(D.ell t/d)<1*(Z^d)^(D.ell s/d) := by + intro s t hst + exact hs s t (fun he=>hst (Subtype.ext he)) + refine ⟨?_,?_,?_,?_,?_⟩ + · exact live_tuple_injective M H (fun _=>F.W) (fun _=>1) (fun _=>2) + (fun s:selected=>D.ell s/d) (Z^d) hu (fun _=>F.complex_support) hs' p (by simpa only [Fintype.mem_piFinset] using hp') + · exact live_tuple_admissible M H (B.data j) (fun _=>F.W) (fun _=>1) (fun _=>2) + (fun s:selected=>D.ell s/d) (Z^d) hu (fun _=>F.complex_support) hl' hs' p (by simpa only [Fintype.mem_piFinset] using hp') + · intro s + change ((p s).absNorm:ℝ)≤2*(Z^d)^(B.widths s) + rw [hwidths] + exact (livePrime_data M H F.W 1 2 ((Z^d)^(D.ell s/d)) + (Real.rpow_pos_of_pos hu _) F.complex_support (p s) (Fintype.mem_piFinset.mp (by simpa only [Fintype.mem_piFinset] using hp') s)).2.2.2 + · exact sourceMoment_live_denominator M H F (B.data j) (Z^d) + (fun s:selected=>D.ell s/d) hu hl' p (by simpa only [Fintype.mem_piFinset] using hp') + · change ‖star (∏s:selected,primeProfile (B.profile s) ((Z^d)^(B.widths s)) (B.external s) (p s))/ + fixedBase (B.data j).η (B.data j).m (B.data j).f (∏s:selected,p s)‖≤1 + rw [hprofile,hwidths] + exact sourceMoment_live_quotient_norm M H F (B.data j) (Z^d) + (fun s:selected=>D.ell s/d) (fun s:selected=>B.external s) hu (fun s=>hz s) hl' p (by simpa only [Fintype.mem_piFinset] using hp') + +end Source +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorPlainMarkedFineField.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorPlainMarkedFineField.lean new file mode 100644 index 0000000000000000000000000000000000000000..d4b3e96991e97155c064df03b988a5787da3252a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorPlainMarkedFineField.lean @@ -0,0 +1,133 @@ +import OAI.NumberTheory.DirichletL.ParametersHighDataFine +import OAI.NumberTheory.DirichletL.Moments.DetectorPlainMomentParameters +import OAI.NumberTheory.DirichletL.Moments.DetectorPlainRelativeClass +import OAI.NumberTheory.DirichletL.Moments.DetectorPlainProfileControl +import OAI.NumberTheory.DirichletL.Hecke.DetectorDyadicGeometry + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ComplexConjugate +open Filter + +namespace SevenEighths.ProbeDetectorPlainMarkedFineField +open HeckeFamily HeckeDyadic HeckeInverseAmplification HeckeDetectorRawFiber HeckeDetectorBatch +open HeckeDetectorRowwisePolynomial HeckeDetectorDyadicProfiles ProbeHighRowFamily ProbeFinalAssembly +open QuadraticInitialBound CenteredMomentDetectorDictionary +open CenteredMomentEnergyBands CenteredMomentEnergyState CenteredMomentInductionEnergy +open CenteredMomentDetectorEnergyInitialState CenteredMomentDetectorPlainMarkedState +open CenteredMomentDetectorPlainMomentParameters CenteredMomentNaturalFixedRaySource +open CenteredMomentFiniteProfileExceptional CenteredMomentDetectorPlainFiberSource +local notation "O"=>HeckeFamily.O + +def PositiveFineSourceInput {Δ:ℝ}{D:Parameters.HighData Δ}(S:SourceData D)(mesh:ℝ):Prop:= + ∀bΦ:ℝ,0conj (S.W x)) + 2 (1/4) (9/4) bΦ 0 1 mesh (33/50) (33/50) 2 (stageError D) + (kappaPlain D) U η₀ (sourceFixedIdeal S) degree seminorms C + +theorem source_batch_plain_marked_fine {Δ:ℝ}{D:Parameters.HighData Δ} + (S:SourceData D)(mesh:ℝ)(hmesh:0(S.w x:ℂ))→B.widths=(fun s=>D.ell s/d)→ + (∀s,B.upper s=2)→(∀s,(B.external s).re=17/50)→ + ∀bin label left right,∀hne:(B.fiberRows bin label left right).Nonempty, + ∀height:ℝ,0≤height→(∀s,|(B.external s).im|≤height)→ + let F:=B.fiber bin label left right hne; + ∀selected:Finset (Fin D.N),selected⊆F.slots→ + 2*F.m+6*(3/4+2*Δ)*(∑s∈selected,F.widths s)≤1→ + ∀j k:ℕ,j+k≤2→∀σ∈Set.Icc (0:ℝ) 1,∀t∈Set.Icc (-height) height, + (∑u∈F.rows,‖polynomial (F.family u F.label) false ((logProfile^[j]) positiveAnnular) + ((Z^d)^F.m) σ t*polynomial (F.family u F.label) false ((logProfile^[k]) positiveAnnular) + ((Z^d)^F.m) σ t*F.physicalProduct selected u‖^2)≤ + (C*(1+height)^J)*(Z^d)^(1+D.t):=by + obtain ⟨bΦ,hbΦ,hsource⟩:=source_batch_marked_initial S + obtain ⟨degree,seminorms,henergy⟩:=henergy bΦ hbΦ + obtain ⟨J,Cprofile,hCprofile,hprofile⟩:= + CenteredMomentDetectorPlainProfileControl.source_height_factor seminorms + refine ⟨J+degree,?_⟩ + intro η + let data:=sourceMomentBase S.modulus ⊤ le_top S.S S.exclusions.prime η + choose C hC hbound using fun label=>henergy (data label) + choose U₀ hU₀ using fun label=>Filter.eventually_atTop.mp (hbound label) + let Csum:ℝ:=1+∑label,C label + have hCsum:0(hC label).le) + dsimp [Csum];linarith + have hClabel (label):C label≤Csum:=by + have h:=Finset.single_le_sum (fun label (_:label∈Finset.univ)=>(hC label).le) + (Finset.mem_univ label) + dsimp [Csum];linarith + have hscale:∀ᶠZ:ℝ in atTop,∀label,∀d:ℝ,(1/200:ℝ)≤d→U₀ label≤Z^d:=by + apply Filter.eventually_all.mpr + intro label + exact HeckeDetectorDyadicGeometry.uniform_scale_threshold (1/200) (U₀ label) (by norm_num) + let Cfinal:=Csum*(1+diagonalControl radialMajorant)*Cprofile + have hdiag:0≤diagonalControl radialMajorant:=diagonalControl_nonneg _ + refine ⟨Cfinal,by dsimp [Cfinal];positivity,?_⟩ + filter_upwards [hsource η (delta D) (fixed_parameters D).1,hscale] with Z hs hscale + refine ⟨hs.1,?_⟩ + intro rows hrows d hd a tstar T allowance i B hB hdata hprof hwidth hupper hreal + bin label left right hne height hheight hexternal F selected hselected hcap j k hjk σ hσ t ht + have hU:1mesh) hmesh hfine d hd s.val).2 + have hpos:=hU₀ label (Z^d) (hscale label d hd) selected (fun _=>1) + (fun s=>F.widths s.val) (fun _=>(33/50:ℝ)) (fun s=>-(F.external s.val).im) + 0 height hw hwcap (fun _=>le_rfl) (fun _=>le_rfl) hheight + (fun s=>by change |-(B.external s.val).im|≤height; simpa only [abs_neg] using hexternal s.val) + state hQ hstate (detectorProfiles F.reverse j k σ t) ((Z^d)^F.m) ((Z^d)^F.m) + (Real.rpow_pos_of_pos (zero_lt_one.trans hU) _) (Real.rpow_pos_of_pos (zero_lt_one.trans hU) _) + (by simpa only [Real.rpow_one] using hf.2.2.2.2.1) + (by simpa only [Real.rpow_one] using hf.2.2.2.2.1) hcapacity + have heq:=CenteredMomentDetectorPlainRelativeClass.energy_eq S.modulus ⊤ le_top + state.character (data label) (fun (_:selected)=>1) state.mask 1 + ((detectorProfiles F.reverse j k σ t).profile 0) + ((detectorProfiles F.reverse j k σ t).profile 1) + (fun _=>2) (fun s:selected=>(Z^d)^(F.widths s.val)) + (fun s I=>HeckePrimeAnnular.annularWeight (fun x=>conj (S.W x)) + ((Z^d)^(F.widths s.val)) (33/50) (-(F.external s.val).im) I) + 0 ((Z^d)^F.m) ((Z^d)^F.m) state.radial.keep state.radial.profile state.radial.scale + have hnorm:=hprofile degree F.reverse j k hjk σ hσ height t hheight (abs_le.mpr ht) + have hp:0≤(detectorProfiles F.reverse j k σ t).control seminorms ^2:=sq_nonneg _ + have hexp:state.width+stageError D≤1+D.t:=by + rw [hwidthstate];linarith [(fixed_parameters D).2.2.2.1] + calc + _≤_:=hrow j k σ t + _≤C label*diagonalControl state.radial.profile* + (detectorProfiles F.reverse j k σ t).control seminorms ^2* + (1+|(0:ℝ)|+height)^degree*(Z^d)^(state.width+stageError D):=by + exact heq.le.trans hpos + _≤(Cfinal*(1+height)^(J+degree))*(Z^d)^(1+D.t):=by + rw [hΦ] + have hpow:=Real.rpow_le_rpow_of_exponent_le hU.le hexp + calc + _=(C label*diagonalControl radialMajorant)* + ((detectorProfiles F.reverse j k σ t).control seminorms ^2* + (1+|(0:ℝ)|+height)^degree)*(Z^d)^(state.width+stageError D):=by ring + _≤(Csum*(1+diagonalControl radialMajorant))* + (Cprofile*(1+height)^(J+degree))*(Z^d)^(1+D.t):=by + apply mul_le_mul _ hpow (Real.rpow_nonneg (zero_lt_one.trans hU).le _) (by positivity) + apply mul_le_mul _ hnorm (by positivity) (by positivity) + exact mul_le_mul (hClabel label) (by linarith) hdiag hCsum.le + _=_:=by dsimp [Cfinal];ring +end SevenEighths.ProbeDetectorPlainMarkedFineField + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/DetectorPlainUnmarkedField.lean b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorPlainUnmarkedField.lean new file mode 100644 index 0000000000000000000000000000000000000000..77de8e43bb57052e2bbbb2fe5657100664121a39 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/DetectorPlainUnmarkedField.lean @@ -0,0 +1,174 @@ +import OAI.NumberTheory.DirichletL.Moments.DetectorPlainMomentParameters +import OAI.NumberTheory.DirichletL.Moments.DetectorPlainProfileControl +import OAI.NumberTheory.DirichletL.Hecke.DetectorDyadicGeometry + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +open Filter + +namespace SevenEighths.ProbeDetectorPlainUnmarkedField +open HeckeDyadic HeckeRowClosure HeckeInverseAmplification +open CenteredMomentDetectorPlainFiberSource +open HeckeFamily HeckeDetectorRawFiber HeckeDetectorBatch ProbeHighRowFamily +open HeckeDetectorRowwisePolynomial HeckeDetectorDyadicProfiles +open CenteredMomentDetectorDictionary CenteredMomentDetectorEnergyInitialState +open CenteredMomentDetectorPlainExceptional CenteredMomentDetectorPlainUnmarkedState +open CenteredMomentDetectorPlainMomentParameters CenteredMomentDetectorPlainProfileControl +open CenteredMomentEnergyState CenteredMomentEnergyBands CenteredMomentNaturalFixedRaySource +open QuadraticInitialBound +local notation "O" => HeckeFamily.O + +def radialSupportUpper : ℝ := Classical.choose radialMajorant_support_bound + +theorem radialSupportUpper_spec : 0(S.w x:ℂ))→B.widths=(fun s=>D.ell s/d)→ + ∀bin label left right,∀hne:(B.fiberRows bin label left right).Nonempty, + ∀height:ℝ,0≤height→∀j k:ℕ,j+k≤2→ + ∀σ∈Set.Icc (0:ℝ) 1,∀t∈Set.Icc (-height) height, + let F:=B.fiber bin label left right hne; + let value:=∑u∈F.rows,‖polynomial (F.family u F.label) false ((logProfile^[j]) positiveAnnular) + ((Z^d)^F.m) σ t*polynomial (F.family u F.label) false ((logProfile^[k]) positiveAnnular) + ((Z^d)^F.m) σ t‖^2; + value≤C*(1+height)^Jheight*(Z^d)^(max 1 (2*F.m)+D.t) ∧ + value≤C*(1+height)^Jheight*max (Z^d) (((Z^d)^F.m)^2)*(Z^d)^D.t := by + obtain ⟨degree,control,henergy⟩:=henergy + obtain ⟨Jheight,Cp,hCp,hprofiles⟩:=paired_control control + refine ⟨Jheight,?_⟩ + intro η + let :Fintype (Sum Bool (RayQuotient.Characters S.modulus ⊤)):=Fintype.ofFinite _ + let η₀:=fun label=>sourceMomentBase S.modulus ⊤ le_top S.S S.exclusions.prime η label + let Q:=fun label=>internalQ (sourceFixedIdeal S) (η₀ label) + choose A hA hzero using (fun label=>henergy (Q label)) + let Amax:ℝ:=1+∑label,A label + have hsum:0≤∑label,A label:=Finset.sum_nonneg (fun j _=>(hA j).le) + have hAmax:0(hA j).le) (Finset.mem_univ label) + dsimp [Amax];linarith + let C:=Amax*(1+diagonalControl radialMajorant)*Cp + have hdiag:0≤diagonalControl radialMajorant:=diagonalControl_nonneg _ + have hC:0 HeckeFamily.O + +open ProbeDetectorPlainUnmarkedField +variable {Δ:ℝ} + +theorem source_zero_from_gated (D:Parameters.HighData Δ) + (S:ProbeFinalAssembly.SourceData D) + (henergy:∃degree:ℕ,∃control:Finset (ℕ×ℕ),∀η₀:Character,∀Q:Ideal O, + Q≤S.modulus→internalQ Q η₀≠0→internalQ Q η₀≠⊤→ + internalQ Q η₀≤Ideal.span {(72:O)}→ + ∃A:ℝ,0(S.w x:ℂ))→B.widths=(fun s=>D.ell s/d)→ + ∀bin label left right,∀hne:(B.fiberRows bin label left right).Nonempty, + ∀height:ℝ,0≤height→∀j k:ℕ,j+k≤2→ + ∀σ∈Set.Icc (0:ℝ) 1,∀t∈Set.Icc (-height) height, + let F:=B.fiber bin label left right hne; + let value:=∑u∈F.rows,‖polynomial (F.family u F.label) false ((logProfile^[j]) positiveAnnular) + ((Z^d)^F.m) σ t*polynomial (F.family u F.label) false ((logProfile^[k]) positiveAnnular) + ((Z^d)^F.m) σ t‖^2; + value≤C*(1+height)^Jheight*(Z^d)^(max 1 (2*F.m)+D.t) ∧ + value≤C*(1+height)^Jheight*max (Z^d) (((Z^d)^F.m)^2)*(Z^d)^D.t := by + obtain ⟨degree,control,henergy⟩:=henergy + obtain ⟨Jheight,Cp,hCp,hprofiles⟩:=paired_control control + refine ⟨Jheight,?_⟩ + intro η + let :Fintype (Sum Bool (RayQuotient.Characters S.modulus ⊤)):=Fintype.ofFinite _ + let η₀:=fun label=>sourceMomentBase S.modulus ⊤ le_top S.S S.exclusions.prime η label + let Q:=fun label=>internalQ (sourceFixedIdeal S) (η₀ label) + choose A hA hzero using (fun label=>henergy (η₀ label)) + let Amax:ℝ:=1+∑label,A label + have hsum:0≤∑label,A label:=Finset.sum_nonneg (fun j _=>(hA j).le) + have hAmax:0(hA j).le) (Finset.mem_univ label) + dsimp [Amax];linarith + let C:=Amax*(1+diagonalControl radialMajorant)*Cp + have hdiag:0≤diagonalControl radialMajorant:=diagonalControl_nonneg _ + have hC:0 K * V ^ (m + a)) + (K * V ^ a * (1 - V)⁻¹) := by + convert hgeo.mul_left (K * V ^ a) using 1 + funext m + rw [pow_add] + ring + have hin := (hfirst.sub hsecond).tsum_eq + unfold markedTableSeries + rw [hin, tsum_mul_right, tsum_geometric_of_norm_lt_one hR] + unfold markedFactor + simp only [div_eq_mul_inv] + ring + +theorem unramified_marked_error (R V qInv K W D : ℂ) + (hR : 1 - R ≠ 0) (hV : 1 - V ≠ 0) : + markedFactor R V qInv K (-D + W * R) 1 + D = + (R * ((1 - qInv) + (1 - V) * (W - D)) - K * V) / + ((1 - R) * (1 - V)) := by + unfold markedFactor + field_simp + ring + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/EulerCoordinates.lean b/lean/OAI/NumberTheory/DirichletL/Detector/EulerCoordinates.lean new file mode 100644 index 0000000000000000000000000000000000000000..75a2a5a3801939489102d6e7cce2ef1cab479057 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/EulerCoordinates.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Detector.CorrectionBounds +import OAI.NumberTheory.DirichletL.Detector.Row + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss +local notation "O" => ActualEisensteinCubic.O + +def coordV (Q : ℝ) (z : ℂ) : ℂ := (Q : ℂ) ^ (-6*z) +def coordR (Q : ℝ) (A x z : ℂ) : ℂ := A * (Q : ℂ) ^ (4-6*x-6*z) +def coordW (Q : ℝ) (v w : ℂ) : ℂ := v * (Q : ℂ) ^ (-w) +def coordD (Q : ℝ) (eta v x : ℂ) : ℂ := eta * star v * (Q : ℂ) ^ (-x) +def coordK (Q : ℝ) (eta x w : ℂ) : ℂ := eta * (Q-1) * (Q : ℂ) ^ (-x-w) + +def unramifiedClosed (Q : ℝ) (A eta v x w z : ℂ) : ℂ := + let V := coordV Q z + let R := coordR Q A x z + let W := coordW Q v w + let D := coordD Q eta v x + let K := coordK Q eta x w + ProbeLocal.continuedCorrection V W D (markedFactor R V (Q:ℂ)⁻¹ K (-D+W*R) 1) + +def actualAPhase (eta : HeckeFamily.Character) (p : O) : ℂ := + star (FiniteGaussPhase.angularFactor p) ^ 6 * HeckeFamily.elementCoeff eta p ^ 6 + +def actualUnramifiedClosed (eta : HeckeFamily.Character) (p u : O) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : ConcretePrimeRowBridge.goodLambda ∉ Ideal.span {p}) (x w z : ℂ) : ℂ := + unramifiedClosed (Ideal.absNorm (Ideal.span {p})) (actualAPhase eta p) + (HeckeFamily.elementCoeff eta p) + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ u)) x w z + +lemma actualAPhase_norm_le_one (eta : HeckeFamily.Character) (p : O) : + ‖actualAPhase eta p‖ ≤ 1 := by + simp only [actualAPhase, norm_mul, norm_pow, norm_star] + exact (mul_le_of_le_one_left (by positivity) + (pow_le_one₀ (norm_nonneg _) (CompletedGauss.angularFactor_norm_le_one p))).trans + (pow_le_one₀ (norm_nonneg _) (ProbeRow.targetMonoid_norm_le_one eta p)) + +lemma coordV_norm (Q : ℝ) (hQ : 0 < Q) (z : ℂ) : + ‖coordV Q z‖ = Q ^ (-6*z.re) := by + rw [coordV, Complex.norm_cpow_eq_rpow_re_of_pos hQ] + simp + +lemma coordR_norm_le (Q : ℝ) (hQ : 0 < Q) (A x z : ℂ) (hA : ‖A‖ ≤ 1) : + ‖coordR Q A x z‖ ≤ Q ^ (4-6*x.re-6*z.re) := by + rw [coordR, norm_mul, Complex.norm_cpow_eq_rpow_re_of_pos hQ] + simp only [Complex.sub_re, Complex.mul_re, Complex.re_ofNat, Complex.im_ofNat, + zero_mul, sub_zero] + exact mul_le_of_le_one_left (Real.rpow_nonneg hQ.le _) hA + +lemma coordW_norm_le (Q : ℝ) (hQ : 0 < Q) (v w : ℂ) (hv : ‖v‖ ≤ 1) : + ‖coordW Q v w‖ ≤ Q ^ (-w.re) := by + rw [coordW, norm_mul, Complex.norm_cpow_eq_rpow_re_of_pos hQ, Complex.neg_re] + exact mul_le_of_le_one_left (Real.rpow_nonneg hQ.le _) hv + +lemma coordD_norm_le (Q : ℝ) (hQ : 0 < Q) (eta v x : ℂ) + (he : ‖eta‖ ≤ 1) (hv : ‖v‖ ≤ 1) : + ‖coordD Q eta v x‖ ≤ Q ^ (-x.re) := by + rw [coordD, norm_mul, Complex.norm_cpow_eq_rpow_re_of_pos hQ, Complex.neg_re] + apply mul_le_of_le_one_left (Real.rpow_nonneg hQ.le _) + rw [norm_mul, norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) he).trans hv + +lemma coordK_norm_le (Q : ℝ) (hQ : 1 ≤ Q) (eta x w : ℂ) (he : ‖eta‖ ≤ 1) : + ‖coordK Q eta x w‖ ≤ Q ^ (1-x.re-w.re) := by + have hQ0 : 0 < Q := lt_of_lt_of_le zero_lt_one hQ + have hsub : ‖(Q:ℂ)-1‖ = Q-1 := by + rw [← Complex.ofReal_one, ← Complex.ofReal_sub, Complex.norm_real, Real.norm_eq_abs, + abs_of_nonneg (sub_nonneg.mpr hQ)] + rw [coordK, norm_mul, norm_mul, hsub, Complex.norm_cpow_eq_rpow_re_of_pos hQ0] + have heq : (1-x.re-w.re) = 1 + (-x.re-w.re) := by ring + rw [heq, Real.rpow_add hQ0, Real.rpow_one] + simp only [Complex.sub_re, Complex.neg_re] + gcongr + calc ‖eta‖*(Q-1) ≤ 1*(Q-1) := mul_le_mul_of_nonneg_right he (sub_nonneg.mpr hQ) + _ ≤ Q := by linarith + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/EulerFinsupp.lean b/lean/OAI/NumberTheory/DirichletL/Detector/EulerFinsupp.lean new file mode 100644 index 0000000000000000000000000000000000000000..030d3b65215b63ed73fe046b66f671d2b6de1fe9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/EulerFinsupp.lean @@ -0,0 +1,107 @@ +import OAI.NumberTheory.DirichletL.Detector.IdealFactorization +import Mathlib.Analysis.Normed.Group.Tannery + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology +open Filter +namespace SevenEighths.ProbeEulerFinsupp + +lemma finitePi_fin {β : Type*} (n : ℕ) (f : Fin n→β→ℂ) + (hf : ∀ i,Summable (fun b=>‖f i b‖)) : + Summable (fun v : Fin n→β => ‖∏ i,f i (v i)‖) ∧ + (∑' v : Fin n→β,∏ i,f i (v i))=∏ i,∑' b,f i b := by + induction n with + | zero => + constructor + · exact (hasSum_fintype _).summable + · simp + | succ n ih => + have ht := ih (fun i=>f i.succ) (fun i=>hf i.succ) + let e := Fin.consEquiv (fun _ : Fin (n+1)=>β) + have he (v : β×(Fin n→β)) : + (∏ i,f i (e v i))=f 0 v.1*(∏ i,f i.succ (v.2 i)) := by + rw [Fin.prod_univ_succ] + rfl + constructor + · rw [←e.summable_iff] + simp only [Function.comp_def,he] + have hm : Summable (fun v : β×(Fin n→β)=>‖f 0 v.1‖ * ‖∏ i : Fin n,f i.succ (v.2 i)‖) := + (hf 0).mul_of_nonneg ht.1 (fun _=>norm_nonneg _) (fun _=>norm_nonneg _) + simpa only [norm_mul] using hm + · rw [←e.tsum_eq (fun v=>∏ i,f i (v i))] + simp only [he] + rw [←tsum_mul_tsum_of_summable_norm (f:=f 0) + (g:=fun v : Fin n→β=>∏ i : Fin n,f i.succ (v i)) (hf 0) ht.1,ht.2,Fin.prod_univ_succ] + +lemma finitePi {α β : Type*} [Fintype α] (f : α→β→ℂ) + (hf : ∀ i,Summable (fun b=>‖f i b‖)) : + Summable (fun v : α→β => ‖∏ i,f i (v i)‖) ∧ + (∑' v : α→β,∏ i,f i (v i))=∏ i,∑' b,f i b := by + let e := Fintype.equivFin α + let d := Equiv.arrowCongr e.symm (Equiv.refl β) + have h := finitePi_fin (Fintype.card α) (fun i=>f (e.symm i)) (fun i=>hf (e.symm i)) + have hd (v : Fin (Fintype.card α)→β) : + (∏ i,f i (d v i))=∏ j,f (e.symm j) (v j) := by + apply Fintype.prod_equiv e + intro i + simp only [d,Equiv.arrowCongr_apply,Equiv.symm_symm,Equiv.refl_apply,e.symm_apply_apply,Function.comp_apply] + constructor + · rw [←d.summable_iff] + simpa only [Function.comp_def,hd] using h.1 + · rw [←d.tsum_eq (fun v=>∏ i,f i (v i))] + simp only [hd] + rw [h.2] + exact e.symm.prod_comp (fun i=>∑' b,f i b) + +variable {α β : Type*} [AddCommMonoid β] + +lemma finiteEuler (f : α→β→ℂ) (h0 : ∀a,f a 0=1) + (hf : ∀a,Summable (fun b=>‖f a b‖)) (S : Finset α) : + (∑' v : {v : α→₀β // (v.support:Set α)⊆S},v.val.prod f)= + ∏ a∈S,∑' b,f a b := by + let e : {v : α→₀β // (v.support:Set α)⊆S} ≃ (S→β) := + (Finsupp.restrictSupportEquiv (S:Set α) β).trans Finsupp.equivFunOnFinite + have he (v : {v : α→₀β // (v.support:Set α)⊆S}) : + v.val.prod f=∏ a:S,f a.val (e v a) := by + rw [←Finsupp.prod_subtypeDomain_index (p:=fun a=>a∈S) (fun a ha=>v.property ha)] + exact Finsupp.prod_fintype _ _ (fun a=>h0 a.val) + simp_rw [he] + rw [e.tsum_eq (fun v : S→β=>∏ a:S,f a.val (v a))] + rw [(finitePi (fun a:S=>f a.val) (fun a=>hf a.val)).2] + exact Finset.prod_coe_sort S (fun a=>∑' b,f a b) + +theorem hasProd_of_summable (f : α→β→ℂ) (h0 : ∀a,f a 0=1) + (hs : Summable (fun v : α→₀β=>‖v.prod f‖)) : + HasProd (fun a=>∑' b,f a b) (∑' v : α→₀β,v.prod f) := by + have hf (a : α) : Summable (fun b=>‖f a b‖) := by + have hh := hs.comp_injective (Finsupp.single_injective a) + simpa only [Function.comp_def,Finsupp.prod_single_index (h0 a)] using hh + have ht : Tendsto (fun S : Finset α=>∑' v : α→₀β, + if v.support⊆S then v.prod f else 0) atTop (𝓝 (∑' v : α→₀β,v.prod f)) := by + apply tendsto_tsum_of_dominated_convergence hs + · intro v + apply tendsto_const_nhds.congr' + filter_upwards [eventually_ge_atTop v.support] with S hS + simp only [ite_eq_left hS] + · apply Filter.Eventually.of_forall + intro S v + split_ifs + · exact le_rfl + · simpa only [norm_zero] using norm_nonneg (v.prod f) + have he (S : Finset α) : (∑' v : α→₀β,if v.support⊆S then v.prod f else 0)= + ∏a∈S,∑' b,f a b := by + rw [←finiteEuler f h0 hf S] + trans ∑' v : α→₀β, {v : α→₀β | (v.support:Set α)⊆S}.indicator (fun v=>v.prod f) v + · apply tsum_congr + intro v + simp only [Set.indicator,Set.mem_ofPred_eq,Finset.coe_subset] + · exact (tsum_subtype {v : α→₀β | (v.support:Set α)⊆S} (fun v=>v.prod f)).symm + change Tendsto (fun S : Finset α=>∏a∈S,∑' b,f a b) atTop _ + simpa only [he] using ht + +end SevenEighths.ProbeEulerFinsupp +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/EulerHolomorphic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/EulerHolomorphic.lean new file mode 100644 index 0000000000000000000000000000000000000000..c50f9e8956eb5347ff91538292911c3b2554ee2d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/EulerHolomorphic.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Detector.EulerRegion + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +lemma coordR_differentiable (Q : ℝ) (hQ : 0 < Q) (A z : ℂ) : + Differentiable ℂ (fun x : ℂ => coordR Q A x z) := by + unfold coordR + have hn : (Q:ℂ) ≠ 0 := by exact_mod_cast hQ.ne' + exact (((differentiable_const (4:ℂ)).sub (differentiable_id.const_mul 6)).sub_const (6*z)).const_cpow + (Or.inl hn) |>.const_mul A + +lemma coordD_differentiable (Q : ℝ) (hQ : 0 < Q) (eta v : ℂ) : + Differentiable ℂ (fun x : ℂ => coordD Q eta v x) := by + unfold coordD + have hn : (Q:ℂ) ≠ 0 := by exact_mod_cast hQ.ne' + exact (differentiable_id.neg.const_cpow (Or.inl hn)).const_mul (eta*star v) + +lemma coordK_differentiable (Q : ℝ) (hQ : 0 < Q) (eta w : ℂ) : + Differentiable ℂ (fun x : ℂ => coordK Q eta x w) := by + unfold coordK + have hn : (Q:ℂ) ≠ 0 := by exact_mod_cast hQ.ne' + exact ((differentiable_id.neg.sub_const w).const_cpow (Or.inl hn)).const_mul (eta*(Q-1)) + +lemma unramifiedClosed_differentiableAt (Q : ℝ) (hQ : 0 < Q) (A eta v x w z : ℂ) + (hR : 1-coordR Q A x z ≠ 0) (_hV : 1-coordV Q z ≠ 0) + (hD : 1-coordD Q eta v x ≠ 0) : + DifferentiableAt ℂ (fun s : ℂ => unramifiedClosed Q A eta v s w z) x := by + have hr := coordR_differentiable Q hQ A z + have hd := coordD_differentiable Q hQ eta v + have hk := coordK_differentiable Q hQ eta w + have hp : DifferentiableAt ℂ (fun s : ℂ => + markedFactor (coordR Q A s z) (coordV Q z) (Q:ℂ)⁻¹ + (coordK Q eta s w) (-coordD Q eta v s + coordW Q v w*coordR Q A s z) 1) x := by + unfold markedFactor + fun_prop (disch := assumption) + unfold unramifiedClosed ProbeLocal.continuedCorrection + dsimp only + fun_prop (disch := assumption) + +theorem principalClosed_analytic (Q : ℝ) (hQ : 4 ≤ Q) (A eta : ℂ) + (hA : ‖A‖ ≤ 1) (heta : ‖eta‖ ≤ 1) : + AnalyticOnNhd ℂ (fun s : ℂ => unramifiedClosed Q A eta 1 s 1 (1/6)) + {s : ℂ | 7/8 < s.re} := by + have hQ0 : 0 < Q := by linarith + have hQ1 : 1 ≤ Q := by linarith + have hv : 1-coordV Q (1/6) ≠ 0 := by + apply ProbeLocal.one_sub_ne_zero_of_norm_le_half + rw [coordV_norm Q hQ0] + apply rpow_le_half Q _ hQ + norm_num + have hdif : DifferentiableOn ℂ (fun s : ℂ => unramifiedClosed Q A eta 1 s 1 (1/6)) + {s : ℂ | 7/8 < s.re} := by + intro s hs + apply (unramifiedClosed_differentiableAt Q hQ0 A eta 1 s 1 (1/6) ?_ hv ?_).differentiableWithinAt + · apply ProbeLocal.one_sub_ne_zero_of_norm_le_half + apply (coordR_norm_le Q hQ0 A s (1/6) hA).trans + apply rpow_le_half Q _ hQ + norm_num + change (7/8:ℝ) < s.re at hs + linarith + · apply ProbeLocal.one_sub_ne_zero_of_norm_le_half + apply (coordD_norm_le Q hQ0 eta 1 s heta (by simp)).trans + apply rpow_le_half Q _ hQ + change (7/8:ℝ) < s.re at hs + linarith + exact hdif.analyticOnNhd (isOpen_lt continuous_const Complex.continuous_re) + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/EulerMarked.lean b/lean/OAI/NumberTheory/DirichletL/Detector/EulerMarked.lean new file mode 100644 index 0000000000000000000000000000000000000000..3ac8976d0ad5882688dedfad239efd4283df3e1e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/EulerMarked.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Detector.EulerFinsupp + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology +open Filter +namespace SevenEighths.ProbeEulerFinsupp +variable {α β : Type*} [AddCommMonoid β] + +def markedArray (T : Finset α) (m f : α→β→ℂ) (v : α→₀β) : ℂ := + (∏a∈T,m a (v a))*v.prod f + +def markedLocal (T : Finset α) (m f : α→β→ℂ) (a : α) (b : β) : ℂ := + (if a∈T then m a b else 1)*f a b + +lemma markedArray_finite (T S : Finset α) (hTS : T⊆S) (m f : α→β→ℂ) + (h0 : ∀a,f a 0=1) (v : α→₀β) (hv : v.support⊆S) : + markedArray T m f v=∏a∈S,markedLocal T m f a (v a) := by + simp only [markedArray,markedLocal,Finset.prod_mul_distrib] + congr 1 + · symm + rw [←Finset.prod_subset hTS] + · apply Finset.prod_congr rfl + intro a ha + simp only [ite_eq_left ha] + · intro a ha hna + simp only [ite_eq_right hna] + · exact Finsupp.prod_of_support_subset v hv _ (fun a _=>h0 a) + +lemma markedArray_norm_le (T : Finset α) (m f : α→β→ℂ) + (hm : ∀a∈T,∀b,‖m a b‖≤1) (v : α→₀β) : + ‖markedArray T m f v‖≤‖v.prod f‖ := by + rw [markedArray,norm_mul] + apply mul_le_of_le_one_left (norm_nonneg _) + rw [norm_prod] + exact Finset.prod_le_one₀ (fun _ _=>norm_nonneg _) (fun a ha=>hm a ha _) + +lemma marked_finiteEuler (T S : Finset α) (hTS : T⊆S) (m f : α→β→ℂ) + (h0 : ∀a,f a 0=1) (hf : ∀a,Summable (fun b=>‖f a b‖)) + (hm : ∀a∈T,∀b,‖m a b‖≤1) : + (∑'v : {v : α→₀β // (v.support:Set α)⊆S},markedArray T m f v.val)= + ∏a∈S,∑'b,markedLocal T m f a b := by + let e : {v : α→₀β // (v.support:Set α)⊆S} ≃ (S→β) := + (Finsupp.restrictSupportEquiv (S:Set α) β).trans Finsupp.equivFunOnFinite + have he (v : {v : α→₀β // (v.support:Set α)⊆S}) : + markedArray T m f v.val=∏a:S,markedLocal T m f a.val (e v a) := by + rw [markedArray_finite T S hTS m f h0 v.val v.property] + exact (Finset.prod_coe_sort S _).symm + have hg (a : α) : Summable (fun b=>‖markedLocal T m f a b‖) := by + apply Summable.of_nonneg_of_le (fun _=>norm_nonneg _) _ (hf a) + intro b + rw [markedLocal,norm_mul] + apply mul_le_of_le_one_left (norm_nonneg _) + split_ifs with ha + · exact hm a ha b + · simp + simp_rw [he] + rw [e.tsum_eq (fun v : S→β=>∏a:S,markedLocal T m f a.val (v a))] + rw [(finitePi (fun a:S=>markedLocal T m f a.val) (fun a=>hg a.val)).2] + exact Finset.prod_coe_sort S (fun a=>∑'b,markedLocal T m f a b) + +theorem marked_hasProd (T : Finset α) (m f : α→β→ℂ) (h0 : ∀a,f a 0=1) + (hs : Summable (fun v : α→₀β=>‖v.prod f‖)) + (hm : ∀a∈T,∀b,‖m a b‖≤1) : + HasProd (fun a=>∑'b,markedLocal T m f a b) (∑'v : α→₀β,markedArray T m f v) := by + have hf (a : α) : Summable (fun b=>‖f a b‖) := by + have hh := hs.comp_injective (Finsupp.single_injective a) + simpa only [Function.comp_def,Finsupp.prod_single_index (h0 a)] using hh + have ht : Tendsto (fun S : Finset α=>∑'v : α→₀β, + if v.support⊆S then markedArray T m f v else 0) atTop + (𝓝 (∑'v : α→₀β,markedArray T m f v)) := by + apply tendsto_tsum_of_dominated_convergence hs + · intro v + apply tendsto_const_nhds.congr' + filter_upwards [eventually_ge_atTop v.support] with S hS + simp only [ite_eq_left hS] + · apply Filter.Eventually.of_forall + intro S v + split_ifs + · exact markedArray_norm_le T m f hm v + · simpa only [norm_zero] using norm_nonneg (v.prod f) + change Tendsto (fun S : Finset α=>∏a∈S,∑'b,markedLocal T m f a b) atTop _ + apply ht.congr' + filter_upwards [eventually_ge_atTop T] with S hTS + rw [←marked_finiteEuler T S hTS m f h0 hf hm] + trans ∑'v : α→₀β,{v : α→₀β | (v.support:Set α)⊆S}.indicator (markedArray T m f) v + · apply tsum_congr + intro v + simp only [Set.indicator,Set.mem_ofPred_eq,Finset.coe_subset] + · exact (tsum_subtype {v : α→₀β | (v.support:Set α)⊆S} (markedArray T m f)).symm + +end SevenEighths.ProbeEulerFinsupp +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/EulerRegion.lean b/lean/OAI/NumberTheory/DirichletL/Detector/EulerRegion.lean new file mode 100644 index 0000000000000000000000000000000000000000..55553d59b482e72288b5350253617460af526209 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/EulerRegion.lean @@ -0,0 +1,82 @@ +import OAI.NumberTheory.DirichletL.Detector.EulerCoordinates + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +lemma rpow_le_half (Q a : ℝ) (hQ : 4 ≤ Q) (ha : a ≤ -(1/2)) : Q^a ≤ 1/2 := by + have hQ0 : 0 < Q := by linarith + have hs : 0 < Real.sqrt Q := Real.sqrt_pos.mpr hQ0 + have hs2 := Real.sq_sqrt hQ0.le + calc + Q^a ≤ Q^(-(1/2:ℝ)) := Real.rpow_le_rpow_of_exponent_le (by linarith) ha + _ = (Real.sqrt Q)⁻¹ := by rw [Real.rpow_neg hQ0.le, ← Real.sqrt_eq_rpow] + _ ≤ 1/2 := by rw [← one_div, div_le_iff₀ hs]; nlinarith [Real.sqrt_nonneg Q] + +theorem unramifiedClosed_second_region_bound (Q : ℝ) (A eta v x w z : ℂ) + (hQ : 4 ≤ Q) (hA : ‖A‖ ≤ 1) (heta : ‖eta‖ ≤ 1) (hv : ‖v‖ ≤ 1) + (hx : (7/8:ℝ) ≤ x.re) (hw : (19/20:ℝ) ≤ w.re) (hz : (33/200:ℝ) ≤ z.re) : + ‖unramifiedClosed Q A eta v x w z - 1‖ ≤ 240 * Q ^ (-(363/200:ℝ)) := by + have hQ0 : 0 < Q := by linarith + have hQ1 : 1 ≤ Q := by linarith + let V := coordV Q z + let R := coordR Q A x z + let W := coordW Q v w + let D := coordD Q eta v x + let K := coordK Q eta x w + have hV : ‖V‖ ≤ Q ^ (-(99/100:ℝ)) := by + rw [show V = coordV Q z from rfl, coordV_norm Q hQ0] + exact Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith) + have hR : ‖R‖ ≤ Q ^ (-(56/25:ℝ)) := + (coordR_norm_le Q hQ0 A x z hA).trans (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith)) + have hW : ‖W‖ ≤ Q ^ (-(19/20:ℝ)) := + (coordW_norm_le Q hQ0 v w hv).trans (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith)) + have hD : ‖D‖ ≤ Q ^ (-(7/8:ℝ)) := + (coordD_norm_le Q hQ0 eta v x heta hv).trans (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith)) + have hK : ‖K‖ ≤ Q ^ (-(33/40:ℝ)) := + (coordK_norm_le Q hQ1 eta x w heta).trans (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith)) + have hVh : ‖V‖ ≤ 1/2 := hV.trans (rpow_le_half Q _ hQ (by norm_num)) + have hRh : ‖R‖ ≤ 1/2 := hR.trans (rpow_le_half Q _ hQ (by norm_num)) + have hDh : ‖D‖ ≤ 1/2 := hD.trans (rpow_le_half Q _ hQ (by norm_num)) + have hWh : ‖W‖ ≤ 1 := by + exact hW.trans ((Real.rpow_le_rpow_of_exponent_le hQ1 (by norm_num : -(19/20:ℝ) ≤ 0)).trans_eq (Real.rpow_zero Q)) + have hqi : ‖(Q:ℂ)⁻¹‖ ≤ 1 := by + rw [norm_inv, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hQ0, ← one_div] + exact (div_le_one hQ0).mpr hQ1 + let T := Q ^ (-(363/200:ℝ)) + have hT : 0 ≤ T := Real.rpow_nonneg hQ0.le _ + have hRT : ‖R‖ ≤ T := hR.trans (Real.rpow_le_rpow_of_exponent_le hQ1 (by norm_num)) + have hprod (a b a' b' : ℝ) (ha : 0 ≤ a) (hb : 0 ≤ b) + (haa : a ≤ Q^a') (hbb : b ≤ Q^b') (he : a'+b' ≤ -(363/200:ℝ)) : a*b ≤ T := by + calc + a*b ≤ Q^a' * Q^b' := mul_le_mul haa hbb hb (Real.rpow_nonneg hQ0.le _) + _ = Q^(a'+b') := (Real.rpow_add hQ0 _ _).symm + _ ≤ T := Real.rpow_le_rpow_of_exponent_le hQ1 he + have hKV : ‖K‖*‖V‖ ≤ T := hprod _ _ _ _ (norm_nonneg _) (norm_nonneg _) hK hV (by norm_num) + have hDV : ‖D‖*‖V‖ ≤ T := hprod _ _ _ _ (norm_nonneg _) (norm_nonneg _) hD hV (by norm_num) + have hDW : ‖D‖*‖W‖ ≤ T := hprod _ _ _ _ (norm_nonneg _) (norm_nonneg _) hD hW (by norm_num) + have hVW : ‖V‖*‖W‖ ≤ T := hprod _ _ _ _ (norm_nonneg _) (norm_nonneg _) hV hW (by norm_num) + have hDVW : ‖D‖*‖V‖*‖W‖ ≤ T := + (mul_le_of_le_one_right (mul_nonneg (norm_nonneg _) (norm_nonneg _)) hWh).trans hDV + let P := markedFactor R V (Q:ℂ)⁻¹ K (-D+W*R) 1 + have hE : ‖P+D‖ ≤ 28*T := by + have h := ProbeLocal.unramified_marked_error_bound R V (Q:ℂ)⁻¹ K W D hRh hVh hqi hDh + have hrw : ‖R‖*(1+‖W‖) ≤ 2*T := by + calc + _ ≤ ‖R‖*2 := mul_le_mul_of_nonneg_left (by linarith) (norm_nonneg _) + _ ≤ _ := by nlinarith + dsimp only [P] + nlinarith + have h := ProbeLocal.continuedCorrection_defect_bound V W D P hVh hDh + change ‖ProbeLocal.continuedCorrection V W D P-1‖ ≤ 240*T + have hWE : (1+‖W‖)*‖P+D‖ ≤ 56*T := by + calc + _ ≤ 2*(28*T) := mul_le_mul (by linarith) hE (norm_nonneg _) (by norm_num) + _ = _ := by ring + nlinarith + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssembly.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssembly.lean new file mode 100644 index 0000000000000000000000000000000000000000..8a9c9cf57cdff8eae4285f22fe174968262d2fa9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssembly.lean @@ -0,0 +1,53 @@ +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyFixedHigh + +namespace OAI + +noncomputable section +open scoped Classical +open Filter +namespace SevenEighths.ProbeFinalAssembly +open HeckeFamily ProbePhysical ProbeHighRowFamily Parameters PrincipalSignalComparison + +theorem common_probe_of_raw_moments (hmom : RawMomentInput) : HeckeCommonProbe.UniformCommonProbe := by + intro hβ + have hgap : 0 HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_nonfloor_cube_arithmetic (N n : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss : ℝ) + (he : 0Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + ∀t : HeightSpace,((|t.1.1|≤(3*i+1:ℕ)*Z^τ ∧ |t.2|≤(3*i+1:ℕ)*Z^τ) ∧ |t.1.2|≤(3*i+1:ℕ)*Z^τ) → + SourceMomentsAt M H hH S hS.prime η rows ell W Z d a ε τ dmax b R mesh i + ((17/50:ℂ)+t.1.2*Complex.I) Δ + (if 2*a-1≤5/6 then counts.cB else counts.cH) (if 2*a-1≤5/6 then counts.kB else counts.kH) + (C0*Z^momentCost) (Z^heightCost) εm → + ‖cubeArithmeticSum S hS hmax η rows T (nonfloorPoolOutside M H S N c b Y) W Y a e t‖≤ + C*C0*(η.modulus.absNorm:ℝ)^(2*eps)* + Z^(3/16+Δ-saving-((25/48)*a-181/300+(105/8)*e)) := by + obtain ⟨C,hC,hclass⟩ := + actual_nonfloor_class_from_raw_moments M H hH N n e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss + he he1 heps hc hcb hA hR hdmin hdmax hdRange hrmin hτ hε hκ hcost hmesh + hbudget hgap hmargin hheight hloss S hS hfirst hmax ell hell hello hellhi W hWs hW hWB hellsum + hdtop hε1 hκ1 hτzero hτheight hwbudget + φ hφ hφc hφp hφ0 hφne a₀ b₀ B₀ ha₀ hab₀ hB₀ hφs hφB + εm Δ ν logCost heightCost momentCost hεm hΔ hΔ1 hν hlog hMomentHeight counts + let cardCost : ℝ := (HeckeDetectorClassBudget.alphabetBound mesh:ℝ)^N + have hcardCost : 0≤cardCost := by dsimp [cardCost];positivity + refine ⟨(cardCost+1)*C,by positivity,?_⟩ + intro η + filter_upwards [hclass η,eventually_gt_atTop (1:ℝ)] with Z hclass hZ + intro d hd hd' v a C0 hv hv' hdv ha ha' hC0 rows hrows hnorm i hi hnext hcurrent + dsimp only + intro t ht hmom + let z : ℂ := (17/50:ℂ)+t.1.2*Complex.I + let Y : Fin N→ℝ := fun j=>Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + let Q := physical M H (fun u : FreeRow=>u.val) W (fun _=>b) (fun j=>ell j/d) (fun _=>z) (Z^d) + let bound : ℝ := C*C0*(η.modulus.absNorm:ℝ)^(2*eps)* + Z^(3/16+Δ-saving-((25/48)*a-181/300+(105/8)*e)) + have hb : 0≤bound := by dsimp [bound];positivity + have hpart := cubeArithmeticSum_class_uniform S hS hmax η rows T + (nonfloorPoolOutside M H S N c b Y) W Y a e t Finset.univ (Z^d) ((2*a-1)/2) mesh hmesh + (by linarith) (fun j=>ell j/d) Q bound hb (by + intro bin hne + have hp := hclass d hd hd' v a C0 hv ha ha' hC0 rows hrows hnorm i hi hnext hcurrent t ht hmom bin hne + dsimp only at hp + let q := classMean Finset.univ ((2*a-1)/2) mesh (fun j=>ell j/d) bin + have hs := adaptive_mixed_saving N a q Δ ε εm R ν ζ μ v d e eps loss mesh + (logCost+heightCost+momentCost) saving (by linarith) ha' hp.1 hp.2.1 hΔ hΔ1 hε.le hεm.le + hR hν.le hcount hζ hζ1 hv' hμ hdv he.le heps.le hfinal + have hid := central_class_exponent_identity N a v d + (adaptiveRowExponent (2*a-1) q Δ ε εm R ν) q e eps loss mesh (logCost+heightCost+momentCost) + apply hp.2.2.trans + apply mul_le_mul_of_nonneg_left _ (by positivity) + apply Real.rpow_le_rpow_of_exponent_le hZ.le + linarith) + simp only [Finset.card_univ,Fintype.card_fin] at hpart + calc + _ ≤ cardCost*bound := hpart + _ ≤ (cardCost+1)*bound := mul_le_mul_of_nonneg_right (by linarith) hb + _ = _ := by dsimp [bound];ring + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCertifiedBands.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCertifiedBands.lean new file mode 100644 index 0000000000000000000000000000000000000000..8c7337e8f0755ba24fddab46a6630d58a32a9c86 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCertifiedBands.lean @@ -0,0 +1,163 @@ +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyChosenData +import OAI.NumberTheory.DirichletL.Detector.DetectorInverseFields +import OAI.NumberTheory.DirichletL.Detector.DetectorPlainMarkedFineField +import OAI.NumberTheory.DirichletL.Detector.DetectorPlainUnmarkedRestrictedField +import OAI.NumberTheory.DirichletL.Energy.CappedWidthInduction + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ComplexConjugate +open Filter + +namespace SevenEighths.ProbeFinalAssemblyCertifiedBands +open HeckeFamily HeckeDyadic HeckeInverseAmplification HeckeDetectorRawFiber HeckeDetectorBatch +open ProbeFinalAssembly ProbeHighRowFamily Parameters +open CenteredMomentEnergyBands CenteredMomentEnergyState +open CenteredMomentEnergyCappedWidthInduction CenteredMomentEnergyWidthRanges +open CenteredMomentEnergyWidthSchedule CenteredMomentDetectorPlainMomentParameters +open CenteredMomentDetectorEnergyInitialState CenteredMomentNaturalFixedRaySource +open ProbeDetectorPlainMarkedFineField ProbeDetectorPlainUnmarkedField +local notation "O"=>HeckeFamily.O + +def detectorMesh (Δ t:ℝ):ℝ:=fineMesh 2 0 1 (3/4+2*Δ) (t/4) + +lemma detectorMesh_pos {Δ t:ℝ}(hΔ:0<Δ)(ht:0conj (F.W x)) + 2 (1/4) (9/4) bΦ 0 1 (33/50) (33/50) 2 (kappaPlain D) (stageError D) + (count 2 (stageError D)) + +theorem plain_inputs {Δ:ℝ}{D:HighData Δ}(F:SourceData D) + (hcert:∀bΦ:ℝ,0conj (F.W x)) 2 (1/4) (9/4) bΦ 0 1 (33/50) (33/50) 2 + (kappaPlain D) (stageError D) (count 2 (stageError D))): + PositiveFineSourceInput F (detectorMesh Δ D.t) ∧ + (∃degree:ℕ,∃control:Finset (ℕ×ℕ),∀η₀:Character,∃A:ℝ,0conj (F.W x)) + 2 (1/4) (9/4) bΦ 0 1 (33/50) (33/50) 2 (kappaPlain D) (stageError D) + (by norm_num) (by norm_num) hp.2.2.2.2.2.le hp.2.2.1 (hcert bΦ hbΦ) + have hactual (bΦ:ℝ)(hbΦ:0conj (F.W x)) + 2 (1/4) (9/4) bΦ 0 1 (detectorMesh Δ D.t) (33/50) (33/50) 2 + (stageError D) (kappaPlain D) U η₀ (sourceFixedIdeal F) degree control Cpositive:=by + obtain ⟨degree,control,hbound⟩:=ht bΦ hbΦ + refine ⟨degree,control,?_⟩ + intro η₀ + obtain ⟨Cz,Cp,hCz,hCp,hbound⟩:=hbound η₀ (sourceFixedIdeal F) + (sourceFixedIdeal_le_modulus F) (source_fixed_gates F η₀).1 + (internalQ_ne_top _ (sourceFixedIdeal_ne_top F) η₀) (source_fixed_gates F η₀).2.2.2 + exact ⟨Cz,Cp,hCz,hCp,hbound.mono (fun U h=>⟨h.2.1,h.2.2⟩)⟩ + constructor + · intro bΦ hbΦ + obtain ⟨degree,control,h⟩:=hactual bΦ hbΦ + refine ⟨degree,control,?_⟩ + intro η₀ + obtain ⟨Cz,Cp,hCz,hCp,h⟩:=h η₀ + exact ⟨Cp,hCp,h.mono (fun U h=>h.2)⟩ + · obtain ⟨degree,control,h⟩:=hactual radialSupportUpper radialSupportUpper_spec.1 + refine ⟨degree,control,?_⟩ + intro η₀ + obtain ⟨Cz,Cp,hCz,hCp,h⟩:=h η₀ + exact ⟨Cz,hCz,h.mono (fun U h=>h.1)⟩ + +theorem source_moments {Δ:ℝ}{D:HighData Δ}(F:SourceData D) + (counts:CountParameters F.modulus ⊤ D.t)(mesh:ℝ)(hmesh:0(hrows u hu).2.1 + have hext:∀s,(B.external s).re=17/50:=by intro s;rw [hexternal];exact hz + have hheight:∀s,|(B.external s).im|≤height:=by intro s;rw [hexternal];exact hzim + have hinv:=hi.2 d hd a D.ε _ _ _ i B hdata hprofile hupper hwidth hext + bin label left right hne height hh + have hmarked:=hm.2 rows hrows' d hd a _ _ _ i B hB hdata hprofile hwidth + (fun s=>by rw [hupper]) hext bin label left right hne height hh hheight + have hunmarked:=hu.2 rows hrows' d hd a _ _ _ i B hB hdata hprofile hwidth + bin label left right hne height hh + have hU:0≤Z^d:=Real.rpow_nonneg hZ.le _ + constructor + · intro n hn σ hσ t ht + exact ⟨rawMoment_mono_constant (hinv.1 n hn σ hσ t ht).1 hCi', + rawMoment_mono_constant (hinv.1 n hn σ hσ t ht).2 hCi'⟩ + · intro selected hselected hfirst hsecond n hn σ hσ t ht + exact (hinv.2 selected hselected hfirst hsecond n hn σ hσ t ht).trans + (mul_le_mul_of_nonneg_right hCi' (Real.rpow_nonneg hU _)) + · intro selected hselected hcap j k hjk σ hσ t ht + exact (hmarked selected hselected hcap j k hjk σ hσ t ht).trans + (mul_le_mul_of_nonneg_right hCm' (Real.rpow_nonneg hU _)) + · intro j k hjk σ hσ t ht + exact (hunmarked j k hjk σ hσ t ht).1.trans + (mul_le_mul_of_nonneg_right hCu' (Real.rpow_nonneg hU _)) + +theorem fine_moments_of_certified (h:DetectorCertifiedBands):FineMomentInput:=by + intro hβ + let Δ:=HeckeZeroSupremum.beta-7/8 + have hΔ:0<Δ:=by dsimp [Δ];linarith + refine ⟨detectorMesh Δ,fun t ht=>detectorMesh_pos hΔ ht,?_⟩ + intro D hfine F counts + obtain ⟨hp,hz⟩:=plain_inputs F (h hβ D hfine F) + exact source_moments F counts (detectorMesh Δ D.t) (detectorMesh_pos hΔ D.t_pos) hfine hp hz + +theorem chosen_moments_of_certified (h:DetectorCertifiedBands):ChosenMomentInput:= + chosen_input_of_fine (fine_moments_of_certified h) + +theorem dirichlet_of_certified (h:DetectorCertifiedBands)(q:ℕ)(hq:q≠0) + (χ:DirichletCharacter ℂ q)(s:ℂ)(hs:(7/8:ℝ) HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_nonfloor_class_from_raw_moments (N n : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss : ℝ) + (he : 0Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + ∀t : HeightSpace,((|t.1.1|≤(3*i+1:ℕ)*Z^τ ∧ |t.2|≤(3*i+1:ℕ)*Z^τ) ∧ |t.1.2|≤(3*i+1:ℕ)*Z^τ) → + let z : ℂ := (17/50:ℂ)+t.1.2*Complex.I + SourceMomentsAt M H hH S hS.prime η rows ell W Z d a ε τ dmax b R mesh i z Δ + (if 2*a-1≤5/6 then counts.cB else counts.cH) (if 2*a-1≤5/6 then counts.kB else counts.kH) + (C0*Z^momentCost) (Z^heightCost) εm → + let Q := physical M H (fun u : FreeRow=>u.val) W (fun _=>b) (fun j=>ell j/d) (fun _=>z) (Z^d) + ∀bin : BinLabel (Finset.univ : Finset (Fin N)) ((2*a-1)/2) mesh, + let rows' := amplitudeRows rows Finset.univ (Z^d) ((2*a-1)/2) mesh hmesh (fun j=>ell j/d) Q bin + let q := classMean Finset.univ ((2*a-1)/2) mesh (fun j=>ell j/d) bin + rows'.Nonempty → 0≤q ∧ q≤(2*a-1)/2 ∧ + ‖cubeArithmeticSum S hS hmax η rows' T (nonfloorPoolOutside M H S N c b Y) W Y a e t‖≤ + C*C0*(η.modulus.absNorm:ℝ)^(2*eps)* + Z^(logCost+heightCost+momentCost+ + d*adaptiveRowExponent (2*a-1) q Δ ε εm R ν+ + v*(a-1/2+12*e+eps*(N+8)-17/50)+loss-2/75+q/6+mesh/6) := by + have hdmax0 : 0u.val) W (fun _=>b) (fun j=>ell j/d) (fun _=>z) (Z^d) + let rows' := amplitudeRows rows Finset.univ (Z^d) ((2*a-1)/2) mesh hmesh (fun j=>ell j/d) Q bin + let q := classMean Finset.univ ((2*a-1)/2) mesh (fun j=>ell j/d) bin + have hsub : rows'⊆rows := Finset.filter_subset _ _ + have hrowne : rows.Nonempty := hne.mono hsub + have hband : rows⊆rowBand (Z^(1/100:ℝ)) (2*Z^v+1) := by + intro u hu + exact mem_rowBand.mpr ⟨(hrows u hu).1,(hrows u hu).2.1,by linarith [(hnorm u hu).2]⟩ + have hellpos (j : Fin N) : 0(hrows u hu).2.2.1) + (fun u hu=>(hrows u hu).2.2.2) a i hi ha ha' hnext hcurrent + N ell hellpos hellhi hellsum W (fun _=>b) (fun _=>z) bin hne + have hBsub : B.rows⊆rows := hBr ▸ hsub + have hBfam : ∀u∈B.rows,∀j,B.family u j=sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u) j := by + intro u hu j + exact hFam u (hBr ▸ hu) j + have hraw := hmom q B hBsub hBd hRev hSlots hWidths hW' hUpper hExternal hMesh hBin hBfam + have hcard := hcount d hd hd' a ε Δ ν C0 q i hi ha ha' hε.le hε1 hΔ hΔ1 hν hC0 B + (by rw [hSlots];simp) hBin (hBr.symm ▸ hne) hMean hraw + rw [hBr,hMesh] at hcard + have hqb := classMean_bounds rows Finset.univ (Z^d) (2*a-1) mesh hmesh (fun j=>ell j/d) Q bin + (by linarith) (fun j _=>div_nonneg (hellpos j).le hd0.le) + (by rw [source_slot_length_sum Finset.univ ell d hellsum];positivity) hne + refine ⟨hqb.1,hqb.2,?_⟩ + have hp := hphysical d hd hd' v a q (K*C0*Z^(logCost+heightCost+momentCost)) + (adaptiveRowExponent (2*a-1) q Δ ε εm R ν) hv ha.le ha' (by positivity) rows' + (fun u hu=>hrows u (hsub hu)) (fun u hu=>hnorm u (hsub hu)) hcard i hi + (fun u hu=>hnext u (hsub hu)) t ht + (fun u hu=>source_amplitude_class_mean M H ell W Z d b a mesh z hZp hd0.ne' hmesh rows bin u hu) + apply hp.trans_eq + rw [show logCost+heightCost+momentCost+ + d*adaptiveRowExponent (2*a-1) q Δ ε εm R ν+ + v*(a-1/2+12*e+eps*(N+8)-17/50)+loss-2/75+q/6+mesh/6= + (logCost+heightCost+momentCost)+(d*adaptiveRowExponent (2*a-1) q Δ ε εm R ν+ + v*(a-1/2+12*e+eps*(N+8)-17/50)+loss-2/75+q/6+mesh/6) by ring, + Real.rpow_add hZp (logCost+heightCost+momentCost)] + ring + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCollected.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCollected.lean new file mode 100644 index 0000000000000000000000000000000000000000..313c80434b5d8bce1bc5e844e8e3d3b8db078dfd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCollected.lean @@ -0,0 +1,196 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.NonfloorCollected +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyNormalized + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ContDiff +open Filter Set +namespace SevenEighths.ProbeFinalAssembly +open ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification ProbePhysical ProbeMellinBoundary +open ProbeRaySlots HeckeDetectorPhysicalSelection HeckeDetectorAmplitudeFirst HeckeDetectorFiberPartition +local notation "O" => HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_nonfloor_rows_saving (N n : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss : ℝ) + (he : 0(W j y:ℂ)) Z + (sourceDyadConductor Z margin k) (51/100+e*j) ε τ dmax b R mesh i + ((17/50:ℂ)+t.1.2*Complex.I) Δ + (if 2*(51/100+e*j)-1≤5/6 then counts.cB else counts.cH) + (if 2*(51/100+e*j)-1≤5/6 then counts.kB else counts.kH) + (C0*Z^momentCost) (Z^heightCost) εm) → + let Y : Fin N→ℝ := fun j=>Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + let normer := PrincipalMellinResidues.sourceResidueConstant W0 W1 (∏P∈S,P)* + (Probe.principalScalar Finset.univ Z (1/6) + (PrincipalSignalComparison.slotMass T (ProbePrincipalResidueActual.residueWeights W Y)) : ℂ) + normer≠0 ∧ ‖finiteCentralCubeRows S hS hmax η rows T (nonfloorPoolOutside M H S N c b Y) + (fun j y=>(W j y:ℂ)) Y W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z e + (fun u=>51/100+e*grid u) (fun u=>(3*idx u+1:ℕ)*Z^τ)/normer‖≤ + C*C0*(η.modulus.absNorm:ℝ)^(2*eps)*Z^(3/16+Δ-saving+nu+dyadCost) := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + obtain ⟨C,hC,hbound⟩ := + actual_normalized_nonfloor_cube M H hH N n e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss + he he1 heps hc hcb hA hR hdmin hdmax hdRange hrmin hτ hε hκ hcost hmesh + hbudget hgap hmargin hheight hloss S hS hfirst hmax ell hell hello hellhi W hWs hW hWB hcompact hne hellsum + hdtop hε1 hκ1 hτzero hτheight hwbudget + φ hφ hφc hφp hφ0 hφne a₀ b₀ B₀ ha₀ hab₀ hB₀ hφs hφB + εm Δ ν logCost heightCost momentCost hεm hΔ hΔ1 hν hlog hMomentHeight + ζ μ saving hζ hζ1 hμ hcount hfinal W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + hr0 hr1 hp0 hp1 hn0 hn1 nu hnu counts + have hellpos (j : Fin N) : 0(hWB j y).1) hne W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + hr0 hr1 hp0 hp1 hn0 hn1 nu hnu + obtain ⟨Cd,hCd,hdyad⟩ := canonical_dyad_cost dyadCost hdyadCost + refine ⟨Cd*(n+1:ℕ)*(m+1:ℕ)*C,by positivity,?_⟩ + intro η + filter_upwards [hbound η,hnormer, + sourceDyad_geometry_eventually dmin dmax margin (13/16+ζ) hdmin hdmin1 hmargin hconductor, + eventually_gt_atTop (1:ℝ)] with Z hb hn hg hZ + intro C0 hC0 rows hrows idx grid hlabels hnext hcurrent hmom + dsimp only at hn ⊢ + refine ⟨hn.1,?_⟩ + have hZp : 0Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + let hT := nonfloorPoolOutside M H S N c b Y + let WC : Fin N→ℝ→ℂ := fun j y=>(W j y:ℂ) + let normer := PrincipalMellinResidues.sourceResidueConstant W0 W1 (∏P∈S,P)* + (Probe.principalScalar Finset.univ Z (1/6) + (PrincipalSignalComparison.slotMass T (ProbePrincipalResidueActual.residueWeights W Y)) : ℂ) + let D : ℝ := C*C0*(η.modulus.absNorm:ℝ)^(2*eps)*Z^(3/16+Δ-saving+nu) + have hD : 0≤D := by dsimp [D];positivity + let F : Finset FreeRow→(FreeRow→ℝ)→(FreeRow→ℝ)→ℂ := fun R a H=> + finiteCentralCubeRows S hS hmax η R T hT WC Y W0 W1 + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z e a H + have hcell (k : ℕ) (hk : k∈smallDyadicIndices (Z^(13/16+ζ))) + (i : ℕ) (hi : i∈Finset.range (n+1)) (j : ℕ) (hj : j∈Finset.range (m+1)) : + ‖F (cubeBinRows (rows∩dyadicRows 1 k) idx grid i j) + (fun _=>51/100+e*j) (fun _=>(3*i+1:ℕ)*Z^τ)/normer‖≤D := by + let Rk := rows∩dyadicRows 1 k + let Rij := cubeBinRows Rk idx grid i j + have hsubk : Rij⊆Rk := Finset.filter_subset _ _ + have hsub : Rij⊆rows := hsubk.trans Finset.inter_subset_left + by_cases hne' : Rij.Nonempty + · have hgeo := hg rows (fun u hu=>⟨(hrows u hu).1,(hrows u hu).2.1,(hrows u hu).2.2.2⟩) k + (hne'.mono hsubk) + obtain ⟨u,hu⟩ := hne' + have huj : grid u=j := ((mem_cubeBinRows Rk idx grid i j u).mp hu).2.2 + have hju : j≠0 := huj ▸ (hlabels u (hsub hu)).2.2.1 + have ha : 51/100<51/100+e*j := by + have hjp : (0:ℝ)⟨(hrows u (hsub hu)).1,(hrows u (hsub hu)).2.1, + (hrows u (hsub hu)).2.2.1,hgeo.2.2.2.2.2 u (hsubk hu)⟩) + (fun u hu=>hgeo.2.2.2.2.1 u (hsubk hu)) i (by simpa using Nat.le_of_lt_succ (Finset.mem_range.mp hi)) + hnext' hcurrent' (fun t ht=>hmom k hk i hi j hj ⟨u,hu⟩ t ht) + exact hbounded.2 + · have he : Rij=∅ := Finset.not_nonempty_iff_eq_empty.mp hne' + simpa only [F,show cubeBinRows (rows∩dyadicRows 1 k) idx grid i j=∅ from he, + finiteCentralCubeRows,Finset.sum_empty,zero_div,norm_zero] using hD + have hpartition : F rows (fun u=>51/100+e*grid u) (fun u=>(3*idx u+1:ℕ)*Z^τ)= + ∑k∈smallDyadicIndices (Z^(13/16+ζ)), + F (rows∩dyadicRows 1 k) (fun u=>51/100+e*grid u) (fun u=>(3*idx u+1:ℕ)*Z^τ) := by + unfold F finiteCentralCubeRows + exact retained_dyadic_sum rows _ (fun u hu=>⟨(hrows u hu).1,(hrows u hu).2.2.2⟩) _ + change ‖F rows (fun u=>51/100+e*grid u) (fun u=>(3*idx u+1:ℕ)*Z^τ)/normer‖≤_ + rw [hpartition,Finset.sum_div] + calc + _ ≤ ∑k∈smallDyadicIndices (Z^(13/16+ζ)),(n+1:ℕ)*(m+1:ℕ)*D := by + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro k hk + have hpart := finiteCentralCubeRows_bin_partition S hS hmax η (rows∩dyadicRows 1 k) T hT WC Y + W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z e (Z^τ) idx grid n m + (fun u hu=>⟨(hlabels u (Finset.mem_inter.mp hu).1).1,(hlabels u (Finset.mem_inter.mp hu).1).2.1⟩) + change ‖F (rows∩dyadicRows 1 k) (fun u=>51/100+e*grid u) (fun u=>(3*idx u+1:ℕ)*Z^τ)/normer‖≤_ + dsimp only [F] + rw [hpart,Finset.sum_div] + apply (norm_sum_le _ _).trans + calc + _ ≤ ∑i∈Finset.range (n+1),∑j∈Finset.range (m+1),D := by + apply Finset.sum_le_sum + intro i hi + rw [Finset.sum_div] + exact (norm_sum_le _ _).trans (Finset.sum_le_sum (fun j hj=>hcell k hk i hi j hj)) + _ = _ := by simp;ring + _ = ((smallDyadicIndices (Z^(13/16+ζ))).card:ℝ)*((n+1:ℕ)*(m+1:ℕ)*D) := by simp + _ ≤ (Cd*Z^dyadCost)*((n+1:ℕ)*(m+1:ℕ)*D) := + mul_le_mul_of_nonneg_right (hdyad Z (13/16+ζ) hZ.le (by linarith)) (by positivity) + _ = _ := by dsimp [D];rw [Real.rpow_add hZp (3/16+Δ-saving+nu) dyadCost];ring + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCountParameters.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCountParameters.lean new file mode 100644 index 0000000000000000000000000000000000000000..055b2b222dd291b51deb02161f0e8a53b04412eb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyCountParameters.lean @@ -0,0 +1,66 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.NonfloorCount + +namespace OAI + +noncomputable section +open scoped Classical BigOperators ContDiff +open Set Filter +namespace SevenEighths.ProbeFinalAssembly +open HeckeFamily HeckeInverseAmplification HeckeDetectorRawFiber HeckeDetectorBatch HeckeDetectorWitnessRows +open HeckeDetectorPhysicalSelection HeckeDetectorAmplitudeFirst HeckeDetectorRowCount HeckeDetectorAdaptiveCutoff +open ProbeHighRowFamily + +structure CountParameters (M : Ideal O) [NeZero M] (H : Subgroup (O ⧸ M)ˣ) (εm : ℝ) where + cB : ℝ + kB : ℝ + cH : ℝ + kH : ℝ + cB_pos : 0u.val) B.profile B.upper B.widths B.external U) u=q) → + (∀bin j J K,∀hne : (B.fiberRows bin j J K).Nonempty, + Moments (B.fiber bin j J K hne) Δ cB kB C height εm) → + (B.rows.card:ℝ)≤(Fintype.card Label:ℝ)*(dyadicLength U:ℝ)^2* fiberConstant C height K₀* + (Fintype.card B.Bin:ℝ)* + U^(Endpoint.balancedRowCount (2*a-1) (1/2-q/(2*a-1))+ + Δ/4+159*ε+εm+B.mesh+7*ν) + high : ∃K₀ : ℝ,0≤K₀ ∧ ∀ᶠ U : ℝ in atTop, + ∀ (a ε T allowance Δ C height q : ℝ) (i : ℕ), + 1 HeckeFamily.O + +structure SourceData {Δ : ℝ} (D : HighData Δ) where + S : Finset (Ideal O) + exclusions : SourceExclusions S + maximal : ∀P∈S,P.IsMaximal + first : FirstTail (4*D.e) S + w : ℝ→ℝ + W : SchwartzMap ℝ ℂ + smooth : ContDiff ℝ ∞ w + compact : HasCompactSupport w + support : Function.support w⊆Set.Ioo 1 2 + positive_support : tsupport w⊆Set.Ioi 0 + bounded : ∀x,0≤w x ∧ w x≤1 + nonzero : w≠0 + complex_eq : ∀x,W x=(w x:ℂ) + complex_nonzero : W≠0 + complex_support : Function.support W⊆Set.Icc 1 2 + real : ∀x,(W x).im=0 + nonnegative : ∀x,0≤(W x).re + +theorem exists_source_data {Δ : ℝ} (D : HighData Δ) : Nonempty (SourceData D) := by + obtain ⟨S,_,hS,hfirst,hmax⟩ := exists_fixed_source D.e D.e_pos ∅ (by simp) + obtain ⟨w,W,hw,hc,hs,hp,hb,hn,he,hWn,hWs,hr,hWpos⟩ := exists_fixed_probe_window + exact ⟨⟨S,hS,hmax,hfirst,w,W,hw,hc,hs,hp,hb,hn,he,hWn,hWs,hr,hWpos⟩⟩ + +def SourceData.modulus {Δ : ℝ} {D : HighData Δ} (F : SourceData D) : Ideal O := ∏P∈F.S,P + +instance {Δ : ℝ} {D : HighData Δ} (F : SourceData D) : NeZero F.modulus := + ⟨fixedPrimeProduct_ne_zero F.S F.exclusions.prime⟩ + +instance {Δ : ℝ} {D : HighData Δ} (F : SourceData D) : Finite (O ⧸ F.modulus) := + Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne F.modulus) + +theorem source_count_parameters {Δ : ℝ} {D : HighData Δ} (F : SourceData D) : + Nonempty (CountParameters F.modulus ⊤ D.t) := by + exact exists_count_parameters F.modulus ⊤ le_top F.S F.w F.smooth F.compact + F.positive_support (fun x=>(F.bounded x).1) F.nonzero 1 2 1 (by norm_num) (by norm_num) + (by norm_num) F.support (fun x=>(F.bounded x).2) D.t D.t_pos + +def SourceData.probe {Δ : ℝ} {D : HighData Δ} (F : SourceData D) (η : Character) : ℝ→ℂ := + letI : NeZero (∏P∈F.S,P) := ⟨fixedPrimeProduct_ne_zero F.S F.exclusions.prime⟩ + normalizedProbe F.modulus ⊤ F.S F.maximal D.ell 1 2 (fun _=>F.w) F.W F.W η + +theorem SourceData.probe_low {Δ : ℝ} {D : HighData Δ} (F : SourceData D) + (loss : ℝ) (hloss : 0Z^(3/16+loss)) := by + exact normalizedProbe_low F.modulus ⊤ le_top F.S F.exclusions F.maximal 1 2 1 loss + (by norm_num) (by norm_num) hloss D.ell (fun j=>(D.slots_bounds j).1) D.slots_injective D.slots_sum + (fun _=>F.w) (fun _=>F.smooth) (fun _=>F.compact) (fun _=>F.support) + (fun _=>F.bounded) (fun _=>F.nonzero) F.W F.W 1 2 1 2 (by norm_num) (by norm_num) + F.complex_support F.complex_support F.real F.real F.nonnegative F.nonnegative F.complex_nonzero F.complex_nonzero η + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyFixedHigh.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyFixedHigh.lean new file mode 100644 index 0000000000000000000000000000000000000000..8cd9b98a1bec3cbce12152a708e6e19cb85abf2c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyFixedHigh.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyHigh +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyMomentInput + +namespace OAI + +noncomputable section +open scoped Classical BigOperators ContDiff +open Filter +namespace SevenEighths.ProbeFinalAssembly +open HeckeFamily ProbePhysical ProbeHighRowFamily Parameters PrincipalSignalComparison +open HeckeInverseAmplification HeckeDetectorPhysicalSelection HeckeDetectorFiberPartition +open ProbeMellinBoundary + +theorem fixed_high_bound (hβ : (7/8:ℝ)(D.slots_bounds j).2.1) (fun j=>(D.slots_bounds j).2.2) + (fun _=>F.w) (fun _=>F.support) (fun _=>F.smooth) (fun _=>F.bounded) + (fun _=>F.compact) (fun _=>F.nonzero) D.slots_sum + (by norm_num) D.epsilon_small D.kappa_small hτd hτcost (by nlinarith [D.detector_budget]) + F.w F.smooth F.compact F.positive_support (fun y=>(F.bounded y).1) F.nonzero + 1 2 1 (by norm_num) (by norm_num) (by norm_num) F.support (fun y=>(F.bounded y).2) + D.t D.t D.t (2*τ) D.t ht ht ht (by linarith) + D.t (2*D.t) D.t ht (by linarith) (by positivity) D.count_budget (by nlinarith [D.central_budget]) + F.W F.W 1 2 1 2 (by norm_num) (by norm_num) F.complex_support F.complex_support + F.real F.real F.nonnegative F.nonnegative F.complex_nonzero F.complex_nonzero + (D.t/8) (by positivity) (D.t/8) (by positivity) (by norm_num) hconductor (by linarith) hβ.le + D.sigma D.sigma_pos D.geometric_budget D.principal_budget D.window_budget D.floor_budget D.high_saving counts + refine ⟨C,hC,?_⟩ + intro η + obtain ⟨Ct,hCt,hb⟩ := hbound η + refine ⟨Ct,hCt,?_⟩ + filter_upwards [hb,sourceDyad_geometry_eventually (1/200) (7/8) D.t (13/16+D.t) + (by norm_num) (by norm_num) ht hconductor, + HeckeDyadic.constant_absorbed_eventually (3*(n:ℝ)+1) τ hτ, + eventually_gt_atTop (1:ℝ)] with Z hb hgeo hnheight hZ + intro C0 hC0 hmom + obtain ⟨hnorm,idx,grid,hlabels,hbins,hray,hestimate⟩ := hb + apply hestimate C0 hC0 + intro k hk i hi j hj + dsimp only + intro hne t htheight + let rows := supportedNonfloorRows F.S F.maximal (rowBand (Z^(1/100:ℝ)) (Z^((13/16:ℝ)+D.t))) grid + let rows' := cubeBinRows (rows∩dyadicRows 1 k) idx grid i j + have hsub : rows'⊆rows∩dyadicRows 1 k := Finset.filter_subset _ _ + have hsubr : rows'⊆rows := hsub.trans Finset.inter_subset_left + have hrows : ∀u∈rows,u.val≠1 ∧ Z^(1/100:ℝ)≤rowNorm u ∧ rowNorm u≤Z^(13/16+D.t) := by + intro u hu + have hh := mem_rowBand.mp ((mem_supportedNonfloorRows F.S F.maximal _ grid u).mp hu).1 + exact ⟨hh.1,hh.2.1,hh.2.2.le⟩ + have hg := hgeo rows hrows k (hne.mono hsub) + obtain ⟨u,hu⟩ := hne + have huj : grid u=j := ((mem_cubeBinRows _ idx grid i j u).mp hu).2.2 + have hjne : j≠0 := huj ▸ ((mem_supportedNonfloorRows F.S F.maximal _ grid u).mp (hsubr hu)).2.2 + have ha : (51/100:ℝ)<51/100+D.e*j := by + have hjp : (0:ℝ) HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_high_probe_from_raw_moments (N : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss : ℝ) + (he : 0Z^(ell j) + let T := fun j=>pool (RayQuotient.identityClass M H) S c b (Yp j) + let _hT := nonfloorPoolOutside M H S N c b Yp + let WC : Fin N→ℝ→ℂ := fun j y=>(W j y:ℂ) + let normer := sourceResidueConstant W0 W1 (∏P∈S,P)* + (Probe.principalScalar Finset.univ Z (1/6) (slotMass T (residueWeights W Yp)) : ℂ) + normer≠0 ∧ ∃idx grid : FreeRow→ℕ, + (∀u,1 ≤ idx u ∧ idx u ≤ n ∧ grid u ≤ ⌊(49/100:ℝ)/e⌋₊ ∧ + ((3*idx u+1:ℕ):ℝ)*Z^τ+Z^τ/2≤(3*idx u+2:ℕ)*Z^τ) ∧ + (∀u, let a : ℝ := 51/100+e*grid u + (51/100:ℝ)≤a ∧ a≤1 ∧ + a≤detectorMaximum (sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u)) (3*idx u*Z^τ) ∧ + detectorMaximum (sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u)) (3*idx u*Z^τ)canonicalSlotSupport (T j)) WC Yp (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z/normer- + HeckeSignal.signal (η.excludePrimes S hS.prime) (sourceCorrection η S) (-11/16) Z‖≤ + (Ct+C*C0*(η.modulus.absNorm:ℝ)^(2*eps))*Z^(HeckeZeroSupremum.beta-11/16-sigma) := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + have hmin : 0(hbins u).2.2.2.2.1 + have hcurrent : ∀u∈rows,51/100+e*grid u≤detectorMaximum + (sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u)) ((3*idx u:ℕ)*Z^τ) := by + intro u hu + simpa only [Nat.cast_mul,Nat.cast_ofNat] using (hbins u).2.2.1 + have hglobal := (hb C0 hC0 rows hrows idx grid hlabel hnext hcurrent hmom).2 + have hexp : Z^(3/16+(HeckeZeroSupremum.beta-7/8)-saving+nu+dyadCost)≤ + Z^(HeckeZeroSupremum.beta-11/16-sigma) := + Real.rpow_le_rpow_of_exponent_le hZ (by linarith) + have hcentral' := hglobal.trans (mul_le_mul_of_nonneg_left hexp (by positivity)) + have hsum := (norm_add_le _ _).trans (add_le_add herror hcentral') + simpa only [rows,sub_add_cancel,add_mul] using hsum + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyIntegral.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyIntegral.lean new file mode 100644 index 0000000000000000000000000000000000000000..ff434e56096eb928b24fbbeef757f5d9dd917562 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyIntegral.lean @@ -0,0 +1,109 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.NonfloorIntegral +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyArithmetic + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ContDiff +open Filter Set +namespace SevenEighths.ProbeFinalAssembly +open ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification ProbePhysical ProbeMellinBoundary +open ProbeRaySlots HeckeDetectorPhysicalSelection HeckeDetectorAmplitudeFirst HeckeDetectorFiberPartition +local notation "O" => HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_nonfloor_cube_norm (N n : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss : ℝ) + (he : 0Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + (∀t : HeightSpace,((|t.1.1|≤(3*i+1:ℕ)*Z^τ ∧ |t.2|≤(3*i+1:ℕ)*Z^τ) ∧ |t.1.2|≤(3*i+1:ℕ)*Z^τ) → + SourceMomentsAt M H hH S hS.prime η rows ell W Z d a ε τ dmax b R mesh i + ((17/50:ℂ)+t.1.2*Complex.I) Δ + (if 2*a-1≤5/6 then counts.cB else counts.cH) (if 2*a-1≤5/6 then counts.kB else counts.kH) + (C0*Z^momentCost) (Z^heightCost) εm) → + ‖finiteCentralCubeRows S hS hmax η rows T (nonfloorPoolOutside M H S N c b Y) W Y + W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z e (fun _=>a) (fun _=>(3*i+1:ℕ)*Z^τ)‖≤ + C*C0*(η.modulus.absNorm:ℝ)^(2*eps)*Z^(3/16+Δ-saving) := by + obtain ⟨C,hC,harith⟩ := + actual_nonfloor_cube_arithmetic M H hH N n e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss + he he1 heps hc hcb hA hR hdmin hdmax hdRange hrmin hτ hε hκ hcost hmesh + hbudget hgap hmargin hheight hloss S hS hfirst hmax ell hell hello hellhi W hWs hW hWB hellsum + hdtop hε1 hκ1 hτzero hτheight hwbudget + φ hφ hφc hφp hφ0 hφne a₀ b₀ B₀ ha₀ hab₀ hB₀ hφs hφB + εm Δ ν logCost heightCost momentCost hεm hΔ hΔ1 hν hlog hMomentHeight + ζ μ saving hζ hζ1 hμ hcount hfinal counts + obtain ⟨D,hD,hprofile⟩ := actual_common_cube_aggregate_norm W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + refine ⟨D*C,mul_pos hD hC,?_⟩ + intro η + filter_upwards [harith η,(tendsto_rpow_atTop hτ).eventually (eventually_gt_atTop (2:ℝ)), + eventually_gt_atTop (1:ℝ)] with Z harith hT hZ + intro d hd hd' v a C0 hv hv' hdv ha ha' hC0 rows hrows hnorm i hi hnext hcurrent + dsimp only + intro hmom + have hZp : 0Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + let A : ℝ := C*C0*(η.modulus.absNorm:ℝ)^(2*eps)* + Z^(3/16+Δ-saving-((25/48)*a-181/300+(105/8)*e)) + have hA : 0≤A := by dsimp [A];positivity + have hp := hprofile e a (Z^τ) ((3*i+1:ℕ)*Z^τ) i he he1 ha.le ha' hT + (by gcongr;omega) S hS hmax hfirst η rows (fun u hu=>(hrows u hu).1) + T (nonfloorPoolOutside M H S N c b Y) (rayCubeFamily M H hH) hnext W Y + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z (by positivity) (by positivity) hZp A hA + (fun t ht=>harith d hd hd' v a C0 hv hv' hdv ha ha' hC0 rows hrows hnorm i hi hnext hcurrent + t ht (hmom t ht)) + apply hp.trans_eq + rw [ProbeCentralExponent.physical_scale_identity Z a e hZp] + dsimp only [A] + calc + _ = (D*C)*C0*(η.modulus.absNorm:ℝ)^(2*eps)* + (Z^((25/48)*a-181/300+(105/8)*e)*Z^(3/16+Δ-saving-((25/48)*a-181/300+(105/8)*e))) := by ring + _ = _ := by rw [←Real.rpow_add hZp];congr 2;ring + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyMomentInput.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyMomentInput.lean new file mode 100644 index 0000000000000000000000000000000000000000..436856065bd974c5ca52ac43b751a716f454ed20 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyMomentInput.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyData +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyMomentMono + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +open Filter +namespace SevenEighths.ProbeFinalAssembly +open HeckeFamily ProbePhysical ProbeHighRowFamily Parameters +open HeckeInverseAmplification + +def SourceMomentBound {Δ : ℝ} {D : HighData Δ} (F : SourceData D) + (counts : CountParameters F.modulus ⊤ D.t) (η : Character) + (Z τ C height : ℝ) : Prop := + ∀rows : Finset FreeRow,∀d a : ℝ, (1/200:ℝ)≤d → d≤7/8 → 51/100(F.w y:ℂ)) + Z d a D.ε τ (7/8) 2 D.t D.t i z Δ + (if 2*a-1≤5/6 then counts.cB else counts.cH) + (if 2*a-1≤5/6 then counts.kB else counts.kH) C height D.t + +lemma SourceMomentBound.mono_constant {Δ : ℝ} {D : HighData Δ} {F : SourceData D} + {counts : CountParameters F.modulus ⊤ D.t} {η : Character} {Z τ C C' height : ℝ} + (hZ : 0≤Z) (h : SourceMomentBound F counts η Z τ C height) (hC : C≤C') : + SourceMomentBound F counts η Z τ C' height := by + intro rows d a hd hd' ha ha' hrows i z hz hzh + exact sourceMomentsAt_mono_constant F.modulus ⊤ le_top F.S F.exclusions.prime η rows D.ell + (fun _ y=>(F.w y:ℂ)) Z d a D.ε τ (7/8) 2 D.t D.t i z Δ _ _ C C' height D.t + hZ hC (h rows d a hd hd' ha ha' hrows i z hz hzh) + +def RawMomentInput : Prop := + ∀_hβ : (7/8:ℝ) HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_normalized_nonfloor_cube (N n : ℕ) (e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss : ℝ) + (he : 0Z^(ell j) + let T : Fin N→Finset ProbePhysical.PrimeIdeal := fun j=>pool (RayQuotient.identityClass M H) S c b (Y j) + (∀t : HeightSpace,((|t.1.1|≤(3*i+1:ℕ)*Z^τ ∧ |t.2|≤(3*i+1:ℕ)*Z^τ) ∧ |t.1.2|≤(3*i+1:ℕ)*Z^τ) → + SourceMomentsAt M H hH S hS.prime η rows ell (fun j y=>(W j y:ℂ)) Z d a ε τ dmax b R mesh i + ((17/50:ℂ)+t.1.2*Complex.I) Δ + (if 2*a-1≤5/6 then counts.cB else counts.cH) (if 2*a-1≤5/6 then counts.kB else counts.kH) + (C0*Z^momentCost) (Z^heightCost) εm) → + let normer := PrincipalMellinResidues.sourceResidueConstant W0 W1 (∏P∈S,P)* + (Probe.principalScalar Finset.univ Z (1/6) + (PrincipalSignalComparison.slotMass T (ProbePrincipalResidueActual.residueWeights W Y)) : ℂ) + normer≠0 ∧ ‖finiteCentralCubeRows S hS hmax η rows T (nonfloorPoolOutside M H S N c b Y) (fun j y=>(W j y:ℂ)) Y + W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z e (fun _=>a) (fun _=>(3*i+1:ℕ)*Z^τ)/normer‖≤ + C*C0*(η.modulus.absNorm:ℝ)^(2*eps)*Z^(3/16+Δ-saving+nu) := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + let WC : Fin N→ℝ→ℂ := fun j y=>(W j y:ℂ) + have hWC (j : Fin N) : ContDiff ℝ ∞ (WC j) := Complex.ofRealCLM.contDiff.comp (hW j) + have hWCs (j : Fin N) : Function.support (WC j)⊆Ioo c b := by + intro y hy + apply hWs j + intro hh + exact hy (by dsimp [WC];rw [hh];simp) + have hWCB (j : Fin N) (y : ℝ) : ‖WC j y‖≤A := by + simpa only [WC,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (hWB j y).1] using (hWB j y).2 + obtain ⟨C,hC,hbound⟩ := + actual_nonfloor_cube_norm M H hH N n e eps c b A R dmin dmax rmin τ ε κ cost mesh margin loss + he he1 heps hc hcb hA hR hdmin hdmax hdRange hrmin hτ hε hκ hcost hmesh + hbudget hgap hmargin hheight hloss S hS hfirst hmax ell hell hello hellhi WC hWCs hWC hWCB hellsum + hdtop hε1 hκ1 hτzero hτheight hwbudget + φ hφ hφc hφp hφ0 hφne a₀ b₀ B₀ ha₀ hab₀ hB₀ hφs hφB + εm Δ ν logCost heightCost momentCost hεm hΔ hΔ1 hν hlog hMomentHeight + ζ μ saving hζ hζ1 hμ hcount hfinal + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 counts + have hellpos (j : Fin N) : 0(hWB j y).1) hne W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + hr0 hr1 hp0 hp1 hn0 hn1 nu hnu + refine ⟨C*Cn,mul_pos hC hCn,?_⟩ + intro η + filter_upwards [hbound η,hnormer,eventually_gt_atTop (0:ℝ)] with Z hb hn hZ + intro d hd hd' v a C0 hv hv' hdv ha ha' hC0 rows hrows hnorm i hi hnext hcurrent + dsimp only at hn ⊢ + intro hmom + refine ⟨hn.1,?_⟩ + have hh := hb d hd hd' v a C0 hv hv' hdv ha ha' hC0 rows hrows hnorm i hi hnext hcurrent hmom + rw [div_eq_mul_inv,norm_mul] + have hm := mul_le_mul hh hn.2 (norm_nonneg _) (by positivity) + apply hm.trans_eq + rw [Real.rpow_add hZ (3/16+Δ-saving) nu] + ring + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblySource.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblySource.lean new file mode 100644 index 0000000000000000000000000000000000000000..93c4852b1fae505afd77a4e6b800613fcf253667 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblySource.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.LowNormalized +import OAI.NumberTheory.DirichletL.Hecke.CommonProbe +import OAI.NumberTheory.DirichletL.Hecke.ModulusRefinement + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open Filter Asymptotics +namespace SevenEighths.ProbeFinalAssembly +open HeckeFamily ProbePhysical ProbeRaySlots PrincipalSignalComparison PrincipalMellinResidues +open ProbePrincipalResidueActual +local notation "O" => HeckeFamily.O + +def normalizedProbe {K : ℕ} (M : Ideal O) [NeZero M] [Finite (O ⧸ M)] + (H : Subgroup (O ⧸ M)ˣ) (S : Finset (Ideal O)) (hmax : ∀P∈S,P.IsMaximal) + [NeZero (∏P∈S,P)] (ell : Fin K→ℝ) (a b : ℝ) (W : Fin K→ℝ→ℝ) + (W0 W1 : SchwartzMap ℝ ℂ) (η : Character) (Z : ℝ) : ℂ := + let Yp := fun j=>Z^(ell j) + let T := fun j=>pool (RayQuotient.identityClass M H) S a b (Yp j) + compensatedPhysicalProbe η (calibrationForSet S hmax) W0 W1 + (fun j=>canonicalSlotSupport (T j)) (fun j y=>(W j y:ℂ)) Yp + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z / + (sourceResidueConstant W0 W1 (∏P∈S,P)* + (Probe.principalScalar Finset.univ Z (1/6) (slotMass T (residueWeights W Yp)) : ℂ)) + +lemma isBigO_rpow_of_eventual_norm_bound (f : ℝ→ℂ) (r : ℝ) + (h : ∃C : ℝ,0Z^r) := by + obtain ⟨C,hC,hb⟩ := h + refine Asymptotics.IsBigO.of_bound C ?_ + filter_upwards [hb,eventually_ge_atTop (0:ℝ)] with Z hb hZ + simpa only [Real.norm_eq_abs,abs_of_nonneg (Real.rpow_nonneg hZ r)] using hb + +theorem normalizedProbe_low {K : ℕ} + (M : Ideal O) [NeZero M] [Finite (O ⧸ M)] + (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + (S : Finset (Ideal O)) (hS : SourceExclusions S) (hmax : ∀P∈S,P.IsMaximal) + (a b B loss : ℝ) (ha : 0Z^(3/16+loss)) := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + intro η + obtain ⟨C,hC,hb⟩ := original_normalized_compensatedPhysicalProbe_low M H hH S hS hmax + a b B loss ha hab hloss ell hell hinj hsum W hW hcompact hsupp hWB hne + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 hr0 hr1 hp0 hp1 hn0 hn1 η + apply isBigO_rpow_of_eventual_norm_bound + exact ⟨C,hC,hb.mono (fun Z h=>h.2)⟩ + +theorem actual_source_analytic (S : Finset (Ideal O)) (hS : SourceExclusions S) (η : Character) : + (∀I,idealCoeff (η.excludePrimes S hS.prime) I= + if IsCoprime I (η.excludePrimes S hS.prime).modulus then idealCoeff η I else 0) ∧ + AnalyticOnNhd ℂ (sourceCorrection η S) {s : ℂ|7/8u.val) B.profile B.upper B.widths B.external (Z^d)) u=q) → + (∀bin j J K,∀hne : (B.fiberRows bin j J K).Nonempty, + Moments (B.fiber bin j J K hne) Δ counts.cB counts.kB (C*Z^momentCost) (Z^heightCost) εm) → + (B.rows.card:ℝ)≤K*C*Z^(logCost+heightCost+momentCost)*(Z^d)^(Endpoint.balancedRowCount (2*a-1) (1/2-q/(2*a-1))+Δ/4+159*ε+εm+B.mesh+7*ν) := by + obtain ⟨K₀,hK₀,hcount⟩ := counts.balanced + obtain ⟨K,hK,hpref⟩ := source_count_prefactor_eventually (Label:=Label) + N dmin dmax logCost heightCost momentCost binWidth K₀ hdmin hdmax hl (by linarith) hb + refine ⟨K,hK,?_⟩ + filter_upwards [eventually_all_rpow_ge hcount dmin hdmin,hpref, + source_count_frequency_eventually n dmax τ heightCost hdmax hτ hh, + eventually_all_rpow_ge (eventually_gt_atTop (1:ℝ)) dmin hdmin, + eventually_ge_atTop (1:ℝ)] with Z hcount hpref hfreq hU hZ + intro d hd hd' a ε Δ ν C q i hi ha haδ ha' hε hε' hΔ hΔ' hν hC Slot B hslots hbin hne hq hmom + have hcard := hcount d hd a ε (Z^τ) ((Z^d)^(τ/(2*dmax))) Δ ν + (C*Z^momentCost) (Z^heightCost) q i (hU d hd) ha haδ hε hε' hΔ hΔ' hν (by positivity) + (by positivity) (hfreq d hd' i hi) B hne hq hmom + apply hcard.trans + exact mul_le_mul_of_nonneg_right + (hpref d hd hd' C a ε (cutoff (2*a-1) q) (Z^τ) ((Z^d)^(τ/(2*dmax))) i + hC ha' B hslots hbin) (Real.rpow_nonneg (Real.rpow_nonneg (by linarith) _) _) + +theorem high_source_count_from_raw_moments + (M : Ideal O) [NeZero M] (H : Subgroup (O ⧸ M)ˣ) + (_hH : RayOrthogonality.globalUnits M≤H) (_S : Finset (Ideal O)) + (φ : ℝ→ℝ) (_hφ : ContDiff ℝ ∞ φ) (_hφc : HasCompactSupport φ) + (_hφp : tsupport φ⊆Ioi 0) (_hφ0 : ∀y,0≤φ y) (_hφne : φ≠0) + (a₀ b₀ B₀ : ℝ) (_ha₀ : 0u.val) B.profile B.upper B.widths B.external (Z^d)) u=q) → + (∀bin j J K,∀hne : (B.fiberRows bin j J K).Nonempty, + Moments (B.fiber bin j J K hne) Δ (if 2*a-1≤5/6 then counts.cB else counts.cH) (if 2*a-1≤5/6 then counts.kB else counts.kH) (C*Z^momentCost) (Z^heightCost) εm) → + (B.rows.card:ℝ)≤K*C*Z^(logCost+heightCost+momentCost)*(Z^d)^(adaptiveRowExponent (2*a-1) q Δ ε εm B.mesh ν) := by + obtain ⟨KB,hKB,hbalanced⟩ := balanced_source_count_from_raw_moments + M H hH S φ hφ hφc hφp hφ0 hφne a₀ b₀ B₀ ha₀ hab₀ hB₀ hφs hφB εm hεm + Label N n dmin dmax τ logCost heightCost momentCost binWidth hdmin hdmax hτ hl hh hb counts + obtain ⟨KH,hKH,hhigh⟩ := high_source_count_from_raw_moments + M H hH S φ hφ hφc hφp hφ0 hφne a₀ b₀ B₀ ha₀ hab₀ hB₀ hφs hφB εm hεm + Label N n dmin dmax τ logCost heightCost momentCost binWidth hdmin hdmax hτ hl hh hb counts + refine ⟨max KB KH,lt_of_lt_of_le hKB (le_max_left _ _),?_⟩ + filter_upwards [hbalanced,hhigh,eventually_ge_atTop (1:ℝ)] with Z hb hh hZ + intro d hd hd' a ε Δ ν C q i hi ha ha' hε hε' hΔ hΔ' hν hC Slot B hslots hbin hne hq hmom + by_cases hδ : 2*a-1≤5/6 + · simp only [ite_eq_left hδ] at hmom + have hc := hb d hd hd' a ε Δ ν C q i hi ha hδ ha' hε hε' hΔ hΔ' hν hC B hslots hbin hne hq hmom + simp only [adaptiveRowExponent,ite_eq_left hδ] + exact hc.trans (by gcongr;exact le_max_left _ _) + · simp only [ite_eq_right hδ] at hmom + have hc := hh d hd hd' a ε Δ C q i hi (lt_of_not_ge hδ) ha' hε hε' hC B hslots hbin hmom + simp only [adaptiveRowExponent,ite_eq_right hδ] + exact hc.trans (by gcongr;exact le_max_right _ _) + +end SevenEighths.ProbeFinalAssembly + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyUnconditional.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyUnconditional.lean new file mode 100644 index 0000000000000000000000000000000000000000..e7c20910424837fb954796e1216f5aa453bbd5da --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FinalAssemblyUnconditional.lean @@ -0,0 +1,50 @@ +import OAI.NumberTheory.DirichletL.Energy.CertifiedExistence +import OAI.NumberTheory.DirichletL.Detector.FinalAssemblyCertifiedBands +import OAI.NumberTheory.DirichletL.Moments.DetectorPlainSlotProfile + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff ComplexConjugate + +namespace SevenEighths.ProbeFinalAssemblyUnconditional +open ProbeFinalAssembly ProbeFinalAssemblyCertifiedBands +open CenteredMomentEnergyCertifiedExistence CenteredMomentDetectorPlainMomentParameters +open CenteredMomentDetectorPlainSlotProfile + +theorem detector_certified_bands:DetectorCertifiedBands:=by + intro hβ D _hfine F bΦ hbΦ + have hp:=fixed_parameters D + apply terminal_certificate (α:=Fin D.N) F.modulus ⊤ le_top + (fun x=>conj (F.W x)) 1 2 (1/4) (9/4) bΦ 0 1 (33/50) (33/50) 2 + (kappaPlain D) (stageError D) + · norm_num + · exact conjugate_source_support F + · exact Complex.conjCLE.contDiff.comp (F.W.smooth ⊤) + · norm_num + · norm_num + · norm_num + · norm_num + · exact hbΦ + · norm_num + · norm_num + · exact hp.2.2.2.2.1.le + · exact hp.2.2.1 + · linarith + · unfold kappaPlain + linarith + +theorem dirichlet_nonzero (q:ℕ)(hq:q≠0)(χ:DirichletCharacter ℂ q)(s:ℂ) + (hs:(7/8:ℝ) Ideal ActualEisensteinCubic.O + +def localMultiplier (η : Character) (P : PrimeIdeal) (x w z : ℂ) : ℂ := + let Q : ℝ := Ideal.absNorm P.val + (Q : ℂ)^(z-1) * + (compensatedReplacement (coordV Q z) (coordW Q 1 w) + (coordD Q (idealCoeff η P.val) 1 x) (idealMarkedClosed η P x w z) + (star (idealCoeff η P.val)*(Q : ℂ)^x) ((Q : ℂ)^(-w)) / + idealClosedCorrection η P x w z) + +def selectedMultiplier (η : Character) (T : Finset PrimeIdeal) (x w z : ℂ) : ℂ := + ∏ P ∈ T, localMultiplier η P x w z + +def slotMultiplier {ι : Type*} (η : Character) (J : Finset ι) + (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) (x w z : ℂ) : ℂ := + ∏ j ∈ J, ∑ P ∈ T j, b j P * localMultiplier η P x w z + +theorem correction_lower_bound (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (x w z : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + 1/2 ≤ ‖idealClosedCorrection η P x w z‖ := by + have hb := (idealClosedCorrection_bound η P (hS.norm_four P hP) x w z hx hw hz).trans + (hS.half ⟨P,hP⟩) + have hn := norm_sub_norm_le (1 : ℂ) (idealClosedCorrection η P x w z) + rw [norm_one, norm_sub_rev] at hn + linarith + +theorem correction_ne_zero (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (x w z : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + idealClosedCorrection η P x w z ≠ 0 := + norm_pos_iff.mp ((by norm_num : (0 : ℝ)<1/2).trans_le + (correction_lower_bound η S hS P hP x w z hx hw hz)) + +theorem correction_inverse_bound (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (x w z : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + ‖(idealClosedCorrection η P x w z)⁻¹‖ ≤ 2 := by + have hh := correction_lower_bound η S hS P hP x w z hx hw hz + rw [norm_inv, inv_eq_one_div] + exact (div_le_iff₀ (by linarith : 0 < ‖idealClosedCorrection η P x w z‖)).mpr (by linarith) + +lemma marked_differentiableAt_w (η : Character) (P : PrimeIdeal) (x w z : ℂ) + (hQ : 4 ≤ (Ideal.absNorm P.val : ℝ)) (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + DifferentiableAt ℂ (fun w => idealMarkedClosed η P x w z) w := by + have hQ0 : 0 < (Ideal.absNorm P.val : ℝ) := by linarith + have hd := open_region_denominators (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx hz + have hw := coordW_differentiable (Ideal.absNorm P.val) hQ0 1 + have hk := coordK_w_differentiable (Ideal.absNorm P.val) hQ0 (idealCoeff η P.val) x + unfold idealMarkedClosed markedFactor + dsimp only + fun_prop (disch := aesop) + +lemma marked_differentiableAt_z (η : Character) (P : PrimeIdeal) (x w z : ℂ) + (hQ : 4 ≤ (Ideal.absNorm P.val : ℝ)) (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + DifferentiableAt ℂ (fun z => idealMarkedClosed η P x w z) z := by + have hQ0 : 0 < (Ideal.absNorm P.val : ℝ) := by linarith + have hd := open_region_denominators (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx hz + have hv := coordV_differentiable (Ideal.absNorm P.val) hQ0 + have hr := coordR_z_differentiable (Ideal.absNorm P.val) hQ0 + (actualAPhase η (primaryGenerator P.val)) x + unfold idealMarkedClosed markedFactor + dsimp only + fun_prop (disch := aesop) + +theorem local_analytic_w (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (x z : ℂ) + (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun w => localMultiplier η P x w z) {w : ℂ | 9/10 < w.re} := by + have hQ : 4 ≤ (Ideal.absNorm P.val : ℝ) := by exact_mod_cast hS.norm_four P hP + have hQ0 : 0 < (Ideal.absNorm P.val : ℝ) := by linarith + have hn : (Ideal.absNorm P.val : ℂ) ≠ 0 := by exact_mod_cast hQ0.ne' + have hd := open_region_denominators (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx hz + have hc := unramifiedClosed_analytic_w (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx hz + apply DifferentiableOn.analyticOnNhd _ (Complex.isOpen_re_gt _) + intro w hw + have hmc := marked_differentiableAt_w η P x w z hQ hx hz + have hcc : DifferentiableAt ℂ (fun w => idealClosedCorrection η P x w z) w := + (hc w hw).differentiableAt + have hh := correction_ne_zero η S hS P hP x w z hx hw.le hz + have hcw := coordW_differentiable (Ideal.absNorm P.val) hQ0 1 + apply DifferentiableAt.differentiableWithinAt + unfold localMultiplier compensatedReplacement + dsimp only + fun_prop (disch := first | assumption | exact hd.2.2 | exact Or.inl hn) + +theorem local_analytic_z (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (x w : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) : + AnalyticOnNhd ℂ (fun z => localMultiplier η P x w z) {z : ℂ | 4/25 < z.re} := by + have hQ : 4 ≤ (Ideal.absNorm P.val : ℝ) := by exact_mod_cast hS.norm_four P hP + have hQ0 : 0 < (Ideal.absNorm P.val : ℝ) := by linarith + have hn : (Ideal.absNorm P.val : ℂ) ≠ 0 := by exact_mod_cast hQ0.ne' + have hc := unramifiedClosed_analytic_z (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x w hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx + apply DifferentiableOn.analyticOnNhd _ (Complex.isOpen_re_gt _) + intro z hz + have hd := open_region_denominators (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx hz.le + have hmc := marked_differentiableAt_z η P x w z hQ hx hz.le + have hcc : DifferentiableAt ℂ (fun z => idealClosedCorrection η P x w z) z := + (hc z hz).differentiableAt + have hh := correction_ne_zero η S hS P hP x w z hx hw hz.le + have hcv := coordV_differentiable (Ideal.absNorm P.val) hQ0 + apply DifferentiableAt.differentiableWithinAt + unfold localMultiplier compensatedReplacement + dsimp only + fun_prop (disch := first | assumption | exact hd.2.2 | exact Or.inl hn) + +lemma marked_bound (Q : ℝ) (A η x w z : ℂ) (hQ : 4 ≤ Q) + (hA : ‖A‖ ≤ 1) (hη : ‖η‖ ≤ 1) (hx : 7/8 ≤ x.re) + (hw : 19/20 ≤ w.re) (hz : 33/200 ≤ z.re) : + ‖PrincipalSlotEstimate.regionMarked Q A η x w z‖ ≤ 16 := by + have hQ0 : 0 < Q := by linarith + have hQ1 : 1 ≤ Q := by linarith + have hR : ‖coordR Q A x z‖ ≤ 1/2 := + (coordR_norm_le Q hQ0 A x z hA).trans (rpow_le_half Q _ hQ (by linarith)) + have hV : ‖coordV Q z‖ ≤ 1/2 := by + rw [coordV_norm Q hQ0]; exact rpow_le_half Q _ hQ (by linarith) + have hW : ‖coordW Q 1 w‖ ≤ 1 := by + apply (coordW_norm_le Q hQ0 1 w (by simp)).trans + exact (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith : -w.re ≤ 0)).trans_eq (Real.rpow_zero Q) + have hD : ‖coordD Q η 1 x‖ ≤ 1/2 := + (coordD_norm_le Q hQ0 η 1 x hη (by simp)).trans (rpow_le_half Q _ hQ (by linarith)) + have hK : ‖coordK Q η x w‖ ≤ 1 := by + apply (coordK_norm_le Q hQ1 η x w hη).trans + exact (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith : 1-x.re-w.re ≤ 0)).trans_eq (Real.rpow_zero Q) + have hqi : ‖(Q : ℂ)⁻¹‖ ≤ 1 := by + rw [norm_inv, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hQ0] + exact inv_le_one_of_one_le₀ hQ1 + have he := unramified_marked_error_bound (coordR Q A x z) (coordV Q z) (Q : ℂ)⁻¹ + (coordK Q η x w) (coordW Q 1 w) (coordD Q η 1 x) hR hV hqi hD + have h1 : 12*‖coordR Q A x z‖*(1+‖coordW Q 1 w‖) ≤ 12 := by + calc + _ ≤ 12*(1/2:ℝ)*(1+1) := by gcongr + _ = _ := by norm_num + have h2 : 4*‖coordK Q η x w‖*‖coordV Q z‖ ≤ 2 := by + calc + _ ≤ 4*1*(1/2:ℝ) := by gcongr + _ = _ := by norm_num + have hn := norm_sub_le (PrincipalSlotEstimate.regionMarked Q A η x w z + coordD Q η 1 x) + (coordD Q η 1 x) + rw [add_sub_cancel_right] at hn + change ‖PrincipalSlotEstimate.regionMarked Q A η x w z + coordD Q η 1 x‖ ≤ _ at he + linarith + +lemma replacement_bound (V W D P B q : ℂ) (R : ℝ) (hR : 0 ≤ R) + (hV : ‖V‖ ≤ 1/2) (hW : ‖W‖ ≤ 1) (hD : ‖D‖ ≤ 1/2) + (hP : ‖P‖ ≤ 16) (hB : ‖B‖ ≤ R) (hq : ‖q‖ ≤ 1) : + ‖compensatedReplacement V W D P B q‖ ≤ 200*(1+R) := by + have hV1 : ‖1-V‖ ≤ 2 := by + have := norm_sub_le (1 : ℂ) V + simp only [norm_one] at this + linarith + have hW1 : ‖1-W‖ ≤ 2 := by + have := norm_sub_le (1 : ℂ) W + simp only [norm_one] at this + linarith + have hBq : ‖B-q‖ ≤ R+1 := (norm_sub_le B q).trans (add_le_add hB hq) + have hVW : ‖1-V*W‖ ≤ 2 := by + have hn := norm_sub_le (1 : ℂ) (V*W) + rw [norm_one,norm_mul] at hn + have hm : ‖V‖*‖W‖ ≤ 1/2 := by + calc + _ ≤ (1/2:ℝ)*1 := by gcongr + _ = _ := by ring + linarith + have hi := inv_one_sub_norm_le_two D hD + unfold compensatedReplacement + rw [div_eq_mul_inv,norm_mul] + calc + _ ≤ (‖B-q‖*‖1-V‖*‖1-W‖*‖P‖ + ‖q‖*‖1-V*W‖)*2 := by + apply mul_le_mul _ hi (norm_nonneg _) (by positivity) + simpa only [norm_mul] using norm_sub_le ((B-q)*(1-V)*(1-W)*P) (q*(1-V*W)) + _ ≤ ((R+1)*2*2*16+1*2)*2 := by gcongr + _ ≤ 200*(1+R) := by linarith + +def localBound (Bx Bz : ℝ) (P : PrimeIdeal) : ℝ := + (Ideal.absNorm P.val : ℝ)^(Bz-1) * (400*(1+(Ideal.absNorm P.val : ℝ)^Bx)) + +lemma localBound_nonneg (Bx Bz : ℝ) (P : PrimeIdeal) : 0 ≤ localBound Bx Bz P := by + unfold localBound + positivity + +theorem local_norm_bound (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (x w z : ℂ) (Bx Bz : ℝ) + (hx : x.re ∈ Icc (7/8) Bx) (hw : 19/20 ≤ w.re) + (hz : z.re ∈ Icc (33/200) Bz) : + ‖localMultiplier η P x w z‖ ≤ localBound Bx Bz P := by + let Q : ℝ := Ideal.absNorm P.val + have hQ : 4 ≤ Q := by dsimp [Q]; exact_mod_cast hS.norm_four P hP + have hQ0 : 0 < Q := by linarith + have hQ1 : 1 ≤ Q := by linarith + have hB : ‖star (idealCoeff η P.val)*(Q : ℂ)^x‖ ≤ Q^Bx := by + rw [norm_mul,norm_star,Complex.norm_cpow_eq_rpow_re_of_pos hQ0] + exact (mul_le_of_le_one_left (Real.rpow_nonneg hQ0.le _) (idealCoeff_norm_le_one η _)).trans + (Real.rpow_le_rpow_of_exponent_le hQ1 hx.2) + have hq : ‖(Q : ℂ)^(-w)‖ ≤ 1 := by + rw [Complex.norm_cpow_eq_rpow_re_of_pos hQ0,Complex.neg_re] + exact (Real.rpow_le_rpow_of_exponent_le hQ1 (by linarith : -w.re ≤ 0)).trans_eq (Real.rpow_zero Q) + have hV : ‖coordV Q z‖ ≤ 1/2 := by + rw [coordV_norm Q hQ0]; exact rpow_le_half Q _ hQ (by linarith [hz.1]) + have hW : ‖coordW Q 1 w‖ ≤ 1 := by simpa only [coordW,one_mul] using hq + have hD : ‖coordD Q (idealCoeff η P.val) 1 x‖ ≤ 1/2 := + (coordD_norm_le Q hQ0 _ 1 x (idealCoeff_norm_le_one η _) (by simp)).trans + (rpow_le_half Q _ hQ (by linarith [hx.1])) + have hm : ‖idealMarkedClosed η P x w z‖ ≤ 16 := + marked_bound Q (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) x w z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) hx.1 hw hz.1 + have hr := replacement_bound _ _ _ _ _ _ (Q^Bx) (Real.rpow_nonneg hQ0.le _) hV hW hD hm hB hq + have hi := correction_inverse_bound η S hS P hP x w z hx.1 (by linarith) (by linarith [hz.1]) + have hp : ‖(Q : ℂ)^(z-1)‖ ≤ Q^(Bz-1) := by + rw [Complex.norm_cpow_eq_rpow_re_of_pos hQ0] + apply Real.rpow_le_rpow_of_exponent_le hQ1 + simpa only [Complex.sub_re,Complex.one_re] using sub_le_sub_right hz.2 1 + unfold localMultiplier + dsimp only + rw [div_eq_mul_inv,norm_mul,norm_mul] + change _ ≤ Q^(Bz-1)*(400*(1+Q^Bx)) + calc + _ ≤ Q^(Bz-1)*(200*(1+Q^Bx)*2) := by gcongr + _ = _ := by ring + +def selectedBound (T : Finset PrimeIdeal) (Bx Bz : ℝ) : ℝ := + ∏ P ∈ T, localBound Bx Bz P + +def slotBound {ι : Type*} (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (Bx Bz : ℝ) : ℝ := + ∏ j ∈ J, ∑ P ∈ T j, ‖b j P‖ * localBound Bx Bz P + +lemma selectedBound_nonneg (T : Finset PrimeIdeal) (Bx Bz : ℝ) : + 0 ≤ selectedBound T Bx Bz := Finset.prod_nonneg (fun P _ => localBound_nonneg Bx Bz P) + +lemma slotBound_nonneg {ι : Type*} (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (Bx Bz : ℝ) : 0 ≤ slotBound J T b Bx Bz := by + apply Finset.prod_nonneg + intro j hj + exact Finset.sum_nonneg (fun P _ => mul_nonneg (norm_nonneg _) (localBound_nonneg Bx Bz P)) + +theorem selected_analytic_w (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (T : Finset PrimeIdeal) (hT : ∀ P ∈ T, P.val ∉ S) (x z : ℂ) + (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun w => selectedMultiplier η T x w z) {w : ℂ | 9/10 < w.re} := + T.analyticOnNhd_fun_prod (fun P hp => local_analytic_w η S hS P (hT P hp) x z hx hz) + +theorem selected_analytic_z (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (T : Finset PrimeIdeal) (hT : ∀ P ∈ T, P.val ∉ S) (x w : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) : + AnalyticOnNhd ℂ (fun z => selectedMultiplier η T x w z) {z : ℂ | 4/25 < z.re} := + T.analyticOnNhd_fun_prod (fun P hp => local_analytic_z η S hS P (hT P hp) x w hx hw) + +theorem slot_analytic_w {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (x z : ℂ) + (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun w => slotMultiplier η J T b x w z) {w : ℂ | 9/10 < w.re} := by + apply J.analyticOnNhd_fun_prod + intro j hj + apply (T j).analyticOnNhd_fun_sum + intro P hp + exact analyticOnNhd_const.mul (local_analytic_w η S hS P (hT j hj P hp) x z hx hz) + +theorem slot_analytic_z {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (x w : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) : + AnalyticOnNhd ℂ (fun z => slotMultiplier η J T b x w z) {z : ℂ | 4/25 < z.re} := by + apply J.analyticOnNhd_fun_prod + intro j hj + apply (T j).analyticOnNhd_fun_sum + intro P hp + exact analyticOnNhd_const.mul (local_analytic_z η S hS P (hT j hj P hp) x w hx hw) + +theorem selected_norm_bound (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (T : Finset PrimeIdeal) (hT : ∀ P ∈ T, P.val ∉ S) (x w z : ℂ) (Bx Bz : ℝ) + (hx : x.re ∈ Icc (7/8) Bx) (hw : 19/20 ≤ w.re) (hz : z.re ∈ Icc (33/200) Bz) : + ‖selectedMultiplier η T x w z‖ ≤ selectedBound T Bx Bz := by + simp only [selectedMultiplier,selectedBound,norm_prod] + exact Finset.prod_le_prod₀ (fun _ _ => norm_nonneg _) + (fun P hp => local_norm_bound η S hS P (hT P hp) x w z Bx Bz hx hw hz) + +theorem slot_norm_bound {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (x w z : ℂ) (Bx Bz : ℝ) + (hx : x.re ∈ Icc (7/8) Bx) (hw : 19/20 ≤ w.re) (hz : z.re ∈ Icc (33/200) Bz) : + ‖slotMultiplier η J T b x w z‖ ≤ slotBound J T b Bx Bz := by + simp only [slotMultiplier,slotBound,norm_prod] + apply Finset.prod_le_prod₀ (fun _ _ => norm_nonneg _) + intro j hj + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro P hp + rw [norm_mul] + exact mul_le_mul_of_nonneg_left + (local_norm_bound η S hS P (hT j hj P hp) x w z Bx Bz hx hw hz) (norm_nonneg _) + +lemma global_norm_bound (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (x w z : ℂ) (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + ‖globalClosedCorrection η S x w z‖ ≤ 3/2 := by + have hb := globalClosedCorrection_bound η S hS x w z hx hw hz + have hn := norm_add_le (globalClosedCorrection η S x w z-1) (1 : ℂ) + rw [sub_add_cancel,norm_one] at hn + linarith + +theorem combined_slot_analytic_w {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (x z : ℂ) + (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun w => globalClosedCorrection η S x w z * slotMultiplier η J T b x w z) + {w : ℂ | 9/10 < w.re} := + (globalClosedCorrection_analytic_w η S hS x z hx hz).mul (slot_analytic_w η S hS J T b hT x z hx hz) + +theorem combined_slot_analytic_z {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (x w : ℂ) + (hx : 7/8 ≤ x.re) (hw : 9/10 ≤ w.re) : + AnalyticOnNhd ℂ (fun z => globalClosedCorrection η S x w z * slotMultiplier η J T b x w z) + {z : ℂ | 4/25 < z.re} := + (globalClosedCorrection_analytic_z η S hS x w hx hw).mul (slot_analytic_z η S hS J T b hT x w hx hw) + +theorem combined_slot_bound {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (x w z : ℂ) (Bx Bz : ℝ) + (hx : x.re ∈ Icc (7/8) Bx) (hw : 19/20 ≤ w.re) (hz : z.re ∈ Icc (33/200) Bz) : + ‖globalClosedCorrection η S x w z * slotMultiplier η J T b x w z‖ ≤ + (3/2)*slotBound J T b Bx Bz := by + rw [norm_mul] + exact mul_le_mul (global_norm_bound η S hS x w z hx.1 (by linarith) (by linarith [hz.1])) + (slot_norm_bound η S hS J T b hT x w z Bx Bz hx hw hz) (norm_nonneg _) (by norm_num) + +theorem selected_initial_identity (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (T : Finset PrimeIdeal) (hT : ∀ P ∈ T, P.val ∉ S) (x w z : ℂ) + (hx : 3/2 < x.re) (hw : 2 < w.re) (hz : 1/6 < z.re) : + (∏ P ∈ T, (Ideal.absNorm P.val : ℂ)^(z-1)) * + spectralCompensatedHigh S T η x w z + (fun P => star (idealCoeff η P.val)*(Ideal.absNorm P.val : ℂ)^x) + (fun P => (Ideal.absNorm P.val : ℂ)^(-w)) = + (LFunction (fixedSourcePrincipal S hS.prime) (6*z) * + LFunction (fixedSourcePrincipal S hS.prime) w / + LFunction (η.excludePrimes S hS.prime) x) * + (globalClosedCorrection η S x w z * selectedMultiplier η T x w z) := by + rw [spectralCompensatedHigh_continued S hS T hT η x w z _ _ hx hw hz] + simp only [selectedMultiplier,localMultiplier,Finset.prod_mul_distrib,Complex.ofReal_natCast] + ring_nf + +theorem source_w_boundary {ι : Type*} (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (a1 b1 : ℝ) (ha1 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) w z * + LFunction (fixedPrincipal M) w) (19/20) cw := by + apply PrincipalMellinGrowth.source_w_boundary W0 W1 a1 b1 ha1 hW1 M X Y Z hY + (η.excludePrimes S hS.prime) s z hEta (globalClosedCorrection η S s) (slotMultiplier η J T b s) + (AH := (3/2)*slotBound J T b s.re z.re) hcw + (mul_nonneg (by norm_num) (slotBound_nonneg J T b _ _)) 0 + · exact (combined_slot_analytic_w η S hS.tail J T b hT s z hs (by linarith)).continuousOn.mono + (by intro w hw; change (9/10:ℝ) sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) 1 z * + LFunction (fixedPrincipal M) (6*z)) (33/200) (1/6+e) := by + apply PrincipalMellinGrowth.source_z_boundary W0 W1 a0 b0 ha0 hW0 M X Y Z hX hZ + (η.excludePrimes S hS.prime) s hEta (globalClosedCorrection η S s) (slotMultiplier η J T b s) + (AH := (3/2)*slotBound J T b s.re (1/6+e)) he he' + (mul_nonneg (by norm_num) (slotBound_nonneg J T b _ _)) 0 + · exact (combined_slot_analytic_z η S hS.tail J T b hT s 1 hs (by norm_num)).continuousOn.mono + (by intro z hz; change (4/25:ℝ) sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) w z) {w : ℂ | 9/10 < w.re} := by + have hM := CubicReflectionKernel.compact_source_mellin_differentiable W1 a1 b1 ha1 hW1 (W1.smooth ⊤) + have hH := (combined_slot_analytic_w η S hS.tail J T b hT s z hs hz).differentiableOn + have hYn : (Y : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hY.ne' + have he : (fun w => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) w z) = + (fun w => ((X:ℂ)^(1/2-z)*(Z:ℂ)^(s+z-1)*Complex.exp ((s+z-1)^2)* + mellin (EisensteinSchwartzPoisson.paperRadialFourier W0) z / + LFunction (η.excludePrimes S hS.prime) s) * (Y:ℂ)^(w-1) * mellin W1 w * + (globalClosedCorrection η S s w z * slotMultiplier η J T b s w z)) := by + funext w; unfold sourceMultiplier; ring + rw [he] + fun_prop (disch := first | assumption | exact Or.inl hYn) + +theorem source_multiplier_differentiable_z {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (hX : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) w z) {z : ℂ | 4/25 < z.re} := by + have hM : DifferentiableOn ℂ (mellin (EisensteinSchwartzPoisson.paperRadialFourier W0)) + {z : ℂ | 4/25 < z.re} := + (ProbeRadialMellin.radial_mellin_differentiable W0).mono (by intro z hz; change 0 < z.re; change (4/25:ℝ) sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) w z) = + (fun z => ((Y:ℂ)^(w-1)*mellin W1 w / LFunction (η.excludePrimes S hS.prime) s) * + (X:ℂ)^(1/2-z)*(Z:ℂ)^(s+z-1)*Complex.exp ((s+z-1)^2)* + mellin (EisensteinSchwartzPoisson.paperRadialFourier W0) z * + (globalClosedCorrection η S s w z * slotMultiplier η J T b s w z)) := by + funext z; unfold sourceMultiplier; ring + rw [he] + fun_prop (disch := first | assumption | exact Or.inl hXn | exact Or.inl hZn) + +theorem source_w_shift {ι : Type*} (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (a1 b1 : ℝ) (ha1 : 0 K w z * LFunction (fixedPrincipal M) w) = + verticalIntegral (19/20) (fun w => K w z * LFunction (fixedPrincipal M) w) + + K 1 z * fixedPrincipalResidue M := by + dsimp only + apply PrincipalMellinResidues.source_w_shift (fixedPrincipal M) _ z hcw + · exact (source_multiplier_differentiable_w η S hS J T b hT W0 W1 a1 b1 ha1 hW1 + X Y Z hY s z hs (by linarith)).mono (by intro w hw; change (9/10:ℝ) K 1 z * LFunction (fixedPrincipal M) (6*z)) = + verticalIntegral (33/200) (fun z => K 1 z * LFunction (fixedPrincipal M) (6*z)) + + K 1 (1/6) * fixedPrincipalResidue M / 6 := by + dsimp only + apply PrincipalMellinResidues.source_residue_z_shift (fixedPrincipal M) _ he + · exact (source_multiplier_differentiable_z η S hS J T b hT W0 W1 X Y Z hX hZ s 1 hs + (by norm_num)).mono (by intro z hz; change (4/25:ℝ) W j ((Ideal.absNorm P.val : ℝ)/scale j)) s w z + +theorem window_at_residue {ι : Type*} (η : Character) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (W : ι → ℝ → ℝ) (scale : ι → ℝ) (s : ℂ) : + windowMultiplier η J T (fun j t => (W j t : ℂ)) scale s 1 (1/6) = + ∏ j ∈ J, ∑ P ∈ T j, + ((W j ((Ideal.absNorm P.val : ℝ)/scale j) * + (Ideal.absNorm P.val : ℝ)^(-(5/6 : ℝ)) : ℝ) : ℂ) * + PrincipalSlotEstimate.principalSlot (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) s := by + unfold windowMultiplier slotMultiplier + apply Finset.prod_congr rfl + intro j hj + apply Finset.sum_congr rfl + intro P hp + rw [local_eq_regionSlot,PrincipalSlotEstimate.region_slot_at_residue] + have hQ : 0 < (Ideal.absNorm P.val : ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr P.property.ne_zero) + rw [Complex.ofReal_mul,Complex.ofReal_cpow hQ.le] + norm_num only [Complex.ofReal_neg,Complex.ofReal_div,Complex.ofReal_ofNat] + norm_num + ring_nf + +theorem slot_norm_bound_sharp {ι : Type*} (η : Character) (J : Finset ι) + (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℝ) (Pmin : ℝ) + (hPmin : 480 ≤ Pmin) (hb : ∀j∈J,∀P∈T j,0≤b j P) + (hQ : ∀j∈J,∀P∈T j,Pmin≤(Ideal.absNorm P.val : ℝ)) + (hη : ∀j∈J,∀P∈T j,‖idealCoeff η P.val‖=1) (s w z : ℂ) + (hs : 7/8≤s.re) (hw : 19/20≤w.re) (hz : 33/200≤z.re) : + ‖slotMultiplier η J T (fun j P => (b j P : ℂ)) s w z‖ ≤ + ∏ j ∈ J, (1+1440*Pmin^(-(7/8 : ℝ))) * + ∑ P ∈ T j, b j P*(Ideal.absNorm P.val : ℝ)^(z.re-1) := by + simp only [slotMultiplier,local_eq_regionSlot,norm_prod] + apply Finset.prod_le_prod₀ (fun _ _ => norm_nonneg _) + intro j hj + simpa only [mul_assoc,Complex.ofReal_natCast] using PrincipalSlotEstimate.weighted_region_slot_norm (T j) (b j) + (fun P => (Ideal.absNorm P.val : ℝ)) (fun P => actualAPhase η (primaryGenerator P.val)) + (fun P => idealCoeff η P.val) s w z Pmin hPmin (hb j hj) (hQ j hj) + (fun P _ => actualAPhase_norm_le_one η _) (hη j hj) hs hw hz + +theorem combined_slot_bound_sharp {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℝ) (Pmin : ℝ) + (hPmin : 480 ≤ Pmin) (hb : ∀j∈J,∀P∈T j,0≤b j P) + (hQ : ∀j∈J,∀P∈T j,Pmin≤(Ideal.absNorm P.val : ℝ)) + (hη : ∀j∈J,∀P∈T j,‖idealCoeff η P.val‖=1) (s w z : ℂ) + (hs : 7/8≤s.re) (hw : 19/20≤w.re) (hz : 33/200≤z.re) : + ‖globalClosedCorrection η S s w z * slotMultiplier η J T (fun j P => (b j P : ℂ)) s w z‖ ≤ + (3/2) * ∏ j ∈ J, (1+1440*Pmin^(-(7/8 : ℝ))) * + ∑ P ∈ T j, b j P*(Ideal.absNorm P.val : ℝ)^(z.re-1) := by + rw [norm_mul] + exact mul_le_mul (global_norm_bound η S hS s w z hs (by linarith) (by linarith)) + (slot_norm_bound_sharp η J T b Pmin hPmin hb hQ hη s w z hs hw hz) (norm_nonneg _) (by norm_num) + +@[simp] theorem slotMultiplier_empty {ι : Type*} (η : Character) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (s w z : ℂ) : slotMultiplier η ∅ T b s w z = 1 := by + simp [slotMultiplier] + +theorem selected_as_slots (η : Character) (T : Finset PrimeIdeal) (s w z : ℂ) : + selectedMultiplier η T s w z = slotMultiplier η T (fun P => {P}) (fun _ _ => 1) s w z := by + simp [selectedMultiplier,slotMultiplier] + +theorem fixed_source_boundaries {ι : Type*} (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 K w z * LFunction (fixedSourcePrincipal S hS.prime) w) (19/20) cw) ∧ + BoundaryControl (fun z => K 1 z * LFunction (fixedSourcePrincipal S hS.prime) (6*z)) + (33/200) (1/6+e) := by + dsimp only + let : NeZero (∏ P ∈ S, P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + constructor + · intro z hz + exact source_w_boundary η S hS J T b hT W0 W1 a1 b1 ha1 hW1 + (∏ P ∈ S, P) X Y Z hY s z hs (by rw [hz]; linarith) hEta hcw + · exact source_z_boundary η S hS J T b hT W0 W1 a0 b0 ha0 hW0 + (∏ P ∈ S, P) X Y Z hX hZ s hs hEta he he' + +lemma boundary_mul_const (F : ℂ → ℂ) (a b : ℝ) (h : BoundaryControl F a b) (c : ℂ) : + BoundaryControl (fun z => F z*c) a b := by + refine ⟨h.left.mul_const c,h.right.mul_const c,?_,?_⟩ + · simpa only [intervalIntegral.integral_mul_const,zero_mul] using h.lower.mul_const c + · simpa only [intervalIntegral.integral_mul_const,zero_mul] using h.upper.mul_const c + +theorem fixed_source_ordered_boundaries {ι : Type*} (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 K w z * LFunction (fixedSourcePrincipal S hS.prime) (6*z) * + LFunction (fixedSourcePrincipal S hS.prime) w) (19/20) cw) ∧ + BoundaryControl (fun z => K 1 z * LFunction (fixedSourcePrincipal S hS.prime) (6*z)) + (33/200) (1/6+e) := by + have hh := fixed_source_boundaries S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z hX hY hZ η s hs hEta hcw he he' + dsimp only at hh ⊢ + refine ⟨?_,hh.2⟩ + intro z hz + convert boundary_mul_const _ _ _ (hh.1 z hz) (LFunction (fixedSourcePrincipal S hS.prime) (6*z)) using 1 + funext w + ring + +theorem uniform_closed_box_bound {ι : Type*} (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (Bx Bw Bz : ℝ) : + ∃ C : ℝ, 0 ≤ C ∧ ∀ (η : Character) (s w z : ℂ), + s.re ∈ Icc (7/8) Bx → w.re ∈ Icc (19/20) Bw → z.re ∈ Icc (33/200) Bz → + ‖globalClosedCorrection η S s w z * slotMultiplier η J T b s w z‖ ≤ C := + ⟨(3/2)*slotBound J T b Bx Bz, + mul_nonneg (by norm_num) (slotBound_nonneg J T b Bx Bz), + fun η s w z hs hw hz => combined_slot_bound η S hS J T b hT s w z Bx Bz hs hw.1 hz⟩ + +end SevenEighths.ProbeFiniteProductBounds +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FiniteProductX.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FiniteProductX.lean new file mode 100644 index 0000000000000000000000000000000000000000..5113258956d5205a619187f177be13b537b7c59f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FiniteProductX.lean @@ -0,0 +1,192 @@ +import OAI.NumberTheory.DirichletL.Detector.FiniteProductBounds +import OAI.NumberTheory.DirichletL.Hecke.Reciprocal + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology +open Complex Set MeasureTheory +namespace SevenEighths.ProbeFiniteProductX +open ActualEisensteinCubic CompletedGauss ProbePhysical ProbeEuler ProbeLocal +open HeckeFamily PrincipalMellinResidues ProbeFiniteProductBounds +local notation "Id" => Ideal ActualEisensteinCubic.O + +lemma marked_differentiableAt_x (η : Character) (P : PrimeIdeal) (x w z : ℂ) + (hQ : 4 ≤ (Ideal.absNorm P.val : ℝ)) (hx : 7/8 ≤ x.re) (hz : 4/25 ≤ z.re) : + DifferentiableAt ℂ (fun x => idealMarkedClosed η P x w z) x := by + have hQ0 : 0 < (Ideal.absNorm P.val : ℝ) := by linarith + have hd := open_region_denominators (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx hz + have hr := coordR_differentiable (Ideal.absNorm P.val) hQ0 + (actualAPhase η (primaryGenerator P.val)) z + have hd' := coordD_differentiable (Ideal.absNorm P.val) hQ0 (idealCoeff η P.val) 1 + have hk := coordK_differentiable (Ideal.absNorm P.val) hQ0 (idealCoeff η P.val) w + unfold idealMarkedClosed markedFactor + dsimp only + fun_prop (disch := aesop) + +theorem local_analytic_x (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (P : PrimeIdeal) (hP : P.val ∉ S) (w z : ℂ) + (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun x => localMultiplier η P x w z) {x : ℂ | 7/8 < x.re} := by + have hQ : 4 ≤ (Ideal.absNorm P.val : ℝ) := by exact_mod_cast hS.norm_four P hP + have hQ0 : 0 < (Ideal.absNorm P.val : ℝ) := by linarith + have hn : (Ideal.absNorm P.val : ℂ) ≠ 0 := by exact_mod_cast hQ0.ne' + have hc := unramifiedClosed_analytic_x (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 w z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hz + apply DifferentiableOn.analyticOnNhd _ (Complex.isOpen_re_gt _) + intro x hx + have hd := open_region_denominators (Ideal.absNorm P.val) + (actualAPhase η (primaryGenerator P.val)) (idealCoeff η P.val) 1 x z hQ + (actualAPhase_norm_le_one η _) (idealCoeff_norm_le_one η _) (by simp) hx.le hz + have hm := marked_differentiableAt_x η P x w z hQ hx.le hz + have hcc : DifferentiableAt ℂ (fun x => idealClosedCorrection η P x w z) x := + (hc x hx).differentiableAt + have hh := correction_ne_zero η S hS P hP x w z hx.le hw hz + have hd' := coordD_differentiable (Ideal.absNorm P.val) hQ0 (idealCoeff η P.val) 1 + apply DifferentiableAt.differentiableWithinAt + unfold localMultiplier compensatedReplacement + dsimp only + fun_prop (disch := first | assumption | exact hd.2.2 | exact Or.inl hn) + +theorem selected_analytic_x (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (T : Finset PrimeIdeal) (hT : ∀ P ∈ T, P.val ∉ S) (w z : ℂ) + (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun x => selectedMultiplier η T x w z) {x : ℂ | 7/8 < x.re} := + T.analyticOnNhd_fun_prod (fun P hp => local_analytic_x η S hS P (hT P hp) w z hw hz) + +theorem slot_analytic_x {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (w z : ℂ) + (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun x => slotMultiplier η J T b x w z) {x : ℂ | 7/8 < x.re} := by + apply J.analyticOnNhd_fun_prod + intro j hj + apply (T j).analyticOnNhd_fun_sum + intro P hp + exact analyticOnNhd_const.mul (local_analytic_x η S hS P (hT j hj P hp) w z hw hz) + +theorem window_analytic_x {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (W : ι → ℝ → ℂ) (scale : ι → ℝ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (w z : ℂ) + (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun x => windowMultiplier η J T W scale x w z) {x : ℂ | 7/8 < x.re} := + slot_analytic_x η S hS J T _ hT w z hw hz + +theorem combined_selected_analytic_x (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (T : Finset PrimeIdeal) (hT : ∀ P ∈ T, P.val ∉ S) (w z : ℂ) + (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun x => globalClosedCorrection η S x w z * selectedMultiplier η T x w z) + {x : ℂ | 7/8 < x.re} := + (globalClosedCorrection_analytic_x η S hS w z hw hz).mul + (selected_analytic_x η S hS T hT w z hw hz) + +theorem combined_slot_analytic_x {ι : Type*} (η : Character) (S : Finset Id) (hS : CorrectionTail S) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) (w z : ℂ) + (hw : 9/10 ≤ w.re) (hz : 4/25 ≤ z.re) : + AnalyticOnNhd ℂ (fun x => globalClosedCorrection η S x w z * slotMultiplier η J T b x w z) + {x : ℂ | 7/8 < x.re} := + (globalClosedCorrection_analytic_x η S hS w z hw hz).mul + (slot_analytic_x η S hS J T b hT w z hw hz) + +def continuedSourceMultiplier {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀ P ∈ S, Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (x w z : ℂ) : ℂ := + (X:ℂ)^(1/2-z) * (Z:ℂ)^(x+z-1) * (Y:ℂ)^(w-1) * + Complex.exp ((x+z-1)^2) * + mellin (EisensteinSchwartzPoisson.paperRadialFourier W0) z * mellin W1 w * + HeckeReciprocal.reciprocal (η.excludePrimes S hS) x * + globalClosedCorrection η S x w z * slotMultiplier η J T b x w z + +theorem continued_source_analytic_x {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (hZ : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z x w z) + {x : ℂ | max (7/8 : ℝ) HeckeZeroSupremum.beta < x.re} := by + have hn : (Z:ℂ) ≠ 0 := by exact_mod_cast hZ.ne' + apply DifferentiableOn.analyticOnNhd _ (Complex.isOpen_re_gt _) + intro x hx + have hx' : (7/8 : ℝ) continuedSourceMultiplier η S hS J T b W0 W1 X Y Z ((a:ℂ)+t*I) w z) + =ᵐ[volume] (fun t : ℝ => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS) + ((a:ℂ)+t*I) (globalClosedCorrection η S ((a:ℂ)+t*I)) + (slotMultiplier η J T b ((a:ℂ)+t*I)) w z) := by + filter_upwards [Measure.ae_ne volume (0:ℝ)] with t ht + apply continued_source_eq_raw + · intro h + exact ht (by simpa using congrArg Complex.im h) + · intro h + exact ht (by simpa using congrArg Complex.im h) + +theorem source_analytic_x_off_one {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀ j ∈ J, ∀ P ∈ T j, P.val ∉ S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (hZ : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) x + (globalClosedCorrection η S x) (slotMultiplier η J T b x) w z) + {x : ℂ | max (7/8 : ℝ) HeckeZeroSupremum.beta < x.re ∧ x≠1} := by + have hn : (Z:ℂ) ≠ 0 := by exact_mod_cast hZ.ne' + apply DifferentiableOn.analyticOnNhd _ + ((Complex.isOpen_re_gt _).inter (isClosed_singleton.isOpen_compl)) + intro x hx + have hx' : (7/8 : ℝ) continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z x w z) + {x : ℂ | a≤x.re ∧ x.re≤c} := by + apply (continued_source_analytic_x η S hS J T b hT W0 W1 X Y Z hZ w z hw hz).differentiableOn.mono + intro x hx + exact lt_of_lt_of_le (max_lt ha hβ) hx.1 + +theorem continued_source_principal_one {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀ P ∈ S, Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (w z : ℂ) + (hχ : (η.excludePrimes S hS).residue=1) : + continuedSourceMultiplier η S hS J T b W0 W1 X Y Z 1 w z=0 := by + simp only [continuedSourceMultiplier,HeckeReciprocal.reciprocal_principal_one _ hχ,mul_zero,zero_mul] + +end SevenEighths.ProbeFiniteProductX +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FixedEuler.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FixedEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..b4fd2c5bc76e8034eb0e1e83ef4631c73ab01613 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FixedEuler.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Detector.HighExcludedLocal +import OAI.NumberTheory.DirichletL.Hecke.RayFamily +import OAI.NumberTheory.DirichletL.Hecke.ModulusRefinement + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic HeckeFamily +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma fixedPrimeProduct_ne_zero (S : Finset Id) (hS : ∀P∈S,Prime P) : + (∏P∈S,P)≠0 := Finset.prod_ne_zero_iff.mpr (fun P hP=>(hS P hP).ne_zero) + +def fixedSourcePrincipal (S : Finset Id) (hS : ∀P∈S,Prime P) : Character := + letI : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS⟩ + HeckeRayFamily.character (∏P∈S,P) 1 + +lemma prime_coprime_fixedProduct (S : Finset Id) (hS : ∀P∈S,Prime P) (P : PrimeIdeal) : + IsCoprime P.val (∏Q∈S,Q) ↔ P.val∉S := by + rw [IsCoprime.prod_right_iff] + constructor + · intro h hP + exact P.property.not_isUnit (isCoprime_self.mp (h P.val hP)) + · intro h Q hQ + exact primeIdeal_coprime P ⟨Q,hS Q hQ⟩ (fun he=>h ((congrArg Subtype.val he).symm ▸ hQ)) + +lemma fixedSourcePrincipal_prime (S : Finset Id) (hS : ∀P∈S,Prime P) (P : PrimeIdeal) : + idealCoeff (fixedSourcePrincipal S hS) P.val=if P.val∈S then 0 else 1 := by + unfold fixedSourcePrincipal + rw [HeckeRayFamily.idealCoeff_character,RayOrthogonality.idealCharacter_one] + change (if P.val=0 then (0:ℂ) else if IsCoprime P.val (∏Q∈S,Q) then 1 else 0)=_ + simp only [P.property.ne_zero,ite_false,prime_coprime_fixedProduct S hS P] + split_ifs <;> simp_all + +lemma excludedTarget_prime (η : Character) (S : Finset Id) (hS : ∀P∈S,Prime P) (P : PrimeIdeal) : + idealCoeff (η.excludePrimes S hS) P.val=if P.val∈S then 0 else idealCoeff η P.val := by + rw [idealCoeff_excludePrimes] + have he : (∀Q∈S,IsCoprime P.val Q) ↔ P.val∉S := by + rw [←IsCoprime.prod_right_iff] + exact prime_coprime_fixedProduct S hS P + simp only [he] + split_ifs <;> simp_all + +theorem LFunction_hasProd_outside (χ : Character) (S : Finset Id) (a : Id→ℂ) + (ha : ∀P : PrimeIdeal,idealCoeff χ P.val=if P.val∈S then 0 else a P.val) + (s : ℂ) (hs : 1 + (1-a P.val.val*CubicEisenstein.fullIdealWeight s P.val.val)⁻¹) (LFunction χ s) := by + have h := IdealEuler.euler_hasProd (idealCoeff χ) (idealCoeff_norm_le_one χ) s hs + rw [←LFunction_eq_series χ hs] at h + have he (P : PrimeIdeal) : (1-IdealEuler.weighted (idealCoeff χ) s P.val)⁻¹= + if P.val∈S then 1 else (1-a P.val*CubicEisenstein.fullIdealWeight s P.val)⁻¹ := by + change (1-idealCoeff χ P.val*CubicEisenstein.fullIdealWeight s P.val)⁻¹=_ + rw [ha] + split_ifs <;> simp only [zero_mul,sub_zero,inv_one] + simp only [he] at h + apply (hasProd_subtype_iff_mulIndicator (s:={P : PrimeIdeal|P.val∉S}) + (f:=fun P : PrimeIdeal=>(1-a P.val*CubicEisenstein.fullIdealWeight s P.val)⁻¹)).mpr + convert h using 1 + funext P + simp only [Set.mulIndicator,Set.mem_ofPred_eq] + split_ifs <;> simp_all + +theorem fixedSourcePrincipal_hasProd (S : Finset Id) (hS : ∀P∈S,Prime P) + (s : ℂ) (hs : 1 + (1-CubicEisenstein.fullIdealWeight s P.val.val)⁻¹) (LFunction (fixedSourcePrincipal S hS) s) := by + simpa only [one_mul] using + LFunction_hasProd_outside (fixedSourcePrincipal S hS) S (fun _=>1) (fixedSourcePrincipal_prime S hS) s hs + +theorem excludedTarget_hasProd (η : Character) (S : Finset Id) (hS : ∀P∈S,Prime P) + (s : ℂ) (hs : 1 + (1-idealCoeff η P.val.val*CubicEisenstein.fullIdealWeight s P.val.val)⁻¹) + (LFunction (η.excludePrimes S hS) s) := + LFunction_hasProd_outside _ S (idealCoeff η) (excludedTarget_prime η S hS) s hs + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/FrequencySupport.lean b/lean/OAI/NumberTheory/DirichletL/Detector/FrequencySupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..31b7c37be8761048a2a9a81b7f7dda70b20cb002 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/FrequencySupport.lean @@ -0,0 +1,97 @@ +import OAI.NumberTheory.DirichletL.Detector.CalibrationCRT +import OAI.NumberTheory.DirichletL.Detector.PhysicalPoisson + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CubicEisenstein GaussianShiftedPartition CanonicalRowCompletion +open CenteredMomentCommonSupport CenteredMomentFourier +local notation "O" => ActualEisensteinCubic.O + +def elementFourier (c : O) (hc : c≠0) (f : O → ℂ) (H : O) : ℂ := + ∑' x : Residue c, f (representative c x) * quotientTrace c hc (Ideal.Quotient.mk _ H*x) + +lemma elementFourier_congr (c d : O) (hc : c≠0) (hd : d≠0) (f : O → ℂ) (H : O) + (he : c=d) : elementFourier c hc f H = elementFourier d hd f H := by + subst d + rfl + +def movingQuotient (A s : O) (hs : s≠0) (x : Residue (A*s)) : ℂ := + idealRowHom (representative (A*s) x) (Ideal.span {A}) * + sexticGauss s hs (-representative (A*s) x) + +lemma movingQuotient_mk (A s : O) (hs : s≠0) (m : O) : + movingQuotient A s hs (Ideal.Quotient.mk _ m) = + idealRowHom m (Ideal.span {A}) * sexticGauss s hs (-m) := by + have hd : A*s ∣ representative (A*s) (Ideal.Quotient.mk _ m)-m := + Ideal.mem_span_singleton.mp (Ideal.Quotient.eq.mp (representative_spec _ _)) + have hA : representative (A*s) (Ideal.Quotient.mk _ m)-m ∈ (Ideal.span {A}:Ideal O) := + Ideal.mem_span_singleton.mpr ((dvd_mul_right A s).trans hd) + have hs' : -representative (A*s) (Ideal.Quotient.mk _ m)-(-m) ∈ (Ideal.span {s}:Ideal O) := by + apply Ideal.mem_span_singleton.mpr + rw [show -representative (A*s) (Ideal.Quotient.mk _ m)-(-m) = + -(representative (A*s) (Ideal.Quotient.mk _ m)-m) by ring] + exact dvd_neg.mpr ((dvd_mul_left s A).trans hd) + unfold movingQuotient + rw [idealRowHom_congr_mod _ _ _ hA, sexticGauss_frequency_congr s hs _ (-m) hs'] + +lemma physicalFourier_eq_element (C : CalibrationData) (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : + actualPhysicalFourier C A s hA hs H = + elementFourier (C.generator*(A*s)) (mul_ne_zero C.generator_ne_zero (mul_ne_zero hA hs)) + (fun m => C.residueMonoid m * idealRowHom m (Ideal.span {A}) * sexticGauss s hs (-m)) H := by + change elementFourier ((C.generator*A)*s) (mul_ne_zero (mul_ne_zero C.generator_ne_zero hA) hs) + (fun m => C.residueMonoid m * idealRowHom m (Ideal.span {A}) * sexticGauss s hs (-m)) H = _ + apply elementFourier_congr + exact mul_assoc _ _ _ + +lemma physicalFourier_eq_mixed (C : CalibrationData) (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : + actualPhysicalFourier C A s hA hs H = + ∑' x : Residue (C.generator*(A*s)), + C.residue (frequencyReduction C.generator (C.generator*(A*s)) (dvd_mul_right _ _) x) * + movingQuotient A s hs (frequencyReduction (A*s) (C.generator*(A*s)) (dvd_mul_left _ _) x) * + quotientTrace (C.generator*(A*s)) (mul_ne_zero C.generator_ne_zero (mul_ne_zero hA hs)) + (Ideal.Quotient.mk _ H*x) := by + rw [physicalFourier_eq_element] + unfold elementFourier + apply tsum_congr + intro x + have he : Ideal.Quotient.mk (Ideal.span {C.generator*(A*s)}) + (representative (C.generator*(A*s)) x) = x := representative_spec _ _ + have hrA : frequencyReduction C.generator (C.generator*(A*s)) (dvd_mul_right _ _) x = + Ideal.Quotient.mk _ (representative (C.generator*(A*s)) x) := by + conv_lhs => rw [← he] + rfl + have hrB : frequencyReduction (A*s) (C.generator*(A*s)) (dvd_mul_left _ _) x = + Ideal.Quotient.mk _ (representative (C.generator*(A*s)) x) := by + conv_lhs => rw [← he] + rfl + rw [hrA, hrB, movingQuotient_mk] + change _ = (C.residueMonoid _ * (_ * _)) * _ + + ring + +theorem actualPhysicalFourier_zero_off_calibration (S : Finset (Ideal O)) + (hS : ∀ P∈S, P.IsMaximal) (A s : O) (hA : A≠0) (hs : s≠0) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (H : O) + (hH : ¬IsCoprime (calibrationForSet S hS).generator H) : + actualPhysicalFourier (calibrationForSet S hS) A s hA hs H=0 := by + rw [physicalFourier_eq_mixed] + exact calibration_mixed_fourier_zero S hS (A*s) (mul_ne_zero hA hs) hcop (movingQuotient A s hs) H hH + +theorem actualCongruenceCoefficient_zero_off_calibration (S : Finset (Ideal O)) + (hS : ∀ P∈S, P.IsMaximal) (A s : O) (hA : A≠0) (hs : s≠0) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (H : O) + (hH : ¬IsCoprime (calibrationForSet S hS).generator H) : + actualCongruenceCoefficient (calibrationForSet S hS) A s hA H=0 := by + have he := actualPhysicalFourier_zero_off_calibration S hS A s hA hs hcop H hH + rw [actualPhysicalFourier_eq] at he + have hn : (Ideal.absNorm (Ideal.span {s}):ℂ)≠0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hs) + exact (mul_eq_zero.mp he).resolve_left hn + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Gauss.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Gauss.lean new file mode 100644 index 0000000000000000000000000000000000000000..ba723bbd6d79939c8c5c618d28a408dc87694fae --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Gauss.lean @@ -0,0 +1,115 @@ +import Mathlib.NumberTheory.GaussSum +import Mathlib.Analysis.SpecialFunctions.Sqrt +import Mathlib.Tactic.FieldSimp +import Mathlib.Tactic.Ring + +namespace OAI + +namespace SevenEighths.ProbeGauss +open scoped BigOperators Classical +noncomputable section + +def frequencyGauss {F : Type*} [Field F] [Fintype F] + (ξ : MulChar F ℂ) (ψ : AddChar F ℂ) (h : F) : ℂ := + ∑ v : F, ξ v * ψ (h * v) + +theorem frequencyGauss_eq_shift {F : Type*} [Field F] [Fintype F] + (ξ : MulChar F ℂ) (ψ : AddChar F ℂ) (h : F) : + frequencyGauss ξ ψ h = gaussSum ξ (ψ.mulShift h) := rfl + +theorem frequencyGauss_nonzero {F : Type*} [Field F] [Fintype F] + (ξ : MulChar F ℂ) (ψ : AddChar F ℂ) {h : F} (hh : h ≠ 0) : + frequencyGauss ξ ψ h = ξ⁻¹ h * gaussSum ξ ψ := by + exact gaussSum_mulShift_eq ξ ψ (Units.mk0 h hh) + +theorem frequencyGauss_zero_nonprincipal {F : Type*} [Field F] [Fintype F] + (ξ : MulChar F ℂ) (ψ : AddChar F ℂ) (hξ : ξ ≠ 1) : + frequencyGauss ξ ψ 0 = 0 := by + simpa [frequencyGauss] using MulChar.sum_eq_zero_of_ne_one hξ + +theorem frequencyGauss_nonprincipal {F : Type*} [Field F] [Fintype F] + (ξ : MulChar F ℂ) (ψ : AddChar F ℂ) (hξ : ξ ≠ 1) (h : F) : + frequencyGauss ξ ψ h = ξ⁻¹ h * gaussSum ξ ψ := by + by_cases hh : h = 0 + · subst h + rw [frequencyGauss_zero_nonprincipal ξ ψ hξ, MulChar.map_zero, zero_mul] + · exact frequencyGauss_nonzero ξ ψ hh + +theorem frequencyGauss_principal {F : Type*} [Field F] [Fintype F] + (ψ : AddChar F ℂ) (hψ : ψ ≠ 1) (h : F) : + frequencyGauss 1 ψ h = if h = 0 then (Nat.card Fˣ : ℂ) else -1 := by + classical + by_cases hh : h = 0 + · subst h + simpa [frequencyGauss, Nat.card_eq_fintype_card] using + (MulChar.sum_one_eq_card_units (R := F) (R' := ℂ)) + · rw [ite_eq_right hh, frequencyGauss_nonzero _ ψ hh, inv_one, + MulChar.one_apply (isUnit_iff_ne_zero.mpr hh), one_mul] + exact gaussSum_one_left hψ + +theorem gauss_inverse_pair {F : Type*} [Field F] [Fintype F] + (χ : MulChar F ℂ) (ψ : AddChar F ℂ) (hχ : χ ≠ 1) (hψ : ψ.IsPrimitive) : + gaussSum χ ψ * gaussSum χ⁻¹ ψ = χ (-1) * (Fintype.card F : ℂ) := by + rw [← mul_gaussSum_inv_eq_gaussSum χ⁻¹, mul_left_comm, + gaussSum_mul_gaussSum_eq_card hχ hψ, MulChar.inv_apply', inv_neg_one] + +def normalizedGauss {F : Type*} [Field F] [Fintype F] + (χ : MulChar F ℂ) (ψ : AddChar F ℂ) : ℂ := + gaussSum χ ψ / (Real.sqrt (Fintype.card F) : ℂ) + +theorem normalizedGauss_inverse_pair {F : Type*} [Field F] [Fintype F] + (χ : MulChar F ℂ) (ψ : AddChar F ℂ) (hχ : χ ≠ 1) (hψ : ψ.IsPrimitive) : + normalizedGauss χ ψ * normalizedGauss χ⁻¹ ψ = χ (-1) := by + have hq : (Fintype.card F : ℂ) ≠ 0 := by exact_mod_cast Fintype.card_ne_zero + have hs : (Real.sqrt (Fintype.card F) : ℂ) ^ 2 = (Fintype.card F : ℂ) := by + exact_mod_cast Real.sq_sqrt (Nat.cast_nonneg (Fintype.card F) : (0 : ℝ) ≤ _) + unfold normalizedGauss + rw [div_mul_div_comm, ← pow_two, hs, gauss_inverse_pair χ ψ hχ hψ] + exact mul_div_cancel_right₀ _ hq + +theorem finite_gauss_convolution {F : Type*} [Field F] [Fintype F] + (χ ξ : MulChar F ℂ) (ψ : AddChar F ℂ) (h : F) : + (∑ d : F, χ d * frequencyGauss ξ ψ (h - d)) = + χ⁻¹ (-1) * gaussSum χ ψ * frequencyGauss (ξ * χ⁻¹) ψ h := by + classical + have hfreq (v : F) : + ξ v * (∑ d : F, χ d * ψ (-(v * d))) = + χ⁻¹ (-1) * gaussSum χ ψ * (ξ v * χ⁻¹ v) := by + by_cases hv : v = 0 + · subst v + simp [MulChar.map_zero] + · have hn : -v ≠ 0 := neg_ne_zero.mpr hv + have he := gaussSum_mulShift_eq χ ψ (Units.mk0 (-v) hn) + simp only [gaussSum, AddChar.mulShift_apply, Units.val_mk0] at he + have hinv : χ⁻¹ (-v) = χ⁻¹ (-1) * χ⁻¹ v := by rw [← map_mul]; congr 1; ring + rw [hinv] at he + have he' : (∑ d : F, χ d * ψ (-(v * d))) = + (χ⁻¹ (-1) * χ⁻¹ v) * gaussSum χ ψ := by + simpa only [neg_mul, gaussSum] using he + rw [he'] + ring + unfold frequencyGauss + simp_rw [Finset.mul_sum] + rw [Finset.sum_comm] + calc + (∑ v : F, ∑ d : F, χ d * (ξ v * ψ ((h - d) * v))) = + ∑ v : F, ψ (h * v) * (ξ v * ∑ d : F, χ d * ψ (-(v * d))) := by + apply Finset.sum_congr rfl + intro v _ + rw [Finset.mul_sum, Finset.mul_sum] + apply Finset.sum_congr rfl + intro d _ + rw [show (h - d) * v = h * v + -(v * d) by ring, ψ.map_add_eq_mul] + ring + _ = ∑ v : F, ψ (h * v) * + (χ⁻¹ (-1) * gaussSum χ ψ * (ξ v * χ⁻¹ v)) := by simp_rw [hfreq] + _ = ∑ v : F, χ⁻¹ (-1) * gaussSum χ ψ * ((ξ * χ⁻¹) v * ψ (h * v)) := by + apply Finset.sum_congr rfl + intro v _ + rw [MulChar.mul_apply] + ring + +end +end SevenEighths.ProbeGauss + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussValuation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussValuation.lean new file mode 100644 index 0000000000000000000000000000000000000000..6a36e548dcdcd3ea39d326e5351c15c5db11619b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussValuation.lean @@ -0,0 +1,65 @@ +import OAI.NumberTheory.DirichletL.Detector.PrimePower + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem primePowerGauss_at_pow_nonprincipal (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (hχ : χ ≠ 1) (n j : ℕ) : + primePowerGauss p hp.ne_zero χ n (p ^ j) = + if j = n then (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n * primeGauss p hp.ne_zero χ 1 + else 0 := by + by_cases he : j = n + · subst j + rw [ite_eq_left rfl] + simpa only [mul_one] using primePowerGauss_lift p hp.ne_zero χ n 1 + rw [ite_eq_right he] + rcases lt_or_gt_of_ne he with hjn | hnj + · apply primePowerGauss_zero_off_support + rw [pow_dvd_pow_iff hp.ne_zero hp.not_isUnit] + omega + · have hle : n ≤ j := Nat.le_of_lt hnj + have heq : p ^ j = p ^ n * p ^ (j - n) := by rw [← pow_add, Nat.add_sub_of_le hle] + rw [heq] + apply primePowerGauss_nonprincipal_extra_divisibility p hp.ne_zero χ hχ + exact dvd_pow_self p (by omega) + +theorem primePowerGauss_at_pow_principal (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hψ : quotientTrace p hp.ne_zero ≠ 1) (n j : ℕ) : + primePowerGauss p hp.ne_zero 1 n (p ^ j) = + (if n + 1 ≤ j then (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ (n + 1) else 0) - + (if n ≤ j then (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n else 0) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Finite (O ⧸ Ideal.span {p}) := ConcreteTraceCRT.finite_quotient_span hp.ne_zero + have hcard : (Nat.card (O ⧸ Ideal.span {p})ˣ : ℂ) = + (Ideal.absNorm (Ideal.span {p}) : ℂ) - 1 := by + rw [Nat.card_units, Nat.cast_sub (Nat.card_pos : 0 < Nat.card (O ⧸ Ideal.span {p})), + Nat.cast_one] + rfl + rcases lt_trichotomy j n with hjn | he | hnj + · rw [ite_eq_right (by omega), ite_eq_right (by omega), sub_self] + apply primePowerGauss_zero_off_support + rw [pow_dvd_pow_iff hp.ne_zero hp.not_isUnit] + omega + · subst j + have hnot : ¬p ∣ (1 : O) := by simpa only [isUnit_iff_dvd_one] using hp.not_isUnit + simpa only [mul_one, ite_eq_right hnot, ite_eq_right (Nat.not_succ_le_self n), + ite_eq_left (le_refl n), zero_sub, mul_neg_one] using + primePowerGauss_principal p hp.ne_zero hψ n 1 + · have hle : n ≤ j := by omega + have heq : p ^ j = p ^ n * p ^ (j - n) := by rw [← pow_add, Nat.add_sub_of_le hle] + have hd : p ∣ p ^ (j - n) := dvd_pow_self p (by omega) + rw [heq, primePowerGauss_principal, ite_eq_left hd, ite_eq_left (by omega : n + 1 ≤ j), + ite_eq_left hle, hcard, pow_succ] + ring + exact hψ + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCommon.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCommon.lean new file mode 100644 index 0000000000000000000000000000000000000000..ab1e3bff726fd851a0091cc43ac98a765881f3ad --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCommon.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianSubset + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory +namespace SevenEighths.ProbePhysical +local notation "O" => ActualEisensteinCubic.O + +theorem compensatedPhysicalProbe_common_gaussian {K : ℕ} + (W : Fin K→ℝ→ℂ) (M : Fin K→ℝ) (hM : ∀i,0≤M i) + (hwindow : ∀i y,W i (Real.exp y)≠0→|y|≤M i) : + ∃V : Finset (Fin K)→SchwartzMap ℝ ℂ, + ∃hV : ∀A,HasCompactSupport (V A:ℝ→ℂ), + (∀N : ℕ,∀s : ℝ,0((2:ℝ)^j)^s*gaussianJointMoment (V A) (hV A) N ((2:ℝ)^j/Z)) ∧ + (∑'j : ℕ,((2:ℝ)^j)^s*gaussianJointMoment (V A) (hV A) N ((2:ℝ)^j/Z))≤B*Z^s) ∧ + (∀η : HeckeFamily.Character,∀C : CalibrationData,∀W0 W1 : ℝ→ℂ, + HasCompactSupport W0→HasCompactSupport W1→ + ∀slotPrimes : Fin K→Finset O,(∀i a,a∈slotPrimes i→a≠0)→ + ∀P : Fin K→ℝ,(∀i,0

(p i).val) A* + compensationRowTest η C W0 W1 (fun i=>(p i).val) A X Y ((2:ℝ)^j) t* + selectedSlotFactor W P (fun i=>(p i).val) A t)* + gaussianJointDensity (V A) (hV A) ((2:ℝ)^j/(Z*∏i∈Finset.univ\A,P i)) t) := by + choose V hV hsep hbound using fun A : Finset (Fin K)=> + gaussian_selected_slot_family (fun i : SelectedSlot A=>W i.val) + (fun i : SelectedSlot A=>M i.val) (fun i=>hM i.val) (fun i=>hwindow i.val) + refine ⟨V,hV,?_,?_⟩ + · intro N s hs + choose B hB hb using fun A : Finset (Fin K)=>gaussianJointMoment_summed (V A) (hV A) N s hs + let B0 := (∑A∈(Finset.univ : Finset (Fin K)).powerset,B A)+1 + have hB0 : 0(hB A).le) + dsimp only [B0] + linarith + refine ⟨B0,hB0,?_⟩ + intro A Z hZ + obtain ⟨hsm,hbd⟩ := hb A Z hZ + refine ⟨hsm,hbd.trans ?_⟩ + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg hZ.le s) + have hm : A∈(Finset.univ : Finset (Fin K)).powerset := Finset.mem_powerset.mpr (Finset.subset_univ A) + have hh := Finset.single_le_sum (fun A _=>(hB A).le) hm + dsimp only [B0] + linarith + · intro η C W0 W1 hW0 hW1 slotPrimes hp P hP X Y Z hX hY hZ + rw [compensatedPhysicalProbe_eq_subsets] + apply Finset.sum_congr rfl + intro A hA + exact compensation_subset_common A W (V A) (hV A) (hsep A) η C W0 W1 hW0 hW1 Finset.univ + (fun p : ((i : Fin K)→{a : O // a∈slotPrimes i})=>fun i=>(p i).val) + (fun p _ i=>hp i (p i).val (p i).property) P hP X Y Z hX hY hZ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCompensation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCompensation.lean new file mode 100644 index 0000000000000000000000000000000000000000..27cc33df0202e1693b98d38bc9032c7c3de475a4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCompensation.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianPhysicalTuple +import OAI.NumberTheory.DirichletL.Detector.PhysicalNorms + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory FourierBridge CompletedGauss +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma physicalElementNorm_pos (a : O) (ha : a≠0) : 0 simp [slotProduct,elementNorm_one] + | @insert i J hi ih => simpa only [slotProduct,Finset.prod_insert hi,elementNorm_mul] using congrArg (fun x=>elementNorm (p i)*x) ih + +lemma slotProduct_nonzero {K : ℕ} (p : Fin K→O) (hp : ∀i,p i≠0) (J : Finset (Fin K)) : + slotProduct p J≠0 := Finset.prod_ne_zero_iff.mpr (fun i _=>hp i) + +lemma slotProduct_norm_pos {K : ℕ} (p : Fin K→O) (hp : ∀i,p i≠0) (J : Finset (Fin K)) : + 0(p i).val) J X Y Z := by + unfold compensatedPhysicalProbe + simp_rw [compensatedTuple_eq_subsets,Finset.mul_sum] + exact Finset.sum_comm + +theorem compensationSubsetProbe_eq_gaussian_rows {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W0 W1 : ℝ→ℂ) (hW0 : HasCompactSupport W0) (hW1 : HasCompactSupport W1) + (p : Fin K→O) (hp : ∀i,p i≠0) (J : Finset (Fin K)) + (X Y Z : ℝ) (hX : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma correctedSummand_normTwisted (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (W : ℝ→ℂ) (T t : ℝ) (I J : Id) : + correctedSummand S D Ψ (CompletedHeight.normTwistedSource W t) T I J= + logPhase t (Real.log ((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/T))* + correctedSummand S D Ψ W T I J := by + unfold correctedSummand markedSummand CompletedGauss.summand Vstar + CompletedHeight.normTwistedSource + ring + +lemma correctedSummand_fixed_finite (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (T : ℝ) (hT : 0correctedSummand S D Ψ gaussianFixedWindow T p.1 p.2)).Finite := by + apply (completedT_finite_support Ψ gaussianFixedWindow gaussianFixedWindow_compact T hT).subset + intro p hp hz + exact hp (by simp only [correctedSummand,markedSummand,hz,mul_zero]) + +lemma gaussian_slot_integrable {ι : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (q : ι→ℝ) (b : SchwartzMap ℝ ℂ) (x : ℝ) (c : ℂ) : + Integrable (fun t : ℝ=>logPhase t x*c* + (∏i,W i (q i)*logPhase (-t) (Real.log (q i)))*b t) := by + have hh : Integrable (fun t : ℝ=>b t*(logPhase t x*c* + ∏i,W i (q i)*logPhase (-t) (Real.log (q i)))) := by + apply b.integrable.mul_bdd (c:=‖c‖*∏i,‖W i (q i)‖) + · apply Continuous.aestronglyMeasurable + apply Continuous.mul ((logPhase_continuous_left x).mul_const c) + apply continuous_finsetProd + intro i hi + exact ((logPhase_continuous_left (Real.log (q i))).comp continuous_neg).const_mul _ + · apply Filter.Eventually.of_forall + intro t + simp only [norm_mul,norm_prod,logPhase_norm,mul_one,one_mul,le_refl] + simpa only [mul_comm (b _) _] using hh + +lemma gaussian_selected_summand {ι : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (hsep : ∀R : ℝ,0hq i) + have hh := hsep ((2:ℝ)^j/Z) (div_pos hT hZ) _ hN q hq + have he : (2:ℝ)^j/Z*((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/(2:ℝ)^j)/(∏i,q i)= + (2:ℝ)^j*((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/(2:ℝ)^j)/(Z*∏i,q i) := by ring + rw [he] at hh + unfold correctedSummand markedSummand CompletedGauss.summand + rw [gaussianDyadicProfile_Vstar _ _ _ hN] + let c : ℂ := completedCorrection I J*completedMask S D I J* + (columnWeight Ψ I/(Real.sqrt (Ideal.absNorm I):ℂ))*cubeWeight Ψ J + calc + _ = c*(gaussianAnnulus ((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/(2:ℝ)^j)* + (∏i,W i (q i))*gaussianMellinProfile + ((2:ℝ)^j*((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/(2:ℝ)^j)/(Z*∏i,q i))) := by dsimp [c]; ring + _ = c*∫t : ℝ,Vstar (CompletedHeight.normTwistedSource gaussianFixedWindow t) + ((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/(2:ℝ)^j)* + (∏i,W i (q i)*logPhase (-t) (Real.log (q i)))* + gaussianJointDensity V hV ((2:ℝ)^j/Z) t := by rw [hh] + _ = _ := by + rw [←integral_const_mul] + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp [c] + ring + +lemma correctedSummand_gaussian_factor (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (Z : ℝ) (j : ℕ) (I J : Id) : + correctedSummand S D Ψ (gaussianDyadicProfile Z j) ((2:ℝ)^j) I J= + gaussianMellinProfile (((2:ℝ)^j/Z)*((Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3/(2:ℝ)^j))* + correctedSummand S D Ψ gaussianFixedWindow ((2:ℝ)^j) I J := by + rw [gaussianDyadicProfile_factor] + unfold correctedSummand markedSummand CompletedGauss.summand Vstar + ring + +lemma gaussian_selected_completed_integrable {ι : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (q : ι→ℝ) (b : SchwartzMap ℝ ℂ) + (S : Finset Id) (D : Id) (Ψ : O→*ℂ) (T : ℝ) (hT : 0correctedCompletedT S D Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T* + (∏i,W i (q i)*logPhase (-t) (Real.log (q i)))*b t) := by + let hf := correctedSummand_fixed_finite S D Ψ T hT + have hz (p : Id×Id) (hp : p∉hf.toFinset) : + correctedSummand S D Ψ gaussianFixedWindow T p.1 p.2=0 := by + simpa only [Set.Finite.mem_toFinset,Function.mem_support,not_not] using hp + have hr (t : ℝ) : correctedCompletedT S D Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T= + ∑p∈hf.toFinset,correctedSummand S D Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T p.1 p.2 := by + exact tsum_eq_sum (fun p hp=>by rw [correctedSummand_normTwisted,hz p hp,mul_zero]) + simp_rw [hr,Finset.sum_mul] + apply integrable_finsetSum + intro p hp + simp_rw [correctedSummand_normTwisted] + exact gaussian_slot_integrable W q b _ _ + +theorem gaussian_selected_completed {ι : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (hsep : ∀R : ℝ,0by rw [correctedSummand_gaussian_factor,hz p hp,mul_zero]) + have hr (t : ℝ) : correctedCompletedT S D Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j)= + ∑p∈hf.toFinset,correctedSummand S D Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j) p.1 p.2 := by + exact tsum_eq_sum (fun p hp=>by rw [correctedSummand_normTwisted,hz p hp,mul_zero]) + have hi (p : Id×Id) : Integrable (fun t : ℝ=> + correctedSummand S D Ψ (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j) p.1 p.2* + (∏i,W i (q i)*logPhase (-t) (Real.log (q i)))* + gaussianJointDensity V hV ((2:ℝ)^j/Z) t) := by + simp_rw [correctedSummand_normTwisted] + exact gaussian_slot_integrable W q _ _ _ + rw [hl,Finset.mul_sum] + simp_rw [hr,Finset.sum_mul] + rw [integral_finsetSum _ (fun p _=>hi p)] + apply Finset.sum_congr rfl + intro p hp + exact gaussian_selected_summand W V hV hsep S D Ψ Z hZ j q hq p.1 p.2 + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCompletion.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCompletion.lean new file mode 100644 index 0000000000000000000000000000000000000000..df898d322013e3d8375a637df488a2da73a31ca3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCompletion.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianMellin +import OAI.NumberTheory.DirichletL.Detector.PhysicalAnalytic + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeRow ProbeCompleted CompletedGauss CubicEisenstein +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def gaussianCompletedProfile (y : ℝ) : ℂ := gaussianMellinProfile y/(Real.sqrt y:ℂ) + +lemma gaussianCompleted_Vstar (y : ℝ) (hy : 0correctedSummand S D Ψ gaussianCompletedProfile Z p.1 p.2) := by + have hs : Summable (fun p : Id×Id=>∫v : ℝ,‖mellinSummand S D Ψ 2 Z p v‖) := by + simp only [mellinSummand_integral_norm S D Ψ 2 Z hZ] + exact (spectralRow_summable S D Ψ hΨ (2:ℂ) (by norm_num)).norm.mul_right _ + have hi : Summable (fun p : Id×Id=>∫v : ℝ,mellinSummand S D Ψ 2 Z p v) := by + apply Summable.of_norm + exact Summable.of_nonneg_of_le (fun _=>norm_nonneg _) (fun p=>norm_integral_le_integral_norm _) hs + have hh := hi.mul_left (((1/(2*Real.pi):ℝ):ℂ)) + simpa only [gaussian_mellinSummand S D Ψ 2 Z hZ] using hh + +theorem spectralRow_eq_gaussianCompleted (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (hΨ : ∀n,‖Ψ n‖≤1) (σ : ℝ) (hσ : 1<σ) (Z : ℝ) (hZ : 0(Z:ℂ)^t*Complex.exp (t^2)*spectralRow S D Ψ t)= + correctedCompletedT S D Ψ gaussianCompletedProfile Z := by + rw [verticalIntegral,spectralRow_integral_eq_tsum S D Ψ hΨ σ hσ Z hZ,←tsum_mul_left] + unfold correctedCompletedT + apply tsum_congr + intro p + exact gaussian_mellinSummand S D Ψ σ Z hZ p.1 p.2 + +theorem markedPhysicalProbe_eq_gaussian (η : HeckeFamily.Character) (C : CalibrationData) + (D : Id) (W0 W1 : ℝ→ℂ) (X Y Z : ℝ) (hZ : 0(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖) ∧ + (∫t : ℝ,(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖)≤C*R^(-A)) := by + let T := ∑i,|a i| *M i + have hT : 0≤T := Finset.sum_nonneg (fun i _=>mul_nonneg (abs_nonneg _) (hM i)) + obtain ⟨φ,hφc,hφs,hφone,hφsupp,_⟩ := FourierBridge.exists_complex_smooth_cutoff T hT + let V : SchwartzMap ℝ ℂ := hφc.toSchwartzMap hφs + have hV : HasCompactSupport (V:ℝ→ℂ) := hφc + have hbox : ∀s,V s≠0→|s|≤T+1 := by + intro s hs + have hh := hφsupp (subset_tsupport φ hs) + exact abs_le.mpr hh + refine ⟨V,hV,?_,?_⟩ + · intro R hR y + apply gaussian_coupled_separation W a y V hV R hR + exact FourierBridge.coupled_cutoff_active W φ a y M hwindow (by simpa only [T] using hφone) + · intro A J + obtain ⟨C,hC,hbound⟩ := gaussianLogWindow_fourier_moment V hV (T+1) (by linarith) hbox A J + refine ⟨C,hC,?_⟩ + intro R hR + exact ⟨JointLogSeparation.weighted_schwartz_integrable (gaussianJointDensity V hV R) J,hbound R hR⟩ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCrude.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCrude.lean new file mode 100644 index 0000000000000000000000000000000000000000..abdf068d2850adac40f442ddc7990bb04fa76a9c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianCrude.lean @@ -0,0 +1,99 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianTuple + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow CompletedGauss CubicEisenstein FourierBridge +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma gaussianAnnulus_norm_le_one (y : ℝ) : ‖gaussianAnnulus y‖≤1 := by + rw [gaussianAnnulus_norm] + change Real.smoothTransition (2-y)-Real.smoothTransition (2-2*y)≤1 + linarith [Real.smoothTransition.le_one (2-y),Real.smoothTransition.nonneg (2-2*y)] + +lemma gaussianAnnulus_scaled_square (N T : ℝ) (hN : 0by unfold rowMajorant;positivity) + refine ⟨4*M+1,by positivity,?_⟩ + intro S D Ψ hΨ T t hT + have hs := correctedSummand_summable S D Ψ _ (gaussianFixedWindow_twist_compact t) T hT + change ‖∑'p : Id×Id,correctedSummand S D Ψ (CompletedHeight.normTwistedSource gaussianFixedWindow t) T p.1 p.2‖≤_ + calc + _ ≤ ∑'p : Id×Id,‖correctedSummand S D Ψ (CompletedHeight.normTwistedSource gaussianFixedWindow t) T p.1 p.2‖ := norm_tsum_le_tsum_norm hs.norm + _ ≤ ∑'p : Id×Id,4*T^2*rowMajorant 2 p := hs.norm.tsum_le_tsum + (fun p=>gaussianFixedWindow_summand_crude S D Ψ hΨ T t hT p.1 p.2) + ((rowMajorant_summable 2 (by norm_num)).mul_left (4*T^2)) + _ = (4*M)*T^2 := by rw [tsum_mul_left];dsimp only [M];ring + _ ≤ _ := by nlinarith [sq_nonneg T] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDecomposition.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..6516b3a43e8574749aee349689c32dbc71adae12 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDecomposition.lean @@ -0,0 +1,82 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianWindows + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeRow ProbeCompleted CompletedGauss +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma annular_reassembly_summable {α : Type*} (a : α→ℂ) (N : α→ℝ) + (ha : Summable a) (hN : ∀p,a p≠0→1≤N p) : + Summable (fun q : α×ℕ=>gaussianAnnulus (N q.1/(2:ℝ)^q.2)*a q.1) := by + have hs (p : α) : HasSum (fun j : ℕ=>‖gaussianAnnulus (N p/(2:ℝ)^j)*a p‖) ‖a p‖ := by + by_cases hp : a p=0 + · simp only [hp,mul_zero,norm_zero] + exact hasSum_zero + · simpa only [norm_mul,one_mul] using (gaussianAnnulus_partition_norm (N p) (hN p hp)).mul_right ‖a p‖ + apply Summable.of_norm + apply (summable_prod_of_nonneg (fun _=>norm_nonneg _)).mpr + exact ⟨fun p=>(hs p).summable,by simpa only [fun p=>(hs p).tsum_eq] using ha.norm⟩ + +lemma annular_reassembly {α : Type*} (a : α→ℂ) (N : α→ℝ) + (ha : Summable a) (hN : ∀p,a p≠0→1≤N p) : + (∑'j : ℕ,∑'p : α,gaussianAnnulus (N p/(2:ℝ)^j)*a p)=∑'p,a p := by + rw [Summable.tsum_comm (f:=fun p : α=>fun j : ℕ=>gaussianAnnulus (N p/(2:ℝ)^j)*a p) + (annular_reassembly_summable a N ha hN)] + apply tsum_congr + intro p + by_cases hp : a p=0 + · simp [hp] + · simpa only [one_mul] using ((gaussianAnnulus_partition (N p) (hN p hp)).mul_right (a p)).tsum_eq + +lemma gaussian_dyadic_correctedSummand (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (Z : ℝ) (hZ : 0gaussian_correctedSummand_norm_ge_one S D Ψ Z p.1 p.2)).symm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDensityBudget.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDensityBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..995f4fa1be3f4dfc968a6af0494437556dab8e9b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDensityBudget.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianTuple + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory +namespace SevenEighths.ProbePhysical + +def gaussianJointMoment (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (R : ℝ) : ℝ := + ∫t : ℝ,(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖ + +lemma gaussianJointMoment_nonneg (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (R : ℝ) : 0≤gaussianJointMoment V hV J R := by + apply integral_nonneg + intro t + positivity + +lemma gaussianJointMoment_power_bound (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (A : ℝ) : + ∃C : ℝ,0((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z)) ∧ + (∑'j : ℕ,((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z))≤C*Z^s := by + obtain ⟨N,hN⟩ := exists_nat_gt s + obtain ⟨B,hB,hbound⟩ := gaussianJointMoment_polynomial_decay V hV J N + obtain ⟨C,hC,hkernel⟩ := CompletedDyadic.kernel_sum_bound s (N:ℝ) hs hN + refine ⟨B*C,by positivity,?_⟩ + intro Z hZ + obtain ⟨hks,hkt⟩ := hkernel Z⁻¹ (inv_pos.mpr hZ) + have hb (j : ℕ) : ((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z)≤ + B*CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := by + have hh := mul_le_mul_of_nonneg_left (hbound ((2:ℝ)^j/Z) (div_pos (by positivity) hZ)) + (Real.rpow_nonneg (by positivity : (0:ℝ)≤2^j) s) + simpa only [CompletedDyadic.kernelTerm,Real.rpow_natCast,div_eq_mul_inv,mul_assoc,mul_left_comm,mul_comm] using hh + have hnon (j : ℕ) : 0≤((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z) := + mul_nonneg (Real.rpow_nonneg (by positivity : (0:ℝ)≤2^j) s) (gaussianJointMoment_nonneg V hV J _) + have hsum := Summable.of_nonneg_of_le hnon hb (hks.mul_left B) + refine ⟨hsum,?_⟩ + calc + _ ≤ ∑'j : ℕ,B*CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := hsum.tsum_le_tsum hb (hks.mul_left B) + _ = B*∑'j : ℕ,CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := tsum_mul_left + _ ≤ B*(C*(Z⁻¹)^(-s)) := mul_le_mul_of_nonneg_left hkt hB.le + _ = (B*C)*Z^s := by rw [Real.inv_rpow hZ.le,Real.rpow_neg hZ.le,inv_inv]; ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDerivative.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDerivative.lean new file mode 100644 index 0000000000000000000000000000000000000000..022aea0421700bf32d13df8184f1ef6ae641af10 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianDerivative.lean @@ -0,0 +1,122 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianLow +import Mathlib.Analysis.Complex.Liouville +import Mathlib.Analysis.Complex.RealDeriv +import Mathlib.Analysis.SpecialFunctions.Complex.Analytic + +namespace OAI + +noncomputable section +open scoped Classical ContDiff Topology +open Filter Set Metric +namespace SevenEighths.ProbePhysical + +def gaussianLog (z : ℂ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)*(Real.pi:ℂ)^(1/2:ℂ)*Complex.exp (-(Complex.log z)^2/4) + +lemma gaussianLog_ofReal (y : ℝ) : gaussianLog (y:ℂ)=gaussianMellinProfile y := rfl + +lemma gaussianLog_power_bound (z : ℂ) (hz : z≠0) (a : ℝ) : + ‖gaussianLog z‖≤ + ‖((1/(2*Real.pi):ℝ):ℂ)*(Real.pi:ℂ)^(1/2:ℂ)‖* + Real.exp (Real.pi^2/4+a^2)*‖z‖^(-a) := by + have hre : (-(Complex.log z)^2/4).re= + ((Complex.log z).im^2-(Real.log ‖z‖)^2)/4 := by + simp [pow_two,Complex.mul_re,Complex.log_re] + have hp : (Complex.log z).im^2≤Real.pi^2 := by + have h1 := Complex.log_im_le_pi z + have h2 := Complex.neg_pi_lt_log_im z + nlinarith [mul_nonneg (sub_nonneg.mpr h1) (show 0≤Real.pi+(Complex.log z).im by linarith)] + unfold gaussianLog + rw [norm_mul,Complex.norm_exp,hre,Real.rpow_def_of_pos (norm_pos_iff.mpr hz), + mul_assoc,←Real.exp_add] + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + apply Real.exp_le_exp.mpr + nlinarith [sq_nonneg (Real.log ‖z‖/2-a)] + +lemma iteratedDeriv_restrict_positive (f : ℂ→ℂ) + (hf : ∀x : ℝ,0f (y:ℂ)) x=iteratedDeriv n f (x:ℂ) := by + induction n generalizing f with + | zero => rfl + | succ n ih => + rw [iteratedDeriv_succ',iteratedDeriv_succ'] + have he : Set.EqOn (deriv (fun y : ℝ=>f (y:ℂ))) (fun y : ℝ=>deriv f (y:ℂ)) (Set.Ioi 0) := by + intro y hy + exact (hf y hy).differentiableAt.hasDerivAt.comp_ofReal.deriv + rw [he.iteratedDeriv_of_isOpen isOpen_Ioi n hx] + exact ih (deriv f) (fun y hy=>(hf y hy).deriv) + +lemma gaussianLog_analytic (z : ℂ) (hz : 0gaussianLog ((r:ℂ)*w)) z := by + have h : 0<((r:ℂ)*z).re := by simpa using mul_pos hr hz + exact (gaussianLog_analytic _ h).comp (analyticAt_const.mul analyticAt_id) + +lemma gaussianLog_scaled_disk_bound (a : ℝ) : + ∃C : ℝ,0t^(-a)) (Set.Icc (1/4:ℝ) (9/4)) := by + intro t ht + exact (continuousAt_id.rpow_const (Or.inl (show t≠0 by linarith [ht.1]))).continuousWithinAt + obtain ⟨B,hB⟩ := isCompact_Icc.exists_bound_of_continuousOn hc + have hBpos : 0gaussianMellinProfile (r*x)) y‖≤C*r^(-a) := by + obtain ⟨B,hB,hbound⟩ := gaussianLog_scaled_disk_bound a + refine ⟨(n.factorial:ℝ)*B/(1/4:ℝ)^n,by positivity,?_⟩ + intro r hr y hy + have hf : ∀x : ℝ,0gaussianLog ((r:ℂ)*z)) (x:ℂ) := + fun x hx=>gaussianLog_scaled_analytic r hr (x:ℂ) hx + have he : (fun x : ℝ=>gaussianMellinProfile (r*x))= + (fun x : ℝ=>gaussianLog ((r:ℂ)*(x:ℂ))) := by + funext x + rw [←Complex.ofReal_mul,gaussianLog_ofReal] + rw [he,iteratedDeriv_restrict_positive _ hf n y (by linarith [hy.1])] + have hd : DiffContOnCl ℂ (fun z : ℂ=>gaussianLog ((r:ℂ)*z)) (Metric.ball (y:ℂ) (1/4)) := by + apply DifferentiableOn.diffContOnCl_ball (U:={z : ℂ|0(gaussianLog_scaled_analytic r hr z hz).differentiableAt.differentiableWithinAt) + intro z hz + have hn : ‖z-(y:ℂ)‖≤1/4 := by simpa only [Metric.mem_closedBall,dist_eq_norm] using hz + have ha := (Complex.abs_re_le_norm (z-(y:ℂ))).trans hn + simp only [Complex.sub_re,Complex.ofReal_re,abs_le] at ha + change 0hbound r hr y hy z (Metric.sphere_subset_closedBall hz)) + exact hh.trans_eq (by ring) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianFlow.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianFlow.lean new file mode 100644 index 0000000000000000000000000000000000000000..53be336efd7cc551c43856181a7d2dc215eeb041 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianFlow.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianSummation + +namespace OAI + +noncomputable section +open scoped Classical ContDiff Topology +open Filter Set Metric +namespace SevenEighths.ProbePhysical + +def gaussianFlow (R : ℝ) (z : ℂ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)*(Real.pi:ℂ)^(1/2:ℂ)* + Complex.exp (-((Real.log R:ℂ)+z)^2/4) +lemma gaussianFlow_analytic (R : ℝ) (z : ℂ) : AnalyticAt ℂ (gaussianFlow R) z := by + unfold gaussianFlow + fun_prop +lemma gaussianFlow_real (R : ℝ) (hR : 0f (y:ℂ)) x=iteratedDeriv n f (x:ℂ) := by + induction n generalizing f with + | zero => rfl + | succ n ih => + rw [iteratedDeriv_succ',iteratedDeriv_succ'] + have he : deriv (fun y : ℝ=>f (y:ℂ))=(fun y : ℝ=>deriv f (y:ℂ)) := by + funext y + exact (hf y).differentiableAt.hasDerivAt.comp_ofReal.deriv + rw [he] + exact ih (deriv f) (fun y=>(hf y).deriv) + +lemma gaussianFlow_disk_bound (a L : ℝ) (_hL : 0≤L) : + ∃C : ℝ,0gaussianFlow R (s:ℂ)) y‖≤C*R^(-a) := by + obtain ⟨B,hB,hbound⟩ := gaussianFlow_disk_bound a L hL + refine ⟨(n.factorial:ℝ)*B,by positivity,?_⟩ + intro R hR y hy + rw [iteratedDeriv_restrict_real _ (fun x=>gaussianFlow_analytic R (x:ℂ)) n y] + have hf : Differentiable ℂ (gaussianFlow R) := fun z=>(gaussianFlow_analytic R z).differentiableAt + have h := Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le n + (by norm_num : (0:ℝ)<1) hf.diffContOnCl + (fun z hz=>hbound R hR y hy z (Metric.sphere_subset_closedBall hz)) + simpa only [one_pow,div_one,mul_assoc] using h + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianLogWindow.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianLogWindow.lean new file mode 100644 index 0000000000000000000000000000000000000000..34719c10e7a8026457efaff0acc61de7a530a8eb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianLogWindow.lean @@ -0,0 +1,124 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianFlow + +namespace OAI + +noncomputable section +open scoped Classical ContDiff Topology SchwartzMap FourierTransform +open Filter Set MeasureTheory +namespace SevenEighths.ProbePhysical + +lemma gaussianFlow_real_smooth (R : ℝ) : ContDiff ℝ ∞ (fun s : ℝ=>gaussianFlow R (s:ℂ)) := by + rw [contDiff_iff_contDiffAt] + intro s + have hf : ContDiffAt ℂ ∞ (gaussianFlow R) (s:ℂ) := (gaussianFlow_analytic R _).contDiffAt + exact (hf.restrict_scalars ℝ).comp s Complex.ofRealCLM.contDiff.contDiffAt + +def gaussianLogWindow (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) (R : ℝ) : SchwartzMap ℝ ℂ := + (hV.mul_right (f':=fun s : ℝ=>gaussianFlow R (s:ℂ))).toSchwartzMap + (V.smooth'.mul (gaussianFlow_real_smooth R)) +@[simp] lemma gaussianLogWindow_apply (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (R s : ℝ) : gaussianLogWindow V hV R s=V s*gaussianFlow R (s:ℂ) := rfl + +lemma gaussianLogWindow_derivative_outside (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (L : ℝ) (hbox : ∀s,V s≠0→|s|≤L) (R y : ℝ) (hy : L < |y|) (n : ℕ) : + iteratedDeriv n (gaussianLogWindow V hV R) y=0 := by + have he : (gaussianLogWindow V hV R:ℝ→ℂ)=ᶠ[𝓝 y](fun _=>0) := by + have hu : {x : ℝ | L < |x|}∈𝓝 y := (isOpen_lt continuous_const continuous_abs).mem_nhds hy + filter_upwards [hu] with x hx + have hv : V x=0 := by by_contra h; exact (not_lt_of_ge (hbox x h)) hx + simp only [gaussianLogWindow_apply,hv,zero_mul] + rw [he.iteratedDeriv_eq n] + simp + +lemma gaussianLogWindow_derivative_bound (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (L : ℝ) (hL : 0≤L) (a : ℝ) (n : ℕ) : + ∃C : ℝ,0gaussianFlow_derivative_bound a L hL i + let A (i : ℕ) := SchwartzMap.seminorm ℝ 0 i V + let C := ∑i∈Finset.range (n+1),(n.choose i:ℝ)*A i*B (n-i) + have hA (i : ℕ) : 0≤A i := apply_nonneg _ _ + have hC : 0≤C := Finset.sum_nonneg (fun i _=>mul_nonneg (mul_nonneg (Nat.cast_nonneg _) (hA i)) (hB _).le) + refine ⟨C+1,by positivity,?_⟩ + intro R hR y hy + change ‖iteratedDeriv n (fun s : ℝ=>V s*gaussianFlow R (s:ℂ)) y‖≤_ + rw [iteratedDeriv_fun_mul (f:=(V:ℝ→ℂ)) (g:=fun s : ℝ=>gaussianFlow R (s:ℂ)) + (V.smooth'.contDiffAt.of_le (by simp)) + ((gaussianFlow_real_smooth R).contDiffAt.of_le (by simp))] + calc + _ ≤ ∑i∈Finset.range (n+1),‖(n.choose i:ℂ)*iteratedDeriv i V y* + iteratedDeriv (n-i) (fun s : ℝ=>gaussianFlow R (s:ℂ)) y‖ := norm_sum_le _ _ + _ ≤ ∑i∈Finset.range (n+1),((n.choose i:ℝ)*A i)*(B (n-i)*R^(-a)) := by + apply Finset.sum_le_sum + intro i hi + rw [norm_mul,norm_mul,Complex.norm_natCast] + have hv : ‖iteratedDeriv i V y‖≤A i := by + simpa only [pow_zero,one_mul] using SchwartzMap.le_seminorm' ℝ 0 i V y + exact mul_le_mul (mul_le_mul_of_nonneg_left hv (Nat.cast_nonneg _)) + (hbound _ R hR y hy) (norm_nonneg _) (mul_nonneg (Nat.cast_nonneg _) (hA i)) + _ = C*R^(-a) := by simp only [C,Finset.sum_mul]; apply Finset.sum_congr rfl; intros; ring + _ ≤ (C+1)*R^(-a) := by nlinarith [Real.rpow_pos_of_pos hR (-a)] + +theorem gaussianLogWindow_seminorm (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (L : ℝ) (hL : 0≤L) (hbox : ∀s,V s≠0→|s|≤L) (a : ℝ) (k n : ℕ) : + ∃C : ℝ,0gaussianLogWindow_seminorm V hV L hL hbox a q.1 q.2 + let C := (∑i∈Finset.range (K+1),(B (0,i)+B (p,i)))+1 + have hC : 0add_nonneg (hB _).le (hB _).le) + dsimp only [C]; linarith + let D := (2:ℝ)^J*(FourierBridge.coefficientMomentBound 0 C+FourierBridge.coefficientMomentBound J C) + have hD : 0≤D := mul_nonneg (by positivity) + (add_nonneg (FourierBridge.coefficientMomentBound_nonneg _ _ hC.le) + (FourierBridge.coefficientMomentBound_nonneg _ _ hC.le)) + refine ⟨D+1,by positivity,?_⟩ + intro R hR + have hcancel : R^a*R^(-a)=1 := by rw [←Real.rpow_add hR]; simp + have hsource (i : ℕ) (hi : i≤J+(MeasureTheory.volume : MeasureTheory.Measure ℝ).integrablePower) : + R^a*(SchwartzMap.seminorm ℝ 0 i (gaussianLogWindow V hV R)+ + SchwartzMap.seminorm ℝ p i (gaussianLogWindow V hV R))≤C := by + have hbi : B (0,i)+B (p,i)≤C := by + have hh := Finset.single_le_sum (s:=Finset.range (K+1)) (a:=i) + (f:=fun i=>B (0,i)+B (p,i)) + (fun i _=>add_nonneg (hB _).le (hB _).le) (Finset.mem_range.mpr (by dsimp only [K,p]; omega)) + dsimp only [C]; linarith + calc + _ ≤ R^a*(B (0,i)*R^(-a)+B (p,i)*R^(-a)) := + mul_le_mul_of_nonneg_left (add_le_add (hb (0,i) R hR) (hb (p,i) R hR)) (by positivity) + _ = B (0,i)+B (p,i) := by rw [←add_mul]; calc + _=(B (0,i)+B (p,i))*(R^a*R^(-a)) := by ring + _=_ := by rw [hcancel,mul_one] + _ ≤ C := hbi + have hh := FourierBridge.uniform_fourier_one_plus_moment (gaussianLogWindow V hV R) J + (R^a) C (by positivity) hC.le hsource + change R^a*(∫t : ℝ,(1+‖t‖)^J*‖(𝓕 (gaussianLogWindow V hV R)) t‖)≤D at hh + have hp := mul_le_mul_of_nonneg_left hh (Real.rpow_pos_of_pos hR (-a)).le + have hc' : R^(-a)*R^a=1 := by rw [mul_comm,hcancel] + rw [←mul_assoc,hc',one_mul] at hp + exact hp.trans (by nlinarith [Real.rpow_pos_of_pos hR (-a)]) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianLow.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianLow.lean new file mode 100644 index 0000000000000000000000000000000000000000..2da8c38a79c609a386e61449e0131c4e40f6ea1f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianLow.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianDecomposition +import OAI.NumberTheory.DirichletL.Detector.LowCompletion + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeRow ProbeCompleted CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def gaussianDyadicSchwartz (Z : ℝ) (hZ : 0(Z:ℂ)^t*Complex.exp (t^2)* + spectralRow S D (rowCoefficient η (calibrationForSet S hS).Xi s hs z) t)= + ∑'j : ℕ,∑χ : RayCharacter,correctionCoeff χ* + InverseMoment.markedCompletedT + (CanonicalRowCompletion.rowTwist + (lowPeriodicBase η (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS) s hs χ) + (calibrationForSet S hS).generator 1 z) + (gaussianDyadicSchwartz Z hZ j) ((2:ℝ)^j) + (fun A=>if D∣A then (1:ℂ) else 0) := by + have hΨ := rowCoefficient_norm_le_one η (calibrationForSet S hS).Xi + (calibrationForSet S hS).Xi_norm_le_one s hs z + rw [spectralRow_eq_gaussianCompleted _ _ _ hΨ 4 (by norm_num) Z hZ, + correctedGaussian_eq_tsum_dyadic _ _ _ hΨ Z hZ] + apply tsum_congr + intro j + exact correctedPhysicalRow_eq_periodic_inverse η S hS hbad s hs z D + (gaussianDyadicProfile Z j) (gaussianDyadicProfile_compact Z j) ((2:ℝ)^j) + (by positivity) (calibrationLowData S hS) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianMellin.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianMellin.lean new file mode 100644 index 0000000000000000000000000000000000000000..93c23e9dd51f20828eb7c216ea7f8f17963d9314 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianMellin.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Detector.RowInterchange +import Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical + +def gaussianMellinProfile (y : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)*(Real.pi:ℂ)^(1/2:ℂ)* + Complex.exp (-(Complex.log (y:ℂ))^2/4) + +lemma gaussianMellin_integral (y : ℝ) (hy : 0.symm + +lemma gaussian_completed_norm_power (a b Z : ℝ) (ha : 0gaussianAnnulus (x/(2:ℝ)^j)) 1 := by + obtain ⟨K,hlo,hhi⟩ := exists_nat_pow_near hx (by norm_num : (1:ℝ)<2) + have h : HasSum (fun j : ℕ=>gaussianAnnulus (x/(2:ℝ)^j)) + (∑j∈({K,K+1}:Finset ℕ),gaussianAnnulus (x/(2:ℝ)^j)) := + hasSum_sum_of_ne_finset_zero (gaussianAnnulus_support_scales x K hlo hhi) + convert h using 1 + rw [Finset.sum_pair (by omega : K≠K+1)] + unfold gaussianAnnulus annularCutoff + have he : 2*(x/(2:ℝ)^(K+1))=x/(2:ℝ)^K := by rw [pow_succ]; field_simp + have hh : 2≤2*(x/(2:ℝ)^K) := by + have hq : 1≤x/(2:ℝ)^K := (one_le_div (by positivity)).mpr hlo + linarith + rw [he,gaussianCutoff_small _ ((div_le_one (by positivity)).mpr hhi.le), + gaussianCutoff_large _ hh] + ring + +lemma gaussianAnnulus_partition_norm (x : ℝ) (hx : 1≤x) : + HasSum (fun j : ℕ=>‖gaussianAnnulus (x/(2:ℝ)^j)‖) 1 := by + simpa only [gaussianAnnulus_norm,Complex.one_re] using + Complex.hasSum_re (gaussianAnnulus_partition x hx) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalMass.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..a21222ad91a6a5af3bd852c9581fde2742c62746 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalMass.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianPhysicalTail +import OAI.NumberTheory.DirichletL.Detector.PhysicalCrudeMass + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def gaussianPhysicalScaleMass {α ι : Type*} [Fintype ι] + (C : CalibrationData) (F : Finset α) (a : α→ℂ) (X Y : α→ℝ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) : ℝ := + ∑k∈F,‖a k‖*(∏i,‖W i (q k i)‖)*lowPhysicalScale C (X k) (Y k) + +theorem gaussianPhysicalFamily_mass_bound (a0 b0 a1 b1 B0 B1 : ℝ) + (ha0 : 0if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianPhysicalFamilyIntegral η (calibrationForSet S hS) W0 W1 F a D X Y W q V hV ((2:ℝ)^j) Z‖ else 0) ∧ + (∑'j : ℕ,if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianPhysicalFamilyIntegral η (calibrationForSet S hS) W0 W1 F a D X Y W q V hV ((2:ℝ)^j) Z‖ else 0)≤ + K*gaussianPhysicalScaleMass (calibrationForSet S hS) F a X Y W q*Z^2/A^N := by + obtain ⟨C0,hC0,hremote⟩ := gaussianPhysicalFamily_remote V hV N + obtain ⟨C1,hC1,hmass⟩ := gaussianPhysicalFamily_mass_bound a0 b0 a1 b1 B0 B1 ha0 ha1 hB0 hB1 + refine ⟨C0*C1,mul_pos hC0 hC1,?_⟩ + intro α ι _ η S hS W0 W1 hW0c hW1c hW0 hW1 hWB0 hWB1 F a D X Y hX hY W q Z A hZ hA + have hh := hremote η (calibrationForSet S hS) W0 W1 hW0c hW1c F a D X Y + (fun k hk=>lt_of_lt_of_le zero_lt_one (hX k hk)) (fun k hk=>lt_of_lt_of_le zero_lt_one (hY k hk)) W q Z A hZ hA + refine ⟨hh.1,hh.2.trans ?_⟩ + have hm := hmass S hS W0 W1 hW1c hW0 hW1 hWB0 hWB1 F a X Y hX hY W q + calc + _ ≤ C0*(C1*gaussianPhysicalScaleMass (calibrationForSet S hS) F a X Y W q)*Z^2/A^N := by gcongr + _ = _ := by ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalTail.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..aba66de9cd8706525de01af2206469e797901494 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalTail.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianRemoteRows +import OAI.NumberTheory.DirichletL.Detector.GaussianPhysicalTuple + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory CompletedGauss FourierBridge +namespace SevenEighths.ProbePhysical +open ProbeCompleted +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def gaussianPhysicalFamilyIntegral {α ι : Type*} [Fintype ι] + (η : HeckeFamily.Character) (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (F : Finset α) (a : α→ℂ) (D : α→Id) (X Y : α→ℝ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (T Z : ℝ) : ℂ := + ∫t : ℝ,(∑k∈F,a k* + (∑'r : PhysicalRowIndex,physicalRowWeight C W0 W1 (X k) (Y k) r* + correctedCompletedT C.excluded (D k) (physicalRowMonoid η C r) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T)* + (∏i,W i (q k i)*logPhase (-t) (Real.log (q k i))))*gaussianJointDensity V hV (T/Z) t + +def gaussianPhysicalFamilyMass {α ι : Type*} [Fintype ι] + (C : CalibrationData) (W0 W1 : ℝ→ℂ) (F : Finset α) (a : α→ℂ) (X Y : α→ℝ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) : ℝ := + ∑k∈F,‖a k‖*(∏i,‖W i (q k i)‖)*∑'r : PhysicalRowIndex,‖physicalRowWeight C W0 W1 (X k) (Y k) r‖ + +lemma gaussianPhysicalFamily_mass_eq {α ι : Type*} [Fintype ι] + (C : CalibrationData) (W0 W1 : ℝ→ℂ) (F : Finset α) (a : α→ℂ) (X Y : α→ℝ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) (R : Finset PhysicalRowIndex) + (hR : ∀k∈F,∀r∉R,physicalRowWeight C W0 W1 (X k) (Y k) r=0) : + gaussianCompletedFamilyMass (F×ˢR) + (fun p=>a p.1*physicalRowWeight C W0 W1 (X p.1) (Y p.1) p.2) W (fun p=>q p.1)= + gaussianPhysicalFamilyMass C W0 W1 F a X Y W q := by + unfold gaussianCompletedFamilyMass gaussianPhysicalFamilyMass + rw [Finset.sum_product] + apply Finset.sum_congr rfl + intro k hk + rw [tsum_eq_sum (s:=R) (fun r hr=>by rw [hR k hk r hr,norm_zero]),Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + rw [norm_mul] + ring + +lemma gaussianPhysicalFamily_integral_eq {α ι : Type*} [Fintype ι] + (η : HeckeFamily.Character) (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (F : Finset α) (a : α→ℂ) (D : α→Id) (X Y : α→ℝ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (T Z : ℝ) (R : Finset PhysicalRowIndex) + (hR : ∀k∈F,∀r∉R,physicalRowWeight C W0 W1 (X k) (Y k) r=0) : + gaussianPhysicalFamilyIntegral η C W0 W1 F a D X Y W q V hV T Z= + gaussianCompletedFamilyIntegral (F×ˢR) + (fun p=>a p.1*physicalRowWeight C W0 W1 (X p.1) (Y p.1) p.2) + C.excluded (fun p=>D p.1) (fun p=>physicalRowMonoid η C p.2) W (fun p=>q p.1) V hV T Z := by + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp only + congr 1 + rw [Finset.sum_product] + apply Finset.sum_congr rfl + intro k hk + rw [tsum_eq_sum (s:=R) (fun r hr=>by rw [hR k hk r hr,zero_mul]),Finset.mul_sum,Finset.sum_mul] + apply Finset.sum_congr rfl + intro r hr + ring + +theorem gaussianPhysicalFamily_remote (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (N : ℕ) : + ∃C0 : ℝ,0if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianPhysicalFamilyIntegral η C W0 W1 F a D X Y W q V hV ((2:ℝ)^j) Z‖ else 0) ∧ + (∑'j : ℕ,if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianPhysicalFamilyIntegral η C W0 W1 F a D X Y W q V hV ((2:ℝ)^j) Z‖ else 0)≤ + C0*gaussianPhysicalFamilyMass C W0 W1 F a X Y W q*Z^2/A^N := by + obtain ⟨C0,hC0,hb⟩ := gaussianCompletedFamily_remote V hV N + refine ⟨C0,hC0,?_⟩ + intro α ι _ η C W0 W1 hW0 hW1 F a D X Y hX hY W q Z A hZ hA + obtain ⟨R,hR⟩ := physicalRows_common_finset C W0 W1 hW0 hW1 F X Y hX hY + have hh := hb (F×ˢR) (fun p=>a p.1*physicalRowWeight C W0 W1 (X p.1) (Y p.1) p.2) + C.excluded (fun p=>D p.1) (fun p=>physicalRowMonoid η C p.2) + (fun p _=>physicalRowMonoid_norm η C p.2) W (fun p=>q p.1) Z A hZ hA + rw [gaussianPhysicalFamily_mass_eq C W0 W1 F a X Y W q R hR] at hh + simpa only [gaussianPhysicalFamily_integral_eq η C W0 W1 F a D X Y W q V hV _ Z R hR] using hh + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalTuple.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalTuple.lean new file mode 100644 index 0000000000000000000000000000000000000000..7a7cf5ba841a86ce103bf7fab8e169e88954c8dc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianPhysicalTuple.lean @@ -0,0 +1,116 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalRows +import OAI.NumberTheory.DirichletL.Detector.GaussianDensityBudget + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory FourierBridge CompletedGauss +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma physicalRows_common_finset {α : Type*} (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (hW0 : HasCompactSupport W0) (hW1 : HasCompactSupport W1) + (F : Finset α) (X Y : α→ℝ) (hX : ∀k∈F,0(hf k).toFinset) + refine ⟨R,?_⟩ + intro k hk r hr + by_contra hn + apply hr + exact Finset.mem_biUnion.mpr ⟨⟨k,hk⟩,by simp,by simpa only [Set.Finite.mem_toFinset,Function.mem_support] using hn⟩ + +theorem physical_selected_gaussian_reassembly {ι α : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (hsep : ∀R : ℝ,0by rw [hR k hk r hr,zero_mul]) + let A (p : α×PhysicalRowIndex) := a p.1*physicalRowWeight C W0 W1 (X p.1) (Y p.1) p.2 + have hh := gaussian_selected_tuple_reassembly W V hV hsep (F×ˢR) A C.excluded + (fun p=>D p.1) (fun p=>physicalRowMonoid η C p.2) + (fun p _=>physicalRowMonoid_norm η C p.2) Z hZ (fun p=>q p.1) + (fun p hp=>hq p.1 (Finset.mem_product.mp hp).1) + calc + _ = ∑p∈F×ˢR,A p*(∏i,W i (q p.1 i))*correctedCompletedT C.excluded (D p.1) + (physicalRowMonoid η C p.2) gaussianCompletedProfile (Z*∏i,q p.1 i) := by + rw [Finset.sum_product] + apply Finset.sum_congr rfl + intro k hk + rw [markedPhysicalProbe_eq_gaussian_rows η C (D k) W0 W1 hW0 hW1 + (X k) (Y k) _ (hX k hk) (hY k hk) (mul_pos hZ (Finset.prod_pos (fun i _=>hq k hk i))),hs k hk] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro r hr + dsimp [A] + ring + _ = _ := hh + _ = _ := by + apply tsum_congr + intro j + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp only + congr 1 + rw [Finset.sum_product] + apply Finset.sum_congr rfl + intro k hk + rw [hs k hk,Finset.mul_sum,Finset.sum_mul] + apply Finset.sum_congr rfl + intro r hr + dsimp [A] + ring + +theorem physical_selected_gaussian_family {ι α : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (M : ι→ℝ) (hM : ∀i,0≤M i) + (hwindow : ∀i y,W i (Real.exp y)≠0→|y|≤M i) : + ∃V : SchwartzMap ℝ ℂ,∃hV : HasCompactSupport (V:ℝ→ℂ), + (∀J : ℕ,∀s : ℝ,0((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z)) ∧ + (∑'j : ℕ,((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z))≤B*Z^s) ∧ + (∀η : HeckeFamily.Character,∀C : CalibrationData,∀W0 W1 : ℝ→ℂ, + HasCompactSupport W0→HasCompactSupport W1→ + ∀F : Finset α,∀a : α→ℂ,∀D : α→Id,∀X Y : α→ℝ, + (∀k∈F,0gaussianJointMoment_summed V hV J s hs,?_⟩ + intro η C W0 W1 hW0 hW1 F a D X Y hX hY Z hZ q hq + exact physical_selected_gaussian_reassembly W V hV hsep η C W0 W1 hW0 hW1 + F a D X Y hX hY Z hZ q hq + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianRemoteRows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianRemoteRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..fe1c355f4e81cc29738433f44b9295f079556785 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianRemoteRows.lean @@ -0,0 +1,122 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianCrude +import OAI.NumberTheory.DirichletL.Detector.GaussianTailBudget + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory CompletedGauss FourierBridge +namespace SevenEighths.ProbePhysical +open ProbeCompleted +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def gaussianCompletedFamilyIntegral {α ι : Type*} [Fintype ι] + (F : Finset α) (a : α→ℂ) (S : Finset Id) (D : α→Id) (Ψ : α→O→*ℂ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (T Z : ℝ) : ℂ := + ∫t : ℝ,(∑k∈F,a k*correctedCompletedT S (D k) (Ψ k) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T* + (∏i,W i (q k i)*logPhase (-t) (Real.log (q k i))))*gaussianJointDensity V hV (T/Z) t + +def gaussianCompletedFamilyMass {α ι : Type*} [Fintype ι] + (F : Finset α) (a : α→ℂ) (W : ι→ℝ→ℂ) (q : α→ι→ℝ) : ℝ := + ∑k∈F,‖a k‖*∏i,‖W i (q k i)‖ + +lemma gaussianCompletedFamilyMass_nonneg {α ι : Type*} [Fintype ι] + (F : Finset α) (a : α→ℂ) (W : ι→ℝ→ℂ) (q : α→ι→ℝ) : + 0≤gaussianCompletedFamilyMass F a W q := by + unfold gaussianCompletedFamilyMass + positivity + +lemma gaussianCompletedFamily_integrable {α ι : Type*} [Fintype ι] + (F : Finset α) (a : α→ℂ) (S : Finset Id) (D : α→Id) (Ψ : α→O→*ℂ) + (W : ι→ℝ→ℂ) (q : α→ι→ℝ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (T Z : ℝ) (hT : 0(∑k∈F,a k*correctedCompletedT S (D k) (Ψ k) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T* + (∏i,W i (q k i)*logPhase (-t) (Real.log (q k i))))*gaussianJointDensity V hV (T/Z) t) := by + have hh := integrable_finsetSum F (fun k _=>(gaussian_selected_completed_integrable W (q k) + (gaussianJointDensity V hV (T/Z)) S (D k) (Ψ k) T hT).const_mul (a k)) + simpa only [Finset.sum_mul,mul_assoc] using hh + +theorem gaussianCompletedFamily_crude : + ∃C : ℝ,0norm_nonneg _)) + _ = _ := by unfold gaussianCompletedFamilyMass;rw [Finset.mul_sum];congr 1;funext k;ring + calc + _ ≤ ∫t : ℝ,‖(∑k∈F,a k*correctedCompletedT S (D k) (Ψ k) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T* + (∏i,W i (q k i)*logPhase (-t) (Real.log (q k i))))*gaussianJointDensity V hV (T/Z) t‖ := + norm_integral_le_integral_norm _ + _ ≤ ∫t : ℝ,(C*T^2*gaussianCompletedFamilyMass F a W q)*‖gaussianJointDensity V hV (T/Z) t‖ := + integral_mono hf.norm ((gaussianJointDensity V hV (T/Z)).integrable.norm.const_mul _) hp + _ = _ := by simp only [integral_const_mul,gaussianJointMoment,pow_zero,one_mul] + +theorem gaussianCompletedFamily_remote (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (N : ℕ) : + ∃C : ℝ,0if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianCompletedFamilyIntegral F a S D Ψ W q V hV ((2:ℝ)^j) Z‖ else 0) ∧ + (∑'j : ℕ,if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianCompletedFamilyIntegral F a S D Ψ W q V hV ((2:ℝ)^j) Z‖ else 0)≤ + C*gaussianCompletedFamilyMass F a W q*Z^2/A^N := by + obtain ⟨Cr,hCr,hr⟩ := gaussianCompletedFamily_crude + obtain ⟨Cg,hCg,hg⟩ := gaussianRemoteMoment_summed V hV 0 N 2 (by norm_num) + refine ⟨Cr*Cg,by positivity,?_⟩ + intro α ι _ F a S D Ψ hΨ W q Z A hZ hA + obtain ⟨hs,ht⟩ := hg Z A hZ hA + let M := gaussianCompletedFamilyMass F a W q + have hM : 0≤M := gaussianCompletedFamilyMass_nonneg F a W q + have hb (j : ℕ) : + (if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianCompletedFamilyIntegral F a S D Ψ W q V hV ((2:ℝ)^j) Z‖ else 0)≤ + (Cr*M)*gaussianRemoteMoment V hV 0 2 Z A j := by + unfold gaussianRemoteMoment + split_ifs + · simpa only [M,Real.rpow_two,mul_assoc,mul_comm,mul_left_comm] using + hr F a S D Ψ hΨ W q V hV ((2:ℝ)^j) Z (by positivity) + · simp + have hnon (j : ℕ) : 0≤(if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ‖gaussianCompletedFamilyIntegral F a S D Ψ W q V hV ((2:ℝ)^j) Z‖ else 0) := by split_ifs <;> positivity + have hsum := Summable.of_nonneg_of_le hnon hb (hs.mul_left (Cr*M)) + refine ⟨hsum,?_⟩ + calc + _ ≤ ∑'j : ℕ,(Cr*M)*gaussianRemoteMoment V hV 0 2 Z A j := hsum.tsum_le_tsum hb (hs.mul_left (Cr*M)) + _ = (Cr*M)*∑'j : ℕ,gaussianRemoteMoment V hV 0 2 Z A j := tsum_mul_left + _ ≤ (Cr*M)*(Cg*Z^(2:ℝ)/A^N) := mul_le_mul_of_nonneg_left ht (mul_nonneg hCr.le hM) + _ = _ := by rw [Real.rpow_two];dsimp only [M];ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSeminorm.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSeminorm.lean new file mode 100644 index 0000000000000000000000000000000000000000..2ead043c3ef474d221a4f078c990f944a5efb11a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSeminorm.lean @@ -0,0 +1,155 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianDerivative + +namespace OAI + +noncomputable section +open scoped Classical ContDiff Topology SchwartzMap +open Filter Set +namespace SevenEighths.ProbePhysical + +def gaussianFixedWindow (y : ℝ) : ℂ := gaussianAnnulus y/(Real.sqrt y:ℂ) +lemma gaussianFixedWindow_small (y : ℝ) (hy : y≤1/2) : gaussianFixedWindow y=0 := by + simp only [gaussianFixedWindow,gaussianAnnulus_small y hy,zero_div] +lemma gaussianFixedWindow_large (y : ℝ) (hy : 2≤y) : gaussianFixedWindow y=0 := by + simp only [gaussianFixedWindow,gaussianAnnulus_large y hy,zero_div] +lemma gaussianFixedWindow_compact : HasCompactSupport gaussianFixedWindow := by + apply HasCompactSupport.of_support_subset_isCompact (isCompact_Icc (a:=(1/2:ℝ)) (b:=2)) + intro y hy + change gaussianFixedWindow y≠0 at hy + constructor + · by_contra h; exact hy (gaussianFixedWindow_small y (le_of_lt (lt_of_not_ge h))) + · by_contra h; exact hy (gaussianFixedWindow_large y (le_of_lt (lt_of_not_ge h))) +lemma gaussianFixedWindow_contDiff : ContDiff ℝ ∞ gaussianFixedWindow := by + rw [contDiff_iff_contDiffAt] + intro y + by_cases hy : 0(Real.sqrt x:ℂ)) y := + Complex.ofRealCLM.contDiff.contDiffAt.comp y (Real.contDiffAt_sqrt hy.ne') + unfold gaussianFixedWindow + simp only [div_eq_mul_inv] + exact gaussianAnnulus_contDiff.contDiffAt.mul (hf.fun_inv hs) + · apply contDiffAt_const.congr_of_eventuallyEq + filter_upwards [eventually_lt_nhds (show y<(1/2:ℝ) by linarith)] with x hx + exact gaussianFixedWindow_small x hx.le + +def gaussianFixedSchwartz : SchwartzMap ℝ ℂ := gaussianFixedWindow_compact.toSchwartzMap gaussianFixedWindow_contDiff + +lemma gaussianProfile_scaled_smooth (r : ℝ) (hr : 0gaussianMellinProfile (r*x)) y := by + have hf : ContDiffAt ℂ ∞ (fun z : ℂ=>gaussianLog ((r:ℂ)*z)) (y:ℂ) := + (gaussianLog_scaled_analytic r hr (y:ℂ) hy).contDiffAt + have hh := (hf.restrict_scalars ℝ).comp y Complex.ofRealCLM.contDiff.contDiffAt + simpa only [Function.comp_def,Complex.ofRealCLM_apply,←Complex.ofReal_mul,gaussianLog_ofReal] using hh + +lemma gaussianDyadicProfile_factor (Z : ℝ) (j : ℕ) : + gaussianDyadicProfile Z j=(fun y : ℝ=>gaussianFixedWindow y* + gaussianMellinProfile (((2:ℝ)^j/Z)*y)) := by + funext y + unfold gaussianDyadicProfile gaussianFixedWindow + rw [show (2:ℝ)^j*y/Z=((2:ℝ)^j/Z)*y by ring] + ring + +lemma gaussianDyadicProfile_derivative_outside (Z : ℝ) (j n : ℕ) (y : ℝ) + (hy : y∉Set.Icc (1/2:ℝ) 2) : iteratedDeriv n (gaussianDyadicProfile Z j) y=0 := by + have he : gaussianDyadicProfile Z j=ᶠ[𝓝 y](fun _=>0) := by + simp only [Set.mem_Icc,not_and_or,not_le] at hy + rcases hy with hy|hy + · filter_upwards [eventually_lt_nhds hy] with x hx + exact gaussianDyadicProfile_small Z j x hx.le + · filter_upwards [eventually_gt_nhds hy] with x hx + exact gaussianDyadicProfile_large Z j x hx.le + rw [he.iteratedDeriv_eq n] + simp + +lemma gaussianDyadicProfile_derivative_uniform (a : ℝ) (n : ℕ) : + ∃C : ℝ,0gaussianLog_scaled_derivative_bound a i + let A (i : ℕ) := SchwartzMap.seminorm ℝ 0 i gaussianFixedSchwartz + let C := ∑i∈Finset.range (n+1),(n.choose i:ℝ)*A i*B (n-i) + have hA (i : ℕ) : 0≤A i := by exact apply_nonneg _ _ + have hC : 0≤C := Finset.sum_nonneg (fun i _=>mul_nonneg (mul_nonneg (Nat.cast_nonneg _) (hA i)) (hB _).le) + refine ⟨C+1,by positivity,?_⟩ + intro Z hZ j y hy + have hr : 0<(2:ℝ)^j/Z := div_pos (by positivity) hZ + have hy0 : 0gaussianMellinProfile (((2:ℝ)^j/Z)*x)) y‖ := norm_sum_le _ _ + _ ≤ ∑i∈Finset.range (n+1),((n.choose i:ℝ)*A i)*(B (n-i)*(((2:ℝ)^j/Z)^(-a))) := by + apply Finset.sum_le_sum + intro i hi + rw [norm_mul,norm_mul,Complex.norm_natCast] + have hfixed : ‖iteratedDeriv i gaussianFixedWindow y‖≤A i := by + have hh := SchwartzMap.le_seminorm' ℝ 0 i gaussianFixedSchwartz y + simp only [pow_zero,one_mul] at hh + exact hh + exact mul_le_mul (mul_le_mul_of_nonneg_left hfixed (Nat.cast_nonneg _)) + (hbound _ _ hr y hy) (norm_nonneg _) (mul_nonneg (Nat.cast_nonneg _) (hA i)) + _ = C*(((2:ℝ)^j/Z)^(-a)) := by simp only [C,Finset.sum_mul]; apply Finset.sum_congr rfl; intros; ring + _ ≤ (C+1)*(((2:ℝ)^j/Z)^(-a)) := by nlinarith [Real.rpow_pos_of_pos hr (-a)] + +theorem gaussianDyadicSchwartz_seminorm (a : ℝ) (k n : ℕ) : + ∃C : ℝ,0 + refine ⟨1,by norm_num,?_⟩ + intro Z hZ j + simp only [Finset.sup_empty,one_mul] + change 0≤(((2:ℝ)^j/Z)^(-a)) + exact Real.rpow_nonneg (by positivity) _ + | @insert p S hp ih => + obtain ⟨B,hB,hbound⟩ := gaussianDyadicSchwartz_seminorm a p.1 p.2 + obtain ⟨C,hC,hrest⟩ := ih + refine ⟨B+C,by positivity,?_⟩ + intro Z hZ j + rw [Finset.sup_insert,Seminorm.sup_apply] + apply max_le + · exact (hbound Z hZ j).trans (by nlinarith [Real.rpow_nonneg (by positivity : 0≤(2:ℝ)^j/Z) (-a)]) + · exact (hrest Z hZ j).trans (by nlinarith [Real.rpow_nonneg (by positivity : 0≤(2:ℝ)^j/Z) (-a)]) + +theorem gaussianDyadicSchwartz_two_sided (A : ℝ) (S : Finset (ℕ×ℕ)) : + ∃C : ℝ,0 fun y=>gaussianAnnulus (Real.exp y) + | some i => fun y=>W i (Real.exp y) +def gaussianSlotSlope {ι : Type*} : Option ι→ℝ + | none => 1 + | some _ => -1 +def gaussianSlotPoint {ι : Type*} (x : ℝ) (q : ι→ℝ) : Option ι→ℝ + | none => Real.log x + | some i => Real.log (q i) + +lemma gaussianSlot_argument {ι : Type*} [Fintype ι] (x : ℝ) (hx : 0(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖) ∧ + (∫t : ℝ,(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖)≤C*R^(-A)) := by + let M' : Option ι→ℝ := fun o=>match o with + | none => |Real.log (1/2)|+|Real.log 2|+1 + | some i => M i + have hM' : ∀o,0≤M' o := by intro o; cases o with + | none => dsimp [M']; positivity + | some i => exact hM i + have hW : ∀o y,gaussianSlotWindow W o y≠0→|y|≤M' o := by + intro o y + cases o with + | none => exact gaussianAnnulus_log_support y + | some i => exact hwindow i y + obtain ⟨V,hV,hsep,hbound⟩ := gaussian_coupled_family (gaussianSlotWindow W) gaussianSlotSlope M' hM' hW + refine ⟨V,hV,?_,hbound⟩ + intro R hR x hx q hq + have hh := hsep R hR (gaussianSlotPoint x q) + rw [gaussianSlot_argument x hx q hq] at hh + simp only [Fintype.prod_option,gaussianSlotWindow,gaussianSlotPoint,Real.exp_log hx] at hh + simp_rw [Real.exp_log (hq _)] at hh + rw [show R*(x/∏i,q i)=R*x/(∏i,q i) by ring] at hh + rw [hh] + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp only + rw [gaussianFixedWindow_Vstar_twist t x hx] + simp only [gaussianSlotSlope,one_mul,neg_one_mul,logPhase_neg_argument] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSubset.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSubset.lean new file mode 100644 index 0000000000000000000000000000000000000000..560ba0b999e04d591537840af659a67b9cbbae57 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSubset.lean @@ -0,0 +1,89 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianCompensation + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory FourierBridge CompletedGauss +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev SelectedSlot {K : ℕ} (J : Finset (Fin K)) := ↥(Finset.univ\J) + +def compensationSubsetWeight {K : ℕ} (η : HeckeFamily.Character) + (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (p : Fin K→O) (J : Finset (Fin K)) : ℂ := + compensationSubsetCoefficient η p J*(∏i∈J,W i (elementNorm (p i)/P i)) + +def selectedSlotFactor {K : ℕ} (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) + (p : Fin K→O) (J : Finset (Fin K)) (t : ℝ) : ℂ := + ∏i : SelectedSlot J,W i.val (elementNorm (p i.val)/P i.val)* + logPhase (-t) (Real.log (elementNorm (p i.val)/P i.val)) + +def compensationRowTest {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W0 W1 : ℝ→ℂ) (p : Fin K→O) (J : Finset (Fin K)) (X Y T t : ℝ) : ℂ := + ∑'r : PhysicalRowIndex, + physicalRowWeight C W0 W1 (X/elementNorm (slotProduct p J)) (Y/elementNorm (slotProduct p J)) r* + correctedCompletedT C.excluded (Ideal.span {slotProduct p (Finset.univ\J)}) + (physicalRowMonoid η C r) (CompletedHeight.normTwistedSource gaussianFixedWindow t) T + +lemma gaussian_slot_window_split {K : ℕ} (W : Fin K→ℝ→ℂ) (q : Fin K→ℝ) (J : Finset (Fin K)) : + (∏i,W i (q i))=(∏i∈J,W i (q i))*(∏i : SelectedSlot J,W i.val (q i.val)) := by + rw [Finset.prod_coe_sort (Finset.univ\J) (fun i=>W i (q i))] + have hh := Finset.prod_sdiff (Finset.subset_univ J) (f:=fun i=>W i (q i)) + simpa only [mul_comm] using hh.symm + +lemma gaussian_compensation_scale {K : ℕ} (P : Fin K→ℝ) (hP : ∀i,0

P i.val) + (fun i : SelectedSlot J=>elementNorm (p i.val)) (fun i=>hP i.val)] + rw [Finset.prod_coe_sort (Finset.univ\J) (fun i=>elementNorm (p i)),elementNorm_slotProduct] + +theorem compensation_subset_common {K : ℕ} {α : Type*} + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) + (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (hsep : ∀R : ℝ,0hP i)) + have hh := physical_selected_gaussian_reassembly + (fun i : SelectedSlot J=>W i.val) V hV hsep η C W0 W1 hW0 hW1 F + (fun k=>compensationSubsetWeight η W P (p k) J) + (fun k=>Ideal.span {slotProduct (p k) (Finset.univ\J)}) + (fun k=>X/elementNorm (slotProduct (p k) J)) (fun k=>Y/elementNorm (slotProduct (p k) J)) + (fun k hk=>div_pos hX (slotProduct_norm_pos (p k) (hp k hk) J)) + (fun k hk=>div_pos hY (slotProduct_norm_pos (p k) (hp k hk) J)) + (Z*∏i∈Finset.univ\J,P i) hbase + (fun k (i : SelectedSlot J)=>elementNorm (p k i.val)/P i.val) + (fun k hk i=>div_pos (physicalElementNorm_pos _ (hp k hk i.val)) (hP i.val)) + calc + _ = ∑k∈F,compensationSubsetWeight η W P (p k) J* + (∏i : SelectedSlot J,W i.val (elementNorm (p k i.val)/P i.val))* + markedPhysicalProbe η C (Ideal.span {slotProduct (p k) (Finset.univ\J)}) W0 W1 + (X/elementNorm (slotProduct (p k) J)) (Y/elementNorm (slotProduct (p k) J)) + ((Z*∏i∈Finset.univ\J,P i)*(∏i : SelectedSlot J,elementNorm (p k i.val)/P i.val)) := by + apply Finset.sum_congr rfl + intro k hk + rw [gaussian_compensation_scale P hP (p k) J Z,gaussian_slot_window_split W (fun i=>elementNorm (p k i)/P i) J] + unfold compensationSubsetProbe compensationSubsetWeight + ring + _ = _ := hh + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSummation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSummation.lean new file mode 100644 index 0000000000000000000000000000000000000000..78d47764d7755a5bf6b6277356e94c157e191339 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianSummation.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianSeminorm + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbePhysical + +lemma gaussianDyadicSchwartz_polynomial_decay (N : ℕ) (S : Finset (ℕ×ℕ)) : + ∃C : ℝ,0((2:ℝ)^j)^s* + S.sup (schwartzSeminormFamily ℝ ℝ ℂ) (gaussianDyadicSchwartz Z hZ j)) ∧ + (∑'j : ℕ,((2:ℝ)^j)^s* + S.sup (schwartzSeminormFamily ℝ ℝ ℂ) (gaussianDyadicSchwartz Z hZ j))≤C*Z^s := by + obtain ⟨N,hN⟩ := exists_nat_gt s + obtain ⟨B,hB,hbound⟩ := gaussianDyadicSchwartz_polynomial_decay N S + obtain ⟨C,hC,hkernel⟩ := CompletedDyadic.kernel_sum_bound s (N:ℝ) hs hN + refine ⟨B*C,by positivity,?_⟩ + intro Z hZ + obtain ⟨hks,hkt⟩ := hkernel Z⁻¹ (inv_pos.mpr hZ) + have hb (j : ℕ) : ((2:ℝ)^j)^s* + S.sup (schwartzSeminormFamily ℝ ℝ ℂ) (gaussianDyadicSchwartz Z hZ j)≤ + B*CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := by + have hh := mul_le_mul_of_nonneg_left (hbound Z hZ j) (Real.rpow_nonneg (by positivity : (0:ℝ)≤2^j) s) + simpa only [CompletedDyadic.kernelTerm,Real.rpow_natCast,div_eq_mul_inv,mul_assoc,mul_left_comm,mul_comm] using hh + have hnon (j : ℕ) : 0≤((2:ℝ)^j)^s* + S.sup (schwartzSeminormFamily ℝ ℝ ℂ) (gaussianDyadicSchwartz Z hZ j) := by positivity + have hsum := Summable.of_nonneg_of_le hnon hb (hks.mul_left B) + refine ⟨hsum,?_⟩ + calc + _ ≤ ∑'j : ℕ,B*CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := hsum.tsum_le_tsum hb (hks.mul_left B) + _ = B*∑'j : ℕ,CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := tsum_mul_left + _ ≤ B*(C*(Z⁻¹)^(-s)) := mul_le_mul_of_nonneg_left hkt hB.le + _ = (B*C)*Z^s := by rw [Real.inv_rpow hZ.le,Real.rpow_neg hZ.le,inv_inv]; ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianTailBudget.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianTailBudget.lean new file mode 100644 index 0000000000000000000000000000000000000000..19a1a25b04c89d50d99e0fdae1ba1295609e554e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianTailBudget.lean @@ -0,0 +1,161 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianDensityBudget + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open MeasureTheory +namespace SevenEighths.ProbePhysical + +def gaussianWeightedMoment (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (k R : ℝ) : ℝ := R^k*gaussianJointMoment V hV J R + +lemma gaussianWeightedMoment_nonneg (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (k R : ℝ) (hR : 0≤R) : 0≤gaussianWeightedMoment V hV J k R := by + unfold gaussianWeightedMoment + exact mul_nonneg (Real.rpow_nonneg hR _) (gaussianJointMoment_nonneg V hV J R) + +lemma gaussianWeightedMoment_power_bound (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (k A : ℝ) : + ∃C : ℝ,0((2:ℝ)^j)^s*gaussianWeightedMoment V hV J k ((2:ℝ)^j/Z)) ∧ + (∑'j : ℕ,((2:ℝ)^j)^s*gaussianWeightedMoment V hV J k ((2:ℝ)^j/Z))≤C*Z^s := by + obtain ⟨N,hN⟩ := exists_nat_gt s + obtain ⟨B,hB,hbound⟩ := gaussianWeightedMoment_polynomial_decay V hV J k N + obtain ⟨C,hC,hkernel⟩ := CompletedDyadic.kernel_sum_bound s (N:ℝ) hs hN + refine ⟨B*C,by positivity,?_⟩ + intro Z hZ + obtain ⟨hks,hkt⟩ := hkernel Z⁻¹ (inv_pos.mpr hZ) + have hb (j : ℕ) : ((2:ℝ)^j)^s*gaussianWeightedMoment V hV J k ((2:ℝ)^j/Z)≤ + B*CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := by + have hh := mul_le_mul_of_nonneg_left (hbound ((2:ℝ)^j/Z) (div_pos (by positivity) hZ)) + (Real.rpow_nonneg (by positivity : (0:ℝ)≤2^j) s) + simpa only [CompletedDyadic.kernelTerm,Real.rpow_natCast,div_eq_mul_inv,mul_assoc,mul_left_comm,mul_comm] using hh + have hnon (j : ℕ) : 0≤((2:ℝ)^j)^s*gaussianWeightedMoment V hV J k ((2:ℝ)^j/Z) := + mul_nonneg (Real.rpow_nonneg (by positivity : (0:ℝ)≤2^j) s) (gaussianWeightedMoment_nonneg V hV J k _ (by positivity)) + have hsum := Summable.of_nonneg_of_le hnon hb (hks.mul_left B) + refine ⟨hsum,?_⟩ + calc + _ ≤ ∑'j : ℕ,B*CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := hsum.tsum_le_tsum hb (hks.mul_left B) + _ = B*∑'j : ℕ,CompletedDyadic.kernelTerm Z⁻¹ s (N:ℝ) j := tsum_mul_left + _ ≤ B*(C*(Z⁻¹)^(-s)) := mul_le_mul_of_nonneg_left hkt hB.le + _ = (B*C)*Z^s := by rw [Real.inv_rpow hZ.le,Real.rpow_neg hZ.le,inv_inv]; ring + +def gaussianRemoteMoment (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (J : ℕ) (s Z A : ℝ) (j : ℕ) : ℝ := + if (2:ℝ)^j/Z≤A⁻¹ ∨ A≤(2:ℝ)^j/Z then + ((2:ℝ)^j)^s*gaussianJointMoment V hV J ((2:ℝ)^j/Z) + else 0 + +theorem gaussianRemoteMoment_summed (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) (J N : ℕ) (s : ℝ) (hs : 0 + (((2:ℝ)^j)^s*gaussianWeightedMoment V hV J (-(N:ℝ)) ((2:ℝ)^j/Z)+ + ((2:ℝ)^j)^s*gaussianWeightedMoment V hV J (N:ℝ) ((2:ℝ)^j/Z))/A^N + have hU : Summable U := (hsm.add hsp).div_const _ + have hnon (j : ℕ) : 0≤gaussianRemoteMoment V hV J s Z A j := by + unfold gaussianRemoteMoment + split_ifs + · exact mul_nonneg (Real.rpow_nonneg (by positivity) _) (gaussianJointMoment_nonneg V hV J _) + · rfl + have hb (j : ℕ) : gaussianRemoteMoment V hV J s Z A j≤U j := by + let R := (2:ℝ)^j/Z + have hR : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma gaussian_selected_tuple_sum {ι α : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (hsep : ∀R : ℝ,0a k*correctedCompletedT S (D k) (Ψ k) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j)* + (∏i,W i (q k i)*logPhase (-t) (Real.log (q k i)))* + gaussianJointDensity V hV ((2:ℝ)^j/Z) t) := by + simpa only [mul_assoc] using (gaussian_selected_completed_integrable W (q k) _ S (D k) (Ψ k) _ (by positivity)).const_mul _ + simp_rw [Finset.sum_mul] + rw [integral_finsetSum _ (fun k _=>hi k)] + apply Finset.sum_congr rfl + intro k hk + have hh := gaussian_selected_completed W V hV hsep S (D k) (Ψ k) Z hZ j (q k) (hq k hk) + calc + _ = a k*((∏i,W i (q k i))*correctedCompletedT S (D k) (Ψ k) + (gaussianDyadicProfile (Z*∏i,q k i) j) ((2:ℝ)^j)) := by ring + _ = a k*∫t : ℝ,correctedCompletedT S (D k) (Ψ k) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j)* + (∏i,W i (q k i)*logPhase (-t) (Real.log (q k i)))* + gaussianJointDensity V hV ((2:ℝ)^j/Z) t := by rw [hh] + _ = _ := by + rw [←integral_const_mul] + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun t=>by dsimp only; ring) + +lemma gaussian_selected_scale {ι : Type*} [Fintype ι] + (Z : ℝ) (P Q : ι→ℝ) (hP : ∀i,0

hP i)) + field_simp + +theorem gaussian_selected_tuple_family {ι α : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (M : ι→ℝ) (hM : ∀i,0≤M i) + (hwindow : ∀i y,W i (Real.exp y)≠0→|y|≤M i) : + ∃V : SchwartzMap ℝ ℂ,∃hV : HasCompactSupport (V:ℝ→ℂ), + (∀A : ℝ,∀J : ℕ,∃C : ℝ,0(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖) ∧ + (∫t : ℝ,(1+‖t‖)^J*‖gaussianJointDensity V hV R t‖)≤C*R^(-A)) ∧ + (∀F : Finset α,∀a : α→ℂ,∀S : Finset Id,∀D : α→Id,∀Ψ : α→O→*ℂ, + ∀Z : ℝ,0 + gaussian_selected_tuple_sum W V hV hsep F a S D Ψ Z hZ j q hq⟩ + +lemma gaussianFixedWindow_twist_compact (t : ℝ) : + HasCompactSupport (CompletedHeight.normTwistedSource gaussianFixedWindow t) := by + exact gaussianFixedWindow_compact.mul_left + +theorem gaussian_twisted_physical_row_inverse (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (s : O) (hs : Supported (Ideal.span {s})) (z : O) (D : Id) (j : ℕ) (t : ℝ) : + correctedCompletedT S D (rowCoefficient η (calibrationForSet S hS).Xi s hs z) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j)= + ∑χ : RayCharacter,correctionCoeff χ* + InverseMoment.markedCompletedT + (CanonicalRowCompletion.rowTwist + (lowPeriodicBase η (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS) s hs χ) + (calibrationForSet S hS).generator 1 z) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) ((2:ℝ)^j) + (fun A=>if D∣A then (1:ℂ) else 0) := by + exact correctedPhysicalRow_eq_periodic_inverse η S hS hbad s hs z D _ + (gaussianFixedWindow_twist_compact t) _ (by positivity) (calibrationLowData S hS) + +lemma correctedGaussian_dyadic_summable (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (hΨ : ∀n,‖Ψ n‖≤1) (Z : ℝ) (hZ : 0correctedCompletedT S D Ψ (gaussianDyadicProfile Z j) ((2:ℝ)^j)) := by + have hh := (annular_reassembly_summable + (fun p : Id×Id=>correctedSummand S D Ψ gaussianCompletedProfile Z p.1 p.2) + (fun p : Id×Id=>(Ideal.absNorm p.1:ℝ)*(Ideal.absNorm p.2:ℝ)^3) + (gaussian_correctedSummand_summable S D Ψ hΨ Z hZ) + (fun p=>gaussian_correctedSummand_norm_ge_one S D Ψ Z p.1 p.2)).prod_symm.prod + simpa only [correctedCompletedT,gaussian_dyadic_correctedSummand S D Ψ Z hZ,Prod.swap] using hh + +theorem gaussian_selected_tuple_reassembly {ι α : Type*} [Fintype ι] + (W : ι→ℝ→ℂ) (V : SchwartzMap ℝ ℂ) (hV : HasCompactSupport (V:ℝ→ℂ)) + (hsep : ∀R : ℝ,0hq k hk i)) + have hd (k : α) (hk : k∈F) : Summable (fun j : ℕ=>a k*(∏i,W i (q k i))* + correctedCompletedT S (D k) (Ψ k) (gaussianDyadicProfile (Z*∏i,q k i) j) ((2:ℝ)^j)) := + (correctedGaussian_dyadic_summable S (D k) (Ψ k) (hΨ k hk) _ (hp k hk)).mul_left _ + calc + _ = ∑k∈F,∑'j : ℕ,a k*(∏i,W i (q k i))*correctedCompletedT S (D k) (Ψ k) + (gaussianDyadicProfile (Z*∏i,q k i) j) ((2:ℝ)^j) := by + apply Finset.sum_congr rfl + intro k hk + rw [correctedGaussian_eq_tsum_dyadic S (D k) (Ψ k) (hΨ k hk) _ (hp k hk),tsum_mul_left] + _ = ∑'j : ℕ,∑k∈F,a k*(∏i,W i (q k i))*correctedCompletedT S (D k) (Ψ k) + (gaussianDyadicProfile (Z*∏i,q k i) j) ((2:ℝ)^j) := (Summable.tsum_finsetSum hd).symm + _ = _ := by + apply tsum_congr + intro j + exact gaussian_selected_tuple_sum W V hV hsep F a S D Ψ Z hZ j q hq + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GaussianWindows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianWindows.lean new file mode 100644 index 0000000000000000000000000000000000000000..227f98000f2a0b3c1572a76dc2e33eec29f5c402 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GaussianWindows.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianPartition + +namespace OAI + +noncomputable section +open scoped Classical Topology ContDiff +open Filter +namespace SevenEighths.ProbePhysical +open CompletedGauss + +lemma gaussianMellinProfile_real (y : ℝ) (hy : 0gaussianAnnulus x* + (((1/(2*Real.pi):ℝ):ℂ)*(Real.pi:ℂ)^(1/2:ℂ)* + (Real.exp (-(Real.log ((2:ℝ)^j*x/Z))^2/4):ℂ))/(Real.sqrt x:ℂ)) := by + filter_upwards [eventually_gt_nhds hy] with x hx + rw [gaussianDyadicProfile,gaussianMellinProfile_real _ (div_pos (mul_pos (by positivity) hx) hZ)] + apply ContDiffAt.congr_of_eventuallyEq _ he + have hq : (2:ℝ)^j*y/Z≠0 := ne_of_gt (div_pos (mul_pos (by positivity) hy) hZ) + have hs : (Real.sqrt y:ℂ)≠0 := Complex.ofReal_ne_zero.mpr (Real.sqrt_pos.mpr hy).ne' + have ha := gaussianAnnulus_contDiff.contDiffAt (x:=y) + have hl : ContDiffAt ℝ ∞ (fun x : ℝ=>Real.log ((2:ℝ)^j*x/Z)) y := + (show ContDiffAt ℝ ∞ (fun x : ℝ=>(2:ℝ)^j*x/Z) y by fun_prop).log hq + have hg : ContDiffAt ℝ ∞ (fun x : ℝ=>Real.exp (-(Real.log ((2:ℝ)^j*x/Z))^2/4)) y := + ((hl.pow 2).neg.div_const 4).exp + have hgC := Complex.ofRealCLM.contDiff.contDiffAt.comp y hg + have hsR : ContDiffAt ℝ ∞ Real.sqrt y := Real.contDiffAt_sqrt hy.ne' + have ht : ContDiffAt ℝ ∞ (fun x : ℝ=>gaussianAnnulus x* + (((1/(2*Real.pi):ℝ):ℂ)*(Real.pi:ℂ)^(1/2:ℂ)* + (Real.exp (-(Real.log ((2:ℝ)^j*x/Z))^2/4):ℂ))) y := + ha.mul (contDiffAt_const.mul hgC) + have hsc : ContDiffAt ℝ ∞ (fun x : ℝ=>(Real.sqrt x:ℂ)) y := + Complex.ofRealCLM.contDiff.contDiffAt.comp y hsR + simpa only [div_eq_mul_inv] using ht.mul (hsc.fun_inv hs) + · apply contDiffAt_const.congr_of_eventuallyEq + filter_upwards [eventually_lt_nhds (show y<(1/2:ℝ) by linarith)] with x hx + exact gaussianDyadicProfile_small Z j x hx.le + +lemma gaussianDyadicProfile_Vstar (Z : ℝ) (j : ℕ) (y : ℝ) (hy : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def globalPrimeDefectBound (P : PrimeIdeal) : ℝ := + 240*(Ideal.absNorm P.val:ℝ)^(-(17/10:ℝ)) + +def globalClosedCorrection (η : HeckeFamily.Character) (S : Finset Id) (x w z : ℂ) : ℂ := + ∏' P : {P : PrimeIdeal // P.val∉S},idealClosedCorrection η P.val x w z + +lemma globalPrimeDefectBound_nonneg (P : PrimeIdeal) : 0≤globalPrimeDefectBound P := by + unfold globalPrimeDefectBound + positivity + +lemma globalPrimeDefectBound_summable : Summable globalPrimeDefectBound := by + have h := (CubicEisenstein.fullIdealWeight_summable_norm ((17/10:ℝ):ℂ) (by norm_num)).comp_injective + (Subtype.val_injective : Function.Injective (fun P : PrimeIdeal=>P.val)) + apply (h.mul_left 240).congr + intro P + change 240*‖CubicEisenstein.fullIdealWeight ((17/10:ℝ):ℂ) P.val‖=globalPrimeDefectBound P + unfold globalPrimeDefectBound CubicEisenstein.fullIdealWeight + simp only [P.property.ne_zero,ite_false] + rw [Complex.norm_natCast_cpow_of_pos (Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr P.property.ne_zero))] + norm_num + +structure CorrectionTail (S : Finset Id) : Prop where + norm_four : ∀P : PrimeIdeal,P.val∉S → 4≤Ideal.absNorm P.val + small : (∑' P : {P : PrimeIdeal // P.val∉S},globalPrimeDefectBound P.val)≤1/6 + +lemma CorrectionTail.summable {S : Finset Id} (_h : CorrectionTail S) : + Summable (fun P : {P : PrimeIdeal // P.val∉S}=>globalPrimeDefectBound P.val) := + globalPrimeDefectBound_summable.subtype _ + +lemma CorrectionTail.half {S : Finset Id} (h : CorrectionTail S) + (P : {P : PrimeIdeal // P.val∉S}) : globalPrimeDefectBound P.val≤1/2 := by + have hh := Summable.le_tsum h.summable P (fun Q _=>globalPrimeDefectBound_nonneg Q.val) + linarith [h.small] + +lemma idealClosedCorrection_bound (η : HeckeFamily.Character) (P : PrimeIdeal) + (hP : 4≤Ideal.absNorm P.val) (x w z : ℂ) + (hx : 7/8≤x.re) (hw : 9/10≤w.re) (hz : 4/25≤z.re) : + ‖idealClosedCorrection η P x w z-1‖≤globalPrimeDefectBound P := by + apply unramifiedClosed_open_region_bound + · exact_mod_cast hP + · exact actualAPhase_norm_le_one η _ + · exact HeckeFamily.idealCoeff_norm_le_one η P.val + · simp + · exact hx + · exact hw + · exact hz + +theorem globalClosedCorrection_bound (η : HeckeFamily.Character) (S : Finset Id) + (hS : CorrectionTail S) (x w z : ℂ) + (hx : 7/8≤x.re) (hw : 9/10≤w.re) (hz : 4/25≤z.re) : + ‖globalClosedCorrection η S x w z-1‖≤1/2 := + product_defect_le _ _ hS.summable + (fun P=>idealClosedCorrection_bound η P.val (hS.norm_four P.val P.property) x w z hx hw hz) + hS.half hS.small + +lemma globalClosedCorrection_multipliable (η : HeckeFamily.Character) (S : Finset Id) + (hS : CorrectionTail S) (x w z : ℂ) + (hx : 7/8≤x.re) (hw : 9/10≤w.re) (hz : 4/25≤z.re) : + Multipliable (fun P : {P : PrimeIdeal // P.val∉S}=>idealClosedCorrection η P.val x w z) := by + let F := fun P : {P : PrimeIdeal // P.val∉S}=>idealClosedCorrection η P.val x w z + let B := fun P : {P : PrimeIdeal // P.val∉S}=>globalPrimeDefectBound P.val + have hB (P) : ‖F P-1‖≤B P := + idealClosedCorrection_bound η P.val (hS.norm_four P.val P.property) x w z hx hw hz + refine ⟨Complex.exp (∑' P,Complex.log (F P)),?_⟩ + apply ((log_summable_of_defect F B hS.summable hB hS.half).of_norm.hasSum.cexp).congr + intro T + apply Finset.prod_congr rfl + intro P hP + exact Complex.exp_log (factor_ne_zero_of_defect _ ((hB P).trans (hS.half P))) + +theorem globalClosedCorrection_analytic_x (η : HeckeFamily.Character) (S : Finset Id) + (hS : CorrectionTail S) (w z : ℂ) (hw : 9/10≤w.re) (hz : 4/25≤z.re) : + AnalyticOnNhd ℂ (fun x=>globalClosedCorrection η S x w z) {x : ℂ|7/8globalClosedCorrection η S x w z) {w : ℂ|9/10globalClosedCorrection η S x w z) {z : ℂ|4/25Ideal.absNorm P.val)) + refine ⟨N,le_max_left _ _,?_⟩ + intro S hS + let T := {P : PrimeIdeal // P.val∉S} + have hnot (P : T) : P.val∉F := by + intro hm + exact P.property (hS P.val ((Finset.le_sup (f:=fun P : PrimeIdeal=>Ideal.absNorm P.val) hm).trans (le_max_right _ _))) + let inc : T→{P : PrimeIdeal // P∉F} := fun P=>⟨P.val,hnot P⟩ + have hi : Function.Injective inc := by + intro P Q h + exact Subtype.ext (congrArg (fun P : {P : PrimeIdeal // P∉F}=>P.val) h) + constructor + · intro P hP + have hn : ¬Ideal.absNorm P.val≤N := fun hn=>hP (hS P hn) + exact (le_max_left _ _).trans (Nat.le_of_lt (Nat.lt_of_not_ge hn)) + · apply le_trans ?_ hF.le + exact Summable.tsum_le_tsum_of_inj inc hi + (fun P _=>globalPrimeDefectBound_nonneg P.val) (fun _=>le_rfl) + (globalPrimeDefectBound_summable.subtype _) (globalPrimeDefectBound_summable.subtype _) + +theorem exists_global_correction (S₀ : Finset Id) : + ∃S : Finset Id,S₀⊆S ∧ CorrectionTail S := by + obtain ⟨N,hN,hcut⟩ := exists_uniform_global_cutoff + refine ⟨S₀∪smallPrimeSet N,Finset.subset_union_left,hcut _ ?_⟩ + intro P hP + exact Finset.mem_union_right _ ((mem_smallPrimeSet N P).mpr hP) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GlobalHolomorphic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GlobalHolomorphic.lean new file mode 100644 index 0000000000000000000000000000000000000000..b3581d4617039e88e9e68934e459c948a806a253 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GlobalHolomorphic.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Detector.GlobalRegion +import OAI.NumberTheory.DirichletL.Detector.EulerHolomorphic + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +lemma coordV_differentiable (Q : ℝ) (hQ : 0coordR Q A x z) := by + unfold coordR + have hn : (Q:ℂ)≠0 := by exact_mod_cast hQ.ne' + exact (((differentiable_id.const_mul 6).const_sub (4-6*x)).const_cpow (Or.inl hn)).const_mul A + +lemma coordK_w_differentiable (Q : ℝ) (hQ : 0coordK Q eta x w) := by + unfold coordK + have hn : (Q:ℂ)≠0 := by exact_mod_cast hQ.ne' + exact ((differentiable_id.const_sub (-x)).const_cpow (Or.inl hn)).const_mul (eta*(Q-1)) + +lemma unramifiedClosed_differentiableAt_w (Q : ℝ) (hQ : 0unramifiedClosed Q A eta v x t z) w := by + have hw := coordW_differentiable Q hQ v + have hk := coordK_w_differentiable Q hQ eta x + have hp : DifferentiableAt ℂ (fun t=> + markedFactor (coordR Q A x z) (coordV Q z) (Q:ℂ)⁻¹ + (coordK Q eta x t) (-coordD Q eta v x+coordW Q v t*coordR Q A x z) 1) w := by + unfold markedFactor + fun_prop (disch := assumption) + unfold unramifiedClosed ProbeLocal.continuedCorrection + dsimp only + fun_prop (disch := assumption) + +lemma unramifiedClosed_differentiableAt_z (Q : ℝ) (hQ : 0unramifiedClosed Q A eta v x w t) z := by + have hv := coordV_differentiable Q hQ + have hr := coordR_z_differentiable Q hQ A x + have hp : DifferentiableAt ℂ (fun t=> + markedFactor (coordR Q A x t) (coordV Q t) (Q:ℂ)⁻¹ + (coordK Q eta x w) (-coordD Q eta v x+coordW Q v w*coordR Q A x t) 1) z := by + unfold markedFactor + fun_prop (disch := assumption) + unfold unramifiedClosed ProbeLocal.continuedCorrection + dsimp only + fun_prop (disch := assumption) + +lemma open_region_denominators (Q : ℝ) (A eta v x z : ℂ) + (hQ : 4≤Q) (hA : ‖A‖≤1) (he : ‖eta‖≤1) (hv : ‖v‖≤1) + (hx : 7/8≤x.re) (hz : 4/25≤z.re) : + 1-coordR Q A x z≠0 ∧ 1-coordV Q z≠0 ∧ 1-coordD Q eta v x≠0 := by + have hQ0 : 0unramifiedClosed Q A eta v x w z) {x : ℂ|7/8unramifiedClosed Q A eta v x w z) {w : ℂ|9/10unramifiedClosed Q A eta v x w z) {z : ℂ|4/25 ActualEisensteinCubic.O + +lemma nonzero_norm_one_le (z : O) (hz : z≠0) : (1:ℝ)≤‖eisEmbedding z‖^2 := by + rw [eisEmbedding_norm_sq_eq_absNorm_span] + exact_mod_cast Nat.one_le_iff_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hz)) + +theorem annular_element_count (F : Finset O) (b N : ℝ) (hb : 0≤b) (hN : 0≤N) + (hzero : ∀z∈F,z≠0) (hbound : ∀z∈F,‖eisEmbedding z‖^2≤b*N) : + (F.card:ℝ)≤128*b*N := by + by_cases hF : F.Nonempty + · obtain ⟨z,hz⟩ := hF + have hscale : 1≤b*N := (nonzero_norm_one_le z (hzero z hz)).trans (hbound z hz) + simpa only [mul_assoc] using DescentFiberCost.finite_element_count_real F (b*N) hscale hbound + · rw [Finset.not_nonempty_iff_eq_empty.mp hF,Finset.card_empty,Nat.cast_zero] + positivity + +theorem annular_pair_count (F G : Finset O) (b N : ℝ) (hb : 0≤b) (hN : 0≤N) + (hFzero : ∀z∈F,z≠0) (hGzero : ∀z∈G,z≠0) + (hFbound : ∀z∈F,‖eisEmbedding z‖^2≤b*N) + (hGbound : ∀z∈G,‖eisEmbedding z‖^2≤b*N) : + ((F×ˢG).card:ℝ)≤(128*b)^2*N^2 := by + rw [Finset.card_product,Nat.cast_mul] + have hf := annular_element_count F b N hb hN hFzero hFbound + have hg := annular_element_count G b N hb hN hGzero hGbound + calc + _ ≤ (128*b*N)*(128*b*N) := mul_le_mul hf hg (Nat.cast_nonneg _) (by positivity) + _ = _ := by ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramAnnularLattice.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramAnnularLattice.lean new file mode 100644 index 0000000000000000000000000000000000000000..b862489979c6c95445693c039204f79eacc4fbd0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramAnnularLattice.lean @@ -0,0 +1,169 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.GramLatticeDecay + +namespace OAI + +noncomputable section +open scoped BigOperators Classical FourierTransform SchwartzMap RealInnerProductSpace + +namespace ProbeGramAnnularLattice +open ProbeGramLatticeDecay ActualEisensteinCubic ConcreteTraceCRT EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +def AnnularSupport (a b : ℝ) (W : 𝓢(Joint, ℂ)) : Prop := + Function.support W ⊆ {z : Joint | a ≤ ‖z.fst‖^2 ∧ ‖z.fst‖^2 ≤ b ∧ + a ≤ ‖z.snd‖^2 ∧ ‖z.snd‖^2 ≤ b} + +theorem scaled_embedding_norm_sq (m : O) (N : ℝ) (hN : 0 ≤ N) : + ‖eisEmbedding m / (Real.sqrt N : ℂ)‖^2 = ‖eisEmbedding m‖^2 / N := by + rw [norm_div, div_pow, Complex.norm_real, Real.norm_eq_abs, sq_abs, Real.sq_sqrt hN] + +theorem physical_sample_eq_zero (a b : ℝ) (ha : 0 < a) (hb : 0 < b) + (W : 𝓢(Joint, ℂ)) (hW : AnnularSupport a b W) + (N : ℝ) (hN : 0 < N) (hsmall : N < b⁻¹) (m : O × O) : + W (physicalPoint N m) = 0 := by + by_contra h + have hw := hW h + change a ≤ ‖eisEmbedding m.1 / (Real.sqrt N : ℂ)‖^2 ∧ + ‖eisEmbedding m.1 / (Real.sqrt N : ℂ)‖^2 ≤ b ∧ _ at hw + have hm : m.1 ≠ 0 := by + intro hz + have hh := hw.1 + rw [hz, map_zero, zero_div, norm_zero, zero_pow (by norm_num : (2:ℕ) ≠ 0)] at hh + linarith + have hl := one_le_eisenstein_norm_sq m.1 hm + have hu := hw.2.1 + rw [scaled_embedding_norm_sq m.1 N hN.le, div_le_iff₀ hN] at hu + have hs : b*N < 1 := by + have hh := mul_lt_mul_of_pos_left hsmall hb + simpa only [mul_inv_cancel₀ hb.ne'] using hh + linarith + +def cauchyWeight (m : O) : ℝ := ((1+‖eisEmbedding m‖^2)^2)⁻¹ + +theorem cauchyWeight_summable : Summable cauchyWeight := by + change Summable (fun m : O => ((1+‖eisEmbedding m‖^2)^2)⁻¹) + simpa only [one_mul] using scaled_eisenstein_cauchy_summable 1 zero_lt_one + +theorem cauchyWeight_mass_le : (∑' m : O, cauchyWeight m) ≤ 4*(1+Real.pi)^2 := by + simpa only [cauchyWeight, one_mul] using scaled_eisenstein_cauchy_small 1 zero_lt_one le_rfl + +theorem physical_subunit_majorant (W : 𝓢(Joint, ℂ)) + (N : ℝ) (hN : 0 < N) (hN1 : N ≤ 1) (m : O × O) : + ‖W (physicalPoint N m)‖ ≤ (2:ℝ)^8 * sourceControl (Finset.Iic (8,0)) W * + (cauchyWeight m.1 * cauchyWeight m.2) := by + have hn (m : O) : ‖eisEmbedding m‖^2 ≤ ‖eisEmbedding m / (Real.sqrt N : ℂ)‖^2 := by + rw [scaled_embedding_norm_sq m N hN.le, le_div_iff₀ hN] + exact mul_le_of_le_one_right (sq_nonneg _) hN1 + have hd : (1+‖eisEmbedding m.1‖^2)^2 * (1+‖eisEmbedding m.2‖^2)^2 ≤ + (1+‖eisEmbedding m.1 / (Real.sqrt N : ℂ)‖^2)^2 * + (1+‖eisEmbedding m.2 / (Real.sqrt N : ℂ)‖^2)^2 := by + exact mul_le_mul (pow_le_pow_left₀ (by positivity) (add_le_add (le_refl 1) (hn m.1)) 2) + (pow_le_pow_left₀ (by positivity) (add_le_add (le_refl 1) (hn m.2)) 2) (by positivity) (by positivity) + have hp := (mul_le_mul_of_nonneg_right hd (norm_nonneg (W (physicalPoint N m)))).trans + (product_decay W (eisEmbedding m.1 / (Real.sqrt N : ℂ)) + (eisEmbedding m.2 / (Real.sqrt N : ℂ))) + dsimp only [cauchyWeight] + rw [← mul_inv, ← div_eq_mul_inv, le_div_iff₀ (by positivity)] + simpa only [mul_comm] using hp + +theorem physical_subunit_bound (W : 𝓢(Joint, ℂ)) + (N : ℝ) (hN : 0 < N) (hN1 : N ≤ 1) : + (∑' m : O × O, ‖W (physicalPoint N m)‖) ≤ + ((2:ℝ)^8*(4*(1+Real.pi)^2)^2) * sourceControl (Finset.Iic (8,0)) W := by + have hg := cauchyWeight_summable + have hp := hg.mul_of_nonneg hg (fun _ => by unfold cauchyWeight; positivity) + (fun _ => by unfold cauchyWeight; positivity) + calc + _ ≤ ∑' m : O × O, ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W)* + (cauchyWeight m.1*cauchyWeight m.2) := + (physical_summable W N hN).tsum_le_tsum (physical_subunit_majorant W N hN hN1) + (hp.mul_left _) + _ = ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W)*(∑' m : O, cauchyWeight m)^2 := by + rw [tsum_mul_left, ← hg.tsum_mul_tsum hg hp, pow_two] + _ ≤ ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W)*(4*(1+Real.pi)^2)^2 := by + apply mul_le_mul_of_nonneg_left _ (mul_nonneg (by positivity) (sourceControl_nonneg _ _)) + exact pow_le_pow_left₀ (tsum_nonneg (fun _ => by unfold cauchyWeight; positivity)) + cauchyWeight_mass_le 2 + _ = _ := by ring + +theorem annular_lattice_bound (a b : ℝ) (ha : 0 < a) (hab : a < b) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)), AnnularSupport a b W → ∀ (N : ℝ), 0 < N → + (∑' m : O × O, ‖W (physicalPoint N m)‖) ≤ C * sourceControl S W * N^2 := by + obtain ⟨S₀,C₀,hC₀,h₀⟩ := physical_lattice_bound + let K : ℝ := (2:ℝ)^8*(4*(1+Real.pi)^2)^2 + have hK : 0 < K := by dsimp [K]; positivity + have hb : 0 < b := ha.trans hab + refine ⟨S₀ ∪ Finset.Iic (8,0),C₀ + K*b^2,by positivity,?_⟩ + intro W hW N hN + have hS₀ := sourceControl_mono (S := S₀) (T := S₀ ∪ Finset.Iic (8,0)) Finset.subset_union_left W + have hS₁ := sourceControl_mono (S := Finset.Iic (8,0)) + (T := S₀ ∪ Finset.Iic (8,0)) Finset.subset_union_right W + by_cases hN1 : 1 ≤ N + · apply (h₀ W N hN1).trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + exact mul_le_mul (le_add_of_nonneg_right (by positivity)) hS₀ + (sourceControl_nonneg _ _) (by positivity) + · by_cases hs : N < b⁻¹ + · have hz : (∑' m : O × O, ‖W (physicalPoint N m)‖) = 0 := by + calc + _ = ∑' _m : O × O, (0:ℝ) := tsum_congr (fun m => by + rw [physical_sample_eq_zero a b ha hb W hW N hN hs m, norm_zero]) + _ = 0 := tsum_zero + rw [hz] + exact mul_nonneg (mul_nonneg (by positivity) (sourceControl_nonneg _ _)) (sq_nonneg _) + · have hBN : 1 ≤ b*N := by + have hh := mul_le_mul_of_nonneg_left (le_of_not_gt hs) hb.le + simpa only [mul_inv_cancel₀ hb.ne'] using hh + have hBN2 : 1 ≤ b^2*N^2 := by nlinarith [sq_nonneg (b*N-1)] + calc + _ ≤ K * sourceControl (Finset.Iic (8,0)) W := + physical_subunit_bound W N hN (le_of_not_ge hN1) + _ ≤ K * sourceControl (S₀ ∪ Finset.Iic (8,0)) W := + mul_le_mul_of_nonneg_left hS₁ hK.le + _ ≤ (K * sourceControl (S₀ ∪ Finset.Iic (8,0)) W) * (b^2*N^2) := + le_mul_of_one_le_right (mul_nonneg hK.le (sourceControl_nonneg _ _)) hBN2 + _ = (K*b^2) * sourceControl (S₀ ∪ Finset.Iic (8,0)) W * N^2 := by ring + _ ≤ (C₀+K*b^2) * sourceControl (S₀ ∪ Finset.Iic (8,0)) W * N^2 := by + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (le_add_of_nonneg_left hC₀.le) + (sourceControl_nonneg _ _)) (sq_nonneg _) + +theorem weighted_summable (W : 𝓢(Joint, ℂ)) (d : O × O → ℂ) (B : ℝ) + (hd : ∀ m, ‖d m‖ ≤ B) (N : ℝ) (hN : 0 < N) : + Summable (fun m : O × O => d m * W (physicalPoint N m)) := by + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ ((physical_summable W N hN).mul_left B) + intro m + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (hd m) (norm_nonneg _) + +theorem annular_weighted_lattice_bound (a b : ℝ) (ha : 0 < a) (hab : a < b) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)), AnnularSupport a b W → + ∀ (d : O × O → ℂ) (B : ℝ), 0 ≤ B → (∀ m, ‖d m‖ ≤ B) → + ∀ (N : ℝ), 0 < N → + Summable (fun m : O × O => d m * W (physicalPoint N m)) ∧ + ‖∑' m : O × O, d m * W (physicalPoint N m)‖ ≤ C * sourceControl S W * B * N^2 := by + obtain ⟨S,C,hC,hbound⟩ := annular_lattice_bound a b ha hab + refine ⟨S,C,hC,?_⟩ + intro W hW d B hB hd N hN + refine ⟨weighted_summable W d B hd N hN,?_⟩ + calc + _ ≤ ∑' m : O × O, B * ‖W (physicalPoint N m)‖ := by + apply (norm_tsum_le_tsum_norm ((weighted_summable W d B hd N hN).norm)).trans + apply ((weighted_summable W d B hd N hN).norm).tsum_le_tsum _ + ((physical_summable W N hN).mul_left B) + intro m + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (hd m) (norm_nonneg _) + _ = B * ∑' m : O × O, ‖W (physicalPoint N m)‖ := tsum_mul_left + _ ≤ B * (C * sourceControl S W * N^2) := mul_le_mul_of_nonneg_left (hbound W hW N hN) hB + _ = _ := by ring + +end ProbeGramAnnularLattice + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramBound.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..93bacf3a6017b388a577f3f0f97063a6135a1e6c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramBound.lean @@ -0,0 +1,99 @@ +import OAI.NumberTheory.DirichletL.Detector.GramScaleLoss + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion +open CenteredMomentGaussEnergy EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem actual_additive_gram_bound (δ : ℝ) (hδ : 0<δ) (hδ1 : δ<1) + (a b M₀ : ℝ) (ha : 0primaryGenerator I.val) (fun I=>(supported_span_primaryGenerator_iff _).mpr I.property) + (lowGaussColumn (calibrationForSet S hS) W Y σ v) U Q‖≤ + K*(1+|v|)^J*(Q/Y)*(1+(Y^2/Q)^(1/6:ℝ)+(Y^2/Q)^2/Y)*Y^δ := by + obtain ⟨J,H₁,H₂,K₁,K₂,hK₁,hK₂,hbound⟩ := original_energy_nonzero_bound δ (1/12) hδ hδ1 + (by norm_num) (by norm_num) a b M₀ ha hab hM₀ W hcompact hs hW hWM + obtain ⟨K₀,hK₀,hzero⟩ := lowGramZeroMode_source_bound a b M₀ ha hM₀ + refine ⟨J,?_⟩ + intro S hS hbad U + let M : ℝ := Ideal.absNorm (jointFixedModulus S hS) + have hM : 1≤M := by dsimp [M];exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr (jointFixedModulus_nonzero S hS)) + let A₀ := K₀*‖paperRadialFourier U 0‖ + let A₁ := K₁*H₁.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*M + let A₂ := K₂*H₂.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*M^(1/12:ℝ) + have hA₀ : 0≤A₀ := by dsimp [A₀];positivity + have hA₁ : 0≤A₁ := by dsimp [A₁];positivity + have hA₂ : 0≤A₂ := by dsimp [A₂];positivity + refine ⟨1+A₀+A₁+A₂,by positivity,?_⟩ + intro σ v Y Q hY hQ hP + have hy : 0primaryGenerator I.val) + (fun I=>(supported_span_primaryGenerator_iff _).mpr I.property) + (lowGaussColumn (calibrationForSet S hS) W Y σ v) U Q + have hn := hbound S hS hbad σ U v Y Q hy hQ + have hz : ‖Z‖≤A₀*(Q/Y) := by + have hh := hzero S hS W hcompact hs hWM Y hY σ v U Q hQ.le + convert hh using 1 ; dsimp [Z,A₀] ; ring + have hgood : K₁*H₁.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J*(Q/Y)*P* + (Y/(M*P))^(-1+δ)≤A₁*(1+|v|)^J*(Q/Y)*(P^2/Y)*Y^δ := by + have hh := mul_le_mul_of_nonneg_left (nonexceptional_scale_loss M P Y δ hM hp hy hδ.le) + (show 0≤K₁*H₁.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J*(Q/Y) by positivity) + convert hh using 1 <;> (try dsimp [A₁]) <;> ring + have henergy : ‖E‖≤A₀*(Q/Y)+A₁*(1+|v|)^J*(Q/Y)*(P^2/Y)*Y^δ+A₂*(Q/Y)*P^(1/6:ℝ) := by + have hn' : ‖E-Z‖≤A₁*(1+|v|)^J*(Q/Y)*(P^2/Y)*Y^δ+A₂*(Q/Y)*P^(1/6:ℝ) := by + apply hn.trans + exact add_le_add hgood (by dsimp [A₂,M,P];ring_nf;exact le_rfl) + calc + ‖E‖=‖(E-Z)+Z‖ := by congr 1;ring + _≤‖E-Z‖+‖Z‖ := norm_add_le _ _ + _≤_ := by linarith + let B := (1+|v|)^J*(Q/Y)*(1+P^(1/6:ℝ)+P^2/Y)*Y^δ + have hb : 0≤B := by dsimp [B];positivity + have hh : 1≤(1+|v|)^J := one_le_pow₀ (by linarith [abs_nonneg v]) + have hyd : 1≤Y^δ := Real.one_le_rpow hY hδ.le + have hshape : 1≤1+P^(1/6:ℝ)+P^2/Y := by + have hpow : 0≤P^(1/6:ℝ) := by positivity + have hratio : 0≤P^2/Y := by positivity + linarith + have hb₀ : Q/Y≤B := by + calc + Q/Y=(1:ℝ)*(Q/Y)*1*1 := by ring + _≤B := by dsimp [B];gcongr + have hb₁ : (1+|v|)^J*(Q/Y)*(P^2/Y)*Y^δ≤B := by + dsimp [B] + gcongr + have hpow : 0≤P^(1/6:ℝ) := by positivity + linarith + have hb₂ : (Q/Y)*P^(1/6:ℝ)≤B := by + calc + _=(1:ℝ)*(Q/Y)*P^(1/6:ℝ)*1 := by ring + _≤B := by + dsimp [B] + gcongr + have hratio : 0≤P^2/Y := by positivity + linarith + change ‖E‖≤_ + calc + _≤A₀*(Q/Y)+A₁*((1+|v|)^J*(Q/Y)*(P^2/Y)*Y^δ)+A₂*((Q/Y)*P^(1/6:ℝ)) := by convert henergy using 1 ; ring + _≤A₀*B+A₁*B+A₂*B := add_le_add (add_le_add (mul_le_mul_of_nonneg_left hb₀ hA₀) + (mul_le_mul_of_nonneg_left hb₁ hA₁)) (mul_le_mul_of_nonneg_left hb₂ hA₂) + _≤(1+A₀+A₁+A₂)*B := by nlinarith + _=_ := by dsimp [B,P];ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonical.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonical.lean new file mode 100644 index 0000000000000000000000000000000000000000..15b08ad3ef165a219c5e8e49544bed0552263dea --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonical.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCommonSource +import OAI.NumberTheory.DirichletL.Detector.GramSourceBlock + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open ConcreteTraceCRT IdealMobiusDivisorSum UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +abbrev GramFrequency := {k : O // k≠0} +abbrev GramPrime (C : SupportedIdeal) := {P : Id // P∈IdealMobiusDivisorSum.primeSupport C.val} +def gramPrime (C : SupportedIdeal) (P : GramPrime C) : Id := P.val +instance gramPrimeMaximal (C : SupportedIdeal) (P : GramPrime C) : (gramPrime C P).IsMaximal := + (Ideal.isPrime_of_prime (support_prime P.property)).isMaximal (support_prime P.property).ne_zero + +def gramExponent (C : SupportedIdeal) (P : GramPrime C) : ℕ := (normalizedFactors C.val).count P.val +lemma gramExponent_pos (C : SupportedIdeal) (P : GramPrime C) : 1≤gramExponent C P := + Multiset.count_pos.mpr (Multiset.mem_toFinset.mp P.property) +lemma gramPrime_good (C : SupportedIdeal) (P : GramPrime C) : λ₀∉gramPrime C P := + (supported_factors_good C.val C.property P.val (Multiset.mem_toFinset.mp P.property)).2.1 +lemma gramPrime_coprime (C : SupportedIdeal) : Pairwise (Function.onFun IsCoprime (gramPrime C)) := by + intro P Q hpq + exact Ideal.isCoprime_of_isMaximal (Subtype.val_injective.ne hpq) +lemma gramPrime_product (C : SupportedIdeal) : C.val=∏P : GramPrime C,gramPrime C P^gramExponent C P := by + calc + C.val=(normalizedFactors C.val).prod := (Ideal.prod_normalizedFactors_eq_self C.property.1).symm + _=∏P∈IdealMobiusDivisorSum.primeSupport C.val,P^(normalizedFactors C.val).count P := Finset.prod_multiset_count _ + _=_ := (Finset.prod_coe_sort _ _).symm + +instance gramPrimePowerFinite (C : SupportedIdeal) (P : GramPrime C) : + Finite (O⧸gramPrime C P^gramExponent C P) := + Ring.HasFiniteQuotients.finiteQuotient (pow_ne_zero _ (support_prime P.property).ne_zero) +instance gramPrimePowerFintype (C : SupportedIdeal) (P : GramPrime C) : + Fintype (O⧸gramPrime C P^gramExponent C P) := Fintype.ofFinite _ +instance gramProductFinite (C : SupportedIdeal) : Finite (O⧸∏P : GramPrime C,gramPrime C P^gramExponent C P) := by + apply Ring.HasFiniteQuotients.finiteQuotient + rw [←gramPrime_product C] + exact C.property.1 +instance gramProductFintype (C : SupportedIdeal) : Fintype (O⧸∏P : GramPrime C,gramPrime C P^gramExponent C P) := Fintype.ofFinite _ + +structure GramNumeratorData (k : GramFrequency) where + unit : Oˣ + lambdaExponent : ℕ + twoExponent : ℕ + good : O + supported : Supported (Ideal.span {good}) + primary : λ₀^2∣good-1 + factor : k.val=unit.val*λ₀^lambdaExponent*(2:O)^twoExponent*good + +lemma gramNumeratorData_nonempty (k : GramFrequency) : Nonempty (GramNumeratorData k) := by + obtain ⟨u,a,b,r,hr,hpr,hf⟩ := exists_supported_numerator_factorization k.val k.property + exact ⟨⟨u,a,b,r,hr,hpr,hf⟩⟩ +def gramNumeratorData (k : GramFrequency) : GramNumeratorData k := Classical.choice (gramNumeratorData_nonempty k) + +def canonicalJoint (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (C : SupportedIdeal) (k : GramFrequency) (n m : O) : ℂ := + let f:=gramNumeratorData k + jointExtension S hS σ (primaryGenerator C.val) k.val f.unit f.lambdaExponent f.twoExponent + f.good f.supported (gramPrime C) (gramPrime_good C) (gramExponent C) n m + +lemma canonicalJoint_norm (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (C : SupportedIdeal) (k : GramFrequency) (n m : O) : ‖canonicalJoint S hS σ C k n m‖≤(Ideal.absNorm C.val:ℝ) := by + have hh := jointExtension_norm S hS σ (primaryGenerator C.val) k.val + (gramNumeratorData k).unit (gramNumeratorData k).lambdaExponent (gramNumeratorData k).twoExponent + (gramNumeratorData k).good (gramNumeratorData k).supported (gramPrime C) (gramPrime_good C) + (gramExponent C) (gramExponent_pos C) n m + simpa only [←gramPrime_product C,canonicalJoint] using hh + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonicalBlock.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonicalBlock.lean new file mode 100644 index 0000000000000000000000000000000000000000..cd0c039f7c15b5a2610ba88ceadeb8f60c511c80 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonicalBlock.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Detector.GramClassification +import OAI.NumberTheory.DirichletL.Detector.GramLatticeWindow + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open ConcreteTraceCRT UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def canonicalLatticeBlock (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (C : SupportedIdeal) (k : GramFrequency) (d : O) (W : ℝ→ℂ) (U : SchwartzMap ℝ ℂ) + (v T N : ℝ) : ℂ := + ∑'m : O×O,canonicalJoint S hS σ C k (d*m.1) (d*m.2)* + shellProfile W v U T (‖eisEmbedding m.1‖^2/N) (‖eisEmbedding m.2‖^2/N) + +theorem canonical_nonexceptional_block (A B : ℕ) (hA : 2 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def originalCommonBlock (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (C : SupportedIdeal) (k : GramFrequency) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (Y Q : ℝ) (hY : 0canonicalJoint S hS σ C k (primaryGenerator D*n) (primaryGenerator D*m))).tsum_prod.symm + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonicalTrivial.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonicalTrivial.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e50f93f508f2047075a5e9f4e125f906e44ba26 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCanonicalTrivial.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCanonicalBlock + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem canonical_trivial_block (a b B : ℝ) (ha : 0canonicalJoint S hS σ C k (d*n) (d*m))] + have hcoef (n m : O) : ‖canonicalJoint S hS σ C k (d*n) (d*m)‖≤(Ideal.absNorm C.val:ℝ) := + canonicalJoint_norm S hS σ C k _ _ + have hpoint (n m : O) : (1+T)^A*‖canonicalJoint S hS σ C k (d*n) (d*m)* + shellProfile W v U T (‖eisEmbedding n‖^2/N) (‖eisEmbedding m‖^2/N)‖≤ + (Ideal.absNorm C.val:ℝ)*(K*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) U) := by + rw [norm_mul] + calc + _ = ‖canonicalJoint S hS σ C k (d*n) (d*m)‖* + ((1+T)^A*‖shellProfile W v U T (‖eisEmbedding n‖^2/N) (‖eisEmbedding m‖^2/N)‖) := by ring + _ ≤ _ := mul_le_mul (hcoef n m) (hprofile W hs hW U v T _ _ hT) (by positivity) (by positivity) + have hcount := annular_pair_count F G b N hb hN.le hF0 hG0 hFN hGN + calc + _ ≤ (1+T)^A*(∑n∈F,∑m∈G,‖canonicalJoint S hS σ C k (d*n) (d*m)* + shellProfile W v U T (‖eisEmbedding n‖^2/N) (‖eisEmbedding m‖^2/N)‖) := by + apply mul_le_mul_of_nonneg_left _ (by positivity) + exact (norm_sum_le _ _).trans (Finset.sum_le_sum fun n _=>norm_sum_le _ _) + _ ≤ (F.card:ℝ)*G.card*((Ideal.absNorm C.val:ℝ)*(K*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) U)) := by + simp_rw [Finset.mul_sum] + calc + _ ≤ ∑n∈F,∑m∈G,(Ideal.absNorm C.val:ℝ)*(K*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) U) := + Finset.sum_le_sum (fun n _=>Finset.sum_le_sum (fun m _=>hpoint n m)) + _ = _ := by simp;ring + _ ≤ ((128*b)^2*N^2)*((Ideal.absNorm C.val:ℝ)*(K*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) U)) := by + apply mul_le_mul_of_nonneg_right _ (by positivity) + simpa only [Finset.card_product,Nat.cast_mul] using hcount + _ ≤ _ := by + have hb' : (128*b)^2≤(1+128*b)^2 := by nlinarith + nlinarith [mul_le_mul_of_nonneg_right hb' (show 0≤N^2*((Ideal.absNorm C.val:ℝ)* + (K*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) U)) by positivity)] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramClassification.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramClassification.lean new file mode 100644 index 0000000000000000000000000000000000000000..68dc51c5976cddcaf20b8eaf34dbe3bd7a7c892d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramClassification.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCanonical +import OAI.NumberTheory.DirichletL.CenteredExceptionalProfile + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss UniqueFactorizationMonoid +open CenteredExceptionalCount +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +def exceptionalModulus (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) : Id := + jointFixedModulus S hS*C.val +lemma exceptionalModulus_nonzero (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) : + exceptionalModulus S hS C≠0 := mul_ne_zero (jointFixedModulus_nonzero S hS) C.property.1 +lemma exceptionalModulus_norm (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) : + Ideal.absNorm (exceptionalModulus S hS C)=Ideal.absNorm (jointFixedModulus S hS)*Ideal.absNorm C.val := + map_mul Ideal.absNorm _ _ + +def ExceptionalFrequency (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) (k : GramFrequency) : Prop := + ∀p∉IdealMobiusDivisorSum.primeSupport (exceptionalModulus S hS C),valuation (Ideal.span {k.val}) p%6=0 + +lemma nonexceptional_prime (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) (k : GramFrequency) + (hk : ¬ExceptionalFrequency S hS C k) : + ∃p : Id,Prime p ∧ p∉IdealMobiusDivisorSum.primeSupport (exceptionalModulus S hS C) ∧ + ¬6∣(normalizedFactors (Ideal.span {k.val})).count p := by + unfold ExceptionalFrequency at hk + push Not at hk + obtain ⟨p,hp,he⟩ := hk + have hcount : (normalizedFactors (Ideal.span {k.val})).count p≠0 := by + intro hz + apply he + simp [valuation,hz] + have hprime := prime_of_normalized_factor p (Multiset.count_pos.mp (Nat.pos_of_ne_zero hcount)) + exact ⟨p,hprime,hp,fun hd=>he (Nat.mod_eq_zero_of_dvd hd)⟩ + +lemma outside_exceptional_not_dvd (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) + (p : Id) (hp : Prime p) (hout : p∉IdealMobiusDivisorSum.primeSupport (exceptionalModulus S hS C)) : + (¬p∣jointFixedModulus S hS) ∧ (¬p∣∏i : GramPrime C,gramPrime C i) := by + have hnot : ¬p∣exceptionalModulus S hS C := by + intro hd + apply hout + exact Multiset.mem_toFinset.mpr ((Ideal.mem_normalizedFactors_iff (exceptionalModulus_nonzero S hS C)).mpr + ⟨Ideal.isPrime_of_prime hp,Ideal.dvd_iff_le.mp hd⟩) + refine ⟨fun hd=>hnot (dvd_mul_of_dvd_left hd _),?_⟩ + intro hd + apply hnot + apply dvd_mul_of_dvd_right + apply dvd_trans hd + calc + _∣∏i : GramPrime C,gramPrime C i^gramExponent C i := + Finset.prod_dvd_prod_of_dvd _ _ (fun i _=>dvd_pow_self _ (Nat.one_le_iff_ne_zero.mp (gramExponent_pos C i))) + _=C.val := (gramPrime_product C).symm + +lemma outside_exceptional_good (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (C : SupportedIdeal) + (p : Id) (hp : Prime p) (hout : p∉IdealMobiusDivisorSum.primeSupport (exceptionalModulus S hS C)) : + λ₀∉p ∧ ringChar (O⧸p)≠2 := by + let : p.IsMaximal := (Ideal.isPrime_of_prime hp).isMaximal hp.ne_zero + have hle : exceptionalModulus S hS C≤Ideal.span {(72:O)} := + le_trans Ideal.mul_le_left Ideal.mul_le_right + have hh := CenteredExceptionalProfile.outside_fixed_support _ (exceptionalModulus_nonzero S hS C) hle p hp hout + exact ⟨hh.1,ActualEisensteinCubic.quotient_char_ne_two_of_two_not_mem p hh.2.1⟩ + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonActual.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonActual.lean new file mode 100644 index 0000000000000000000000000000000000000000..4165975f2ee2959d21b0e0406f6bd32ce1fe2b2a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonActual.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCommonSum +import OAI.NumberTheory.DirichletL.Detector.GramCommonLinear +import OAI.NumberTheory.DirichletL.Moments.SupportedCorrelation + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CenteredMomentCorrelation CenteredMomentSupportedCorrelation +open CenteredMomentCommonSupport CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +def actualCommon (C : O) (hC : Supported (Ideal.span {C})) (n₁ n₂ k : O) : ℂ := by + letI := finite_quotient_span (supported_element_ne_zero C hC) + letI : Fintype (ResidueQ C) := Fintype.ofFinite _ + exact fullCorrelation (fun x : ResidueQ C=>Ideal.Quotient.mk _ n₂*x) + (fun y : ResidueQ C=>Ideal.Quotient.mk _ n₁*y) + (supportedModulusCharacter C hC) (supportedModulusCharacter C hC) (Ideal.Quotient.mk _ k) + +lemma actualCommon_parameter (C : O) (hC : Supported (Ideal.span {C})) (n₁ n₂ a b k : O) + (hab : a*n₁+b*n₂=1) : + letI := finite_quotient_span (supported_element_ne_zero C hC) + letI : Fintype (ResidueQ C) := Fintype.ofFinite _ + actualCommon C hC n₁ n₂ k= + ∑t : ResidueQ C, + supportedModulusCharacter C hC (Ideal.Quotient.mk _ (b*k)+Ideal.Quotient.mk _ n₁*t)* + star (supportedModulusCharacter C hC (Ideal.Quotient.mk _ (-a*k)+Ideal.Quotient.mk _ n₂*t)) := by + let := finite_quotient_span (supported_element_ne_zero C hC) + let : Fintype (ResidueQ C) := Fintype.ofFinite _ + have hh : Ideal.Quotient.mk (Ideal.span {C}) a*Ideal.Quotient.mk _ n₁+ + Ideal.Quotient.mk _ b*Ideal.Quotient.mk _ n₂=1 := by rw [←map_mul,←map_mul,←map_add,hab,map_one] + rw [actualCommon,fullCorrelation_bezout _ _ _ _ _ hh] + simp only [map_mul,map_neg] + +theorem actualCommon_norm (C : O) (hC : Supported (Ideal.span {C})) (n₁ n₂ k : O) + (hn : IsCoprime n₁ n₂) : ‖actualCommon C hC n₁ n₂ k‖≤(Ideal.absNorm (Ideal.span {C}):ℝ) := by + obtain ⟨a,b,hab⟩ := hn + let := finite_quotient_span (supported_element_ne_zero C hC) + let : Fintype (ResidueQ C) := Fintype.ofFinite _ + have hh : Ideal.Quotient.mk (Ideal.span {C}) a*Ideal.Quotient.mk _ n₁+ + Ideal.Quotient.mk _ b*Ideal.Quotient.mk _ n₂=1 := by rw [←map_mul,←map_mul,←map_add,hab,map_one] + have hc (x : ResidueQ C) : ‖supportedModulusCharacter C hC x‖≤1 := by + obtain ⟨x,rfl⟩ := Ideal.Quotient.mk_surjective x + exact idealRowHom_norm _ _ + have hd := fullCorrelation_bezout_norm (Ideal.Quotient.mk (Ideal.span {C}) n₁) + (Ideal.Quotient.mk _ n₂) _ _ (Ideal.Quotient.mk _ k) hh + (supportedModulusCharacter C hC) (supportedModulusCharacter C hC) hc hc + simpa only [actualCommon,Ideal.absNorm_apply,Submodule.cardQuot_apply,Nat.card_eq_fintype_card] using hd + +theorem actual_common_lift_bezout (C n₁ n₂ a b k : O) + (hC : Supported (Ideal.span {C})) (h₁ : Supported (Ideal.span {n₁})) + (h₂ : Supported (Ideal.span {n₂})) (hab : a*n₁+b*n₂=1) : + actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) (C*k)= + (idealRowHom (b*k) (Ideal.span {n₁})*star (idealRowHom (-a*k) (Ideal.span {n₂})))* + actualCommon C hC n₁ n₂ k := by + have hc := supported_element_ne_zero C hC + have h₁n := supported_element_ne_zero n₁ h₁ + have h₂n := supported_element_ne_zero n₂ h₂ + let := finite_quotient_span hc + let := finite_quotient_span (mul_ne_zero hc h₁n) + let := finite_quotient_span (mul_ne_zero hc h₂n) + let : Fintype (ResidueQ C) := Fintype.ofFinite _ + let : Fintype (ResidueQ (C*n₁)) := Fintype.ofFinite _ + let : Fintype (ResidueQ (C*n₂)) := Fintype.ofFinite _ + change fullModulusCorrelation (C*n₁) (C*n₂) _ _ (C*k)=_ + rw [fullModulusCorrelation_parameter C n₁ n₂ a b k hc h₁n hab, + actualCommon_parameter C hC n₁ n₂ a b k hab,Finset.mul_sum] + apply Finset.sum_congr rfl + intro t ht + obtain ⟨t,rfl⟩ := Ideal.Quotient.mk_surjective t + rw [leftParam_mk,rightParam_mk,supportedModulusCharacter_mul C n₁ hC h₁, + supportedModulusCharacter_mul C n₂ hC h₂] + have hleft : idealRowHom (b*k+n₁*t) (Ideal.span {n₁})=idealRowHom (b*k) (Ideal.span {n₁}) := by + apply idealRowHom_congr_mod + exact Ideal.mem_span_singleton.mpr ⟨t,by ring⟩ + have hright : idealRowHom (-a*k+n₂*t) (Ideal.span {n₂})=idealRowHom (-a*k) (Ideal.span {n₂}) := by + apply idealRowHom_congr_mod + exact Ideal.mem_span_singleton.mpr ⟨t,by ring⟩ + simp only [←map_mul,←map_add] + simp only [supportedModulusCharacter_mk,hleft,hright,star_mul] + ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..f5dbd3467f5ef03f36c03a9cae7f537af4910d77 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonEnergy.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Detector.GramEnergyNonzero +import OAI.NumberTheory.DirichletL.Detector.GramWindowGcd + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT RayFourExpansion +open CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson CenteredMomentGaussEnergy +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma gcdCommon_product_coprime (C I J : SupportedIdeal) (h : IsCoprime I.val J.val) : + gcdCommon (supportedIdealProduct C I) (supportedIdealProduct C J)=C := by + have hh:=congrArg (fun t : CoprimeTriple=>t.val.1) (gcdTriple_multiply ⟨(C,I,J),h⟩) + exact hh + +def originalPairWeight (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (W : ℝ→ℂ) (Y v : ℝ) (I J : SupportedIdeal) : ℂ := + (lowGramCoefficient (calibrationForSet S hS) σ I*lowGramProfile W v ((Ideal.absNorm I.val:ℝ)/Y))* + star (lowGramCoefficient (calibrationForSet S hS) σ J*lowGramProfile W v ((Ideal.absNorm J.val:ℝ)/Y)) + +theorem original_nonzero_common_sum (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (W : ℝ→ℂ) (hW : HasCompactSupport W) (Y Q : ℝ) (hY : 0 + if IsCoprime I.val J.val then + originalPairWeight S hS σ W Y v (supportedIdealProduct C I) (supportedIdealProduct C J)* + actualCorrelation (primaryGenerator (supportedIdealProduct C I).val) (primaryGenerator (supportedIdealProduct C J).val) + ((supported_span_primaryGenerator_iff _).mpr (supportedIdealProduct C I).property) + ((supported_span_primaryGenerator_iff _).mpr (supportedIdealProduct C J).property) (primaryGenerator C.val*k.val)* + paperRadialFourier U (Q*‖eisEmbedding (primaryGenerator C.val*k.val)‖^2/ + ‖eisEmbedding (primaryGenerator (supportedIdealProduct C I).val*primaryGenerator (supportedIdealProduct C J).val)‖^2) else 0 + have hf (I J : SupportedIdeal) : Summable (f I J) := by + by_cases hij : IsCoprime I.val J.val + · have hh := ((actual_correlation_radial_summable (supportedIdealProduct C I) (supportedIdealProduct C J) + (primaryGenerator C.val) (supported_primaryGenerator_ne_zero _ C.property) U Q hQ).subtype (fun k : O=>k≠0)).mul_left + (originalPairWeight S hS σ W Y v (supportedIdealProduct C I) (supportedIdealProduct C J)) + simpa only [f,hij,ite_true,Function.comp_def,mul_assoc] using hh + · simpa only [f,hij,ite_false] using (summable_zero : Summable (fun _ : GramFrequency=>(0:ℂ))) + have hr : (∑'k : GramFrequency,originalCommonBlock S hS σ C k W hW Y Q hY U v)= + ∑I∈F,∑J∈F,∑'k : GramFrequency,f I J k := by + change (∑'k : GramFrequency,∑I∈F,∑J∈F,f I J k)=_ + rw [Summable.tsum_finsetSum (fun I hI=>summable_sum (fun J hJ=>hf I J))] + apply Finset.sum_congr rfl + intro I hI + exact Summable.tsum_finsetSum (fun J hJ=>hf I J) + rw [hr] + apply Finset.sum_congr rfl + intro I hI + apply Finset.sum_congr rfl + intro J hJ + by_cases hij : IsCoprime I.val J.val + · simp only [hij,ite_true,f,gcdCommon_product_coprime C I J hij] + rw [←tsum_mul_left] + apply tsum_congr + intro k + ring + · simp only [hij,ite_false,f,tsum_zero] + +theorem original_energy_common_blocks (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (W : ℝ→ℂ) (hW : HasCompactSupport W) (Y Q : ℝ) (hY : 0primaryGenerator I.val) + (fun I=>(supported_span_primaryGenerator_iff _).mpr I.property) + (lowGaussColumn (calibrationForSet S hS) W Y σ v) U Q= + lowGramZeroMode (calibrationForSet S hS) W hW Y hY σ v U Q+ + ((Q/Y^3:ℝ):ℂ)*(∑C∈commonPool (lowGaussColumns W hW Y hY), + ∑'k : GramFrequency,originalCommonBlock S hS σ C k W hW Y Q hY U v) := by + rw [original_energy_nonzero _ _ _ _ _ _ _ _ _ hQ] + congr 1 + congr 1 + exact original_nonzero_common_sum S hS σ W hW Y Q hY hQ U v + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonLinear.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonLinear.lean new file mode 100644 index 0000000000000000000000000000000000000000..a8ab0b958193694f422de791043980c8e568bd3f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonLinear.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCommonParam + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CenteredMomentCorrelation +variable {R : Type*} [CommRing R] + +def bezoutPairEquiv (n₁ n₂ a b : R) (hab : a*n₁+b*n₂=1) : R×R≃R×R where + toFun p := (b*p.2+n₁*p.1,-a*p.2+n₂*p.1) + invFun p := (a*p.1+b*p.2,n₂*p.1-n₁*p.2) + left_inv p := by + apply Prod.ext + · dsimp only + linear_combination p.1*hab + · dsimp only + linear_combination p.2*hab + right_inv p := by + apply Prod.ext + · dsimp only + linear_combination p.1*hab + · dsimp only + linear_combination p.2*hab + +theorem fullCorrelation_bezout [Fintype R] (n₁ n₂ a b k : R) (hab : a*n₁+b*n₂=1) + (f g : R→ℂ) : + fullCorrelation (fun x=>n₂*x) (fun y=>n₁*y) f g k= + ∑t : R,f (b*k+n₁*t)*star (g (-a*k+n₂*t)) := by + unfold fullCorrelation + rw [←Fintype.sum_prod_type (fun p : R×R=>if n₂*p.1-n₁*p.2=k then f p.1*star (g p.2) else 0)] + have he := (Fintype.sum_equiv (bezoutPairEquiv n₁ n₂ a b hab) + (fun p : R×R=>if p.2=k then f (b*p.2+n₁*p.1)*star (g (-a*p.2+n₂*p.1)) else 0) + (fun p : R×R=>if n₂*p.1-n₁*p.2=k then f p.1*star (g p.2) else 0) (by + intro p + have hh : n₂*(b*p.2+n₁*p.1)-n₁*(-a*p.2+n₂*p.1)=p.2 := by + linear_combination p.2*hab + change (if p.2=k then _ else 0)=(if n₂*(b*p.2+n₁*p.1)-n₁*(-a*p.2+n₂*p.1)=k then _ else 0) + rw [hh] + rfl)).symm + rw [he,Fintype.sum_prod_type] + simp only [Finset.sum_ite_eq',Finset.mem_univ,ite_true] + +theorem fullCorrelation_bezout_norm [Fintype R] (n₁ n₂ a b k : R) (hab : a*n₁+b*n₂=1) + (f g : R→ℂ) (hf : ∀x,‖f x‖≤1) (hg : ∀x,‖g x‖≤1) : + ‖fullCorrelation (fun x=>n₂*x) (fun y=>n₁*y) f g k‖≤(Fintype.card R:ℝ) := by + rw [fullCorrelation_bezout n₁ n₂ a b k hab] + calc + _ ≤ ∑t : R,‖f (b*k+n₁*t)*star (g (-a*k+n₂*t))‖ := norm_sum_le _ _ + _ ≤ ∑_t : R,(1:ℝ) := by + apply Finset.sum_le_sum + intro t ht + rw [norm_mul,norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) (hf _)).trans (hg _) + _ = _ := by simp + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonParam.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonParam.lean new file mode 100644 index 0000000000000000000000000000000000000000..4a1f3a44833f8ed7340f18daccf4d4256adf755c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonParam.lean @@ -0,0 +1,107 @@ +import OAI.NumberTheory.DirichletL.Moments.FullCorrelation + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CenteredMomentCorrelation +variable {A : Type*} [CommRing A] [IsDomain A] +abbrev ResidueQ (a : A) := A⧸Ideal.span {a} + +def condition (C n₁ n₂ k : A) (p : ResidueQ (C*n₁) × ResidueQ (C*n₂)) : Prop := + scaledResidue (C*n₁) (C*n₂) ((C*n₁)*(C*n₂)) rfl p.1- + scaledResidue (C*n₂) (C*n₁) ((C*n₁)*(C*n₂)) (mul_comm _ _) p.2= + Ideal.Quotient.mk (Ideal.span {(C*n₁)*(C*n₂)}) (C*k) + +abbrev Solutions (C n₁ n₂ k : A) := {p : ResidueQ (C*n₁) × ResidueQ (C*n₂) // condition C n₁ n₂ k p} + +def leftParam (C n₁ b k : A) (t : ResidueQ C) : ResidueQ (C*n₁) := + Ideal.Quotient.mk _ (b*k)+scaledResidue C n₁ (C*n₁) rfl t + +def rightParam (C n₂ a k : A) (t : ResidueQ C) : ResidueQ (C*n₂) := + Ideal.Quotient.mk _ (-a*k)+scaledResidue C n₂ (C*n₂) rfl t + +omit [IsDomain A] in +@[simp] lemma leftParam_mk (C n₁ b k t : A) : + leftParam C n₁ b k (Ideal.Quotient.mk _ t)=Ideal.Quotient.mk _ (b*k+n₁*t) := by + simp only [leftParam,scaledResidue_mk,map_add] + +omit [IsDomain A] in +@[simp] lemma rightParam_mk (C n₂ a k t : A) : + rightParam C n₂ a k (Ideal.Quotient.mk _ t)=Ideal.Quotient.mk _ (-a*k+n₂*t) := by + simp only [rightParam,scaledResidue_mk,map_add] + +omit [IsDomain A] in +lemma param_condition (C n₁ n₂ a b k : A) (hab : a*n₁+b*n₂=1) (t : ResidueQ C) : + condition C n₁ n₂ k (leftParam C n₁ b k t,rightParam C n₂ a k t) := by + obtain ⟨t,rfl⟩ := Ideal.Quotient.mk_surjective t + rw [leftParam_mk,rightParam_mk] + unfold condition + rw [scaledResidue_congruence] + have he : C*n₂*(b*k+n₁*t)-C*n₁*(-a*k+n₂*t)-C*k=C*k*(a*n₁+b*n₂-1) := by ring + rw [he,hab,sub_self,mul_zero] + exact dvd_zero _ + +def param (C n₁ n₂ a b k : A) (hab : a*n₁+b*n₂=1) (t : ResidueQ C) : Solutions C n₁ n₂ k := + ⟨(leftParam C n₁ b k t,rightParam C n₂ a k t),param_condition C n₁ n₂ a b k hab t⟩ + +lemma param_injective (C n₁ n₂ a b k : A) (hab : a*n₁+b*n₂=1) (hn₁ : n₁≠0) : + Function.Injective (param C n₁ n₂ a b k hab) := by + intro t u he + have hl : leftParam C n₁ b k t=leftParam C n₁ b k u := congrArg (fun p=>p.val.1) he + apply scaledResidue_injective C n₁ (C*n₁) rfl hn₁ + exact add_left_cancel hl + +lemma condition_divided (C n₁ n₂ k x y : A) (hC : C≠0) + (hc : condition C n₁ n₂ k (Ideal.Quotient.mk _ x,Ideal.Quotient.mk _ y)) : + C*n₁*n₂∣n₂*x-n₁*y-k := by + unfold condition at hc + rw [scaledResidue_congruence] at hc + have hh : C*(C*n₁*n₂)∣C*(n₂*x-n₁*y-k) := by convert hc using 1 <;> ring + exact (mul_dvd_mul_iff_left hC).mp hh + +lemma param_surjective (C n₁ n₂ a b k : A) (hC : C≠0) (hab : a*n₁+b*n₂=1) : + Function.Surjective (param C n₁ n₂ a b k hab) := by + intro p + obtain ⟨x,hx⟩ := Ideal.Quotient.mk_surjective p.val.1 + obtain ⟨y,hy⟩ := Ideal.Quotient.mk_surjective p.val.2 + have hc : condition C n₁ n₂ k (Ideal.Quotient.mk _ x,Ideal.Quotient.mk _ y) := by + rw [hx,hy] + exact p.property + have hd := condition_divided C n₁ n₂ k x y hC hc + refine ⟨Ideal.Quotient.mk _ (a*x+b*y),?_⟩ + apply Subtype.ext + apply Prod.ext + · change leftParam C n₁ b k (Ideal.Quotient.mk _ (a*x+b*y))=p.val.1 + rw [leftParam_mk,←hx,Ideal.Quotient.eq] + apply Ideal.mem_span_singleton.mpr + have hh : C*n₁∣n₂*x-n₁*y-k := (dvd_mul_right (C*n₁) n₂).trans hd + have he : b*k+n₁*(a*x+b*y)-x= -b*(n₂*x-n₁*y-k) := by + linear_combination x*hab + rw [he] + exact dvd_mul_of_dvd_right hh _ + · change rightParam C n₂ a k (Ideal.Quotient.mk _ (a*x+b*y))=p.val.2 + rw [rightParam_mk,←hy,Ideal.Quotient.eq] + apply Ideal.mem_span_singleton.mpr + have hh : C*n₂∣n₂*x-n₁*y-k := by + apply dvd_trans _ hd + exact ⟨n₁,by ring⟩ + have he : -a*k+n₂*(a*x+b*y)-y=a*(n₂*x-n₁*y-k) := by + linear_combination y*hab + rw [he] + exact dvd_mul_of_dvd_right hh _ + +def solutionEquiv (C n₁ n₂ a b k : A) (hC : C≠0) (hn₁ : n₁≠0) + (hab : a*n₁+b*n₂=1) : ResidueQ C≃Solutions C n₁ n₂ k := + Equiv.ofBijective (param C n₁ n₂ a b k hab) + ⟨param_injective C n₁ n₂ a b k hab hn₁,param_surjective C n₁ n₂ a b k hC hab⟩ + +@[simp] lemma solutionEquiv_val (C n₁ n₂ a b k : A) (hC : C≠0) (hn₁ : n₁≠0) + (hab : a*n₁+b*n₂=1) (t : ResidueQ C) : + (solutionEquiv C n₁ n₂ a b k hC hn₁ hab t).val=(leftParam C n₁ b k t,rightParam C n₂ a k t) := rfl + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonPhase.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonPhase.lean new file mode 100644 index 0000000000000000000000000000000000000000..a18e5336d21edbc0b859e35c9d6c257466079f1f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonPhase.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCommonActual + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CenteredMomentCorrelation CenteredMomentSupportedCorrelation CenteredMomentCommonSupport +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +lemma supported_bezout_inverse (n m a b : O) (hn : Supported (Ideal.span {n})) + (hab : a*n+b*m=1) : + idealRowHom b (Ideal.span {n})=star (idealRowHom m (Ideal.span {n})) := by + have he : idealRowHom (b*m) (Ideal.span {n})=1 := by + rw [←idealRowHom_one_supported (Ideal.span {n}) hn] + apply idealRowHom_congr_mod + apply Ideal.mem_span_singleton.mpr + refine ⟨-a,?_⟩ + linear_combination hab + rw [idealRowHom_argument_mul] at he + let := finite_quotient_span (supported_element_ne_zero n hn) + let : Fintype (ResidueQ n) := Fintype.ofFinite _ + change supportedModulusCharacter n hn (Ideal.Quotient.mk _ b)= + star (supportedModulusCharacter n hn (Ideal.Quotient.mk _ m)) + rw [MulChar.star_apply',MulChar.inv_apply_eq_inv'] + exact eq_inv_of_mul_eq_one_left he + +theorem actual_common_lift (C n₁ n₂ k : O) + (hC : Supported (Ideal.span {C})) (h₁ : Supported (Ideal.span {n₁})) + (h₂ : Supported (Ideal.span {n₂})) + (hp₁ : ConcretePrimeRowBridge.goodLambda^2∣n₁-1) + (hp₂ : ConcretePrimeRowBridge.goodLambda^2∣n₂-1) (hn : IsCoprime n₁ n₂) : + actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) (C*k)= + idealRowHom k (Ideal.span {n₁})*star (idealRowHom (-k) (Ideal.span {n₂}))* + sexticReciprocityPhase n₁ n₂*actualCommon C hC n₁ n₂ k := by + obtain ⟨a,b,hab⟩ := hn + rw [actual_common_lift_bezout C n₁ n₂ a b k hC h₁ h₂ hab] + have h₁b := supported_bezout_inverse n₁ n₂ a b h₁ hab + have h₂a := supported_bezout_inverse n₂ n₁ b a h₂ (by simpa only [add_comm] using hab) + have he : idealRowHom (-a*k) (Ideal.span {n₂})= + idealRowHom a (Ideal.span {n₂})*idealRowHom (-k) (Ideal.span {n₂}) := by + rw [show -a*k=a*(-k) by ring,idealRowHom_argument_mul] + rw [idealRowHom_argument_mul,he,h₁b,h₂a,star_mul,star_star] + let := finite_quotient_span (supported_element_ne_zero n₁ h₁) + let : Fintype (ResidueQ n₁) := Fintype.ofFinite _ + have hphase := supported_opposite_phase n₁ n₂ h₁ h₂ hp₁ hp₂ ⟨a,b,hab⟩ + calc + _ = idealRowHom k (Ideal.span {n₁})*star (idealRowHom (-k) (Ideal.span {n₂}))* + (idealRowHom n₁ (Ideal.span {n₂})*star (idealRowHom n₂ (Ideal.span {n₁})))*actualCommon C hC n₁ n₂ k := by ring + _ = _ := by rw [hphase] + +theorem actual_common_norm (C n₁ n₂ k : O) + (hC : Supported (Ideal.span {C})) (h₁ : Supported (Ideal.span {n₁})) + (h₂ : Supported (Ideal.span {n₂})) (hn : IsCoprime n₁ n₂) : + ‖actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) (C*k)‖≤(Ideal.absNorm (Ideal.span {C}):ℝ) := by + obtain ⟨a,b,hab⟩ := hn + rw [actual_common_lift_bezout C n₁ n₂ a b k hC h₁ h₂ hab,norm_mul,norm_mul,norm_star] + have hc := actualCommon_norm C hC n₁ n₂ k ⟨a,b,hab⟩ + have hp : ‖idealRowHom (b*k) (Ideal.span {n₁})‖*‖idealRowHom (-a*k) (Ideal.span {n₂})‖≤1 := + (mul_le_of_le_one_left (norm_nonneg _) (idealRowHom_norm _ _)).trans (idealRowHom_norm _ _) + exact (mul_le_mul_of_nonneg_right hp (norm_nonneg _)).trans (by simpa using hc) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonSource.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..4d448554ff1f4e498b82abe9ed9d036cc84e3a00 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramCommonSource.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Detector.GramWindowMobius +import OAI.NumberTheory.DirichletL.Detector.GramPhysicalScale + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open ConcreteTraceCRT CenteredMomentMobiusRegroup UniqueFactorizationMonoid +open CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +def commonResidualScale (C : SupportedIdeal) (Y : ℝ) : ℝ := Y/Ideal.absNorm C.val +lemma commonResidualScale_pos (C : SupportedIdeal) (Y : ℝ) (hY : 0 + if condition C n₁ n₂ k p then χ p.1*star (ψ p.2) else 0)] + change (∑p : ResidueQ (C*n₁)×ResidueQ (C*n₂), + if condition C n₁ n₂ k p then χ p.1*star (ψ p.2) else 0)=_ + rw [←Finset.sum_filter] + exact Finset.sum_subtype _ (by simp) _ + +theorem fullModulusCorrelation_parameter (C n₁ n₂ a b k : A) (hC : C≠0) (hn₁ : n₁≠0) + (hab : a*n₁+b*n₂=1) + [Fintype (ResidueQ C)] [Fintype (ResidueQ (C*n₁))] [Fintype (ResidueQ (C*n₂))] + (χ : MulChar (ResidueQ (C*n₁)) ℂ) (ψ : MulChar (ResidueQ (C*n₂)) ℂ) : + fullModulusCorrelation (C*n₁) (C*n₂) χ ψ (C*k)= + ∑t : ResidueQ C,χ (leftParam C n₁ b k t)*star (ψ (rightParam C n₂ a k t)) := by + rw [fullModulusCorrelation_solutions] + symm + exact Fintype.sum_equiv (solutionEquiv C n₁ n₂ a b k hC hn₁ hab) _ _ (fun _=>rfl) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramEnergyNonzero.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramEnergyNonzero.lean new file mode 100644 index 0000000000000000000000000000000000000000..1b4e0d231c20fd90a462418ce9a247d0447d1435 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramEnergyNonzero.lean @@ -0,0 +1,58 @@ +import OAI.NumberTheory.DirichletL.Detector.GramFrequencyConvergence +import OAI.NumberTheory.DirichletL.Detector.GramNonzeroFrequency +import OAI.NumberTheory.DirichletL.Detector.LowGramDiagonal + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss ConcreteTraceCRT RayFourExpansion +open CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson CenteredMomentGaussEnergy +local notation "O" => ActualEisensteinCubic.O + +lemma original_pair_zero_split (I J : SupportedIdeal) (U : SchwartzMap ℝ ℂ) (Q : ℝ) (hQ : 0primaryGenerator I.val) + (fun I=>(supported_span_primaryGenerator_iff _).mpr I.property) + (lowGaussColumn C W Y σ v) U Q= + lowGramZeroMode C W hW Y hY σ v U Q+ + ((Q/Y^3:ℝ):ℂ)*∑I∈lowGaussColumns W hW Y hY,∑J∈lowGaussColumns W hW Y hY, + ((lowGramCoefficient C σ I*lowGramProfile W v ((Ideal.absNorm I.val:ℝ)/Y))* + star (lowGramCoefficient C σ J*lowGramProfile W v ((Ideal.absNorm J.val:ℝ)/Y)))* + ∑'h : GramFrequency,actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (-h.val)* + paperRadialFourier U (Q*‖eisEmbedding h.val‖^2/‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2) := by + rw [lowGram_source_poisson C W hW Y hY σ v U Q hQ,lowGramZeroMode_eq_source] + simp_rw [original_pair_zero_split _ _ U Q hQ,mul_add,Finset.sum_add_distrib] + simp only [mul_add] + congr 1 + congr 1 + apply Finset.sum_congr rfl + intro I hI + apply Finset.sum_congr rfl + intro J hJ + ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramFiniteGcd.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramFiniteGcd.lean new file mode 100644 index 0000000000000000000000000000000000000000..3890e84fcbde48c493ad55fae41d1d3b46d9cf28 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramFiniteGcd.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCanonicalSource + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +local notation "O" => ActualEisensteinCubic.O + +lemma supportedIdealProduct_injective (C : SupportedIdeal) : Function.Injective (supportedIdealProduct C) := by + intro I J h + apply Subtype.ext + exact mul_left_cancel₀ C.property.1 (congrArg Subtype.val h) + +def commonPool (F : Finset SupportedIdeal) : Finset SupportedIdeal := + (F×ˢF).image (fun p=>gcdCommon p.1 p.2) +def commonColumns (F : Finset SupportedIdeal) (C : SupportedIdeal) : Finset SupportedIdeal := + F.preimage (supportedIdealProduct C) (supportedIdealProduct_injective C).injOn +lemma commonColumns_mem (F : Finset SupportedIdeal) (C I : SupportedIdeal) : + I∈commonColumns F C ↔ supportedIdealProduct C I∈F := Finset.mem_preimage + +def commonTriples (F : Finset SupportedIdeal) : Finset ((_C : SupportedIdeal)×(SupportedIdeal×SupportedIdeal)) := + (commonPool F).sigma (fun C=>(commonColumns F C×ˢcommonColumns F C).filter (fun p=>IsCoprime p.1.val p.2.val)) + +theorem finite_pair_gcd (F : Finset SupportedIdeal) (f : SupportedIdeal→SupportedIdeal→ℂ) : + (∑I∈F,∑J∈F,f I J)= + ∑C∈commonPool F,∑I∈commonColumns F C,∑J∈commonColumns F C, + if IsCoprime I.val J.val then f (supportedIdealProduct C I) (supportedIdealProduct C J) else 0 := by + have he : (∑p∈F×ˢF,f p.1 p.2)= + ∑t∈commonTriples F,f (supportedIdealProduct t.1 t.2.1) (supportedIdealProduct t.1 t.2.2) := by + apply Finset.sum_bij (fun p _=>⟨gcdCommon p.1 p.2,gcdLeft p.1 p.2,gcdRight p.1 p.2⟩) + · intro p hp + have hl : supportedIdealProduct (gcdCommon p.1 p.2) (gcdLeft p.1 p.2)=p.1 := Subtype.ext (gcd_common_left _ _) + have hr : supportedIdealProduct (gcdCommon p.1 p.2) (gcdRight p.1 p.2)=p.2 := Subtype.ext (gcd_common_right _ _) + simp only [commonTriples,Finset.mem_sigma,Finset.mem_filter,Finset.mem_product,commonColumns_mem] + exact ⟨Finset.mem_image.mpr ⟨p,hp,rfl⟩,⟨by rw [hl];exact (Finset.mem_product.mp hp).1,by rw [hr];exact (Finset.mem_product.mp hp).2⟩,gcd_residual_coprime _ _⟩ + · intro p hp q hq he + have hc := congrArg Sigma.fst he + have hl := congrArg (fun t : (C : SupportedIdeal)×(SupportedIdeal×SupportedIdeal)=>t.2.1) he + have hr := congrArg (fun t : (C : SupportedIdeal)×(SupportedIdeal×SupportedIdeal)=>t.2.2) he + apply Prod.ext <;> apply Subtype.ext + · rw [←gcd_common_left p.1 p.2,←gcd_common_left q.1 q.2] + rw [show gcdCommon p.1 p.2=gcdCommon q.1 q.2 from hc,show gcdLeft p.1 p.2=gcdLeft q.1 q.2 from hl] + · rw [←gcd_common_right p.1 p.2,←gcd_common_right q.1 q.2] + rw [show gcdCommon p.1 p.2=gcdCommon q.1 q.2 from hc,show gcdRight p.1 p.2=gcdRight q.1 q.2 from hr] + · intro t ht + have ht' : t.1∈commonPool F ∧ (t.2.1∈commonColumns F t.1 ∧ t.2.2∈commonColumns F t.1) ∧ IsCoprime t.2.1.val t.2.2.val := by + simpa only [commonTriples,Finset.mem_sigma,Finset.mem_filter,Finset.mem_product] using ht + let u : CoprimeTriple:=⟨(t.1,t.2),ht'.2.2⟩ + refine ⟨(supportedIdealProduct t.1 t.2.1,supportedIdealProduct t.1 t.2.2),?_,?_⟩ + · exact Finset.mem_product.mpr ⟨(commonColumns_mem F _ _).mp ht'.2.1.1,(commonColumns_mem F _ _).mp ht'.2.1.2⟩ + · have h:=congrArg Subtype.val (gcdTriple_multiply u) + exact congrArg (fun p : SupportedIdeal×(SupportedIdeal×SupportedIdeal)=>(⟨p.1,p.2⟩ : (C : SupportedIdeal)×(SupportedIdeal×SupportedIdeal))) h + · intro p hp + have hl : supportedIdealProduct (gcdCommon p.1 p.2) (gcdLeft p.1 p.2)=p.1 := Subtype.ext (gcd_common_left _ _) + have hr : supportedIdealProduct (gcdCommon p.1 p.2) (gcdRight p.1 p.2)=p.2 := Subtype.ext (gcd_common_right _ _) + simp only [hl,hr] + rw [Finset.sum_product] at he + rw [he,commonTriples,Finset.sum_sigma] + apply Finset.sum_congr rfl + intro C hC + rw [Finset.sum_filter,Finset.sum_product] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequency.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequency.lean new file mode 100644 index 0000000000000000000000000000000000000000..d7bc7b5f9bb32e8e326eea0c382411c39c3da926 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequency.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Detector.GramGcd + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT +open CenteredMomentCorrelation CenteredMomentSupportedCorrelation +local notation "O" => ActualEisensteinCubic.O + +lemma actual_common_frequency_zero (C n₁ n₂ j : O) + (hC : Supported (Ideal.span {C})) (h₁ : Supported (Ideal.span {n₁})) + (h₂ : Supported (Ideal.span {n₂})) (hj : ¬C∣j) : + actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) j=0 := by + let := finite_quotient_span (mul_ne_zero (supported_element_ne_zero C hC) (supported_element_ne_zero n₁ h₁)) + let := finite_quotient_span (mul_ne_zero (supported_element_ne_zero C hC) (supported_element_ne_zero n₂ h₂)) + let : Fintype (O⧸Ideal.span {C*n₁}) := Fintype.ofFinite _ + let : Fintype (O⧸Ideal.span {C*n₂}) := Fintype.ofFinite _ + exact fullModulusCorrelation_eq_zero_of_common_not_dvd _ _ C j _ _ + (dvd_mul_right _ _) (dvd_mul_right _ _) hj + +lemma tsum_element_divisible (C : O) (hC : C≠0) (f : O→ℂ) : + (∑'j : O,if C∣j then f j else 0)=∑'k : O,f (C*k) := by + have hinj : Function.Injective (fun k : O=>C*k) := fun _ _ h=>mul_left_cancel₀ hC h + have hs : Function.support (fun j : O=>if C∣j then f j else 0)⊆Set.range (fun k : O=>C*k) := by + intro j hj + have hd : C∣j := by by_contra h;simp [h] at hj + obtain ⟨k,rfl⟩ := hd + exact ⟨k,rfl⟩ + have ht := hinj.tsum_eq hs + calc + _ = ∑'k : O,if C∣C*k then f (C*k) else 0 := ht.symm + _ = _ := by simp only [dvd_mul_right,ite_true] + +theorem actual_common_frequency_tsum (C n₁ n₂ : O) + (hC : Supported (Ideal.span {C})) (h₁ : Supported (Ideal.span {n₁})) + (h₂ : Supported (Ideal.span {n₂})) (W : O→ℂ) : + (∑'j : O,actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) j*W j)= + ∑'k : O,actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) (C*k)*W (C*k) := by + rw [←tsum_element_divisible C (supported_element_ne_zero C hC) (fun j=> + actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) j*W j)] + apply tsum_congr + intro j + by_cases hj : C∣j + · rw [ite_eq_left hj] + · rw [ite_eq_right hj,actual_common_frequency_zero C n₁ n₂ j hC h₁ h₂ hj,zero_mul] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencyConvergence.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencyConvergence.lean new file mode 100644 index 0000000000000000000000000000000000000000..68eac4efa64d2cfac1640ba1161d4ee78bbcb295 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencyConvergence.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCanonicalSource +import OAI.NumberTheory.DirichletL.Moments.Tail + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss ConcreteTraceCRT +open CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +lemma actual_correlation_radial_summable (I J : SupportedIdeal) (C : O) (hC : C≠0) + (U : SchwartzMap ℝ ℂ) (Q : ℝ) (hQ : 0actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (C*k)* + paperRadialFourier U (Q*‖eisEmbedding (C*k)‖^2/ + ‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2)) := by + let t:=Q*‖eisEmbedding C‖^2/‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2 + have hc : 0<‖eisEmbedding C‖^2 := sq_pos_of_pos (norm_pos_iff.mpr (eisEmbedding_ne_zero hC)) + have hd : 0<‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2 := + sq_pos_of_pos (norm_pos_iff.mpr (eisEmbedding_ne_zero (mul_ne_zero + (supported_primaryGenerator_ne_zero _ I.property) (supported_primaryGenerator_ne_zero _ J.property)))) + have ht : 0norm_nonneg _) _ (hs.mul_left B) + intro k + rw [norm_mul,harg] + exact mul_le_mul_of_nonneg_right (hb k) (norm_nonneg _) + +lemma originalCommonBlock_summable (S : Finset (Ideal O)) (hS : ∀p∈S,p.IsMaximal) + (σ : RayFourExpansion.RayRing) (C : SupportedIdeal) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (Y Q : ℝ) (hY : 0originalCommonBlock S hS σ C k W hW Y Q hY U v) := by + unfold originalCommonBlock + apply summable_sum + intro I hI + apply summable_sum + intro J hJ + by_cases hij : IsCoprime I.val J.val + · simp only [hij,ite_true] + have hs := (actual_correlation_radial_summable (supportedIdealProduct C I) (supportedIdealProduct C J) + (primaryGenerator C.val) (supported_primaryGenerator_ne_zero _ C.property) U Q hQ).subtype (fun k : O=>k≠0) + simpa only [Function.comp_def,mul_assoc] using hs.mul_left + ((lowGramCoefficient (calibrationForSet S hS) σ (supportedIdealProduct C I)* + lowGramProfile W v ((Ideal.absNorm (supportedIdealProduct C I).val:ℝ)/Y))* + star (lowGramCoefficient (calibrationForSet S hS) σ (supportedIdealProduct C J)* + lowGramProfile W v ((Ideal.absNorm (supportedIdealProduct C J).val:ℝ)/Y))) + · simpa only [hij,ite_false] using (summable_zero : Summable (fun _ : GramFrequency=>(0:ℂ))) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencyMass.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencyMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..4dc0bde44ee39f1804bef851896feb4a6a7844c6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencyMass.lean @@ -0,0 +1,93 @@ +import OAI.NumberTheory.DirichletL.Detector.GramWeightedFrequency +import OAI.NumberTheory.DirichletL.Detector.GramCanonicalTrivial +import OAI.NumberTheory.DirichletL.Detector.GramFrequencySummation + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma gramFrequency_image_sum (E : Finset GramFrequency) (f : O→ℝ) : + (∑k∈E.image Subtype.val,f k)=∑k∈E,f k.val := + Finset.sum_image (fun _ _ _ _ h=>Subtype.val_injective h) + +theorem canonical_nonexceptional_frequency_sum (A : ℕ) (hA : 2hblock S hS σ C k (hE k hk) d U v H N hH hN) + _=V*(∑k∈E,(1+(Ideal.absNorm (Ideal.span {k.val}):ℝ)/H)^(-2:ℝ)) := (Finset.mul_sum ..).symm + _≤V*(L*H) := mul_le_mul_of_nonneg_left hc hV + _=_ := by dsimp [V];ring + +theorem canonical_exceptional_frequency_sum (a b M ε : ℝ) (ha : 0hp k) + _=V*(∑k∈E,(1+(Ideal.absNorm (Ideal.span {k.val}):ℝ)/H)^(-2:ℝ)) := (Finset.mul_sum ..).symm + _≤V*(L*((Ideal.absNorm (jointFixedModulus S hS):ℝ)*Ideal.absNorm C.val)^ε*H^(1/6:ℝ)) := mul_le_mul_of_nonneg_left hc hV + _=_ := by dsimp [V];ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencySummation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencySummation.lean new file mode 100644 index 0000000000000000000000000000000000000000..89924b330c84311d7056f7a2de4baf7401f86f41 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramFrequencySummation.lean @@ -0,0 +1,128 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.LowGramExceptional + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.ProbeGramFrequencySummation +local notation "O" => ActualEisensteinCubic.O + +def frequencyNorm (k : O) : ℝ := Ideal.absNorm (Ideal.span {k}) + +lemma frequencyNorm_nonneg (k : O) : 0 ≤ frequencyNorm k := Nat.cast_nonneg _ + +lemma frequencyNorm_one_le (k : O) (hk : k ≠ 0) : 1 ≤ frequencyNorm k := by + unfold frequencyNorm + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hk)) + +theorem finite_weighted_of_count {α : Type*} (E : Finset α) (q : α → ℝ) + (hq : ∀ x, 0 ≤ q x) (C d H : ℝ) (hC : 0 ≤ C) (hd : d ≤ 1) (hH : 0 < H) + (hcount : ∀ F : Finset α, F ⊆ E → ∀ R : ℝ, 0 < R → + (∀ x ∈ F, q x ≤ R) → (F.card : ℝ) ≤ C * R ^ d) : + ∑ x ∈ E, (1 + q x / H) ^ (-2 : ℝ) ≤ 4 * C * H ^ d := by + have hex (x : α) : ∃ n : ℕ, (2:ℝ)^n ≤ 1 + q x / H ∧ + 1 + q x / H < (2:ℝ)^(n+1) := + exists_nat_pow_near (by linarith [div_nonneg (hq x) hH.le]) (by norm_num) + let bin (x : α) : ℕ := Classical.choose (hex x) + have hlo (x : α) : (2:ℝ)^(bin x) ≤ 1 + q x / H := (Classical.choose_spec (hex x)).1 + have hhi (x : α) : 1 + q x / H < (2:ℝ)^(bin x+1) := (Classical.choose_spec (hex x)).2 + have hbin (n : ℕ) : + ∑ x ∈ E.filter (fun x => bin x = n), (1 + q x / H) ^ (-2 : ℝ) ≤ + (2*C*H^d) * (1/2:ℝ)^n := by + let F := E.filter (fun x => bin x = n) + have hcard : (F.card:ℝ) ≤ C * ((2:ℝ)^(n+1)*H)^d := by + apply hcount F (Finset.filter_subset _ _) _ (by positivity) + intro x hx + have he := (Finset.mem_filter.mp hx).2 + have hh := hhi x + rw [he] at hh + have hqdiv : q x/H ≤ (2:ℝ)^(n+1) := by linarith + exact (div_le_iff₀ hH).mp hqdiv + have hweight (x : α) (hx : x∈F) : (1+q x/H)^(-2:ℝ) ≤ (1/4:ℝ)^n := by + have hl := hlo x + rw [(Finset.mem_filter.mp hx).2] at hl + apply (Real.rpow_le_rpow_of_nonpos (by positivity) hl (by norm_num)).trans_eq + rw [Real.rpow_neg (by positivity), Real.rpow_two, ← pow_mul, Nat.mul_comm, pow_mul, ← inv_pow] + norm_num + have hp : ((2:ℝ)^(n+1))^d ≤ (2:ℝ)^(n+1) := + Real.rpow_le_self_of_one_le (one_le_pow₀ (by norm_num)) hd + calc + _ ≤ (F.card:ℝ)*(1/4:ℝ)^n := by + apply (Finset.sum_le_sum hweight).trans_eq + simp only [Finset.sum_const, nsmul_eq_mul] + _ ≤ (C*((2:ℝ)^(n+1)*H)^d)*(1/4:ℝ)^n := + mul_le_mul_of_nonneg_right hcard (by positivity) + _ ≤ (C*((2:ℝ)^(n+1)*H^d))*(1/4:ℝ)^n := by + rw [Real.mul_rpow (by positivity) hH.le] + gcongr + _ = (2*C*H^d)*((2:ℝ)^n*(1/4:ℝ)^n) := by rw [pow_succ]; ring + _ = _ := by rw [←mul_pow]; norm_num + have hsum : (∑ x∈E,(1+q x/H)^(-2:ℝ)) = + ∑ n∈E.image bin, ∑ x∈E.filter (fun x=>bin x=n), (1+q x/H)^(-2:ℝ) := by + symm + exact Finset.sum_fiberwise_of_maps_to (fun x hx => Finset.mem_image.mpr ⟨x,hx,rfl⟩) _ + rw [hsum] + apply (Finset.sum_le_sum (fun n _=>hbin n)).trans + have hs := (summable_geometric_of_lt_one (by norm_num : (0:ℝ)≤1/2) + (by norm_num : (1/2:ℝ)<1)).mul_left (2*C*H^d) + apply (Summable.sum_le_tsum _ (by intro n _; positivity) hs).trans_eq + rw [tsum_mul_left, tsum_geometric_of_lt_one (by norm_num : (0:ℝ)≤1/2) + (by norm_num : (1/2:ℝ)<1)] + ring + +theorem nonzero_frequency_count (E : Finset O) (R : ℝ) (hR : 0 < R) + (hE : ∀ k∈E, k≠0) (hN : ∀ k∈E, frequencyNorm k≤R) : + (E.card:ℝ) ≤ 128*R := by + by_cases hr : 1≤R + · apply DescentFiberCost.finite_element_count_real E R hr + intro k hk + simpa only [ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span,frequencyNorm] + using hN k hk + · have he : E=∅ := Finset.eq_empty_iff_forall_notMem.mpr (by + intro k hk + have hh := frequencyNorm_one_le k (hE k hk) + have hb := hN k hk + linarith) + rw [he,Finset.card_empty,Nat.cast_zero] + positivity + +theorem frequency_weighted_sum : + ∃ K : ℝ, 0hE k (hFE hk)) hN) + norm_num only [Real.rpow_one,show (4:ℝ)*128=512 by norm_num] at hh + exact hh + +theorem exceptional_frequency_weighted_sum (ε : ℝ) (hε : 0<ε) : + ∃ K : ℝ, 0hE k (hFE hk)) + (fun k hk=>hres k (hFE hk)) hN) + convert hh using 1 + ring + +end SevenEighths.ProbeGramFrequencySummation + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramGcd.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramGcd.lean new file mode 100644 index 0000000000000000000000000000000000000000..4b5e0f77ddde3c0c2dd27dcdc6178ae85cf8c1e0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramGcd.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Detector.GramJointSource + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +abbrev SupportedIdeal := {I : Id // Supported I} + +lemma gram_supported_divisor (I D : Id) (hI : Supported I) (hd : D∣I) : Supported D := by + obtain ⟨J,rfl⟩ := hd + exact (supported_mul_iff D J).mp hI |>.1 + +lemma gram_supported_quotient (I D : Id) (hI : Supported I) (hd : D∣I) : + Supported (idealQuotient D I) := gram_supported_divisor I _ hI (idealQuotient_dvd hd) + +def gcdCommon (I J : SupportedIdeal) : SupportedIdeal := + ⟨gcd I.val J.val,gram_supported_divisor I.val _ I.property (gcd_dvd_left _ _)⟩ + +def gcdLeft (I J : SupportedIdeal) : SupportedIdeal := + ⟨idealQuotient (gcdCommon I J).val I.val, + gram_supported_quotient I.val _ I.property (gcd_dvd_left _ _)⟩ + +def gcdRight (I J : SupportedIdeal) : SupportedIdeal := + ⟨idealQuotient (gcdCommon I J).val J.val, + gram_supported_quotient J.val _ J.property (gcd_dvd_right _ _)⟩ + +lemma gcd_residual_coprime (I J : SupportedIdeal) : IsCoprime (gcdLeft I J).val (gcdRight I J).val := + (gcd_eq_iff_quotient_coprime _ _ _ (gcdCommon I J).property.1 + (gcd_dvd_left _ _) (gcd_dvd_right _ _)).mp rfl + +lemma gcd_common_left (I J : SupportedIdeal) : (gcdCommon I J).val*(gcdLeft I J).val=I.val := + idealQuotient_mul (gcd_dvd_left _ _) + +lemma gcd_common_right (I J : SupportedIdeal) : (gcdCommon I J).val*(gcdRight I J).val=J.val := + idealQuotient_mul (gcd_dvd_right _ _) + +abbrev CoprimeTriple := {t : SupportedIdeal×SupportedIdeal×SupportedIdeal // IsCoprime t.2.1.val t.2.2.val} + +def gcdTriple (p : SupportedIdeal×SupportedIdeal) : CoprimeTriple := + ⟨(gcdCommon p.1 p.2,gcdLeft p.1 p.2,gcdRight p.1 p.2),gcd_residual_coprime p.1 p.2⟩ + +def multiplyTriple (t : CoprimeTriple) : SupportedIdeal×SupportedIdeal := + (⟨t.val.1.val*t.val.2.1.val,(supported_mul_iff _ _).mpr ⟨t.val.1.property,t.val.2.1.property⟩⟩, + ⟨t.val.1.val*t.val.2.2.val,(supported_mul_iff _ _).mpr ⟨t.val.1.property,t.val.2.2.property⟩⟩) + +lemma multiply_gcdTriple (p : SupportedIdeal×SupportedIdeal) : multiplyTriple (gcdTriple p)=p := by + apply Prod.ext <;> apply Subtype.ext + · exact gcd_common_left _ _ + · exact gcd_common_right _ _ + +lemma gcdTriple_multiply (t : CoprimeTriple) : gcdTriple (multiplyTriple t)=t := by + have he : gcd (t.val.1.val*t.val.2.1.val) (t.val.1.val*t.val.2.2.val)=t.val.1.val := by + rw [_root_.gcd_mul_left,normalize_eq,Ideal.isCoprime_iff_gcd.mp t.property,mul_one] + apply Subtype.ext + apply Prod.ext + · exact Subtype.ext he + · apply Prod.ext <;> apply Subtype.ext + · change idealQuotient (gcd _ _) (t.val.1.val*t.val.2.1.val)=t.val.2.1.val + dsimp only [multiplyTriple] + rw [he] + exact mul_left_cancel₀ t.val.1.property.1 (idealQuotient_mul (dvd_mul_right _ _)) + · change idealQuotient (gcd _ _) (t.val.1.val*t.val.2.2.val)=t.val.2.2.val + dsimp only [multiplyTriple] + rw [he] + exact mul_left_cancel₀ t.val.1.property.1 (idealQuotient_mul (dvd_mul_right _ _)) + +def gcdPairEquiv : (SupportedIdeal×SupportedIdeal)≃CoprimeTriple where + toFun := gcdTriple + invFun := multiplyTriple + left_inv := multiply_gcdTriple + right_inv := gcdTriple_multiply + +lemma gcdPair_tsum (f : SupportedIdeal×SupportedIdeal→ℂ) : + (∑'p,f p)=∑'t : CoprimeTriple,f (multiplyTriple t) := by + exact (gcdPairEquiv.symm.tsum_eq f).symm + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramGcdSource.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramGcdSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..200f75c285b000c5c32323c31ba7ba76f4dc5d4d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramGcdSource.lean @@ -0,0 +1,82 @@ +import OAI.NumberTheory.DirichletL.Detector.GramFrequency +import OAI.NumberTheory.DirichletL.Detector.LowGramPoisson + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT +open CenteredMomentCorrelation CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +lemma gcd_generator_left (I J : SupportedIdeal) : + primaryGenerator I.val=primaryGenerator (gcdCommon I J).val*primaryGenerator (gcdLeft I J).val := by + rw [←primaryGenerator_mul,gcd_common_left] + +lemma gcd_generator_right (I J : SupportedIdeal) : + primaryGenerator J.val=primaryGenerator (gcdCommon I J).val*primaryGenerator (gcdRight I J).val := by + rw [←primaryGenerator_mul,gcd_common_right] + +lemma gcd_generator_coprime (I J : SupportedIdeal) : + IsCoprime (primaryGenerator (gcdLeft I J).val) (primaryGenerator (gcdRight I J).val) := by + apply (Ideal.isCoprime_span_singleton_iff _ _).mp + rw [(primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ (gcdLeft I J).property)).1, + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ (gcdRight I J).property)).1] + exact gcd_residual_coprime I J + +theorem actual_gcd_lift (I J : SupportedIdeal) (k : O) : + let C:=primaryGenerator (gcdCommon I J).val + let n₁:=primaryGenerator (gcdLeft I J).val + let n₂:=primaryGenerator (gcdRight I J).val + actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (C*k)= + idealRowHom k (gcdLeft I J).val*star (idealRowHom (-k) (gcdRight I J).val)* + sexticReciprocityPhase n₁ n₂* + actualCommon C ((supported_span_primaryGenerator_iff _).mpr (gcdCommon I J).property) n₁ n₂ k := by + dsimp only + have h₁ := (supported_span_primaryGenerator_iff _).mpr (gcdLeft I J).property + have h₂ := (supported_span_primaryGenerator_iff _).mpr (gcdRight I J).property + have hp₁ : ConcretePrimeRowBridge.goodLambda^2∣primaryGenerator (gcdLeft I J).val-1 := + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ (gcdLeft I J).property)).2 + have hp₂ : ConcretePrimeRowBridge.goodLambda^2∣primaryGenerator (gcdRight I J).val-1 := + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ (gcdRight I J).property)).2 + have hh := actual_common_lift (primaryGenerator (gcdCommon I J).val) + (primaryGenerator (gcdLeft I J).val) (primaryGenerator (gcdRight I J).val) k + ((supported_span_primaryGenerator_iff _).mpr (gcdCommon I J).property) h₁ h₂ hp₁ hp₂ + (gcd_generator_coprime I J) + simpa only [←gcd_generator_left I J,←gcd_generator_right I J, + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ (gcdLeft I J).property)).1, + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ (gcdRight I J).property)).1] using hh + +theorem actual_gcd_frequency_source (I J : SupportedIdeal) (U : SchwartzMap ℝ ℂ) (Q : ℝ) : + (∑'h : O,actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (-h)* + paperRadialFourier U (Q*‖eisEmbedding h‖^2/‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2))= + ∑'k : O,actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (primaryGenerator (gcdCommon I J).val*k)* + paperRadialFourier U (Q*‖eisEmbedding (primaryGenerator (gcdCommon I J).val*k)‖^2/ + ‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2) := by + have hneg := (Equiv.neg O).tsum_eq (fun h : O=> + actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) h* + paperRadialFourier U (Q*‖eisEmbedding h‖^2/‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2)) + simp only [Equiv.neg_apply,map_neg,norm_neg] at hneg + rw [hneg] + have hh := actual_common_frequency_tsum (primaryGenerator (gcdCommon I J).val) + (primaryGenerator (gcdLeft I J).val) (primaryGenerator (gcdRight I J).val) + ((supported_span_primaryGenerator_iff _).mpr (gcdCommon I J).property) + ((supported_span_primaryGenerator_iff _).mpr (gcdLeft I J).property) + ((supported_span_primaryGenerator_iff _).mpr (gcdRight I J).property) + (fun h=>paperRadialFourier U (Q*‖eisEmbedding h‖^2/ + ‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2)) + simpa only [←gcd_generator_left I J,←gcd_generator_right I J] using hh + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramGlobalExtension.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramGlobalExtension.lean new file mode 100644 index 0000000000000000000000000000000000000000..b88870c4cb7433cce2ea83c2909b85130da4f945 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramGlobalExtension.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Detector.GramLocalExtension +import OAI.NumberTheory.DirichletL.Detector.GramCommonPhase + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +open CenteredMomentCorrelation CenteredMomentCanonical CenteredMomentSupportedCorrelation +local notation "O" => ActualEisensteinCubic.O +variable {ι : Type*} [Fintype ι] + +def globalExtension (P : ι→Ideal O) [∀i,(P i).IsMaximal] + (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) (n₁ n₂ k : O) : ℂ := + ∏i,localExtension (P i) (hg i) (c i) n₁ n₂ k + +lemma globalExtension_norm (P : ι→Ideal O) [∀i,(P i).IsMaximal] + (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) (hc : ∀i,1≤c i) (n₁ n₂ k : O) : + ‖globalExtension P hg c n₁ n₂ k‖≤(Ideal.absNorm (∏i,P i^c i):ℝ) := by + rw [globalExtension,norm_prod] + calc + _ ≤ ∏i,(Ideal.absNorm (P i):ℝ)^c i := + Finset.prod_le_prod₀ (fun _ _=>norm_nonneg _) (fun i _=>localExtension_norm (P i) (hg i) (c i) (hc i) n₁ n₂ k) + _ = _ := by simp only [map_prod,map_pow,Nat.cast_prod,Nat.cast_pow] + +theorem globalExtension_periodic (P : ι→Ideal O) [∀i,(P i).IsMaximal] + (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) (n₁ n₂ m₁ m₂ k l : O) + (h₁ : n₁-m₁∈∏i,P i) (h₂ : n₂-m₂∈∏i,P i) (hk : k-l∈∏i,P i) : + globalExtension P hg c n₁ n₂ k=globalExtension P hg c m₁ m₂ l := by + apply Finset.prod_congr rfl + intro i hi + have hle : (∏i,P i)≤P i := Ideal.prod_le_inf.trans (Finset.inf_le (Finset.mem_univ i)) + exact localExtension_periodic (P i) (hg i) (c i) n₁ n₂ m₁ m₂ k l (hle h₁) (hle h₂) (hle hk) + +theorem canonical_common_extension (P : ι→Ideal O) [∀i,(P i).IsMaximal] + (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) (hc : ∀i,1≤c i) + (hcop : Pairwise (Function.onFun IsCoprime P)) + [Fintype (O⧸∏i,P i^c i)] [∀i,Fintype (O⧸P i^c i)] + (n₁ n₂ k : O) (hn : IsCoprime n₁ n₂) : + fullCorrelation (fun x : O⧸∏i,P i^c i=>Ideal.Quotient.mk _ n₂*x) + (fun y : O⧸∏i,P i^c i=>Ideal.Quotient.mk _ n₁*y) + (canonicalCRTCharacter P hg c hc hcop) (canonicalCRTCharacter P hg c hc hcop) + (Ideal.Quotient.mk _ k)=globalExtension P hg c n₁ n₂ k := by + have hpc : Pairwise (Function.onFun IsCoprime (fun i => P i ^ c i)) := by + intro i j hij + exact (hcop hij).pow + have he := canonicalCRTCorrelation P hg c hc hcop + (Ideal.Quotient.mk _ n₁) (Ideal.Quotient.mk _ n₂) (Ideal.Quotient.mk _ k) + have hprod : fullCorrelation (fun x : O⧸∏i,P i^c i=>Ideal.Quotient.mk _ n₂*x) + (fun y : O⧸∏i,P i^c i=>Ideal.Quotient.mk _ n₁*y) + (canonicalCRTCharacter P hg c hc hcop) (canonicalCRTCharacter P hg c hc hcop) + (Ideal.Quotient.mk _ k) = + ∏i,fullCorrelation (fun x : O⧸P i^c i=>Ideal.Quotient.mk _ n₂*x) + (fun y : O⧸P i^c i=>Ideal.Quotient.mk _ n₁*y) + (primePowerRow (P i) (hg i) (hc i)) (primePowerRow (P i) (hg i) (hc i)) + (Ideal.Quotient.mk _ k) := by + simpa only [IdealGaussCRT.quotientProdEquivPi_mk + (fun i => P i ^ c i) hpc] using he + rw [hprod] + apply Finset.prod_congr rfl + intro i hi + apply primePower_common_extension + by_contra h + push Not at h + obtain ⟨a,b,hab⟩ := hn + have hmem : (1:O)∈P i := by + rw [←hab] + exact (P i).add_mem ((P i).mul_mem_left a h.1) ((P i).mul_mem_left b h.2) + exact (Ideal.IsMaximal.ne_top (I:=P i) inferInstance) ((Ideal.eq_top_iff_one (P i)).mpr hmem) + +theorem actualCommon_eq_globalExtension (C : O) (hC : Supported (Ideal.span {C})) + (P : ι→Ideal O) [∀i,(P i).IsMaximal] (hg : ∀i,goodLambda∉P i) + (c : ι→ℕ) (hc : ∀i,1≤c i) (hcop : Pairwise (Function.onFun IsCoprime P)) + (he : Ideal.span {C}=∏i,P i^c i) + [Fintype (O⧸∏i,P i^c i)] [∀i,Fintype (O⧸P i^c i)] + (n₁ n₂ k : O) (hn : IsCoprime n₁ n₂) : + actualCommon C hC n₁ n₂ k=globalExtension P hg c n₁ n₂ k := by + let := finite_quotient_span (supported_element_ne_zero C hC) + let : Fintype (O⧸Ideal.span {C}) := Fintype.ofFinite _ + let e := Ideal.quotEquivOfEq he + have hchar : (supportedModulusCharacter C hC : (O⧸Ideal.span {C})→ℂ)= + (fun x=>canonicalCRTCharacter P hg c hc hcop (e x)) := by + funext x + obtain ⟨x,rfl⟩ := Ideal.Quotient.mk_surjective x + rw [show e (Ideal.Quotient.mk _ x)=Ideal.Quotient.mk _ x from Ideal.quotEquivOfEq_mk he x, + canonicalCRTCharacter_mk,supportedModulusCharacter_mk,he] + rw [actualCommon,hchar,fullCorrelation_ringEquiv e] + simp only [e,Ideal.quotEquivOfEq_mk] + exact canonical_common_extension P hg c hc hcop n₁ n₂ k hn + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealDilation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealDilation.lean new file mode 100644 index 0000000000000000000000000000000000000000..d71a9b4dd10abf28a708050d85efffe15fbd58d2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealDilation.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Detector.GramGcd + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev DivisibleSupported (D : SupportedIdeal) := {I : SupportedIdeal // D.val∣I.val} + +def supportedIdealProduct (D J : SupportedIdeal) : SupportedIdeal := + ⟨D.val*J.val,(supported_mul_iff _ _).mpr ⟨D.property,J.property⟩⟩ + +def supportedDilationEquiv (D : SupportedIdeal) : SupportedIdeal≃DivisibleSupported D where + toFun J := ⟨supportedIdealProduct D J,dvd_mul_right _ _⟩ + invFun I := ⟨idealQuotient D.val I.val.val,gram_supported_quotient I.val.val D.val I.val.property I.property⟩ + left_inv J := by + apply Subtype.ext + exact mul_left_cancel₀ D.property.1 (idealQuotient_mul (dvd_mul_right D.val J.val)) + right_inv I := by + apply Subtype.ext + apply Subtype.ext + exact idealQuotient_mul I.property + +lemma supported_dilation_generator (D J : SupportedIdeal) : + primaryGenerator (supportedIdealProduct D J).val=primaryGenerator D.val*primaryGenerator J.val := + primaryGenerator_mul _ _ + +lemma supported_dilation_norm (D J : SupportedIdeal) : + Ideal.absNorm (supportedIdealProduct D J).val=Ideal.absNorm D.val*Ideal.absNorm J.val := + map_mul Ideal.absNorm _ _ + +theorem supported_divisor_tsum (D : SupportedIdeal) (f : SupportedIdeal→ℂ) : + (∑'I : SupportedIdeal,if D.val∣I.val then f I else 0)= + ∑'J : SupportedIdeal,f (supportedIdealProduct D J) := by + change (∑'I : SupportedIdeal,({I : SupportedIdeal | D.val∣I.val}.indicator f) I)=_ + rw [←tsum_subtype (s:={I : SupportedIdeal | D.val∣I.val}) (f:=f)] + exact (supportedDilationEquiv D).tsum_eq (fun I : DivisibleSupported D=>f I.val) |>.symm + +theorem supported_divisor_pair_tsum (D : SupportedIdeal) (f : SupportedIdeal→SupportedIdeal→ℂ) : + (∑'I : SupportedIdeal,∑'J : SupportedIdeal, + if D.val∣I.val ∧ D.val∣J.val then f I J else 0)= + ∑'I : SupportedIdeal,∑'J : SupportedIdeal, + f (supportedIdealProduct D I) (supportedIdealProduct D J) := by + have hinner (I : SupportedIdeal) : (∑'J : SupportedIdeal,if D.val∣I.val ∧ D.val∣J.val then f I J else 0)= + if D.val∣I.val then ∑'J : SupportedIdeal,f I (supportedIdealProduct D J) else 0 := by + by_cases hI : D.val∣I.val + · simp only [hI,true_and,ite_true] + exact supported_divisor_tsum D (f I) + · simp [hI] + simp_rw [hinner] + exact supported_divisor_tsum D (fun I=>∑'J : SupportedIdeal,f I (supportedIdealProduct D J)) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealMass.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..9052ad4a90e0aae792fe1d9ab1410c7c1c84cc51 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealMass.lean @@ -0,0 +1,137 @@ +import OAI.NumberTheory.DirichletL.Detector.GramFrequencyMass +import OAI.NumberTheory.DirichletL.Detector.GramPrefactor + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma normalized_double_sum_bound (F G : Finset SupportedIdeal) (α V : SupportedIdeal→SupportedIdeal→ℂ) + (hα : ∀C∈F,∀D∈G,‖α C D‖≤1) (p : ℝ) (hp : 0≤p) : + ‖(p:ℂ)*(∑C∈F,∑D∈G,α C D*V C D)‖≤∑C∈F,∑D∈G,p*‖V C D‖ := by + rw [norm_mul,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg hp] + calc + _≤p*(∑C∈F,∑D∈G,‖α C D*V C D‖) := mul_le_mul_of_nonneg_left + ((norm_sum_le _ _).trans (Finset.sum_le_sum (fun _ _=>norm_sum_le _ _))) hp + _≤p*(∑C∈F,∑D∈G,‖V C D‖) := by + apply mul_le_mul_of_nonneg_left _ hp + apply Finset.sum_le_sum + intro C hC + apply Finset.sum_le_sum + intro D hD + rw [norm_mul] + exact (mul_le_mul_of_nonneg_right (hα C hC D hD) (norm_nonneg _)).trans_eq (one_mul _) + _=_ := by simp only [Finset.mul_sum] + +theorem canonical_nonexceptional_ideal_sum (δ : ℝ) (hδ : 0<δ) (hδ1 : δ<1) + (A : ℕ) (hA : 2∑k∈E C D, + canonicalLatticeBlock S hS σ C k (primaryGenerator D.val) W U v + ((Ideal.absNorm (Ideal.span {k.val}):ℝ)/(P/gramIdealNorm C)) (Y/(gramIdealNorm C*gramIdealNorm D)) + let B := K*H₀.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J*(Q/Y)*P + have hB : 0≤B := by dsimp [B];positivity + have ht (C D : SupportedIdeal) (hC : C∈F) (hD : D∈G) : + (Q/Y^3)*‖V C D‖≤B*(gramIdealNorm C^(-2:ℝ)*gramIdealNorm D^(-2:ℝ)* + min 1 ((gramIdealNorm C*gramIdealNorm D/(Y/(M*P)))^A)) := by + have hc := gramIdealNorm_pos C + have hd := gramIdealNorm_pos D + have hh := hfreq S hS σ C (E C D) (hE C hC D hD) (primaryGenerator D.val) U v + (P/gramIdealNorm C) (Y/(gramIdealNorm C*gramIdealNorm D)) (by positivity) (by positivity) + have hh' := mul_le_mul_of_nonneg_left hh (show 0≤Q/Y^3 by positivity) + apply hh'.trans_eq + change (Q/Y^3)*(K*H₀.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J* + gramIdealNorm C*(Y/(gramIdealNorm C*gramIdealNorm D))^2*(P/gramIdealNorm C)* + min 1 ((M*gramIdealNorm C*(P/gramIdealNorm C)/(Y/(gramIdealNorm C*gramIdealNorm D)))^A))=_ + calc + _=(K*H₀.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J)* + ((Q/Y^3)*gramIdealNorm C*(Y/(gramIdealNorm C*gramIdealNorm D))^2*(P/gramIdealNorm C)* + min 1 ((M*gramIdealNorm C*(P/gramIdealNorm C)/(Y/(gramIdealNorm C*gramIdealNorm D)))^A)) := by ring + _=_ := by rw [supported_nonexceptional_prefactor C D M P Y Q hM hP hY A];dsimp [B];ring + calc + _≤∑C∈F,∑D∈G,(Q/Y^3)*‖V C D‖ := normalized_double_sum_bound F G α V hα _ (by positivity) + _≤∑C∈F,∑D∈G,B*(gramIdealNorm C^(-2:ℝ)*gramIdealNorm D^(-2:ℝ)* + min 1 ((gramIdealNorm C*gramIdealNorm D/(Y/(M*P)))^A)) := Finset.sum_le_sum (fun C hC=>Finset.sum_le_sum (fun D hD=>ht C D hC hD)) + _=B*(∑C∈F,∑D∈G,gramIdealNorm C^(-2:ℝ)*gramIdealNorm D^(-2:ℝ)* + min 1 ((gramIdealNorm C*gramIdealNorm D/(Y/(M*P)))^A)) := by simp only [Finset.mul_sum] + _≤B*(L*(Y/(M*P))^(-1+δ)) := mul_le_mul_of_nonneg_left (hideal A (by omega) _ (by positivity) F G) hB + _=_ := by dsimp [B,M];ring + +theorem canonical_exceptional_ideal_sum (ε : ℝ) (hε : 0<ε) (hε1 : ε<1/6) + (a b M₀ : ℝ) (ha : 0∑k∈E C D, + canonicalLatticeBlock S hS σ C k (primaryGenerator D.val) W U v + ((Ideal.absNorm (Ideal.span {k.val}):ℝ)/(P/gramIdealNorm C)) (Y/(gramIdealNorm C*gramIdealNorm D)) + let B := K*H₀.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(Q/Y)*M^ε*P^(1/6:ℝ) + have hB : 0≤B := by dsimp [B];positivity + have ht (C D : SupportedIdeal) (hC : C∈F) (hD : D∈G) : + (Q/Y^3)*‖V C D‖≤B*(gramIdealNorm C^(-7/6+ε:ℝ)*gramIdealNorm D^(-2:ℝ)) := by + have hc := gramIdealNorm_pos C + have hd := gramIdealNorm_pos D + have hh := hfreq W hcompact hs hW U S hS σ C (E C D) (hE C hC D hD) (primaryGenerator D.val) v + (P/gramIdealNorm C) (Y/(gramIdealNorm C*gramIdealNorm D)) (by positivity) (by positivity) + have hh' := mul_le_mul_of_nonneg_left hh (show 0≤Q/Y^3 by positivity) + apply hh'.trans_eq + change (Q/Y^3)*(K*H₀.sup (schwartzSeminormFamily ℝ ℝ ℂ) U* + gramIdealNorm C*(Y/(gramIdealNorm C*gramIdealNorm D))^2*(M*gramIdealNorm C)^ε*(P/gramIdealNorm C)^(1/6:ℝ))=_ + calc + _=(K*H₀.sup (schwartzSeminormFamily ℝ ℝ ℂ) U)* + ((Q/Y^3)*gramIdealNorm C*(Y/(gramIdealNorm C*gramIdealNorm D))^2*(M*gramIdealNorm C)^ε*(P/gramIdealNorm C)^(1/6:ℝ)) := by ring + _=_ := by rw [supported_exceptional_prefactor C D M P Y Q ε hM hP hY];dsimp [B];ring + calc + _≤∑C∈F,∑D∈G,(Q/Y^3)*‖V C D‖ := normalized_double_sum_bound F G α V hα _ (by positivity) + _≤∑C∈F,∑D∈G,B*(gramIdealNorm C^(-7/6+ε:ℝ)*gramIdealNorm D^(-2:ℝ)) := + Finset.sum_le_sum (fun C hC=>Finset.sum_le_sum (fun D hD=>ht C D hC hD)) + _=B*(∑C∈F,∑D∈G,gramIdealNorm C^(-7/6+ε:ℝ)*gramIdealNorm D^(-2:ℝ)) := by simp only [Finset.mul_sum] + _≤B*L := mul_le_mul_of_nonneg_left (hideal F G) hB + _=_ := by dsimp [B,M];ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealSummation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealSummation.lean new file mode 100644 index 0000000000000000000000000000000000000000..b889394857052cb8e320e8a04aeb446c02865654 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramIdealSummation.lean @@ -0,0 +1,127 @@ +import OAI.NumberTheory.DirichletL.Foundation + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +namespace SevenEighths.ProbeGramCommon +open ActualEisensteinCubic CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "SupportedIdeal" => {I : Ideal O // Supported I} + +def gramIdealNorm (I : SupportedIdeal) : ℝ := Ideal.absNorm I.val + +lemma gramIdealNorm_pos (I : SupportedIdeal) : 0 < gramIdealNorm I := by + unfold gramIdealNorm + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr I.property.1) + +lemma gramIdealNorm_one_le (I : SupportedIdeal) : 1 ≤ gramIdealNorm I := by + unfold gramIdealNorm + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr I.property.1) + +theorem supportedIdeal_rpow_summable (r : ℝ) (hr : r < -1) : + Summable (fun I : SupportedIdeal => gramIdealNorm I ^ r) := by + have hs := CubicEisenstein.fullIdealWeight_summable_norm ((-r:ℝ):ℂ) + (by simp only [Complex.ofReal_re]; linarith) + have hinj : Function.Injective (fun I : SupportedIdeal => I.val) := Subtype.val_injective + have ht := hs.comp_injective hinj + apply ht.congr + intro I + rw [Function.comp_apply,CubicEisenstein.fullIdealWeight,ite_eq_right I.property.1] + have he : (Ideal.absNorm I.val:ℂ) = ((gramIdealNorm I:ℝ):ℂ) := by simp [gramIdealNorm] + rw [he,Complex.norm_cpow_eq_rpow_re_of_pos (gramIdealNorm_pos I)] + simp only [Complex.neg_re,Complex.ofReal_re,neg_neg] + +theorem supportedIdeal_rpow_finite_bound (r : ℝ) (hr : r < -1) : + ∃ K : ℝ, 0 < K ∧ ∀ F : Finset SupportedIdeal, + (∑ I ∈ F, gramIdealNorm I ^ r) ≤ K := by + have hs := supportedIdeal_rpow_summable r hr + let K := 1 + ∑' I : SupportedIdeal, gramIdealNorm I ^ r + have hn : 0 ≤ ∑' I : SupportedIdeal, gramIdealNorm I ^ r := + tsum_nonneg (fun I => Real.rpow_nonneg (gramIdealNorm_pos I).le _) + refine ⟨K, by dsimp [K]; linarith, ?_⟩ + intro F + exact (hs.sum_le_tsum F (fun I _ => Real.rpow_nonneg (gramIdealNorm_pos I).le _)).trans + (by dsimp [K]; linarith) + +lemma ideal_sum_min_power_bound (t : ℝ) (ht : 0 < t) (A : ℕ) (θ : ℝ) + (hθ : 0 ≤ θ) (hA : θ ≤ A) : min 1 (t^A) ≤ t^θ := by + by_cases h : t ≤ 1 + · apply (min_le_right _ _).trans + rw [← Real.rpow_natCast] + exact Real.rpow_le_rpow_of_exponent_ge ht h hA + · exact (min_le_left _ _).trans (Real.one_le_rpow (le_of_not_ge h) hθ) + +lemma gram_ideal_term_bound (δ Λ : ℝ) (hδ : 0 < δ) (hδ1 : δ < 1) + (hΛ : 0 < Λ) (A : ℕ) (hA : 1 ≤ A) (I J : SupportedIdeal) : + gramIdealNorm I ^ (-2:ℝ) * gramIdealNorm J ^ (-2:ℝ) * + min 1 ((gramIdealNorm I*gramIdealNorm J/Λ)^A) ≤ + Λ^(-1+δ) * (gramIdealNorm I^(-1-δ) * gramIdealNorm J^(-1-δ)) := by + have hi := gramIdealNorm_pos I + have hj := gramIdealNorm_pos J + have ha : (1-δ:ℝ) ≤ A := by + have hh : (1:ℝ) ≤ A := by exact_mod_cast hA + linarith + have hm := ideal_sum_min_power_bound (gramIdealNorm I*gramIdealNorm J/Λ) + (by positivity) A (1-δ) (by linarith) ha + apply (mul_le_mul_of_nonneg_left hm (by positivity)).trans_eq + rw [Real.div_rpow (by positivity) hΛ.le,Real.mul_rpow hi.le hj.le, + div_eq_mul_inv,← Real.rpow_neg hΛ.le] + have hi' : gramIdealNorm I^(-2:ℝ)*gramIdealNorm I^(1-δ)=gramIdealNorm I^(-1-δ) := by + rw [←Real.rpow_add hi] + congr 1 + ring + have hj' : gramIdealNorm J^(-2:ℝ)*gramIdealNorm J^(1-δ)=gramIdealNorm J^(-1-δ) := by + rw [←Real.rpow_add hj] + congr 1 + ring + rw [show -(1-δ) = -1+δ by ring] + calc + _ = Λ^(-1+δ)*((gramIdealNorm I^(-2:ℝ)*gramIdealNorm I^(1-δ))* + (gramIdealNorm J^(-2:ℝ)*gramIdealNorm J^(1-δ))) := by ring + _ = _ := by rw [hi',hj'] + +theorem gram_supported_double_sum (δ : ℝ) (hδ : 0 < δ) (hδ1 : δ < 1) : + ∃ K : ℝ, 0 < K ∧ ∀ (A : ℕ), 1 ≤ A → ∀ (Λ : ℝ), 0 < Λ → + ∀ (F G : Finset SupportedIdeal), + (∑ I ∈ F, ∑ J ∈ G, gramIdealNorm I^(-2:ℝ) * gramIdealNorm J^(-2:ℝ) * + min 1 ((gramIdealNorm I*gramIdealNorm J/Λ)^A)) ≤ K*Λ^(-1+δ) := by + obtain ⟨C,hC,hb⟩ := supportedIdeal_rpow_finite_bound (-1-δ) (by linarith) + refine ⟨C^2, by positivity, ?_⟩ + intro A hA Λ hΛ F G + have hF := hb F + have hG := hb G + have hGn : 0 ≤ ∑ J ∈ G, gramIdealNorm J^(-1-δ) := + Finset.sum_nonneg (fun J _ => Real.rpow_nonneg (gramIdealNorm_pos J).le _) + calc + _ ≤ ∑ I ∈ F, ∑ J ∈ G, Λ^(-1+δ)* + (gramIdealNorm I^(-1-δ)*gramIdealNorm J^(-1-δ)) := + Finset.sum_le_sum (fun I _ => Finset.sum_le_sum + (fun J _ => gram_ideal_term_bound δ Λ hδ hδ1 hΛ A hA I J)) + _ = Λ^(-1+δ)*((∑ I ∈ F, gramIdealNorm I^(-1-δ))* + (∑ J ∈ G, gramIdealNorm J^(-1-δ))) := by + simp only [Finset.mul_sum,Finset.sum_mul] + rw [Finset.sum_comm] + _ ≤ Λ^(-1+δ)*C^2 := by + apply mul_le_mul_of_nonneg_left _ (by positivity) + simpa only [pow_two] using mul_le_mul hF hG hGn hC.le + _ = _ := by ring + +theorem gram_supported_exceptional_sum (ε : ℝ) (_hε : 0 ≤ ε) (hε1 : ε < 1/6) : + ∃ K : ℝ, 0 < K ∧ ∀ (F G : Finset SupportedIdeal), + (∑ I ∈ F, ∑ J ∈ G, + gramIdealNorm I^(-7/6+ε:ℝ)*gramIdealNorm J^(-2:ℝ)) ≤ K := by + obtain ⟨C,hC,hb⟩ := supportedIdeal_rpow_finite_bound (-7/6+ε) (by linarith) + obtain ⟨D,hD,hd⟩ := supportedIdeal_rpow_finite_bound (-2) (by norm_num) + refine ⟨C*D, by positivity, ?_⟩ + intro F G + rw [← Finset.sum_mul_sum] + exact mul_le_mul (hb F) (hd G) + (Finset.sum_nonneg (fun J _ => Real.rpow_nonneg (gramIdealNorm_pos J).le _)) hC.le + +end SevenEighths.ProbeGramCommon + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramInfiniteEstimate.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramInfiniteEstimate.lean new file mode 100644 index 0000000000000000000000000000000000000000..b066e734a080c8d023a27a91014ebe0d4c1540b1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramInfiniteEstimate.lean @@ -0,0 +1,53 @@ +import OAI.NumberTheory.DirichletL.Detector.GramSourceEstimate + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff Topology +namespace SevenEighths.ProbeGramCommon +open Filter ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion +open CenteredMomentGaussEnergy +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma sourceTruncation_tendsto (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (F : Finset SupportedIdeal) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (Y Q : ℝ) (hY : 0sourceTruncation S hS σ F E W hW Y Q hY U v) atTop + (𝓝 (((Q/Y^3:ℝ):ℂ)*∑C∈F,∑'k : GramFrequency,originalCommonBlock S hS σ C k W hW Y Q hY U v)) := by + have hs (C : SupportedIdeal) : Summable (fun k : GramFrequency=>originalCommonBlock S hS σ C k W hW Y Q hY U v) := + originalCommonBlock_summable S hS σ C W hW Y Q hY hQ U v + have hh := (summable_sum (s:=F) (fun C hC=>hs C)).hasSum.mul_left ((Q/Y^3:ℝ):ℂ) + rw [Summable.tsum_finsetSum (fun C hC=>hs C)] at hh + change Tendsto _ atTop (𝓝 _) at hh + convert hh using 1 + funext E + unfold sourceTruncation + rw [←Finset.mul_sum,Finset.sum_comm] + +theorem original_energy_nonzero_bound (δ ε : ℝ) (hδ : 0<δ) (hδ1 : δ<1) + (hε : 0<ε) (hε1 : ε<1/6) (a b M₀ : ℝ) (ha : 0primaryGenerator I.val) + (fun I=>(supported_span_primaryGenerator_iff _).mpr I.property) + (lowGaussColumn (calibrationForSet S hS) W Y σ v) U Q- + lowGramZeroMode (calibrationForSet S hS) W hcompact Y hY σ v U Q‖≤ + K₁*H₁.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J*(Q/Y)*(Y^2/Q)* + (Y/((Ideal.absNorm (jointFixedModulus S hS):ℝ)*(Y^2/Q)))^(-1+δ)+ + K₂*H₂.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(Q/Y)* + (Ideal.absNorm (jointFixedModulus S hS):ℝ)^ε*(Y^2/Q)^(1/6:ℝ) := by + obtain ⟨J,H₁,H₂,K₁,K₂,hK₁,hK₂,hbound⟩ := original_source_truncation_bound δ ε hδ hδ1 hε hε1 a b M₀ ha hab hM₀ W hcompact hs hW hWM + refine ⟨J,H₁,H₂,K₁,K₂,hK₁,hK₂,?_⟩ + intro S hS hbad σ U v Y Q hY hQ + rw [original_energy_common_blocks S hS σ W hcompact Y Q hY hQ U v,add_sub_cancel_left] + exact le_of_tendsto (sourceTruncation_tendsto S hS σ _ W hcompact Y Q hY hQ U v).norm + (Eventually.of_forall (fun E=>hbound S hS hbad σ _ E U v Y Q hY hQ)) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramJoint.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramJoint.lean new file mode 100644 index 0000000000000000000000000000000000000000..55acc5adf41f078dd68899f2583d1db17313c92d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramJoint.lean @@ -0,0 +1,65 @@ +import OAI.NumberTheory.DirichletL.Detector.GramJointFixed + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open CenteredMomentSupportedCorrelation +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +def jointExtension (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) (n₁ n₂ : O) : ℂ := + jointFixed S hS σ C u a b r hr n₁ n₂* + (idealRowHom n₁ (Ideal.span {r})*star (idealRowHom n₂ (Ideal.span {r})))* + globalExtension P hg c n₁ n₂ k + +lemma jointExtension_norm (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) (hc : ∀i,1≤c i) + (n₁ n₂ : O) : ‖jointExtension S hS σ C k u a b r hr P hg c n₁ n₂‖≤Ideal.absNorm (∏i,P i^c i) := by + rw [jointExtension,norm_mul] + have ha : ‖jointFixed S hS σ C u a b r hr n₁ n₂* + (idealRowHom n₁ (Ideal.span {r})*star (idealRowHom n₂ (Ideal.span {r})))‖≤1 := by + rw [norm_mul,norm_mul,norm_star] + exact (mul_le_of_le_one_left (mul_nonneg (norm_nonneg _) (norm_nonneg _)) + (jointFixed_norm _ _ _ _ _ _ _ _ _ _ _)).trans + ((mul_le_of_le_one_left (norm_nonneg _) (idealRowHom_norm _ _)).trans (idealRowHom_norm _ _)) + exact (mul_le_mul_of_nonneg_right ha (norm_nonneg _)).trans (by simpa using globalExtension_norm P hg c hc n₁ n₂ k) + +def jointPeriod (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (P : ι→Id) (r : O) : Id := + jointFixedModulus S hS*(∏i,P i)*Ideal.span {r} + +lemma jointExtension_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) + (n₁ n₂ m₁ m₂ : O) (h₁ : n₁-m₁∈jointPeriod S hS P r) (h₂ : n₂-m₂∈jointPeriod S hS P r) : + jointExtension S hS σ C k u a b r hr P hg c n₁ n₂= + jointExtension S hS σ C k u a b r hr P hg c m₁ m₂ := by + have hf := jointFixed_periodic S hS σ C u a b r hr n₁ n₂ m₁ m₂ + (Ideal.mul_le_left (Ideal.mul_le_left h₁)) (Ideal.mul_le_left (Ideal.mul_le_left h₂)) + have hm₁ := idealRowHom_congr_mod (Ideal.span {r}) n₁ m₁ (Ideal.mul_le_right h₁) + have hm₂ := idealRowHom_congr_mod (Ideal.span {r}) n₂ m₂ (Ideal.mul_le_right h₂) + have he := globalExtension_periodic P hg c n₁ n₂ m₁ m₂ k k + (Ideal.mul_le_right (Ideal.mul_le_left h₁)) (Ideal.mul_le_right (Ideal.mul_le_left h₂)) (by simp) + simp only [jointExtension,hf,hm₁,hm₂,he] + +lemma jointExtension_dilation_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) + (d n₁ n₂ m₁ m₂ : O) (h₁ : n₁-m₁∈jointPeriod S hS P r) (h₂ : n₂-m₂∈jointPeriod S hS P r) : + jointExtension S hS σ C k u a b r hr P hg c (d*n₁) (d*n₂)= + jointExtension S hS σ C k u a b r hr P hg c (d*m₁) (d*m₂) := by + apply jointExtension_periodic + · rw [←mul_sub];exact (jointPeriod S hS P r).mul_mem_left d h₁ + · rw [←mul_sub];exact (jointPeriod S hS P r).mul_mem_left d h₂ + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramJointConstruction.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointConstruction.lean new file mode 100644 index 0000000000000000000000000000000000000000..cff1d3514fec5bc4bb478b639f1e13adde95603d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointConstruction.lean @@ -0,0 +1,274 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.GramLatticeDecay +import OAI.NumberTheory.DirichletL.Detector.GramAnnularLattice + +namespace OAI + +noncomputable section +open Filter Set +open scoped Classical SchwartzMap ContDiff Topology + +namespace ProbeGramJointConstruction +open ProbeGramLatticeDecay EisensteinSchwartzPoisson + +def q1 (z : Joint) : ℝ := ‖z.fst‖^2 +def q2 (z : Joint) : ℝ := ‖z.snd‖^2 + +lemma q1_smooth : ContDiff ℝ ∞ q1 := + (WithLp.fstL 2 ℝ ℂ ℂ).contDiff.norm_sq ℂ +lemma q2_smooth : ContDiff ℝ ∞ q2 := + (WithLp.sndL 2 ℝ ℂ ℂ).contDiff.norm_sq ℂ + +lemma norm_sq_eq (z : Joint) : ‖z‖^2 = q1 z + q2 z := + WithLp.prod_norm_sq_eq_of_L2 z + +def log1 (a b : ℝ) (ha : 0 FourierBridge.logPhase (v/(2*Real.pi)) (phase a b ha z)) := by + unfold FourierBridge.logPhase + exact ((Complex.ofRealCLM.contDiff.comp (contDiff_const.mul h2)).mul contDiff_const).cexp + exact (h1.mul hp).mul (h4.comp (contDiff_const.mul h3)) + +lemma rawProfile_zero_left (W : ℝ→ℂ) (U : 𝓢(ℝ,ℂ)) (v T : ℝ) (z : Joint) + (hz : W (q1 z)=0) : rawProfile W U v T z=0 := by simp [rawProfile,hz] +lemma rawProfile_zero_right (W : ℝ→ℂ) (U : 𝓢(ℝ,ℂ)) (v T : ℝ) (z : Joint) + (hz : W (q2 z)=0) : rawProfile W U v T z=0 := by simp [rawProfile,hz] +lemma patchedProfile_zero_left (W : ℝ→ℂ) (U : 𝓢(ℝ,ℂ)) (a b : ℝ) (ha : 0 hz (by simp [amplitude,h]) + have h2 : W (q2 z)≠0 := fun h => hz (by simp [amplitude,h]) + exact ⟨(hs h1).1,(hs h1).2,(hs h2).1,(hs h2).2⟩ + +lemma annulus_subset_sourceCompact (a b : ℝ) (ha : 0 hz (rawProfile_zero_left W U v T z h) + have h2 : W (q2 z)≠0 := fun h => hz (rawProfile_zero_right W U v T z h) + exact ⟨(hs h1).1,(hs h1).2,(hs h2).1,(hs h2).2⟩ + +lemma rawProfile_hasCompactSupport (W : ℝ→ℂ) (U : 𝓢(ℝ,ℂ)) + (a b : ℝ) (ha : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +def primaryCoefficient (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (n : O) : ℂ := + if λ₀^2∣n-1 then gramCoefficientExtension S hS σ n else 0 + +lemma primaryCoefficient_norm (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (n : O) : + ‖primaryCoefficient S hS σ n‖≤1 := by + unfold primaryCoefficient + split_ifs + · exact gramCoefficientExtension_norm _ _ _ _ + · simp + +def jointFixedModulus (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) : Id := + gramFixedModulus S hS*Ideal.span {λ₀^2}*Ideal.span {(72:O)} + +lemma jointFixedModulus_nonzero (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) : jointFixedModulus S hS≠0 := by + apply mul_ne_zero + · apply mul_ne_zero (gramFixedModulus_nonzero S hS) + exact Ideal.span_singleton_eq_bot.not.mpr (pow_ne_zero _ ConcretePrimeRowBridge.goodLambda_prime.ne_zero) + · exact Ideal.span_singleton_eq_bot.not.mpr (by norm_num) + +lemma primaryCoefficient_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (σ : RayRing) (x y : O) (hxy : x-y∈jointFixedModulus S hS) : + primaryCoefficient S hS σ x=primaryCoefficient S hS σ y := by + have hg := gramCoefficientExtension_periodic S hS σ x y (Ideal.mul_le_left (Ideal.mul_le_left hxy)) + have hp : λ₀^2∣x-y := Ideal.mem_span_singleton.mp (Ideal.mul_le_right (Ideal.mul_le_left hxy)) + have hi : (λ₀^2∣x-1)↔(λ₀^2∣y-1) := by + constructor + · intro h + convert dvd_sub h hp using 1 ; ring + · intro h + convert dvd_add hp h using 1 ; ring + simp only [primaryCoefficient,hi,hg] + +def jointFixed (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) (n₁ n₂ : O) : ℂ := + primaryCoefficient S hS σ (C*n₁)*star (primaryCoefficient S hS σ (C*n₂))* + numeratorBadTwist u a b r hr n₁*star (numeratorBadTwist (-u) a b r hr n₂)* + sexticReciprocityPhase n₁ n₂ + +lemma jointFixed_norm (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) (n₁ n₂ : O) : + ‖jointFixed S hS σ C u a b r hr n₁ n₂‖≤1 := by + unfold jointFixed + simp only [norm_mul,norm_star] + refine (mul_le_of_le_one_left (norm_nonneg _) ?_).trans (sexticReciprocityPhase_norm _ _) + refine (mul_le_of_le_one_left (norm_nonneg _) ?_).trans (numeratorBadTwist_norm _ _ _ _ _ _) + refine (mul_le_of_le_one_left (norm_nonneg _) ?_).trans (numeratorBadTwist_norm _ _ _ _ _ _) + exact (mul_le_of_le_one_left (norm_nonneg _) (primaryCoefficient_norm _ _ _ _)).trans (primaryCoefficient_norm _ _ _ _) + +lemma jointFixed_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) (n₁ n₂ m₁ m₂ : O) + (h₁ : n₁-m₁∈jointFixedModulus S hS) (h₂ : n₂-m₂∈jointFixedModulus S hS) : + jointFixed S hS σ C u a b r hr n₁ n₂=jointFixed S hS σ C u a b r hr m₁ m₂ := by + have hc₁ := primaryCoefficient_periodic S hS σ (C*n₁) (C*m₁) + (by rw [←mul_sub];exact (jointFixedModulus S hS).mul_mem_left C h₁) + have hc₂ := primaryCoefficient_periodic S hS σ (C*n₂) (C*m₂) + (by rw [←mul_sub];exact (jointFixedModulus S hS).mul_mem_left C h₂) + have hb₁ := numeratorBadTwist_periodic u a b r hr n₁ m₁ (Ideal.mul_le_right h₁) + have hb₂ := numeratorBadTwist_periodic (-u) a b r hr n₂ m₂ (Ideal.mul_le_right h₂) + have hfour (x y : O) (h : x-y∈jointFixedModulus S hS) : (4:O)∣x-y := + (show (4:O)∣72 from ⟨18,by norm_num⟩).trans (Ideal.mem_span_singleton.mp (Ideal.mul_le_right h)) + have hp : sexticReciprocityPhase n₁ n₂=sexticReciprocityPhase m₁ m₂ := by + unfold sexticReciprocityPhase + rw [QuadraticGaussRay.residue_eq_of_four_dvd_sub n₁ m₁ (hfour _ _ h₁), + QuadraticGaussRay.residue_eq_of_four_dvd_sub n₂ m₂ (hfour _ _ h₂)] + simp only [jointFixed,hc₁,hc₂,hb₁,hb₂,hp] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramJointMean.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointMean.lean new file mode 100644 index 0000000000000000000000000000000000000000..6a31c4b5f704cf182699a64637c1584aa4c1b85a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointMean.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Detector.GramJointSource +import OAI.NumberTheory.DirichletL.Detector.GramMeanLift + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open ConcretePrimeRowBridge CenteredMomentCorrelation +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +variable {ι : Type*} [Fintype ι] + +def jointRemainder (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) + (J : Id) (n₁ n₂ : O) : ℂ := + jointFixed S hS σ C u a b r hr n₁ n₂* + (idealRowHom n₁ J*star (idealRowHom n₂ (Ideal.span {r})))*globalExtension P hg c n₁ n₂ k + +theorem jointExtension_local_factor (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) + (J p : Id) [p.IsMaximal] (hgp : goodLambda∉p) (e : ℕ) (he : e≠0) + (hfactor : Ideal.span {r}=J*p^e) (n₁ n₂ : O) : + jointExtension S hS σ C k u a b r hr P hg c n₁ n₂= + (actualSextic p hgp^e) (Ideal.Quotient.mk p n₁)* + jointRemainder S hS σ C k u a b r hr P hg c J n₁ n₂ := by + have hf : idealRowHom n₁ (Ideal.span {r})= + idealRowHom n₁ J*(actualSextic p hgp^e) (Ideal.Quotient.mk p n₁) := by + rw [hfactor,map_mul,map_pow,idealRowHom_prime n₁ p hgp,MulChar.pow_apply' _ he] + rw [jointExtension,hf,jointRemainder] + ring + +lemma jointRemainder_periodic_first (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) + (J : Id) (n m y : O) (h : n-m∈jointFixedModulus S hS*(∏i,P i)*J) : + jointRemainder S hS σ C k u a b r hr P hg c J n y= + jointRemainder S hS σ C k u a b r hr P hg c J m y := by + have hf := jointFixed_periodic S hS σ C u a b r hr n y m y + (Ideal.mul_le_left (Ideal.mul_le_left h)) (by simp) + have hm := idealRowHom_congr_mod J n m (Ideal.mul_le_right h) + have hg' := globalExtension_periodic P hg c n y m y k k + (Ideal.mul_le_right (Ideal.mul_le_left h)) (by simp) (by simp) + simp only [jointRemainder,hf,hm,hg'] + +theorem jointExtension_mean_zero (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) + (J p : Id) [p.IsMaximal] (hgp : goodLambda∉p) (hchar : ringChar (O⧸p)≠2) + (e : ℕ) (he : ¬6∣e) (hfactor : Ideal.span {r}=J*p^e) + (hcop : IsCoprime (jointFixedModulus S hS*(∏i,P i)*J) (p^e)) + [Fintype (O⧸jointFixedModulus S hS*(∏i,P i)*J)] [Fintype (O⧸p^e)] + [Fintype (O⧸(jointFixedModulus S hS*(∏i,P i)*J)*p^e)] (d : O) : + (∑x : O⧸(jointFixedModulus S hS*(∏i,P i)*J)*p^e, + ∑y : O⧸(jointFixedModulus S hS*(∏i,P i)*J)*p^e, + jointExtension S hS σ C k u a b r hr P hg c (d*x.out) (d*y.out))=0 := by + have he0 : e≠0 := by intro h;exact he (h ▸ dvd_zero 6) + have he1 : 1≤e := Nat.one_le_iff_ne_zero.mpr he0 + simp_rw [jointExtension_local_factor S hS σ C k u a b r hr P hg c J p hgp e he0 hfactor] + apply joint_mean_of_local_factor _ p hgp hchar e e he1 he hcop + (fun x y=>jointRemainder S hS σ C k u a b r hr P hg c J (d*x) (d*y)) _ d + intro x z y hxz + apply jointRemainder_periodic_first + rw [←mul_sub] + exact (jointFixedModulus S hS*(∏i,P i)*J).mul_mem_left d hxz + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramJointPeriod.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointPeriod.lean new file mode 100644 index 0000000000000000000000000000000000000000..a0ab10c0c75e09fbeac901949c241221b04ee325 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointPeriod.lean @@ -0,0 +1,50 @@ +import OAI.NumberTheory.DirichletL.Detector.GramJointMean + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +lemma common_radical_norm_le (C : O) (hC : C≠0) (P : ι→Id) (c : ι→ℕ) + (hc : ∀i,1≤c i) (he : Ideal.span {C}=∏i,P i^c i) : + Ideal.absNorm (∏i,P i)≤Ideal.absNorm (Ideal.span {C}) := by + apply Nat.le_of_dvd (Nat.pos_of_ne_zero + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hC))) + apply map_dvd Ideal.absNorm + rw [he] + exact Finset.prod_dvd_prod_of_dvd _ _ (fun i _=>dvd_pow_self _ (Nat.one_le_iff_ne_zero.mp (hc i))) + +lemma jointPeriod_norm_bound (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (C k : O) (hC : C≠0) (hk0 : k≠0) (u : Oˣ) (a b : ℕ) (r : O) + (hk : k=u.val*λ₀^a*(2:O)^b*r) (P : ι→Id) (c : ι→ℕ) + (hc : ∀i,1≤c i) (he : Ideal.span {C}=∏i,P i^c i) : + Ideal.absNorm (jointPeriod S hS P r)≤ + Ideal.absNorm (jointFixedModulus S hS)*Ideal.absNorm (Ideal.span {C})*Ideal.absNorm (Ideal.span {k}) := by + rw [jointPeriod,map_mul,map_mul] + exact Nat.mul_le_mul (Nat.mul_le_mul_left _ (common_radical_norm_le C hC P c hc he)) + (numerator_good_norm_le u a b r k hk hk0) + +lemma jointPeriod_nonzero (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (C : O) (hC : C≠0) (P : ι→Id) (c : ι→ℕ) + (hc : ∀i,1≤c i) (he : Ideal.span {C}=∏i,P i^c i) (r : O) (hr : r≠0) : + jointPeriod S hS P r≠0 := by + have hp : ∏i,P i≠(0:Id) := by + intro hz + have hd : (∏i,P i)∣Ideal.span {C} := by + rw [he] + exact Finset.prod_dvd_prod_of_dvd _ _ (fun i _=>dvd_pow_self _ (Nat.one_le_iff_ne_zero.mp (hc i))) + rw [hz,zero_dvd_iff] at hd + exact hC (Ideal.span_singleton_eq_bot.mp hd) + exact mul_ne_zero (mul_ne_zero (jointFixedModulus_nonzero S hS) hp) + (Ideal.span_singleton_eq_bot.not.mpr hr) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramJointProfile.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..7f5337627e0c9b065b5374043d65e577ca353852 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointProfile.lean @@ -0,0 +1,415 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.GramLatticeDecay +import OAI.NumberTheory.DirichletL.Detector.GramAnnularLattice +import OAI.NumberTheory.DirichletL.Detector.GramJointConstruction + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set FourierBridge +namespace ProbeGramJointProfile +open ProbeGramLatticeDecay EisensteinSchwartzPoisson + +def rayControl (B n : ℕ) (g : 𝓢(ℝ, ℂ)) : ℝ := + (Finset.Iic (2*B+n,n)).sup (schwartzSeminormFamily ℝ ℝ ℂ) g + +lemma rayControl_nonneg (B n : ℕ) (g : 𝓢(ℝ, ℂ)) : + 0 ≤ rayControl B n g := apply_nonneg _ _ + +lemma mul_derivative_bound {f g : Joint → ℂ} (n : ℕ) + (hf : ContDiff ℝ ∞ f) (hg : ContDiff ℝ ∞ g) (x : Joint) + {C D : ℝ} (hC : 0 ≤ C) (_hD : 0 ≤ D) + (hfb : ∀ i ≤ n, ‖iteratedFDeriv ℝ i f x‖ ≤ C) + (hgb : ∀ i ≤ n, ‖iteratedFDeriv ℝ i g x‖ ≤ D) : + ‖iteratedFDeriv ℝ n (fun y => f y * g y) x‖ ≤ 2^n*C*D := by + calc + _ ≤ ∑ i ∈ Finset.range (n+1), (n.choose i : ℝ) * + ‖iteratedFDeriv ℝ i f x‖ * ‖iteratedFDeriv ℝ (n-i) g x‖ := + norm_iteratedFDeriv_mul_le hf hg x (by simp) + _ ≤ ∑ i ∈ Finset.range (n+1), (n.choose i : ℝ) * C * D := by + apply Finset.sum_le_sum + intro i hi + exact mul_le_mul (mul_le_mul_of_nonneg_left + (hfb i (Finset.mem_range_succ_iff.mp hi)) (by positivity)) + (hgb (n-i) (Nat.sub_le _ _)) (norm_nonneg _) (by positivity) + _ = _ := by + rw [← Finset.sum_mul, ← Finset.sum_mul, ← Nat.cast_sum, Nat.sum_range_choose] + norm_cast + +lemma compact_derivatives {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] + {K : Set Joint} (hK : IsCompact K) {f : Joint → F} + (hf : ContDiff ℝ ∞ f) (n : ℕ) : + ∃ D : ℝ, 1 ≤ D ∧ ∀ i ≤ n, ∀ x ∈ K, + ‖iteratedFDeriv ℝ i f x‖ ≤ D := by + have hb (i : ℕ) : ∃ D : ℝ, ∀ x ∈ K, ‖iteratedFDeriv ℝ i f x‖ ≤ D := by + obtain ⟨D, hD⟩ := hK.bddAbove_image + (hf.continuous_iteratedFDeriv (by exact_mod_cast le_top)).norm.continuousOn + exact ⟨D, fun x hx => hD (Set.mem_image_of_mem _ hx)⟩ + choose D hD using hb + refine ⟨1 + ∑ i ∈ Finset.range (n+1), |D i|, by + have hn : 0 ≤ ∑ i ∈ Finset.range (n+1), |D i| := by positivity + linarith, ?_⟩ + intro i hi x hx + have hs : |D i| ≤ ∑ j ∈ Finset.range (n+1), |D j| := + Finset.single_le_sum (fun j _ => abs_nonneg (D j)) (Finset.mem_range.mpr (by omega)) + exact (hD i x hx).trans ((le_abs_self _).trans (by linarith)) + +lemma compact_positive_margin {K : Set Joint} (hK : IsCompact K) + {h : Joint → ℝ} (hc : Continuous h) (hp : ∀ x ∈ K, 0 < h x) : + ∃ m : ℝ, 0 < m ∧ m ≤ 1 ∧ ∀ x ∈ K, m ≤ h x := by + by_cases hne : K.Nonempty + · obtain ⟨x, hx, hm⟩ := hK.exists_isMinOn hne hc.continuousOn + exact ⟨min 1 (h x), lt_min zero_lt_one (hp x hx), min_le_left _ _, + fun y hy => (min_le_right _ _).trans (hm hy)⟩ + · exact ⟨1, zero_lt_one, le_rfl, fun x hx => False.elim (hne ⟨x,hx⟩)⟩ + +lemma scaled_argument_derivative {h : Joint → ℝ} (hh : ContDiff ℝ ∞ h) + {D R : ℝ} (hD : 1 ≤ D) (hR : 0 ≤ R) (i : ℕ) (hi : 1 ≤ i) + (x : Joint) (hb : ‖iteratedFDeriv ℝ i h x‖ ≤ D) : + ‖iteratedFDeriv ℝ i (fun y => R*h y) x‖ ≤ (D^2*(1+R))^i := by + have he : iteratedFDeriv ℝ i (fun y => R*h y) x = R • iteratedFDeriv ℝ i h x := + by simpa only [smul_eq_mul] using + (iteratedFDeriv_const_smul_apply' (a := R) (i := i) (x := x) + ((hh.of_le (by exact_mod_cast le_top)).contDiffAt)) + rw [he, norm_smul, Real.norm_of_nonneg hR] + have hDi : D ≤ D^i := by + calc D = D^1 := by simp + _ ≤ D^i := pow_le_pow_right₀ hD hi + have hRi : R ≤ (1+R)^i := by + calc R ≤ 1+R := by linarith + _ = (1+R)^1 := by simp + _ ≤ (1+R)^i := pow_le_pow_right₀ (by linarith) hi + calc + R * ‖iteratedFDeriv ℝ i h x‖ ≤ R*D := mul_le_mul_of_nonneg_left hb hR + _ ≤ (1+R)^i * D^i := mul_le_mul hRi hDi (by linarith) (by positivity) + _ ≤ (D^2*(1+R))^i := by + rw [mul_pow, pow_two, mul_pow] + have hhD : 1 ≤ D^i := one_le_pow₀ hD + nlinarith [mul_nonneg (show 0 ≤ (1+R)^i by positivity) + (show 0 ≤ (D^i)^2-D^i by nlinarith)] + +lemma normalized_phase_derivative (v x : ℝ) (i : ℕ) : + ‖iteratedFDeriv ℝ i (logPhase (v/(2*Real.pi))) x‖ = |v|^i := by + rw [JointLogSeparation.logPhase_iteratedFDeriv_norm, norm_div, + Real.norm_of_nonneg (by positivity : 0 ≤ 2*Real.pi), Real.norm_eq_abs] + congr 1 + field_simp + +lemma phase_derivative_bound {φ : Joint → ℝ} (hφ : ContDiff ℝ ∞ φ) + {D : ℝ} (hD : 1 ≤ D) (n j : ℕ) (hj : j ≤ n) + (x : Joint) (hb : ∀ i ≤ n, ‖iteratedFDeriv ℝ i φ x‖ ≤ D) (v : ℝ) : + ‖iteratedFDeriv ℝ j (fun y => logPhase (v/(2*Real.pi)) (φ y)) x‖ ≤ + (n.factorial : ℝ)*D^n*(1+|v|)^n := by + have hcomp := norm_iteratedFDeriv_comp_le (JointLogSeparation.logPhase_temperate (v/(2*Real.pi))).1 + hφ (n := j) (by simp) x (C := (1+|v|)^n) (D := D) + have hc : ∀ i ≤ j, ‖iteratedFDeriv ℝ i (logPhase (v/(2*Real.pi))) (φ x)‖ ≤ + (1+|v|)^n := by + intro i hi + rw [normalized_phase_derivative] + exact (pow_le_pow_left₀ (abs_nonneg _) (by linarith : |v| ≤ 1+|v|) i).trans + (pow_le_pow_right₀ (by linarith [abs_nonneg v]) (hi.trans hj)) + have hd : ∀ i, 1 ≤ i → i ≤ j → ‖iteratedFDeriv ℝ i φ x‖ ≤ D^i := by + intro i hi hij + exact (hb i (hij.trans hj)).trans (by + calc D = D^1 := by simp + _ ≤ D^i := pow_le_pow_right₀ hD hi) + calc + _ ≤ (j.factorial : ℝ)*(1+|v|)^n*D^j := hcomp hc hd + _ ≤ (n.factorial : ℝ)*(1+|v|)^n*D^n := by + exact mul_le_mul + (mul_le_mul_of_nonneg_right (by exact_mod_cast Nat.factorial_le hj) (by positivity)) + (pow_le_pow_right₀ hD hj) (by positivity) (by positivity) + _ = _ := by ring + +lemma kernel_derivative_bound {h : Joint → ℝ} (hh : ContDiff ℝ ∞ h) + {D m R : ℝ} (hD : 1 ≤ D) (hm : 0 < m) (hm1 : m ≤ 1) (hR : 0 ≤ R) + (B n j : ℕ) (hj : j ≤ n) (x : Joint) + (hb : ∀ i ≤ n, ‖iteratedFDeriv ℝ i h x‖ ≤ D) (hl : m ≤ h x) + (g : 𝓢(ℝ, ℂ)) : + ‖iteratedFDeriv ℝ j (fun y => g (R*h y)) x‖ ≤ + (((n.factorial : ℝ)*2^(2*B+n)*(D^2)^n/m^(2*B+n))*rayControl B n g) / + (1+R)^(2*B) := by + have hu : 0 ≤ R*h x := mul_nonneg hR (hm.le.trans hl) + have hden : 0 < (1+R*h x)^(2*B+n) := by positivity + have harg : ContDiff ℝ ∞ (fun y => R*h y) := contDiff_const.mul hh + have hcomp : ‖iteratedFDeriv ℝ j (fun y => g (R*h y)) x‖ ≤ + (j.factorial : ℝ)*(2^(2*B+n)*rayControl B n g/(1+R*h x)^(2*B+n))* + (D^2*(1+R))^j := by + apply norm_iteratedFDeriv_comp_le (g.smooth ⊤) harg (by simp) x + · intro i hi + apply (le_div_iff₀ hden).mpr + have hd := SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) + (m := (2*B+n,n)) (k := 2*B+n) (n := i) le_rfl (hi.trans hj) g (R*h x) + change (1+‖R*h x‖)^(2*B+n) * ‖iteratedFDeriv ℝ i g (R*h x)‖ ≤ + 2^(2*B+n)*rayControl B n g at hd + rw [Real.norm_of_nonneg hu] at hd + simpa only [mul_comm] using hd + · intro i hi hij + exact scaled_argument_derivative hh hD hR i hi x (hb i (hij.trans hj)) + have hscale : m*(1+R) ≤ 1+R*h x := by + nlinarith [mul_nonneg hR (sub_nonneg.mpr hl)] + have habs := FourierBridge.derivative_scale_absorption R (R*h x) m D + (2^(2*B+n)*rayControl B n g) (2*B) n j hR hm (by linarith) + (mul_nonneg (by positivity) (rayControl_nonneg _ _ _)) hu hscale hj + have hbound : m^(2*B+n)*(1+R)^(2*B)* + ‖iteratedFDeriv ℝ j (fun y => g (R*h y)) x‖ ≤ + (n.factorial : ℝ)*(2^(2*B+n)*rayControl B n g)*(D^2)^n := by + calc + _ ≤ m^(2*B+n)*(1+R)^(2*B)* + ((j.factorial : ℝ)*(2^(2*B+n)*rayControl B n g/(1+R*h x)^(2*B+n))* + (D^2*(1+R))^j) := mul_le_mul_of_nonneg_left hcomp (by positivity) + _ ≤ (j.factorial : ℝ)*(2^(2*B+n)*rayControl B n g)*(D^2)^j := habs + _ ≤ _ := by + exact mul_le_mul + (mul_le_mul_of_nonneg_right (by exact_mod_cast Nat.factorial_le hj) + (mul_nonneg (by positivity) (rayControl_nonneg _ _ _))) + (pow_le_pow_right₀ (one_le_pow₀ hD) hj) (by positivity) + (mul_nonneg (by positivity) (mul_nonneg (by positivity) (rayControl_nonneg _ _ _))) + apply (le_div_iff₀ (by positivity : 0 < (1+R)^(2*B))).mpr + rw [div_mul_eq_mul_div] + apply (le_div_iff₀ (by positivity : 0 < m^(2*B+n))).mpr + convert hbound using 1 <;> ring + +def amplitudeControl (n : ℕ) (A : 𝓢(Joint, ℂ)) : ℝ := + (Finset.Iic (0,n)).sup (schwartzSeminormFamily ℝ Joint ℂ) A + +lemma amplitudeControl_nonneg (n : ℕ) (A : 𝓢(Joint, ℂ)) : + 0 ≤ amplitudeControl n A := apply_nonneg _ _ + +lemma amplitude_derivative_bound (n i : ℕ) (hi : i ≤ n) + (A : 𝓢(Joint, ℂ)) (x : Joint) : + ‖iteratedFDeriv ℝ i A x‖ ≤ amplitudeControl n A := by + have hp : schwartzSeminormFamily ℝ Joint ℂ (0, i) ≤ + (Finset.Iic (0,n)).sup (schwartzSeminormFamily ℝ Joint ℂ) := + Finset.le_sup (Finset.mem_Iic.mpr ⟨le_rfl, hi⟩) + have hz : ‖iteratedFDeriv ℝ i A x‖ ≤ SchwartzMap.seminorm ℝ 0 i A := by + simpa using SchwartzMap.le_seminorm ℝ 0 i A x + exact hz.trans (Seminorm.le_def.mp hp A) + +theorem compact_profile_seminorm + {K : Set Joint} (hK : IsCompact K) {φ h : Joint → ℝ} + (hφ : ContDiff ℝ ∞ φ) (hh : ContDiff ℝ ∞ h) + (hhpos : ∀ x ∈ K, 0 < h x) (B k n : ℕ) : + ∃ C : ℝ, 0 < C ∧ ∀ (A : 𝓢(Joint, ℂ)), tsupport (A : Joint → ℂ) ⊆ K → + ∀ (g : 𝓢(ℝ, ℂ)) (v R : ℝ), 0 ≤ R → + ∀ (F : 𝓢(Joint, ℂ)), + (∀ x, F x = A x * logPhase (v/(2*Real.pi)) (φ x) * g (R*h x)) → + SchwartzMap.seminorm ℝ k n F ≤ + C*amplitudeControl n A*rayControl B n g*(1+|v|)^n/(1+R)^(2*B) := by + obtain ⟨Dφ, hDφ, hbφ⟩ := compact_derivatives hK hφ n + obtain ⟨Dh, hDh, hbh⟩ := compact_derivatives hK hh n + obtain ⟨m, hm, hm1, hml⟩ := compact_positive_margin hK hh.continuous hhpos + obtain ⟨L0, hL0⟩ := hK.bddAbove_image (continuous_norm.continuousOn : ContinuousOn (fun x : Joint => ‖x‖) K) + let D := max Dφ Dh + let L := max 1 L0 + have hD : 1 ≤ D := hDφ.trans (le_max_left _ _) + have hL : 1 ≤ L := le_max_left _ _ + have hDp : 0 < D := lt_of_lt_of_le zero_lt_one hD + have hLp : 0 < L := lt_of_lt_of_le zero_lt_one hL + let Cg : ℝ := (n.factorial : ℝ)*2^(2*B+n)*(D^2)^n/m^(2*B+n) + have hCg : 0 < Cg := by dsimp [Cg]; positivity + let Cp : ℝ := (n.factorial : ℝ)*D^n + have hCp : 0 < Cp := by dsimp [Cp]; positivity + refine ⟨L^k*2^n*2^n*Cp*Cg, by positivity, ?_⟩ + intro A hA g v R hR F hF + have hp : ContDiff ℝ ∞ (fun y => logPhase (v/(2*Real.pi)) (φ y)) := + (JointLogSeparation.logPhase_temperate _).1.comp hφ + have hg : ContDiff ℝ ∞ (fun y => g (R*h y)) := + (g.smooth ⊤).comp (contDiff_const.mul hh) + have hFfun : (F : Joint → ℂ) = + fun x => A x * logPhase (v/(2*Real.pi)) (φ x) * g (R*h x) := funext hF + have hFs : tsupport (F : Joint → ℂ) ⊆ K := by + rw [hFfun] + exact (tsupport_mul_subset_left.trans tsupport_mul_subset_left).trans hA + have hAn := amplitudeControl_nonneg n A + have hgn := rayControl_nonneg B n g + have hden : 0 < (1+R)^(2*B) := by positivity + apply SchwartzMap.seminorm_le_bound ℝ k n F (by positivity) + intro x + by_cases hx : x ∈ K + · have hxb : ‖x‖ ≤ L := (hL0 (mem_image_of_mem _ hx)).trans (le_max_right _ _) + have hpbd (j : ℕ) (hj : j ≤ n) : + ‖iteratedFDeriv ℝ j (fun y => logPhase (v/(2*Real.pi)) (φ y)) x‖ ≤ + Cp*(1+|v|)^n := + phase_derivative_bound hφ hD n j hj x + (fun i hi => (hbφ i hi x hx).trans (le_max_left _ _)) v + have hgbd (j : ℕ) (hj : j ≤ n) : + ‖iteratedFDeriv ℝ j (fun y => g (R*h y)) x‖ ≤ + Cg*rayControl B n g/(1+R)^(2*B) := + kernel_derivative_bound hh hD hm hm1 hR B n j hj x + (fun i hi => (hbh i hi x hx).trans (le_max_right _ _)) (hml x hx) g + have hap (j : ℕ) (hj : j ≤ n) : + ‖iteratedFDeriv ℝ j (fun y => A y * logPhase (v/(2*Real.pi)) (φ y)) x‖ ≤ + 2^n*amplitudeControl n A*(Cp*(1+|v|)^n) := by + calc + _ ≤ 2^j*amplitudeControl n A*(Cp*(1+|v|)^n) := + mul_derivative_bound j (A.smooth ⊤) hp x hAn (by positivity) + (fun i hi => amplitude_derivative_bound n i (hi.trans hj) A x) + (fun i hi => hpbd i (hi.trans hj)) + _ ≤ _ := mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (by norm_num) hj) hAn) (by positivity) + have hb := mul_derivative_bound n ((A.smooth ⊤).mul hp) hg x + (C := 2^n*amplitudeControl n A*(Cp*(1+|v|)^n)) + (D := Cg*rayControl B n g/(1+R)^(2*B)) (by positivity) (by positivity) hap hgbd + rw [hFfun] + calc + _ ≤ L^k * (2^n*(2^n*amplitudeControl n A*(Cp*(1+|v|)^n))* + (Cg*rayControl B n g/(1+R)^(2*B))) := + mul_le_mul (pow_le_pow_left₀ (norm_nonneg _) hxb _) hb (norm_nonneg _) (by positivity) + _ = _ := by ring + · have hz : iteratedFDeriv ℝ n (F : Joint → ℂ) x = 0 := by + apply Function.notMem_support.mp + intro hx' + exact hx (hFs ((support_iteratedFDeriv_subset n) hx')) + rw [hz, norm_zero, mul_zero] + positivity + +lemma amplitudeControl_mono {n N : ℕ} (hn : n ≤ N) (A : 𝓢(Joint, ℂ)) : + amplitudeControl n A ≤ amplitudeControl N A := by + exact Seminorm.le_def.mp (Finset.sup_mono (by + intro p hp + exact Finset.mem_Iic.mpr (le_trans (Finset.mem_Iic.mp hp) ⟨le_rfl, hn⟩))) A + +lemma rayControl_mono (B : ℕ) {n N : ℕ} (hn : n ≤ N) (g : 𝓢(ℝ, ℂ)) : + rayControl B n g ≤ rayControl B N g := by + exact Seminorm.le_def.mp (Finset.sup_mono (by + intro p hp + exact Finset.mem_Iic.mpr (le_trans (Finset.mem_Iic.mp hp) ⟨by omega, hn⟩))) g + +def heightOrder (H : Finset (ℕ × ℕ)) : ℕ := H.sup Prod.snd + +theorem compact_profile_finite + {K : Set Joint} (hK : IsCompact K) {φ h : Joint → ℝ} + (hφ : ContDiff ℝ ∞ φ) (hh : ContDiff ℝ ∞ h) + (hhpos : ∀ x ∈ K, 0 < h x) (B : ℕ) (H : Finset (ℕ × ℕ)) : + ∃ C : ℝ, 0 < C ∧ ∀ (A : 𝓢(Joint, ℂ)), tsupport (A : Joint → ℂ) ⊆ K → + ∀ (g : 𝓢(ℝ, ℂ)) (v R : ℝ), 0 ≤ R → + ∀ (F : 𝓢(Joint, ℂ)), + (∀ x, F x = A x * logPhase (v/(2*Real.pi)) (φ x) * g (R*h x)) → + sourceControl H F ≤ + C*amplitudeControl (heightOrder H) A*rayControl B (heightOrder H) g* + (1+|v|)^(heightOrder H)/(1+R)^(2*B) := by + have hc (p : ℕ × ℕ) := compact_profile_seminorm hK hφ hh hhpos B p.1 p.2 + choose C hC hbound using hc + let D : ℝ := 1+∑ p ∈ H, C p + have hD : 0 < D := by + have hs : 0 ≤ ∑ p ∈ H, C p := Finset.sum_nonneg (fun p _ => (hC p).le) + dsimp [D] + linarith + refine ⟨D, hD, ?_⟩ + intro A hA g v R hR F hF + have hAn := amplitudeControl_nonneg (heightOrder H) A + have hgn := rayControl_nonneg B (heightOrder H) g + apply Seminorm.finset_sup_apply_le (by positivity) + intro p hp + have hn : p.2 ≤ heightOrder H := Finset.le_sup hp + have hCD : C p ≤ D := by + have hs := Finset.single_le_sum (fun p _ => (hC p).le) hp + dsimp [D] + linarith + exact (hbound p A hA g v R hR F hF).trans (by + apply div_le_div_of_nonneg_right _ (by positivity) + apply mul_le_mul + · exact mul_le_mul + (mul_le_mul hCD (amplitudeControl_mono hn A) + (amplitudeControl_nonneg _ _) hD.le) + (rayControl_mono B hn g) (rayControl_nonneg _ _ _) (by positivity) + · exact pow_le_pow_right₀ (by linarith [abs_nonneg v]) hn + · positivity + · positivity) + +lemma sqrt_decay_absorption (T : ℝ) (hT : 0 ≤ T) (B : ℕ) : + (1+T)^B ≤ (1+Real.sqrt T)^(2*B) := by + have hbase : 1+T ≤ (1+Real.sqrt T)^2 := by + nlinarith [Real.sq_sqrt hT, Real.sqrt_nonneg T] + calc + _ ≤ ((1+Real.sqrt T)^2)^B := pow_le_pow_left₀ (by positivity) hbase B + _ = _ := by rw [pow_mul] + +theorem compact_fourier_profile_finite + {K : Set Joint} (hK : IsCompact K) {φ h : Joint → ℝ} + (hφ : ContDiff ℝ ∞ φ) (hh : ContDiff ℝ ∞ h) + (hhpos : ∀ x ∈ K, 0 < h x) (B : ℕ) (H : Finset (ℕ × ℕ)) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (A : 𝓢(Joint, ℂ)), tsupport (A : Joint → ℂ) ⊆ K → + ∀ (U : 𝓢(ℝ, ℂ)) (v T : ℝ), 0 ≤ T → + ∀ (F : 𝓢(Joint, ℂ)), + (∀ x, F x = A x * logPhase (v/(2*Real.pi)) (φ x) * + paperFourierRayCLM U (Real.sqrt T*h x)) → + sourceControl H F ≤ C*amplitudeControl (heightOrder H) A* + S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^(heightOrder H)/(1+T)^B := by + obtain ⟨D, hD, hbound⟩ := compact_profile_finite hK hφ hh hhpos B H + obtain ⟨S, E, hE, hEbound⟩ := schwartzCLM_finite_seminorm_control + paperFourierRayCLM (Finset.Iic (2*B+heightOrder H,heightOrder H)) + refine ⟨S, D*E, by positivity, ?_⟩ + intro A hA U v T hT F hF + have hAn := amplitudeControl_nonneg (heightOrder H) A + have hUn : 0 ≤ S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U := apply_nonneg _ _ + have hg := hEbound U + change rayControl B (heightOrder H) (paperFourierRayCLM U) ≤ + E*S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U at hg + calc + _ ≤ D*amplitudeControl (heightOrder H) A* + rayControl B (heightOrder H) (paperFourierRayCLM U)* + (1+|v|)^(heightOrder H)/(1+Real.sqrt T)^(2*B) := + hbound A hA (paperFourierRayCLM U) v (Real.sqrt T) (Real.sqrt_nonneg _) F hF + _ ≤ D*amplitudeControl (heightOrder H) A* + (E*S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U)* + (1+|v|)^(heightOrder H)/(1+Real.sqrt T)^(2*B) := by + gcongr + _ ≤ D*amplitudeControl (heightOrder H) A* + (E*S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U)* + (1+|v|)^(heightOrder H)/(1+T)^B := + div_le_div_of_nonneg_left (by positivity) (by positivity) (sqrt_decay_absorption T hT B) + _ = _ := by ring + +open ProbeGramJointConstruction + +theorem jointProfile_homogeneous (a b : ℝ) (ha : 0 < a) (hab : a < b) + (B : ℕ) (H : Finset (ℕ × ℕ)) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : ℝ → ℂ) (hs : Function.support W ⊆ Icc a b) (hW : ContDiff ℝ ∞ W) + (U : 𝓢(ℝ, ℂ)) (v T : ℝ) (hT : 0 ≤ T), + sourceControl H (jointProfile W U a b ha hab hs hW v T hT) ≤ + C*amplitudeControl (heightOrder H) (amplitudeSchwartz W a b ha hab hs hW)* + S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U* + (1+|v|)^(heightOrder H)/(1+T)^B := by + obtain ⟨S, C, hC, hb⟩ := compact_fourier_profile_finite + (sourceCompact_isCompact b) (phase_smooth a b ha) (rootScale_smooth a b ha) + (fun z _ => rootScale_pos a b ha z) B H + refine ⟨S, C, hC, ?_⟩ + intro W hs hW U v T hT + exact hb (amplitudeSchwartz W a b ha hab hs hW) + (tsupport_amplitude_subset W a b ha hab hs) U v T hT + (jointProfile W U a b ha hab hs hW v T hT) + (jointProfile_factorization W U a b ha hab hs hW v T hT) + +theorem jointProfile_uniform_degree (a b : ℝ) (ha : 0 < a) (hab : a < b) + (B : ℕ) (H : Finset (ℕ × ℕ)) : + ∃ (J : ℕ) (S : Finset (ℕ × ℕ)), + ∀ (W : ℝ → ℂ) (hs : Function.support W ⊆ Icc a b) (hW : ContDiff ℝ ∞ W), + ∃ C : ℝ, 0 < C ∧ ∀ (U : 𝓢(ℝ, ℂ)) (v T : ℝ) (hT : 0 ≤ T), + sourceControl H (jointProfile W U a b ha hab hs hW v T hT) ≤ + C*S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J/(1+T)^B := by + obtain ⟨S, C, hC, hb⟩ := jointProfile_homogeneous a b ha hab B H + refine ⟨heightOrder H, S, ?_⟩ + intro W hs hW + let A := amplitudeControl (heightOrder H) (amplitudeSchwartz W a b ha hab hs hW) + have hA : 0 ≤ A := amplitudeControl_nonneg _ _ + refine ⟨C*(1+A), by positivity, ?_⟩ + intro U v T hT + have hU : 0 ≤ S.sup (schwartzSeminormFamily ℝ ℝ ℂ) U := apply_nonneg _ _ + exact (hb W hs hW U v T hT).trans (by + apply div_le_div_of_nonneg_right _ (by positivity) + apply mul_le_mul_of_nonneg_right _ (by positivity) + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left (by dsimp [A]; linarith : + amplitudeControl (heightOrder H) (amplitudeSchwartz W a b ha hab hs hW) ≤ 1+A) hC.le) hU) + +end ProbeGramJointProfile + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramJointSource.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..de6dcab432aaa1f20932f5ac8a512e1e45d4d8e7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramJointSource.lean @@ -0,0 +1,49 @@ +import OAI.NumberTheory.DirichletL.Detector.GramJoint + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open CenteredMomentSupportedCorrelation CenteredMomentCorrelation +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +theorem jointExtension_source (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (hC : Supported (Ideal.span {C})) + (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (hpr : λ₀^2∣r-1) (hk : k=u.val*λ₀^a*(2:O)^b*r) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) + (hc : ∀i,1≤c i) (hcop : Pairwise (Function.onFun IsCoprime P)) + (he : Ideal.span {C}=∏i,P i^c i) + [Fintype (O⧸∏i,P i^c i)] [∀i,Fintype (O⧸P i^c i)] + (n₁ n₂ : O) (h₁ : Supported (Ideal.span {n₁})) (h₂ : Supported (Ideal.span {n₂})) + (hp₁ : λ₀^2∣n₁-1) (hp₂ : λ₀^2∣n₂-1) (hn : IsCoprime n₁ n₂) : + jointExtension S hS σ C k u a b r hr P hg c n₁ n₂= + primaryCoefficient S hS σ (C*n₁)*star (primaryCoefficient S hS σ (C*n₂))* + actualCorrelation (C*n₁) (C*n₂) (supported_mul_elements C n₁ hC h₁) + (supported_mul_elements C n₂ hC h₂) (C*k) := by + rw [actual_common_lift C n₁ n₂ k hC h₁ h₂ hp₁ hp₂ hn, + actualCommon_eq_globalExtension C hC P hg c hc hcop he n₁ n₂ k hn, + ←numeratorExtension_primary u a b r k n₁ hr hpr hk h₁ hp₁, + ←numeratorExtension_neg_primary u a b r k n₂ hr hpr hk h₂ hp₂] + simp only [jointExtension,jointFixed,numeratorExtension,MonoidHom.mul_apply, + movingNumeratorRow,MonoidHom.coe_mk,OneHom.coe_mk,star_mul] + ring + +lemma lowGramCoefficient_eq_primary (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (s : {I : Id // Supported I}) : + lowGramCoefficient (calibrationForSet S hS) σ s= + primaryCoefficient S hS σ (primaryGenerator s.val) := by + have hp : λ₀^2∣primaryGenerator s.val-1 := (primaryGenerator_spec s.val + (supported_primaryGenerator_ne_zero s.val s.property)).2 + rw [primaryCoefficient,ite_eq_left hp] + exact lowGramCoefficient_eq_extension S hS hbad σ s + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeDecay.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeDecay.lean new file mode 100644 index 0000000000000000000000000000000000000000..68fb4364f38487198894b92b1f346485e29150df --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeDecay.lean @@ -0,0 +1,300 @@ +import OAI.NumberTheory.DirichletL.Foundation + +namespace OAI + +noncomputable section +open scoped BigOperators Classical FourierTransform SchwartzMap RealInnerProductSpace + +namespace ProbeGramLatticeDecay +open ActualEisensteinCubic ConcreteTraceCRT EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +abbrev Joint := WithLp 2 (ℂ × ℂ) + +def point (x y : ℂ) : Joint := WithLp.toLp 2 (x,y) + +def sourceControl (S : Finset (ℕ × ℕ)) (W : 𝓢(Joint, ℂ)) : ℝ := + S.sup (schwartzSeminormFamily ℝ Joint ℂ) W + +theorem sourceControl_nonneg (S : Finset (ℕ × ℕ)) (W : 𝓢(Joint, ℂ)) : + 0 ≤ sourceControl S W := apply_nonneg _ _ + +@[simp] theorem norm_point_sq (x y : ℂ) : + ‖point x y‖^2 = ‖x‖^2 + ‖y‖^2 := WithLp.prod_norm_sq_eq_of_L2 _ + +theorem product_decay (W : 𝓢(Joint, ℂ)) (x y : ℂ) : + ((1+‖x‖^2)^2 * (1+‖y‖^2)^2) * ‖W (point x y)‖ ≤ + (2:ℝ)^8 * sourceControl (Finset.Iic (8,0)) W := by + have hx := WithLp.norm_fst_le ℂ (point x y) + have hy := WithLp.norm_snd_le ℂ (point x y) + change ‖x‖ ≤ ‖point x y‖ at hx + change ‖y‖ ≤ ‖point x y‖ at hy + have hx2 : 1+‖x‖^2 ≤ (1+‖point x y‖)^2 := by nlinarith [norm_nonneg (point x y), norm_nonneg x, norm_nonneg y] + have hy2 : 1+‖y‖^2 ≤ (1+‖point x y‖)^2 := by nlinarith [norm_nonneg (point x y), norm_nonneg x, norm_nonneg y] + have hpow : (1+‖x‖^2)^2 * (1+‖y‖^2)^2 ≤ (1+‖point x y‖)^8 := by + calc + _ ≤ ((1+‖point x y‖)^2)^2 * ((1+‖point x y‖)^2)^2 := by gcongr + _ = _ := by ring + have h := SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) + (m := (8,0)) (k := 8) (n := 0) le_rfl le_rfl W (point x y) + simp only [norm_iteratedFDeriv_zero] at h + exact (mul_le_mul_of_nonneg_right hpow (norm_nonneg _)).trans h + +def physicalPoint (N : ℝ) (m : O × O) : Joint := + point (eisEmbedding m.1 / (Real.sqrt N : ℂ)) + (eisEmbedding m.2 / (Real.sqrt N : ℂ)) + +theorem physicalPoint_eq_smul (N : ℝ) (m : O × O) : + physicalPoint N m = (Real.sqrt N)⁻¹ • point (eisEmbedding m.1) (eisEmbedding m.2) := by + apply WithLp.ofLp_injective + simp [physicalPoint, point, div_eq_mul_inv, Algebra.smul_def, mul_comm] + +theorem physical_summable (W : 𝓢(Joint, ℂ)) (N : ℝ) (hN : 0 < N) : + Summable (fun m : O × O => ‖W (physicalPoint N m)‖) := by + let g : O → ℝ := fun m => ((1+N⁻¹*‖eisEmbedding m‖^2)^2)⁻¹ + have hg : Summable g := scaled_eisenstein_cauchy_summable _ (inv_pos.mpr hN) + have hp := hg.mul_of_nonneg hg (fun _ => by dsimp [g]; positivity) + (fun _ => by dsimp [g]; positivity) + apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ (hp.mul_left ((2:ℝ)^8 * sourceControl (Finset.Iic (8,0)) W)) + intro m + have hb := product_decay W (eisEmbedding m.1 / (Real.sqrt N : ℂ)) + (eisEmbedding m.2 / (Real.sqrt N : ℂ)) + have hnorm (m : O) : ‖eisEmbedding m / (Real.sqrt N : ℂ)‖^2 = N⁻¹*‖eisEmbedding m‖^2 := by + rw [norm_div, div_pow, Complex.norm_real, Real.norm_eq_abs, sq_abs, Real.sq_sqrt hN.le] + ring + simp only [hnorm] at hb + change ‖W (physicalPoint N m)‖ ≤ ((2:ℝ)^8 * sourceControl (Finset.Iic (8,0)) W) * (g m.1*g m.2) + dsimp only [g] + rw [ ← mul_inv, ← div_eq_mul_inv, le_div_iff₀ (by positivity)] + simpa only [physicalPoint, mul_comm] using hb + +theorem physical_lattice_bound : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)) (N : ℝ), 1 ≤ N → + (∑' m : O × O, ‖W (physicalPoint N m)‖) ≤ C * sourceControl S W * N^2 := by + refine ⟨Finset.Iic (8,0), (2:ℝ)^8 * (4*(1+Real.pi)^2)^2, by positivity, ?_⟩ + intro W N hN + have hNp : 0 < N := lt_of_lt_of_le zero_lt_one hN + let g : O → ℝ := fun m => ((1+N⁻¹*‖eisEmbedding m‖^2)^2)⁻¹ + have hg : Summable g := scaled_eisenstein_cauchy_summable _ (inv_pos.mpr hNp) + have hp := hg.mul_of_nonneg hg (fun _ => by dsimp [g]; positivity) + (fun _ => by dsimp [g]; positivity) + have hpoint (m : O × O) : ‖W (physicalPoint N m)‖ ≤ + ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W) * (g m.1*g m.2) := by + have hb := product_decay W (eisEmbedding m.1 / (Real.sqrt N : ℂ)) + (eisEmbedding m.2 / (Real.sqrt N : ℂ)) + have hn (m : O) : ‖eisEmbedding m / (Real.sqrt N : ℂ)‖^2 = N⁻¹*‖eisEmbedding m‖^2 := by + rw [norm_div, div_pow, Complex.norm_real, Real.norm_eq_abs, sq_abs, Real.sq_sqrt hNp.le] + ring + simp only [hn] at hb + dsimp only [g] + rw [ ← mul_inv, ← div_eq_mul_inv, le_div_iff₀ (by positivity)] + simpa only [physicalPoint, mul_comm] using hb + have hmass : (∑' m : O, g m) ≤ (4*(1+Real.pi)^2)*N := by + have h := scaled_eisenstein_cauchy_small N⁻¹ (inv_pos.mpr hNp) ((inv_le_one₀ hNp).mpr hN) + have hh := mul_le_mul_of_nonneg_left h hNp.le + simpa only [g, ← mul_assoc, mul_inv_cancel₀ hNp.ne', one_mul, mul_comm] using hh + calc + _ ≤ ∑' m : O × O, ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W)*(g m.1*g m.2) := + (physical_summable W N hNp).tsum_le_tsum hpoint (hp.mul_left _) + _ = ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W)*(∑' m : O, g m)^2 := by + rw [tsum_mul_left, ← hg.tsum_mul_tsum hg hp, pow_two] + _ ≤ ((2:ℝ)^8*sourceControl (Finset.Iic (8,0)) W)*((4*(1+Real.pi)^2)*N)^2 := by + apply mul_le_mul_of_nonneg_left _ (mul_nonneg (by positivity) (sourceControl_nonneg _ _)) + exact pow_le_pow_left₀ (tsum_nonneg (fun _ => by dsimp [g]; positivity)) hmass 2 + _ = _ := by ring + +abbrev DualIndex := (ℤ × ℤ) × (ℤ × ℤ) + +def dualPoint (p : DualIndex) : Joint := + point (explicitDualFrequency 1 p.1) (explicitDualFrequency 1 p.2) + +def dualRow (p : DualIndex) : Fin 2 → O := + ![dualFrequencyEquiv p.1, dualFrequencyEquiv p.2] + +def dualCoordinates (p : DualIndex) : (Fin 2 × Fin 2) → ℤ := + CubicEisenstein.rowCoordinates (dualRow p) + +theorem dualCoordinates_injective : Function.Injective dualCoordinates := by + intro p q hp + have h := CubicEisenstein.rowCoordinates_injective hp + apply Prod.ext + · exact dualFrequencyEquiv.injective (congrFun h 0) + · exact dualFrequencyEquiv.injective (congrFun h 1) + +@[simp] theorem dualCoordinates_zero : dualCoordinates 0 = 0 := by + have hzero : ActualEisensteinCoordinates.coords (0 : O) = (0,0) := by + simpa [ActualEisensteinCoordinates.eval] using ShortDraftLatticeCount.coords_eval 0 0 + ext ⟨i,j⟩ + fin_cases i <;> fin_cases j <;> + simp [dualCoordinates, CubicEisenstein.rowCoordinates, dualRow, + dualFrequencyEquiv, ActualEisensteinCoordinates.eval, hzero] + +theorem dualCoordinates_norm_le (p : DualIndex) : + ‖dualCoordinates p‖ ≤ 2 * ‖dualPoint p‖ := by + have hc := CubicEisenstein.coordinates_norm_bound (dualRow p) + have hp : ‖fun i => eisEmbedding (dualRow p i)‖ ≤ ‖dualPoint p‖ := by + apply (pi_norm_le_iff_of_nonneg (norm_nonneg _)).mpr + intro i + have h1 := explicitDualFrequency_norm_sq 1 p.1 + have h2 := explicitDualFrequency_norm_sq 1 p.2 + norm_num only [norm_one, one_pow, div_one] at h1 h2 + have hq := norm_point_sq (explicitDualFrequency 1 p.1) (explicitDualFrequency 1 p.2) + fin_cases i + · change ‖eisEmbedding (dualFrequencyEquiv p.1)‖ ≤ ‖dualPoint p‖ + dsimp only [dualPoint] + nlinarith [sq_nonneg ‖eisEmbedding (dualFrequencyEquiv p.2)‖, + norm_nonneg (point (explicitDualFrequency 1 p.1) (explicitDualFrequency 1 p.2)), + norm_nonneg (eisEmbedding (dualFrequencyEquiv p.1))] + · change ‖eisEmbedding (dualFrequencyEquiv p.2)‖ ≤ ‖dualPoint p‖ + dsimp only [dualPoint] + nlinarith [sq_nonneg ‖eisEmbedding (dualFrequencyEquiv p.1)‖, + norm_nonneg (point (explicitDualFrequency 1 p.1) (explicitDualFrequency 1 p.2)), + norm_nonneg (eisEmbedding (dualFrequencyEquiv p.2))] + exact hc.trans (mul_le_mul_of_nonneg_left hp (by norm_num)) + +theorem dualPoint_norm_pos (p : DualIndex) (hp : p ≠ 0) : 0 < ‖dualPoint p‖ := by + have hc : dualCoordinates p ≠ 0 := by + intro h + exact hp (dualCoordinates_injective (h.trans dualCoordinates_zero.symm)) + have hh := norm_pos_iff.mpr hc + have hb := dualCoordinates_norm_le p + linarith + +theorem dual_power_summable (k : ℝ) (hk : 4 < k) : + Summable (fun p : {p : DualIndex // p ≠ 0} => ‖dualPoint p.val‖ ^ (-k)) := by + have hs : Summable (fun p : {p : DualIndex // p ≠ 0} => ‖dualCoordinates p.val‖ ^ (-k)) := + (CubicEisenstein.summable_integer_four_rpow k hk).comp_injective + (dualCoordinates_injective.comp (Subtype.val_injective)) + apply Summable.of_nonneg_of_le (fun _ => Real.rpow_nonneg (norm_nonneg _) _) _ + (hs.mul_left ((2:ℝ)^k)) + intro p + have hc : 0 < ‖dualCoordinates p.val‖ := norm_pos_iff.mpr (by + intro h + exact p.property (dualCoordinates_injective (h.trans dualCoordinates_zero.symm))) + have h := Real.rpow_le_rpow_of_nonpos (half_pos hc) + (by have := dualCoordinates_norm_le p.val; linarith : ‖dualCoordinates p.val‖ / 2 ≤ ‖dualPoint p.val‖) + (by linarith : -k ≤ 0) + calc + _ ≤ (‖dualCoordinates p.val‖ / 2) ^ (-k) := h + _ = (2:ℝ)^k * ‖dualCoordinates p.val‖ ^ (-k) := by + rw [Real.div_rpow (norm_nonneg _) (by norm_num), Real.rpow_neg (by norm_num : (0:ℝ) ≤ 2)] + simp only [div_inv_eq_mul, mul_comm] + +def scaledDualPoint (L : ℝ) (u : ℂ) (p : DualIndex) : Joint := + point (u*(L:ℂ)*explicitDualFrequency 1 p.1) + (u*(L:ℂ)*explicitDualFrequency 1 p.2) + +theorem norm_scaledDualPoint (L : ℝ) (hL : 0 ≤ L) (u : ℂ) (hu : ‖u‖ = 1) + (p : DualIndex) : ‖scaledDualPoint L u p‖ = L * ‖dualPoint p‖ := by + have h1 := norm_point_sq (u*(L:ℂ)*explicitDualFrequency 1 p.1) + (u*(L:ℂ)*explicitDualFrequency 1 p.2) + have h2 := norm_point_sq (explicitDualFrequency 1 p.1) (explicitDualFrequency 1 p.2) + simp only [norm_mul, hu, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg hL, + one_mul] at h1 + apply (sq_eq_sq₀ (norm_nonneg _) (mul_nonneg hL (norm_nonneg _))).mp + change ‖point (u*(L:ℂ)*explicitDualFrequency 1 p.1) + (u*(L:ℂ)*explicitDualFrequency 1 p.2)‖^2 = + (L*‖point (explicitDualFrequency 1 p.1) (explicitDualFrequency 1 p.2)‖)^2 + simp only [h1, mul_pow, h2] + ring + +theorem fourier_seminorm_control (k : ℕ) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ ∀ W : 𝓢(Joint, ℂ), + SchwartzMap.seminorm ℝ k 0 (𝓕 W) ≤ C * sourceControl S W := by + let T : 𝓢(Joint, ℂ) →L[ℝ] 𝓢(Joint, ℂ) := SchwartzMap.fourierTransformCLM ℝ + let q : Seminorm ℝ 𝓢(Joint, ℂ) := (SchwartzMap.seminorm ℝ k 0).comp T.toLinearMap + have hq : Continuous q := + ((schwartz_withSeminorms ℝ Joint ℂ).continuous_seminorm (k,0)).comp T.continuous + obtain ⟨S,C,hC,hbound⟩ := + Seminorm.bound_of_continuous (schwartz_withSeminorms ℝ Joint ℂ) q hq + refine ⟨S,C,?_,?_⟩ + · exact_mod_cast (pos_iff_ne_zero.mpr hC : 0 < C) + · intro W + exact Seminorm.le_def.mp hbound W + +theorem scaledDual_decay (F : 𝓢(Joint, ℂ)) (k : ℕ) (L : ℝ) (hL : 0 < L) + (u : ℂ) (hu : ‖u‖ = 1) (p : DualIndex) (hp : p ≠ 0) : + ‖F (scaledDualPoint L u p)‖ ≤ SchwartzMap.seminorm ℝ k 0 F * + L^(-(k:ℝ)) * ‖dualPoint p‖^(-(k:ℝ)) := by + have hn : 0 < ‖scaledDualPoint L u p‖ := by + rw [norm_scaledDualPoint L hL.le u hu] + exact mul_pos hL (dualPoint_norm_pos p hp) + have hb := SchwartzMap.norm_pow_mul_le_seminorm ℝ F k (scaledDualPoint L u p) + have hh : ‖F (scaledDualPoint L u p)‖ ≤ + SchwartzMap.seminorm ℝ k 0 F * ‖scaledDualPoint L u p‖^(-(k:ℝ)) := by + rw [Real.rpow_neg hn.le, Real.rpow_natCast, ← div_eq_mul_inv, + le_div_iff₀ (pow_pos hn k)] + simpa only [mul_comm] using hb + rw [norm_scaledDualPoint L hL.le u hu, + Real.mul_rpow hL.le (norm_nonneg _)] at hh + simpa only [mul_assoc] using hh + +theorem dual_fourier_summable (A : ℕ) (hA : 2 < A) + (W : 𝓢(Joint, ℂ)) (L : ℝ) (hL : 0 < L) (u : ℂ) (hu : ‖u‖ = 1) : + Summable (fun p : {p : DualIndex // p ≠ 0} => ‖(𝓕 W) (scaledDualPoint L u p.val)‖) := by + have hdim : (4:ℝ) < ((2*A:ℕ):ℝ) := by exact_mod_cast (by omega : 4 < 2*A) + apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ + ((dual_power_summable ((2*A:ℕ):ℝ) hdim).mul_left + (SchwartzMap.seminorm ℝ (2*A) 0 (𝓕 W) * L^(-((2*A:ℕ):ℝ)))) + intro p + exact scaledDual_decay (𝓕 W) (2*A) L hL u hu p.val p.property + +theorem dual_fourier_lattice_bound (A : ℕ) (hA : 2 < A) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)) (L : ℝ), 1 ≤ L → ∀ (u : ℂ), ‖u‖ = 1 → + (∑' p : {p : DualIndex // p ≠ 0}, ‖(𝓕 W) (scaledDualPoint L u p.val)‖) ≤ + C * sourceControl S W * L^(-((2*A:ℕ):ℝ)) := by + obtain ⟨S,C,hC,hbound⟩ := fourier_seminorm_control (2*A) + let mass : ℝ := ∑' p : {p : DualIndex // p ≠ 0}, ‖dualPoint p.val‖^(-((2*A:ℕ):ℝ)) + have hm : 0 ≤ mass := tsum_nonneg (fun _ => Real.rpow_nonneg (norm_nonneg _) _) + refine ⟨S,C*(mass+1),mul_pos hC (by positivity),?_⟩ + intro W L hL u hu + have hLp : 0 < L := lt_of_lt_of_le zero_lt_one hL + have hdim : (4:ℝ) < ((2*A:ℕ):ℝ) := by exact_mod_cast (by omega : 4 < 2*A) + calc + _ ≤ ∑' p : {p : DualIndex // p ≠ 0}, + (SchwartzMap.seminorm ℝ (2*A) 0 (𝓕 W) * L^(-((2*A:ℕ):ℝ))) * + ‖dualPoint p.val‖^(-((2*A:ℕ):ℝ)) := + (dual_fourier_summable A hA W L hLp u hu).tsum_le_tsum + (fun p => scaledDual_decay (𝓕 W) (2*A) L hLp u hu p.val p.property) + ((dual_power_summable ((2*A:ℕ):ℝ) hdim).mul_left _) + _ = SchwartzMap.seminorm ℝ (2*A) 0 (𝓕 W) * L^(-((2*A:ℕ):ℝ)) * mass := tsum_mul_left + _ ≤ (C * sourceControl S W) * L^(-((2*A:ℕ):ℝ)) * (mass+1) := by + apply mul_le_mul + · exact mul_le_mul_of_nonneg_right (hbound W) (Real.rpow_nonneg hLp.le _) + · linarith + · exact hm + · exact mul_nonneg (mul_nonneg hC.le (sourceControl_nonneg S W)) (Real.rpow_nonneg hLp.le _) + _ = _ := by ring + +theorem sourceControl_mono {S T : Finset (ℕ × ℕ)} (hST : S ⊆ T) + (W : 𝓢(Joint, ℂ)) : sourceControl S W ≤ sourceControl T W := + Seminorm.le_def.mp (Finset.sup_mono hST) W + +theorem joint_lattice_bounds (A : ℕ) (hA : 2 < A) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + (∀ (W : 𝓢(Joint, ℂ)) (N : ℝ), 1 ≤ N → + (∑' m : O × O, ‖W (physicalPoint N m)‖) ≤ C * sourceControl S W * N^2) ∧ + (∀ (W : 𝓢(Joint, ℂ)) (L : ℝ), 1 ≤ L → ∀ (u : ℂ), ‖u‖ = 1 → + (∑' p : {p : DualIndex // p ≠ 0}, ‖(𝓕 W) (scaledDualPoint L u p.val)‖) ≤ + C * sourceControl S W * L^(-((2*A:ℕ):ℝ))) := by + obtain ⟨S₁,C₁,hC₁,h₁⟩ := physical_lattice_bound + obtain ⟨S₂,C₂,hC₂,h₂⟩ := dual_fourier_lattice_bound A hA + refine ⟨S₁∪S₂,C₁+C₂,add_pos hC₁ hC₂,?_,?_⟩ + · intro W N hN + apply (h₁ W N hN).trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + exact mul_le_mul (le_add_of_nonneg_right hC₂.le) + (sourceControl_mono Finset.subset_union_left W) (sourceControl_nonneg _ _) (by positivity) + · intro W L hL u hu + apply (h₂ W L hL u hu).trans + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg (by linarith) _) + exact mul_le_mul (le_add_of_nonneg_left hC₁.le) + (sourceControl_mono Finset.subset_union_right W) (sourceControl_nonneg _ _) (by positivity) + +end ProbeGramLatticeDecay + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeSource.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..aab2ff7a7f68cc045d83dec0e7c04bd7c1b2fff6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeSource.lean @@ -0,0 +1,57 @@ +import OAI.NumberTheory.DirichletL.Detector.GramPrimaryLattice + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +lemma jointExtension_zero_off_primary_left (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (C k d : O) + (hCd : λ₀^2∣C*d-1) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) + (n m : O) (hn : ¬(Supported (Ideal.span {n}) ∧ λ₀^2∣n-1)) : + jointExtension S hS σ C k u a b r hr P hg c (d*n) (d*m)=0 := by + have hz : primaryCoefficient S hS σ (C*(d*n))=0 := by + by_contra h + apply hn + apply primaryCoefficient_residual S hS hbad σ (C*d) n hCd + simpa only [mul_assoc] using h + simp only [jointExtension,jointFixed,hz,zero_mul] + +lemma jointExtension_zero_off_primary_right (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (C k d : O) + (hCd : λ₀^2∣C*d-1) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) + (n m : O) (hm : ¬(Supported (Ideal.span {m}) ∧ λ₀^2∣m-1)) : + jointExtension S hS σ C k u a b r hr P hg c (d*n) (d*m)=0 := by + have hz : primaryCoefficient S hS σ (C*(d*m))=0 := by + by_contra h + apply hm + apply primaryCoefficient_residual S hS hbad σ (C*d) m hCd + simpa only [mul_assoc] using h + simp only [jointExtension,jointFixed,hz,star_zero,mul_zero,zero_mul] + +theorem jointExtension_ideal_lattice (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (C k d : O) + (hCd : λ₀^2∣C*d-1) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) (W : O→O→ℂ) : + (∑'I : SupportedIdeal,∑'J : SupportedIdeal, + jointExtension S hS σ C k u a b r hr P hg c (d*primaryGenerator I.val) (d*primaryGenerator J.val)* + W (primaryGenerator I.val) (primaryGenerator J.val))= + ∑'n : O,∑'m : O,jointExtension S hS σ C k u a b r hr P hg c (d*n) (d*m)*W n m := by + apply primary_ideal_pair_tsum (fun n m=>jointExtension S hS σ C k u a b r hr P hg c (d*n) (d*m)*W n m) + · intro n m hn + rw [jointExtension_zero_off_primary_left S hS hbad σ C k d hCd u a b r hr P hg c n m hn,zero_mul] + · intro n m hm + rw [jointExtension_zero_off_primary_right S hS hbad σ C k d hCd u a b r hr P hg c n m hm,zero_mul] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeWindow.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeWindow.lean new file mode 100644 index 0000000000000000000000000000000000000000..d7283b368b7ff832a0e8a4b9c286bbe5b37d06e3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramLatticeWindow.lean @@ -0,0 +1,66 @@ +import OAI.NumberTheory.DirichletL.Detector.GramShell +import OAI.NumberTheory.DirichletL.Detector.GramAnnularCount + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +def shellLatticeColumns (W : ℝ→ℂ) (hW : HasCompactSupport W) (N : ℝ) (hN : 0f m.1 m.2*shellProfile W v U T (‖eisEmbedding m.1‖^2/N) (‖eisEmbedding m.2‖^2/N)) := by + apply summable_of_ne_finset_zero (s:=(shellLatticeColumns W hW N hN)×ˢ(shellLatticeColumns W hW N hN)) + intro m hm + have h : m.1∉shellLatticeColumns W hW N hN ∨ m.2∉shellLatticeColumns W hW N hN := by simpa only [Finset.mem_product,not_and_or] using hm + rw [shell_lattice_support W hW N hN U v T m.1 m.2 h,mul_zero] + +lemma shell_lattice_tsum (W : ℝ→ℂ) (hW : HasCompactSupport W) (N : ℝ) (hN : 0 ActualEisensteinCubic.O + +lemma finiteField_local_norm {F : Type*} [Field F] [Fintype F] + (χ : MulChar F ℂ) (u v k : F) (huv : u≠0 ∨ v≠0) : + ‖localCorrelation χ u v k‖≤(Fintype.card F:ℝ) := by + rcases huv with hu|hv + · exact fullCorrelation_bezout_norm u v u⁻¹ 0 k (by simp [hu]) χ χ + (FiniteRayExpansion.norm_char_le_one χ) (FiniteRayExpansion.norm_char_le_one χ) + · exact fullCorrelation_bezout_norm u v 0 v⁻¹ k (by simp [hv]) χ χ + (FiniteRayExpansion.norm_char_le_one χ) (FiniteRayExpansion.norm_char_le_one χ) + +def localExtension (P : Ideal O) [P.IsMaximal] (hg : goodLambda∉P) + (c : ℕ) (n₁ n₂ k : O) : ℂ := by + letI : Fintype (O⧸P) := Fintype.ofFinite _ + letI : Field (O⧸P) := Ideal.Quotient.field P + exact if n₁∈P ∧ n₂∈P then 0 else (Ideal.absNorm P:ℂ)^(c-1)* + localCorrelation (actualSextic P hg^c) (Ideal.Quotient.mk P n₁) + (Ideal.Quotient.mk P n₂) (Ideal.Quotient.mk P k) + +lemma localExtension_both_zero (P : Ideal O) [P.IsMaximal] (hg : goodLambda∉P) + (c : ℕ) (n₁ n₂ k : O) (h₁ : n₁∈P) (h₂ : n₂∈P) : + localExtension P hg c n₁ n₂ k=0 := by simp [localExtension,h₁,h₂] + +theorem localExtension_periodic (P : Ideal O) [P.IsMaximal] (hg : goodLambda∉P) + (c : ℕ) (n₁ n₂ m₁ m₂ k l : O) + (h₁ : n₁-m₁∈P) (h₂ : n₂-m₂∈P) (hk : k-l∈P) : + localExtension P hg c n₁ n₂ k=localExtension P hg c m₁ m₂ l := by + have he₁ := Ideal.Quotient.eq.mpr h₁ + have he₂ := Ideal.Quotient.eq.mpr h₂ + have hek := Ideal.Quotient.eq.mpr hk + have hm₁ : n₁∈P↔m₁∈P := by + rw [←Ideal.Quotient.eq_zero_iff_mem,he₁,Ideal.Quotient.eq_zero_iff_mem] + have hm₂ : n₂∈P↔m₂∈P := by + rw [←Ideal.Quotient.eq_zero_iff_mem,he₂,Ideal.Quotient.eq_zero_iff_mem] + simp only [localExtension,hm₁,hm₂,he₁,he₂,hek] + +theorem localExtension_norm (P : Ideal O) [P.IsMaximal] (hg : goodLambda∉P) + (c : ℕ) (hc : 1≤c) (n₁ n₂ k : O) : + ‖localExtension P hg c n₁ n₂ k‖≤(Ideal.absNorm P:ℝ)^c := by + let : Fintype (O⧸P) := Fintype.ofFinite _ + let : Field (O⧸P) := Ideal.Quotient.field P + unfold localExtension + split_ifs with hn + · simp only [norm_zero] + positivity + have huv : Ideal.Quotient.mk P n₁≠0 ∨ Ideal.Quotient.mk P n₂≠0 := by + by_contra hh + push Not at hh + exact hn ⟨Ideal.Quotient.eq_zero_iff_mem.mp hh.1,Ideal.Quotient.eq_zero_iff_mem.mp hh.2⟩ + have hh := finiteField_local_norm (actualSextic P hg^c) (Ideal.Quotient.mk P n₁) + (Ideal.Quotient.mk P n₂) (Ideal.Quotient.mk P k) huv + rw [norm_mul,norm_pow,Complex.norm_natCast] + calc + _ ≤ (Ideal.absNorm P:ℝ)^(c-1)*(Ideal.absNorm P:ℝ) := by + apply mul_le_mul_of_nonneg_left _ (by positivity) + simpa only [Ideal.absNorm_apply,Submodule.cardQuot_apply,Nat.card_eq_fintype_card] using hh + _ = _ := by rw [←pow_succ,Nat.sub_add_cancel hc] + +theorem primePower_common_extension (P : Ideal O) [P.IsMaximal] (hg : goodLambda∉P) + (c : ℕ) (hc : 1≤c) [Fintype (O⧸P^c)] (n₁ n₂ k : O) + (hn : n₁∉P ∨ n₂∉P) : + fullCorrelation (fun x : O⧸P^c=>Ideal.Quotient.mk _ n₂*x) + (fun y : O⧸P^c=>Ideal.Quotient.mk _ n₁*y) + (primePowerRow P hg hc) (primePowerRow P hg hc) (Ideal.Quotient.mk _ k)= + localExtension P hg c n₁ n₂ k := by + let : Fintype (O⧸P) := Fintype.ofFinite _ + let : Field (O⧸P) := Ideal.Quotient.field P + have hn' : ¬(n₁∈P ∧ n₂∈P) := by tauto + rw [localExtension,ite_eq_right hn'] + rcases hn with h₁|h₂ + · have hu : IsUnit (Ideal.Quotient.mk (P^c) n₁) := + (Ideal.Quotient.isUnit_mk_pow_iff_isUnit_mk P (by omega)).mpr + (isUnit_iff_ne_zero.mpr (fun hz=>h₁ (Ideal.Quotient.eq_zero_iff_mem.mp hz))) + obtain ⟨u,hu⟩ := hu + rw [←hu] + unfold primePowerRow + rw [primePower_localCorrelation] + simp only [primePowerReduction,Ideal.Quotient.factor_mk,hu] + · have hv : IsUnit (Ideal.Quotient.mk (P^c) n₂) := + (Ideal.Quotient.isUnit_mk_pow_iff_isUnit_mk P (by omega)).mpr + (isUnit_iff_ne_zero.mpr (fun hz=>h₂ (Ideal.Quotient.eq_zero_iff_mem.mp hz))) + obtain ⟨v,hv⟩ := hv + rw [←hv] + unfold primePowerRow + rw [fullCorrelation_reduction_unit_left _ (primePowerReduction_surjective P hc), + primePowerReduction_multiplicity,Nat.cast_pow] + change (Ideal.absNorm P:ℂ)^(c-1)*localCorrelation (actualSextic P hg^c) + (primePowerReduction P hc (Ideal.Quotient.mk _ n₁)) (primePowerReduction P hc v) + (primePowerReduction P hc (Ideal.Quotient.mk _ k))=_ + simp only [hv,primePowerReduction,Ideal.Quotient.factor_mk] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramMean.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramMean.lean new file mode 100644 index 0000000000000000000000000000000000000000..62519287531e884205f01a4e0caf4db56e1cc94d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramMean.lean @@ -0,0 +1,58 @@ +import OAI.NumberTheory.DirichletL.Detector.GramGlobalExtension + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ActualEisensteinCubic CompletedGauss ConcreteTraceCRT ConcretePrimeRowBridge +open CenteredMomentCorrelation CenteredMomentCanonical +local notation "O" => ActualEisensteinCubic.O + +lemma actualSextic_power_nonprincipal (P : Ideal O) [P.IsMaximal] + (hg : goodLambda∉P) (hchar : ringChar (O⧸P)≠2) (e : ℕ) (he : ¬6∣e) : + actualSextic P hg^e≠1 := by + intro h + have hd := (orderOf_dvd_iff_pow_eq_one).mpr h + rw [actualSextic_order_six P hg hchar] at hd + exact he hd + +theorem primePower_mean_zero (P : Ideal O) [P.IsMaximal] + (hg : goodLambda∉P) (hchar : ringChar (O⧸P)≠2) + (c e : ℕ) (hc : 1≤c) (he : ¬6∣e) [Fintype (O⧸P^c)] (d : O) : + (∑x : O⧸P^c,(actualSextic P hg^e) + (Ideal.Quotient.mk P d*primePowerReduction P hc x))=0 := by + let : Fintype (O⧸P) := Fintype.ofFinite _ + simp_rw [map_mul] + rw [←Finset.mul_sum,sum_reduction _ (primePowerReduction_surjective P hc), + MulChar.sum_eq_zero_of_ne_one (actualSextic_power_nonprincipal P hg hchar e he),mul_zero,mul_zero] + +theorem crt_joint_mean_zero (Q P : Ideal O) [P.IsMaximal] + (hg : goodLambda∉P) (hchar : ringChar (O⧸P)≠2) + (c e : ℕ) (hc : 1≤c) (he : ¬6∣e) (hcop : IsCoprime Q (P^c)) + [Fintype (O⧸Q)] [Fintype (O⧸P^c)] [Fintype (O⧸Q*P^c)] + (F : (O⧸Q)→(O⧸Q*P^c)→ℂ) (d : O) : + (∑x : O⧸Q*P^c,∑y : O⧸Q*P^c, + (actualSextic P hg^e) (Ideal.Quotient.mk P d* + primePowerReduction P hc ((Ideal.quotientMulEquivQuotientProd Q (P^c) hcop x).2))* + F ((Ideal.quotientMulEquivQuotientProd Q (P^c) hcop x).1) y)=0 := by + rw [Finset.sum_comm] + apply Finset.sum_eq_zero + intro y hy + let E := Ideal.quotientMulEquivQuotientProd Q (P^c) hcop + have heq := E.toEquiv.sum_comp (fun p : (O⧸Q)×(O⧸P^c)=> + (actualSextic P hg^e) (Ideal.Quotient.mk P d*primePowerReduction P hc p.2)*F p.1 y) + change (∑x : O⧸Q*P^c,(actualSextic P hg^e) + (Ideal.Quotient.mk P d*primePowerReduction P hc (E x).2)*F (E x).1 y)=0 + calc + _ = ∑p : (O⧸Q)×(O⧸P^c),(actualSextic P hg^e) + (Ideal.Quotient.mk P d*primePowerReduction P hc p.2)*F p.1 y := heq + _ = 0 := by + rw [Fintype.sum_prod_type] + simp_rw [←Finset.sum_mul,primePower_mean_zero P hg hchar c e hc he d,zero_mul] + simp + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramMeanLift.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramMeanLift.lean new file mode 100644 index 0000000000000000000000000000000000000000..223ce567282af1844e6046ab9681b66b7fd3af4d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramMeanLift.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Detector.GramMean + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ActualEisensteinCubic CompletedGauss ConcreteTraceCRT ConcretePrimeRowBridge +open CenteredMomentCorrelation CanonicalCoefficientClass +local notation "O" => ActualEisensteinCubic.O + +theorem joint_mean_of_local_factor (Q P : Ideal O) [P.IsMaximal] + (hg : goodLambda∉P) (hchar : ringChar (O⧸P)≠2) + (c e : ℕ) (hc : 1≤c) (he : ¬6∣e) (hcop : IsCoprime Q (P^c)) + [Fintype (O⧸Q)] [Fintype (O⧸P^c)] [Fintype (O⧸Q*P^c)] + (F : O→O→ℂ) (hF : ∀x z y,x-z∈Q → F x y=F z y) (d : O) : + (∑x : O⧸Q*P^c,∑y : O⧸Q*P^c, + (actualSextic P hg^e) (Ideal.Quotient.mk P (d*x.out))*F x.out y.out)=0 := by + let E := Ideal.quotientMulEquivQuotientProd Q (P^c) hcop + have hE (x : O⧸Q*P^c) : E x=(Ideal.Quotient.mk Q x.out,Ideal.Quotient.mk (P^c) x.out) := by + conv_lhs => rw [←Ideal.Quotient.mk_out x] + rfl + have hf (x : O⧸Q*P^c) (y : O) : F x.out y=F (E x).1.out y := by + apply hF + apply Ideal.Quotient.eq.mp + rw [Ideal.Quotient.mk_out,hE] + have hp (x : O⧸Q*P^c) : Ideal.Quotient.mk P (d*x.out)= + Ideal.Quotient.mk P d*primePowerReduction P hc (E x).2 := by + rw [map_mul,hE] + rfl + have hz := crt_joint_mean_zero Q P hg hchar c e hc he hcop + (fun x y=>F x.out y.out) d + convert hz using 1 + apply Finset.sum_congr rfl + intro x hx + apply Finset.sum_congr rfl + intro y hy + rw [hp,hf] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramMobiusLattice.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramMobiusLattice.lean new file mode 100644 index 0000000000000000000000000000000000000000..4b8d57d97d2f201d697047a522ed49dc9154b656 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramMobiusLattice.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Detector.GramIdealDilation +import OAI.NumberTheory.DirichletL.Detector.GramLatticeSource + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +lemma primary_product (C d : O) (hC : λ₀^2∣C-1) (hd : λ₀^2∣d-1) : λ₀^2∣C*d-1 := by + have h := dvd_add (hC.mul_right d) hd + convert h using 1 ; ring + +theorem jointExtension_divisor_lattice (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (C k : O) (hC : λ₀^2∣C-1) + (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,λ₀∉P i) (c : ι→ℕ) + (D : SupportedIdeal) (W : O→O→ℂ) : + (∑'I : SupportedIdeal,∑'J : SupportedIdeal, + if D.val∣I.val ∧ D.val∣J.val then + jointExtension S hS σ C k u a b r hr P hg c (primaryGenerator I.val) (primaryGenerator J.val)* + W (primaryGenerator I.val) (primaryGenerator J.val) else 0)= + ∑'n : O,∑'m : O, + jointExtension S hS σ C k u a b r hr P hg c (primaryGenerator D.val*n) (primaryGenerator D.val*m)* + W (primaryGenerator D.val*n) (primaryGenerator D.val*m) := by + rw [supported_divisor_pair_tsum D (fun I J=> + jointExtension S hS σ C k u a b r hr P hg c (primaryGenerator I.val) (primaryGenerator J.val)* + W (primaryGenerator I.val) (primaryGenerator J.val))] + simp only [supported_dilation_generator] + have hd : λ₀^2∣primaryGenerator D.val-1 := + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ D.property)).2 + exact jointExtension_ideal_lattice S hS hbad σ C k (primaryGenerator D.val) (primary_product C _ hC hd) + u a b r hr P hg c (fun n m=>W (primaryGenerator D.val*n) (primaryGenerator D.val*m)) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramMobiusPool.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramMobiusPool.lean new file mode 100644 index 0000000000000000000000000000000000000000..44e5dd84aa34e1d51f04d8dc0559eb1ca590212b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramMobiusPool.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Detector.GramIdealDilation +import OAI.NumberTheory.DirichletL.Moments.MobiusRegroup + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CompletedGauss IdealMobiusDivisorSum UniqueFactorizationMonoid +open CenteredMomentMobiusRegroup +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma divisorPool_supported (G : Finset SupportedIdeal) (D : Id) (hD : D∈divisorPool G Subtype.val) : + Supported D := by + obtain ⟨J,hJ,hd⟩ := Finset.mem_biUnion.mp hD + exact gram_supported_divisor J.val D J.property ((mem_idealDivisors J.property.1).mp hd) + +def poolDivisor (G : Finset SupportedIdeal) (D : Id) : SupportedIdeal := + if hD : D∈divisorPool G Subtype.val then ⟨D,divisorPool_supported G D hD⟩ + else ⟨1,by + constructor + · exact one_ne_zero + · intro P hP + change P∈normalizedFactors (1:Id) at hP + rw [normalizedFactors_one] at hP + simp at hP⟩ + +lemma poolDivisor_val (G : Finset SupportedIdeal) (D : Id) (hD : D∈divisorPool G Subtype.val) : + (poolDivisor G D).val=D := by simp [poolDivisor,hD] + +lemma finite_pair_eq_tsum (F G : Finset SupportedIdeal) (f : SupportedIdeal→SupportedIdeal→ℂ) + (hf : ∀I J,I∉F ∨ J∉G→f I J=0) : + (∑I∈F,∑J∈G,f I J)=∑'I : SupportedIdeal,∑'J : SupportedIdeal,f I J := by + have hinner (I : SupportedIdeal) : (∑J∈G,f I J)=∑'J : SupportedIdeal,f I J := + (tsum_eq_sum (fun J hJ=>hf I J (Or.inr hJ))).symm + simp_rw [hinner] + symm + apply tsum_eq_sum + intro I hI + simp only [hf I _ (Or.inl hI),tsum_zero] + +theorem finite_pair_mobius_dilation (F G : Finset SupportedIdeal) + (f : SupportedIdeal→SupportedIdeal→ℂ) (hf : ∀I J,I∉F ∨ J∉G→f I J=0) : + (∑I∈F,∑J∈G,if IsCoprime I.val J.val then f I J else 0)= + ∑D∈divisorPool G Subtype.val,(moebius D:ℂ)* + ∑'I : SupportedIdeal,∑'J : SupportedIdeal, + f (supportedIdealProduct (poolDivisor G D) I) (supportedIdealProduct (poolDivisor G D) J) := by + rw [finite_pair_mobius F G Subtype.val Subtype.val (fun J _=>J.property.1) f] + apply Finset.sum_congr rfl + intro D hD + congr 1 + have hd := poolDivisor_val G D hD + rw [finite_pair_eq_tsum F G (fun I J=>if D∣I.val ∧ D∣J.val then f I J else 0) (by + intro I J h + simp only [hf I J h,ite_self])] + convert supported_divisor_pair_tsum (poolDivisor G D) f using 1 + rw [hd] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramNonexceptionalBlock.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramNonexceptionalBlock.lean new file mode 100644 index 0000000000000000000000000000000000000000..39c4d5f2c436156040fb401c1bdd376c1d4b7552 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramNonexceptionalBlock.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.GramResidue +import OAI.NumberTheory.DirichletL.Detector.GramPeriodicPoisson + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open ConcretePrimeRowBridge UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "Joint" => ProbeGramPeriodicPoisson.Joint + +theorem literal_nonexceptional_block (A : ℕ) (hA : 2jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + W (ProbeGramLatticeDecay.physicalPoint N m)) ∧ + ‖∑'m : O×O,jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + W (ProbeGramLatticeDecay.physicalPoint N m)‖≤ + K*ProbeGramLatticeDecay.sourceControl H W*(Ideal.absNorm (Ideal.span {C}):ℝ)*N^2* + min 1 (((Ideal.absNorm (jointFixedModulus S hS):ℝ)*Ideal.absNorm (Ideal.span {C})* + Ideal.absNorm (Ideal.span {k})/N)^A) := by + obtain ⟨H,K,hK,hengine⟩ := ProbeGramPeriodicPoisson.ideal_annular_periodic_bound A hA a₀ b₀ ha₀ hab + refine ⟨H,K,hK,?_⟩ + intro ι inst S hS σ C k hC hk0 u a b r hr hk P hmax hg c hc hfac p hpmax hp0 hgp hchar hfixed hcommon he W hW d N hN + have hcount : (normalizedFactors (Ideal.span {k})).count p= + (normalizedFactors (Ideal.span {r})).count p := by + rw [hk] + exact good_factor_count p hgp hchar u a b r hr + have heR : ¬6∣(normalizedFactors (Ideal.span {r})).count p := hcount ▸ he + obtain ⟨M,hM,hMN,hres⟩ := exists_nonexceptional_residue S hS σ C k hC hk0 u a b r hr hk + P hg c hc hfac p hp0 hgp hchar hfixed hcommon heR + let : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient hM + let : Fintype (O⧸M) := Fintype.ofFinite _ + obtain ⟨f,hf,hfn,hfm⟩ := hres d + have hmean : (∑'v : (O⧸M)×(O⧸M),f v.1 v.2)=0 := by + rw [tsum_fintype,Fintype.sum_prod_type] + exact hfm + have hh := hengine W hW M hM (fun v=>f v.1 v.2) (Ideal.absNorm (Ideal.span {C})) + (Nat.cast_nonneg _) (fun v=>hfn v.1 v.2) hmean N hN + have hfun : (fun m : O×O=>f (ProbeGramPeriodicPoisson.idealQuotientPair M m).1 + (ProbeGramPeriodicPoisson.idealQuotientPair M m).2*W (ProbeGramLatticeDecay.physicalPoint N m))= + (fun m : O×O=>jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + W (ProbeGramLatticeDecay.physicalPoint N m)) := by + funext m + rw [ProbeGramPeriodicPoisson.idealQuotientPair,hf] + rw [hfun] at hh + refine ⟨hh.1,hh.2.trans ?_⟩ + apply mul_le_mul_of_nonneg_left _ (by unfold ProbeGramLatticeDecay.sourceControl;positivity) + apply min_le_min_left + apply pow_le_pow_left₀ (by positivity) + apply div_le_div_of_nonneg_right _ hN.le + exact_mod_cast hMN + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramNonzeroFrequency.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramNonzeroFrequency.lean new file mode 100644 index 0000000000000000000000000000000000000000..1269acce994e1df68aa17e8e4eb22868d2766279 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramNonzeroFrequency.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCanonicalSource + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT +open CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +lemma nonzero_tsum_indicator (f : O→ℂ) : + (∑'k : O,if k=0 then 0 else f k)=∑'k : GramFrequency,f k.val := by + rw [←tsum_subtype_eq_of_support_subset (s:={k : O | k≠0}) (by + intro k hk hz + subst k + exact hk (by simp))] + apply tsum_congr + intro k + exact ite_eq_right k.property + +def gramFrequencyNeg : GramFrequency≃GramFrequency where + toFun k:=⟨-k.val,neg_ne_zero.mpr k.property⟩ + invFun k:=⟨-k.val,neg_ne_zero.mpr k.property⟩ + left_inv k:=Subtype.ext (neg_neg k.val) + right_inv k:=Subtype.ext (neg_neg k.val) + +lemma actual_common_nonzero_tsum (C n₁ n₂ : O) + (hC : Supported (Ideal.span {C})) (h₁ : Supported (Ideal.span {n₁})) (h₂ : Supported (Ideal.span {n₂})) + (F : O→ℂ) : + (∑'j : GramFrequency,actualCorrelation (C*n₁) (C*n₂) + (supported_mul_elements C n₁ hC h₁) (supported_mul_elements C n₂ hC h₂) j.val*F j.val)= + ∑'k : GramFrequency,actualCorrelation (C*n₁) (C*n₂) + (supported_mul_elements C n₁ hC h₁) (supported_mul_elements C n₂ hC h₂) (C*k.val)*F (C*k.val) := by + have hh := actual_common_frequency_tsum C n₁ n₂ hC h₁ h₂ (fun j=>if j=0 then 0 else F j) + have hc0 := supported_element_ne_zero C hC + simp only [mul_ite,mul_zero,mul_eq_zero,hc0,false_or] at hh + simpa only [nonzero_tsum_indicator] using hh + +lemma actual_gcd_nonzero_frequency_source (I J : SupportedIdeal) (U : SchwartzMap ℝ ℂ) (Q : ℝ) : + (∑'h : GramFrequency,actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (-h.val)* + paperRadialFourier U (Q*‖eisEmbedding h.val‖^2/‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2))= + ∑'k : GramFrequency,actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) (primaryGenerator (gcdCommon I J).val*k.val)* + paperRadialFourier U (Q*‖eisEmbedding (primaryGenerator (gcdCommon I J).val*k.val)‖^2/ + ‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2) := by + have hn := gramFrequencyNeg.tsum_eq (fun h : GramFrequency=> + actualCorrelation (primaryGenerator I.val) (primaryGenerator J.val) + ((supported_span_primaryGenerator_iff _).mpr I.property) + ((supported_span_primaryGenerator_iff _).mpr J.property) h.val* + paperRadialFourier U (Q*‖eisEmbedding h.val‖^2/‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2)) + simp only [gramFrequencyNeg,Equiv.coe_fn_mk,map_neg,norm_neg] at hn + rw [hn] + have hh := actual_common_nonzero_tsum (primaryGenerator (gcdCommon I J).val) + (primaryGenerator (gcdLeft I J).val) (primaryGenerator (gcdRight I J).val) + ((supported_span_primaryGenerator_iff _).mpr (gcdCommon I J).property) + ((supported_span_primaryGenerator_iff _).mpr (gcdLeft I J).property) + ((supported_span_primaryGenerator_iff _).mpr (gcdRight I J).property) + (fun h=>paperRadialFourier U (Q*‖eisEmbedding h‖^2/ + ‖eisEmbedding (primaryGenerator I.val*primaryGenerator J.val)‖^2)) + simpa only [←gcd_generator_left I J,←gcd_generator_right I J] using hh + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramNumerator.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramNumerator.lean new file mode 100644 index 0000000000000000000000000000000000000000..2173d90848260eb1d314780eb857a9911b1ac727 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramNumerator.lean @@ -0,0 +1,59 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramFixedCoefficient +import OAI.NumberTheory.DirichletL.Detector.GramMean + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +def numeratorExtension (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) : O→*ℂ := + numeratorBadTwist u a b r hr*movingNumeratorRow r hr + +lemma numeratorExtension_norm (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) (n : O) : + ‖numeratorExtension u a b r hr n‖≤1 := by + rw [numeratorExtension,MonoidHom.mul_apply,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (numeratorBadTwist_norm _ _ _ _ _ _)).trans (movingNumeratorRow_norm _ _ _) + +lemma numeratorExtension_periodic (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) : + CanonicalCoefficientClass.FactorsModulo (Ideal.span {(72:O)}*Ideal.span {r}) + (numeratorExtension u a b r hr) := by + intro x y hxy + change numeratorBadTwist u a b r hr x*movingNumeratorRow r hr x= + numeratorBadTwist u a b r hr y*movingNumeratorRow r hr y + rw [numeratorBadTwist_periodic _ _ _ _ _ x y (Ideal.mul_le_left hxy), + movingNumeratorRow_periodic _ _ x y (Ideal.mul_le_right hxy)] + +lemma numeratorExtension_primary (u : Oˣ) (a b : ℕ) (r k n : O) + (hr : Supported (Ideal.span {r})) (hpr : λ₀^2∣r-1) + (hk : k=u.val*λ₀^a*(2:O)^b*r) + (hn : Supported (Ideal.span {n})) (hpn : λ₀^2∣n-1) : + numeratorExtension u a b r hr n=idealRowHom k (Ideal.span {n}) := by + rw [hk] + exact (idealRowHom_factor_numerator u a b r n hr hpr hn hpn).symm + +lemma numeratorExtension_neg_primary (u : Oˣ) (a b : ℕ) (r k n : O) + (hr : Supported (Ideal.span {r})) (hpr : λ₀^2∣r-1) + (hk : k=u.val*λ₀^a*(2:O)^b*r) + (hn : Supported (Ideal.span {n})) (hpn : λ₀^2∣n-1) : + numeratorExtension (-u) a b r hr n=idealRowHom (-k) (Ideal.span {n}) := by + apply numeratorExtension_primary _ _ _ _ _ _ hr hpr _ hn hpn + simp only [Units.val_neg,hk] + ring + +lemma numerator_good_norm_le (u : Oˣ) (a b : ℕ) (r k : O) + (hk : k=u.val*λ₀^a*(2:O)^b*r) (hk0 : k≠0) : + Ideal.absNorm (Ideal.span {r})≤Ideal.absNorm (Ideal.span {k}) := by + apply Nat.le_of_dvd + · exact Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hk0)) + · apply map_dvd Ideal.absNorm + rw [Ideal.span_singleton_dvd_span_singleton_iff_dvd] + exact ⟨u.val*λ₀^a*(2:O)^b,by rw [hk];ring⟩ + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramPeriodicPoisson.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramPeriodicPoisson.lean new file mode 100644 index 0000000000000000000000000000000000000000..914e4a377e0eb48cf43029e34ad6b2bde3c5f3bb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramPeriodicPoisson.lean @@ -0,0 +1,1097 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.GramLatticeDecay +import OAI.NumberTheory.DirichletL.Detector.GramAnnularLattice + +namespace OAI + +noncomputable section +open MeasureTheory Filter +open scoped BigOperators Classical FourierTransform SchwartzMap RealInnerProductSpace + +namespace ProbeGramPeriodicPoisson + +abbrev Joint := WithLp 2 (ℂ × ℂ) + +def point (x y : ℂ) : Joint := WithLp.toLp 2 (x, y) + +def embeddingPair (m : ActualEisensteinCubic.O × ActualEisensteinCubic.O) : Joint := + point (ConcreteTraceCRT.eisEmbedding m.1) (ConcreteTraceCRT.eisEmbedding m.2) + +@[simp] theorem norm_point_sq (x y : ℂ) : + ‖point x y‖ ^ 2 = ‖x‖ ^ 2 + ‖y‖ ^ 2 := + WithLp.prod_norm_sq_eq_of_L2 _ + +def leftInjection : ℂ →L[ℝ] Joint := + (((WithLp.linearEquiv 2 ℝ (ℂ × ℂ)).symm.toLinearMap).comp + (LinearMap.inl ℝ ℂ ℂ)).toContinuousLinearMap + +def rightInjection : ℂ →L[ℝ] Joint := + (((WithLp.linearEquiv 2 ℝ (ℂ × ℂ)).symm.toLinearMap).comp + (LinearMap.inr ℝ ℂ ℂ)).toContinuousLinearMap + +@[simp] theorem point_eq_add (x y : ℂ) : + point x y = leftInjection x + rightInjection y := by + change WithLp.toLp 2 (x,y) = WithLp.toLp 2 (x,0) + WithLp.toLp 2 (0,y) + rw [← WithLp.toLp_add] + simp + +theorem slice_isometry (y : ℂ) : Isometry (fun x : ℂ => point x y) := by + apply Isometry.of_dist_eq + intro x z + simp only [dist_eq_norm, point_eq_add, add_sub_add_right_eq_sub, ← map_sub] + exact WithLp.norm_toLp_fst 2 ℂ ℂ (x-z) + +theorem slice_temperate (y : ℂ) : + (fun x : ℂ => point x y).HasTemperateGrowth := by + simp only [point_eq_add] + fun_prop + +def leftSlice (W : 𝓢(Joint, ℂ)) (y : ℂ) : 𝓢(ℂ, ℂ) := + SchwartzMap.compCLMOfAntilipschitz ℂ (slice_temperate y) + (slice_isometry y).antilipschitzWith W + +@[simp] theorem leftSlice_apply (W : 𝓢(Joint, ℂ)) (y x : ℂ) : + leftSlice W y x = W (point x y) := rfl + +theorem fourier_joint_eq_iterated (f : Joint → ℂ) (hf : Integrable f) (ξ η : ℂ) : + 𝓕 f (point ξ η) = + 𝓕 (fun x : ℂ => 𝓕 (fun y : ℂ => f (point x y)) η) ξ := by + let w : Joint := point ξ η + let G : Joint → ℂ := fun z => Real.fourierChar (-inner ℝ z w) • f z + have hG : Integrable G := (Real.fourierIntegral_convergent_iff w).mpr hf + have hGp : Integrable (fun z : ℂ × ℂ => G (WithLp.toLp 2 z)) := + (WithLp.volume_preserving_toLp ℂ ℂ).integrable_comp_of_integrable hG + calc + 𝓕 f (point ξ η) = ∫ z : Joint, G z := rfl + _ = ∫ z : ℂ × ℂ, G (WithLp.toLp 2 z) := + ((WithLp.volume_preserving_toLp ℂ ℂ).integral_comp + (MeasurableEquiv.toLp 2 (ℂ × ℂ)).measurableEmbedding G).symm + _ = ∫ x : ℂ, ∫ y : ℂ, G (WithLp.toLp 2 (x, y)) := integral_prod _ hGp + _ = _ := by + simp only [Real.fourier_eq, Circle.smul_def, smul_eq_mul] + apply integral_congr_ae + exact Eventually.of_forall fun x => by + dsimp only + rw [← integral_const_mul] + apply integral_congr_ae + exact Eventually.of_forall fun y => by + simp only [G, w, point, WithLp.prod_inner_apply, + neg_add, Real.fourierChar.map_add_eq_mul, Circle.smul_def, smul_eq_mul, + Circle.coe_mul, mul_assoc] + +def partialFourier (W : 𝓢(Joint, ℂ)) (η x : ℂ) : ℂ := + 𝓕 (fun y : ℂ => W (point x y)) η + +def planeMajorant (y : ℂ) : ℝ := ((1 + ‖y‖ ^ 2) ^ 2)⁻¹ + +theorem planeMajorant_integrable : Integrable planeMajorant := by + have h := integrable_rpow_neg_one_add_norm_sq (E := ℂ) (μ := volume) + (r := 4) (by norm_num) + change Integrable (fun y : ℂ => ((1 + ‖y‖ ^ 2) ^ 2)⁻¹) + convert h using 1 + funext y + rw [show -(4:ℝ)/2 = -(2:ℝ) by norm_num, Real.rpow_neg (by positivity), Real.rpow_two] + +def majorantConstant (W : 𝓢(Joint, ℂ)) : ℝ := + SchwartzMap.seminorm ℝ 0 0 W + 2 * SchwartzMap.seminorm ℝ 2 0 W + + SchwartzMap.seminorm ℝ 4 0 W + +theorem norm_le_planeMajorant (W : 𝓢(Joint, ℂ)) (x y : ℂ) : + ‖W (point x y)‖ ≤ majorantConstant W * planeMajorant y := by + have h0 := SchwartzMap.norm_le_seminorm ℝ W (point x y) + have h2 := SchwartzMap.norm_pow_mul_le_seminorm ℝ W 2 (point x y) + have h4 := SchwartzMap.norm_pow_mul_le_seminorm ℝ W 4 (point x y) + have hy : ‖y‖^2 ≤ ‖point x y‖^2 := by rw [norm_point_sq]; exact le_add_of_nonneg_left (sq_nonneg _) + have hy4 : ‖y‖^4 ≤ ‖point x y‖^4 := by nlinarith [sq_nonneg (‖x‖^2)] + have hm2 := mul_le_mul_of_nonneg_right hy (norm_nonneg (W (point x y))) + have hm4 := mul_le_mul_of_nonneg_right hy4 (norm_nonneg (W (point x y))) + rw [planeMajorant, ← div_eq_mul_inv, le_div_iff₀ (by positivity)] + dsimp [majorantConstant] + nlinarith + +theorem partialFourier_continuous (W : 𝓢(Joint, ℂ)) (η : ℂ) : + Continuous (partialFourier W η) := by + change Continuous (fun x : ℂ => ∫ y : ℂ, + Real.fourierChar (-inner ℝ y η) • W (point x y)) + apply continuous_of_dominated (bound := fun y => majorantConstant W * planeMajorant y) + · intro x + exact ((by fun_prop : Continuous (fun y : ℂ => Real.fourierChar (-inner ℝ y η))).smul + (W.continuous.comp (show Continuous (fun y : ℂ => point x y) from by + simp only [point_eq_add]; fun_prop))).aestronglyMeasurable + · intro x + exact Eventually.of_forall fun y => by + simpa only [Circle.smul_def, smul_eq_mul, norm_mul, Circle.norm_coe, one_mul] using + norm_le_planeMajorant W x y + · exact planeMajorant_integrable.const_mul _ + · exact Eventually.of_forall fun y => + continuous_const.smul (W.continuous.comp (slice_isometry y).continuous) + +theorem partialFourier_integrable (W : 𝓢(Joint, ℂ)) (η : ℂ) : + Integrable (partialFourier W η) := by + let G : Joint → ℂ := fun z => Real.fourierChar (-inner ℝ z.snd η) • W z + have hG : Integrable G := W.integrable.norm.mono' + (by fun_prop : Continuous G).aestronglyMeasurable + (Eventually.of_forall fun z => by + simp only [G, Circle.smul_def, smul_eq_mul, norm_mul, Circle.norm_coe, one_mul] + exact le_rfl) + have hGp : Integrable (fun z : ℂ × ℂ => G (WithLp.toLp 2 z)) := + (WithLp.volume_preserving_toLp ℂ ℂ).integrable_comp_of_integrable hG + change Integrable (fun x : ℂ => ∫ y : ℂ, + Real.fourierChar (-inner ℝ y η) • W (point x y)) + exact hGp.integral_prod_left + +def partialFourierSchwartz (W : 𝓢(Joint, ℂ)) (η : ℂ) : 𝓢(ℂ, ℂ) := + 𝓕⁻ (leftSlice (𝓕 W) η) + +theorem partialFourierSchwartz_apply (W : 𝓢(Joint, ℂ)) (η x : ℂ) : + partialFourierSchwartz W η x = partialFourier W η x := by + have heq : 𝓕 (partialFourier W η) = (leftSlice (𝓕 W) η : ℂ → ℂ) := by + funext ξ + change 𝓕 (fun x : ℂ => 𝓕 (fun y : ℂ => W (point x y)) η) ξ = _ + rw [← fourier_joint_eq_iterated W W.integrable ξ η] + exact (congrFun (SchwartzMap.fourier_coe W) (point ξ η)).symm + have hi : Integrable (𝓕 (partialFourier W η)) := by + rw [heq] + exact (leftSlice (𝓕 W) η).integrable + change (𝓕⁻ (leftSlice (𝓕 W) η)) x = _ + rw [congrFun (SchwartzMap.fourierInv_coe (leftSlice (𝓕 W) η)) x, ← heq] + exact (partialFourier_integrable W η).fourierInv_fourier_eq hi + (partialFourier_continuous W η).continuousAt + +theorem fourier_partialFourierSchwartz (W : 𝓢(Joint, ℂ)) (ξ η : ℂ) : + 𝓕 (partialFourierSchwartz W η) ξ = (𝓕 W) (point ξ η) := by + simp [partialFourierSchwartz] + +theorem jointCLM_finite_seminorm_control + {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] + (T : 𝓢(Joint, ℂ) →L[ℝ] 𝓢(E, ℂ)) (S : Finset (ℕ × ℕ)) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ ∀ W : 𝓢(Joint, ℂ), + S.sup (schwartzSeminormFamily ℝ E ℂ) (T W) ≤ + C * s.sup (schwartzSeminormFamily ℝ Joint ℂ) W := by + let q : Seminorm ℝ 𝓢(Joint, ℂ) := + (S.sup (schwartzSeminormFamily ℝ E ℂ)).comp T.toLinearMap + have hq : Continuous q := + (((schwartz_withSeminorms ℝ E ℂ).finset_sups).continuous_seminorm S).comp T.continuous + obtain ⟨s, C, hC, hbound⟩ := + Seminorm.bound_of_continuous (schwartz_withSeminorms ℝ Joint ℂ) q hq + refine ⟨s, C, ?_, ?_⟩ + · exact_mod_cast (pos_iff_ne_zero.mpr hC : 0 < C) + · intro W + exact Seminorm.le_def.mp hbound W + +def productDecayConstant (W : 𝓢(Joint, ℂ)) : ℝ := + 2 ^ (8:ℕ) * (Finset.Iic (8,0)).sup (schwartzSeminormFamily ℝ Joint ℂ) W + +theorem product_decay (W : 𝓢(Joint, ℂ)) (x y : ℂ) : + ((1+‖x‖^2)^2 * (1+‖y‖^2)^2) * ‖W (point x y)‖ ≤ productDecayConstant W := by + have hx := WithLp.norm_fst_le ℂ (point x y) + have hy := WithLp.norm_snd_le ℂ (point x y) + change ‖x‖ ≤ ‖point x y‖ at hx + change ‖y‖ ≤ ‖point x y‖ at hy + have hx2 : 1+‖x‖^2 ≤ (1+‖point x y‖)^2 := by nlinarith [norm_nonneg (point x y), norm_nonneg x, norm_nonneg y] + have hy2 : 1+‖y‖^2 ≤ (1+‖point x y‖)^2 := by nlinarith [norm_nonneg (point x y), norm_nonneg x, norm_nonneg y] + have hpow : (1+‖x‖^2)^2 * (1+‖y‖^2)^2 ≤ (1+‖point x y‖)^8 := by + calc + _ ≤ ((1+‖point x y‖)^2)^2 * ((1+‖point x y‖)^2)^2 := by gcongr + _ = _ := by ring + have h := SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) + (m := (8,0)) (k := 8) (n := 0) le_rfl le_rfl W (point x y) + simp only [norm_iteratedFDeriv_zero] at h + exact (mul_le_mul_of_nonneg_right hpow (norm_nonneg _)).trans h + +theorem norm_le_product_majorant (W : 𝓢(Joint, ℂ)) (x y : ℂ) : + ‖W (point x y)‖ ≤ productDecayConstant W * (planeMajorant x * planeMajorant y) := by + rw [planeMajorant, planeMajorant, ← mul_inv, ← div_eq_mul_inv] + apply (le_div_iff₀ (by positivity)).mpr + simpa only [mul_comm] using product_decay W x y + +theorem planeMajorant_eisenstein_summable : + Summable (fun m : ActualEisensteinCubic.O => + planeMajorant (ConcreteTraceCRT.eisEmbedding m)) := by + have hs := CubicEisenstein.summable_embedding_rpow (-4) (by norm_num) + rw [← Finset.summable_compl_iff (s := ({0} : Finset ActualEisensteinCubic.O))] + apply Summable.of_nonneg_of_le (fun _ => by unfold planeMajorant; positivity) _ + (hs.subtype (fun m : ActualEisensteinCubic.O => m ∉ ({0} : Finset _))) + intro m + have hm : m.val ≠ 0 := by simpa using m.property + have hn : 0 < ‖ConcreteTraceCRT.eisEmbedding m.val‖ := norm_pos_iff.mpr + (ConcreteTraceCRT.eisEmbedding_ne_zero hm) + change ((1+‖ConcreteTraceCRT.eisEmbedding m.val‖^2)^2)⁻¹ ≤ + ‖ConcreteTraceCRT.eisEmbedding m.val‖ ^ (-4:ℝ) + rw [show (-4:ℝ) = -(4:ℝ) by rfl, Real.rpow_neg hn.le, Real.rpow_ofNat] + apply inv_anti₀ (by positivity) + nlinarith [sq_nonneg (‖ConcreteTraceCRT.eisEmbedding m.val‖^2)] + +theorem joint_eisenstein_summable_norm (W : 𝓢(Joint, ℂ)) : + Summable (fun m : ActualEisensteinCubic.O × ActualEisensteinCubic.O => + ‖W (embeddingPair m)‖) := by + have hs := planeMajorant_eisenstein_summable.mul_of_nonneg + planeMajorant_eisenstein_summable + (fun _ => by unfold planeMajorant; positivity) + (fun _ => by unfold planeMajorant; positivity) + apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ + (hs.mul_left (productDecayConstant W)) + intro m + exact norm_le_product_majorant W _ _ + +theorem joint_weighted_summable {R : Type*} (q : ActualEisensteinCubic.O → R) + (a : R × R → ℂ) (B : ℝ) (hB : ∀ r, ‖a r‖ ≤ B) (W : 𝓢(Joint, ℂ)) : + Summable (fun m : ActualEisensteinCubic.O × ActualEisensteinCubic.O => + a (q m.1,q m.2) * W (embeddingPair m)) := by + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ + ((joint_eisenstein_summable_norm W).mul_left B) + intro m + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (hB _) (norm_nonneg _) + +open scoped LineDeriv + +theorem leftSlice_lineDeriv (F : 𝓢(Joint, ℂ)) (η v : ℂ) : + ∂_{v} (leftSlice F η) = leftSlice (∂_{leftInjection v} F) η := by + apply SchwartzMap.ext + intro x + rw [SchwartzMap.lineDerivOp_apply_eq_fderiv, leftSlice_apply, + SchwartzMap.lineDerivOp_apply_eq_fderiv] + have hd : HasFDerivAt (fun x : ℂ => point x η) leftInjection x := by + simp only [point_eq_add] + exact leftInjection.hasFDerivAt.add_const _ + have hc := (F.hasFDerivAt (point x η)).comp x hd + change fderiv ℝ ((F : Joint → ℂ) ∘ (fun y => point y η)) x v = _ + rw [hc.fderiv] + rfl + +theorem norm_inverse_lineDeriv (g : 𝓢(ℂ, ℂ)) (v x : ℂ) : + ‖(𝓕⁻ (∂_{v} g)) x‖ = (2 * Real.pi) * |inner ℝ x v| * ‖(𝓕⁻ g) x‖ := by + have ht : (fun u : ℂ => inner ℝ u v).HasTemperateGrowth := by fun_prop + have hc : ‖(-(2 * Real.pi * Complex.I) : ℂ)‖ = 2 * Real.pi := by + simp [Complex.norm_real, Real.norm_eq_abs, abs_of_pos Real.pi_pos] + rw [SchwartzMap.fourierInv_lineDerivOp_eq] + simp only [smul_apply, SchwartzMap.smulLeftCLM_apply_apply ht, + norm_smul] + rw [hc] + simp only [Real.norm_eq_abs, mul_assoc] + +theorem inner_sq_mul_norm_inverse_le (g : 𝓢(ℂ, ℂ)) (v x : ℂ) : + (inner ℝ x v)^2 * ‖(𝓕⁻ g) x‖ ≤ ‖(𝓕⁻ (∂_{v} (∂_{v} g))) x‖ := by + rw [norm_inverse_lineDeriv, norm_inverse_lineDeriv] + have hp : 1 ≤ (2 * Real.pi)^2 := by nlinarith [Real.pi_gt_three] + calc + _ ≤ ((2 * Real.pi)^2 * (inner ℝ x v)^2) * ‖(𝓕⁻ g) x‖ := + mul_le_mul_of_nonneg_right (le_mul_of_one_le_left (sq_nonneg _) hp) (norm_nonneg _) + _ = _ := by rw [← sq_abs (inner ℝ x v)]; ring + +theorem norm_sq_mul_norm_inverse_le (g : 𝓢(ℂ, ℂ)) (x : ℂ) : + ‖x‖^2 * ‖(𝓕⁻ g) x‖ ≤ + ‖(𝓕⁻ (∂_{(1:ℂ)} (∂_{(1:ℂ)} g))) x‖ + + ‖(𝓕⁻ (∂_{Complex.I} (∂_{Complex.I} g))) x‖ := by + have h1 := inner_sq_mul_norm_inverse_le g 1 x + have hi := inner_sq_mul_norm_inverse_le g Complex.I x + have he : (inner ℝ x (1:ℂ))^2 + (inner ℝ x Complex.I)^2 = ‖x‖^2 := by + rw [Complex.sq_norm] + simp [Complex.inner, Complex.normSq_apply, sq] + rw [← he, add_mul] + exact add_le_add h1 hi + +theorem norm_inverse_leftSlice_le (F : 𝓢(Joint, ℂ)) (η x : ℂ) : + ‖(𝓕⁻ (leftSlice F η)) x‖ ≤ + productDecayConstant F * planeMajorant η * ∫ y : ℂ, planeMajorant y := by + have hb : Integrable (fun y : ℂ => + productDecayConstant F * planeMajorant η * planeMajorant y) := + planeMajorant_integrable.const_mul _ + have h := norm_integral_le_of_norm_le + (f := fun y : ℂ => Real.fourierChar (inner ℝ y x) • leftSlice F η y) hb + (Eventually.of_forall fun y => by + simpa only [Circle.smul_def, smul_eq_mul, norm_mul, Circle.norm_coe, one_mul, + leftSlice_apply, mul_left_comm, mul_assoc, mul_comm] using norm_le_product_majorant F y η) + rw [congrFun (SchwartzMap.fourierInv_coe (leftSlice F η)) x, Real.fourierInv_eq] + simpa only [integral_const_mul] using h + +def leftSecondReal (F : 𝓢(Joint, ℂ)) : 𝓢(Joint, ℂ) := + ∂_{leftInjection (1:ℂ)} (∂_{leftInjection (1:ℂ)} F) + +def leftSecondImag (F : 𝓢(Joint, ℂ)) : 𝓢(Joint, ℂ) := + ∂_{leftInjection Complex.I} (∂_{leftInjection Complex.I} F) + +def sliceIntegralBound (F : 𝓢(Joint, ℂ)) : ℝ := + productDecayConstant F * ∫ y : ℂ, planeMajorant y + +def firstDecayBound (F : 𝓢(Joint, ℂ)) : ℝ := + sliceIntegralBound F + sliceIntegralBound (leftSecondReal F) + + sliceIntegralBound (leftSecondImag F) + +def secondDecayBound (F : 𝓢(Joint, ℂ)) : ℝ := + firstDecayBound F + firstDecayBound (leftSecondReal F) + + firstDecayBound (leftSecondImag F) + +theorem inverse_leftSlice_weight_le (F : 𝓢(Joint, ℂ)) (η x : ℂ) : + (1+‖x‖^2) * ‖(𝓕⁻ (leftSlice F η)) x‖ ≤ + ‖(𝓕⁻ (leftSlice F η)) x‖ + + ‖(𝓕⁻ (leftSlice (leftSecondReal F) η)) x‖ + + ‖(𝓕⁻ (leftSlice (leftSecondImag F) η)) x‖ := by + have h := norm_sq_mul_norm_inverse_le (leftSlice F η) x + simp only [leftSlice_lineDeriv] at h + change ‖x‖^2 * ‖(𝓕⁻ (leftSlice F η)) x‖ ≤ + ‖(𝓕⁻ (leftSlice (leftSecondReal F) η)) x‖ + + ‖(𝓕⁻ (leftSlice (leftSecondImag F) η)) x‖ at h + nlinarith + +theorem inverse_leftSlice_first_decay (F : 𝓢(Joint, ℂ)) (η x : ℂ) : + (1+‖x‖^2) * ‖(𝓕⁻ (leftSlice F η)) x‖ ≤ firstDecayBound F * planeMajorant η := by + apply (inverse_leftSlice_weight_le F η x).trans + have h0 := norm_inverse_leftSlice_le F η x + have h1 := norm_inverse_leftSlice_le (leftSecondReal F) η x + have h2 := norm_inverse_leftSlice_le (leftSecondImag F) η x + dsimp [firstDecayBound, sliceIntegralBound] + nlinarith + +theorem inverse_leftSlice_second_decay (F : 𝓢(Joint, ℂ)) (η x : ℂ) : + (1+‖x‖^2)^2 * ‖(𝓕⁻ (leftSlice F η)) x‖ ≤ secondDecayBound F * planeMajorant η := by + have h := mul_le_mul_of_nonneg_left (inverse_leftSlice_weight_le F η x) + (show 0 ≤ 1+‖x‖^2 by positivity) + have h0 := inverse_leftSlice_first_decay F η x + have h1 := inverse_leftSlice_first_decay (leftSecondReal F) η x + have h2 := inverse_leftSlice_first_decay (leftSecondImag F) η x + dsimp [secondDecayBound] + nlinarith + +theorem norm_partialFourier_le (W : 𝓢(Joint, ℂ)) (η x : ℂ) : + ‖partialFourier W η x‖ ≤ + secondDecayBound (𝓕 W) * (planeMajorant x * planeMajorant η) := by + rw [← partialFourierSchwartz_apply] + change ‖(𝓕⁻ (leftSlice (𝓕 W) η)) x‖ ≤ _ + have h := inverse_leftSlice_second_decay (𝓕 W) η x + have hd : ‖(𝓕⁻ (leftSlice (𝓕 W) η)) x‖ ≤ + secondDecayBound (𝓕 W) * planeMajorant η / (1+‖x‖^2)^2 := + (le_div_iff₀ (by positivity)).mpr (by nlinarith [h]) + convert hd using 1 + simp only [planeMajorant, div_eq_mul_inv] + ring + +open EisensteinSchwartzPoisson hiding O + +theorem planeMajorant_cartesian_summable : + Summable (fun p : ℤ × ℤ => planeMajorant (complexPoint (p.1:ℝ) (p.2:ℝ))) := by + apply Summable.of_nonneg_of_le (fun _ => by unfold planeMajorant; positivity) _ + summable_int_cauchy_product + intro p + change ((1+‖complexPoint (p.1:ℝ) (p.2:ℝ)‖^2)^2)⁻¹ ≤ _ + rw [← mul_inv] + apply inv_anti₀ (by positivity) + rw [Complex.sq_norm] + simp only [complexPoint, Complex.normSq_apply] + nlinarith [sq_nonneg (p.1:ℝ), sq_nonneg (p.2:ℝ), + mul_nonneg (sq_nonneg (p.1:ℝ)) (sq_nonneg (p.2:ℝ))] + +def cartesianPoint (p : ℤ × ℤ) : ℂ := complexPoint (p.1:ℝ) (p.2:ℝ) + +theorem joint_cartesian_summable_norm (W : 𝓢(Joint, ℂ)) : + Summable (fun p : (ℤ × ℤ) × (ℤ × ℤ) => + ‖W (point (cartesianPoint p.1) (cartesianPoint p.2))‖) := by + have hs := planeMajorant_cartesian_summable.mul_of_nonneg + planeMajorant_cartesian_summable + (fun _ => by unfold planeMajorant; positivity) + (fun _ => by unfold planeMajorant; positivity) + exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) + (fun _ => norm_le_product_majorant W _ _) (hs.mul_left (productDecayConstant W)) + +theorem partialFourier_cartesian_summable_norm (W : 𝓢(Joint, ℂ)) : + Summable (fun p : (ℤ × ℤ) × (ℤ × ℤ) => + ‖partialFourier W (cartesianPoint p.2) (cartesianPoint p.1)‖) := by + have hs := planeMajorant_cartesian_summable.mul_of_nonneg + planeMajorant_cartesian_summable + (fun _ => by unfold planeMajorant; positivity) + (fun _ => by unfold planeMajorant; positivity) + exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) + (fun _ => norm_partialFourier_le W _ _) (hs.mul_left (secondDecayBound (𝓕 W))) + +theorem rightSlice_isometry (x : ℂ) : Isometry (fun y : ℂ => point x y) := by + apply Isometry.of_dist_eq + intro y z + simp only [dist_eq_norm, point_eq_add, add_sub_add_left_eq_sub, ← map_sub] + exact WithLp.norm_toLp_snd 2 ℂ ℂ (y-z) + +def rightSlice (W : 𝓢(Joint, ℂ)) (x : ℂ) : 𝓢(ℂ, ℂ) := + SchwartzMap.compCLMOfAntilipschitz ℂ + (by simp only [point_eq_add]; fun_prop : (fun y : ℂ => point x y).HasTemperateGrowth) + (rightSlice_isometry x).antilipschitzWith W + +@[simp] theorem rightSlice_apply (W : 𝓢(Joint, ℂ)) (x y : ℂ) : + rightSlice W x y = W (point x y) := rfl + +theorem rightSlice_poisson (W : 𝓢(Joint, ℂ)) (x : ℂ) : + (∑' p : ℤ × ℤ, W (point x (cartesianPoint p))) = + ∑' p : ℤ × ℤ, partialFourier W (cartesianPoint p) x := by + have h := integer_pair_poisson (rightSlice W x) + have hcoe : (rightSlice W x : ℂ → ℂ) = fun y => W (point x y) := rfl + simpa only [rightSlice_apply, SchwartzMap.fourier_coe, hcoe, partialFourier, cartesianPoint] using h + +private theorem joint_cartesian_eq_partial (W : 𝓢(Joint, ℂ)) : + (∑' p : (ℤ × ℤ) × (ℤ × ℤ), W (point (cartesianPoint p.1) (cartesianPoint p.2))) = + ∑' n : ℤ × ℤ, ∑' m : ℤ × ℤ, + partialFourier W (cartesianPoint n) (cartesianPoint m) := by + have hp := (joint_cartesian_summable_norm W).of_norm + have hm := (partialFourier_cartesian_summable_norm W).of_norm + calc + _ = ∑' m : ℤ × ℤ, ∑' n : ℤ × ℤ, + W (point (cartesianPoint m) (cartesianPoint n)) := hp.tsum_prod + _ = ∑' m : ℤ × ℤ, ∑' n : ℤ × ℤ, + partialFourier W (cartesianPoint n) (cartesianPoint m) := by + apply tsum_congr + intro m + exact rightSlice_poisson W _ + _ = _ := hm.tsum_comm.symm + +private theorem partial_cartesian_poisson (W : 𝓢(Joint, ℂ)) (n : ℤ × ℤ) : + (∑' m : ℤ × ℤ, partialFourier W (cartesianPoint n) (cartesianPoint m)) = + ∑' m : ℤ × ℤ, (𝓕 W) (point (cartesianPoint m) (cartesianPoint n)) := by + calc + _ = ∑' m : ℤ × ℤ, partialFourierSchwartz W (cartesianPoint n) (cartesianPoint m) := + tsum_congr fun m => + (partialFourierSchwartz_apply W (cartesianPoint n) (cartesianPoint m)).symm + _ = ∑' m : ℤ × ℤ, + (𝓕 (partialFourierSchwartz W (cartesianPoint n)) : 𝓢(ℂ, ℂ)) (cartesianPoint m) := by + simpa only [cartesianPoint] using + integer_pair_poisson (partialFourierSchwartz W (cartesianPoint n)) + _ = _ := tsum_congr fun m => + fourier_partialFourierSchwartz W (cartesianPoint m) (cartesianPoint n) + +private theorem cartesian_swap_tsum (F : 𝓢(Joint, ℂ)) : + (∑' n : ℤ × ℤ, ∑' m : ℤ × ℤ, F (point (cartesianPoint m) (cartesianPoint n))) = + ∑' p : (ℤ × ℤ) × (ℤ × ℤ), F (point (cartesianPoint p.1) (cartesianPoint p.2)) := by + have hF := (joint_cartesian_summable_norm F).of_norm + exact hF.tsum_comm.trans hF.tsum_prod.symm + +private theorem partial_cartesian_eq_fourier (W : 𝓢(Joint, ℂ)) : + (∑' n : ℤ × ℤ, ∑' m : ℤ × ℤ, + partialFourier W (cartesianPoint n) (cartesianPoint m)) = + ∑' p : (ℤ × ℤ) × (ℤ × ℤ), (𝓕 W) (point (cartesianPoint p.1) (cartesianPoint p.2)) := by + exact (tsum_congr (partial_cartesian_poisson W)).trans (cartesian_swap_tsum (𝓕 W)) + +theorem joint_cartesian_poisson (W : 𝓢(Joint, ℂ)) : + (∑' p : (ℤ × ℤ) × (ℤ × ℤ), W (point (cartesianPoint p.1) (cartesianPoint p.2))) = + ∑' p : (ℤ × ℤ) × (ℤ × ℤ), (𝓕 W) (point (cartesianPoint p.1) (cartesianPoint p.2)) := by + exact (joint_cartesian_eq_partial W).trans (partial_cartesian_eq_fourier W) + +def blockMap (A : ℂ ≃L[ℝ] ℂ) : Joint ≃L[ℝ] Joint := + ((A.toLinearEquiv.prodCongr A.toLinearEquiv).withLpCongr 2).toContinuousLinearEquiv + +@[simp] theorem blockMap_apply (A : ℂ ≃L[ℝ] ℂ) (z : Joint) : + blockMap A z = point (A z.fst) (A z.snd) := rfl + +@[simp] theorem blockMap_symm_apply (A : ℂ ≃L[ℝ] ℂ) (z : Joint) : + (blockMap A).symm z = point (A.symm z.fst) (A.symm z.snd) := rfl + +theorem blockMap_det (A : ℂ ≃L[ℝ] ℂ) : + LinearMap.det (blockMap A : Joint →ₗ[ℝ] Joint) = + LinearMap.det (A : ℂ →ₗ[ℝ] ℂ) ^ 2 := by + have h := LinearMap.det_conj + ((A : ℂ →ₗ[ℝ] ℂ).prodMap (A : ℂ →ₗ[ℝ] ℂ)) + (WithLp.linearEquiv 2 ℝ (ℂ × ℂ)).symm + rw [LinearMap.det_prodMap] at h + convert h using 1 <;> first | rfl | ring + +def jointInverseJacobian (A : Joint ≃L[ℝ] Joint) : ℝ := + |(LinearMap.det (A : Joint →ₗ[ℝ] Joint))⁻¹| + +theorem jointInverseJacobian_blockMap (A : ℂ ≃L[ℝ] ℂ) : + jointInverseJacobian (blockMap A) = inverseJacobian A ^ 2 := by + rw [jointInverseJacobian, blockMap_det, ← inv_pow, abs_pow] + rfl + +def jointDual (A : Joint ≃L[ℝ] Joint) : Joint →L[ℝ] Joint := + A.symm.toContinuousLinearMap.adjoint + +theorem joint_inner_linear_dual (A : Joint ≃L[ℝ] Joint) (x y : Joint) : + inner ℝ (A x) (jointDual A y) = inner ℝ x y := by + rw [jointDual, ContinuousLinearMap.adjoint_inner_right] + simp + +theorem jointDual_blockMap (A : ℂ ≃L[ℝ] ℂ) (ξ η : ℂ) : + jointDual (blockMap A) (point ξ η) = point (dualMap A ξ) (dualMap A η) := by + apply ext_inner_left ℝ + intro z + rw [jointDual, ContinuousLinearMap.adjoint_inner_right] + change inner ℝ (point (A.symm z.fst) (A.symm z.snd)) (point ξ η) = _ + simp only [point, WithLp.prod_inner_apply, dualMap, + ContinuousLinearMap.adjoint_inner_right] + rfl + +theorem joint_integral_comp_linearEquiv (A : Joint ≃L[ℝ] Joint) (f : Joint → ℂ) : + (∫ x : Joint, f (A x)) = jointInverseJacobian A • ∫ x : Joint, f x := by + have h := integral_map_equiv («μ» := (volume : Measure Joint)) + A.toHomeomorph.toMeasurableEquiv f + have hm : Measure.map A (volume : Measure Joint) = + ENNReal.ofReal (jointInverseJacobian A) • volume := + Measure.map_linearMap_addHaar_eq_smul_addHaar volume A.toLinearEquiv.isUnit_det'.ne_zero + change (∫ y : Joint, f y ∂Measure.map A volume) = (∫ x : Joint, f (A x)) at h + rw [hm, integral_smul_measure, ENNReal.toReal_ofReal + (show 0 ≤ jointInverseJacobian A from abs_nonneg _)] at h + exact h.symm + +theorem joint_fourier_comp_linearEquiv (A : Joint ≃L[ℝ] Joint) + (f : Joint → ℂ) (w : Joint) : + 𝓕 (f ∘ A) w = jointInverseJacobian A • 𝓕 f (jointDual A w) := by + let H : Joint → ℂ := fun z => Real.fourierChar (-inner ℝ z (jointDual A w)) • f z + calc + 𝓕 (f ∘ A) w = ∫ x : Joint, H (A x) := by + apply integral_congr_ae + exact Eventually.of_forall fun x => by + simp only [H, joint_inner_linear_dual, Function.comp_apply] + rfl + _ = jointInverseJacobian A • ∫ z : Joint, H z := joint_integral_comp_linearEquiv A H + _ = _ := rfl + +def jointTranslate (W : 𝓢(Joint, ℂ)) (b : Joint) : 𝓢(Joint, ℂ) := + SchwartzMap.compCLMOfAntilipschitz ℂ (g := fun z : Joint => z+b) + (by fun_prop) (isometry_add_right b).antilipschitzWith W + +def jointAffine (W : 𝓢(Joint, ℂ)) (A : Joint ≃L[ℝ] Joint) (b : Joint) : 𝓢(Joint, ℂ) := + SchwartzMap.compCLMOfContinuousLinearEquiv ℂ A (jointTranslate W b) + +@[simp] theorem jointAffine_apply (W : 𝓢(Joint, ℂ)) (A : Joint ≃L[ℝ] Joint) (b z : Joint) : + jointAffine W A b z = W (A z+b) := rfl + +theorem joint_fourier_affine (W : 𝓢(Joint, ℂ)) (A : Joint ≃L[ℝ] Joint) (b w : Joint) : + (𝓕 (jointAffine W A b)) w = + jointInverseJacobian A • + (Real.fourierChar (inner ℝ b (jointDual A w)) • (𝓕 W) (jointDual A w)) := by + rw [congrFun (SchwartzMap.fourier_coe _) w] + change 𝓕 ((fun z => W (z+b)) ∘ A) w = _ + rw [joint_fourier_comp_linearEquiv] + have ht : 𝓕 (fun z => W (z+b)) (jointDual A w) = + Real.fourierChar (inner ℝ b (jointDual A w)) • 𝓕 (W : Joint → ℂ) (jointDual A w) := + congrFun (VectorFourier.fourierIntegral_comp_add_right Real.fourierChar + (volume : Measure Joint) (innerₗ Joint) (W : Joint → ℂ) b) (jointDual A w) + rw [ht] + rw [congrFun (SchwartzMap.fourier_coe W) (jointDual A w)] + +theorem joint_affine_poisson (W : 𝓢(Joint, ℂ)) (A : Joint ≃L[ℝ] Joint) (b : Joint) : + (∑' p : (ℤ × ℤ) × (ℤ × ℤ), + W (A (point (cartesianPoint p.1) (cartesianPoint p.2))+b)) = + jointInverseJacobian A • ∑' p : (ℤ × ℤ) × (ℤ × ℤ), + Real.fourierChar (inner ℝ b + (jointDual A (point (cartesianPoint p.1) (cartesianPoint p.2)))) • + (𝓕 W) (jointDual A (point (cartesianPoint p.1) (cartesianPoint p.2))) := by + have h := joint_cartesian_poisson (jointAffine W A b) + simp only [jointAffine_apply, joint_fourier_affine] at h + rw [tsum_const_smul''] at h + exact h + +def jointFrequency (c : ℂ) (hc : c ≠ 0) (p : (ℤ × ℤ) × (ℤ × ℤ)) : Joint := + point (eisensteinDualFrequency c hc p.1) (eisensteinDualFrequency c hc p.2) + +open ActualEisensteinCubic ConcreteTraceCRT + +theorem actual_joint_coset_poisson (W : 𝓢(Joint, ℂ)) (b : O × O) (c : O) (hc : c ≠ 0) : + (∑' m : O × O, W (embeddingPair (b.1+c*m.1,b.2+c*m.2))) = + (2 / (Real.sqrt 3 * ‖eisEmbedding c‖^2))^2 • + ∑' p : (ℤ × ℤ) × (ℤ × ℤ), + Real.fourierChar (inner ℝ (embeddingPair b) + (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)) • + (𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p) := by + let A := eisensteinLatticeMap (eisEmbedding c) (eisEmbedding_ne_zero hc) + have h := joint_affine_poisson W (blockMap A) (embeddingPair b) + simp only [jointInverseJacobian_blockMap, jointDual_blockMap] at h + rw [eisenstein_inverseJacobian] at h + calc + _ = ∑' p : (ℤ × ℤ) × (ℤ × ℤ), W (embeddingPair + (b.1+c*latticeCoordEquiv.symm p.1,b.2+c*latticeCoordEquiv.symm p.2)) := + ((latticeCoordEquiv.symm.prodCongr latticeCoordEquiv.symm).tsum_eq _).symm + _ = ∑' p : (ℤ × ℤ) × (ℤ × ℤ), + W (blockMap A (point (cartesianPoint p.1) (cartesianPoint p.2))+embeddingPair b) := by + apply tsum_congr + intro p + congr 1 + change point (eisEmbedding (b.1+c*ActualEisensteinCoordinates.eval p.1.1 p.1.2)) + (eisEmbedding (b.2+c*ActualEisensteinCoordinates.eval p.2.1 p.2.2)) = _ + simp only [map_add, map_mul, blockMap_apply, point] + rw [← eisensteinLatticeMap_point (eisEmbedding c) (eisEmbedding_ne_zero hc) p.1, + ← eisensteinLatticeMap_point (eisEmbedding c) (eisEmbedding_ne_zero hc) p.2] + change point (eisEmbedding b.1 + A (cartesianPoint p.1)) + (eisEmbedding b.2 + A (cartesianPoint p.2)) = + point (A (cartesianPoint p.1)+eisEmbedding b.1) + (A (cartesianPoint p.2)+eisEmbedding b.2) + simp only [add_comm] + _ = _ := h + +theorem joint_dual_summable_norm (W : 𝓢(Joint, ℂ)) (A : Joint ≃L[ℝ] Joint) : + Summable (fun p : (ℤ × ℤ) × (ℤ × ℤ) => + ‖(𝓕 W) (jointDual A (point (cartesianPoint p.1) (cartesianPoint p.2)))‖) := by + have hJ : 0 < jointInverseJacobian A := + abs_pos.mpr (inv_ne_zero A.toLinearEquiv.isUnit_det'.ne_zero) + have hs := joint_cartesian_summable_norm (𝓕 (jointAffine W A 0)) + have hn (p : (ℤ × ℤ) × (ℤ × ℤ)) : + ‖(𝓕 (jointAffine W A 0)) (point (cartesianPoint p.1) (cartesianPoint p.2))‖ = + jointInverseJacobian A * + ‖(𝓕 W) (jointDual A (point (cartesianPoint p.1) (cartesianPoint p.2)))‖ := by + rw [joint_fourier_affine] + simp [abs_of_pos hJ] + simp_rw [hn] at hs + have hi := hs.mul_left (jointInverseJacobian A)⁻¹ + simpa only [← mul_assoc, inv_mul_cancel₀ hJ.ne', one_mul] using hi + +theorem jointFrequency_summable_norm (W : 𝓢(Joint, ℂ)) (c : ℂ) (hc : c ≠ 0) : + Summable (fun p : (ℤ × ℤ) × (ℤ × ℤ) => ‖(𝓕 W) (jointFrequency c hc p)‖) := by + have h := joint_dual_summable_norm W (blockMap (eisensteinLatticeMap c hc)) + simpa only [jointDual_blockMap, jointFrequency, eisensteinDualFrequency, cartesianPoint] using h + +abbrev Residue (c : O) := O ⧸ Ideal.span {c} + +def quotientPair (c : O) (m : O × O) : Residue c × Residue c := + (Ideal.Quotient.mk (Ideal.span {c}) m.1, Ideal.Quotient.mk (Ideal.span {c}) m.2) + +def representativePair (c : O) (r : Residue c × Residue c) : O × O := + (GaussianShiftedPartition.representative c r.1, GaussianShiftedPartition.representative c r.2) + +def jointFiberSplit (c : O) (r : Residue c × Residue c) : + (quotientPair c ⁻¹' {r}) ≃ + ((Ideal.Quotient.mk (Ideal.span {c})) ⁻¹' {r.1}) × + ((Ideal.Quotient.mk (Ideal.span {c})) ⁻¹' {r.2}) where + toFun z := (⟨z.1.1, congrArg Prod.fst z.2⟩, ⟨z.1.2, congrArg Prod.snd z.2⟩) + invFun z := ⟨(z.1.1,z.2.1), Prod.ext z.1.2 z.2.2⟩ + left_inv _ := rfl + right_inv _ := rfl + +theorem joint_fiber_tsum (c : O) (hc : c ≠ 0) (r : Residue c × Residue c) + (W : O × O → ℂ) : + (∑' m : quotientPair c ⁻¹' {r}, W m.1) = + ∑' m : O × O, W ((representativePair c r).1+c*m.1, + (representativePair c r).2+c*m.2) := by + let e1 := GaussianFiberEquiv.fiberEquiv c hc r.1 + (GaussianShiftedPartition.representative c r.1) + (GaussianShiftedPartition.representative_spec c r.1) + let e2 := GaussianFiberEquiv.fiberEquiv c hc r.2 + (GaussianShiftedPartition.representative c r.2) + (GaussianShiftedPartition.representative_spec c r.2) + let e := (e1.prodCongr e2).trans (jointFiberSplit c r).symm + exact (e.tsum_eq (fun m => W m.1)).symm + +def residueFourier (c : O) (hc : c ≠ 0) (a : Residue c × Residue c → ℂ) + (p : (ℤ × ℤ) × (ℤ × ℤ)) : ℂ := + ∑' r : Residue c × Residue c, a r * + (Real.fourierChar (inner ℝ (embeddingPair (representativePair c r)) + (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)) : ℂ) + +theorem actual_joint_periodic_poisson (W : 𝓢(Joint, ℂ)) (c : O) (hc : c ≠ 0) + (a : Residue c × Residue c → ℂ) : + letI : Finite (Residue c) := finite_quotient_span hc + letI : Fintype (Residue c) := Fintype.ofFinite _ + (∑' m : O × O, a (quotientPair c m) * W (embeddingPair m)) = + ∑ r : Residue c × Residue c, a r * + ((2 / (Real.sqrt 3 * ‖eisEmbedding c‖^2))^2 • + ∑' p : (ℤ × ℤ) × (ℤ × ℤ), + Real.fourierChar (inner ℝ (embeddingPair (representativePair c r)) + (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)) • + (𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)) := by + classical + let : Finite (Residue c) := finite_quotient_span hc + let : Fintype (Residue c) := Fintype.ofFinite _ + have ha (r : Residue c × Residue c) : ‖a r‖ ≤ ∑ t : Residue c × Residue c, ‖a t‖ := + Finset.single_le_sum (fun t _ => norm_nonneg (a t)) (Finset.mem_univ r) + have hs := joint_weighted_summable (Ideal.Quotient.mk (Ideal.span {c})) a _ ha W + rw [GaussianAbelPartition.tsum_periodic_weighted_partition (quotientPair c) a + (fun m => W (embeddingPair m)) hs] + apply Finset.sum_congr rfl + intro r hr + congr 1 + exact (joint_fiber_tsum c hc r (fun m => W (embeddingPair m))).trans + (actual_joint_coset_poisson W (representativePair c r) c hc) + +theorem actual_joint_periodic_fourier (W : 𝓢(Joint, ℂ)) (c : O) (hc : c ≠ 0) + (a : Residue c × Residue c → ℂ) : + (∑' m : O × O, a (quotientPair c m) * W (embeddingPair m)) = + (2 / (Real.sqrt 3 * ‖eisEmbedding c‖^2))^2 • + ∑' p : (ℤ × ℤ) × (ℤ × ℤ), residueFourier c hc a p * + (𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p) := by + classical + let : Finite (Residue c) := finite_quotient_span hc + let : Fintype (Residue c) := Fintype.ofFinite _ + rw [actual_joint_periodic_poisson W c hc a] + have hs (r : Residue c × Residue c) : Summable (fun p : (ℤ × ℤ) × (ℤ × ℤ) => + a r * (Real.fourierChar (inner ℝ (embeddingPair (representativePair c r)) + (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)) • + (𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p))) := by + apply Summable.mul_left + apply Summable.of_norm + simpa only [Circle.norm_smul] using + jointFrequency_summable_norm W (eisEmbedding c) (eisEmbedding_ne_zero hc) + simp_rw [mul_smul_comm, ← tsum_mul_left] + rw [← Finset.smul_sum, ← Summable.tsum_finsetSum (fun r _ => hs r)] + congr 1 + apply tsum_congr + intro p + simp only [residueFourier, tsum_fintype, Circle.smul_def, smul_eq_mul, + Finset.sum_mul, mul_assoc] + +@[simp] theorem jointFrequency_zero (c : ℂ) (hc : c ≠ 0) : + jointFrequency c hc 0 = 0 := by + have h : complexPoint (0:ℝ) 0 = 0 := by apply Complex.ext <;> rfl + simp [jointFrequency, eisensteinDualFrequency, h, point] + +@[simp] theorem residueFourier_zero (c : O) (hc : c ≠ 0) + (a : Residue c × Residue c → ℂ) : + residueFourier c hc a 0 = ∑' r, a r := by + simp [residueFourier] + +theorem residueFourier_norm_le (c : O) (hc : c ≠ 0) + (a : Residue c × Residue c → ℂ) (B : ℝ) (hB : ∀ r, ‖a r‖ ≤ B) + (p : (ℤ × ℤ) × (ℤ × ℤ)) : + ‖residueFourier c hc a p‖ ≤ (Ideal.absNorm (Ideal.span {c}) : ℝ)^2 * B := by + classical + let : Finite (Residue c) := finite_quotient_span hc + let : Fintype (Residue c) := Fintype.ofFinite _ + rw [residueFourier, tsum_fintype] + calc + _ ≤ ∑ r : Residue c × Residue c, ‖a r * + (Real.fourierChar (inner ℝ (embeddingPair (representativePair c r)) + (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)) : ℂ)‖ := + norm_sum_le _ _ + _ ≤ ∑ r : Residue c × Residue c, B := by + apply Finset.sum_le_sum + intro r hr + simpa only [norm_mul, Circle.norm_coe, mul_one] using hB r + _ = _ := by + simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul, Fintype.card_prod, + Nat.cast_mul, Ideal.absNorm_apply, Submodule.cardQuot_apply, + Nat.card_eq_fintype_card, Residue, pow_two] + +theorem principal_joint_inverse_covolume (c : O) (hc : c ≠ 0) : + (2 / (Real.sqrt 3 * ‖eisEmbedding c‖^2))^2 * + (Ideal.absNorm (Ideal.span {c}) : ℝ)^2 = 4/3 := by + have hn : ‖eisEmbedding c‖ ≠ 0 := norm_ne_zero_iff.mpr (eisEmbedding_ne_zero hc) + rw [← eisEmbedding_norm_sq_eq_absNorm_span] + have hs : (Real.sqrt 3)^2 = (3:ℝ) := Real.sq_sqrt (by norm_num) + have hs0 : Real.sqrt 3 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) + field_simp + nlinarith + +theorem norm_periodic_zero_mean_le (W : 𝓢(Joint, ℂ)) (c : O) (hc : c ≠ 0) + (a : Residue c × Residue c → ℂ) (B : ℝ) (hB : ∀ r, ‖a r‖ ≤ B) + (hmean : (∑' r, a r) = 0) : + ‖∑' m : O × O, a (quotientPair c m) * W (embeddingPair m)‖ ≤ + (4/3:ℝ) * B * + ∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, + ‖(𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p.val)‖ := by + let F (p : (ℤ × ℤ) × (ℤ × ℤ)) := residueFourier c hc a p * + (𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p) + let q : ℝ := Ideal.absNorm (Ideal.span {c}) + have hF0 : F 0 = 0 := by simp [F, hmean] + have hnorm (p : (ℤ × ℤ) × (ℤ × ℤ)) : ‖F p‖ ≤ q^2 * B * + ‖(𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)‖ := by + dsimp only [F] + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (residueFourier_norm_le c hc a B hB p) (norm_nonneg _) + have hsF : Summable (fun p => ‖F p‖) := + Summable.of_nonneg_of_le (fun _ => norm_nonneg _) hnorm + ((jointFrequency_summable_norm W (eisEmbedding c) (eisEmbedding_ne_zero hc)).mul_left _) + have heq : (∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, F p.val) = ∑' p, F p := by + apply tsum_subtype_eq_of_support_subset + intro p hp + change F p ≠ 0 at hp + exact fun h => hp (h ▸ hF0) + have hb : ‖∑' p, F p‖ ≤ q^2 * B * + ∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, + ‖(𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p.val)‖ := by + rw [← heq] + have hs1 : Summable (fun p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0} => ‖F p.val‖) := + hsF.subtype (fun p => p ≠ 0) + have hm : Summable (fun p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0} => + ‖(𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p.val)‖) := + (jointFrequency_summable_norm W (eisEmbedding c) + (eisEmbedding_ne_zero hc)).subtype (fun p => p ≠ 0) + have ht : (∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, ‖F p.val‖) ≤ + ∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, q^2 * B * + ‖(𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p.val)‖ := + Summable.tsum_le_tsum (fun p => hnorm p.val) hs1 (hm.mul_left (q^2*B)) + exact (norm_tsum_le_tsum_norm hs1).trans (by simpa only [tsum_mul_left] using ht) + rw [actual_joint_periodic_fourier W c hc a, norm_smul, Real.norm_eq_abs, + abs_of_nonneg (sq_nonneg _)] + calc + _ ≤ (2/(Real.sqrt 3*‖eisEmbedding c‖^2))^2 * (q^2 * B * + ∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, + ‖(𝓕 W) (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p.val)‖) := + mul_le_mul_of_nonneg_left hb (sq_nonneg _) + _ = _ := by + rw [← mul_assoc, ← mul_assoc, principal_joint_inverse_covolume c hc] + +def scaleMap (t : ℝ) (ht : 0 < t) : Joint ≃L[ℝ] Joint := + blockMap (complexMulEquiv ((t⁻¹:ℝ):ℂ) + (Complex.ofReal_ne_zero.mpr (inv_ne_zero ht.ne'))) + +@[simp] theorem scaleMap_apply (t : ℝ) (ht : 0 < t) (z : Joint) : + scaleMap t ht z = t⁻¹ • z := by + apply WithLp.ofLp_injective + apply Prod.ext <;> simp [scaleMap, blockMap_apply, complexMulEquiv_apply, point, Algebra.smul_def] + +theorem scaleMap_dual (t : ℝ) (ht : 0 < t) (z : Joint) : + jointDual (scaleMap t ht) z = t • z := by + have hz : z = point z.fst z.snd := rfl + conv_lhs => rw [hz] + rw [scaleMap, jointDual_blockMap, dual_mul_apply, dual_mul_apply] + apply WithLp.ofLp_injective + apply Prod.ext <;> simp [point, Algebra.smul_def] + +theorem scaleMap_inverseJacobian (t : ℝ) (ht : 0 < t) : + jointInverseJacobian (scaleMap t ht) = t^4 := by + rw [scaleMap, jointInverseJacobian_blockMap, inverseJacobian, complexMulEquiv_det, + abs_inv, abs_of_nonneg (Complex.normSq_nonneg _), Complex.normSq_eq_norm_sq] + simp only [Complex.norm_real, Real.norm_eq_abs, abs_inv, abs_of_pos ht, ← inv_pow, inv_inv] + ring + +def scaledSource (W : 𝓢(Joint, ℂ)) (t : ℝ) (ht : 0 < t) : 𝓢(Joint, ℂ) := + jointAffine W (scaleMap t ht) 0 + +@[simp] theorem scaledSource_apply (W : 𝓢(Joint, ℂ)) (t : ℝ) (ht : 0 < t) (z : Joint) : + scaledSource W t ht z = W (t⁻¹ • z) := by + simp [scaledSource] + +theorem fourier_scaledSource (W : 𝓢(Joint, ℂ)) (t : ℝ) (ht : 0 < t) (z : Joint) : + (𝓕 (scaledSource W t ht)) z = t^4 • (𝓕 W) (t • z) := by + rw [scaledSource, joint_fourier_affine, scaleMap_inverseJacobian, scaleMap_dual] + simp + +theorem scaledSource_physicalPoint (W : 𝓢(Joint, ℂ)) (N : ℝ) (hN : 0 < N) (m : O × O) : + scaledSource W (Real.sqrt N) (Real.sqrt_pos.mpr hN) (embeddingPair m) = + W (ProbeGramLatticeDecay.physicalPoint N m) := by + rw [scaledSource_apply, ProbeGramLatticeDecay.physicalPoint_eq_smul] + rfl + +def generatorRotation (c : ℂ) : ℂ := (‖c‖:ℂ) / starRingEnd ℂ c + +theorem norm_generatorRotation (c : ℂ) (hc : c ≠ 0) : ‖generatorRotation c‖ = 1 := by + simp [generatorRotation, Complex.norm_real, norm_ne_zero_iff.mpr hc] + +theorem scaled_jointFrequency_eq (c : ℂ) (hc : c ≠ 0) (N : ℝ) (hN : 0 < N) + (p : (ℤ × ℤ) × (ℤ × ℤ)) : + Real.sqrt N • jointFrequency c hc p = + ProbeGramLatticeDecay.scaledDualPoint (Real.sqrt (N/‖c‖^2)) (generatorRotation c) p := by + have hn : ‖c‖ ≠ 0 := norm_ne_zero_iff.mpr hc + have hs : Real.sqrt (N/‖c‖^2) = Real.sqrt N / ‖c‖ := by + rw [Real.sqrt_div hN.le, Real.sqrt_sq (norm_nonneg c)] + have hcoord (v : ℤ × ℤ) : (Real.sqrt N:ℂ) * eisensteinDualFrequency c hc v = + generatorRotation c * (Real.sqrt (N/‖c‖^2):ℂ) * explicitDualFrequency 1 v := by + rw [eisensteinDualFrequency_explicit, hs] + simp only [generatorRotation, explicitDualFrequency, map_one, div_one, Complex.ofReal_div] + have hnC : (‖c‖:ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hn + field_simp + apply WithLp.ofLp_injective + change (Real.sqrt N • eisensteinDualFrequency c hc p.1, + Real.sqrt N • eisensteinDualFrequency c hc p.2) = _ + apply Prod.ext + · simpa [Algebra.smul_def, ProbeGramLatticeDecay.scaledDualPoint, ProbeGramLatticeDecay.point] using hcoord p.1 + · simpa [Algebra.smul_def, ProbeGramLatticeDecay.scaledDualPoint, ProbeGramLatticeDecay.point] using hcoord p.2 + +theorem sqrt_ratio_decay (N q : ℝ) (hN : 0 < N) (hq : 0 < q) (A : ℕ) : + (Real.sqrt (N/q))^(-((2*A:ℕ):ℝ)) = (q/N)^A := by + rw [Real.rpow_neg (Real.sqrt_nonneg _), Real.rpow_natCast, pow_mul, + Real.sq_sqrt (div_nonneg hN.le hq.le), ← inv_pow, inv_div] + +theorem physical_weighted_summable (W : 𝓢(Joint, ℂ)) (N : ℝ) (hN : 0 < N) + (d : O × O → ℂ) (B : ℝ) (hB : ∀ m, ‖d m‖ ≤ B) : + Summable (fun m : O × O => d m * W (ProbeGramLatticeDecay.physicalPoint N m)) := by + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ + ((ProbeGramLatticeDecay.physical_summable W N hN).mul_left B) + intro m + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (hB m) (norm_nonneg _) + +theorem principal_high_bound (A : ℕ) (hA : 2 < A) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)) (c : O) (_hc : c ≠ 0) + (a : Residue c × Residue c → ℂ) (B : ℝ), 0 ≤ B → + (∀ r, ‖a r‖ ≤ B) → (∑' r, a r) = 0 → + ∀ (N : ℝ), 0 < N → (Ideal.absNorm (Ideal.span {c}) : ℝ) ≤ N → + ‖∑' m : O × O, a (quotientPair c m) * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + C * ProbeGramLatticeDecay.sourceControl S W * B * N^2 * + ((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A := by + obtain ⟨S,C,hC,hhigh⟩ := ProbeGramLatticeDecay.dual_fourier_lattice_bound A hA + refine ⟨S,(4/3)*C,mul_pos (by norm_num) hC,?_⟩ + intro W c hc a B hB0 hB hmean N hN hscale + let q : ℝ := Ideal.absNorm (Ideal.span {c}) + have hq : 0 < q := by + dsimp only [q] + rw [← eisEmbedding_norm_sq_eq_absNorm_span] + exact sq_pos_of_pos (norm_pos_iff.mpr (eisEmbedding_ne_zero hc)) + have hL : 1 ≤ Real.sqrt (N/q) := by + apply Real.le_sqrt_of_sq_le + norm_num only [one_pow] + exact (le_div_iff₀ hq).mpr (by simpa only [one_mul] using hscale) + let u : ℂ := generatorRotation (eisEmbedding c) + have hu : ‖u‖ = 1 := norm_generatorRotation _ (eisEmbedding_ne_zero hc) + have ht4 : (Real.sqrt N)^4 = N^2 := by + rw [show (4:ℕ) = 2*2 by norm_num, pow_mul, Real.sq_sqrt hN.le] + have hf (p : (ℤ × ℤ) × (ℤ × ℤ)) : + ‖(𝓕 (scaledSource W (Real.sqrt N) (Real.sqrt_pos.mpr hN))) + (jointFrequency (eisEmbedding c) (eisEmbedding_ne_zero hc) p)‖ = + N^2 * ‖(𝓕 W) (ProbeGramLatticeDecay.scaledDualPoint (Real.sqrt (N/q)) u p)‖ := by + rw [fourier_scaledSource, norm_smul, Real.norm_eq_abs, + abs_of_nonneg (pow_nonneg (Real.sqrt_nonneg _) _), ht4, + scaled_jointFrequency_eq _ _ N hN] + rw [eisEmbedding_norm_sq_eq_absNorm_span] + have h := norm_periodic_zero_mean_le + (scaledSource W (Real.sqrt N) (Real.sqrt_pos.mpr hN)) c hc a B hB hmean + simp_rw [scaledSource_physicalPoint W N hN, hf, tsum_mul_left] at h + have hD := hhigh W (Real.sqrt (N/q)) hL u hu + rw [sqrt_ratio_decay N q hN hq A] at hD + calc + _ ≤ (4/3:ℝ)*B*(N^2 * + ∑' p : {p : (ℤ × ℤ) × (ℤ × ℤ) // p ≠ 0}, + ‖(𝓕 W) (ProbeGramLatticeDecay.scaledDualPoint (Real.sqrt (N/q)) u p.val)‖) := h + _ ≤ (4/3:ℝ)*B*(N^2 * + (C * ProbeGramLatticeDecay.sourceControl S W * (q/N)^A)) := by + gcongr + _ = _ := by ring + +theorem norm_physical_weighted_le (W : 𝓢(Joint, ℂ)) (N : ℝ) (hN : 0 < N) + (d : O × O → ℂ) (B : ℝ) (hB : ∀ m, ‖d m‖ ≤ B) : + ‖∑' m : O × O, d m * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + B * ∑' m : O × O, ‖W (ProbeGramLatticeDecay.physicalPoint N m)‖ := by + have hbound (m : O × O) : ‖d m * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + B * ‖W (ProbeGramLatticeDecay.physicalPoint N m)‖ := by + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (hB m) (norm_nonneg _) + have hs := ProbeGramLatticeDecay.physical_summable W N hN + have hsD := Summable.of_nonneg_of_le (fun m => norm_nonneg _) hbound (hs.mul_left B) + apply (norm_tsum_le_tsum_norm hsD).trans + have h := Summable.tsum_le_tsum hbound hsD (hs.mul_left B) + simpa only [tsum_mul_left] using h + +theorem principal_periodic_bound (A : ℕ) (hA : 2 < A) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)) (c : O), c ≠ 0 → + ∀ (a : Residue c × Residue c → ℂ) (B : ℝ), 0 ≤ B → + (∀ r, ‖a r‖ ≤ B) → (∑' r, a r) = 0 → ∀ (N : ℝ), 1 ≤ N → + Summable (fun m : O × O => + a (quotientPair c m) * W (ProbeGramLatticeDecay.physicalPoint N m)) ∧ + ‖∑' m : O × O, a (quotientPair c m) * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + C * ProbeGramLatticeDecay.sourceControl S W * B * N^2 * + min 1 (((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A) := by + obtain ⟨Sl,Cl,hCl,hl⟩ := ProbeGramLatticeDecay.physical_lattice_bound + obtain ⟨Sh,Ch,hCh,hh⟩ := principal_high_bound A hA + refine ⟨Sl∪Sh,Cl+Ch,add_pos hCl hCh,?_⟩ + intro W c hc a B hB0 hB hm N hN + have hNp : 0 < N := lt_of_lt_of_le zero_lt_one hN + refine ⟨physical_weighted_summable W N hNp _ B (fun m => hB _),?_⟩ + have hSl : Cl*ProbeGramLatticeDecay.sourceControl Sl W ≤ + (Cl+Ch)*ProbeGramLatticeDecay.sourceControl (Sl∪Sh) W := + mul_le_mul (le_add_of_nonneg_right hCh.le) + (ProbeGramLatticeDecay.sourceControl_mono Finset.subset_union_left W) + (ProbeGramLatticeDecay.sourceControl_nonneg _ _) (by positivity) + have hSh : Ch*ProbeGramLatticeDecay.sourceControl Sh W ≤ + (Cl+Ch)*ProbeGramLatticeDecay.sourceControl (Sl∪Sh) W := + mul_le_mul (le_add_of_nonneg_left hCl.le) + (ProbeGramLatticeDecay.sourceControl_mono Finset.subset_union_right W) + (ProbeGramLatticeDecay.sourceControl_nonneg _ _) (by positivity) + have hratio : 0 ≤ (Ideal.absNorm (Ideal.span {c}) : ℝ)/N := div_nonneg (by positivity) hNp.le + by_cases hscale : (Ideal.absNorm (Ideal.span {c}) : ℝ) ≤ N + · have hp : ((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A ≤ 1 := + pow_le_one₀ hratio ((div_le_one hNp).mpr hscale) + rw [min_eq_right hp] + exact (hh W c hc a B hB0 hB hm N hNp hscale).trans + (mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hSh hB0) (sq_nonneg _)) + (pow_nonneg hratio _)) + · have hp : 1 ≤ ((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A := + one_le_pow₀ ((le_div_iff₀ hNp).mpr (by linarith)) + rw [min_eq_left hp, mul_one] + calc + _ ≤ B * ∑' m : O × O, ‖W (ProbeGramLatticeDecay.physicalPoint N m)‖ := + norm_physical_weighted_le W N hNp _ B (fun m => hB _) + _ ≤ B * (Cl*ProbeGramLatticeDecay.sourceControl Sl W*N^2) := + mul_le_mul_of_nonneg_left (hl W N hN) hB0 + _ = Cl*ProbeGramLatticeDecay.sourceControl Sl W*B*N^2 := by ring + _ ≤ _ := mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hSl hB0) (sq_nonneg _) + +def idealQuotientPair (r : Ideal O) (m : O × O) : (O ⧸ r) × (O ⧸ r) := + (Ideal.Quotient.mk r m.1, Ideal.Quotient.mk r m.2) + +theorem ideal_periodic_bound (A : ℕ) (hA : 2 < A) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)) (r : Ideal O), r ≠ 0 → + ∀ (a : (O ⧸ r) × (O ⧸ r) → ℂ) (B : ℝ), 0 ≤ B → + (∀ v, ‖a v‖ ≤ B) → (∑' v, a v) = 0 → ∀ (N : ℝ), 1 ≤ N → + Summable (fun m : O × O => + a (idealQuotientPair r m) * W (ProbeGramLatticeDecay.physicalPoint N m)) ∧ + ‖∑' m : O × O, a (idealQuotientPair r m) * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + C * ProbeGramLatticeDecay.sourceControl S W * B * N^2 * + min 1 (((Ideal.absNorm r : ℝ)/N)^A) := by + obtain ⟨S,C,hC,h⟩ := principal_periodic_bound A hA + refine ⟨S,C,hC,?_⟩ + intro W r hr + obtain ⟨c,hc,heq⟩ : ∃ c : O, c ≠ 0 ∧ Ideal.span {c} = r := + ⟨ConcretePrimeRowBridge.idealGenerator r, + ConcretePrimeRowBridge.idealGenerator_ne_zero r hr, + ConcretePrimeRowBridge.span_idealGenerator r⟩ + subst r + exact h W c hc + +theorem principal_annular_periodic_bound (A : ℕ) (hA : 2 < A) + (a b : ℝ) (ha : 0 < a) (hab : a < b) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)), ProbeGramAnnularLattice.AnnularSupport a b W → + ∀ (c : O), c ≠ 0 → ∀ (d : Residue c × Residue c → ℂ) (B : ℝ), 0 ≤ B → + (∀ r, ‖d r‖ ≤ B) → (∑' r, d r) = 0 → ∀ (N : ℝ), 0 < N → + Summable (fun m : O × O => + d (quotientPair c m) * W (ProbeGramLatticeDecay.physicalPoint N m)) ∧ + ‖∑' m : O × O, d (quotientPair c m) * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + C * ProbeGramLatticeDecay.sourceControl S W * B * N^2 * + min 1 (((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A) := by + obtain ⟨Sl,Cl,hCl,hl⟩ := ProbeGramAnnularLattice.annular_weighted_lattice_bound a b ha hab + obtain ⟨Sh,Ch,hCh,hh⟩ := principal_high_bound A hA + refine ⟨Sl∪Sh,Cl+Ch,add_pos hCl hCh,?_⟩ + intro W hW c hc d B hB0 hB hm N hN + refine ⟨physical_weighted_summable W N hN _ B (fun m => hB _),?_⟩ + have hSl : Cl*ProbeGramLatticeDecay.sourceControl Sl W ≤ + (Cl+Ch)*ProbeGramLatticeDecay.sourceControl (Sl∪Sh) W := + mul_le_mul (le_add_of_nonneg_right hCh.le) + (ProbeGramLatticeDecay.sourceControl_mono Finset.subset_union_left W) + (ProbeGramLatticeDecay.sourceControl_nonneg _ _) (by positivity) + have hSh : Ch*ProbeGramLatticeDecay.sourceControl Sh W ≤ + (Cl+Ch)*ProbeGramLatticeDecay.sourceControl (Sl∪Sh) W := + mul_le_mul (le_add_of_nonneg_left hCl.le) + (ProbeGramLatticeDecay.sourceControl_mono Finset.subset_union_right W) + (ProbeGramLatticeDecay.sourceControl_nonneg _ _) (by positivity) + have hratio : 0 ≤ (Ideal.absNorm (Ideal.span {c}) : ℝ)/N := div_nonneg (by positivity) hN.le + by_cases hscale : (Ideal.absNorm (Ideal.span {c}) : ℝ) ≤ N + · have hp : ((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A ≤ 1 := + pow_le_one₀ hratio ((div_le_one hN).mpr hscale) + rw [min_eq_right hp] + exact (hh W c hc d B hB0 hB hm N hN hscale).trans + (mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hSh hB0) (sq_nonneg _)) + (pow_nonneg hratio _)) + · have hp : 1 ≤ ((Ideal.absNorm (Ideal.span {c}) : ℝ)/N)^A := + one_le_pow₀ ((le_div_iff₀ hN).mpr (by linarith)) + rw [min_eq_left hp, mul_one] + exact (hl W hW (fun m => d (quotientPair c m)) B hB0 + (fun m => hB _) N hN).2.trans + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hSl hB0) (sq_nonneg _)) + +theorem ideal_annular_periodic_bound (A : ℕ) (hA : 2 < A) + (a b : ℝ) (ha : 0 < a) (hab : a < b) : + ∃ (S : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(Joint, ℂ)), ProbeGramAnnularLattice.AnnularSupport a b W → + ∀ (r : Ideal O), r ≠ 0 → ∀ (d : (O ⧸ r) × (O ⧸ r) → ℂ) (B : ℝ), 0 ≤ B → + (∀ v, ‖d v‖ ≤ B) → (∑' v, d v) = 0 → ∀ (N : ℝ), 0 < N → + Summable (fun m : O × O => + d (idealQuotientPair r m) * W (ProbeGramLatticeDecay.physicalPoint N m)) ∧ + ‖∑' m : O × O, d (idealQuotientPair r m) * W (ProbeGramLatticeDecay.physicalPoint N m)‖ ≤ + C * ProbeGramLatticeDecay.sourceControl S W * B * N^2 * + min 1 (((Ideal.absNorm r : ℝ)/N)^A) := by + obtain ⟨S,C,hC,h⟩ := principal_annular_periodic_bound A hA a b ha hab + refine ⟨S,C,hC,?_⟩ + intro W hW r hr + obtain ⟨c,hc,heq⟩ : ∃ c : O, c ≠ 0 ∧ Ideal.span {c} = r := + ⟨ConcretePrimeRowBridge.idealGenerator r, + ConcretePrimeRowBridge.idealGenerator_ne_zero r hr, + ConcretePrimeRowBridge.span_idealGenerator r⟩ + subst r + exact h W hW c hc + +end ProbeGramPeriodicPoisson + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramPhysicalScale.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramPhysicalScale.lean new file mode 100644 index 0000000000000000000000000000000000000000..b18314c5bf921577fbf4c101d8e50eb0d4072675 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramPhysicalScale.lean @@ -0,0 +1,59 @@ +import OAI.NumberTheory.DirichletL.Detector.GramMobiusLattice +import OAI.NumberTheory.DirichletL.Detector.GramNonexceptionalBlock + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + + def residualScale (C D : SupportedIdeal) (Y : ℝ) : ℝ := + Y/((Ideal.absNorm C.val:ℝ)*Ideal.absNorm D.val) + +lemma residualScale_pos (C D : SupportedIdeal) (Y : ℝ) (hY : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +abbrev PrimaryElement := {n : O // Supported (Ideal.span {n}) ∧ λ₀^2∣n-1} + +def primaryIdealEquiv : SupportedIdeal≃PrimaryElement where + toFun I := ⟨primaryGenerator I.val,(supported_span_primaryGenerator_iff _).mpr I.property, + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ I.property)).2⟩ + invFun n := ⟨Ideal.span {n.val},n.property.1⟩ + left_inv I := Subtype.ext (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ I.property)).1 + right_inv n := Subtype.ext (primaryGenerator_span n.val (supported_element_ne_zero _ n.property.1) n.property.2) + +lemma primaryCoefficient_nonzero_supported (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (n : O) (hn : primaryCoefficient S hS σ n≠0) : + Supported (Ideal.span {n}) ∧ λ₀^2∣n-1 := by + have hp : λ₀^2∣n-1 := by + by_contra h + exact hn (by simp [primaryCoefficient,h]) + have hc : IsCoprime (calibrationForSet S hS).generator n := by + by_contra h + exact hn (by rw [primaryCoefficient,ite_eq_left hp,gramCoefficientExtension_zero S hS σ n h]) + have hb := calibration_generator_bad S hS hbad + exact ⟨supported_of_coprime_bad _ n hb.1 hb.2 hc,hp⟩ + +lemma primary_factor_right (A n : O) (hA : λ₀^2∣A-1) (hAn : λ₀^2∣A*n-1) : λ₀^2∣n-1 := by + have h := dvd_sub hAn (hA.mul_right n) + convert h using 1 ; ring + +lemma primaryCoefficient_residual (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (A n : O) (hA : λ₀^2∣A-1) + (hn : primaryCoefficient S hS σ (A*n)≠0) : + Supported (Ideal.span {n}) ∧ λ₀^2∣n-1 := by + have hs := primaryCoefficient_nonzero_supported S hS hbad σ (A*n) hn + have hsp : Supported (Ideal.span {A}*Ideal.span {n}) := by + rw [Ideal.span_singleton_mul_span_singleton] + exact hs.1 + exact ⟨((supported_mul_iff _ _).mp hsp).2,primary_factor_right A n hA hs.2⟩ + +theorem primary_ideal_tsum (f : O→ℂ) + (hz : ∀n,¬(Supported (Ideal.span {n}) ∧ λ₀^2∣n-1)→f n=0) : + (∑'I : SupportedIdeal,f (primaryGenerator I.val))=∑'n : O,f n := by + have he := primaryIdealEquiv.tsum_eq (fun n : PrimaryElement=>f n.val) + change (∑'I : SupportedIdeal,f (primaryGenerator I.val))=∑'n : PrimaryElement,f n.val at he + rw [he] + exact tsum_subtype_eq_of_support_subset (by intro n hn;by_contra h;exact hn (hz n h)) + +theorem primary_ideal_pair_tsum (f : O→O→ℂ) + (hl : ∀n m,¬(Supported (Ideal.span {n}) ∧ λ₀^2∣n-1)→f n m=0) + (hr : ∀n m,¬(Supported (Ideal.span {m}) ∧ λ₀^2∣m-1)→f n m=0) : + (∑'I : SupportedIdeal,∑'J : SupportedIdeal,f (primaryGenerator I.val) (primaryGenerator J.val))= + ∑'n : O,∑'m : O,f n m := by + have hinner (n : O) : (∑'J : SupportedIdeal,f n (primaryGenerator J.val))=∑'m : O,f n m := + primary_ideal_tsum (fun m=>f n m) (fun m h=>hr n m h) + simp_rw [hinner] + apply primary_ideal_tsum (fun n=>∑'m : O,f n m) + intro n hn + simp only [hl n _ hn,tsum_zero] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramPrimeSeparation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramPrimeSeparation.lean new file mode 100644 index 0000000000000000000000000000000000000000..a236e4ea529d91a3887b7dce1965d073ac2f905f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramPrimeSeparation.lean @@ -0,0 +1,45 @@ +import OAI.NumberTheory.DirichletL.Detector.GramJointPeriod + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma maximal_coprime_of_not_dvd (p J : Id) [p.IsMaximal] (h : ¬p∣J) : IsCoprime J p := by + rw [Ideal.isCoprime_iff_sup_eq] + by_contra htop + have he : p=J⊔p := Ideal.IsMaximal.eq_of_le inferInstance htop le_sup_right + apply h + apply Ideal.dvd_iff_le.mpr + rw [he] + exact le_sup_left + +theorem exists_prime_separation (I p : Id) (hI : I≠0) [p.IsMaximal] (hp0 : p≠0) : + ∃J : Id,I=J*p^((normalizedFactors I).count p) ∧ IsCoprime J p ∧ J≠0 := by + have hp : Prime p := Ideal.prime_of_isPrime hp0 inferInstance + obtain ⟨J,hJ,hnd⟩ := (FiniteMultiplicity.of_prime_left hp hI).exists_eq_pow_mul_and_not_dvd + have he : multiplicity p I=(normalizedFactors I).count p := by + simpa only [normalize_eq] using multiplicity_eq_count_normalizedFactors hp.irreducible hI + refine ⟨J,?_,maximal_coprime_of_not_dvd p J hnd,?_⟩ + · rw [←he,mul_comm] + exact hJ + · intro hz + rw [hz,mul_zero] at hJ + exact hI hJ + +theorem exists_nonexceptional_separation (L R I p : Id) (hI : I≠0) + [p.IsMaximal] (hp0 : p≠0) (hL : ¬p∣L) (hR : ¬p∣R) : + ∃J : Id,I=J*p^((normalizedFactors I).count p) ∧ + IsCoprime (L*R*J) (p^((normalizedFactors I).count p)) ∧ J≠0 := by + obtain ⟨J,hJ,hcop,hJ0⟩ := exists_prime_separation I p hI hp0 + exact ⟨J,hJ,((maximal_coprime_of_not_dvd p L hL).mul_left + (maximal_coprime_of_not_dvd p R hR)).mul_left hcop |>.pow_right,hJ0⟩ + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramResidue.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramResidue.lean new file mode 100644 index 0000000000000000000000000000000000000000..79cc0b871e06738049c08db5f9d3d63cdd9cba73 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramResidue.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.GramPrimeSeparation + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbeGramCommon +open CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss RayFourExpansion +open ConcretePrimeRowBridge UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +variable {ι : Type*} [Fintype ι] + +theorem exists_nonexceptional_residue (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) + (C k : O) (hC : C≠0) (hk0 : k≠0) (u : Oˣ) (a b : ℕ) (r : O) + (hr : Supported (Ideal.span {r})) (hk : k=u.val*goodLambda^a*(2:O)^b*r) + (P : ι→Id) [∀i,(P i).IsMaximal] (hg : ∀i,goodLambda∉P i) (c : ι→ℕ) + (hc : ∀i,1≤c i) (hfac : Ideal.span {C}=∏i,P i^c i) + (p : Id) [p.IsMaximal] (hp0 : p≠0) (hgp : goodLambda∉p) + (hchar : ringChar (O⧸p)≠2) (hfixed : ¬p∣jointFixedModulus S hS) (hcommon : ¬p∣∏i,P i) + (he : ¬6∣(normalizedFactors (Ideal.span {r})).count p) : + ∃(M : Id)(hM : M≠0), + Ideal.absNorm M≤Ideal.absNorm (jointFixedModulus S hS)* + Ideal.absNorm (Ideal.span {C})*Ideal.absNorm (Ideal.span {k}) ∧ + letI : Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient hM + letI : Fintype (O⧸M):=Fintype.ofFinite _ + ∀d : O,∃A : (O⧸M)→(O⧸M)→ℂ, + (∀n₁ n₂,A (Ideal.Quotient.mk M n₁) (Ideal.Quotient.mk M n₂)= + jointExtension S hS σ C k u a b r hr P hg c (d*n₁) (d*n₂)) ∧ + (∀x y,‖A x y‖≤Ideal.absNorm (Ideal.span {C})) ∧ + (∑x,∑y,A x y)=0 := by + obtain ⟨J,hJ,hcop,hJ0⟩ := exists_nonexceptional_separation (jointFixedModulus S hS) + (∏i,P i) (Ideal.span {r}) p hr.1 hp0 hfixed hcommon + let e := (normalizedFactors (Ideal.span {r})).count p + let M : Id := (jointFixedModulus S hS*(∏i,P i)*J)*p^e + have hMperiod : M=jointPeriod S hS P r := by + rw [jointPeriod,hJ] + dsimp [M,e] + ring + have hM0 : M≠0 := hMperiod ▸ jointPeriod_nonzero S hS C hC P c hc hfac r + (CenteredMomentSupportedCorrelation.supported_element_ne_zero r hr) + refine ⟨M,hM0,?_,?_⟩ + · rw [hMperiod] + exact jointPeriod_norm_bound S hS C k hC hk0 u a b r hk P c hc hfac + · let : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient hM0 + let : Fintype (O⧸M) := Fintype.ofFinite _ + let : Finite (O⧸jointFixedModulus S hS*(∏i,P i)*J) := + Ring.HasFiniteQuotients.finiteQuotient (left_ne_zero_of_mul hM0) + let : Fintype (O⧸jointFixedModulus S hS*(∏i,P i)*J) := Fintype.ofFinite _ + let : Finite (O⧸p^e) := Ring.HasFiniteQuotients.finiteQuotient (pow_ne_zero _ hp0) + let : Fintype (O⧸p^e) := Fintype.ofFinite _ + intro d + let A : (O⧸M)→(O⧸M)→ℂ := fun x y=> + jointExtension S hS σ C k u a b r hr P hg c (d*x.out) (d*y.out) + refine ⟨A,?_,?_,?_⟩ + · intro n₁ n₂ + apply jointExtension_dilation_periodic + · rw [←hMperiod] + exact Ideal.Quotient.eq.mp (Ideal.Quotient.mk_out (Ideal.Quotient.mk M n₁)) + · rw [←hMperiod] + exact Ideal.Quotient.eq.mp (Ideal.Quotient.mk_out (Ideal.Quotient.mk M n₂)) + · intro x y + rw [hfac] + exact jointExtension_norm S hS σ C k u a b r hr P hg c hc _ _ + · exact jointExtension_mean_zero S hS σ C k u a b r hr P hg c J p hgp hchar e he hJ hcop d + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramScaleLoss.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramScaleLoss.lean new file mode 100644 index 0000000000000000000000000000000000000000..fc93106b16cc2ec84d98ee92747fd839b22e614c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramScaleLoss.lean @@ -0,0 +1,39 @@ +import OAI.NumberTheory.DirichletL.Detector.GramInfiniteEstimate + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeGramCommon + +lemma nonexceptional_scale_identity (M P Y δ : ℝ) (hM : 0 lhs;rw [←Real.rpow_one P] + rw [←Real.rpow_add hP] + congr 1 + ring + calc + _=M^(1-δ)*(P*P^(-(-1+δ)))*Y^(-1+δ) := by rw [show -(-1+δ)=1-δ by ring];ring + _=_ := by rw [he] + +lemma nonexceptional_scale_loss (M P Y δ : ℝ) (hM : 1≤M) (hP : 1≤P) (hY : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma jointProfile_physicalPoint (W : ℝ→ℂ) (U : SchwartzMap ℝ ℂ) + (a b : ℝ) (ha : 0jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + shellProfile W v U T (‖eisEmbedding m.1‖^2/N) (‖eisEmbedding m.2‖^2/N)) ∧ + ‖∑'m : O×O,jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + shellProfile W v U T (‖eisEmbedding m.1‖^2/N) (‖eisEmbedding m.2‖^2/N)‖≤ + K*H.sup (schwartzSeminormFamily ℝ ℝ ℂ) U*(1+|v|)^J/(1+T)^B* + (Ideal.absNorm (Ideal.span {C}):ℝ)*N^2* + min 1 (((Ideal.absNorm (jointFixedModulus S hS):ℝ)*Ideal.absNorm (Ideal.span {C})* + Ideal.absNorm (Ideal.span {k})/N)^A) := by + obtain ⟨H₀,K₀,hK₀,hblock⟩ := literal_nonexceptional_block A hA a₀ b₀ ha₀ hab + obtain ⟨J,H,hprofile⟩ := ProbeGramJointProfile.jointProfile_uniform_degree a₀ b₀ ha₀ hab B H₀ + refine ⟨J,H,?_⟩ + intro W hs hW + obtain ⟨K₁,hK₁,hprofile⟩ := hprofile W hs hW + refine ⟨K₀*K₁,mul_pos hK₀ hK₁,?_⟩ + intro ι inst S hS σ C k hC hk0 u a b r hr hk P hmax hg c hc hfac p hpmax hp0 hgp hchar hfixed hcommon he U v T hT d N hN + let V := ProbeGramJointConstruction.jointProfile W U a₀ b₀ ha₀ hab hs hW v T hT + have hv := ProbeGramJointConstruction.jointProfile_annularSupport W U a₀ b₀ ha₀ hab hs hW v T hT + have hb := hblock S hS σ C k hC hk0 u a b r hr hk P hg c hc hfac p hp0 hgp hchar hfixed hcommon he V hv d N hN + have hfun : (fun m : O×O=>jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + V (ProbeGramLatticeDecay.physicalPoint N m))= + (fun m : O×O=>jointExtension S hS σ C k u a b r hr P hg c (d*m.1) (d*m.2)* + shellProfile W v U T (‖eisEmbedding m.1‖^2/N) (‖eisEmbedding m.2‖^2/N)) := by + funext m + rw [jointProfile_physicalPoint W U a₀ b₀ ha₀ hab hs hW v T hT N hN m] + rw [hfun] at hb + refine ⟨hb.1,hb.2.trans ?_⟩ + have hm : 0≤min (1:ℝ) (((Ideal.absNorm (jointFixedModulus S hS):ℝ)*Ideal.absNorm (Ideal.span {C})* + Ideal.absNorm (Ideal.span {k})/N)^A) := by positivity + have hh := mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left (hprofile U v T hT) hK₀.le) + (Nat.cast_nonneg (Ideal.absNorm (Ideal.span {C})))) (sq_nonneg N)) hm + convert hh using 1 ; ring + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramSourceDivisors.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramSourceDivisors.lean new file mode 100644 index 0000000000000000000000000000000000000000..9a831838747f7597558b3949bce16f95e3d25078 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramSourceDivisors.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCommonEnergy +import OAI.NumberTheory.DirichletL.Detector.GramIdealMass + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion ConcreteTraceCRT +open CenteredMomentMobiusRegroup UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def sourceDivisors (W : ℝ→ℂ) (hW : HasCompactSupport W) (Y : ℝ) (hY : 0D.val) + · intro D hD;exact (sourceDivisors_mem W hW Y hY C D).mp hD + · intro D hD E hE h;exact Subtype.val_injective h + · intro D hD + refine ⟨⟨D,divisorPool_supported _ _ hD⟩,?_,rfl⟩ + exact (sourceDivisors_mem W hW Y hY C _).mpr hD + · intro D hD;rfl + +lemma sourceMobiusWeight_rectangle (F : Finset SupportedIdeal) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (Y : ℝ) (hY : 0Finset.mem_biUnion.mpr ⟨C,hC,hD⟩) (by intro D hD hn;simp only [sourceMobiusWeight,ite_eq_right hn,zero_mul])] + exact Finset.sum_congr rfl (fun D hD=>by rw [sourceMobiusWeight,ite_eq_left hD]) + +theorem originalCommonBlock_eq_rectangle (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (F : Finset SupportedIdeal) (C : SupportedIdeal) (hC : C∈F) + (k : GramFrequency) (W : ℝ→ℂ) (hW : HasCompactSupport W) (Y Q : ℝ) (hY : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem original_source_truncation_bound (δ ε : ℝ) (hδ : 0<δ) (hδ1 : δ<1) + (hε : 0<ε) (hε1 : ε<1/6) (a b M₀ : ℝ) (ha : 0sourceMobiusWeight_norm W hcompact Y hY C D + have hg := hgood S hS σ F G (fun C _=>nonexceptionalFrequencies S hS E C) + (sourceMobiusWeight W hcompact Y hY) hα + (by intro C hC D hD k hk;exact (Finset.mem_filter.mp hk).2) + U v (Y^2/Q) Y Q (by positivity) hY hQ.le + have hb := hbadbound W hcompact hs hWM S hS σ F G (fun C _=>exceptionalFrequencies S hS E C) + (sourceMobiusWeight W hcompact Y hY) hα + (by intro C hC D hD k hk;exact (Finset.mem_filter.mp hk).2) + U v (Y^2/Q) Y Q (by positivity) hY hQ.le + rw [sourceTruncation_eq_canonical S hS hbad σ F E W hcompact Y Q hY hQ U v,sourceCanonicalSum_split] + exact (norm_add_le _ _).trans ((add_le_add hb hg).trans_eq (add_comm _ _)) + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramTruncation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramTruncation.lean new file mode 100644 index 0000000000000000000000000000000000000000..a635986c80fbc985fffcdb74bf4fe92b5576524e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramTruncation.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Detector.GramSourceDivisors + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def sourceTruncation (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (F : Finset SupportedIdeal) (E : Finset GramFrequency) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (Y Q : ℝ) (hY : 0E) W hW Y Q hY U v := by + unfold sourceTruncation sourceCanonicalSum + congr 1 + apply Finset.sum_congr rfl + intro C hC + simp_rw [originalCommonBlock_eq_rectangle S hS hbad σ F C hC _ W hW Y Q hY hQ U v] + rw [Finset.sum_comm] + exact Finset.sum_congr rfl (fun D hD=>(Finset.mul_sum ..).symm) + +def exceptionalFrequencies (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (E : Finset GramFrequency) (C : SupportedIdeal) : Finset GramFrequency := + E.filter (ExceptionalFrequency S hS C) +def nonexceptionalFrequencies (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (E : Finset GramFrequency) (C : SupportedIdeal) : Finset GramFrequency := + E.filter (fun k=>¬ExceptionalFrequency S hS C k) + +lemma sourceCanonicalSum_split (S : Finset Id) (hS : ∀p∈S,p.IsMaximal) (σ : RayRing) + (F : Finset SupportedIdeal) (E : Finset GramFrequency) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (Y Q : ℝ) (hY : 0E) W hW Y Q hY U v= + sourceCanonicalSum S hS σ F (exceptionalFrequencies S hS E) W hW Y Q hY U v+ + sourceCanonicalSum S hS σ F (nonexceptionalFrequencies S hS E) W hW Y Q hY U v := by + unfold sourceCanonicalSum exceptionalFrequencies nonexceptionalFrequencies + rw [←mul_add,←Finset.sum_add_distrib] + congr 1 + apply Finset.sum_congr rfl + intro C hC + rw [←Finset.sum_add_distrib] + apply Finset.sum_congr rfl + intro D hD + rw [←mul_add,Finset.sum_filter_add_sum_filter_not] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/GramWeightedFrequency.lean b/lean/OAI/NumberTheory/DirichletL/Detector/GramWeightedFrequency.lean new file mode 100644 index 0000000000000000000000000000000000000000..6a247ef9e4a2ff2aed2c9df68b78209f5071cc7a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/GramWeightedFrequency.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.GramCanonicalBlock + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff +namespace SevenEighths.ProbeGramCommon +open ProbePhysical CanonicalQuadraticSieve CompletedGauss RayFourExpansion ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma min_product_amplification (L T : ℝ) (hL : 0≤L) (hT : 0≤T) (A : ℕ) : + min 1 ((L*T)^A)≤(1+T)^A*min 1 (L^A) := by + by_cases h : L^A≤1 + · rw [min_eq_right h] + apply (min_le_right _ _).trans + rw [mul_pow,mul_comm] + exact mul_le_mul_of_nonneg_right (pow_le_pow_left₀ hT (by linarith) _) (pow_nonneg hL _) + · rw [min_eq_left (le_of_not_ge h),mul_one] + exact (min_le_left _ _).trans (one_le_pow₀ (by linarith)) + +lemma frequencyScale_ratio (C : SupportedIdeal) (k : GramFrequency) (Y Q : ℝ) : + frequencyScale C k.val Y Q=(Ideal.absNorm (Ideal.span {k.val}):ℝ)/((Y^2/Q)/Ideal.absNorm C.val) := by + rw [frequencyScale,ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span,div_div_eq_mul_div] + simp only [div_eq_mul_inv,mul_inv_rev,inv_inv] + ring + +theorem canonical_nonexceptional_weighted (A : ℕ) (hA : 2 ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable {ι : Type*} [Fintype ι] + +lemma primary_norm (I : SupportedIdeal) : + ‖eisEmbedding (primaryGenerator I.val)‖^2=(Ideal.absNorm I.val:ℝ) := by + rw [ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span, + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ I.property)).1] + +lemma shell_dilated_column (D I : SupportedIdeal) (N : ℝ) : + (Ideal.absNorm (supportedIdealProduct D I).val:ℝ)/N= + ‖eisEmbedding (primaryGenerator I.val)‖^2/(N/Ideal.absNorm D.val) := by + rw [primary_norm,supported_dilation_norm,Nat.cast_mul] + rw [div_div_eq_mul_div] + ring + +lemma shell_window_support (W : ℝ→ℂ) (hW : HasCompactSupport W) (N : ℝ) (hN : 0jointExtension S hS σ C k u a b r hr P hg c + (primaryGenerator I.val) (primaryGenerator J.val)* + shellProfile W v U T ((Ideal.absNorm I.val:ℝ)/N) ((Ideal.absNorm J.val:ℝ)/N) + have hf : ∀I J,I∉F ∨ J∉F→f I J=0 := by + intro I J h + dsimp [f] + rw [shell_window_support W hW N hN U v T I J h,mul_zero] + change (∑I∈F,∑J∈F,if IsCoprime I.val J.val then f I J else 0)=_ + rw [finite_pair_mobius_dilation F F f hf] + apply Finset.sum_congr rfl + intro D hD + congr 1 + let D₀ := poolDivisor F D + have hd : D₀.val=D := poolDivisor_val F D hD + have hdp : λ₀^2∣primaryGenerator D₀.val-1 := + (primaryGenerator_spec _ (supported_primaryGenerator_ne_zero _ D₀.property)).2 + have he := jointExtension_ideal_lattice S hS hbad σ C k (primaryGenerator D₀.val) + (primary_product C _ hC hdp) u a b r hr P hg c + (fun n m=>shellProfile W v U T (‖eisEmbedding n‖^2/(N/Ideal.absNorm D₀.val)) + (‖eisEmbedding m‖^2/(N/Ideal.absNorm D₀.val))) + dsimp only [f] + simp only [supported_dilation_generator,shell_dilated_column] + convert he using 1 + rw [hd] + +end SevenEighths.ProbeGramCommon +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighAbsolute.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighAbsolute.lean new file mode 100644 index 0000000000000000000000000000000000000000..c50af4462b822f091cc5ddfad1b097142d371499 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighAbsolute.lean @@ -0,0 +1,82 @@ +import OAI.NumberTheory.DirichletL.Detector.HighDeletion + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CubicEisenstein ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +abbrev NonzeroFrequency := {u : O // u≠0} + +def frequencyWeight (z : ℂ) (u : NonzeroFrequency) : ℂ := (elementNorm u.val:ℂ)^(-z) + +lemma frequencyWeight_norm (z : ℂ) (u : NonzeroFrequency) : + ‖frequencyWeight z u‖=‖eisEmbedding u.val‖^(-2*z.re) := by + have hn : 0<‖eisEmbedding u.val‖ := norm_pos_iff.mpr (eisEmbedding_ne_zero u.property) + unfold frequencyWeight elementNorm + have hN : (Ideal.absNorm (Ideal.span {u.val}):ℝ)=‖eisEmbedding u.val‖^2 := + (eisEmbedding_norm_sq_eq_absNorm_span u.val).symm + rw [hN, + Complex.norm_cpow_eq_rpow_re_of_pos (sq_pos_of_pos hn), Complex.neg_re, + ← Real.rpow_natCast_mul hn.le 2] + congr 1 + ring + +theorem frequencyWeight_summable_norm (z : ℂ) (hz : 1 ‖frequencyWeight z u‖) := by + simp only [frequencyWeight_norm] + exact (summable_embedding_rpow (-2*z.re) (by linarith)).subtype _ + +def highAbsoluteMajorant (x w z : ℂ) (p : (Id×Id)×(Id×Id)) : ℝ := + ‖fullIdealWeight (x-1/2) p.1.1‖ * ‖fullIdealWeight (3*x-2) p.1.2‖ * + ‖fullIdealWeight (w-1) p.2.1‖ * ‖fullIdealWeight (6*z) p.2.2‖ + +lemma highAbsoluteMajorant_nonneg (x w z : ℂ) (p : (Id×Id)×(Id×Id)) : + 0≤highAbsoluteMajorant x w z p := by unfold highAbsoluteMajorant; positivity + +lemma highAbsoluteMajorant_summable (x w z : ℂ) + (hx : 3/2norm_nonneg _) (fun _=>norm_nonneg _) + have h34 := h3.mul_of_nonneg h4 (fun _=>norm_nonneg _) (fun _=>norm_nonneg _) + have hall := h12.mul_of_nonneg h34 + (fun _=>mul_nonneg (norm_nonneg _) (norm_nonneg _)) + (fun _=>mul_nonneg (norm_nonneg _) (norm_nonneg _)) + unfold highAbsoluteMajorant + simpa only [mul_assoc] using hall + +theorem fullHighSummand_summable (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (x w z : ℂ) (hx : 3/2 + mask p.1 * frequencyWeight z p.1 * + markedIdealHighSummand S D η p.1.val x w z p.2.1.1 p.2.1.2 p.2.2.1 p.2.2.2) := by + have hm := (frequencyWeight_summable_norm z hz).mul_of_nonneg + (highAbsoluteMajorant_summable x w z hx hw (by linarith)) + (fun _=>norm_nonneg _) (highAbsoluteMajorant_nonneg x w z) + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun _=>norm_nonneg _) _ hm + intro p + rw [norm_mul,norm_mul] + have hcoeff := (markedIdealHighSummand_norm_le S D η p.1.val x w z + p.2.1.1 p.2.1.2 p.2.2.1 p.2.2.2).trans + (bareIdealHighSummand_norm_le η p.1.val x w z p.2.1.1 p.2.1.2 p.2.2.1 p.2.2.2) + change _≤‖frequencyWeight z p.1‖*highAbsoluteMajorant x w z p.2 + calc + _ ≤ (1*‖frequencyWeight z p.1‖)*highAbsoluteMajorant x w z p.2 := by + apply mul_le_mul + · exact mul_le_mul_of_nonneg_right (hmask p.1) (norm_nonneg _) + · exact hcoeff + · exact norm_nonneg _ + · positivity + _ = _ := by rw [one_mul] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighDeletion.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighDeletion.lean new file mode 100644 index 0000000000000000000000000000000000000000..60c5f2c4a3d230a83ea5d3ef55a91818904668b0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighDeletion.lean @@ -0,0 +1,49 @@ +import OAI.NumberTheory.DirichletL.Detector.HighSeries + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss ProbeCompleted +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def highIdealMask (S : Finset Id) (D I J K L : Id) : ℂ := + completedMask S D I J * + (if ∀ P∈S,¬P∣K then 1 else 0) * (if ∀ P∈S,¬P∣L then 1 else 0) + +lemma highIdealMask_norm_le_one (S : Finset Id) (D I J K L : Id) : + ‖highIdealMask S D I J K L‖≤1 := by + unfold highIdealMask + split_ifs <;> simp only [mul_one,mul_zero,norm_zero] + · exact completedMask_norm_le_one S D I J + all_goals norm_num + +def markedIdealHighSummand (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) (I J K L : Id) : ℂ := + highIdealMask S D I J K L * bareIdealHighSummand η u x w z I J K L + +lemma markedIdealHighSummand_norm_le (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) (I J K L : Id) : + ‖markedIdealHighSummand S D η u x w z I J K L‖≤‖bareIdealHighSummand η u x w z I J K L‖ := by + rw [markedIdealHighSummand,norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (highIdealMask_norm_le_one S D I J K L) + +theorem markedIdealHighSummand_summable (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) (hx : 3/2 + markedIdealHighSummand S D η u x w z p.1.1 p.1.2 p.2.1 p.2.2) := by + apply Summable.of_norm + exact Summable.of_nonneg_of_le (fun _=>norm_nonneg _) + (fun p=>markedIdealHighSummand_norm_le S D η u x w z p.1.1 p.1.2 p.2.1 p.2.2) + (bareIdealHighSummand_summable η u x w z hx hw hz).norm + +def markedIdealHighSeries (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) : ℂ := + ∑' p : (Id×Id)×(Id×Id), markedIdealHighSummand S D η u x w z p.1.1 p.1.2 p.2.1 p.2.2 + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighEuler.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..26156f807f4528349996635e82f54682cfd7ab24 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighEuler.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Detector.HighValuations +import OAI.NumberTheory.DirichletL.Detector.EulerFinsupp +import OAI.NumberTheory.DirichletL.Detector.IdealLocalEuler + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma bareIdealHighSummand_support (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (I J K L : Id) (h : bareIdealHighSummand η u x w z I J K L≠0) : + highSupport I J K L := by + by_contra hn + apply h + unfold highSupport at hn + simp only [bareIdealHighSummand,bareIdealHighCoefficient,dite_eq_right hn,zero_mul] + +theorem highValuationTerm_tsum_eq (η : HeckeFamily.Character) (x w z : ℂ) : + (∑'v : PrimeIdeal→₀HighValuation,highValuationTerm η x w z v)= + bareIdealHighSeries η 1 x w z := by + unfold highValuationTerm bareIdealHighSeries + apply highIdeals_injective.tsum_eq (f:=fun a : HighIdeal=> + bareIdealHighSummand η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2) + intro a ha + have hs := bareIdealHighSummand_support η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2 ha + let b : (NonzeroIdeal×NonzeroIdeal)×(NonzeroIdeal×NonzeroIdeal) := + ((⟨a.1.1,hs.2.1.1⟩,⟨a.1.2,hs.2.2.1.1⟩), + (⟨a.2.1,hs.2.2.2.1.1⟩,⟨a.2.2,hs.2.2.2.2.1⟩)) + refine ⟨highValuationEquiv b,?_⟩ + rw [highIdeals_eq_equiv,highValuationEquiv.symm_apply_apply] + +theorem bareIdealHighSeries_hasProd (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2∑' b : HighValuation,highPrimeTerm η x w z P b) + (bareIdealHighSeries η 1 x w z) := by + have hs := highValuationTerm_summable_norm η x w z hx hw hz + simp only [highValuationTerm_eq_prod] at hs + have he := ProbeEulerFinsupp.hasProd_of_summable (highPrimeTerm η x w z) + (highPrimeTerm_zero η x w z) hs + simpa only [←highValuationTerm_eq_prod,highValuationTerm_tsum_eq] using he + +theorem bareIdealHighSeries_eq_tprod (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma highArray_val_prod (F : HighIdeal→ℂ) (h1 : F 1=1) + (hmul : ∀ a b : HighIdeal, + IsCoprime (a.1.1*a.1.2*a.2.1*a.2.2) (b.1.1*b.1.2*b.2.1*b.2.2) → F (a*b)=F a*F b) + (v : PrimeIdeal→₀HighValuation) : + F (highIdeals v)=v.prod (fun P b=>F ((P.val^b.1.1,P.val^b.1.2),(P.val^b.2.1,P.val^b.2.2))) := by + have hzero (P : PrimeIdeal) : F ((P.val^0,P.val^0),(P.val^0,P.val^0))=1 := by + simp only [pow_zero] + change F (1 : HighIdeal)=1 + exact h1 + induction v using Finsupp.induction with + | zero => simp only [highIdeals_zero,h1,Finsupp.prod_zero_index] + | @single_add P b v hP hb ih => + have hc := prime_coprime_highIdeals P v (Finsupp.notMem_support_iff.mp hP) + have hpow : IsCoprime (P.val^b.1.1*P.val^b.1.2*P.val^b.2.1*P.val^b.2.2) + ((highIdeals v).1.1*(highIdeals v).1.2*(highIdeals v).2.1*(highIdeals v).2.2) := + ((hc.pow_left.mul_left hc.pow_left).mul_left hc.pow_left).mul_left hc.pow_left + have hd : Disjoint (Finsupp.single P b).support v.support := by + rw [Finsupp.support_single _ hb] + exact Finset.disjoint_singleton_left.mpr hP + rw [Finsupp.prod_add_index_of_disjoint hd,Finsupp.prod_single_index (hzero P),←ih, + highIdeals_add,highIdeals_single] + exact hmul _ _ hpow + +theorem highArray_hasProd (F : HighIdeal→ℂ) (h1 : F 1=1) + (hmul : ∀ a b : HighIdeal, + IsCoprime (a.1.1*a.1.2*a.2.1*a.2.2) (b.1.1*b.1.2*b.2.1*b.2.2) → F (a*b)=F a*F b) + (hzero : ∀ a : HighIdeal,F a≠0 → a.1.1≠0 ∧ a.1.2≠0 ∧ a.2.1≠0 ∧ a.2.2≠0) + (hs : Summable (fun a=>‖F a‖)) : + HasProd (fun P : PrimeIdeal=>∑' b : HighValuation, + F ((P.val^b.1.1,P.val^b.1.2),(P.val^b.2.1,P.val^b.2.2))) (∑' a,F a) := by + have hv := hs.comp_injective highIdeals_injective + have hp := highArray_val_prod F h1 hmul + simp only [Function.comp_def,hp] at hv + have hlocal (P : PrimeIdeal) : F ((P.val^0,P.val^0),(P.val^0,P.val^0))=1 := by + simp only [pow_zero] + change F (1 : HighIdeal)=1 + exact h1 + have he := ProbeEulerFinsupp.hasProd_of_summable + (fun (P : PrimeIdeal) (b : HighValuation)=>F ((P.val^b.1.1,P.val^b.1.2),(P.val^b.2.1,P.val^b.2.2))) hlocal hv + have hsum : (∑' v : PrimeIdeal→₀HighValuation,F (highIdeals v))=∑' a,F a := by + apply highIdeals_injective.tsum_eq + intro a ha + have hn := hzero a ha + let b : (NonzeroIdeal×NonzeroIdeal)×(NonzeroIdeal×NonzeroIdeal) := + ((⟨a.1.1,hn.1⟩,⟨a.1.2,hn.2.1⟩),(⟨a.2.1,hn.2.2.1⟩,⟨a.2.2,hn.2.2.2⟩)) + refine ⟨highValuationEquiv b,?_⟩ + rw [highIdeals_eq_equiv,highValuationEquiv.symm_apply_apply] + simpa only [←hp,hsum] using he + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighEulerLocal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighEulerLocal.lean new file mode 100644 index 0000000000000000000000000000000000000000..a19d82acb9bd6cc5094ec8e7dfeb002d73c02acf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighEulerLocal.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Detector.HighEuler + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion +open ConcretePrimeRowBridge ProbeEuler ProbePrimePower ProbeRow +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma highPrimeTerm_summable_norm (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2‖highPrimeTerm η x w z P b‖) := by + have hs := (highValuationTerm_summable_norm η x w z hx hw hz).comp_injective + (Finsupp.single_injective P) + simpa only [Function.comp_def,highValuationTerm_eq_prod, + Finsupp.prod_single_index (highPrimeTerm_zero η x w z P)] using hs + +lemma highPrimeTerm_zero_of_two_le (η : HeckeFamily.Character) (x w z : ℂ) + (P : PrimeIdeal) (e l k m : ℕ) (he : 2≤e) : + highPrimeTerm η x w z P ((e,l),(k,m))=0 := by + by_contra hn + have hs := bareIdealHighSummand_support η 1 x w z (P.val^e) (P.val^l) (P.val^k) (P.val^m) hn + have hc := hs.1.eq_zero_or_one_of_pow_of_not_isUnit P.property.not_isUnit + omega + +theorem highPrimeTerm_tsum_eq_localFactor (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2by + have hh : 2≤e := Nat.le_of_not_gt (by simpa only [Finset.mem_range] using he) + simp only [highPrimeTerm_zero_of_two_le η x w z P e _ _ _ hh,tsum_zero]), + ←Fin.sum_univ_eq_sum_range] + rfl + +theorem bareIdealHighSeries_hasProd_localFactor (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2idealHighLocalFactor η P.val x w z) + (bareIdealHighSeries η 1 x w z) := by + have h := bareIdealHighSeries_hasProd η x w z hx hw hz + simpa only [highPrimeTerm_tsum_eq_localFactor η x w z hx hw hz] using h + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighEulerRational.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighEulerRational.lean new file mode 100644 index 0000000000000000000000000000000000000000..4f21afa27d097f4d994875c254bcacb09824d699 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighEulerRational.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Detector.HighEulerLocal +import OAI.NumberTheory.DirichletL.Hecke.IdealBridge + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +open ProbeEuler ProbeRow ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +lemma supported_primeGenerator_prime (P : PrimeIdeal) (hs : Supported P.val) : + Prime (primaryGenerator P.val) := by + apply (Ideal.span_singleton_prime (supported_primaryGenerator_ne_zero P.val hs)).mp + rw [span_primaryGenerator_of_supported P.val hs] + exact Ideal.isPrime_of_prime P.property + +lemma targetMonoid_primaryGenerator (η : HeckeFamily.Character) (I : Ideal O) (hs : Supported I) : + targetMonoid η (primaryGenerator I)=HeckeFamily.idealCoeff η I := by + calc + _ = HeckeFamily.idealCoeff η (Ideal.span {primaryGenerator I}) := + (HeckeFamily.idealCoeff_span η (supported_primaryGenerator_ne_zero I hs)).symm + _ = _ := by rw [span_primaryGenerator_of_supported I hs] + +def idealClosedCorrection (η : HeckeFamily.Character) (P : PrimeIdeal) (x w z : ℂ) : ℂ := + unramifiedClosed (Ideal.absNorm P.val) (actualAPhase η (primaryGenerator P.val)) + (HeckeFamily.idealCoeff η P.val) 1 x w z + +theorem idealHighLocalFactor_rational (η : HeckeFamily.Character) (P : PrimeIdeal) + (hs : Supported P.val) (x w z : ℂ) (hx : 3/2 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma outside_mul (S : Finset Id) (hS : ∀P∈S,Prime P) (A B : Id) : + (∀P∈S,¬P∣A*B) ↔ (∀P∈S,¬P∣A) ∧ (∀P∈S,¬P∣B) := by + constructor + · intro h + constructor + · intro P hP hd + exact h P hP ((hS P hP).dvd_mul.mpr (Or.inl hd)) + · intro P hP hd + exact h P hP ((hS P hP).dvd_mul.mpr (Or.inr hd)) + · rintro ⟨hA,hB⟩ P hP hd + exact ((hS P hP).dvd_mul.mp hd).elim (hA P hP) (hB P hP) + +lemma outside_cube (S : Finset Id) (hS : ∀P∈S,Prime P) (A : Id) : + (∀P∈S,¬P∣A^3) ↔ ∀P∈S,¬P∣A := by + constructor + · intro h P hP hd + exact h P hP (dvd_trans hd (dvd_pow_self A (by decide : (3:ℕ)≠0))) + · intro h P hP hd + exact h P hP ((hS P hP).dvd_of_dvd_pow hd) + +def highExclusion (S : Finset Id) (hS : ∀P∈S,Prime P) : Id→*ℂ where + toFun A := if ∀P∈S,¬P∣A then 1 else 0 + map_one' := by + rw [ite_eq_left] + intro P hP hd + exact (hS P hP).not_isUnit (isUnit_of_dvd_one hd) + map_mul' A B := by + simp only [outside_mul S hS A B] + split_ifs <;> simp_all + +lemma highExclusion_cube (S : Finset Id) (hS : ∀P∈S,Prime P) (A : Id) : + highExclusion S hS (A^3)=highExclusion S hS A := by + change (if ∀P∈S,¬P∣A^3 then (1:ℂ) else 0)=_ + simp only [outside_cube S hS] + rfl + +theorem highIdealMask_unmarked (S : Finset Id) (hS : ∀P∈S,Prime P) (I J K L : Id) : + highIdealMask S 1 I J K L = + highExclusion S hS I*highExclusion S hS J*highExclusion S hS K*highExclusion S hS L := by + have he : completedMask S 1 I J=highExclusion S hS (I*J^3) := by + simp only [completedMask,one_dvd,true_and] + rfl + unfold highIdealMask + rw [he,map_mul,highExclusion_cube] + rfl + +lemma highIdealMask_unmarked_one (S : Finset Id) (hS : ∀P∈S,Prime P) : + highIdealMask S 1 1 1 1 1=1 := by + rw [highIdealMask_unmarked S hS] + simp only [map_one,one_mul] + +lemma highIdealMask_unmarked_mul (S : Finset Id) (hS : ∀P∈S,Prime P) + (a b : HighIdeal) : + highIdealMask S 1 (a.1.1*b.1.1) (a.1.2*b.1.2) (a.2.1*b.2.1) (a.2.2*b.2.2)= + highIdealMask S 1 a.1.1 a.1.2 a.2.1 a.2.2 * highIdealMask S 1 b.1.1 b.1.2 b.2.1 b.2.2 := by + simp only [highIdealMask_unmarked S hS,map_mul] + ring + +theorem excludedIdealHighSeries_hasProd (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2∑' b : HighValuation, + markedIdealHighSummand S 1 η 1 x w z (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2)) + (markedIdealHighSeries S 1 η 1 x w z) := by + apply highArray_hasProd (fun a : HighIdeal=>markedIdealHighSummand S 1 η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2) + · simp only [Prod.fst_one,Prod.snd_one,markedIdealHighSummand, + highIdealMask_unmarked_one S hS,bareIdealHighSummand_one,one_mul] + · intro a b hc + simp only [Prod.fst_mul,Prod.snd_mul,markedIdealHighSummand, + highIdealMask_unmarked_mul S hS a b, + bareIdealHighSummand_mul η x w z _ _ _ _ _ _ _ _ hc] + ring + · intro a ha + have hh : bareIdealHighSummand η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2≠0 := + (mul_ne_zero_iff.mp ha).2 + have hs := bareIdealHighSummand_support η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2 hh + exact ⟨hs.2.1.1,hs.2.2.1.1,hs.2.2.2.1.1,hs.2.2.2.2.1⟩ + · exact (markedIdealHighSummand_summable S 1 η 1 x w z hx hw hz).norm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighExcludedLocal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighExcludedLocal.lean new file mode 100644 index 0000000000000000000000000000000000000000..a14272c99e1141eecce8466e3bfa865090c08c58 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighExcludedLocal.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Detector.HighExcludedEuler +import OAI.NumberTheory.DirichletL.Detector.HighEulerLocal + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma highExclusion_prime (S : Finset Id) (hS : ∀P∈S,Prime P) (P : PrimeIdeal) : + highExclusion S hS P.val=if P.val∈S then 0 else 1 := by + change (if ∀Q∈S,¬Q∣P.val then (1:ℂ) else 0)=_ + by_cases hP : P.val∈S + · rw [ite_eq_right (fun h=>h P.val hP (dvd_refl _)),ite_eq_left hP] + · have houtside : ∀Q∈S,¬Q∣P.val := by + intro Q hQ hd + have hn : (⟨Q,hS Q hQ⟩ : PrimeIdeal)≠P := by + intro hh + exact hP ((congrArg Subtype.val hh) ▸ hQ) + exact (hS Q hQ).not_isUnit ((primeIdeal_coprime ⟨Q,hS Q hQ⟩ P hn).isUnit_of_dvd hd) + rw [ite_eq_left houtside,ite_eq_right hP] + +lemma highIdealMask_prime_outside (S : Finset Id) (hS : ∀P∈S,Prime P) + (P : PrimeIdeal) (hP : P.val∉S) (b : HighValuation) : + highIdealMask S 1 (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2)=1 := by + simp only [highIdealMask_unmarked S hS,map_pow,highExclusion_prime S hS P, + ite_eq_right hP,one_pow,one_mul] + +lemma highIdealMask_prime_inside (S : Finset Id) (hS : ∀P∈S,Prime P) + (P : PrimeIdeal) (hP : P.val∈S) (b : HighValuation) : + highIdealMask S 1 (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2)= + if b=0 then 1 else 0 := by + rcases b with ⟨⟨e,l⟩,k,m⟩ + simp only [highIdealMask_unmarked S hS,map_pow,highExclusion_prime S hS P,ite_eq_left hP] + by_cases he : e=0 <;> by_cases hl : l=0 <;> by_cases hk : k=0 <;> by_cases hm : m=0 <;> + simp [he,hl,hk,hm,Prod.mk_eq_zero] + +theorem excludedHighLocalFactor (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2idealHighLocalFactor η P.val.val x w z) + (markedIdealHighSeries S 1 η 1 x w z) := by + have h := excludedIdealHighSeries_hasProd S hS η x w z hx hw hz + simp only [excludedHighLocalFactor S hS η x w z hx hw hz] at h + apply (hasProd_subtype_iff_mulIndicator + (s:={P : PrimeIdeal | P.val∉S}) + (f:=fun P : PrimeIdeal=>idealHighLocalFactor η P.val x w z)).mpr + convert h using 1 + funext P + simp only [Set.mulIndicator,Set.mem_ofPred_eq] + split_ifs <;> simp_all + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighLFactorization.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighLFactorization.lean new file mode 100644 index 0000000000000000000000000000000000000000..04fb60a29c95f32e4b90b7d9203bbadb97e22108 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighLFactorization.lean @@ -0,0 +1,48 @@ +import OAI.NumberTheory.DirichletL.Detector.FixedEuler +import OAI.NumberTheory.DirichletL.Detector.GlobalCorrection + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic HeckeFamily CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem principalHigh_L_factorization (S : Finset Id) (hS : ∀P∈S,Prime P) + (hgood : ∀P : PrimeIdeal,P.val∉S → Supported P.val) (htail : CorrectionTail S) + (η : Character) (x w z : ℂ) (hx : 3/2idealHighLocalFactor η P.val.val x w z) + (LFunction (fixedSourcePrincipal S hS) (6*z) * LFunction (fixedSourcePrincipal S hS) w / + LFunction (η.excludePrimes S hS) x * globalClosedCorrection η S x w z) := by + simpa only [hlocal,div_eq_mul_inv,globalClosedCorrection] using he + exact (excludedIdealHighSeries_hasProd_outside S hS η x w z hx hw hz).unique he' + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsActual.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsActual.lean new file mode 100644 index 0000000000000000000000000000000000000000..c9d5578bd73ddc0be4c8ee4aab780e7610fec4d8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsActual.lean @@ -0,0 +1,49 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsClosed + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower ProbeEuler +open CanonicalQuadraticSieve CanonicalRowCompletion ProbeRow CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem actualSextic_unit_six (p b : O) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + (hb : IsCoprime b p) : + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^6=1 := by + have h := congrArg (fun χ : MulChar (O ⧸ Ideal.span {p}) ℂ => + χ (Ideal.Quotient.mk _ b)) (actualSextic_six _ hg hc) + simpa only [MulChar.pow_apply' _ (by decide : (6:ℕ)≠0), + MulChar.one_apply ((isUnit_quotient_span_iff p b).mpr hb.symm)] using h + +theorem idealRowHighLocalFactor_eq_closed (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hc : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (b : O) (hb : IsCoprime b p) + (j : ℕ) (hj : j<6) (x w z : ℂ) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) (actualACube η p) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) (coordV (Ideal.absNorm (Ideal.span {p})) z)‖<1) + (hW : ‖actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w))‖<1) : + idealRowHighLocalFactor η (b*p^j) (Ideal.span {p}) x w z= + 1/(1-coordV (Ideal.absNorm (Ideal.span {p})) z)+ + (if j=0 then + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)))/ + (1-actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w))) else 0)+ + rowClosedMarked p hp hg (targetMonoid η p) (actualACube η p) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)) j := by + rw [idealRowHighLocalFactor_eq_source η p hp hg hc hprimary hs b hb j x w z] + exact sourceRowSeries_eq_closed p hp hg hc _ _ _ x w z + (actualSextic_unit_six p b hg hc hb) hV hR hW j hj + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralBase.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralBase.lean new file mode 100644 index 0000000000000000000000000000000000000000..ee22f7b445523161e033eccd4bc934fc2dee3221 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralBase.lean @@ -0,0 +1,103 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsCentralTerms + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +lemma rowBaseFinite_central_remainder (eta a rho x w z : ℂ) (alpha eps : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0rowMarkedTerm p hp hg eta a ((Q:ℂ)^(-x)) ((Q:ℂ)^(-w)) (coordV Q z) rho j e l k m + ‖rowBaseFinite p hp hg eta a ((Q:ℂ)^(-x)) ((Q:ℂ)^(-w)) (coordV Q z) rho j e l- + (if e=1 ∧ l=0 then T 1 0 else 0)‖≤16*Q^(1/2-x.re) := by + dsimp only + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + let T := fun k m=>rowMarkedTerm p hp hg eta a ((Q:ℂ)^(-x)) ((Q:ℂ)^(-w)) (coordV Q z) rho j e l k m + have hpow : 0≤Q^(1/2-x.re) := by positivity + have hv := ProbeLocal.inv_one_sub_norm_le_two _ (first_region_V_half _ hQ z (by rw [hz])) + have ht (k m : ℕ) (hk : k≤1) (hstrict : ¬(e=1 ∧ l=0 ∧ k=1 ∧ m=0)) : + ‖T k m‖≤2*Q^(1/2-x.re) := by + have ht0 : e+3*l≠0 := by rcases hf with h|h|h|h <;> omega + dsimp only [T,Q] + simp only [Complex.ofReal_natCast] + rw [←sourceRowTerm_pos p hp hg eta a rho x w z j e l k m ht0] + exact sourceRowTerm_central_nonstrict p hp hg hc eta a rho x w z alpha eps + heta ha hρ halpha halpha1 heps heps1 hx hw hz j e l k m hj hk hf hstrict + have hd (k : ℕ) (hk : k≤1) : ‖T k 2/(1-coordV Q z)‖≤4*Q^(1/2-x.re) := by + rw [div_eq_mul_inv,norm_mul] + exact (mul_le_mul (ht k 2 hk (by omega)) hv (norm_nonneg _) (by positivity)).trans_eq (by ring) + by_cases hb : e=1 ∧ l=0 + · rw [ite_eq_left hb] + have hid : rowBaseFinite p hp hg eta a ((Q:ℂ)^(-x)) ((Q:ℂ)^(-w)) (coordV Q z) rho j e l-T 1 0= + ((T 0 0+T 0 1+T 0 2/(1-coordV Q z))+T 1 1)+T 1 2/(1-coordV Q z) := by + simp only [rowBaseFinite,Fin.sum_univ_two] + dsimp only [T] + norm_num only [Fin.val_zero,Fin.val_one] + ring + change ‖rowBaseFinite p hp hg eta a ((Q:ℂ)^(-x)) ((Q:ℂ)^(-w)) (coordV Q z) rho j e l-T 1 0‖≤_ + rw [hid] + have h00 := ht 0 0 (by omega) (by omega) + have h01 := ht 0 1 (by omega) (by omega) + have h11 := ht 1 1 (by omega) (by omega) + have hn := (norm_add_le _ _).trans (add_le_add + ((norm_add_le _ _).trans (add_le_add + ((norm_add_le _ _).trans (add_le_add ((norm_add_le _ _).trans (add_le_add h00 h01)) (hd 0 (by omega)))) h11)) (hd 1 (by omega))) + exact hn.trans (by linarith) + · rw [ite_eq_right hb,sub_zero] + unfold rowBaseFinite + apply (norm_sum_le _ _).trans + calc + _≤∑ _k : Fin 2,8*Q^(1/2-x.re) := by + apply Finset.sum_le_sum + intro k hk + have h0 := ht k.val 0 (by omega) (by tauto) + have h1 := ht k.val 1 (by omega) (by omega) + exact ((norm_add_le _ _).trans (add_le_add ((norm_add_le _ _).trans (add_le_add h0 h1)) (hd k.val (by omega)))).trans_eq (by ring) + _=16*Q^(1/2-x.re) := by simp;ring + +include hc in +theorem rowClosedMarked_central_remainder (eta a rho x w z : ℂ) (alpha eps : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) +include hc in +lemma rowClosedMarked_central_size (eta a rho x w z : ℂ) (alpha eps : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +lemma sourceRowTerm_central_strict_norm (eta a rho x w z : ℂ) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) (j : ℕ) (hj : j<6) : + ‖sourceRowTerm p hp hg eta a rho x w z j 1 0 1 0‖≤ + 2*(Ideal.absNorm (Ideal.span {p}):ℝ)^(1-x.re-w.re) := by + apply sourceRowTerm_norm_from_scalar_power p hp hg hc eta a rho x w z heta ha hρ + j 1 0 1 0 (3/2) (1-x.re-w.re) + · have hb := squarefree_base_strict_norm p hp hg hc j hj + have ht : 0≤(Ideal.absNorm (Ideal.span {p}):ℝ)^(3/2:ℝ) := by positivity + simpa only [sourceScalar,Nat.reduceMul,Nat.reduceAdd,Nat.reduceSub,ite_false, + Nat.reduceEqDiff,mul_zero,add_zero] using hb.trans (show _≤2*(Ideal.absNorm (Ideal.span {p}):ℝ)^(3/2:ℝ) by linarith) + · norm_num ; linarith + +include hc in +lemma sourceRowTerm_central_boundary_norm (eta a rho x w z : ℂ) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) (j : ℕ) (hj : j≤1) : + ‖sourceRowTerm p hp hg eta a rho x w z j 1 0 1 0‖≤ + 2*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re-w.re) := by + apply sourceRowTerm_norm_from_scalar_power p hp hg hc eta a rho x w z heta ha hρ + j 1 0 1 0 (1/2) (-x.re-w.re) + · have hb := squarefree_base_boundary_norm p hp hg hc j hj + rw [Real.sqrt_eq_rpow] at hb + have ht : 0≤(Ideal.absNorm (Ideal.span {p}):ℝ)^(1/2:ℝ) := by positivity + simpa only [sourceScalar,Nat.reduceMul,Nat.reduceAdd,Nat.reduceSub,ite_false, + Nat.reduceEqDiff,mul_zero,add_zero] using hb.trans (show _≤2*(Ideal.absNorm (Ideal.span {p}):ℝ)^(1/2:ℝ) by linarith) + · norm_num +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralError.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralError.lean new file mode 100644 index 0000000000000000000000000000000000000000..8f5a203cfc6f81faf58edff567eca06a2a282d13 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralError.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsCentralCancellation +import OAI.NumberTheory.DirichletL.Detector.HighRowsSelectedUnramified + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler +open ProbeLocal + +lemma central_unramified_error_weights (Q a e : ℝ) (A eta v x w z : ℂ) + (hQ : 4≤Q) (ha : (51/100:ℝ)≤a) (ha1 : a≤1) (he : 0 ActualEisensteinCubic.O + +theorem central_correction_threshold (eps : ℝ) (heps : 0198*Q^(-10*eps)) atTop (nhds 0) := by + simpa only [mul_zero,neg_mul] using + (tendsto_rpow_neg_atTop (show 0<10*eps by positivity)).const_mul (198:ℝ) + have he := hh.eventually (eventually_lt_nhds (by norm_num : (0:ℝ)<1/2)) + obtain ⟨Q0,hQ0⟩ := Filter.eventually_atTop.mp he + refine ⟨max 480 Q0,le_max_left _ _,?_⟩ + intro Q hQ + exact (hQ0 Q ((le_max_right _ _).trans hQ)).le + +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) +include hc in +theorem ramifiedClosed_central_lower (eta a rho x w z : ℂ) (alpha eps : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (hsmall : 198*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-10*eps)≤1/2) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +def ramifiedStrictSelected (eta a rho x w z : ℂ) (j : ℕ) : ℂ := + star eta*(Ideal.absNorm (Ideal.span {p}):ℂ)^x*(1-coordV (Ideal.absNorm (Ideal.span {p})) z)* + (rowMarkedTerm p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j 1 0 1 0 / + (1-evenRatio (Ideal.absNorm (Ideal.span {p})) a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + (coordV (Ideal.absNorm (Ideal.span {p})) z))) + +include hc in +theorem ramifiedSelected_central_regular (eta a rho x w z : ℂ) (alpha eps : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0 ActualEisensteinCubic.O + +lemma norm_div_le_twice (A H : ℂ) (hH : 1/2≤‖H‖) : ‖A/H‖≤2*‖A‖ := by + rw [norm_div] + apply (div_le_iff₀ (by linarith : 0<‖H‖)).mpr + nlinarith [norm_nonneg A] + +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) +include hc in +theorem ramifiedSelected_central_quotient (eta a rho x w z : ℂ) (alpha eps : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (hsmall : 198*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-10*eps)≤1/2) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) +include hc in +lemma squarefree_base_boundary_norm (j : ℕ) (hj : j≤1) : + ‖positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 0 1 j‖≤ + Real.sqrt (Ideal.absNorm (Ideal.span {p}):ℝ) := by + have he := row_squarefree_kone p hp hg hc 0 0 j (by omega) + norm_num only [Nat.mul_zero,zero_add,mul_zero,add_zero,pow_zero,one_mul] at he + rw [he,ite_eq_right (by omega)] + split_ifs + · rw [norm_mul,norm_mul,norm_inv, + Complex.norm_eq_one_of_pow_eq_one (actualSextic_neg_one_sq _ hg) (by decide), + inv_one,one_mul,primeGauss_actual_norm p hp.ne_zero hg hc] + norm_num + · simp only [mul_zero,norm_zero] + positivity + +include hc in +lemma squarefree_base_strict_norm (j : ℕ) (hj : j<6) : + ‖positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 0 1 j‖≤ + (Ideal.absNorm (Ideal.span {p}):ℝ)^(3/2:ℝ) := by + have he := row_squarefree_kone p hp hg hc 0 0 j hj + norm_num only [Nat.mul_zero,zero_add,mul_zero,add_zero,pow_zero,one_mul] at he + have hQ : (0:ℝ) norm_num +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralStrictSelected.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralStrictSelected.lean new file mode 100644 index 0000000000000000000000000000000000000000..c71d35024d7c5b1ac3b8adca71faa73c3af2ab68 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsCentralStrictSelected.lean @@ -0,0 +1,62 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsCentralRamified + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +lemma ramifiedStrictSelected_from_entry (eta a rho x w z : ℂ) (j : ℕ) (b : ℝ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (heta : ‖eta‖≤1) (ha : ‖a‖≤1) + (hx : (51/100:ℝ)≤x.re) (hz : (17/50:ℝ)≤z.re) + (ht : ‖sourceRowTerm p hp hg eta a rho x w z j 1 0 1 0‖≤ + 2*(Ideal.absNorm (Ideal.span {p}):ℝ)^b) : + ‖ramifiedStrictSelected p hp hg eta a rho x w z j‖≤ + 6*(Ideal.absNorm (Ideal.span {p}):ℝ)^(x.re+b) := by + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + have hQ0 : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +theorem sourceRowTerm_central_nonstrict (eta a rho x w z : ℂ) (alpha eps : ℝ) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (halpha : (51/100:ℝ)≤alpha) (halpha1 : alpha≤1) (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +def rowBaseFinite (eta a X W V rho : ℂ) (j e l : ℕ) : ℂ := + ∑ k : Fin 2, + (rowMarkedTerm p hp hg eta a X W V rho j e l k.val 0+ + rowMarkedTerm p hp hg eta a X W V rho j e l k.val 1+ + rowMarkedTerm p hp hg eta a X W V rho j e l k.val 2/(1-V)) + +def rowClosedMarked (eta a X W V rho : ℂ) (j : ℕ) : ℂ := + (rowBaseFinite p hp hg eta a X W V rho j 0 2+ + rowBaseFinite p hp hg eta a X W V rho j 1 0+ + rowBaseFinite p hp hg eta a X W V rho j 0 1+ + rowBaseFinite p hp hg eta a X W V rho j 1 1)/ + (1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) + +include hc in +theorem rowMarkedSeries_eq_closed (eta a X W V rho : ℂ) (hρ : rho^6=1) + (hV : ‖V‖<1) (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) + (j : ℕ) (hj : j<6) : + rowMarkedSeries p hp hg eta a X W V rho j=rowClosedMarked p hp hg eta a X W V rho j := by + rw [rowMarkedSeries_four_families p hp hg hc eta a X W V rho hρ hV hR j hj] + unfold rowClosedMarked rowBaseFinite + rw [rowInner_base_rational p hp hg hc eta a X W V rho hV j 0 2 (by omega) (by omega), + rowInner_base_rational p hp hg hc eta a X W V rho hV j 1 0 (by omega) (by omega), + rowInner_base_rational p hp hg hc eta a X W V rho hV j 0 1 (by omega) (by omega), + rowInner_base_rational p hp hg hc eta a X W V rho hV j 1 1 (by omega) (by omega)] + +include hc in +lemma rowInner_zero_squarefree_summable (eta a X W V rho : ℂ) (hρ : rho^6=1) + (hV : ‖V‖<1) (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) + (j : ℕ) (hj : j<6) : Summable (fun l=>rowInner p hp hg eta a X W V rho j 0 l) := by + have h02 := rowInner_family_hasSum p hp hg hc eta a X W V rho hρ hV hR j 0 2 hj (by omega) + have h01 := rowInner_family_hasSum p hp hg hc eta a X W V rho hρ hV hR j 0 1 hj (by omega) + have hs : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 0 (2*(r+1))) + (rowInner p hp hg eta a X W V rho j 0 2/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + convert h02 using 1 + funext r + congr 1 + omega + have he := hs.sum_range_add (f:=fun r=>rowInner p hp hg eta a X W V rho j 0 (2*r)) (k:=1) + have ho : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 0 (2*r+1)) + (rowInner p hp hg eta a X W V rho j 0 1/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + simpa only [Nat.add_comm 1] using h01 + exact (he.even_add_odd ho).summable + +def sourceRowSeries (eta a rho x w z : ℂ) (j : ℕ) : ℂ := + ∑ e : Fin 2,∑' l,∑' k,∑' m,sourceRowTerm p hp hg eta a rho x w z j e.val l k m + +include hc in + +theorem sourceRowSeries_eq_closed (eta a rho x w z : ℂ) (hρ : rho^6=1) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) (coordV (Ideal.absNorm (Ideal.span {p})) z)‖<1) + (hW : ‖rho*((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w))‖<1) (j : ℕ) (hj : j<6) : + sourceRowSeries p hp hg eta a rho x w z j= + 1/(1-coordV (Ideal.absNorm (Ideal.span {p})) z)+ + (if j=0 then (rho*((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)))/ + (1-rho*((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w))) else 0)+ + rowClosedMarked p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j := by + let X : ℂ := (Ideal.absNorm (Ideal.span {p}):ℂ)^(-x) + let W : ℂ := (Ideal.absNorm (Ideal.span {p}):ℂ)^(-w) + let V : ℂ := coordV (Ideal.absNorm (Ideal.span {p})) z + let Z0 := 1/(1-V)+(if j=0 then rho*W/(1-rho*W) else 0) + have he0 (l : ℕ) : (∑' k,∑' m,sourceRowTerm p hp hg eta a rho x w z j 0 l k m)= + rowInner p hp hg eta a X W V rho j 0 l+(if l=0 then Z0 else 0) := by + by_cases hl : l=0 + · subst l + simp only [sourceRowTerm_zero,rowInner_zero,ite_true,zero_add] + exact rowZeroIndexSeries_eq p hp (actualSextic (Ideal.span {p}) hg) (rho*W) V j hW hV + · rw [ite_eq_right hl,add_zero] + apply tsum_congr + intro k + apply tsum_congr + intro m + exact sourceRowTerm_pos p hp hg eta a rho x w z j 0 l k m (by omega) + have he1 (l : ℕ) : (∑' k,∑' m,sourceRowTerm p hp hg eta a rho x w z j 1 l k m)= + rowInner p hp hg eta a X W V rho j 1 l := by + apply tsum_congr + intro k + apply tsum_congr + intro m + exact sourceRowTerm_pos p hp hg eta a rho x w z j 1 l k m (by omega) + have hs := rowInner_zero_squarefree_summable p hp hg hc eta a X W V rho hρ hV hR j hj + have hc' := rowMarkedSeries_eq_closed p hp hg hc eta a X W V rho hρ hV hR j hj + unfold rowMarkedSeries at hc' + simp only [Fin.sum_univ_two,Fin.val_zero,Fin.val_one] at hc' + unfold sourceRowSeries + simp only [Fin.sum_univ_two,Fin.val_zero,Fin.val_one,he0,he1] + rw [hs.tsum_add (hasSum_ite_eq 0 Z0).summable,tsum_ite_eq] + change _=Z0+rowClosedMarked p hp hg eta a X W V rho j + rw [←hc'] + ring + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsDiagonal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsDiagonal.lean new file mode 100644 index 0000000000000000000000000000000000000000..6249592acc4acc0015a1d50043367530eb94edd4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsDiagonal.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Detector.LocalSummation + +namespace OAI + +noncomputable section +open scoped BigOperators +namespace SevenEighths.ProbeEuler + +theorem diagonal_recurrence_eq (f : ℕ→ℕ→ℂ) (R : ℂ) + (hstep : ∀ r m,f (r+1) (m+1)=R*f r m) (hz : ∀ r,f (r+1) 0=0) : + ∀ r m,f r m=if r≤m then R^r*f 0 (m-r) else 0 := by + intro r + induction r with + | zero => intro m; simp + | succ r ih => + intro m + cases m with + | zero => simp [hz] + | succ m => + rw [hstep,ih] + by_cases h : r≤m + · simp only [h,ite_true,Nat.succ_le_succ_iff,Nat.succ_sub_succ_eq_sub,pow_succ] + ring + · simp only [h,ite_false,Nat.succ_le_succ_iff,mul_zero] + +theorem diagonal_recurrence_inner_hasSum (f : ℕ→ℕ→ℂ) (R : ℂ) + (hstep : ∀ r m,f (r+1) (m+1)=R*f r m) (hz : ∀ r,f (r+1) 0=0) + (hs : Summable (f 0)) (r : ℕ) : HasSum (f r) (R^r*∑' m,f 0 m) := by + have he := diagonal_recurrence_eq f R hstep hz + have htail : HasSum (fun m=>f r (m+r)) (R^r*∑' m,f 0 m) := by + convert hs.hasSum.mul_left (R^r) using 1 + funext m + rw [he,ite_eq_left (Nat.le_add_left r m),Nat.add_sub_cancel] + have hzero : (∑ m∈Finset.range r,f r m)=0 := by + apply Finset.sum_eq_zero + intro m hm + rw [he,ite_eq_right (by have := Finset.mem_range.mp hm; omega)] + simpa only [hzero,zero_add] using htail.sum_range_add + +theorem diagonal_recurrence_hasSum (f : ℕ→ℕ→ℂ) (R : ℂ) + (hstep : ∀ r m,f (r+1) (m+1)=R*f r m) (hz : ∀ r,f (r+1) 0=0) + (hs : Summable (f 0)) (hR : ‖R‖<1) : + HasSum (fun r=>∑' m,f r m) ((∑' m,f 0 m)/(1-R)) := by + have he (r : ℕ) := (diagonal_recurrence_inner_hasSum f R hstep hz hs r).tsum_eq + have hg : HasSum (fun r=>R^r*(∑' m,f 0 m)) ((∑' m,f 0 m)/(1-R)) := by + simpa only [div_eq_mul_inv,mul_comm] using + (hasSum_geometric_of_norm_lt_one hR).mul_right (∑' m,f 0 m) + convert hg using 1 + funext r + exact he r + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsEuler.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..7d7ff397a0cf4fdbac36b02942c0f922bf855cb0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsEuler.lean @@ -0,0 +1,51 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsMultiplicative + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +open CubicEisenstein ProbePhase ConcretePrimeRowBridge ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +@[simp] theorem bareIdealHighCoefficient_row_one (η : HeckeFamily.Character) (u : O) : + bareIdealHighCoefficient η u 1 1 1 1=1 := by + have hs := supported_one_ideal + have hg : Squarefree (1:Ideal O) ∧ Supported 1 ∧ Supported 1 ∧ Supported 1 ∧ Supported 1 := + ⟨squarefree_one,hs,hs,hs,hs⟩ + unfold bareIdealHighCoefficient + rw [dite_eq_left hg] + simp only [primaryGenerator_one,one_pow,mul_one] + unfold bareSourceCoefficient correctedFiniteCoefficient reciprocityCoefficient + rw [gaussTwo_one,G_one,angularFactor_one] + have ho := supported_residue_odd (1:O) (by + rw [Ideal.span_singleton_one,←Ideal.one_eq_top];exact hs) + rw [reciprocitySign_one_left (1:O) ho, + bareCongruenceCoefficient_inner_one 1 one_ne_zero,outerQuotient_mk] + simp only [map_one,star_one,one_mul,Ideal.span_singleton_one,←Ideal.one_eq_top] + +@[simp] theorem bareIdealHighSummand_row_one (η : HeckeFamily.Character) (u : O) (x w z : ℂ) : + bareIdealHighSummand η u x w z 1 1 1 1=1 := by + have hw (t : ℂ) : fullIdealWeight t (1:Ideal O)=1 := (IdealEuler.normWeight t).map_one + simp only [bareIdealHighSummand,bareIdealHighCoefficient_row_one,hw,one_mul] + +theorem bareIdealHighSeries_row_hasProd (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2∑' b : HighValuation, + bareIdealHighSummand η u x w z (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2)) + (bareIdealHighSeries η u x w z) := by + apply highArray_hasProd (fun a : HighIdeal=>bareIdealHighSummand η u x w z a.1.1 a.1.2 a.2.1 a.2.2) + · exact bareIdealHighSummand_row_one η u x w z + · intro a b hc + exact bareIdealHighSummand_row_mul η u x w z _ _ _ _ _ _ _ _ hc + · intro a ha + have hs := bareIdealHighSummand_support η u x w z a.1.1 a.1.2 a.2.1 a.2.2 ha + exact ⟨hs.2.1.1,hs.2.2.1.1,hs.2.2.2.1.1,hs.2.2.2.2.1⟩ + · exact (bareIdealHighSummand_summable η u x w z hx hw hz).norm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsExcluded.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsExcluded.lean new file mode 100644 index 0000000000000000000000000000000000000000..dacf4f1a63ac38599d6cdd6bcaf7db32a64d1d88 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsExcluded.lean @@ -0,0 +1,37 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsEuler +import OAI.NumberTheory.DirichletL.Detector.HighExcludedLocal + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem excludedIdealHighSeries_row_hasProd (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2∑' b : HighValuation, + markedIdealHighSummand S 1 η u x w z (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2)) + (markedIdealHighSeries S 1 η u x w z) := by + apply highArray_hasProd (fun a : HighIdeal=>markedIdealHighSummand S 1 η u x w z a.1.1 a.1.2 a.2.1 a.2.2) + · simp only [Prod.fst_one,Prod.snd_one,markedIdealHighSummand, + highIdealMask_unmarked_one S hS,bareIdealHighSummand_row_one,one_mul] + · intro a b hc + simp only [Prod.fst_mul,Prod.snd_mul,markedIdealHighSummand, + highIdealMask_unmarked_mul S hS a b, + bareIdealHighSummand_row_mul η u x w z _ _ _ _ _ _ _ _ hc] + ring + · intro a ha + have hh : bareIdealHighSummand η u x w z a.1.1 a.1.2 a.2.1 a.2.2≠0 := + (mul_ne_zero_iff.mp ha).2 + have hs := bareIdealHighSummand_support η u x w z a.1.1 a.1.2 a.2.1 a.2.2 hh + exact ⟨hs.2.1.1,hs.2.2.1.1,hs.2.2.2.1.1,hs.2.2.2.2.1⟩ + · exact (markedIdealHighSummand_summable S 1 η u x w z hx hw hz).norm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFamilies.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFamilies.lean new file mode 100644 index 0000000000000000000000000000000000000000..606357887bfc98552c8386a45b27d9f5bf9248bb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFamilies.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsSummability + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +def rowInner (eta a X W V rho : ℂ) (j e l : ℕ) : ℂ := + ∑' k, ∑' m,rowMarkedTerm p hp hg eta a X W V rho j e l k m + +def rowMarkedSeries (eta a X W V rho : ℂ) (j : ℕ) : ℂ := + ∑ e : Fin 2, ∑' l,rowInner p hp hg eta a X W V rho j e.val l + +lemma rowInner_two (eta a X W V rho : ℂ) (j e l : ℕ) : + rowInner p hp hg eta a X W V rho j e l= + (∑' m,rowMarkedTerm p hp hg eta a X W V rho j e l 0 m)+ + (∑' m,rowMarkedTerm p hp hg eta a X W V rho j e l 1 m) := by + apply tsum_two_of_rest_zero + intro k + simp only [rowMarkedTerm_higher_outer,tsum_zero] + +@[simp] lemma rowInner_zero (eta a X W V rho : ℂ) (j : ℕ) : + rowInner p hp hg eta a X W V rho j 0 0=0 := by + simp only [rowInner,rowMarkedTerm,mul_zero,add_zero,ite_true,tsum_zero] + +include hc in +theorem rowInner_family_hasSum (eta a X W V rho : ℂ) (hρ : rho^6=1) + (hV : ‖V‖<1) (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) + (j e l : ℕ) (hj : j<6) (ht : 0rowInner p hp hg eta a X W V rho j e (l+2*r)) + (rowInner p hp hg eta a X W V rho j e l/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + have h0 := rowMarkedFamily_hasSum p hp hg hc eta a X W V rho hρ hV hR j e l 0 hj ht + have h1 := rowMarkedFamily_hasSum p hp hg hc eta a X W V rho hρ hV hR j e l 1 hj ht + convert h0.add h1 using 1 + · funext r + exact rowInner_two p hp hg eta a X W V rho j e (l+2*r) + · rw [rowInner_two,add_div] + +include hc in + +theorem rowMarkedSeries_four_families (eta a X W V rho : ℂ) (hρ : rho^6=1) + (hV : ‖V‖<1) (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) + (j : ℕ) (hj : j<6) : + rowMarkedSeries p hp hg eta a X W V rho j= + (rowInner p hp hg eta a X W V rho j 0 2+ + rowInner p hp hg eta a X W V rho j 1 0+ + rowInner p hp hg eta a X W V rho j 0 1+ + rowInner p hp hg eta a X W V rho j 1 1)/ + (1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) := by + have h02 := rowInner_family_hasSum p hp hg hc eta a X W V rho hρ hV hR j 0 2 hj (by omega) + have h10 := rowInner_family_hasSum p hp hg hc eta a X W V rho hρ hV hR j 1 0 hj (by omega) + have h01 := rowInner_family_hasSum p hp hg hc eta a X W V rho hρ hV hR j 0 1 hj (by omega) + have h11 := rowInner_family_hasSum p hp hg hc eta a X W V rho hρ hV hR j 1 1 hj (by omega) + have he0 : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 0 (2*r)) + (rowInner p hp hg eta a X W V rho j 0 2/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + have hshift : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 0 (2*(r+1))) + (rowInner p hp hg eta a X W V rho j 0 2/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + convert h02 using 1 + funext r + congr 1 + omega + have h := hshift.sum_range_add (f:=fun r=>rowInner p hp hg eta a X W V rho j 0 (2*r)) (k:=1) + simpa only [Finset.sum_range_one,mul_zero,rowInner_zero,zero_add] using h + have he1 : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 1 (2*r)) + (rowInner p hp hg eta a X W V rho j 1 0/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + simpa only [zero_add] using h10 + have ho0 : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 0 (2*r+1)) + (rowInner p hp hg eta a X W V rho j 0 1/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + simpa only [Nat.add_comm 1] using h01 + have ho1 : HasSum (fun r=>rowInner p hp hg eta a X W V rho j 1 (2*r+1)) + (rowInner p hp hg eta a X W V rho j 1 1/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + simpa only [Nat.add_comm 1] using h11 + unfold rowMarkedSeries + simp only [Fin.sum_univ_two,Fin.val_zero,Fin.val_one] + rw [(he0.even_add_odd ho0).tsum_eq,(he1.even_add_odd ho1).tsum_eq] + ring + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFiniteBounds.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFiniteBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce7d586f612b5459fd93de8475a36ffa08faa6b2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFiniteBounds.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsTermBounds +import OAI.NumberTheory.DirichletL.Detector.EulerRegion + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +lemma rowMarkedTerm_second_region (eta a rho x w z : ℂ) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (7/8:ℝ)≤x.re) (hw : (19/20:ℝ)≤w.re) (hz : (33/200:ℝ)≤z.re) + (j e l k m : ℕ) (ht : 0unramifiedClosed Q A eta v x w z) {x : ℂ|1/2unramifiedClosed Q A eta v x w z) (Set.univ : Set ℂ) := by + apply DifferentiableOn.analyticOnNhd _ isOpen_univ + intro w hw + have hd := first_open_region_denominators Q A eta v x z hQ hA he hv hx hz + exact (unramifiedClosed_differentiableAt_w Q (by linarith) A eta v x w z hd.1 hd.2.1 hd.2.2).differentiableWithinAt + +theorem unramifiedClosed_first_analytic_z (Q : ℝ) (A eta v x w : ℂ) + (hQ : 4≤Q) (hA : ‖A‖≤1) (he : ‖eta‖≤1) (hv : ‖v‖≤1) (hx : 1/2≤x.re) : + AnalyticOnNhd ℂ (fun z=>unramifiedClosed Q A eta v x w z) {z : ℂ|1/3 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) + +lemma ramifiedClosed_first_analytic_x (eta a rho w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (ha : ‖a‖≤1) (hz : (1/3:ℝ)≤z.re) (j : ℕ) : + AnalyticOnNhd ℂ (fun x=>ramifiedClosed p hp hg eta a rho x w z j) {x : ℂ|1/2w) (fun _=>z) x + differentiableAt_id (differentiableAt_const w) (differentiableAt_const z) hd.2.1 hd.1 j).differentiableWithinAt + +lemma ramifiedClosed_first_analytic_w (eta a rho x z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (ha : ‖a‖≤1) + (hx : (1/2:ℝ)≤x.re) (hz : (1/3:ℝ)≤z.re) (j : ℕ) : + Differentiable ℂ (fun w=>ramifiedClosed p hp hg eta a rho x w z j) := by + intro w + have hd := first_open_region_denominators _ (a^2) 0 0 x z hQ + (by simpa only [norm_pow] using pow_le_one₀ (norm_nonneg a) ha) (by norm_num) (by norm_num) hx hz + exact ramifiedClosed_differentiableAt p hp hg eta a rho (fun _=>x) id (fun _=>z) w + (differentiableAt_const x) differentiableAt_id (differentiableAt_const z) hd.2.1 hd.1 j + +lemma ramifiedClosed_first_analytic_z (eta a rho x w : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (ha : ‖a‖≤1) (hx : (1/2:ℝ)≤x.re) (j : ℕ) : + AnalyticOnNhd ℂ (fun z=>ramifiedClosed p hp hg eta a rho x w z j) {z : ℂ|1/3x) (fun _=>w) id z + (differentiableAt_const x) (differentiableAt_const w) differentiableAt_id hd.2.1 hd.1 j).differentiableWithinAt + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFirstNeighborhood.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFirstNeighborhood.lean new file mode 100644 index 0000000000000000000000000000000000000000..3be30becc49af7836cc8828a254e2168a47cb0bb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFirstNeighborhood.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsFirstRegion + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +theorem unramifiedClosed_first_neighborhood_bound (Q : ℝ) (A eta v x w z : ℂ) (eps : ℝ) + (hQ : 4≤Q) (hA : ‖A‖≤1) (heta : ‖eta‖≤1) (hv : ‖v‖≤1) + (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +lemma first_region_V_half (Q : ℝ) (hQ : 4≤Q) (z : ℂ) (hz : (17/50:ℝ)≤z.re) : + ‖coordV Q z‖≤1/2 := by + rw [coordV_norm Q (by linarith)] + exact rpow_le_half Q _ hQ (by linarith) + +lemma first_region_R_half (Q : ℝ) (hQ : 4≤Q) (a x z : ℂ) (ha : ‖a‖≤1) + (hx : (51/100:ℝ)≤x.re) (hz : (17/50:ℝ)≤z.re) : + ‖evenRatio Q a ((Q:ℂ)^(-x)) (coordV Q z)‖≤1/2 := by + rw [evenRatio_eq_coordR Q (by linarith)] + apply (coordR_norm_le Q (by linarith) (a^2) x z (by simpa only [norm_pow] using pow_le_one₀ (norm_nonneg a) ha)).trans + exact rpow_le_half Q _ hQ (by linarith) + +include hc in +lemma rowBaseFinite_first_region (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (51/100:ℝ)≤x.re) (hw : -(1/100:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) + (hxw : 1≤x.re+w.re) (j e l : ℕ) (hj : j<6) + (hf : (e=0 ∧ l=2) ∨ (e=1 ∧ l=0) ∨ (e=0 ∧ l=1) ∨ (e=1 ∧ l=1)) : + ‖rowBaseFinite p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l‖≤16 := by + have hv := ProbeLocal.inv_one_sub_norm_le_two _ (first_region_V_half _ hQ z hz) + have ht' (k : Fin 2) (m : ℕ) : + ‖rowMarkedTerm p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l k.val m‖≤2 := by + have ht : e+3*l≠0 := by rcases hf with h|h|h|h <;> omega + rw [←sourceRowTerm_pos p hp hg eta a rho x w z j e l k.val m ht] + exact sourceRowTerm_first_base p hp hg hc eta a rho x w z heta ha hρ hx hw hz hxw + j e l k.val m hj (by omega) hf + unfold rowBaseFinite + apply (norm_sum_le _ _).trans + calc + _ ≤ ∑ _k : Fin 2,(8:ℝ) := by + apply Finset.sum_le_sum + intro k hk + apply (norm_add_le _ _).trans + have hab := (norm_add_le _ _).trans (add_le_add (ht' k 0) (ht' k 1)) + have hd : ‖rowMarkedTerm p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l k.val 2/(1-coordV (Ideal.absNorm (Ideal.span {p})) z)‖≤4 := by + rw [div_eq_mul_inv,norm_mul] + exact (mul_le_mul (ht' k 2) hv (norm_nonneg _) (by norm_num)).trans_eq (by norm_num) + linarith + _ = _ := by norm_num + +include hc in +theorem rowClosedMarked_first_region (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (51/100:ℝ)≤x.re) (hw : -(1/100:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) (hxw : 1≤x.re+w.re) (j : ℕ) (hj : j<6) : + ‖rowClosedMarked p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j‖≤128 := by + have h02 := rowBaseFinite_first_region p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz hxw j 0 2 hj (by omega) + have h10 := rowBaseFinite_first_region p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz hxw j 1 0 hj (by omega) + have h01 := rowBaseFinite_first_region p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz hxw j 0 1 hj (by omega) + have h11 := rowBaseFinite_first_region p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz hxw j 1 1 hj (by omega) + have hr := ProbeLocal.inv_one_sub_norm_le_two _ (first_region_R_half _ hQ a x z ha hx hz) + simp only [Complex.ofReal_natCast] at hr + unfold rowClosedMarked + rw [div_eq_mul_inv,norm_mul] + apply (mul_le_mul_of_nonneg_right + ((norm_add_le _ _).trans (add_le_add + ((norm_add_le _ _).trans (add_le_add + ((norm_add_le _ _).trans (add_le_add h02 h10)) h01)) h11)) (norm_nonneg _)).trans + nlinarith + +include hc in +theorem ramifiedClosed_first_region_bound (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (51/100:ℝ)≤x.re) (hw : -(1/100:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) (hxw : 1≤x.re+w.re) (j : ℕ) (hj : j<6) : + ‖ramifiedClosed p hp hg eta a rho x w z j‖≤193 := by + have hb := rowClosedMarked_first_region p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz hxw j hj + have hv := first_region_V_half _ hQ z hz + have hs := norm_sub_le (1:ℂ) (coordV (Ideal.absNorm (Ideal.span {p})) z) + simp only [norm_one] at hs + unfold ramifiedClosed + apply (norm_add_le _ _).trans + rw [norm_one,norm_mul] + have hm := mul_le_mul (show ‖1-coordV (Ideal.absNorm (Ideal.span {p})) z‖≤3/2 by linarith) + hb (norm_nonneg _) (by norm_num : (0:ℝ)≤3/2) + linarith + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFirstRegion.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFirstRegion.lean new file mode 100644 index 0000000000000000000000000000000000000000..4d48c458a292d81dc9a097120cde2b5fdf67fd4f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsFirstRegion.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsHolomorphic + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +theorem unramifiedClosed_first_region_bound (Q : ℝ) (A eta v x w z : ℂ) (eps : ℝ) + (hQ : 4≤Q) (hA : ‖A‖≤1) (heta : ‖eta‖≤1) (hv : ‖v‖≤1) + (heps : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +lemma pow_mul_sqrt (Q : ℝ) (hQ : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) + +lemma rowMarkedTerm_differentiableAt (eta a rho : ℂ) (X W V : ℂ→ℂ) (t : ℂ) + (hX : DifferentiableAt ℂ X t) (hW : DifferentiableAt ℂ W t) (hV : DifferentiableAt ℂ V t) + (j e l k m : ℕ) : + DifferentiableAt ℂ (fun s=>rowMarkedTerm p hp hg eta a (X s) (W s) (V s) rho j e l k m) t := by + unfold rowMarkedTerm + split_ifs + · fun_prop + · unfold rowWeightedScalar weightedScalar + fun_prop + +lemma rowBaseFinite_differentiableAt (eta a rho : ℂ) (X W V : ℂ→ℂ) (t : ℂ) + (hX : DifferentiableAt ℂ X t) (hW : DifferentiableAt ℂ W t) (hV : DifferentiableAt ℂ V t) + (hv : 1-V t≠0) (j e l : ℕ) : + DifferentiableAt ℂ (fun s=>rowBaseFinite p hp hg eta a (X s) (W s) (V s) rho j e l) t := by + have hd (k m : ℕ) := rowMarkedTerm_differentiableAt p hp hg eta a rho X W V t hX hW hV j e l k m + unfold rowBaseFinite + fun_prop (disch := assumption) + +lemma rowClosedMarked_differentiableAt (eta a rho : ℂ) (X W V : ℂ→ℂ) (t : ℂ) + (hX : DifferentiableAt ℂ X t) (hW : DifferentiableAt ℂ W t) (hV : DifferentiableAt ℂ V t) + (hv : 1-V t≠0) (hr : 1-evenRatio (Ideal.absNorm (Ideal.span {p})) a (X t) (V t)≠0) (j : ℕ) : + DifferentiableAt ℂ (fun s=>rowClosedMarked p hp hg eta a (X s) (W s) (V s) rho j) t := by + have hd (e l : ℕ) := rowBaseFinite_differentiableAt p hp hg eta a rho X W V t hX hW hV hv j e l + have hR : DifferentiableAt ℂ (fun s=>evenRatio (Ideal.absNorm (Ideal.span {p})) a (X s) (V s)) t := by + unfold evenRatio + fun_prop + unfold rowClosedMarked + fun_prop (disch := assumption) + +lemma ramifiedClosed_differentiableAt (eta a rho : ℂ) (X W Z : ℂ→ℂ) (t : ℂ) + (hX : DifferentiableAt ℂ X t) (hW : DifferentiableAt ℂ W t) (hZ : DifferentiableAt ℂ Z t) + (hv : 1-coordV (Ideal.absNorm (Ideal.span {p})) (Z t)≠0) + (hr : 1-coordR (Ideal.absNorm (Ideal.span {p})) (a^2) (X t) (Z t)≠0) (j : ℕ) : + DifferentiableAt ℂ (fun s=>ramifiedClosed p hp hg eta a rho (X s) (W s) (Z s) j) t := by + have hQ : (0:ℝ)(Ideal.absNorm (Ideal.span {p}):ℂ)^(-X s)) t := by + exact hX.neg.const_cpow (Or.inl (by exact_mod_cast hQ.ne')) + have hcw : DifferentiableAt ℂ (fun s=>(Ideal.absNorm (Ideal.span {p}):ℂ)^(-W s)) t := by + exact hW.neg.const_cpow (Or.inl (by exact_mod_cast hQ.ne')) + have hcv := (coordV_differentiable _ hQ).differentiableAt.comp t hZ + change DifferentiableAt ℂ (fun s=>coordV (Ideal.absNorm (Ideal.span {p})) (Z s)) t at hcv + have hr' := evenRatio_eq_coordR (Ideal.absNorm (Ideal.span {p}):ℝ) hQ a (X t) (Z t) + simp only [Complex.ofReal_natCast] at hr' + have hd := rowClosedMarked_differentiableAt p hp hg eta a rho _ _ _ t hcx hcw hcv hv + (by rw [hr'];exact hr) j + unfold ramifiedClosed + fun_prop + +lemma ramifiedClosed_analytic_x (eta a rho w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (ha : ‖a‖≤1) (hz : (4/25:ℝ)≤z.re) (j : ℕ) : + AnalyticOnNhd ℂ (fun x=>ramifiedClosed p hp hg eta a rho x w z j) {x : ℂ|7/8w) (fun _=>z) x + differentiableAt_id (differentiableAt_const w) (differentiableAt_const z) hd.2.1 hd.1 j).differentiableWithinAt + +lemma ramifiedClosed_analytic_w (eta a rho x z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (ha : ‖a‖≤1) + (hx : (7/8:ℝ)≤x.re) (hz : (4/25:ℝ)≤z.re) (j : ℕ) : + Differentiable ℂ (fun w=>ramifiedClosed p hp hg eta a rho x w z j) := by + intro w + have hd := open_region_denominators _ (a^2) 0 0 x z hQ + (by simpa only [norm_pow] using pow_le_one₀ (norm_nonneg a) ha) (by norm_num) (by norm_num) hx hz + exact ramifiedClosed_differentiableAt p hp hg eta a rho (fun _=>x) id (fun _=>z) w + (differentiableAt_const x) differentiableAt_id (differentiableAt_const z) hd.2.1 hd.1 j + +lemma ramifiedClosed_analytic_z (eta a rho x w : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (ha : ‖a‖≤1) (hx : (7/8:ℝ)≤x.re) (j : ℕ) : + AnalyticOnNhd ℂ (fun z=>ramifiedClosed p hp hg eta a rho x w z j) {z : ℂ|4/25x) (fun _=>w) id z + (differentiableAt_const x) (differentiableAt_const w) differentiableAt_id hd.2.1 hd.1 j).differentiableWithinAt + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsLocal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsLocal.lean new file mode 100644 index 0000000000000000000000000000000000000000..328fa569dd2ac592f2eadbd50d67648f6318dd9a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsLocal.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsExcluded + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def rowHighPrimeTerm (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (P : PrimeIdeal) (b : HighValuation) : ℂ := + bareIdealHighSummand η u x w z (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2) + +def idealRowHighLocalFactor (η : HeckeFamily.Character) (u : O) (P : Id) (x w z : ℂ) : ℂ := + ∑ e : Fin 2, ∑' l : ℕ, ∑' k : ℕ, ∑' m : ℕ, + bareIdealHighSummand η u x w z (P^e.val) (P^l) (P^k) (P^m) + +lemma rowHighPrimeTerm_summable_norm (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2‖rowHighPrimeTerm η u x w z P b‖) := by + have hs := ((bareIdealHighSummand_summable η u x w z hx hw hz).norm.comp_injective + highIdeals_injective).comp_injective (Finsupp.single_injective P) + simpa only [Function.comp_def,highIdeals_single,rowHighPrimeTerm] using hs + +lemma rowHighPrimeTerm_zero_of_two_le (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (P : PrimeIdeal) (e l k m : ℕ) (he : 2≤e) : + rowHighPrimeTerm η u x w z P ((e,l),(k,m))=0 := by + by_contra hn + have hs := bareIdealHighSummand_support η u x w z (P.val^e) (P.val^l) (P.val^k) (P.val^m) hn + have hc := hs.1.eq_zero_or_one_of_pow_of_not_isUnit P.property.not_isUnit + omega + +theorem rowHighPrimeTerm_tsum_eq_localFactor (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2by + have hh : 2≤e := Nat.le_of_not_gt (by simpa only [Finset.mem_range] using he) + simp only [rowHighPrimeTerm_zero_of_two_le η u x w z P e _ _ _ hh,tsum_zero]), + ←Fin.sum_univ_eq_sum_range] + rfl + +theorem bareIdealHighSeries_row_hasProd_localFactor (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2idealRowHighLocalFactor η u P.val x w z) + (bareIdealHighSeries η u x w z) := by + have h := bareIdealHighSeries_row_hasProd η u x w z hx hw hz + change HasProd (fun P : PrimeIdeal=>∑' b : HighValuation,rowHighPrimeTerm η u x w z P b) _ at h + simpa only [rowHighPrimeTerm_tsum_eq_localFactor η u x w z hx hw hz] using h + +theorem excludedRowHighLocalFactor (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2idealRowHighLocalFactor η u P.val.val x w z) + (markedIdealHighSeries S 1 η u x w z) := by + have h := excludedIdealHighSeries_row_hasProd S hS η u x w z hx hw hz + simp only [excludedRowHighLocalFactor S hS η u x w z hx hw hz] at h + apply (hasProd_subtype_iff_mulIndicator + (s:={P : PrimeIdeal | P.val∉S}) + (f:=fun P : PrimeIdeal=>idealRowHighLocalFactor η u P.val x w z)).mpr + convert h using 1 + funext P + simp only [Set.mulIndicator,Set.mem_ofPred_eq] + split_ifs <;> simp_all + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsMultiplicative.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsMultiplicative.lean new file mode 100644 index 0000000000000000000000000000000000000000..e993a43e2ddf9d2bac0603d2666bcedf137b5700 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsMultiplicative.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Detector.HighEulerGeneral +import OAI.NumberTheory.DirichletL.Detector.SixthFrequency + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ConcretePrimeRowBridge CubicEisenstein +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem bareSourceCoefficient_product_row_frequency (η : HeckeFamily.Character) (u : O) (I J : Ideal O) + (hI : CubicSieve.Admissible I) (hJ : CubicSieve.Admissible J) + (hIJ : CubicSieve.Admissible (I*J)) (hIJcop : IsCoprime I J) + (n m s r : O) + (hc : Supported (Ideal.span {primaryGenerator I})) (hd : Supported (Ideal.span {primaryGenerator J})) + (hn : Supported (Ideal.span {n})) (hm : Supported (Ideal.span {m})) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hpc : goodLambda^2∣primaryGenerator I-1) (hpd : goodLambda^2∣primaryGenerator J-1) + (hpn : goodLambda^2∣n-1) (hpm : goodLambda^2∣m-1) + (hps : goodLambda^2∣s-1) (hpr : goodLambda^2∣r-1) + (hcop : IsCoprime ((primaryGenerator I*n^3)*s) ((primaryGenerator J*m^3)*r)) (a b : O) + (hba : IsCoprime b ((primaryGenerator I*n^3)*s)) + (hab : IsCoprime a ((primaryGenerator J*m^3)*r)) : + let A := primaryGenerator I*n^3 + let B := primaryGenerator J*m^3 + let hA := supportedElement_ne_zero A (supported_completed _ _ hc hn) + let hB := supportedElement_ne_zero B (supported_completed _ _ hd hm) + bareSourceCoefficient η (I*J) hIJ.2 (A*B) (s*r) (mul_ne_zero hA hB) (u*(a*b)^6) = + bareSourceCoefficient η I hI.2 A s hA (u*a^6) * bareSourceCoefficient η J hJ.2 B r hB (u*b^6) := by + have he := bareSourceCoefficient_product η I J hI hJ hIJ hIJcop n m s r + hc hd hn hm hs hr hpc hpd hpn hpm hps hpr hcop (u*(a*b)^6) + dsimp only at he ⊢ + have hi := bareSourceCoefficient_sixth_frequency η I hI.2 (primaryGenerator I*n^3) s + (supported_completed _ _ hc hn) hs b (u*a^6) hba + have hj := bareSourceCoefficient_sixth_frequency η J hJ.2 (primaryGenerator J*m^3) r + (supported_completed _ _ hd hm) hr a (u*b^6) hab + rw [show b^6*(u*a^6)=u*(a*b)^6 by ring] at hi + rw [show a^6*(u*b^6)=u*(a*b)^6 by ring] at hj + rw [hi,hj] at he + exact he + +theorem bareIdealHighCoefficient_row_mul (η : HeckeFamily.Character) (u : O) + (I J K L I' J' K' L' : Id) + (hcop : IsCoprime (I*J*K*L) (I'*J'*K'*L')) : + bareIdealHighCoefficient η u (I*I') (J*J') (K*K') (L*L') = + bareIdealHighCoefficient η u I J K L * bareIdealHighCoefficient η u I' J' K' L' := by + have hII := hcop.mono (first_block_dvd I J K L) (first_block_dvd I' J' K' L') + by_cases h : highSupport I J K L ∧ highSupport I' J' K' L' + · have hprod := (highSupport_mul I J K L I' J' K' L' hII).mpr h + rcases h with ⟨h,h'⟩ + have hsA := (supported_mul_iff (I*J^3) K).mpr + ⟨(supported_mul_iff I (J^3)).mpr ⟨h.2.1,supported_pow h.2.2.1 3⟩,h.2.2.2.1⟩ + have hsB := (supported_mul_iff (I'*J'^3) K').mpr + ⟨(supported_mul_iff I' (J'^3)).mpr ⟨h'.2.1,supported_pow h'.2.2.1 3⟩,h'.2.2.2.1⟩ + have hc3 : IsCoprime ((I*J*K*L)^3) ((I'*J'*K'*L')^3) := hcop.pow_left.pow_right + have hab := primaryGenerator_coprime _ _ hsA hsB + (hc3.mono (completed_block_dvd_cube I J K L) (completed_block_dvd_cube I' J' K' L')) + have hba := primaryGenerator_coprime _ _ h'.2.2.2.2 hsA + (hcop.symm.pow_right.mono (last_block_dvd I' J' K' L') (completed_block_dvd_cube I J K L)) + have hab' := primaryGenerator_coprime _ _ h.2.2.2.2 hsB + (hcop.pow_right.mono (last_block_dvd I J K L) (completed_block_dvd_cube I' J' K' L')) + simp only [primaryGenerator_mul,primaryGenerator_pow] at hab hba hab' + have he := bareSourceCoefficient_product_row_frequency η u I I' + ⟨h.1,supported_primaryGenerator_ne_zero I h.2.1⟩ + ⟨h'.1,supported_primaryGenerator_ne_zero I' h'.2.1⟩ + ⟨hprod.1,supported_primaryGenerator_ne_zero (I*I') hprod.2.1⟩ hII + (primaryGenerator J) (primaryGenerator J') (primaryGenerator K) (primaryGenerator K') + ((supported_span_primaryGenerator_iff I).mpr h.2.1) + ((supported_span_primaryGenerator_iff I').mpr h'.2.1) + ((supported_span_primaryGenerator_iff J).mpr h.2.2.1) + ((supported_span_primaryGenerator_iff J').mpr h'.2.2.1) + ((supported_span_primaryGenerator_iff K).mpr h.2.2.2.1) + ((supported_span_primaryGenerator_iff K').mpr h'.2.2.2.1) + (primaryGenerator_spec I (supported_primaryGenerator_ne_zero I h.2.1)).2 + (primaryGenerator_spec I' (supported_primaryGenerator_ne_zero I' h'.2.1)).2 + (primaryGenerator_spec J (supported_primaryGenerator_ne_zero J h.2.2.1)).2 + (primaryGenerator_spec J' (supported_primaryGenerator_ne_zero J' h'.2.2.1)).2 + (primaryGenerator_spec K (supported_primaryGenerator_ne_zero K h.2.2.2.1)).2 + (primaryGenerator_spec K' (supported_primaryGenerator_ne_zero K' h'.2.2.2.1)).2 + hab (primaryGenerator L) (primaryGenerator L') hba hab' + unfold highSupport at hprod h h' + unfold bareIdealHighCoefficient + rw [dite_eq_left hprod,dite_eq_left h,dite_eq_left h'] + simp only [primaryGenerator_mul] + dsimp only at he + convert he using 1 ; ring_nf + · have hprod := mt (highSupport_mul I J K L I' J' K' L' hII).mp h + unfold highSupport at hprod + unfold bareIdealHighCoefficient + rw [dite_eq_right hprod] + by_cases hi : highSupport I J K L + · have hj : ¬highSupport I' J' K' L' := fun hj=>h ⟨hi,hj⟩ + unfold highSupport at hj + rw [dite_eq_right hj,mul_zero] + · unfold highSupport at hi + rw [dite_eq_right hi,zero_mul] + +theorem bareIdealHighSummand_row_mul (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (I J K L I' J' K' L' : Id) + (hcop : IsCoprime (I*J*K*L) (I'*J'*K'*L')) : + bareIdealHighSummand η u x w z (I*I') (J*J') (K*K') (L*L') = + bareIdealHighSummand η u x w z I J K L * bareIdealHighSummand η u x w z I' J' K' L' := by + unfold bareIdealHighSummand + rw [bareIdealHighCoefficient_row_mul η u I J K L I' J' K' L' hcop, + fullIdealWeight_mul,fullIdealWeight_mul,fullIdealWeight_mul,fullIdealWeight_mul] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsPrime.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsPrime.lean new file mode 100644 index 0000000000000000000000000000000000000000..bef09507dc3d967f3cf7a7f7d1c3bd1fa19aeb60 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsPrime.lean @@ -0,0 +1,154 @@ +import OAI.NumberTheory.DirichletL.Detector.LocalUnitFrequency +import OAI.NumberTheory.DirichletL.Detector.HighRowsSeries +import OAI.NumberTheory.DirichletL.Detector.HighRowsLocal + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +def sourceRowTerm (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (eta a rho x w z : ℂ) (j e l k m : ℕ) : ℂ := + (rho^k/rho^(e+3*l))*sourceWeightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (localGamma p hp.ne_zero hg 1) (star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) x w z + (sourceScalar p hp hg (e+3*l) k (j+6*m)) e l k m + +theorem sourceRowTerm_pos (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (eta a rho x w z : ℂ) (j e l k m : ℕ) + (ht : e+3*l≠0) : + sourceRowTerm p hp hg eta a rho x w z j e l k m= + rowMarkedTerm p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l k m := by + unfold sourceRowTerm + rw [sourceWeightedScalar_actual p hp hg] + simp only [rowMarkedTerm,rowWeightedScalar,sourceScalar,ite_eq_right ht,coordV,Complex.ofReal_natCast] + +end SevenEighths.ProbeEuler +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ConcretePrimeRowBridge CubicEisenstein ProbePhase ProbeEuler ProbePrimePower ProbeRow +local notation "O" => ActualEisensteinCubic.O + +theorem bareSourceCoefficient_unit_frequency (η : HeckeFamily.Character) + (I : Ideal O) (hI : primaryGenerator I≠0) (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (b H : O) (hcop : IsCoprime b (A*s)) : + bareSourceCoefficient η I hI A s (supportedElement_ne_zero A hA) (b*H)= + ((idealRowHom b (Ideal.span {A}))⁻¹*idealRowHom b (Ideal.span {s}))* + bareSourceCoefficient η I hI A s (supportedElement_ne_zero A hA) H := by + unfold bareSourceCoefficient correctedFiniteCoefficient reciprocityCoefficient + rw [bareCongruenceCoefficient_unit_frequency A s hA hs b H hcop] + ring + +theorem bareSourceCoefficient_row_prime_formula (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (b : O) (hb : IsCoprime b p) + (e l k j : ℕ) (he : e≤1) (hI : primaryGenerator (Ideal.span {p^e})≠0) : + bareSourceCoefficient η (Ideal.span {p^e}) hI (p^(e+3*l)) (p^k) + (pow_ne_zero _ hp.ne_zero) (b*p^j)= + ((actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^k / + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^(e+3*l)) * + ((-1:ℂ)^e * ((localGamma p hp.ne_zero hg 1)⁻¹)^e * (targetMonoid η p)^e * + (star (FiniteGaussPhase.angularFactor p)^3 * (targetMonoid η p)^3 * + star (localGamma p hp.ne_zero hg 3))^l * + (actualSextic (Ideal.span {p}) hg (-1))^((e+3*l)*k+e*l+l.choose 2) * + sourceScalar p hp hg (e+3*l) k j) := by + rw [bareSourceCoefficient_unit_frequency η _ hI _ _ + (supported_element_power p hs _) (supported_element_power p hs _) b _ + (hb.pow_right.mul_right hb.pow_right), + bareSourceCoefficient_prime_formula η p hp hg hchar hprimary hs e l k j he hI, + idealRowHom_prime_power_value p b hg,idealRowHom_prime_power_value p b hg] + simp only [div_eq_mul_inv] + ac_rfl + +theorem bareSourceCoefficient_row_weighted_prime (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (b : O) (hb : IsCoprime b p) (j e l k m : ℕ) (he : e≤1) + (hI : primaryGenerator (Ideal.span {p^e})≠0) (x w z : ℂ) : + bareSourceCoefficient η (Ideal.span {p^e}) hI (p^(e+3*l)) (p^k) + (pow_ne_zero _ hp.ne_zero) (b*p^(j+6*m)) * + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(x+1/2)*(e:ℂ)-(1+3*x)*(l:ℂ)-w*(k:ℂ)-6*z*(m:ℂ)) = + sourceRowTerm p hp hg (targetMonoid η p) (actualACube η p) + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)) x w z j e l k m := by + rw [bareSourceCoefficient_row_prime_formula η p hp hg hchar hprimary hs b hb e l k (j+6*m) he hI] + unfold sourceRowTerm sourceWeightedScalar + simp only [zpow_neg,zpow_natCast,←inv_pow,Complex.ofReal_natCast] + have hpdiag := source_signed_phase + (actualACube η p*star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) (actualSextic_neg_one_sq _ hg) e l k + simp only [localCubePhase] at hpdiag + have ha : actualACube η p= + star (FiniteGaussPhase.angularFactor p)^3*(targetMonoid η p)^3 := rfl + rw [ha] at hpdiag ⊢ + linear_combination -((actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^k / + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^(e+3*l)) * + ((-1:ℂ)^e*((localGamma p hp.ne_zero hg 1)⁻¹)^e*(targetMonoid η p)^e) * + sourceScalar p hp hg (e+3*l) k (j+6*m) * + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(x+1/2)*(e:ℂ)-(1+3*x)*(l:ℂ)-w*(k:ℂ)-6*z*(m:ℂ)) * hpdiag + +theorem bareIdealHighCoefficient_row_at_prime (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (u : O) (e l k m : ℕ) (he : e≤1) : + bareIdealHighCoefficient η u ((Ideal.span {p})^e) ((Ideal.span {p})^l) + ((Ideal.span {p})^k) ((Ideal.span {p})^m) = + bareSourceCoefficient η (Ideal.span {p^e}) + (by rw [← Ideal.span_singleton_pow,primaryGenerator_prime_power p hp.ne_zero hprimary e]; + exact pow_ne_zero _ hp.ne_zero) + (p^(e+3*l)) (p^k) (pow_ne_zero _ hp.ne_zero) (u*p^(6*m)) := by + have hguard : Squarefree ((Ideal.span {p})^e) ∧ Supported ((Ideal.span {p})^e) ∧ + Supported ((Ideal.span {p})^l) ∧ Supported ((Ideal.span {p})^k) ∧ Supported ((Ideal.span {p})^m) := + ⟨prime_power_small_squarefree p hp e he,supported_pow hs e,supported_pow hs l,supported_pow hs k,supported_pow hs m⟩ + unfold bareIdealHighCoefficient + rw [dite_eq_left hguard] + simp only [primaryGenerator_prime_power p hp.ne_zero hprimary] + have hA : p^e*(p^l)^3=p^(e+3*l) := by rw [←pow_mul,Nat.mul_comm l 3,←pow_add] + have hH : (p^m)^6=p^(6*m) := by rw [←pow_mul,Nat.mul_comm m 6] + simp only [hA,hH,Ideal.span_singleton_pow] + +theorem bareIdealHighSummand_row_at_prime (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (b : O) (hb : IsCoprime b p) + (j e l k m : ℕ) (he : e≤1) (x w z : ℂ) : + bareIdealHighSummand η (b*p^j) x w z ((Ideal.span {p})^e) ((Ideal.span {p})^l) + ((Ideal.span {p})^k) ((Ideal.span {p})^m)= + sourceRowTerm p hp hg (targetMonoid η p) (actualACube η p) + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)) x w z j e l k m := by + unfold bareIdealHighSummand + rw [bareIdealHighCoefficient_row_at_prime η p hp hprimary hs (b*p^j) e l k m he] + rw [show b*p^j*p^(6*m)=b*p^(j+6*m) by rw [pow_add]; ring] + have hw := prime_spectral_weights p hp.ne_zero e l k m x w z + simp only [mul_assoc] at hw ⊢ + rw [hw] + simpa only [mul_assoc] using + bareSourceCoefficient_row_weighted_prime η p hp hg hchar hprimary hs b hb j e l k m he _ x w z + +theorem idealRowHighLocalFactor_eq_source (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (b : O) (hb : IsCoprime b p) (j : ℕ) (x w z : ℂ) : + idealRowHighLocalFactor η (b*p^j) (Ideal.span {p}) x w z= + ∑ e : Fin 2,∑' l,∑' k,∑' m,sourceRowTerm p hp hg (targetMonoid η p) (actualACube η p) + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b)) x w z j e.val l k m := by + unfold idealRowHighLocalFactor + apply Finset.sum_congr rfl + intro e he + apply tsum_congr + intro l + apply tsum_congr + intro k + apply tsum_congr + intro m + exact bareIdealHighSummand_row_at_prime η p hp hg hchar hprimary hs b hb j e.val l k m (by omega) x w z + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRamified.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRamified.lean new file mode 100644 index 0000000000000000000000000000000000000000..0a74f80b76ad69b5d66500f5caef470c19b50292 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRamified.lean @@ -0,0 +1,52 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsFiniteBounds + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +def ramifiedClosed (eta a rho x w z : ℂ) (j : ℕ) : ℂ := + 1+(1-coordV (Ideal.absNorm (Ideal.span {p})) z)* + rowClosedMarked p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j + +include hc in +theorem ramifiedClosed_bound (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (7/8:ℝ)≤x.re) (hw : (19/20:ℝ)≤w.re) (hz : (33/200:ℝ)≤z.re) (j : ℕ) : + ‖ramifiedClosed p hp hg eta a rho x w z j‖≤193 := by + have hb := rowClosedMarked_second_region p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz j + have hv := second_region_V_half _ hQ z hz + have hs := norm_sub_le (1:ℂ) (coordV (Ideal.absNorm (Ideal.span {p})) z) + simp only [norm_one] at hs + unfold ramifiedClosed + apply (norm_add_le _ _).trans + rw [norm_one,norm_mul] + have hm := mul_le_mul (show ‖1-coordV (Ideal.absNorm (Ideal.span {p})) z‖≤3/2 by linarith) + hb (norm_nonneg _) (by norm_num : (0:ℝ)≤3/2) + linarith + +include hc in + +theorem sourceRowSeries_ramified (eta a rho x w z : ℂ) (hρ : rho^6=1) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) (coordV (Ideal.absNorm (Ideal.span {p})) z)‖<1) + (hW : ‖rho*((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w))‖<1) + (j : ℕ) (hj0 : j≠0) (hj : j<6) : + sourceRowSeries p hp hg eta a rho x w z j*(1-coordV (Ideal.absNorm (Ideal.span {p})) z)= + ramifiedClosed p hp hg eta a rho x w z j := by + rw [sourceRowSeries_eq_closed p hp hg hc eta a rho x w z hρ hV hR hW j hj,ite_eq_right hj0,add_zero] + unfold ramifiedClosed + have hn := one_sub_ne_zero_of_norm_lt_one _ hV + field_simp + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRecurrence.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRecurrence.lean new file mode 100644 index 0000000000000000000000000000000000000000..a787e44108b7f673823667faa77c446af0e6b679 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRecurrence.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsScalar + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +lemma gaussValuationTable_step_six (Q G : ℂ) (r n j : ℕ) : + gaussValuationTable Q G (r+6) (n+6) (j+6)=Q^6*gaussValuationTable Q G r n j := by + have hd : 6∣r+6 ↔ 6∣r := by omega + have hle : n+6+1≤j+6 ↔ n+1≤j := by omega + have hle' : n+6≤j+6 ↔ n≤j := by omega + have he : j+6=n+6 ↔ j=n := by omega + simp only [gaussValuationTable,hd,hle,hle',he] + split_ifs <;> simp [pow_add] <;> ring + +theorem positiveScalar_step_six (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (n k j : ℕ) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (n+6) k (j+6)= + (Ideal.absNorm (Ideal.span {p}):ℂ)^6* + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) n k j := by + rw [positiveScalar_actual_table p hp hg hc,positiveScalar_actual_table p hp hg hc] + have hp6 (a : ℕ) : actualSextic (Ideal.span {p}) hg^(a+6)= + actualSextic (Ideal.span {p}) hg^a := by + rw [pow_add,actualSextic_six _ hg hc,mul_one] + by_cases hk : k=0 + · simp only [hk,ite_true] + rw [show n+6+1=(n+1)+6 by omega,hp6,gaussValuationTable_step_six] + · simp only [ite_eq_right hk] + by_cases hk1 : k=1 + · subst k + by_cases hj : 1≤j + · rw [ite_eq_left ⟨rfl,by omega⟩,ite_eq_left ⟨rfl,hj⟩,hp6, + show j+6-1=(j-1)+6 by omega,gaussValuationTable_step_six] + ring + · have hz : j=0 := by omega + subst j + simp only [show (1:ℕ)≤0+6 by omega,show ¬(1:ℕ)≤0 by omega, + and_true,and_false,ite_true,ite_false,mul_zero] + simp only [gaussValuationTable] + split_ifs <;> simp_all ; omega + · rw [ite_eq_right (by omega),ite_eq_right (by omega),mul_zero] + +theorem positiveScalar_zero_below (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (n k j : ℕ) (hj : j simp_all <;> omega + · have hbelow : j-1 simp_all <;> omega + rw [hz,mul_zero] + · rfl + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRegion.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRegion.lean new file mode 100644 index 0000000000000000000000000000000000000000..01b4b00cfd45bd6e4aae9a66cf684ab839b080f7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsRegion.lean @@ -0,0 +1,62 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsUnramified +import OAI.NumberTheory.DirichletL.Detector.HighEulerRational + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +open ProbeEuler ProbeRow ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +lemma row_initial_geometric (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hc : ringChar (O ⧸ Ideal.span {p})≠2) (b : O) (hb : IsCoprime b p) + (x w z : ℂ) (hx : 3/2 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) +include hc + +theorem row_even_kzero (r m j : ℕ) (hj : j<6) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r+5) 0 (j+6*m) = + if r+1≤m then + (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+5)*((Ideal.absNorm (Ideal.span {p}):ℂ)-1) + else if j=5 ∧ m=r then -(Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+5) else 0 := by + rw [positiveScalar_kzero,actualSextic_primePowerGauss_at_pow p hp hg hc, + ite_eq_left (by omega : 6∣6*r+5+1)] + by_cases hm : r+1≤m + · rw [ite_eq_left hm,ite_eq_left (by omega),ite_eq_left (by omega),pow_succ] + ring + · rw [ite_eq_right hm,ite_eq_right (by omega)] + by_cases hb : j=5 ∧ m=r + · rw [ite_eq_left hb,ite_eq_left (by omega),zero_sub] + · rw [ite_eq_right hb,ite_eq_right (by omega),sub_self] + +theorem row_nonprincipal_kzero (r m j d : ℕ) (hj : j<6) (hd : d<5) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r+d) 0 (j+6*m) = + if j=d ∧ m=r then + (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+d)* + primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg^(d+1)) 1 + else 0 := by + rw [positiveScalar_kzero,actualSextic_primePowerGauss_at_pow p hp hg hc, + ite_eq_right (by omega : ¬6∣6*r+d+1)] + rw [show 6*r+d+1=6*r+(d+1) by omega,actualSextic_pow_six_mul_add _ hg hc] + have he : j+6*m=6*r+d ↔ j=d ∧ m=r := by omega + simp only [he] + +theorem row_squarefree_kone (r m j : ℕ) (hj : j<6) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r) 1 (j+6*m) = + ((actualSextic (Ideal.span {p}) hg (-1))⁻¹ * + primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1) * + (if 6*r+1 ActualEisensteinCubic.O + +lemma primeGauss_norm_le (p : O) (hp : p≠0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (h : O) : + ‖primeGauss p hp χ h‖≤(Ideal.absNorm (Ideal.span {p}):ℝ) := by + let := finite_quotient_span hp + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + rw [primeGauss,tsum_fintype] + calc + _ ≤ ∑ x : O ⧸ Ideal.span {p},‖χ x*quotientTrace p hp (Ideal.Quotient.mk _ h*x)‖ := norm_sum_le _ _ + _ ≤ ∑ _x : O ⧸ Ideal.span {p},(1:ℝ) := Finset.sum_le_sum fun x _=>by + rw [norm_mul,(quotientTrace p hp).norm_apply,mul_one] + exact QuadraticInitialBound.norm_finite_character_le_one χ x + _ = _ := by simp [Ideal.absNorm_apply,Submodule.cardQuot_apply,Nat.card_eq_fintype_card] + +lemma primeGauss_actual_norm (p : O) (hp : p≠0) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) : + ‖primeGauss p hp (actualSextic (Ideal.span {p}) hg) 1‖= + Real.sqrt (Ideal.absNorm (Ideal.span {p}):ℝ) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + have hn := localGamma_norm_one p hp hg hc 1 (by decide) (by decide) + rw [localGamma,ProbePhase.normalizedTraceGauss_eq_normalizedGauss] at hn + simp only [pow_one,ProbeGauss.normalizedGauss,norm_div,Complex.norm_real, + Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _)] at hn + have hQ : (0:ℝ) ActualEisensteinCubic.O + +lemma elementCoeff_zero_or_norm_one (eta : HeckeFamily.Character) (p : O) : + HeckeFamily.elementCoeff eta p=0 ∨ ‖HeckeFamily.elementCoeff eta p‖=1 := by + by_cases h : HeckeFamily.elementCoeff eta p=0 + · exact Or.inl h + · right + let : Finite (O ⧸ eta.modulus) := Ring.HasFiniteQuotients.finiteQuotient eta.modulus_ne_bot + let : Fintype (O ⧸ eta.modulus) := Fintype.ofFinite _ + have hu : IsUnit (Ideal.Quotient.mk eta.modulus p) := eta.residue.apply_ne_zero_iff.mp h + obtain ⟨u,hu⟩ := hu + change ‖eta.residue (Ideal.Quotient.mk eta.modulus p)‖=1 + rw [←hu] + exact FiniteRayExpansion.norm_char_unit eta.residue u + +def actualUnramifiedSelected (eta : HeckeFamily.Character) (p u : O) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) (x w z : ℂ) : ℂ := + unramifiedSelected (Ideal.absNorm (Ideal.span {p})) (actualAPhase eta p) + (HeckeFamily.elementCoeff eta p) + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ u)) x w z + +theorem actualUnramifiedSelected_bound (eta : HeckeFamily.Character) (p u : O) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hc : ringChar (O ⧸ Ideal.span {p})≠2) (hu : IsCoprime u p) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) (x w z : ℂ) + (hx : (7/8:ℝ)≤x.re) (hw : (1/2:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) : + ‖actualUnramifiedSelected eta p u hg x w z‖≤961 := by + have hv := Complex.norm_eq_one_of_pow_eq_one (ProbePhysical.actualSextic_unit_six p u hg hc hu) (by decide : (6:ℕ)≠0) + unfold actualUnramifiedSelected + rcases elementCoeff_zero_or_norm_one eta p with heta|heta + · have hA : actualAPhase eta p=0 := by simp [actualAPhase,heta] + rw [heta,hA] + exact (unramifiedSelected_zero_bound _ _ x w z hQ hv.le hw hz).trans (by norm_num) + · exact unramifiedSelected_bound _ _ _ _ x w z hQ (actualAPhase_norm_le_one eta p) heta hv hx hw hz + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedBound.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..bbad944f0a6ab48e1f92de81a60d02732ff6ae1c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedBound.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsSelectedTerms + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +lemma rowBaseFinite_selected_bound (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (7/8:ℝ)≤x.re) (hw : (1/2:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) + (j e l : ℕ) (hj : j<6) + (hf : (e=0 ∧ l=2) ∨ (e=1 ∧ l=0) ∨ (e=0 ∧ l=1) ∨ (e=1 ∧ l=1)) : + ‖rowBaseFinite p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l‖≤16*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by + have hpow : 0≤(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by positivity + have hv := ProbeLocal.inv_one_sub_norm_le_two _ (first_region_V_half _ hQ z hz) + have ht' (k : Fin 2) (m : ℕ) : + ‖rowMarkedTerm p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l k.val m‖≤2*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by + have ht : e+3*l≠0 := by rcases hf with h|h|h|h <;> omega + rw [←sourceRowTerm_pos p hp hg eta a rho x w z j e l k.val m ht] + exact sourceRowTerm_selected_base p hp hg hc eta a rho x w z heta ha hρ hx hw hz + j e l k.val m hj (by omega) hf + unfold rowBaseFinite + apply (norm_sum_le _ _).trans + calc + _ ≤ ∑ _k : Fin 2,8*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by + apply Finset.sum_le_sum + intro k hk + apply (norm_add_le _ _).trans + have hab := (norm_add_le _ _).trans (add_le_add (ht' k 0) (ht' k 1)) + have hd : ‖rowMarkedTerm p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) + rho j e l k.val 2/(1-coordV (Ideal.absNorm (Ideal.span {p})) z)‖≤4*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by + rw [div_eq_mul_inv,norm_mul] + exact (mul_le_mul (ht' k 2) hv (norm_nonneg _) (by positivity)).trans_eq (by ring) + linarith + _ = _ := by simp;ring + +include hc in +theorem rowClosedMarked_selected_bound (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (7/8:ℝ)≤x.re) (hw : (1/2:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) (j : ℕ) (hj : j<6) : + ‖rowClosedMarked p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j‖≤128*(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by + have hpow : 0≤(Ideal.absNorm (Ideal.span {p}):ℝ)^(-x.re+max (1-w.re) 0) := by positivity + have h02 := rowBaseFinite_selected_bound p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz j 0 2 hj (by omega) + have h10 := rowBaseFinite_selected_bound p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz j 1 0 hj (by omega) + have h01 := rowBaseFinite_selected_bound p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz j 0 1 hj (by omega) + have h11 := rowBaseFinite_selected_bound p hp hg hc eta a rho x w z hQ heta ha hρ hx hw hz j 1 1 hj (by omega) + have hr := ProbeLocal.inv_one_sub_norm_le_two _ (first_region_R_half _ hQ a x z ha (by linarith) hz) + simp only [Complex.ofReal_natCast] at hr + unfold rowClosedMarked + rw [div_eq_mul_inv,norm_mul] + apply (mul_le_mul_of_nonneg_right + ((norm_add_le _ _).trans (add_le_add + ((norm_add_le _ _).trans (add_le_add + ((norm_add_le _ _).trans (add_le_add h02 h10)) h01)) h11)) (norm_nonneg _)).trans + nlinarith + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedCancellation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedCancellation.lean new file mode 100644 index 0000000000000000000000000000000000000000..ed643f56cf7d11e49e078b9273f137269bd8cdbc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedCancellation.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.PrincipalSlotEstimate + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeLocal +theorem compensated_phase_error_bound (V W D P B q vInv : ℂ) (T : ℝ) + (_hT : 0 ≤ T) (hV : ‖V‖ ≤ 1 / 2) (hW : ‖W‖ ≤ 1) + (hD : ‖D‖ ≤ 1 / 2) (hq : ‖q‖ ≤ 1) + (hVT : ‖V‖ ≤ T) (hDT : ‖D‖ ≤ T) + (hE : ‖P + D‖ ≤ 28 * T) (hBE : ‖B‖ * ‖P + D‖ ≤ 28 * T) + (hv : ‖vInv‖≤1) (hBD : B * D = vInv) (hWq : vInv*W = q) : + ‖compensatedReplacement V W D P B q + continuedCorrection V W D P*vInv‖ ≤ 720 * T := by + have h1V : ‖1 - V‖ ≤ 2 := by + have := norm_sub_le (1 : ℂ) V + simp only [norm_one] at this + linarith + have h1W : ‖1 - W‖ ≤ 2 := by + have := norm_sub_le (1 : ℂ) W + simp only [norm_one] at this + linarith + have h1q : ‖vInv - q‖ ≤ 2 := by + have := norm_sub_le vInv q + linarith + have hiV := inv_one_sub_norm_le_two V hV + have hiD := inv_one_sub_norm_le_two D hD + have hfac : ‖(1 - V) * (1 - W) / (1 - D)‖ ≤ 8 := by + rw [div_eq_mul_inv, norm_mul, norm_mul] + calc + ‖1 - V‖ * ‖1 - W‖ * ‖(1 - D)⁻¹‖ ≤ (2 : ℝ) * 2 * 2 := by gcongr + _ = 8 := by norm_num + have hleft : ‖(vInv - q) * (V / (1 - V) - D)‖ ≤ 6 * T := by + calc + _ = ‖vInv - q‖ * ‖V / (1 - V) - D‖ := norm_mul _ _ + _ ≤ 2 * (‖V‖ * 2 + ‖D‖) := by + gcongr + calc + _ ≤ ‖V / (1 - V)‖ + ‖D‖ := norm_sub_le _ _ + _ ≤ _ := by rw [div_eq_mul_inv, norm_mul]; gcongr + _ ≤ 6 * T := by linarith + have hright : ‖(B + vInv - q) * (P + D)‖ ≤ 84 * T := by + have hc : ‖B + vInv - q‖ ≤ ‖B‖ + 2 := by + calc + _ = ‖B + (vInv - q)‖ := by congr 1; ring + _ ≤ ‖B‖ + ‖vInv - q‖ := norm_add_le _ _ + _ ≤ _ := by linarith + calc + _ = ‖B + vInv - q‖ * ‖P + D‖ := norm_mul _ _ + _ ≤ (‖B‖ + 2) * ‖P + D‖ := mul_le_mul_of_nonneg_right hc (norm_nonneg _) + _ ≤ 84 * T := by nlinarith + have hid := continued_normalized_cancellation V W D P B q vInv + (one_sub_ne_zero_of_norm_le_half V hV) (one_sub_ne_zero_of_norm_le_half D hD) + hBD hWq + rw [hid, norm_mul] + calc + _ ≤ 8 * (‖(vInv - q) * (V / (1 - V) - D)‖ + ‖(B + vInv - q) * (P + D)‖) := by + gcongr + exact norm_add_le _ _ + _ ≤ 720 * T := by linarith + +end SevenEighths.ProbeLocal +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedError.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedError.lean new file mode 100644 index 0000000000000000000000000000000000000000..1832cbb89521c462d4f2d2f129c23f21ad511716 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSelectedError.lean @@ -0,0 +1,71 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsSelectedCancellation +import OAI.NumberTheory.DirichletL.Detector.HighRowsFirstRegion + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler +open ProbeLocal + +def unramifiedMarked (Q : ℝ) (A eta v x w z : ℂ) : ℂ := + markedFactor (coordR Q A x z) (coordV Q z) (Q:ℂ)⁻¹ (coordK Q eta x w) + (-coordD Q eta v x+coordW Q v w*coordR Q A x z) 1 + +lemma unramifiedMarked_selected_error (Q : ℝ) (A eta v x w z : ℂ) + (hQ : 4≤Q) (hA : ‖A‖≤1) (heta : ‖eta‖≤1) (hv : ‖v‖≤1) + (hx : (7/8:ℝ)≤x.re) (hw : (1/2:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) : + ‖unramifiedMarked Q A eta v x w z+coordD Q eta v x‖≤28 ∧ + ‖star eta*(Q:ℂ)^x‖*‖unramifiedMarked Q A eta v x w z+coordD Q eta v x‖≤28 := by + have hQ0 : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +def ramifiedSelected (eta a rho x w z : ℂ) (j : ℕ) : ℂ := + star eta*(Ideal.absNorm (Ideal.span {p}):ℂ)^x*(1-coordV (Ideal.absNorm (Ideal.span {p})) z)* + rowClosedMarked p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j - + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)*ramifiedClosed p hp hg eta a rho x w z j + +lemma ramifiedSelected_eq_replacement (eta a rho x w z : ℂ) (j : ℕ) : + ramifiedSelected p hp hg eta a rho x w z j = + ProbeLocal.compensatedReplacement (coordV (Ideal.absNorm (Ideal.span {p})) z) 0 0 + (rowClosedMarked p hp hg eta a ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) rho j) + (star eta*(Ideal.absNorm (Ideal.span {p}):ℂ)^x) ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) := by + rw [ProbeLocal.continued_ramified_compensation] + simp only [ramifiedSelected,ramifiedClosed,ProbeLocal.continuedCorrection,mul_zero,sub_zero,mul_one,div_one] + +include hc in +theorem ramifiedSelected_bound (eta a rho x w z : ℂ) + (hQ : (4:ℝ)≤Ideal.absNorm (Ideal.span {p})) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (hx : (7/8:ℝ)≤x.re) (hw : (1/2:ℝ)≤w.re) (hz : (17/50:ℝ)≤z.re) (j : ℕ) (hj : j<6) : + ‖ramifiedSelected p hp hg eta a rho x w z j‖≤385*(Ideal.absNorm (Ideal.span {p}):ℝ)^(max (1-w.re) 0) := by + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + let B : ℝ := max (1-w.re) 0 + have hQ0 : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +lemma sourceRowTerm_norm_from_scalar_power (eta a rho x w z : ℂ) + (heta : ‖eta‖≤1) (ha : ‖a‖≤1) (hρ : rho^6=1) + (j e l k m : ℕ) (nu B : ℝ) + (hs : ‖sourceScalar p hp hg (e+3*l) k (j+6*m)‖≤2*(Ideal.absNorm (Ideal.span {p}):ℝ)^nu) + (he : nu-(x.re+1/2)*(e:ℝ)-(1+3*x.re)*(l:ℝ)-w.re*(k:ℝ)-6*z.re*(m:ℝ)≤B) : + ‖sourceRowTerm p hp hg eta a rho x w z j e l k m‖≤2*(Ideal.absNorm (Ideal.span {p}):ℝ)^B := by + have hP : Prime (Ideal.span {p}:Ideal O) := Ideal.prime_span_singleton_iff.mpr hp + have hQ2 : (2:ℝ)≤Ideal.absNorm (Ideal.span {p}) := by exact_mod_cast SmoothMobiusCorrection.prime_norm_two_le ⟨_,hP⟩ + have hQ : (0:ℝ) ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + +def rowMarkedTerm (eta a X W V rho : ℂ) (j e l k m : ℕ) : ℂ := + if e+3*l=0 then 0 else + rowWeightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1) + (star (localGamma p hp.ne_zero hg 3)) (actualSextic (Ideal.span {p}) hg (-1)) X W V rho + (positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (e+3*l-1) k (j+6*m)) e l k m + +include hc in +theorem rowMarkedTerm_step (eta a X W V rho : ℂ) (hρ : rho^6=1) + (j e l k m : ℕ) (ht : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +include hc in +lemma primeGauss_actual_pow_norm (r : ℕ) (hr : r≠0) (hr6 : r<6) : + ‖primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg^r) 1‖= + Real.sqrt (Ideal.absNorm (Ideal.span {p}):ℝ) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + have hn := localGamma_norm_one p hp.ne_zero hg hc r hr hr6 + rw [localGamma,ProbePhase.normalizedTraceGauss_eq_normalizedGauss] at hn + simp only [ProbeGauss.normalizedGauss,norm_div,Complex.norm_real, + Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _)] at hn + have hQ : (0:ℝ) simp [norm_pow] + · rw [ite_eq_left (by omega),ite_eq_right hm,norm_mul,norm_pow,Complex.norm_natCast] + have hQ1 : (1:ℝ)≤Ideal.absNorm (Ideal.span {p}) := by + have hh := SmoothMobiusCorrection.prime_norm_two_le + ⟨Ideal.span {p},Ideal.prime_span_singleton_iff.mpr hp⟩ + change 2≤Ideal.absNorm (Ideal.span {p}) at hh + exact_mod_cast (by omega : 1≤Ideal.absNorm (Ideal.span {p})) + have hsub : ‖(Ideal.absNorm (Ideal.span {p}):ℂ)-1‖=(Ideal.absNorm (Ideal.span {p}):ℝ)-1 := by + rw [←Complex.ofReal_natCast,←Complex.ofReal_one,←Complex.ofReal_sub,Complex.norm_real, + Real.norm_eq_abs,abs_of_nonneg (by linarith)] + rw [hsub,show (Ideal.absNorm (Ideal.span {p}):ℝ)^6=(Ideal.absNorm (Ideal.span {p}):ℝ)^5*(Ideal.absNorm (Ideal.span {p}):ℝ) by ring] + exact mul_le_mul_of_nonneg_left (by linarith) (by positivity) + +include hc in +lemma even_base_kone_zero (j : ℕ) (hj : j<6) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 5 1 j=0 := by + rw [positiveScalar_actual_table p hp hg hc,ite_eq_right (by decide : (1:ℕ)≠0)] + by_cases hj1 : 1≤j + · rw [ite_eq_left ⟨rfl,hj1⟩,gaussValuationTable,ite_eq_right (by decide : ¬6∣5), + ite_eq_right (by omega : j-1≠5),mul_zero] + · rw [ite_eq_right (by omega)] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSummability.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSummability.lean new file mode 100644 index 0000000000000000000000000000000000000000..44dc359e13c90854f779c1e3238f1872b3ef77fc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsSummability.lean @@ -0,0 +1,98 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsSeries +import OAI.NumberTheory.DirichletL.Detector.HighRowsDiagonal + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +lemma geometric_indicator_summable (V A : ℂ) (hV : ‖V‖<1) (p : ℕ→Prop) : + Summable (fun m=>(if p m then A else 0)*V^m) := by + convert (((hasSum_geometric_of_norm_lt_one hV).summable.mul_left A).indicator {m | p m}) using 1 + funext m + by_cases hm : p m <;> simp [hm] + +lemma gaussValuationTable_geometric_summable (Q G V : ℂ) (hV : ‖V‖<1) + (r n : ℕ) (j : ℕ→ℕ) : + Summable (fun m=>gaussValuationTable Q G r n (j m)*V^m) := by + by_cases hr : 6∣r + · have ha := geometric_indicator_summable V (Q^(n+1)) hV (fun m=>n+1≤j m) + have hb := geometric_indicator_summable V (Q^n) hV (fun m=>n≤j m) + convert ha.sub hb using 1 + funext m + simp only [gaussValuationTable,ite_eq_left hr,sub_mul] + split_ifs <;> rfl + · convert geometric_indicator_summable V (Q^n*G) hV (fun m=>j m=n) using 1 + funext m + simp only [gaussValuationTable,ite_eq_right hr] + split_ifs <;> rfl + +theorem positiveScalar_geometric_summable (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (n k : ℕ) (j : ℕ→ℕ) (V : ℂ) (hV : ‖V‖<1) : + Summable (fun m=>positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) n k (j m)*V^m) := by + simp only [positiveScalar_actual_table p hp hg hc] + by_cases hk : k=0 + · simp only [ite_eq_left hk] + exact gaussValuationTable_geometric_summable _ _ V hV (n+1) n j + · simp only [ite_eq_right hk] + have hs := (gaussValuationTable_geometric_summable (Ideal.absNorm (Ideal.span {p})) + (primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg^n) 1) V hV n n (fun m=>j m-1)).mul_left + (((actualSextic (Ideal.span {p}) hg (-1))⁻¹)*primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1) + convert hs.indicator {m | k=1 ∧ 1≤j m} using 1 + funext m + by_cases hm : k=1 ∧ 1≤j m <;> simp [hm,mul_assoc] + +end SevenEighths.ProbePrimePower +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) +include hc + +theorem rowMarkedTerm_frequency_summable (eta a X W V rho : ℂ) (hV : ‖V‖<1) + (j e l k : ℕ) : Summable (fun m=>rowMarkedTerm p hp hg eta a X W V rho j e l k m) := by + by_cases ht : e+3*l=0 + · simp only [rowMarkedTerm,ite_eq_left ht,summable_zero] + · simp only [rowMarkedTerm,ite_eq_right ht,rowWeightedScalar,weightedScalar] + have hs := SevenEighths.ProbePrimePower.positiveScalar_geometric_summable p hp hg hc (e+3*l-1) k (fun m=>j+6*m) V hV + convert hs.mul_left ((rho^k/rho^(e+3*l)) * + ((-eta*X/primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1)^e * + (a*X^3/(Ideal.absNorm (Ideal.span {p}):ℂ))^l * + localCubePhase (star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) e l k) *W^k) using 1 + funext m + ring + +theorem rowMarkedTerm_zero_lower_edge (eta a X W V rho : ℂ) + (j e l k : ℕ) (hj : j<6) (ht : 0∑' m,rowMarkedTerm p hp hg eta a X W V rho j e (l+2*r) k m) + ((∑' m,rowMarkedTerm p hp hg eta a X W V rho j e l k m)/ + (1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + apply diagonal_recurrence_hasSum + · intro r m + rw [show l+2*(r+1)=(l+2*r)+2 by omega] + exact rowMarkedTerm_step p hp hg hc eta a X W V rho hρ j e (l+2*r) k m (by omega) + · intro r + rw [show l+2*(r+1)=(l+2*r)+2 by omega] + exact rowMarkedTerm_zero_lower_edge p hp hg hc eta a X W V rho j e (l+2*r) k hj (by omega) + · simpa only [mul_zero,add_zero] using rowMarkedTerm_frequency_summable p hp hg hc eta a X W V rho hV j e l k + · exact hR + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsTail.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsTail.lean new file mode 100644 index 0000000000000000000000000000000000000000..4ca1442634b960afc4e9e93e37e33816b7e33bdc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsTail.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsFamilies + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +lemma gaussValuationTable_above (Q G : ℂ) (r n j : ℕ) (hj : n+1≤j) : + gaussValuationTable Q G r n j=if 6∣r then Q^(n+1)-Q^n else 0 := by + unfold gaussValuationTable + by_cases hd : 6∣r + · rw [ite_eq_left hd,ite_eq_left hd,ite_eq_left hj,ite_eq_left (by omega)] + · rw [ite_eq_right hd,ite_eq_right hd,ite_eq_right (by omega)] + +theorem positiveScalar_stable_large (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hc : ringChar (O ⧸ Ideal.span {p})≠2) (n k j j' : ℕ) + (hj : n+1 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) +include hc + +theorem rowMarkedTerm_base_tail (eta a X W V rho : ℂ) + (j e l k m : ℕ) (ht : 0rowMarkedTerm p hp hg eta a X W V rho j e l k (m+2)) + (rowMarkedTerm p hp hg eta a X W V rho j e l k 2/(1-V)) := by + have hgeo := (hasSum_geometric_of_norm_lt_one hV).mul_left (rowMarkedTerm p hp hg eta a X W V rho j e l k 2) + rw [←div_eq_mul_inv] at hgeo + convert hgeo using 1 + funext m + exact rowMarkedTerm_base_tail p hp hg hc eta a X W V rho j e l k m ht ht6 + have h := ht'.sum_range_add (f:=fun m=>rowMarkedTerm p hp hg eta a X W V rho j e l k m) (k:=2) + simpa only [Finset.sum_range_succ,Finset.sum_range_zero,zero_add] using h.tsum_eq + rw [rowInner_two,hsum 0,hsum 1] + simp only [Fin.sum_univ_two,Fin.val_zero,Fin.val_one] + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsTermBounds.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsTermBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..e73a54c7ba9521959bbfb5d09a6d1e5bf16387cb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighRowsTermBounds.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsScalarBounds + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +lemma sourceWeightedScalar_norm_le (Q : ℝ) (hQ : 0 ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p})≠2) + +lemma rowMarkedTerm_unramified (eta a X W V rho : ℂ) (e l k m : ℕ) : + rowMarkedTerm p hp hg eta a X W V rho 0 e l k m= + principalMarkedTerm p hp hg (eta/rho) (a/rho^3) X (rho*W) V e l k m := by + unfold rowMarkedTerm principalMarkedTerm + split_ifs + · rfl + · simp only [zero_add,rowWeightedScalar_parameters] + +lemma rowMarkedSeries_unramified (eta a X W V rho : ℂ) : + rowMarkedSeries p hp hg eta a X W V rho 0= + principalMarkedSeries p hp hg (eta/rho) (a/rho^3) X (rho*W) V := by + unfold rowMarkedSeries principalMarkedSeries rowInner principalInner + apply Finset.sum_congr rfl + intro e he + apply tsum_congr + intro l + apply tsum_congr + intro k + apply tsum_congr + intro m + exact rowMarkedTerm_unramified p hp hg eta a X W V rho e.val l k m + +include hc in +lemma rowClosedMarked_unramified (eta a X W V rho : ℂ) (hρ : rho^6=1) + (hV : ‖V‖<1) (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) : + rowClosedMarked p hp hg eta a X W V rho 0= + markedFactor (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) V + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹ + (eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W) + (-(eta/rho)*X+(rho*W)*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) 1 := by + have hn : rho≠0 := by intro h; simp [h] at hρ + rw [←rowMarkedSeries_eq_closed p hp hg hc eta a X W V rho hρ hV hR 0 (by decide), + rowMarkedSeries_unramified p hp hg, + principalMarkedSeries_eq p hp hg hc _ _ _ _ _ hV + (by simpa only [evenRatio_unit _ _ _ _ _ hρ] using hR), + evenRatio_unit _ _ _ _ _ hρ] + congr 1 + field_simp + +include hc in + +theorem sourceRowSeries_unramified_euler (eta a rho x w z : ℂ) (hρ : rho^6=1) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖coordR (Ideal.absNorm (Ideal.span {p})) (a^2) x z‖<1) + (hW : ‖coordW (Ideal.absNorm (Ideal.span {p})) rho w‖<1) + (hD : 1-coordD (Ideal.absNorm (Ideal.span {p})) eta rho x≠0) : + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + sourceRowSeries p hp hg eta a rho x w z 0= + (1-coordD Q eta rho x)/((1-coordV Q z)*(1-coordW Q rho w))* + unramifiedClosed Q (a^2) eta rho x w z := by + dsimp only + have hQ : (0:ℝ) ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) + +def rowZeroIndexTerm (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) (j k m : ℕ) : ℂ := + (if k=0 then 1 else (χ^k) (Ideal.Quotient.mk _ (p^(j+6*m))))*W^k*V^m + +theorem sourceRowTerm_zero (eta a rho x w z : ℂ) (j k m : ℕ) : + sourceRowTerm p hp hg eta a rho x w z j 0 0 k m= + rowZeroIndexTerm p (actualSextic (Ideal.span {p}) hg) + (rho*((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w))) + (coordV (Ideal.absNorm (Ideal.span {p})) z) j k m := by + unfold sourceRowTerm + rw [sourceWeightedScalar_actual p hp hg] + simp only [rowZeroIndexTerm,sourceScalar,weightedScalar,localCubePhase, + coordV,Complex.ofReal_natCast,mul_zero,add_zero,pow_zero,one_mul,mul_one, + zero_mul,Nat.choose_zero_succ,ite_true,div_one,mul_pow] + ring + +omit [(Ideal.span {p}).IsMaximal] in +lemma rowZeroIndex_zero (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) + (j : ℕ) (hV : ‖V‖<1) : + HasSum (fun m=>rowZeroIndexTerm p χ W V j 0 m) (1/(1-V)) := by + simpa only [rowZeroIndexTerm,ite_true,pow_zero,one_mul,one_div] using + hasSum_geometric_of_norm_lt_one hV + +include hp in +theorem rowZeroIndex_pos_ramified (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) + (j k m : ℕ) (hj : j≠0) (hk : k≠0) : rowZeroIndexTerm p χ W V j k m=0 := by + rw [rowZeroIndexTerm,ite_eq_right hk,zero_index_scalar p hp χ k (j+6*m) hk, + ite_eq_right (by omega),zero_mul,zero_mul] + +include hp in +theorem rowZeroIndexSeries_eq (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) + (j : ℕ) (hW : ‖W‖<1) (hV : ‖V‖<1) : + (∑' k,∑' m,rowZeroIndexTerm p χ W V j k m)= + 1/(1-V)+(if j=0 then W/(1-W) else 0) := by + by_cases hj : j=0 + · subst j + simp only [rowZeroIndexTerm,zero_add,ite_true] + exact zeroIndexSeries_eq p hp χ W V hW hV + · rw [ite_eq_right hj,add_zero] + rw [tsum_eq_single 0] + · exact (rowZeroIndex_zero p χ W V j hV).tsum_eq + · intro k hk + simp only [rowZeroIndex_pos_ramified p hp χ W V j k _ hj hk,tsum_zero] + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighSeries.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighSeries.lean new file mode 100644 index 0000000000000000000000000000000000000000..59e3271e929c9c2b40666d121ef9e24d8f8e9735 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighSeries.lean @@ -0,0 +1,115 @@ +import OAI.NumberTheory.DirichletL.Detector.SourceBounds + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open CubicEisenstein +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def bareIdealHighCoefficient (η : HeckeFamily.Character) (u : O) (I J K L : Id) : ℂ := + if h : Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported L then + bareSourceCoefficient η I (supported_primaryGenerator_ne_zero I h.2.1) + (primaryGenerator I * primaryGenerator J^3) (primaryGenerator K) + (mul_ne_zero (supported_primaryGenerator_ne_zero I h.2.1) + (pow_ne_zero _ (supported_primaryGenerator_ne_zero J h.2.2.1))) + (u*primaryGenerator L^6) + else 0 + +theorem bareIdealHighCoefficient_norm_le (η : HeckeFamily.Character) (u : O) (I J K L : Id) : + ‖bareIdealHighCoefficient η u I J K L‖ ≤ (K.absNorm:ℝ)*(I.absNorm:ℝ)*(J.absNorm:ℝ)^3 := by + unfold bareIdealHighCoefficient + split_ifs with h + · have hi := (supported_span_primaryGenerator_iff I).mpr h.2.1 + have hj := (supported_span_primaryGenerator_iff J).mpr h.2.2.1 + have hk := (supported_span_primaryGenerator_iff K).mpr h.2.2.2.1 + have hb := bareSourceCoefficient_norm_le η I ⟨h.1,supported_primaryGenerator_ne_zero I h.2.1⟩ + (primaryGenerator I*primaryGenerator J^3) (primaryGenerator K) + (supported_completed _ _ hi hj) hk (u*primaryGenerator L^6) + rw [← Ideal.span_singleton_mul_span_singleton,← Ideal.span_singleton_pow, + (primaryGenerator_spec I (supported_primaryGenerator_ne_zero I h.2.1)).1, + (primaryGenerator_spec J (supported_primaryGenerator_ne_zero J h.2.2.1)).1, + (primaryGenerator_spec K (supported_primaryGenerator_ne_zero K h.2.2.2.1)).1, + map_mul,map_pow,Nat.cast_mul,Nat.cast_pow] at hb + convert hb using 1 ; ring + · simp only [norm_zero] + positivity + +def bareIdealHighSummand (η : HeckeFamily.Character) (u : O) (x w z : ℂ) (I J K L : Id) : ℂ := + bareIdealHighCoefficient η u I J K L * fullIdealWeight (x+1/2) I * + fullIdealWeight (1+3*x) J * fullIdealWeight w K * fullIdealWeight (6*z) L + +lemma fullIdealWeight_nat_scale (s : ℂ) (I : Id) (hI : I≠0) (k : ℕ) : + (I.absNorm:ℝ)^k * ‖fullIdealWeight s I‖ = ‖fullIdealWeight (s-k) I‖ := by + have hN : 0<(I.absNorm:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr hI) + simp only [fullIdealWeight,ite_eq_right hI] + simp only [← Complex.ofReal_natCast] + rw [Complex.norm_cpow_eq_rpow_re_of_pos hN,Complex.norm_cpow_eq_rpow_re_of_pos hN] + simp only [Complex.neg_re,Complex.sub_re,Complex.ofReal_re] + rw [← Real.rpow_natCast,← Real.rpow_add hN] + congr 1 + ring + +theorem bareIdealHighSummand_norm_le (η : HeckeFamily.Character) (u : O) (x w z : ℂ) (I J K L : Id) : + ‖bareIdealHighSummand η u x w z I J K L‖ ≤ + ‖fullIdealWeight (x-1/2) I‖ * ‖fullIdealWeight (3*x-2) J‖ * + ‖fullIdealWeight (w-1) K‖ * ‖fullIdealWeight (6*z) L‖ := by + by_cases h : Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported L + · have hb := bareIdealHighCoefficient_norm_le η u I J K L + calc + _ ≤ ((K.absNorm:ℝ)*(I.absNorm:ℝ)*(J.absNorm:ℝ)^3) * + ‖fullIdealWeight (x+1/2) I‖ * ‖fullIdealWeight (1+3*x) J‖ * + ‖fullIdealWeight w K‖ * ‖fullIdealWeight (6*z) L‖ := by + simp only [bareIdealHighSummand,norm_mul] + gcongr + _ = ((I.absNorm:ℝ)^1*‖fullIdealWeight (x+1/2) I‖) * + ((J.absNorm:ℝ)^3*‖fullIdealWeight (1+3*x) J‖) * + ((K.absNorm:ℝ)^1*‖fullIdealWeight w K‖) * ‖fullIdealWeight (6*z) L‖ := by ring + _ = _ := by + rw [fullIdealWeight_nat_scale _ I h.2.1.1 1, + fullIdealWeight_nat_scale _ J h.2.2.1.1 3, + fullIdealWeight_nat_scale _ K h.2.2.2.1.1 1] + norm_num only [Nat.cast_one, Nat.cast_ofNat] + rw [show x+(1/2:ℂ)-1=x-1/2 by ring,show (1:ℂ)+3*x-3=3*x-2 by ring] + · simp only [bareIdealHighSummand,bareIdealHighCoefficient,dite_eq_right h,zero_mul,norm_zero] + positivity + +theorem bareIdealHighSummand_summable (η : HeckeFamily.Character) (u : O) (x w z : ℂ) + (hx : 3/2 + bareIdealHighSummand η u x w z p.1.1 p.1.2 p.2.1 p.2.2) := by + have h1 := fullIdealWeight_summable_norm (x-1/2) (by + simp only [Complex.sub_re,Complex.div_re,Complex.one_re,Complex.one_im, + show (2:ℂ).re=2 by rfl,show (2:ℂ).im=0 by rfl] + norm_num + linarith) + have h2 := fullIdealWeight_summable_norm (3*x-2) (by + norm_num [Complex.sub_re,Complex.mul_re] + linarith) + have h3 := fullIdealWeight_summable_norm (w-1) (by + simp only [Complex.sub_re,Complex.one_re] + linarith) + have h4 := fullIdealWeight_summable_norm (6*z) (by + norm_num [Complex.mul_re] + linarith) + have h12 := h1.mul_of_nonneg h2 (fun _=>norm_nonneg _) (fun _=>norm_nonneg _) + have h34 := h3.mul_of_nonneg h4 (fun _=>norm_nonneg _) (fun _=>norm_nonneg _) + have hall := h12.mul_of_nonneg h34 + (fun _=>mul_nonneg (norm_nonneg _) (norm_nonneg _)) + (fun _=>mul_nonneg (norm_nonneg _) (norm_nonneg _)) + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun _=>norm_nonneg _) _ hall + intro p + simpa only [mul_assoc] using bareIdealHighSummand_norm_le η u x w z p.1.1 p.1.2 p.2.1 p.2.2 + +def bareIdealHighSeries (η : HeckeFamily.Character) (u : O) (x w z : ℂ) : ℂ := + ∑' p : (Id×Id)×(Id×Id), bareIdealHighSummand η u x w z p.1.1 p.1.2 p.2.1 p.2.2 + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/HighValuations.lean b/lean/OAI/NumberTheory/DirichletL/Detector/HighValuations.lean new file mode 100644 index 0000000000000000000000000000000000000000..340572224d19a2d608fa130a8ef6a052270fa77c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/HighValuations.lean @@ -0,0 +1,113 @@ +import OAI.NumberTheory.DirichletL.Detector.IdealFactorization +import OAI.NumberTheory.DirichletL.Detector.IdealUnit + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev HighIdeal := (Id×Id)×(Id×Id) + +def highIdeals (v : PrimeIdeal→₀HighValuation) : HighIdeal := + ((idealFromValuations (v.mapRange (fun b=>b.1.1) rfl), + idealFromValuations (v.mapRange (fun b=>b.1.2) rfl)), + (idealFromValuations (v.mapRange (fun b=>b.2.1) rfl), + idealFromValuations (v.mapRange (fun b=>b.2.2) rfl))) + +lemma highIdeals_eq_equiv (v : PrimeIdeal→₀HighValuation) : + highIdeals v = + (((highValuationEquiv.symm v).1.1.val,(highValuationEquiv.symm v).1.2.val), + ((highValuationEquiv.symm v).2.1.val,(highValuationEquiv.symm v).2.2.val)) := by + apply Prod.ext <;> apply Prod.ext + all_goals + apply congrArg idealFromValuations + ext P + rfl + +lemma highIdeals_injective : Function.Injective highIdeals := by + intro v w h + apply highValuationEquiv.symm.injective + rw [highIdeals_eq_equiv,highIdeals_eq_equiv] at h + apply Prod.ext + · apply Prod.ext + · exact Subtype.ext (congrArg (fun b : HighIdeal=>b.1.1) h) + · exact Subtype.ext (congrArg (fun b : HighIdeal=>b.1.2) h) + · apply Prod.ext + · exact Subtype.ext (congrArg (fun b : HighIdeal=>b.2.1) h) + · exact Subtype.ext (congrArg (fun b : HighIdeal=>b.2.2) h) + +lemma highIdeals_zero : highIdeals 0=1 := by + simp only [highIdeals,Finsupp.mapRange_zero,idealFromValuations_zero] + rfl + +lemma highIdeals_single (P : PrimeIdeal) (b : HighValuation) : + highIdeals (Finsupp.single P b)=((P.val^b.1.1,P.val^b.1.2),(P.val^b.2.1,P.val^b.2.2)) := by + simp only [highIdeals,Finsupp.mapRange_single,idealFromValuations_single] + +lemma highIdeals_add (v w : PrimeIdeal→₀HighValuation) : + highIdeals (v+w)=highIdeals v*highIdeals w := by + have hproj (f : HighValuation→ℕ) (hf0 : f 0=0) (hf : ∀a b,f (a+b)=f a+f b) : + (v+w).mapRange f hf0=v.mapRange f hf0+w.mapRange f hf0 := by + ext P + simp only [Finsupp.mapRange_apply,Finsupp.add_apply,hf] + simp only [highIdeals,hproj (fun b=>b.1.1) rfl (fun _ _=>rfl), + hproj (fun b=>b.1.2) rfl (fun _ _=>rfl),hproj (fun b=>b.2.1) rfl (fun _ _=>rfl), + hproj (fun b=>b.2.2) rfl (fun _ _=>rfl),idealFromValuations_add] + rfl + +lemma prime_coprime_highIdeals (P : PrimeIdeal) (v : PrimeIdeal→₀HighValuation) + (hv : v P=0) : IsCoprime P.val + ((highIdeals v).1.1*(highIdeals v).1.2*(highIdeals v).2.1*(highIdeals v).2.2) := by + have hc (f : HighValuation→ℕ) (hf0 : f 0=0) : + IsCoprime P.val (idealFromValuations (v.mapRange f hf0)) := by + apply prime_coprime_idealFromValuations + simp only [Finsupp.mapRange_apply,hv,hf0] + exact ((hc _ rfl).mul_right (hc _ rfl)).mul_right (hc _ rfl) |>.mul_right (hc _ rfl) + +def highValuationTerm (η : HeckeFamily.Character) (x w z : ℂ) + (v : PrimeIdeal→₀HighValuation) : ℂ := + bareIdealHighSummand η 1 x w z (highIdeals v).1.1 (highIdeals v).1.2 + (highIdeals v).2.1 (highIdeals v).2.2 + +def highPrimeTerm (η : HeckeFamily.Character) (x w z : ℂ) + (P : PrimeIdeal) (b : HighValuation) : ℂ := + bareIdealHighSummand η 1 x w z (P.val^b.1.1) (P.val^b.1.2) (P.val^b.2.1) (P.val^b.2.2) + +lemma highPrimeTerm_zero (η : HeckeFamily.Character) (x w z : ℂ) (P : PrimeIdeal) : + highPrimeTerm η x w z P 0=1 := by + simp only [highPrimeTerm,Prod.fst_zero,Prod.snd_zero,pow_zero,bareIdealHighSummand_one] + +theorem highValuationTerm_eq_prod (η : HeckeFamily.Character) (x w z : ℂ) + (v : PrimeIdeal→₀HighValuation) : + highValuationTerm η x w z v=v.prod (highPrimeTerm η x w z) := by + induction v using Finsupp.induction with + | zero => + simp only [highValuationTerm,highIdeals_zero,Prod.fst_one,Prod.snd_one, + bareIdealHighSummand_one,Finsupp.prod_zero_index] + | @single_add P b v hP hb ih => + have hv : v P=0 := Finsupp.notMem_support_iff.mp hP + have hc := prime_coprime_highIdeals P v hv + have hpow : IsCoprime (P.val^b.1.1*P.val^b.1.2*P.val^b.2.1*P.val^b.2.2) + ((highIdeals v).1.1*(highIdeals v).1.2*(highIdeals v).2.1*(highIdeals v).2.2) := + ((hc.pow_left.mul_left hc.pow_left).mul_left hc.pow_left).mul_left hc.pow_left + have hd : Disjoint (Finsupp.single P b).support v.support := by + rw [Finsupp.support_single _ hb] + exact Finset.disjoint_singleton_left.mpr hP + rw [Finsupp.prod_add_index_of_disjoint hd,Finsupp.prod_single_index (highPrimeTerm_zero η x w z P),←ih] + unfold highValuationTerm + rw [highIdeals_add,highIdeals_single] + exact bareIdealHighSummand_mul η x w z _ _ _ _ _ _ _ _ hpow + +theorem highValuationTerm_summable_norm (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2‖highValuationTerm η x w z v‖) := + (bareIdealHighSummand_summable η 1 x w z hx hw hz).norm.comp_injective highIdeals_injective + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/IdealFactorization.lean b/lean/OAI/NumberTheory/DirichletL/Detector/IdealFactorization.lean new file mode 100644 index 0000000000000000000000000000000000000000..25eb63b032af7bafd1112567ecf156ea3a43fbf1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/IdealFactorization.lean @@ -0,0 +1,138 @@ +import OAI.NumberTheory.DirichletL.Detector.IdealMultiplicative +import Mathlib.RingTheory.UniqueFactorizationDomain.Finsupp + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic UniqueFactorizationMonoid +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev PrimeIdeal := {P : Id // Prime P} + +def primeValuations (I : Id) : PrimeIdeal →₀ ℕ := + (factorization I).subtypeDomain Prime + +def idealFromValuations (v : PrimeIdeal →₀ ℕ) : Id := + v.prod (fun P n=>P.val^n) + +lemma idealFromValuations_ne_zero (v : PrimeIdeal →₀ ℕ) : idealFromValuations v≠0 := by + unfold idealFromValuations Finsupp.prod + exact Finset.prod_ne_zero_iff.mpr (fun P hP=>pow_ne_zero _ P.property.ne_zero) + +@[simp] lemma primeValuations_apply (I : Id) (P : PrimeIdeal) : + primeValuations I P=(normalizedFactors I).count P.val := by + simp only [primeValuations,Finsupp.subtypeDomain_apply,factorization_eq_count] + +@[simp] lemma primeValuations_one : primeValuations 1=0 := by + simp only [primeValuations,factorization_one,Finsupp.subtypeDomain_zero] + +lemma primeValuations_mul (I J : Id) (hI : I≠0) (hJ : J≠0) : + primeValuations (I*J)=primeValuations I+primeValuations J := by + simp only [primeValuations,factorization_mul hI hJ,Finsupp.subtypeDomain_add] + +@[simp] lemma primeValuations_prime (P : PrimeIdeal) : + primeValuations P.val=Finsupp.single P 1 := by + ext Q + simp only [primeValuations_apply,normalizedFactors_irreducible P.property.irreducible, + normalize_eq,Multiset.count_singleton,Finsupp.single_apply] + by_cases h : Q=P + · subst Q + simp + · have hv : Q.val≠P.val := fun hh=>h (Subtype.ext hh) + simp [Ne.symm h,hv] + +lemma primeValuations_pow (I : Id) (n : ℕ) : + primeValuations (I^n)=n • primeValuations I := by + ext P + simp only [primeValuations_apply,normalizedFactors_pow,Multiset.count_nsmul, + Finsupp.coe_smul,Pi.smul_apply,smul_eq_mul] + +@[simp] lemma idealFromValuations_zero : idealFromValuations 0=1 := by + simp [idealFromValuations] + +lemma idealFromValuations_add (v w : PrimeIdeal →₀ ℕ) : + idealFromValuations (v+w)=idealFromValuations v*idealFromValuations w := by + exact Finsupp.prod_add_index' (fun _=>pow_zero _) (fun _ _ _=>pow_add _ _ _) + +@[simp] lemma idealFromValuations_single (P : PrimeIdeal) (n : ℕ) : + idealFromValuations (Finsupp.single P n)=P.val^n := by + simp [idealFromValuations] + +@[simp] theorem primeValuations_idealFromValuations (v : PrimeIdeal →₀ ℕ) : + primeValuations (idealFromValuations v)=v := by + induction v using Finsupp.induction with + | zero => simp only [idealFromValuations_zero,primeValuations_one] + | @single_add P n v hP hn ih => + rw [idealFromValuations_add,primeValuations_mul _ _ + (idealFromValuations_ne_zero _) (idealFromValuations_ne_zero _),ih] + simp only [idealFromValuations_single,primeValuations_pow,primeValuations_prime, + Finsupp.smul_single,smul_eq_mul,mul_one] + +@[simp] theorem idealFromValuations_primeValuations (I : Id) (hI : I≠0) : + idealFromValuations (primeValuations I)=I := by + have hs : ∀ P∈(factorization I).support,Prime P := by + intro P hP + exact prime_of_normalized_factor P (Multiset.mem_toFinset.mp (by simpa using hP)) + unfold idealFromValuations primeValuations + rw [Finsupp.prod_subtypeDomain_index hs] + simp only [Finsupp.prod,support_factorization,factorization_eq_count] + rw [← Finset.prod_multiset_count_of_subset _ _ (Finset.Subset.refl _)] + exact Ideal.prod_normalizedFactors_eq_self hI + +def nonzeroIdealValuationEquiv : {I : Id // I≠0} ≃ (PrimeIdeal →₀ ℕ) where + toFun I := primeValuations I.val + invFun v := ⟨idealFromValuations v,idealFromValuations_ne_zero v⟩ + left_inv I := Subtype.ext (idealFromValuations_primeValuations I.val I.property) + right_inv := primeValuations_idealFromValuations + +lemma primeIdeal_coprime (P Q : PrimeIdeal) (h : P≠Q) : IsCoprime P.val Q.val := by + let : P.val.IsPrime := Ideal.isPrime_of_prime P.property + let : Q.val.IsPrime := Ideal.isPrime_of_prime Q.property + let : P.val.IsMaximal := Ideal.IsPrime.isMaximal inferInstance P.property.ne_zero + let : Q.val.IsMaximal := Ideal.IsPrime.isMaximal inferInstance Q.property.ne_zero + exact Ideal.isCoprime_of_isMaximal (fun hh=>h (Subtype.ext hh)) + +lemma prime_coprime_idealFromValuations (P : PrimeIdeal) (v : PrimeIdeal →₀ ℕ) + (hP : v P=0) : IsCoprime P.val (idealFromValuations v) := by + apply IsCoprime.prod_right + intro Q hQ + apply IsCoprime.pow_right + apply primeIdeal_coprime + intro hh + subst Q + exact Finsupp.mem_support_iff.mp hQ hP + +def finsuppPairEquiv {α β γ : Type*} [Zero β] [Zero γ] : + ((α→₀β)×(α→₀γ)) ≃ (α→₀(β×γ)) where + toFun v := Finsupp.zipWith Prod.mk rfl v.1 v.2 + invFun v := (v.mapRange Prod.fst rfl,v.mapRange Prod.snd rfl) + left_inv v := by + apply Prod.ext <;> ext a <;> rfl + right_inv v := by + apply Finsupp.ext + intro a + exact Prod.eta (v a) + +abbrev HighValuation := (ℕ×ℕ)×(ℕ×ℕ) +abbrev NonzeroIdeal := {I : Id // I≠0} + +def highValuationEquiv : ((NonzeroIdeal×NonzeroIdeal)×(NonzeroIdeal×NonzeroIdeal)) ≃ + (PrimeIdeal→₀HighValuation) := + (Equiv.prodCongr + (Equiv.prodCongr nonzeroIdealValuationEquiv nonzeroIdealValuationEquiv) + (Equiv.prodCongr nonzeroIdealValuationEquiv nonzeroIdealValuationEquiv)).trans + ((Equiv.prodCongr finsuppPairEquiv finsuppPairEquiv).trans finsuppPairEquiv) + +@[simp] lemma highValuationEquiv_apply + (a : (NonzeroIdeal×NonzeroIdeal)×(NonzeroIdeal×NonzeroIdeal)) (P : PrimeIdeal) : + highValuationEquiv a P = + ((primeValuations a.1.1.val P,primeValuations a.1.2.val P), + (primeValuations a.2.1.val P,primeValuations a.2.2.val P)) := rfl + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/IdealLocalEuler.lean b/lean/OAI/NumberTheory/DirichletL/Detector/IdealLocalEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..269bd04c77ca24d23abdbee0ce92381063565bde --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/IdealLocalEuler.lean @@ -0,0 +1,119 @@ +import OAI.NumberTheory.DirichletL.Detector.HighSeries +import OAI.NumberTheory.DirichletL.Detector.SourcePrimeFactor +import OAI.NumberTheory.DirichletL.IdealEuler + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ConcretePrimeRowBridge CubicEisenstein ProbePhase ProbeEuler ProbePrimePower ProbeRow +local notation "O" => ActualEisensteinCubic.O + +lemma primaryGenerator_prime_power (p : O) (hp : p≠0) (hprimary : goodLambda^2∣p-1) (e : ℕ) : + primaryGenerator ((Ideal.span {p})^e)=p^e := by + rw [primaryGenerator_pow,primaryGenerator_span p hp hprimary] + +lemma prime_power_small_squarefree (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (e : ℕ) (he : e≤1) : + Squarefree ((Ideal.span {p})^e) := by + have hP : Prime (Ideal.span {p}:Ideal O) := + Ideal.prime_of_isPrime (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero) inferInstance + have hcases : e=0 ∨ e=1 := by omega + rcases hcases with rfl|rfl + · simpa only [pow_zero] using (squarefree_one : Squarefree (1:Ideal O)) + · simpa only [pow_one] using hP.squarefree + +theorem bareIdealHighCoefficient_at_prime (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (e l k m : ℕ) (he : e≤1) : + bareIdealHighCoefficient η 1 ((Ideal.span {p})^e) ((Ideal.span {p})^l) + ((Ideal.span {p})^k) ((Ideal.span {p})^m) = + bareSourceCoefficient η (Ideal.span {p^e}) + (by rw [← Ideal.span_singleton_pow,primaryGenerator_prime_power p hp.ne_zero hprimary e]; + exact pow_ne_zero _ hp.ne_zero) + (p^(e+3*l)) (p^k) (pow_ne_zero _ hp.ne_zero) (p^(6*m)) := by + have hguard : Squarefree ((Ideal.span {p})^e) ∧ Supported ((Ideal.span {p})^e) ∧ + Supported ((Ideal.span {p})^l) ∧ Supported ((Ideal.span {p})^k) ∧ Supported ((Ideal.span {p})^m) := + ⟨prime_power_small_squarefree p hp e he,supported_pow hs e,supported_pow hs l,supported_pow hs k,supported_pow hs m⟩ + unfold bareIdealHighCoefficient + rw [dite_eq_left hguard] + simp only [primaryGenerator_prime_power p hp.ne_zero hprimary,one_mul] + have hA : p^e*(p^l)^3=p^(e+3*l) := by rw [←pow_mul,Nat.mul_comm l 3,←pow_add] + have hH : (p^m)^6=p^(6*m) := by rw [←pow_mul,Nat.mul_comm m 6] + simp only [hA,hH,Ideal.span_singleton_pow] + +lemma fullIdealWeight_power (s : ℂ) (I : Ideal O) (n : ℕ) : + fullIdealWeight s (I^n)=fullIdealWeight s I^n := (IdealEuler.normWeight s).map_pow I n + +lemma prime_spectral_weights (p : O) (hp : p≠0) (e l k m : ℕ) (x w z : ℂ) : + fullIdealWeight (x+1/2) ((Ideal.span {p})^e) * + fullIdealWeight (1+3*x) ((Ideal.span {p})^l) * + fullIdealWeight w ((Ideal.span {p})^k) * fullIdealWeight (6*z) ((Ideal.span {p})^m) = + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(x+1/2)*(e:ℂ)-(1+3*x)*(l:ℂ)-w*(k:ℂ)-6*z*(m:ℂ)) := by + have hI : (Ideal.span {p}:Ideal O)≠0 := Ideal.span_singleton_eq_bot.not.mpr hp + have hQ : (Ideal.absNorm (Ideal.span {p}):ℂ)≠0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr hI + simp only [fullIdealWeight_power] + simp only [fullIdealWeight,ite_eq_right hI] + rw [←Complex.cpow_mul_nat,←Complex.cpow_mul_nat,←Complex.cpow_mul_nat,←Complex.cpow_mul_nat, + ←Complex.cpow_add _ _ hQ,←Complex.cpow_add _ _ hQ,←Complex.cpow_add _ _ hQ] + congr 1 + ring + +theorem bareIdealHighSummand_at_prime (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (e l k m : ℕ) (he : e≤1) (x w z : ℂ) : + bareIdealHighSummand η 1 x w z ((Ideal.span {p})^e) ((Ideal.span {p})^l) + ((Ideal.span {p})^k) ((Ideal.span {p})^m) = + sourcePrincipalTerm p hp hg (targetMonoid η p) (actualACube η p) x w z e l k m := by + unfold bareIdealHighSummand + rw [bareIdealHighCoefficient_at_prime η p hp hprimary hs e l k m he] + have hw := prime_spectral_weights p hp.ne_zero e l k m x w z + simp only [mul_assoc] at hw ⊢ + rw [hw] + simpa only [mul_assoc] using + bareSourceCoefficient_weighted_prime η p hp hg hchar hprimary hs e l k m he _ x w z + +def idealHighLocalFactor (η : HeckeFamily.Character) (P : Ideal O) (x w z : ℂ) : ℂ := + ∑ e : Fin 2, ∑' l, ∑' k, ∑' m, + bareIdealHighSummand η 1 x w z (P^e.val) (P^l) (P^k) (P^m) + +theorem idealHighLocalFactor_eq_source (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (x w z : ℂ) : + idealHighLocalFactor η (Ideal.span {p}) x w z = + sourcePrincipalSeries p hp hg (targetMonoid η p) (actualACube η p) x w z := by + unfold idealHighLocalFactor sourcePrincipalSeries + apply Finset.sum_congr rfl + intro e he + apply tsum_congr + intro l + apply tsum_congr + intro k + apply tsum_congr + intro m + exact bareIdealHighSummand_at_prime η p hp hg hchar hprimary hs e.val l k m (by omega) x w z + +theorem idealHighLocalFactor_euler_identity (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (x w z : ℂ) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖coordR (Ideal.absNorm (Ideal.span {p})) ((actualACube η p)^2) x z‖<1) + (hW : ‖coordW (Ideal.absNorm (Ideal.span {p})) 1 w‖<1) + (hD : 1-coordD (Ideal.absNorm (Ideal.span {p})) (targetMonoid η p) 1 x≠0) : + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + idealHighLocalFactor η (Ideal.span {p}) x w z = + (1-coordD Q (targetMonoid η p) 1 x) / ((1-coordV Q z)*(1-coordW Q 1 w)) * + unramifiedClosed Q ((actualACube η p)^2) (targetMonoid η p) 1 x w z := by + rw [idealHighLocalFactor_eq_source η p hp hg hchar hprimary hs] + exact sourcePrincipalSeries_euler_identity p hp hg hchar _ _ x w z hV hR hW hD + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/IdealMultiplicative.lean b/lean/OAI/NumberTheory/DirichletL/Detector/IdealMultiplicative.lean new file mode 100644 index 0000000000000000000000000000000000000000..36b45e503e0e764cd557bb8a73d162fc88b74dad --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/IdealMultiplicative.lean @@ -0,0 +1,119 @@ +import OAI.NumberTheory.DirichletL.Detector.HighSeries +import OAI.NumberTheory.DirichletL.Detector.SixthFrequency +import OAI.NumberTheory.DirichletL.IdealEuler + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ConcretePrimeRowBridge CubicEisenstein +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def highSupport (I J K L : Id) : Prop := + Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported L + +lemma highSupport_mul (I J K L I' J' K' L' : Id) (hcop : IsCoprime I I') : + highSupport (I*I') (J*J') (K*K') (L*L') ↔ + highSupport I J K L ∧ highSupport I' J' K' L' := by + simp only [highSupport, squarefree_mul_iff, supported_mul_iff] + have hc := hcop.isRelPrime + tauto + +lemma span_primaryGenerator_of_supported (I : Id) (hI : Supported I) : + Ideal.span {primaryGenerator I}=I := + (primaryGenerator_spec I (supported_primaryGenerator_ne_zero I hI)).1 + +lemma primaryGenerator_coprime (I J : Id) (hI : Supported I) (hJ : Supported J) + (hcop : IsCoprime I J) : IsCoprime (primaryGenerator I) (primaryGenerator J) := by + apply (Ideal.isCoprime_span_singleton_iff _ _).mp + rwa [span_primaryGenerator_of_supported I hI,span_primaryGenerator_of_supported J hJ] + +lemma completed_block_dvd_cube (I J K L : Id) : I*J^3*K ∣ (I*J*K*L)^3 := by + refine ⟨I^2*K^2*L^3,?_⟩ + ring + +lemma first_block_dvd (I J K L : Id) : I ∣ I*J*K*L := by + refine ⟨J*K*L,?_⟩ + ring + +lemma last_block_dvd (I J K L : Id) : L ∣ I*J*K*L := by + refine ⟨I*J*K,?_⟩ + ring + +theorem bareIdealHighCoefficient_mul (η : HeckeFamily.Character) + (I J K L I' J' K' L' : Id) + (hcop : IsCoprime (I*J*K*L) (I'*J'*K'*L')) : + bareIdealHighCoefficient η 1 (I*I') (J*J') (K*K') (L*L') = + bareIdealHighCoefficient η 1 I J K L * bareIdealHighCoefficient η 1 I' J' K' L' := by + have hII := hcop.mono (first_block_dvd I J K L) (first_block_dvd I' J' K' L') + by_cases h : highSupport I J K L ∧ highSupport I' J' K' L' + · have hprod := (highSupport_mul I J K L I' J' K' L' hII).mpr h + rcases h with ⟨h,h'⟩ + have hsA := (supported_mul_iff (I*J^3) K).mpr + ⟨(supported_mul_iff I (J^3)).mpr ⟨h.2.1,supported_pow h.2.2.1 3⟩,h.2.2.2.1⟩ + have hsB := (supported_mul_iff (I'*J'^3) K').mpr + ⟨(supported_mul_iff I' (J'^3)).mpr ⟨h'.2.1,supported_pow h'.2.2.1 3⟩,h'.2.2.2.1⟩ + have hc3 : IsCoprime ((I*J*K*L)^3) ((I'*J'*K'*L')^3) := hcop.pow_left.pow_right + have hab := primaryGenerator_coprime _ _ hsA hsB + (hc3.mono (completed_block_dvd_cube I J K L) (completed_block_dvd_cube I' J' K' L')) + have hba := primaryGenerator_coprime _ _ h'.2.2.2.2 hsA + (hcop.symm.pow_right.mono (last_block_dvd I' J' K' L') (completed_block_dvd_cube I J K L)) + have hab' := primaryGenerator_coprime _ _ h.2.2.2.2 hsB + (hcop.pow_right.mono (last_block_dvd I J K L) (completed_block_dvd_cube I' J' K' L')) + simp only [primaryGenerator_mul,primaryGenerator_pow] at hab hba hab' + have he := bareSourceCoefficient_product_frequency η I I' + ⟨h.1,supported_primaryGenerator_ne_zero I h.2.1⟩ + ⟨h'.1,supported_primaryGenerator_ne_zero I' h'.2.1⟩ + ⟨hprod.1,supported_primaryGenerator_ne_zero (I*I') hprod.2.1⟩ hII + (primaryGenerator J) (primaryGenerator J') (primaryGenerator K) (primaryGenerator K') + ((supported_span_primaryGenerator_iff I).mpr h.2.1) + ((supported_span_primaryGenerator_iff I').mpr h'.2.1) + ((supported_span_primaryGenerator_iff J).mpr h.2.2.1) + ((supported_span_primaryGenerator_iff J').mpr h'.2.2.1) + ((supported_span_primaryGenerator_iff K).mpr h.2.2.2.1) + ((supported_span_primaryGenerator_iff K').mpr h'.2.2.2.1) + (primaryGenerator_spec I (supported_primaryGenerator_ne_zero I h.2.1)).2 + (primaryGenerator_spec I' (supported_primaryGenerator_ne_zero I' h'.2.1)).2 + (primaryGenerator_spec J (supported_primaryGenerator_ne_zero J h.2.2.1)).2 + (primaryGenerator_spec J' (supported_primaryGenerator_ne_zero J' h'.2.2.1)).2 + (primaryGenerator_spec K (supported_primaryGenerator_ne_zero K h.2.2.2.1)).2 + (primaryGenerator_spec K' (supported_primaryGenerator_ne_zero K' h'.2.2.2.1)).2 + hab (primaryGenerator L) (primaryGenerator L') hba hab' + unfold highSupport at hprod h h' + unfold bareIdealHighCoefficient + rw [dite_eq_left hprod,dite_eq_left h,dite_eq_left h'] + simp only [primaryGenerator_mul,one_mul] + dsimp only at he + convert he using 1 ; ring_nf + · have hprod := mt (highSupport_mul I J K L I' J' K' L' hII).mp h + unfold highSupport at hprod + unfold bareIdealHighCoefficient + rw [dite_eq_right hprod] + by_cases hi : highSupport I J K L + · have hj : ¬highSupport I' J' K' L' := fun hj=>h ⟨hi,hj⟩ + unfold highSupport at hj + rw [dite_eq_right hj,mul_zero] + · unfold highSupport at hi + rw [dite_eq_right hi,zero_mul] + +lemma fullIdealWeight_mul (s : ℂ) (I J : Id) : + fullIdealWeight s (I*J)=fullIdealWeight s I*fullIdealWeight s J := + (IdealEuler.normWeight s).map_mul I J + +theorem bareIdealHighSummand_mul (η : HeckeFamily.Character) (x w z : ℂ) + (I J K L I' J' K' L' : Id) + (hcop : IsCoprime (I*J*K*L) (I'*J'*K'*L')) : + bareIdealHighSummand η 1 x w z (I*I') (J*J') (K*K') (L*L') = + bareIdealHighSummand η 1 x w z I J K L * bareIdealHighSummand η 1 x w z I' J' K' L' := by + unfold bareIdealHighSummand + rw [bareIdealHighCoefficient_mul η I J K L I' J' K' L' hcop, + fullIdealWeight_mul,fullIdealWeight_mul,fullIdealWeight_mul,fullIdealWeight_mul] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/IdealUnit.lean b/lean/OAI/NumberTheory/DirichletL/Detector/IdealUnit.lean new file mode 100644 index 0000000000000000000000000000000000000000..d94df130b145e83ec61fc511d2151fabc39ed9eb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/IdealUnit.lean @@ -0,0 +1,58 @@ +import OAI.NumberTheory.DirichletL.Detector.IdealMultiplicative +import OAI.NumberTheory.DirichletL.Detector.SourcePrime + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss +open CubicEisenstein ProbePhase ConcretePrimeRowBridge ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +lemma supported_one_ideal : Supported (1 : Ideal O) := by + refine ⟨one_ne_zero,?_⟩ + intro P hP + simp only [UniqueFactorizationMonoid.normalizedFactors_one,Multiset.notMem_zero] at hP + +lemma G_one : G (1:O)=1 := by + have hs : Supported (Ideal.span {(1:O)}) := by + rw [Ideal.span_singleton_one,←Ideal.one_eq_top] + exact supported_one_ideal + have ho := supported_residue_odd (1:O) hs + have hn : G (1:O)≠0 := by + intro hz + have hh := G_norm_one_of_odd (1:O) ho + rw [hz,norm_zero] at hh + norm_num at hh + have he := G_mul (1:O) 1 ho ho + rw [one_mul,reciprocitySign_one_left (1:O) ho,mul_one] at he + exact mul_left_cancel₀ hn (by simpa only [mul_one] using he.symm) + +lemma angularFactor_one : FiniteGaussPhase.angularFactor (1:O)=1 := by + simp only [FiniteGaussPhase.angularFactor,map_one,norm_one,Complex.ofReal_one,div_one] + +@[simp] theorem bareIdealHighCoefficient_one (η : HeckeFamily.Character) : + bareIdealHighCoefficient η 1 1 1 1 1=1 := by + have hs := supported_one_ideal + have hg : Squarefree (1:Ideal O) ∧ Supported 1 ∧ Supported 1 ∧ Supported 1 ∧ Supported 1 := + ⟨squarefree_one,hs,hs,hs,hs⟩ + unfold bareIdealHighCoefficient + rw [dite_eq_left hg] + simp only [primaryGenerator_one,one_pow,one_mul] + unfold bareSourceCoefficient correctedFiniteCoefficient reciprocityCoefficient + rw [gaussTwo_one,G_one,angularFactor_one] + have ho := supported_residue_odd (1:O) (by + rw [Ideal.span_singleton_one,←Ideal.one_eq_top];exact hs) + rw [reciprocitySign_one_left (1:O) ho, + bareCongruenceCoefficient_inner_one 1 one_ne_zero,outerQuotient_mk] + simp only [map_one,star_one,one_mul,Ideal.span_singleton_one,←Ideal.one_eq_top] + +@[simp] theorem bareIdealHighSummand_one (η : HeckeFamily.Character) (x w z : ℂ) : + bareIdealHighSummand η 1 x w z 1 1 1 1=1 := by + have hw (t : ℂ) : fullIdealWeight t (1:Ideal O)=1 := (IdealEuler.normWeight t).map_one + simp only [bareIdealHighSummand,bareIdealHighCoefficient_one,hw,one_mul] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/InitialFubini.lean b/lean/OAI/NumberTheory/DirichletL/Detector/InitialFubini.lean new file mode 100644 index 0000000000000000000000000000000000000000..8ecfb7327b8e89309d2ca98157b66e5b402079fa --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/InitialFubini.lean @@ -0,0 +1,32 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialIntegral +import OAI.NumberTheory.DirichletL.Detector.InitialScales + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary +local notation "O" => ActualEisensteinCubic.O + +theorem source_initial_integral_tsum (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable + +def initialHighOnLines (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (σ υ ξ : ℝ) (i : FullHighIndex) (p : HeightSpace) : ℂ := + fullHighCoefficient S D η mask ((σ:ℂ)+p.1.1*Complex.I) + ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I) i + +lemma initialHighOnLines_continuous (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (σ υ ξ : ℝ) (i : FullHighIndex) : + Continuous (initialHighOnLines S D η mask σ υ ξ i) := by + unfold initialHighOnLines + have hc : Continuous (fun p : HeightSpace => + (((σ:ℂ)+p.1.1*Complex.I,(υ:ℂ)+p.2*Complex.I),(ξ:ℂ)+p.1.2*Complex.I)) := by fun_prop + have hh := (fullHighCoefficient_continuous S D η mask i).comp hc + simpa only [Function.comp_def] using hh + +lemma initialHighOnLines_norm_le (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) (σ υ ξ : ℝ) + (i : FullHighIndex) (p : HeightSpace) : + ‖initialHighOnLines S D η mask σ υ ξ i p‖≤ initialHighMajorant σ υ ξ i := by + exact fullHighCoefficient_norm_le S D η mask hm _ _ _ σ υ ξ (by simp) (by simp) (by simp) i + +lemma initial_profile_integrable (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 01) aestronglyMeasurable_const 1 0 (fun _=>by simp) + +theorem initialHigh_integral_tsum (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0initialHighOnLines S D η mask σ υ ξ i p*onLines W0 W1 σ ξ υ p + have hb (i : FullHighIndex) (p : HeightSpace) : + ‖F i p‖≤ initialHighMajorant σ υ ξ i*‖onLines W0 W1 σ ξ υ p‖ := by + dsimp only [F] + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (initialHighOnLines_norm_le S D η mask hm σ υ ξ i p) (norm_nonneg _) + have hF (i : FullHighIndex) : Integrable (F i) heightMeasure := by + apply (hp.norm.const_mul (initialHighMajorant σ υ ξ i)).mono' + · exact ((initialHighOnLines_continuous S D η mask σ υ ξ i).mul + (onLines_continuous W0 W1 a1 b1 ha1 hW1 σ ξ υ hξ0)).aestronglyMeasurable + · exact Filter.Eventually.of_forall (hb i) + have hsum : Summable (fun i : FullHighIndex=>∫p,‖F i p‖ ∂heightMeasure) := by + apply Summable.of_nonneg_of_le (fun i=>integral_nonneg (fun _=>norm_nonneg _)) + (fun i=>?_) ((initialHighMajorant_summable σ υ ξ hσ hυ hξ).mul_right + (∫p,‖onLines W0 W1 σ ξ υ p‖ ∂heightMeasure)) + rw [←integral_const_mul] + exact integral_mono (hF i).norm (hp.norm.const_mul _) (hb i) + exact (integral_tsum_of_summable_integral_norm hF hsum).symm + +theorem initialHigh_integral_tsum_test (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) + (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1<ξ) + (T : HeightSpace→ℂ) (hT : Integrable T heightMeasure) : + (∫p,∑'i : FullHighIndex, initialHighOnLines S D η mask σ υ ξ i p*T p ∂heightMeasure)= + ∑'i : FullHighIndex, ∫p,initialHighOnLines S D η mask σ υ ξ i p*T p ∂heightMeasure := by + let F := fun i p=>initialHighOnLines S D η mask σ υ ξ i p*T p + have hb (i : FullHighIndex) (p : HeightSpace) : + ‖F i p‖≤ initialHighMajorant σ υ ξ i*‖T p‖ := by + dsimp only [F] + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (initialHighOnLines_norm_le S D η mask hm σ υ ξ i p) (norm_nonneg _) + have hF (i : FullHighIndex) : Integrable (F i) heightMeasure := by + apply (hT.norm.const_mul (initialHighMajorant σ υ ξ i)).mono' + · exact (initialHighOnLines_continuous S D η mask σ υ ξ i).aestronglyMeasurable.mul hT.aestronglyMeasurable + · exact Filter.Eventually.of_forall (hb i) + have hsum : Summable (fun i : FullHighIndex=>∫p,‖F i p‖ ∂heightMeasure) := by + apply Summable.of_nonneg_of_le (fun i=>integral_nonneg (fun _=>norm_nonneg _)) + (fun i=>?_) ((initialHighMajorant_summable σ υ ξ hσ hυ hξ).mul_right + (∫p,‖T p‖ ∂heightMeasure)) + rw [←integral_const_mul] + exact integral_mono (hF i).norm (hT.norm.const_mul _) (hb i) + exact (integral_tsum_of_summable_integral_norm hF hsum).symm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/InitialMajorant.lean b/lean/OAI/NumberTheory/DirichletL/Detector/InitialMajorant.lean new file mode 100644 index 0000000000000000000000000000000000000000..007eb24cae3fae6ccb84aa181f03b5dd727c5150 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/InitialMajorant.lean @@ -0,0 +1,83 @@ +import OAI.NumberTheory.DirichletL.Detector.MellinGuarded +import OAI.NumberTheory.DirichletL.Detector.RowAnalytic +import OAI.NumberTheory.DirichletL.Detector.MellinBoundary + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CubicEisenstein ProbeRow +attribute [local fun_prop] fullIdealWeight_continuous +local notation "O" => ActualEisensteinCubic.O +abbrev FullHighIndex := NonzeroFrequency×((Ideal O×Ideal O)×(Ideal O×Ideal O)) + +def initialHighMajorant (σ υ ξ : ℝ) (p : FullHighIndex) : ℝ := + ‖frequencyWeight (ξ:ℂ) p.1‖*highAbsoluteMajorant (σ:ℂ) (υ:ℂ) (ξ:ℂ) p.2 + +lemma initialHighMajorant_nonneg (σ υ ξ : ℝ) (p : FullHighIndex) : + 0≤ initialHighMajorant σ υ ξ p := mul_nonneg (norm_nonneg _) (highAbsoluteMajorant_nonneg _ _ _ _) + +lemma initialHighMajorant_summable (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1<ξ) : + Summable (initialHighMajorant σ υ ξ) := by + exact (frequencyWeight_summable_norm (ξ:ℂ) hξ).mul_of_nonneg + (highAbsoluteMajorant_summable (σ:ℂ) (υ:ℂ) (ξ:ℂ) hσ hυ (by simpa using (show (1/6:ℝ)<ξ by linarith))) + (fun _=>norm_nonneg _) (highAbsoluteMajorant_nonneg _ _ _) + +lemma frequencyWeight_norm_eq_of_re (z z' : ℂ) (h : z.re=z'.re) (H : NonzeroFrequency) : + ‖frequencyWeight z H‖=‖frequencyWeight z' H‖ := by simp only [frequencyWeight_norm,h] + +lemma highAbsoluteMajorant_eq_of_re (x w z x' w' z' : ℂ) + (hx : x.re=x'.re) (hw : w.re=w'.re) (hz : z.re=z'.re) + (p : (Ideal O×Ideal O)×(Ideal O×Ideal O)) : + highAbsoluteMajorant x w z p=highAbsoluteMajorant x' w' z' p := by + unfold highAbsoluteMajorant + rw [fullIdealWeight_norm_eq_of_re (x-1/2) (x'-1/2) (by simp [hx]), + fullIdealWeight_norm_eq_of_re (3*x-2) (3*x'-2) (by simp [hx]), + fullIdealWeight_norm_eq_of_re (w-1) (w'-1) (by simp [hw]), + fullIdealWeight_norm_eq_of_re (6*z) (6*z') (by simp [hz])] + +def fullHighCoefficient (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (x w z : ℂ) (p : FullHighIndex) : ℂ := + mask p.1*frequencyWeight z p.1* + markedIdealHighSummand S D η p.1.val x w z p.2.1.1 p.2.1.2 p.2.2.1 p.2.2.2 + +lemma fullHighCoefficient_norm_le (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) (x w z : ℂ) + (σ υ ξ : ℝ) (hx : x.re=σ) (hw : w.re=υ) (hz : z.re=ξ) (p : FullHighIndex) : + ‖fullHighCoefficient S D η mask x w z p‖≤ initialHighMajorant σ υ ξ p := by + unfold fullHighCoefficient + rw [norm_mul,norm_mul] + have hb := (markedIdealHighSummand_norm_le S D η p.1.val x w z p.2.1.1 p.2.1.2 p.2.2.1 p.2.2.2).trans + (bareIdealHighSummand_norm_le η p.1.val x w z p.2.1.1 p.2.1.2 p.2.2.1 p.2.2.2) + calc + _ ≤ (1*‖frequencyWeight z p.1‖)*highAbsoluteMajorant x w z p.2 := + mul_le_mul (mul_le_mul_of_nonneg_right (hm _) (norm_nonneg _)) hb (norm_nonneg _) (by positivity) + _ = initialHighMajorant σ υ ξ p := by + rw [one_mul,frequencyWeight_norm_eq_of_re z (ξ:ℂ) hz, + highAbsoluteMajorant_eq_of_re x w z (σ:ℂ) (υ:ℂ) (ξ:ℂ) hx hw hz] + rfl + +lemma fullHighCoefficient_continuous (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (p : FullHighIndex) : + Continuous (fun q : (ℂ × ℂ) × ℂ => fullHighCoefficient S D η mask q.1.1 q.1.2 q.2 p) := by + have hH : (elementNorm p.1.val:ℂ)≠0 := Complex.ofReal_ne_zero.mpr (elementNorm_pos _ p.1.property).ne' + unfold fullHighCoefficient frequencyWeight markedIdealHighSummand bareIdealHighSummand + have hc : Continuous (fun q : (ℂ × ℂ) × ℂ => (elementNorm p.1.val:ℂ)^(-q.2)) := + continuous_snd.neg.const_cpow (Or.inl hH) + have h1 : Continuous (fun q : (ℂ × ℂ) × ℂ => fullIdealWeight (q.1.1+1/2) p.2.1.1) := + (fullIdealWeight_continuous _).comp (by fun_prop) + have h2 : Continuous (fun q : (ℂ × ℂ) × ℂ => fullIdealWeight (1+3*q.1.1) p.2.1.2) := + (fullIdealWeight_continuous _).comp (by fun_prop) + have h3 : Continuous (fun q : (ℂ × ℂ) × ℂ => fullIdealWeight q.1.2 p.2.2.1) := + (fullIdealWeight_continuous _).comp (by fun_prop) + have h4 : Continuous (fun q : (ℂ × ℂ) × ℂ => fullIdealWeight (6*q.2) p.2.2.2) := + (fullIdealWeight_continuous _).comp (by fun_prop) + exact (continuous_const.mul hc).mul + (continuous_const.mul ((((continuous_const.mul h1).mul h2).mul h3).mul h4)) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/InitialProduct.lean b/lean/OAI/NumberTheory/DirichletL/Detector/InitialProduct.lean new file mode 100644 index 0000000000000000000000000000000000000000..a9b3af9ccaf0fe8984106b4329116c0fc8a50dc3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/InitialProduct.lean @@ -0,0 +1,39 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialSubseries +import Mathlib.MeasureTheory.Integral.Prod + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary +local notation "O" => ActualEisensteinCubic.O + +theorem initialHigh_counting_product_integrable {ι : Type*} [Countable ι] + [MeasurableSpace ι] [MeasurableSingletonClass ι] + (e : ι→FullHighIndex) (he : Function.Injective e) + (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) + (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1<ξ) + (T : HeightSpace→ℂ) (hT : Integrable T heightMeasure) (hcT : Continuous T) : + Integrable (fun p : ι×HeightSpace=>initialHighOnLines S D η mask σ υ ξ (e p.1) p.2*T p.2) + ((Measure.count:Measure ι).prod heightMeasure) := by + have hb : Integrable (fun i : ι=>initialHighMajorant σ υ ξ (e i)) Measure.count := by + rw [integrable_count_iff] + simpa only [Function.comp_def,Real.norm_eq_abs,abs_of_nonneg (initialHighMajorant_nonneg _ _ _ _)] using + (initialHighMajorant_summable σ υ ξ hσ hυ hξ).comp_injective he + apply (hb.mul_prod hT.norm).mono' + · apply Measurable.aestronglyMeasurable + apply measurable_from_prod_countable_right + intro i + exact ((initialHighOnLines_continuous S D η mask σ υ ξ (e i)).mul hcT).measurable + · apply Filter.Eventually.of_forall + intro p + rw [norm_mul] + exact mul_le_mul_of_nonneg_right + (initialHighOnLines_norm_le S D η mask hm σ υ ξ (e p.1) p.2) (norm_nonneg _) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/InitialRows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/InitialRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..343c3e709cc2de8a9f83c23a8bc1c91860946f42 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/InitialRows.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Detector.CompensatedTriple + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def highRowOnLines (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) (D : Id) + (σ υ ξ : ℝ) (u : NonzeroFrequency) (t : HeightSpace) : ℂ := + star (C.residueMonoid u.val)*frequencyWeight ((ξ:ℂ)+t.1.2*Complex.I) u* + markedIdealHighSeries S D η u.val ((σ:ℂ)+t.1.1*Complex.I) + ((υ:ℂ)+t.2*Complex.I) ((ξ:ℂ)+t.1.2*Complex.I) + +lemma highRowOnLines_eq_tsum (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) (D : Id) + (σ υ ξ : ℝ) (u : NonzeroFrequency) (t : HeightSpace) : + highRowOnLines η S C D σ υ ξ u t= + ∑'q : (Id×Id)×(Id×Id),initialHighOnLines S D η (fun H=>star (C.residueMonoid H.val)) + σ υ ξ (u,q) t := by + unfold highRowOnLines markedIdealHighSeries initialHighOnLines fullHighCoefficient + exact (tsum_mul_left (a:=star (C.residueMonoid u.val)*frequencyWeight ((ξ:ℂ)+t.1.2*Complex.I) u) + (f:=fun q : (Id×Id)×(Id×Id)=>markedIdealHighSummand S D η u.val + ((σ:ℂ)+t.1.1*Complex.I) ((υ:ℂ)+t.2*Complex.I) ((ξ:ℂ)+t.1.2*Complex.I) + q.1.1 q.1.2 q.2.1 q.2.2)).symm + +lemma initialHighMajorant_row_summable (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1/6<ξ) + (u : NonzeroFrequency) : Summable (fun q : (Id×Id)×(Id×Id)=>initialHighMajorant σ υ ξ (u,q)) := by + unfold initialHighMajorant + exact (highAbsoluteMajorant_summable (σ:ℂ) (υ:ℂ) (ξ:ℂ) hσ hυ hξ).mul_left ‖frequencyWeight (ξ:ℂ) u‖ + +lemma highRowOnLines_continuous (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) (D : Id) + (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1/6<ξ) (u : NonzeroFrequency) : + Continuous (highRowOnLines η S C D σ υ ξ u) := by + change Continuous (fun t=>highRowOnLines η S C D σ υ ξ u t) + simp_rw [highRowOnLines_eq_tsum] + apply continuous_tsum _ (initialHighMajorant_row_summable σ υ ξ hσ hυ hξ u) + (fun q t=>initialHighOnLines_norm_le S D η (fun H=>star (C.residueMonoid H.val)) + (fun H=>by simpa only [norm_star] using C.residueMonoid_norm_le_one H.val) σ υ ξ (u,q) t) + intro q + exact initialHighOnLines_continuous S D η _ σ υ ξ (u,q) + +lemma highRowOnLines_bound (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) (D : Id) + (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1/6<ξ) (u : NonzeroFrequency) (t : HeightSpace) : + ‖highRowOnLines η S C D σ υ ξ u t‖≤ + ‖frequencyWeight (ξ:ℂ) u‖*(∑'q : (Id×Id)×(Id×Id),highAbsoluteMajorant (σ:ℂ) (υ:ℂ) (ξ:ℂ) q) := by + rw [highRowOnLines_eq_tsum] + have hm := initialHighMajorant_row_summable σ υ ξ hσ hυ hξ u + have hb (q : (Id×Id)×(Id×Id)) := initialHighOnLines_norm_le S D η + (fun H=>star (C.residueMonoid H.val)) + (fun H=>by simpa only [norm_star] using C.residueMonoid_norm_le_one H.val) σ υ ξ (u,q) t + have hs := Summable.of_nonneg_of_le (fun q=>norm_nonneg _) hb hm + apply (norm_tsum_le_tsum_norm hs).trans + have he := hs.tsum_le_tsum hb hm + simpa only [initialHighMajorant,tsum_mul_left] using he + +lemma highRows_counting_product_integrable {ρ : Type*} [Countable ρ] + [MeasurableSpace ρ] [MeasurableSingletonClass ρ] + (e : ρ→NonzeroFrequency) (he : Function.Injective e) + (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) (D : Id) + (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1<ξ) + (T : HeightSpace→ℂ) (hT : Integrable T heightMeasure) (hcT : Continuous T) : + Integrable (fun p : ρ×HeightSpace=>highRowOnLines η S C D σ υ ξ (e p.1) p.2*T p.2) + ((Measure.count:Measure ρ).prod heightMeasure) := by + let A : ℝ := ∑'q : (Id×Id)×(Id×Id),highAbsoluteMajorant (σ:ℂ) (υ:ℂ) (ξ:ℂ) q + have hA : 0≤A := tsum_nonneg (highAbsoluteMajorant_nonneg _ _ _) + have hb : Integrable (fun r : ρ=>‖frequencyWeight (ξ:ℂ) (e r)‖*A) Measure.count := by + rw [integrable_count_iff] + simpa only [Function.comp_def,Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (norm_nonneg _) hA)] using + ((frequencyWeight_summable_norm (ξ:ℂ) hξ).comp_injective he).mul_right A + apply (hb.mul_prod hT.norm).mono' + · apply Measurable.aestronglyMeasurable + apply measurable_from_prod_countable_right + intro r + exact ((highRowOnLines_continuous η S C D σ υ ξ hσ hυ (by linarith) (e r)).mul hcT).measurable + · apply Filter.Eventually.of_forall + intro p + rw [norm_mul] + exact mul_le_mul_of_nonneg_right + (highRowOnLines_bound η S C D σ υ ξ hσ hυ (by linarith) (e p.1) p.2) (norm_nonneg _) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/InitialScales.lean b/lean/OAI/NumberTheory/DirichletL/Detector/InitialScales.lean new file mode 100644 index 0000000000000000000000000000000000000000..e627c6235600fb947889316d7afa400fe9fb027d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/InitialScales.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialMajorant +import OAI.NumberTheory.DirichletL.Detector.MellinScaling + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary + +def sourceScale (X Y Z : ℝ) (x w z : ℂ) : ℂ := + (X:ℂ)^(1/2-z)*(Z:ℂ)^(x+z-1)*(Y:ℂ)^(w-1) + +lemma sourceMellinWeight_eq_scale (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (x w z : ℂ) : + sourceMellinWeight W0 W1 X Y Z x w z=sourceScale X Y Z x w z*profile W0 W1 x w z := by + unfold sourceMellinWeight sourceScale profile + ring + +lemma sourceScale_continuous (X Y Z : ℝ) (hX : 0sourceScale X Y Z q.1.1 q.1.2 q.2) := by + have hx : (X:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hX.ne' + have hy : (Y:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hY.ne' + have hz : (Z:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hZ.ne' + unfold sourceScale + exact (((by fun_prop : Continuous (fun q : (ℂ × ℂ) × ℂ =>(1/2:ℂ)-q.2)).const_cpow (Or.inl hx)).mul + (((by fun_prop : Continuous (fun q : (ℂ × ℂ) × ℂ =>q.1.1+q.2-1)).const_cpow (Or.inl hz)))) |>.mul + ((by fun_prop : Continuous (fun q : (ℂ × ℂ) × ℂ =>q.1.2-1)).const_cpow (Or.inl hy)) + +lemma sourceScale_norm (X Y Z : ℝ) (hX : 0sourceMellinWeight W0 W1 X Y Z + ((σ:ℂ)+p.1.1*Complex.I) ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I)) heightMeasure := by + let G := fun p : HeightSpace=>sourceScale X Y Z + ((σ:ℂ)+p.1.1*Complex.I) ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I) + have hc0 := (sourceScale_continuous X Y Z hX hY hZ).comp + (show Continuous (fun p : HeightSpace=>(((σ:ℂ)+p.1.1*Complex.I,(υ:ℂ)+p.2*Complex.I), + (ξ:ℂ)+p.1.2*Complex.I)) by fun_prop) + have hc : Continuous G := by simpa only [G,Function.comp_def] using hc0 + have hb (p : HeightSpace) : ‖G p‖≤(X^(1/2-ξ)*Z^(σ+ξ-1)*Y^(υ-1))*jointHeight p.1.1 p.1.2 p.2^0 := by + simp only [G,sourceScale_norm X Y Z hX hY hZ] + simp + simpa only [sourceMellinWeight_eq_scale,onLines,G] using + profile_arithmetic_integrable W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 σ ξ υ hξ G + hc.aestronglyMeasurable _ 0 hb + +lemma sourceMellinWeight_initial_continuous (W0 W1 : SchwartzMap ℝ ℂ) + (a1 b1 : ℝ) (ha1 : 0sourceMellinWeight W0 W1 X Y Z + ((σ:ℂ)+p.1.1*Complex.I) ((υ:ℂ)+p.2*Complex.I) ((ξ:ℂ)+p.1.2*Complex.I)) := by + have hc := (sourceScale_continuous X Y Z hX hY hZ).comp + (show Continuous (fun p : HeightSpace=>(((σ:ℂ)+p.1.1*Complex.I,(υ:ℂ)+p.2*Complex.I), + (ξ:ℂ)+p.1.2*Complex.I)) by fun_prop) + simpa only [Function.comp_def,Pi.mul_def,sourceMellinWeight_eq_scale,onLines] using + hc.mul (onLines_continuous W0 W1 a1 b1 ha1 hW1 σ ξ υ hξ) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/InitialSubseries.lean b/lean/OAI/NumberTheory/DirichletL/Detector/InitialSubseries.lean new file mode 100644 index 0000000000000000000000000000000000000000..c4a15fd89c8db245f71a77b9c5858a08d750826a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/InitialSubseries.lean @@ -0,0 +1,48 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialFubini + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary +local notation "O" => ActualEisensteinCubic.O + +abbrev RawHighIndex := NonzeroFrequency×((Ideal O×Ideal O)×Ideal O) + +def rawHighEmbedding (p : RawHighIndex) : FullHighIndex := (p.1,(p.2.1,(p.2.2,1))) + +lemma rawHighEmbedding_injective : Function.Injective rawHighEmbedding := by + rintro ⟨h,⟨ij,k⟩⟩ ⟨h',⟨ij',k'⟩⟩ he + simpa only [rawHighEmbedding,Prod.mk.injEq,and_true] using he + +theorem initialHigh_integral_tsum_subseries {ι : Type*} [Countable ι] + (e : ι→FullHighIndex) (he : Function.Injective e) + (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (hm : ∀H,‖mask H‖≤1) + (σ υ ξ : ℝ) (hσ : 3/2<σ) (hυ : 2<υ) (hξ : 1<ξ) + (T : HeightSpace→ℂ) (hT : Integrable T heightMeasure) : + (∫p,∑'i : ι, initialHighOnLines S D η mask σ υ ξ (e i) p*T p ∂heightMeasure)= + ∑'i : ι, ∫p,initialHighOnLines S D η mask σ υ ξ (e i) p*T p ∂heightMeasure := by + let F := fun i p=>initialHighOnLines S D η mask σ υ ξ (e i) p*T p + have hb (i : ι) (p : HeightSpace) : + ‖F i p‖≤ initialHighMajorant σ υ ξ (e i)*‖T p‖ := by + dsimp only [F] + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (initialHighOnLines_norm_le S D η mask hm σ υ ξ (e i) p) (norm_nonneg _) + have hF (i : ι) : Integrable (F i) heightMeasure := by + apply (hT.norm.const_mul (initialHighMajorant σ υ ξ (e i))).mono' + · exact (initialHighOnLines_continuous S D η mask σ υ ξ (e i)).aestronglyMeasurable.mul hT.aestronglyMeasurable + · exact Filter.Eventually.of_forall (hb i) + have hsum : Summable (fun i : ι=>∫p,‖F i p‖ ∂heightMeasure) := by + apply Summable.of_nonneg_of_le (fun i=>integral_nonneg (fun _=>norm_nonneg _)) + (fun i=>?_) (((initialHighMajorant_summable σ υ ξ hσ hυ hξ).comp_injective he).mul_right + (∫p,‖T p‖ ∂heightMeasure)) + rw [←integral_const_mul] + exact integral_mono (hF i).norm (hT.norm.const_mul _) (hb i) + exact (integral_tsum_of_summable_integral_norm hF hsum).symm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LiftedFourier.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LiftedFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..acb1b1178867170942f5d4330a830ab41588a96c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LiftedFourier.lean @@ -0,0 +1,113 @@ +import OAI.NumberTheory.DirichletL.Detector.CongruenceScalar + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CubicEisenstein GaussianShiftedPartition +local notation "O" => ActualEisensteinCubic.O + +theorem primePowerGauss_lift_add (p : O) (hp : Prime p) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n k : ℕ) (h : O) : + primePowerGauss p hp.ne_zero χ (n+k) (p^k*h) = + (Ideal.absNorm (Ideal.span {p}):ℂ)^k * primePowerGauss p hp.ne_zero χ n h := by + by_cases hd : p^n ∣ h + · obtain ⟨a, rfl⟩ := hd + have he : p^k*(p^n*a) = p^(n+k)*a := by rw [pow_add]; ring + rw [he, primePowerGauss_lift, primePowerGauss_lift, pow_add] + ring + · have hbig : ¬p^(n+k) ∣ p^k*h := by + rw [pow_add, mul_comm (p^n) (p^k), mul_dvd_mul_iff_left (pow_ne_zero _ hp.ne_zero)] + exact hd + rw [primePowerGauss_zero_off_support _ _ _ _ _ hbig, + primePowerGauss_zero_off_support _ _ _ _ _ hd, mul_zero] + +theorem primePowerGauss_add_period (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h a : O) : + primePowerGauss p hp χ n (h+p^(n+1)*a) = primePowerGauss p hp χ n h := by + unfold primePowerGauss conductorFourier + apply tsum_congr + intro x + have hz : Ideal.Quotient.mk (Ideal.span {p*p^n}) (p^(n+1)*a) = 0 := by + apply Ideal.Quotient.eq_zero_iff_mem.mpr + apply Ideal.mem_span_singleton.mpr + refine ⟨a, ?_⟩ + rw [pow_succ'] + simp only [map_add, hz, add_zero] + +theorem gauss_exactQuotient_lift (p : O) (hp : Prime p) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n k : ℕ) (h : O) : + (if hd : p^k ∣ h then primePowerGauss p hp.ne_zero χ n (exactQuotient h (p^k) hd) else 0) = + ((Ideal.absNorm (Ideal.span {p}):ℂ)^k)⁻¹ * primePowerGauss p hp.ne_zero χ (n+k) h := by + have hq : (Ideal.absNorm (Ideal.span {p}):ℂ) ≠ 0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero) + by_cases hd : p^k ∣ h + · rw [dite_eq_left hd] + conv_rhs => rw [exactQuotient_spec h (p^k) hd] + rw [primePowerGauss_lift_add p hp, ← mul_assoc, inv_mul_cancel₀ (pow_ne_zero _ hq), one_mul] + · rw [dite_eq_right hd] + have hnd : ¬p^(n+k) ∣ h := by + intro he + exact hd ((show p^k ∣ p^(n+k) from ⟨p^n, by rw [pow_add]; ring⟩).trans he) + rw [primePowerGauss_zero_off_support _ _ _ _ _ hnd, mul_zero] + +theorem positiveScalar_full_lift (p : O) (hp : Prime p) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n k j : ℕ) (hk : k ≠ 0) : + positiveScalar p hp.ne_zero χ n k j = + ((Ideal.absNorm (Ideal.span {p}):ℂ)^k)⁻¹ * + ∑' d : O ⧸ Ideal.span {p^k}, + (χ^k) (Ideal.Quotient.mk _ (representative (p^k) d)) * + primePowerGauss p hp.ne_zero (χ^(n+1)) (n+k) + (p^j-p^(n+1)*representative (p^k) d) := by + rw [positiveScalar, ite_eq_right hk, ← tsum_mul_left] + apply tsum_congr + intro d + have he := gauss_exactQuotient_lift p hp (χ^(n+1)) n k + (p^j-p^(n+1)*representative (p^k) d) + by_cases hd : p^k ∣ p^j-p^(n+1)*representative (p^k) d + · rw [dite_eq_left hd] at he ⊢ + rw [he] + ring + · rw [dite_eq_right hd] at he ⊢ + linear_combination (χ^k) (Ideal.Quotient.mk _ (representative (p^k) d)) * he + +lemma quotientTrace_split_frequency (a b : O) (ha : a ≠ 0) (hb : b ≠ 0) + (H d v : O) : + quotientTrace (a*b) (mul_ne_zero ha hb) (Ideal.Quotient.mk _ ((H-b*d)*v)) = + quotientTrace (a*b) (mul_ne_zero ha hb) (Ideal.Quotient.mk _ (H*v)) * + quotientTrace a ha (Ideal.Quotient.mk _ ((-v)*d)) := by + have hs := quotientTrace_conductor_scale a b ((-v)*d) ha hb 1 + simp only [mul_one, map_one] at hs + rw [show (H-b*d)*v = H*v+b*((-v)*d) by ring, map_add, AddChar.map_add_eq_mul, hs] + +def quotientFourier (p c : O) (hc : c ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (H : O) : ℂ := + ∑' d : O ⧸ Ideal.span {c}, χ (Ideal.Quotient.mk _ (representative c d)) * + quotientTrace c hc (Ideal.Quotient.mk _ (H*representative c d)) + +lemma quotientFourier_congr (p a b : O) (ha : a ≠ 0) (hb : b ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (H : O) (he : a=b) : + quotientFourier p a ha χ H = quotientFourier p b hb χ H := by + subst b + rfl + +lemma primePowerGauss_eq_quotientFourier (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (H : O) : + primePowerGauss p hp χ n H = + quotientFourier p (p*p^n) (mul_ne_zero hp (pow_ne_zero _ hp)) χ H := by + unfold primePowerGauss conductorFourier quotientFourier + apply tsum_congr + intro d + have hr : conductorReduction p (p^n) d = + Ideal.Quotient.mk (Ideal.span {p}) (representative (p*p^n) d) := by + conv_lhs => rw [← representative_spec (p*p^n) d] + rfl + have hm : Ideal.Quotient.mk (Ideal.span {p*p^n}) (H*representative (p*p^n) d) = + Ideal.Quotient.mk _ H*d := by rw [map_mul, representative_spec] + rw [hr, hm] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Local.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Local.lean new file mode 100644 index 0000000000000000000000000000000000000000..599ab7884122342f9d200a81119ea5a410114e0a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Local.lean @@ -0,0 +1,98 @@ +import Mathlib.Analysis.Complex.Norm +import Mathlib.Tactic.FieldSimp +import Mathlib.Tactic.Ring +import Mathlib.Tactic.LinearCombination + +namespace OAI + +namespace SevenEighths.ProbeLocal +noncomputable section + +def localFactor (V W Pstar : ℂ) : ℂ := 1 / (1 - V) + W / (1 - W) + Pstar + +def localCorrection (V W D Pstar : ℂ) : ℂ := + localFactor V W Pstar * ((1 - V) * (1 - W)) / (1 - D) + +def continuedCorrection (V W D Pstar : ℂ) : ℂ := + (1 - V * W + (1 - V) * (1 - W) * Pstar) / (1 - D) + +theorem continuedCorrection_eq_raw (V W D Pstar : ℂ) + (hV : 1 - V ≠ 0) (hW : 1 - W ≠ 0) (hD : 1 - D ≠ 0) : + continuedCorrection V W D Pstar = localCorrection V W D Pstar := by + unfold continuedCorrection localCorrection localFactor + field_simp + ring + +def compensatedReplacement (V W D Pstar B q : ℂ) : ℂ := + ((B - q) * (1 - V) * (1 - W) * Pstar - q * (1 - V * W)) / (1 - D) + +theorem correction_defect (V W D Pstar : ℂ) + (hV : 1 - V ≠ 0) (hW : 1 - W ≠ 0) (hD : 1 - D ≠ 0) : + localCorrection V W D Pstar - 1 = + (D * (V + W - V * W) - V * W + + (1 - V) * (1 - W) * (Pstar + D)) / (1 - D) := by + unfold localCorrection localFactor + field_simp + ring + +theorem compensatedReplacement_eq_raw (V W D Pstar B q : ℂ) + (hV : 1 - V ≠ 0) (hW : 1 - W ≠ 0) (hD : 1 - D ≠ 0) + (hP : localFactor V W Pstar ≠ 0) : + compensatedReplacement V W D Pstar B q = + localCorrection V W D Pstar * (B * Pstar / localFactor V W Pstar - q) := by + unfold localCorrection compensatedReplacement + field_simp + unfold localFactor + field_simp + ring + +theorem compensatedReplacement_ramified (V Pstar B q : ℂ) (hV : 1 - V ≠ 0) : + compensatedReplacement V 0 0 Pstar B q = + B * (1 - V) * Pstar - q * localCorrection V 0 0 Pstar := by + unfold compensatedReplacement localCorrection localFactor + field_simp + ring + +theorem normalized_cancellation (V W D Pstar B q vInv : ℂ) + (hV : 1 - V ≠ 0) (hW : 1 - W ≠ 0) (hD : 1 - D ≠ 0) + (hBD : B * D = vInv) (hvW : vInv * W = q) : + compensatedReplacement V W D Pstar B q + + localCorrection V W D Pstar * vInv = + (1 - V) * (1 - W) / (1 - D) * + ((vInv - q) * (V / (1 - V) - D) + + (B + vInv - q) * (Pstar + D)) := by + unfold compensatedReplacement localCorrection localFactor + field_simp + linear_combination -(1 - V) * (1 - W) * hBD + (1 - V) * hvW + +theorem continuedCorrection_defect (V W D Pstar : ℂ) (hD : 1 - D ≠ 0) : + continuedCorrection V W D Pstar - 1 = + (D * (V + W - V * W) - V * W + + (1 - V) * (1 - W) * (Pstar + D)) / (1 - D) := by + unfold continuedCorrection + field_simp + ring + +theorem continued_normalized_cancellation (V W D Pstar B q vInv : ℂ) + (hV : 1 - V ≠ 0) (hD : 1 - D ≠ 0) + (hBD : B * D = vInv) (hvW : vInv * W = q) : + compensatedReplacement V W D Pstar B q + + continuedCorrection V W D Pstar * vInv = + (1 - V) * (1 - W) / (1 - D) * + ((vInv - q) * (V / (1 - V) - D) + + (B + vInv - q) * (Pstar + D)) := by + unfold compensatedReplacement continuedCorrection + field_simp + linear_combination -(1 - V) * (1 - W) * hBD + (1 - V) * hvW + +theorem continued_ramified_compensation (V Pstar B q : ℂ) : + compensatedReplacement V 0 0 Pstar B q = + B * (1 - V) * Pstar - q * continuedCorrection V 0 0 Pstar := by + simp only [compensatedReplacement, continuedCorrection, mul_zero, sub_zero, + mul_one, div_one] + ring + +end +end SevenEighths.ProbeLocal + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LocalPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LocalPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..e936163fe9fc53cc0f3538331701fb4203a3fb62 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LocalPhysical.lean @@ -0,0 +1,114 @@ +import OAI.NumberTheory.DirichletL.Detector.CalibrationRemoval +import OAI.NumberTheory.DirichletL.Detector.ScalarTable + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalRowCompletion +open CubicEisenstein GaussianShiftedPartition ProbePrimePower ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +lemma outerQuotient_prime_power (p : O) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (k : ℕ) (hk : k≠0) (d : O ⧸ Ideal.span {p^k}) : + outerQuotient (p^k) d = + (actualSextic (Ideal.span {p}) hg ^ k) + (Ideal.Quotient.mk _ (representative (p^k) d)) := by + unfold outerQuotient + rw [← Ideal.span_singleton_pow, map_pow, idealRowHom_prime _ _ hg, MulChar.pow_apply' _ hk] + +lemma sexticGauss_prime_power (p : O) (hp : Prime p) [(Ideal.span {p}:Ideal O).IsMaximal] + (hg : goodLambda∉Ideal.span {p}) (n : ℕ) (H : O) : + sexticGauss (p^(n+1)) (pow_ne_zero _ hp.ne_zero) H = + primePowerGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg^(n+1)) n H := by + have he : sexticGauss (p^(n+1)) (pow_ne_zero _ hp.ne_zero) H = + quotientFourier p (p^(n+1)) (pow_ne_zero _ hp.ne_zero) + (actualSextic (Ideal.span {p}) hg^(n+1)) H := by + unfold sexticGauss quotientFourier + apply tsum_congr + intro d + have hc := outerQuotient_prime_power p hg (n+1) (by omega) d + change idealRowHom (representative (p^(n+1)) d) (Ideal.span {p^(n+1)}) = _ at hc + rw [hc] + rw [(Ideal.Quotient.mk (Ideal.span {p^(n+1)})).map_mul, representative_spec] + rw [he, primePowerGauss_eq_quotientFourier] + apply quotientFourier_congr + exact pow_succ' p n + +theorem bareCongruenceCoefficient_prime_power_pos (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (n k j : ℕ) (hk : k≠0) : + bareCongruenceCoefficient (p^(n+1)) (p^k) (pow_ne_zero _ hp.ne_zero) (p^j) = + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) n k j := by + unfold bareCongruenceCoefficient congruenceCoefficient + rw [positiveScalar, ite_eq_right hk] + apply tsum_congr + intro d + rw [outerQuotient_prime_power p hg k hk] + split_ifs with hd + · rw [rawFourier_outer, sexticGauss_prime_power p hp hg] + · ring + +lemma sexticGauss_one (H : O) : sexticGauss 1 one_ne_zero H=1 := by + let : Subsingleton (O ⧸ Ideal.span {(1:O)}) := by + rw [Ideal.span_singleton_one] + infer_instance + let : Unique (O ⧸ Ideal.span {(1:O)}) := uniqueOfSubsingleton 0 + let : Fintype (O ⧸ Ideal.span {(1:O)}) := Fintype.ofFinite _ + unfold sexticGauss + have hrow (d : O ⧸ Ideal.span {(1:O)}) : + idealRowHom (representative 1 d) (Ideal.span {(1:O)})=1 := by + rw [Ideal.span_singleton_one, ← Ideal.one_eq_top, map_one] + simp only [hrow, one_mul] + have ht (d : O ⧸ Ideal.span {(1:O)}) : + quotientTrace 1 one_ne_zero (Ideal.Quotient.mk _ H*d)=1 := by + rw [Subsingleton.elim (Ideal.Quotient.mk _ H*d) 0, AddChar.map_zero_eq_one] + simp only [ht, tsum_fintype, Finset.sum_const, Finset.card_univ, Fintype.card_unique, one_smul] + +lemma barePhysicalFourier_outer_one (A : O) (hA : A≠0) (H : O) : + barePhysicalFourier A 1 hA one_ne_zero H = sexticGauss A hA H := by + unfold barePhysicalFourier + rw [elementFourier_congr (A*1) A (mul_ne_zero hA one_ne_zero) hA _ H (mul_one A)] + simp only [sexticGauss_one, mul_one] + rfl + +lemma bareCongruenceCoefficient_outer_one (A : O) (hA : A≠0) (H : O) : + bareCongruenceCoefficient A 1 hA H=sexticGauss A hA H := by + have he := barePhysicalFourier_eq A 1 hA one_ne_zero H + rw [barePhysicalFourier_outer_one] at he + simpa only [Ideal.span_singleton_one, ← Ideal.one_eq_top, map_one, Nat.cast_one, one_mul] using he.symm + +theorem bareCongruenceCoefficient_prime_power (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) (n k j : ℕ) : + bareCongruenceCoefficient (p^(n+1)) (p^k) (pow_ne_zero _ hp.ne_zero) (p^j) = + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) n k j := by + by_cases hk : k=0 + · subst k + rw [pow_zero, bareCongruenceCoefficient_outer_one, sexticGauss_prime_power p hp hg, + positiveScalar_kzero] + · exact bareCongruenceCoefficient_prime_power_pos p hp hg n k j hk + +theorem bareCongruenceCoefficient_inner_one (s : O) (hs : s≠0) (H : O) : + bareCongruenceCoefficient 1 s one_ne_zero H = outerQuotient s (Ideal.Quotient.mk _ H) := by + let := finite_quotient_span hs + let : Fintype (O ⧸ Ideal.span {s}) := Fintype.ofFinite _ + have htest (d : O ⧸ Ideal.span {s}) : + s∣H-1*representative s d ↔ d=Ideal.Quotient.mk _ H := by + rw [one_mul, ← Ideal.mem_span_singleton, ← Ideal.Quotient.mk_eq_mk_iff_sub_mem, + representative_spec, eq_comm] + have hraw (k : O) : rawFourier 1 one_ne_zero (outerQuotient 1) k=1 := by + rw [rawFourier_outer, sexticGauss_one] + unfold bareCongruenceCoefficient congruenceCoefficient + simp_rw [hraw] + simp only [tsum_fintype] + rw [Finset.sum_eq_single (Ideal.Quotient.mk _ H)] + · rw [dite_eq_left ((htest _).mpr rfl), mul_one] + · intro d hd hne + rw [dite_eq_right ((htest d).not.mpr hne), mul_zero] + · simp + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LocalSeries.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LocalSeries.lean new file mode 100644 index 0000000000000000000000000000000000000000..6f34311b0db9dedad0288d2e8de8d4768037b535 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LocalSeries.lean @@ -0,0 +1,145 @@ +import OAI.NumberTheory.DirichletL.Detector.UnramifiedScalar +import OAI.NumberTheory.DirichletL.Detector.LocalWeights + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + +def principalMarkedTerm (eta a X W V : ℂ) (e l k m : ℕ) : ℂ := + if e+3*l=0 then 0 else + weightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1) + (star (localGamma p hp.ne_zero hg 3)) (actualSextic (Ideal.span {p}) hg (-1)) X W V + (positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (e+3*l-1) k (6*m)) e l k m + +include hc in +lemma localGamma_conjugate_three_sq : + (star (localGamma p hp.ne_zero hg 3))^2 = actualSextic (Ideal.span {p}) hg (-1) := by + have hg3 : localGamma p hp.ne_zero hg 3 ^ 2 = actualSextic (Ideal.span {p}) hg (-1) := + ProbePhase.normalizedTraceGauss_three_sq p hp.ne_zero hg hc + rw [← star_pow, hg3] + have hω := actualSextic_neg_one_sq (Ideal.span {p}) hg + rcases (sq_eq_one_iff).mp hω with h | h + · simp [h] + · simp [h] + +include hc in +lemma firstGauss_ne_zero : primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1 ≠ 0 := by + have hχ : actualSextic (Ideal.span {p}) hg ≠ 1 := by + intro h + have he : actualSextic (Ideal.span {p}) hg ^ 1 = 1 := by simpa using h + have hd := (actualSextic_pow_eq_one_iff _ hg hc 1).mp he + norm_num at hd + have he := primeGauss_inverse_pair p hp.ne_zero (actualSextic (Ideal.span {p}) hg) hχ + have hω : actualSextic (Ideal.span {p}) hg (-1) ≠ 0 := + (actualSextic (Ideal.span {p}) hg).apply_ne_zero_iff.mpr isUnit_one.neg + have hQ : (Ideal.absNorm (Ideal.span {p}):ℂ) ≠ 0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero) + intro hz + rw [hz, zero_mul] at he + exact (mul_ne_zero hω hQ) he.symm + +omit [(Ideal.span {p}).IsMaximal] in +include hp in +lemma primeNorm_ne_zero : (Ideal.absNorm (Ideal.span {p}):ℂ) ≠ 0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero) + +include hc + +omit hc in +@[simp] theorem markedTerm_zero_index (eta a X W V : ℂ) (k m : ℕ) : + principalMarkedTerm p hp hg eta a X W V 0 0 k m = 0 := by + simp only [principalMarkedTerm, mul_zero, add_zero, ite_true] + +omit hc in +lemma markedTerm_higher_outer (eta a X W V : ℂ) (e l k m : ℕ) : + principalMarkedTerm p hp hg eta a X W V e l (k+2) m = 0 := by + unfold principalMarkedTerm + split_ifs + · rfl + · rw [positiveScalar_kge_two p hp, weightedScalar_zero] + +lemma markedTerm_odd (eta a X W V : ℂ) (e r k m : ℕ) (he : e ≤ 1) : + principalMarkedTerm p hp hg eta a X W V e (2*r+1) k m = 0 := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega)] + have hn : e+3*(2*r+1)-1 = 6*r+(e+2) := by omega + rw [hn, unramified_odd_zero p hp hg hc r m k (e+2) (by omega), weightedScalar_zero] + +lemma markedTerm_squarefree_boundary (eta a X W V : ℂ) (r : ℕ) : + principalMarkedTerm p hp hg eta a X W V 1 (2*r) 0 r = + evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * (-eta*X) := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 1+3*(2*r)-1=6*r by omega, + unramified_squarefree_kzero p hp hg hc, ite_eq_left rfl] + exact weighted_squarefree_boundary _ _ _ _ _ _ _ _ _ (primeNorm_ne_zero p hp) + (firstGauss_ne_zero p hp hg hc) (localGamma_conjugate_three_sq p hp hg hc) + (actualSextic_neg_one_sq _ hg) r + +lemma markedTerm_squarefree_boundary_off (eta a X W V : ℂ) (r m : ℕ) (hm : m ≠ r) : + principalMarkedTerm p hp hg eta a X W V 1 (2*r) 0 m = 0 := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 1+3*(2*r)-1=6*r by omega, + unramified_squarefree_kzero p hp hg hc, ite_eq_right hm, weightedScalar_zero] + +lemma markedTerm_even_bulk (eta a X W V : ℂ) (r d : ℕ) : + principalMarkedTerm p hp hg eta a X W V 0 (2*r+2) 0 (r+1+d) = + evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V * + (1-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*V^d) := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 0+3*(2*r+2)-1=6*r+5 by omega, + unramified_even_kzero p hp hg hc, ite_eq_left (by omega)] + exact weighted_even_bulk _ _ _ _ _ _ _ _ _ (primeNorm_ne_zero p hp) + (localGamma_conjugate_three_sq p hp hg hc) (actualSextic_neg_one_sq _ hg) r d + +lemma markedTerm_even_bulk_off (eta a X W V : ℂ) (r m : ℕ) (hm : m < r+1) : + principalMarkedTerm p hp hg eta a X W V 0 (2*r+2) 0 m = 0 := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 0+3*(2*r+2)-1=6*r+5 by omega, + unramified_even_kzero p hp hg hc, ite_eq_right (by omega), weightedScalar_zero] + +lemma markedTerm_even_kone (eta a X W V : ℂ) (r : ℕ) : + principalMarkedTerm p hp hg eta a X W V 0 (2*r+2) 1 (r+1) = + evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (W*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 0+3*(2*r+2)-1=6*r+5 by omega, + unramified_even_kone p hp hg hc, ite_eq_left rfl] + exact weighted_even_kone _ _ _ _ _ _ _ _ _ (primeNorm_ne_zero p hp) + (localGamma_conjugate_three_sq p hp hg hc) (actualSextic_neg_one_sq _ hg) r + +lemma markedTerm_even_kone_off (eta a X W V : ℂ) (r m : ℕ) (hm : m ≠ r+1) : + principalMarkedTerm p hp hg eta a X W V 0 (2*r+2) 1 m = 0 := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 0+3*(2*r+2)-1=6*r+5 by omega, + unramified_even_kone p hp hg hc, ite_eq_right hm, weightedScalar_zero] + +lemma markedTerm_squarefree_bulk (eta a X W V : ℂ) (r d : ℕ) : + principalMarkedTerm p hp hg eta a X W V 1 (2*r) 1 (r+1+d) = + evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (-eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W*V^(d+1)) := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 1+3*(2*r)-1=6*r by omega, + unramified_squarefree_kone p hp hg hc, ite_eq_left (by omega)] + exact weighted_squarefree_bulk _ _ _ _ _ _ _ _ _ (primeNorm_ne_zero p hp) + (firstGauss_ne_zero p hp hg hc) (localGamma_conjugate_three_sq p hp hg hc) + (actualSextic_neg_one_sq _ hg) r d + +lemma markedTerm_squarefree_bulk_off (eta a X W V : ℂ) (r m : ℕ) (hm : m < r+1) : + principalMarkedTerm p hp hg eta a X W V 1 (2*r) 1 m = 0 := by + unfold principalMarkedTerm + rw [ite_eq_right (by omega), show 1+3*(2*r)-1=6*r by omega, + unramified_squarefree_kone p hp hg hc, ite_eq_right (by omega), weightedScalar_zero] + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LocalSummation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LocalSummation.lean new file mode 100644 index 0000000000000000000000000000000000000000..996cd7de7eb8c78e65951d8d99b08b0a759dcfdd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LocalSummation.lean @@ -0,0 +1,184 @@ +import OAI.NumberTheory.DirichletL.Detector.LocalSeries +import OAI.NumberTheory.DirichletL.Detector.Euler + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +lemma hasSum_geometric_tail (f : ℕ → ℂ) (a : ℕ) (B V : ℂ) (hV : ‖V‖<1) + (hz : ∀ m, m f (n+a)) (B/(1-V)) := by + simpa only [hf, div_eq_mul_inv] using (hasSum_geometric_of_norm_lt_one hV).mul_left B + have hs : (∑ i ∈ Finset.range a, f i) = 0 := + Finset.sum_eq_zero (fun i hi => hz i (Finset.mem_range.mp hi)) + simpa only [hs, zero_add] using ht.sum_range_add + +lemma tsum_two_of_rest_zero (f : ℕ → ℂ) (hf : ∀ k, f (k+2)=0) : + (∑' k, f k) = f 0+f 1 := by + rw [tsum_eq_sum (s := {0,1})] + · simp + · intro k hk + have hk2 : 2 ≤ k := by simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk; omega + obtain ⟨k,rfl⟩ := Nat.exists_eq_add_of_le hk2 + simpa only [Nat.add_comm] using hf k + +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + +def principalInner (eta a X W V : ℂ) (e l : ℕ) : ℂ := + ∑' k : ℕ, ∑' m : ℕ, principalMarkedTerm p hp hg eta a X W V e l k m + +include hc + +lemma squarefree_boundary_hasSum (eta a X W V : ℂ) (r : ℕ) : + HasSum (fun m => principalMarkedTerm p hp hg eta a X W V 1 (2*r) 0 m) + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * (-eta*X)) := by + apply (hasSum_ite_eq r _).congr + intro s + apply Finset.sum_congr rfl + intro m hmS + dsimp only + by_cases hm : m=r + · subst m + rw [ite_eq_left rfl, markedTerm_squarefree_boundary p hp hg hc] + · rw [ite_eq_right hm, markedTerm_squarefree_boundary_off p hp hg hc _ _ _ _ _ _ _ hm] + +lemma even_kone_hasSum (eta a X W V : ℂ) (r : ℕ) : + HasSum (fun m => principalMarkedTerm p hp hg eta a X W V 0 (2*r+2) 1 m) + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (W*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + apply (hasSum_ite_eq (r+1) _).congr + intro s + apply Finset.sum_congr rfl + intro m hmS + dsimp only + by_cases hm : m=r+1 + · subst m + rw [ite_eq_left rfl, markedTerm_even_kone p hp hg hc] + · rw [ite_eq_right hm, markedTerm_even_kone_off p hp hg hc _ _ _ _ _ _ _ hm] + +lemma even_bulk_hasSum (eta a X W V : ℂ) (hV : ‖V‖<1) (r : ℕ) : + HasSum (fun m => principalMarkedTerm p hp hg eta a X W V 0 (2*r+2) 0 m) + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V * + (1-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)) / (1-V)) := by + apply hasSum_geometric_tail _ (r+1) _ V hV + · exact markedTerm_even_bulk_off p hp hg hc eta a X W V r + · intro n + rw [Nat.add_comm n (r+1), markedTerm_even_bulk p hp hg hc] + ring + +lemma squarefree_bulk_hasSum (eta a X W V : ℂ) (hV : ‖V‖<1) (r : ℕ) : + HasSum (fun m => principalMarkedTerm p hp hg eta a X W V 1 (2*r) 1 m) + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (-eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W*V) / (1-V)) := by + apply hasSum_geometric_tail _ (r+1) _ V hV + · exact markedTerm_squarefree_bulk_off p hp hg hc eta a X W V r + · intro n + rw [Nat.add_comm n (r+1), markedTerm_squarefree_bulk p hp hg hc, pow_succ] + ring + +omit hc in +lemma principalInner_two (eta a X W V : ℂ) (e l : ℕ) : + principalInner p hp hg eta a X W V e l = + (∑' m, principalMarkedTerm p hp hg eta a X W V e l 0 m) + + (∑' m, principalMarkedTerm p hp hg eta a X W V e l 1 m) := by + apply tsum_two_of_rest_zero + intro k + simp only [markedTerm_higher_outer p hp hg, tsum_zero] + +lemma principalInner_squarefree (eta a X W V : ℂ) (hV : ‖V‖<1) (r : ℕ) : + principalInner p hp hg eta a X W V 1 (2*r) = + evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (-eta*X - eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W*V/(1-V)) := by + rw [principalInner_two p hp hg, (squarefree_boundary_hasSum p hp hg hc _ _ _ _ _ r).tsum_eq, + (squarefree_bulk_hasSum p hp hg hc _ _ _ _ _ hV r).tsum_eq] + ring + +lemma principalInner_even (eta a X W V : ℂ) (hV : ‖V‖<1) (r : ℕ) : + principalInner p hp hg eta a X W V 0 (2*r+2) = + evenRatio (Ideal.absNorm (Ideal.span {p})) a X V ^ r * + (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V * + (1-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)/(1-V) + + W*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) := by + rw [principalInner_two p hp hg, (even_bulk_hasSum p hp hg hc _ _ _ _ _ hV r).tsum_eq, + (even_kone_hasSum p hp hg hc _ _ _ _ _ r).tsum_eq] + ring + +lemma principalInner_odd (eta a X W V : ℂ) (e r : ℕ) (he : e≤1) : + principalInner p hp hg eta a X W V e (2*r+1) = 0 := by + simp only [principalInner, markedTerm_odd p hp hg hc _ _ _ _ _ e r _ _ he, tsum_zero] + +omit hc in +@[simp] lemma principalInner_zero (eta a X W V : ℂ) : + principalInner p hp hg eta a X W V 0 0 = 0 := by + simp only [principalInner, markedTerm_zero_index p hp hg, tsum_zero] + +lemma principalInner_squarefree_hasSum (eta a X W V : ℂ) (hV : ‖V‖<1) + (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) : + HasSum (fun l => principalInner p hp hg eta a X W V 1 l) + ((-eta*X-eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W*V/(1-V)) / + (1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + let B := -eta*X-eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W*V/(1-V) + have he : HasSum (fun r => principalInner p hp hg eta a X W V 1 (2*r)) + ((1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)⁻¹ * B) := by + simpa only [principalInner_squarefree p hp hg hc eta a X W V hV, B] using + (hasSum_geometric_of_norm_lt_one hR).mul_right B + have ho : HasSum (fun r => principalInner p hp hg eta a X W V 1 (2*r+1)) 0 := by + simp only [principalInner_odd p hp hg hc eta a X W V 1 _ (by omega)] + exact hasSum_zero + convert he.even_add_odd ho using 1 + simp only [add_zero, div_eq_mul_inv, B] + ring + +lemma principalInner_even_hasSum (eta a X W V : ℂ) (hV : ‖V‖<1) + (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) : + HasSum (fun l => principalInner p hp hg eta a X W V 0 l) + ((evenRatio (Ideal.absNorm (Ideal.span {p})) a X V * + (1-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)/(1-V) + + W*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) / + (1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + let B := evenRatio (Ideal.absNorm (Ideal.span {p})) a X V * + (1-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)/(1-V) + + W*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V + have he : HasSum (fun r => principalInner p hp hg eta a X W V 0 (2*r)) + (B/(1-evenRatio (Ideal.absNorm (Ideal.span {p})) a X V)) := by + apply hasSum_geometric_tail _ 1 B _ hR + · intro m hm + have hm0 : m=0 := by omega + simp [hm0, principalInner_zero p hp hg] + · intro r + rw [show 2*(r+1)=2*r+2 by ring, principalInner_even p hp hg hc _ _ _ _ _ hV] + ring + have ho : HasSum (fun r => principalInner p hp hg eta a X W V 0 (2*r+1)) 0 := by + simp only [principalInner_odd p hp hg hc eta a X W V 0 _ (by omega)] + exact hasSum_zero + simpa only [add_zero, B] using he.even_add_odd ho + +def principalMarkedSeries (eta a X W V : ℂ) : ℂ := + ∑ e : Fin 2, ∑' l : ℕ, principalInner p hp hg eta a X W V e.val l + +theorem principalMarkedSeries_eq (eta a X W V : ℂ) (hV : ‖V‖<1) + (hR : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1) : + principalMarkedSeries p hp hg eta a X W V = + markedFactor (evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) V + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹ + (eta*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)*X*W) + (-eta*X+W*evenRatio (Ideal.absNorm (Ideal.span {p})) a X V) 1 := by + unfold principalMarkedSeries + simp only [Fin.sum_univ_two, Fin.val_zero, Fin.val_one] + rw [(principalInner_even_hasSum p hp hg hc eta a X W V hV hR).tsum_eq, + (principalInner_squarefree_hasSum p hp hg hc eta a X W V hV hR).tsum_eq] + unfold markedFactor + simp only [pow_one] + ring + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LocalUnitFrequency.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LocalUnitFrequency.lean new file mode 100644 index 0000000000000000000000000000000000000000..f847e4287dad40517de73c4349c9716d429a336a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LocalUnitFrequency.lean @@ -0,0 +1,165 @@ +import OAI.NumberTheory.DirichletL.Detector.SixthFrequency +import OAI.NumberTheory.DirichletL.Detector.PhysicalLocalEuler + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalRowCompletion CanonicalQuadraticSieve CubicEisenstein +open CompletedGauss ConcreteTraceCRT GaussianShiftedPartition CenteredMomentCommonSupport +open CenteredMomentSupportedCorrelation ConcretePrimeRowBridge ProbePrimePower ProbeLocal ProbeEuler +local notation "O" => ActualEisensteinCubic.O + +lemma finite_fourier_unit_scale {R : Type*} [CommRing R] [Fintype R] + (F : R → ℂ) (ψ : AddChar R ℂ) (u : Rˣ) (c : ℂ) (hc : c ≠ 0) + (hF : ∀ x, F ((u : R) * x) = c * F x) (H : R) : + (∑ x, F x * ψ (((u : R) * H) * x)) = c⁻¹ * ∑ x, F x * ψ (H*x) := by + have he : (∑ x, F x * ψ (H*x)) = c * ∑ x, F x * ψ (((u : R)*H)*x) := by + rw [← Equiv.sum_comp u.mulLeft (fun x => F x * ψ (H*x))] + simp only [Units.mulLeft_apply, hF, Finset.mul_sum] + apply Finset.sum_congr rfl + intro x hx + rw [show H*((u : R)*x) = ((u : R)*H)*x by ring] + ring + rw [he, ← mul_assoc, inv_mul_cancel₀ hc, one_mul] + +theorem barePhysicalFourier_unit_frequency (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (b H : O) (hcop : IsCoprime b (A*s)) : + barePhysicalFourier A s (supportedElement_ne_zero A hA) + (supportedElement_ne_zero s hs) (b*H) = + ((idealRowHom b (Ideal.span {A}))⁻¹ * idealRowHom b (Ideal.span {s})) * + barePhysicalFourier A s (supportedElement_ne_zero A hA) + (supportedElement_ne_zero s hs) H := by + have hAs := mul_ne_zero (supportedElement_ne_zero A hA) (supportedElement_ne_zero s hs) + let := finite_quotient_span hAs + let : Fintype (Residue (A*s)) := Fintype.ofFinite _ + let u := residueUnit (A*s) b hcop.symm + have hcA := idealRowHom_ne_zero_of_coprime A b hA hcop.of_mul_right_left.symm + have hcs := idealRowHom_ne_zero_of_coprime s b hs hcop.of_mul_right_right.symm + have hF (x : Residue (A*s)) : + movingQuotient A s (supportedElement_ne_zero s hs) ((u : Residue (A*s))*x) = + (idealRowHom b (Ideal.span {A}) * (idealRowHom b (Ideal.span {s}))⁻¹) * + movingQuotient A s (supportedElement_ne_zero s hs) x := by + exact movingQuotient_unit_scale A s hs b hcop.of_mul_right_right x + have he := finite_fourier_unit_scale (movingQuotient A s (supportedElement_ne_zero s hs)) + (quotientTrace (A*s) hAs) u _ (mul_ne_zero hcA (inv_ne_zero hcs)) hF + (Ideal.Quotient.mk _ H) + unfold barePhysicalFourier elementFourier + simp only [tsum_fintype] + change (∑ x, movingQuotient A s (supportedElement_ne_zero s hs) x * + quotientTrace (A*s) hAs (Ideal.Quotient.mk _ (b*H)*x)) = + _ * ∑ x, movingQuotient A s (supportedElement_ne_zero s hs) x * + quotientTrace (A*s) hAs (Ideal.Quotient.mk _ H*x) + simpa only [u, residueUnit_coe, map_mul, mul_inv_rev, inv_inv, mul_comm] using he + +theorem bareCongruenceCoefficient_unit_frequency (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (b H : O) (hcop : IsCoprime b (A*s)) : + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) (b*H) = + ((idealRowHom b (Ideal.span {A}))⁻¹ * idealRowHom b (Ideal.span {s})) * + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H := by + have he := barePhysicalFourier_unit_frequency A s hA hs b H hcop + simp only [barePhysicalFourier_eq] at he + have hn : (Ideal.absNorm (Ideal.span {s}) : ℂ) ≠ 0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr (supportedElement_ne_zero s hs)) + apply mul_left_cancel₀ hn + rw [he] + ring + +lemma idealRowHom_norm_one_of_coprime (s b : O) + (hs : Supported (Ideal.span {s})) (hcop : IsCoprime b s) : + ‖idealRowHom b (Ideal.span {s})‖ = 1 := by + have h6 := idealRowHom_sixth_mask b (Ideal.span {s}) hs + rw [idealRowHom_argument_pow _ _ _ hs, + ite_eq_left ((Ideal.isCoprime_span_singleton_iff s b).mpr hcop.symm)] at h6 + exact Complex.norm_eq_one_of_pow_eq_one h6 (by decide : (6 : ℕ) ≠ 0) + +theorem bareCongruenceCoefficient_unit_frequency_norm (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (b H : O) (hcop : IsCoprime b (A*s)) : + ‖bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) (b*H)‖ = + ‖bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H‖ := by + rw [bareCongruenceCoefficient_unit_frequency A s hA hs b H hcop, + norm_mul, norm_mul, norm_inv, + idealRowHom_norm_one_of_coprime A b hA hcop.of_mul_right_left, + idealRowHom_norm_one_of_coprime s b hs hcop.of_mul_right_right, + inv_one, one_mul, one_mul] + +theorem bareCongruenceCoefficient_unit_frequency_eq_zero_iff (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (b H : O) (hcop : IsCoprime b (A*s)) : + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) (b*H) = 0 ↔ + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H = 0 := by + rw [← norm_eq_zero, bareCongruenceCoefficient_unit_frequency_norm A s hA hs b H hcop, + norm_eq_zero] + +lemma supported_element_power (p : O) (hs : Supported (Ideal.span {p})) (n : ℕ) : + Supported (Ideal.span {p^n}) := by + rw [← Ideal.span_singleton_pow] + exact supported_pow hs n + +lemma idealRowHom_prime_power_value (p b : O) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (n : ℕ) : + idealRowHom b (Ideal.span {p^n}) = + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^n := by + rw [← Ideal.span_singleton_pow, map_pow, idealRowHom_prime _ _ hg] + +lemma actualSextic_unit_power_ne_zero (p b : O) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hcop : IsCoprime b p) (t : ℕ) : + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^t ≠ 0 := by + apply pow_ne_zero + exact (actualSextic (Ideal.span {p}) hg).apply_ne_zero_iff.mpr + ((isUnit_quotient_span_iff p b).mpr hcop.symm) + +theorem bareCongruenceCoefficient_prime_power_unit_frequency (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] (hs : Supported (Ideal.span {p})) + (hg : goodLambda ∉ Ideal.span {p}) (b : O) (hcop : IsCoprime b p) (t k j : ℕ) : + bareCongruenceCoefficient (p^t) (p^k) (pow_ne_zero _ hp.ne_zero) (b*p^j) = + ((actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^k / + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^t) * + bareCongruenceCoefficient (p^t) (p^k) (pow_ne_zero _ hp.ne_zero) (p^j) := by + have he := bareCongruenceCoefficient_unit_frequency (p^t) (p^k) + (supported_element_power p hs t) (supported_element_power p hs k) b (p^j) + (hcop.pow_right.mul_right hcop.pow_right) + simpa only [idealRowHom_prime_power_value p b hg, div_eq_mul_inv, mul_comm] using he + +theorem bareCongruenceCoefficient_all_prime_powers_unit (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] (hs : Supported (Ideal.span {p})) + (hg : goodLambda ∉ Ideal.span {p}) (b : O) (hcop : IsCoprime b p) (t k j : ℕ) : + bareCongruenceCoefficient (p^t) (p^k) (pow_ne_zero _ hp.ne_zero) (b*p^j) = + ((actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^k / + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^t) * + sourceScalar p hp hg t k j := by + rw [bareCongruenceCoefficient_prime_power_unit_frequency p hp hs hg b hcop t k j, + bareCongruenceCoefficient_all_prime_powers p hp hg t k j] + +theorem barePhysicalFourier_all_prime_powers_unit (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] (hs : Supported (Ideal.span {p})) + (hg : goodLambda ∉ Ideal.span {p}) (b : O) (hcop : IsCoprime b p) (t k j : ℕ) : + barePhysicalFourier (p^t) (p^k) (pow_ne_zero _ hp.ne_zero) + (pow_ne_zero _ hp.ne_zero) (b*p^j) = + (Ideal.absNorm (Ideal.span {p^k}) : ℂ) * + (((actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^k / + (actualSextic (Ideal.span {p}) hg (Ideal.Quotient.mk _ b))^t) * + sourceScalar p hp hg t k j) := by + rw [barePhysicalFourier_eq, + bareCongruenceCoefficient_all_prime_powers_unit p hp hs hg b hcop t k j] + +theorem bareCongruenceCoefficient_all_prime_powers_unit_norm (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] (hs : Supported (Ideal.span {p})) + (hg : goodLambda ∉ Ideal.span {p}) (b : O) (hcop : IsCoprime b p) (t k j : ℕ) : + ‖bareCongruenceCoefficient (p^t) (p^k) (pow_ne_zero _ hp.ne_zero) (b*p^j)‖ = + ‖sourceScalar p hp hg t k j‖ := by + have he := bareCongruenceCoefficient_unit_frequency_norm (p^t) (p^k) + (supported_element_power p hs t) (supported_element_power p hs k) b (p^j) + (hcop.pow_right.mul_right hcop.pow_right) + rw [bareCongruenceCoefficient_all_prime_powers p hp hg t k j] at he + exact he + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LocalWeights.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LocalWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..f30baea8693ca2d864c56c13587dac50113fd86d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LocalWeights.lean @@ -0,0 +1,93 @@ +import OAI.NumberTheory.DirichletL.Detector.PrimeConstants +import OAI.NumberTheory.DirichletL.Detector.PhasePowers + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +lemma even_diagonal_exponent (r : ℕ) : r + (2*r).choose 2 = 2*r*r := by + rw [Nat.choose_two_right, mul_assoc, Nat.mul_div_cancel_left _ (by decide : 0 < 2)] + cases r with + | zero => simp + | succ r => + rw [show 2*(r+1)-1 = 2*r+1 by omega] + ring + +def localCubePhase (C omega : ℂ) (e l k : ℕ) : ℂ := + C^l * omega^((e+3*l)*k+e*l+l.choose 2) + +theorem localCubePhase_even (C omega : ℂ) (hC : C^2=omega) (ho : omega^2=1) + (e r k : ℕ) : localCubePhase C omega e (2*r) k = omega^(e*k) := by + unfold localCubePhase + rw [pow_mul C 2 r, hC, ← pow_add] + have he : r+((e+3*(2*r))*k+e*(2*r)+(2*r).choose 2) = + e*k+2*(3*r*k+e*r+r*r) := by + have hd := even_diagonal_exponent r + nlinarith + rw [he, pow_add, pow_mul omega 2, ho, one_pow, mul_one] + +def weightedScalar (Q eta a G1 C omega X W V scalar : ℂ) (e l k m : ℕ) : ℂ := + (-eta*X/G1)^e * (a*X^3/Q)^l * localCubePhase C omega e l k * scalar * W^k * V^m + +lemma weightedScalar_zero (Q eta a G1 C omega X W V : ℂ) (e l k m : ℕ) : + weightedScalar Q eta a G1 C omega X W V 0 e l k m = 0 := by + simp [weightedScalar] + +def evenRatio (Q a X V : ℂ) : ℂ := a^2*Q^4*X^6*V + +lemma weighted_squarefree_boundary (Q eta a G1 C omega X W V : ℂ) + (hQ : Q ≠ 0) (hG : G1 ≠ 0) (hC : C^2=omega) (ho : omega^2=1) (r : ℕ) : + weightedScalar Q eta a G1 C omega X W V (Q^(6*r)*G1) 1 (2*r) 0 r = + evenRatio Q a X V ^ r * (-eta*X) := by + unfold weightedScalar + rw [localCubePhase_even C omega hC ho] + simp only [mul_zero, pow_zero, pow_one, mul_one] + unfold evenRatio + rw [mul_pow, mul_pow, mul_pow, div_pow, mul_pow, pow_mul, pow_mul, pow_mul, pow_mul] + field_simp + ring + +lemma weighted_even_bulk (Q eta a G1 C omega X W V : ℂ) + (hQ : Q ≠ 0) (hC : C^2=omega) (ho : omega^2=1) (r d : ℕ) : + weightedScalar Q eta a G1 C omega X W V (Q^(6*r+5)*(Q-1)) + 0 (2*r+2) 0 (r+1+d) = + evenRatio Q a X V ^ r * (evenRatio Q a X V*(1-Q⁻¹)*V^d) := by + unfold weightedScalar + rw [show 2*r+2=2*(r+1) by ring, localCubePhase_even C omega hC ho] + simp only [zero_mul, pow_zero, one_mul, mul_one] + unfold evenRatio + simp only [mul_pow, div_pow, pow_add, pow_mul] + field_simp + ring + +lemma weighted_even_kone (Q eta a G1 C omega X W V : ℂ) + (hQ : Q ≠ 0) (hC : C^2=omega) (ho : omega^2=1) (r : ℕ) : + weightedScalar Q eta a G1 C omega X W V (Q^(6*r+6)) + 0 (2*r+2) 1 (r+1) = evenRatio Q a X V ^ r * (W*evenRatio Q a X V) := by + unfold weightedScalar + rw [show 2*r+2=2*(r+1) by ring, localCubePhase_even C omega hC ho] + simp only [pow_zero, pow_one, one_mul, mul_one] + unfold evenRatio + simp only [mul_pow, div_pow, pow_add, pow_mul] + field_simp + ring + +lemma weighted_squarefree_bulk (Q eta a G1 C omega X W V : ℂ) + (hQ : Q ≠ 0) (hG : G1 ≠ 0) (hC : C^2=omega) (ho : omega^2=1) (r d : ℕ) : + weightedScalar Q eta a G1 C omega X W V + ((omega⁻¹*G1)*(Q^(6*r)*(Q-1))) 1 (2*r) 1 (r+1+d) = + evenRatio Q a X V ^ r * (-eta*(Q-1)*X*W*V^(d+1)) := by + have hω : omega ≠ 0 := by intro h; rw [h, zero_pow (by decide)] at ho; norm_num at ho + unfold weightedScalar + rw [localCubePhase_even C omega hC ho] + simp only [one_mul, pow_one] + unfold evenRatio + simp only [mul_pow, div_pow, pow_add, pow_mul] + field_simp + ring + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowActualEnergies.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowActualEnergies.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e810c0fd2eec79fb94e35aa4ccffb2592a899b2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowActualEnergies.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Detector.LowColumnBounds +import OAI.NumberTheory.DirichletL.Detector.LowCauchy + +namespace OAI + +noncomputable section +open scoped Classical ContDiff SchwartzMap +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion CenteredMomentGaussEnergy +local notation "O" => ActualEisensteinCubic.O + +def lowNumeratorRows (a b : ℝ) (ha : 0primaryGenerator s.val) + (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) (lowGaussMajorant a b ha hb) Q).re := by + simp_rw [lowRayAmplitude_source_columns C W1 hW1 Y hY σ v] + exact CenteredMomentReflectedChild.finite_reflected_energy_le_gaussEnergy _ _ _ _ _ Q hQ _ + (fun _=>lowGaussMajorant_nonneg a b ha hb _) + (fun m hm=>by rw [lowGaussMajorant_on_rows a b ha hb Q hQ m hm];norm_num) + +lemma lowSeparatedIntegrand_source_cauchy (a b : ℝ) (ha : 0by rw [hR m hm,zero_mul])] + simp_rw [Finset.mul_sum] + rw [Finset.sum_comm] + simp only [mul_assoc] + rw [he,norm_mul] + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + calc + _ ≤ ∑σ : RayRing,‖∑m∈R,lowNumeratorWeight C (lowOuterCutoff a b) X Y m v*lowRayAmplitude C W1 Y σ m v*B σ m‖ := norm_sum_le _ _ + _ ≤ _ := Finset.sum_le_sum (fun σ _=>CenteredMomentCauchy.bounded_row_cauchy R + (fun m=>lowNumeratorWeight C (lowOuterCutoff a b) X Y m v) (fun m=>lowRayAmplitude C W1 Y σ m v) (B σ) + (fun m _=>lowNumeratorWeight_norm C _ (lowOuterCutoff_norm a b) + (lowOuterCutoff_small a b ha 0 (by positivity)) X Y hX hY m v)) + +theorem lowSeparatedIntegrand_actual_energies (a b : ℝ) (ha : 0primaryGenerator s.val) (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) (lowGaussMajorant a b ha hb) (lowPhysicalScale C X Y)).re)* + Real.sqrt (∑m∈lowNumeratorRows a b ha hb (lowPhysicalScale C X Y) (lowPhysicalScale_pos C X Y hX hY),‖B σ m‖^2) := by + apply (lowSeparatedIntegrand_source_cauchy a b ha hb C W0 W1 X Y hX hY B v).trans + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + apply Finset.sum_le_sum + intro σ hσ + exact mul_le_mul_of_nonneg_right (Real.sqrt_le_sqrt (lowRayAmplitude_actual_energy a b ha hb C W1 hW1 Y hY σ v + (lowPhysicalScale C X Y) (lowPhysicalScale_pos C X Y hX hY))) (Real.sqrt_nonneg _) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowActualIdealLists.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowActualIdealLists.lean new file mode 100644 index 0000000000000000000000000000000000000000..a29aae44a5e7880aa9c3b5a85a65fc3bb9945ee9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowActualIdealLists.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Detector.LowTruePeriodPuncture + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowPrimeIdealList (T : Finset PrimeIdeal) : Finset Id := T.image Subtype.val + +def lowPrimeListEquiv (T : Finset PrimeIdeal) : T≃lowPrimeIdealList T := + Equiv.ofBijective (fun p=>⟨p.val.val,Finset.mem_image.mpr ⟨p.val,p.property,rfl⟩⟩) (by + constructor + · intro p q h + exact Subtype.ext (Subtype.ext (congrArg (fun x : lowPrimeIdealList T=>x.val) h)) + · intro I + obtain ⟨P,hP,h⟩ := Finset.mem_image.mp I.property + exact ⟨⟨P,hP⟩,Subtype.ext h⟩) + +@[simp] lemma lowPrimeListEquiv_val (T : Finset PrimeIdeal) (p : T) : + (lowPrimeListEquiv T p).val=p.val.val := rfl + +lemma lowPrimeIdealList_prime (T : Finset PrimeIdeal) (I : Id) (hI : I∈lowPrimeIdealList T) : Prime I := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hI + exact P.property + +lemma lowPrimeIdealList_supported (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (I : Id) (hI : I∈lowPrimeIdealList T) : Supported I := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hI + exact hT P hP + +lemma lowPrimeIdealList_maximal (T : Finset PrimeIdeal) (I : Id) (hI : I∈lowPrimeIdealList T) : I.IsMaximal := + (Ideal.isPrime_of_prime (lowPrimeIdealList_prime T I hI)).isMaximal (lowPrimeIdealList_prime T I hI).ne_zero + +lemma lowPrimeIdealList_good_odd (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (I : Id) (hI : I∈lowPrimeIdealList T) : + ConcretePrimeRowBridge.goodLambda∉I ∧ ringChar (O⧸I)≠2 := by + have hs := lowPrimeIdealList_supported T hT I hI + exact hs.2 I ((Ideal.mem_normalizedFactors_iff hs.1).mpr + ⟨Ideal.isPrime_of_prime (lowPrimeIdealList_prime T I hI),le_rfl⟩) + +lemma lowPrimeIdealList_disjoint {ι : Type*} (T : ι→Finset PrimeIdeal) + (hT : Pairwise (fun i j=>Disjoint (T i) (T j))) : + Pairwise (fun i j=>Disjoint (lowPrimeIdealList (T i)) (lowPrimeIdealList (T j))) := by + intro i j hij + apply Finset.disjoint_left.mpr + intro I hI hJ + obtain ⟨P,hP,hPI⟩ := Finset.mem_image.mp hI + obtain ⟨Q,hQ,hQI⟩ := Finset.mem_image.mp hJ + have he : P=Q := Subtype.ext (hPI.trans hQI.symm) + exact Finset.disjoint_left.mp (hT hij) hP (he.symm ▸ hQ) + +lemma lowPrimeIdealList_norm (T : Finset PrimeIdeal) (H : ℝ) + (hT : ∀P∈T,(Ideal.absNorm P.val:ℝ)≤H) (I : Id) (hI : I∈lowPrimeIdealList T) : + (Ideal.absNorm I:ℝ)≤H := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hI + exact hT P hP + +lemma lowPrimeIdealList_coprime (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : Finset PrimeIdeal) + (I : Id) (hI : I∈lowPrimeIdealList (lowPeriodPrimeList η S hS T)) : + IsCoprime I (lowPeriodIdeal η S hS) := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hI + exact lowPeriodPrimeList_coprime η S hS T P hP + +theorem low_actual_ideal_polynomial {ι : Type*} [Fintype ι] + (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hbad : fixedBadPrimes⊆S) (T : ι→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (hout : ∀i P,P∈T i→P.val∉S) + (W : ι→ℝ→ℂ) (Y : ι→ℝ) (t : ℝ) (F : (ι→Id)→ℂ) : + (∑p : ∀i,canonicalSlotSupport (T i), + (∏i,lowSingleSlotWeight η (W i) (Y i) t (p i).val)*F (fun i=>Ideal.span {(p i).val}))= + ∑p : ∀i,lowPrimeIdealList (lowPeriodPrimeList η S hS (T i)), + (∏i,lowSingleSlotWeight η (W i) (Y i) t (primaryGenerator (p i).val))*F (fun i=>(p i).val) := by + let E := Equiv.piCongrRight (fun i=>canonicalSlotEquiv (T i) (hT i)) + rw [←Equiv.sum_comp E] + simp only [E,Equiv.piCongrRight_apply,Pi.map_apply,canonicalSlotEquiv_val] + have hspan (p : ∀i,T i) (i : ι) : Ideal.span {primaryGenerator (p i).val.val}=(p i).val.val := + span_primaryGenerator_of_supported _ (hT i _ (p i).property) + simp_rw [hspan] + rw [low_canonical_polynomial_period_filter η S hS hbad T hT hout W Y t (fun p=>F (fun i=>(p i).val))] + exact Equiv.sum_comp (Equiv.piCongrRight (fun i=>lowPrimeListEquiv (lowPeriodPrimeList η S hS (T i)))) + (fun p=>(∏i,lowSingleSlotWeight η (W i) (Y i) t (primaryGenerator (p i).val))*F (fun i=>(p i).val)) + +lemma low_actual_ideal_weight_bound (η : HeckeFamily.Character) (W : ℝ→ℂ) + (hW : ∀x,‖W x‖≤1) (Y t : ℝ) (I : Id) : + ‖lowSingleSlotWeight η W Y t (primaryGenerator I)‖≤1 := + (lowSingleSlotWeight_norm η W Y t _).trans (hW _) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowActualReflectedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowActualReflectedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..015c046a5d4ccbf088ee627df75a5c80c7f561e6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowActualReflectedEnergy.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Detector.LowActualIdealLists +import OAI.NumberTheory.DirichletL.Detector.LowElementRows + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve CanonicalRowCompletion RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local instance : Fintype Oˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def lowActualIdealPolynomial {ι : Type*} [Fintype ι] + (L : ι→Finset Id) (w : ι→Id→ℂ) (Ψ : O→*ℂ) (W : ℝ→ℂ) (X : ℝ) : ℂ := + ∑p : ∀i,L i,(∏i,w i (p i).val)*InverseMoment.markedCompletedT Ψ W X + (fun A=>∏i,if (p i).val∣A then (1:ℂ) else 0) + +theorem lowSelectedInverseRow_actual_ideal {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→Supported P.val) + (hout : ∀i P,P∈T i→P.val∉S) + (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (Y : Fin K→ℝ) + (X t : ℝ) (σ : RayRing) (z : O) : + lowSelectedInverseRow Finset.univ + (lowSelectedWeight η (fun i=>canonicalSlotSupport (T i)) J W Y t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t σ z= + ∑χ : RayCharacter,ProbeCompleted.correctionCoeff χ* + lowActualIdealPolynomial + (fun i : SelectedSlot J=>lowPrimeIdealList (lowPeriodPrimeList η S hS (T i.val))) + (fun i I=>lowSingleSlotWeight η (W i.val) (Y i.val) t (primaryGenerator I)) + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (lowReflectionMask η S hS) 1 z) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) X := by + rw [lowSelectedInverseRow_correction] + apply Finset.sum_congr rfl + intro χ hχ + congr 1 + simp_rw [lowSelectedWeight_eq_product] + have hm (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + (fun A : Id=>if lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J b∣A then (1:ℂ) else 0)= + (fun A=>∏i : SelectedSlot J,if Ideal.span {(b i).val}∣A then (1:ℂ) else 0) := by + funext A + exact lowSelectedIdeal_mark _ J b (lowCanonicalSelected_coprime T hT hdis J b) A + simp_rw [hm,←physical_markedCompletedT_absorb_true_period η S hS hbad σ χ] + convert low_actual_ideal_polynomial η S hS hbad (fun i : SelectedSlot J=>T i.val) + (fun i=>hT i.val) (fun i=>hout i.val) (fun i=>W i.val) (fun i=>Y i.val) t + (fun p=>InverseMoment.markedCompletedT + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (lowReflectionMask η S hS) 1 z) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) X + (fun A=>∏i : SelectedSlot J,if p i∣A then (1:ℂ) else 0)) using 1 + · congr 1 + ext p + simp + · rfl + +theorem lowSelectedInverseRow_actual_reflected_energy {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→Supported P.val) + (hout : ∀i P,P∈T i→P.val∉S) + (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (Y : Fin K→ℝ) + (X t : ℝ) (σ : RayRing) (R : Finset O) (hR : ∀z∈R,z≠0) : + (∑z∈R,‖lowSelectedInverseRow Finset.univ + (lowSelectedWeight η (fun i=>canonicalSlotSupport (T i)) J W Y t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t σ z‖^2)≤ + lowCorrectionEnergy*∑χ : RayCharacter,∑u : Oˣ,∑I∈lowIdealRows R, + ‖lowActualIdealPolynomial + (fun i : SelectedSlot J=>lowPrimeIdealList (lowPeriodPrimeList η S hS (T i.val))) + (fun i I=>lowSingleSlotWeight η (W i.val) (Y i.val) t (primaryGenerator I)) + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (lowReflectionMask η S hS) + (ConcretePrimeRowBridge.idealGenerator (1:Id)) (u.val*ConcretePrimeRowBridge.idealGenerator I)) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) X‖^2 := by + simp_rw [lowSelectedInverseRow_actual_ideal η S hS hbad T hT hout hdis J W Y X t σ] + apply (fixed_correction_energy R ProbeCompleted.correctionCoeff _).trans + apply mul_le_mul_of_nonneg_left _ lowCorrectionEnergy_nonneg + apply Finset.sum_le_sum + intro χ hχ + exact low_element_rowTwist_energy R hR (physicalRayPeriodicBase η S hS σ χ) + (lowReflectionMask η S hS) (fun Ψ=>lowActualIdealPolynomial + (fun i : SelectedSlot J=>lowPrimeIdealList (lowPeriodPrimeList η S hS (T i.val))) + (fun i I=>lowSingleSlotWeight η (W i.val) (Y i.val) t (primaryGenerator I)) Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) X) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowCauchy.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowCauchy.lean new file mode 100644 index 0000000000000000000000000000000000000000..7fc6db76fa469c0a4dab1d0fed69b1028502c741 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowCauchy.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSeparated +import OAI.NumberTheory.DirichletL.Moments.Cauchy + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open RayFourExpansion +local notation "O" => ActualEisensteinCubic.O + +def lowNumeratorWeight (C : CalibrationData) (Ω : ℝ→ℂ) (X Y : ℝ) (m : O) (v : ℝ) : ℂ := + Ω (elementNorm m/lowPhysicalScale C X Y)*C.residueMonoid m* + ((elementNorm m/lowPhysicalScale C X Y:ℝ):ℂ)^(-((v:ℂ)*Complex.I)) + +lemma lowOuterCutoff_norm (a b x : ℝ) : ‖lowOuterCutoff a b x‖≤1 := by + rw [lowOuterCutoff,norm_mul,Complex.norm_real,Complex.norm_real, + Real.norm_eq_abs,Real.norm_eq_abs, + abs_of_nonneg (Real.smoothTransition.nonneg _),abs_of_nonneg (Real.smoothTransition.nonneg _)] + exact (mul_le_of_le_one_left (Real.smoothTransition.nonneg _) (Real.smoothTransition.le_one _)).trans (Real.smoothTransition.le_one _) + +lemma lowNumeratorWeight_norm (C : CalibrationData) (Ω : ℝ→ℂ) + (hΩ : ∀x,‖Ω x‖≤1) (hΩ0 : Ω 0=0) (X Y : ℝ) (hX : 0by rw [hR m hm v,zero_mul])] + simp_rw [Finset.mul_sum] + rw [Finset.sum_comm] + simp only [mul_assoc] + rw [he,norm_mul] + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + calc + _ ≤ ∑σ : RayRing,‖∑m∈R,lowNumeratorWeight C Ω X Y m v*lowRayAmplitude C W1 Y σ m v*B σ m‖ := norm_sum_le _ _ + _ ≤ _ := Finset.sum_le_sum (fun σ _=>CenteredMomentCauchy.bounded_row_cauchy R + (fun m=>lowNumeratorWeight C Ω X Y m v) (fun m=>lowRayAmplitude C W1 Y σ m v) (B σ) + (fun m _=>lowNumeratorWeight_norm C Ω hΩ hΩ0 X Y hX hY m v)) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowCentralGeometry.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowCentralGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..3e0fc6e9228fdd6a265bbf23c46ceea19659365c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowCentralGeometry.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Detector.LowNominalGeometry + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical + +lemma lowUnselectedProduct_norm_upper_nominal {K : ℕ} (ell : Fin K→ℝ) + (b Z : ℝ) (hZ : 0by unfold elementNorm;positivity) + (fun i _=>(hslots i.val _ (p i).property).trans + (mul_le_mul_of_nonneg_right (le_max_right _ _) (by positivity))) + _=(max 1 b)^J.card*Z^(lowUnselectedLength ell J) := by + rw [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_coe, + ←Real.rpow_sum_of_pos hZ,Finset.sum_coe_sort] + rfl + _≤_ := mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (le_max_left _ _) hc) (by positivity) + +theorem eventually_low_selected_caps {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) + (b ε : ℝ) (hε : 0<ε) : + ∀ᶠZ : ℝ in Filter.atTop,1 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma low_compensated_sqrt_factor (q L : ℝ) (hq : 0≤q) (hL : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→a*Z^(ell i)≤(Ideal.absNorm P.val:ℝ) ∧ (Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(X : ℝ),0Z^(ell i)) (fun i=>(p i).val) J* + compensationRowTest η (calibrationForSet S hS) W0 W1 (fun i=>(p i).val) J + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) X t* + selectedSlotFactor W (fun i=>Z^(ell i)) (fun i=>(p i).val) J t‖≤ + C*(1+‖t‖)^degree*Z^(3/16+254*ε) := by + obtain ⟨Cg,hCg,hgram⟩ := compensation_tuple_actual_gram ε hε hε1 W0 W1 + a0 b0 a1 b1 M ha0 ha1 hab1 hM hW0 hW1 hW0s hW1s hWM S hS hbad + obtain ⟨degree,Ci,hCi,hinverse⟩ := low_physical_inverse_normalized η S hS hbad ell hell hsum + a b (a0*a1) (max 1 (b0*b1)) ε ha (mul_pos ha0 ha1) + (lt_of_lt_of_le zero_lt_one (le_max_left _ _)) hε hε1.le + obtain ⟨Cu,hCu,hmass⟩ := lowUnselectedMass_bound K 1 (by norm_num) + let q := elementNorm (calibrationForSet S hS).generator + have hq : 0canonicalSlotSupport (T i) + let Yp := fun i=>Z^(ell i) + have hz : 0canonicalSlotSupport_nonzero _ (hT i) + have hnormE : ∀i n,n∈slots i→elementNorm n≤max 1 b*Z^(ell i) := by + intro i n hn + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hn + rw [primaryTuple_norm P (hT i P hP)] + exact (hnorm i P hP).2.trans (mul_le_mul_of_nonneg_right (le_max_right _ _) (by positivity)) + have hs := hScale.2 slots hslots hnormE J + have hg := hgram K η slots hslots J W Yp (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) X t + (by positivity) (by positivity) hX (fun p=>(hs p).1) (fun p=>(hs p).2.1) + apply hg.trans + let G := Z^(3/16+(23/96)*ε:ℝ) + let V := Ci*(1+‖t‖)^degree*Z^(507*ε/2) + have hGV : G*V≤Ci*(1+‖t‖)^degree*Z^(3/16+254*ε) := by + dsimp only [G,V] + calc + _=Ci*(1+‖t‖)^degree*(Z^(3/16+(23/96)*ε:ℝ)*Z^(507*ε/2)) := by ring + _≤_ := by + rw [←Real.rpow_add hz] + apply mul_le_mul_of_nonneg_left _ (by positivity) + exact Real.rpow_le_rpow_of_exponent_le hInv.1.le (by linarith) + have hterm (p : LowUnselectedTuple slots J) : + let L := elementNorm (∏i : J,(p i).val) + let Q := lowPhysicalScale (calibrationForSet S hS) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) + ‖lowUnselectedWeight slots J W Yp p‖*((Real.sqrt Q)⁻¹/(2*Real.pi))* + lowGramFactor (calibrationForSet S hS) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) ε* + lowInverseMass (calibrationForSet S hS) (a0*a1) (max 1 (b0*b1)) (mul_pos ha0 ha1) + (lt_of_lt_of_le zero_lt_one (le_max_left _ _)) + (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) + (div_pos (by positivity) (lowUnselectedProduct_norm_pos slots hslots J p)) + (div_pos (by positivity) (lowUnselectedProduct_norm_pos slots hslots J p)) + (lowSelectedInverseRow Finset.univ (lowSelectedWeight η slots J W Yp t) + η S hS (lowSelectedIdeal slots J) X t)≤ + (Ci*Real.sqrt (3*q)*(1+‖t‖)^degree*Z^(3/16+254*ε))* + (‖lowUnselectedWeight slots J W Yp p‖*L^(-(1/2:ℝ))) := by + dsimp only + let L := elementNorm (∏i : J,(p i).val) + let Q := lowPhysicalScale (calibrationForSet S hS) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) + have hL := lowUnselectedProduct_norm_pos slots hslots J p + have hgb := (hs p).2.2 ε hε.le + have hib := hInv.2 T hT hout hdis hnorm J p X hX hXlo hXhi W hW t + (div_pos (by positivity) hL) (div_pos (by positivity) hL) + have hgn : 0≤lowGramFactor (calibrationForSet S hS) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) ε := Real.sqrt_nonneg _ + have hh := mul_le_mul_of_nonneg_left hib + (mul_nonneg (norm_nonneg (lowUnselectedWeight slots J W Yp p)) hgn) + have hh2 := mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left hgb (norm_nonneg (lowUnselectedWeight slots J W Yp p))) + (show 0≤V by dsimp [V];positivity) + calc + _=‖lowUnselectedWeight slots J W Yp p‖* + lowGramFactor (calibrationForSet S hS) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) ε* + (Real.sqrt Q)⁻¹/(2*Real.pi)* + lowInverseMass (calibrationForSet S hS) (a0*a1) (max 1 (b0*b1)) (mul_pos ha0 ha1) + (lt_of_lt_of_le zero_lt_one (le_max_left _ _)) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) + (div_pos (by positivity) hL) (div_pos (by positivity) hL) + (lowSelectedInverseRow Finset.univ (lowSelectedWeight η slots J W Yp t) η S hS (lowSelectedIdeal slots J) X t) := by ring + _≤(‖lowUnselectedWeight slots J W Yp p‖*Real.sqrt (3*q/L))*(G*V) := by + have hh3 := hh.trans hh2 + simp only [G,V,div_eq_mul_inv,mul_assoc] at hh3 ⊢ + convert hh3 using 1 ; congr 7 + _≤(‖lowUnselectedWeight slots J W Yp p‖*Real.sqrt (3*q/L))* + (Ci*(1+‖t‖)^degree*Z^(3/16+254*ε)) := + mul_le_mul_of_nonneg_left hGV (by positivity) + _=_ := by rw [low_compensated_sqrt_factor q L hq.le hL];ring + have hh := mul_le_mul_of_nonneg_left (Finset.sum_le_sum (s:=Finset.univ) (fun p _=>hterm p)) hCg.le + apply hh.trans + rw [←Finset.mul_sum] + have hm := hmass T hT J W Yp hW + calc + _≤Cg*((Ci*Real.sqrt (3*q)*(1+‖t‖)^degree*Z^(3/16+254*ε))*Cu) := by gcongr + _=_ := by dsimp [C0];ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowColumnBounds.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowColumnBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..5e824f7207d6def5d26290c91e5b077c2f49bfad --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowColumnBounds.lean @@ -0,0 +1,112 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGaussEnergy + +namespace OAI + +noncomputable section +open scoped Classical +open CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowGaussColumns (W1 : ℝ→ℂ) (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0s.val) Subtype.val_injective.injOn).toFinset + +lemma lowGaussColumns_mem (W1 : ℝ→ℂ) (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0primaryGenerator s.val) + (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) (-m) := by + unfold lowRayAmplitude + rw [tsum_eq_sum (s:=lowGaussColumns W1 hW1 Y hY) (fun s hs=>by + have hz : W1 ((Ideal.absNorm s.val:ℝ)/Y)=0 := by + simpa only [lowGaussColumns_mem,not_not] using hs + simp only [lowAdditiveCoefficient_outer_zero C W1 Y s m v hz,ite_self])] + unfold CenteredMomentGaussEnergy.gaussPolynomial + exact Finset.sum_congr rfl (fun s _=>lowGaussColumn_row C W1 Y σ v s m) + +lemma lowGaussColumns_card (W1 : ℝ→ℂ) (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 1≤Y) + (a b : ℝ) (hW : Function.support W1⊆Set.Icc a b) : + ((lowGaussColumns W1 hW1 Y (lt_of_lt_of_le zero_lt_one hY)).card:ℝ)≤128*max 1 b*Y := by + let F := lowGaussColumns W1 hW1 Y (lt_of_lt_of_le zero_lt_one hY) + have hH : 1≤max 1 b*Y := one_le_mul_of_one_le_of_one_le (le_max_left _ _) hY + have hh := DescentFiberCost.finite_ideal_count_real (F.image Subtype.val) (max 1 b*Y) hH + (by intro I hI;obtain ⟨s,hs,rfl⟩ := Finset.mem_image.mp hI;exact s.property.1) + (by + intro I hI + obtain ⟨s,hs,rfl⟩ := Finset.mem_image.mp hI + have hw := (hW ((lowGaussColumns_mem W1 hW1 Y _ s).mp hs)).2 + have hn : (Ideal.absNorm s.val:ℝ)≤b*Y := (div_le_iff₀ (lt_of_lt_of_le zero_lt_one hY)).mp hw + exact hn.trans (mul_le_mul_of_nonneg_right (le_max_right _ _) (le_trans zero_le_one hY))) + rw [Finset.card_image_of_injective _ Subtype.val_injective] at hh + simpa only [mul_assoc,F] using hh + +lemma lowGaussColumn_norm_bound (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (W1 : ℝ→ℂ) (a b B : ℝ) (ha : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma low_window_log_support (W : ℝ→ℂ) (a b : ℝ) (ha : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→a*Z^(ell i)≤(Ideal.absNorm P.val:ℝ) ∧ (Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ‖compensatedPhysicalProbe η (calibrationForSet S hS) W0 W1 + (fun i=>canonicalSlotSupport (T i)) W (fun i=>Z^(ell i)) + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z‖≤C*Z^(3/16+256*ε) := by + obtain ⟨V,hV,hbudget,hidentity⟩ := compensatedPhysicalProbe_common_gaussian W + (fun _=>|Real.log a|+|Real.log b|) (fun _=>by positivity) + (fun i=>low_window_log_support (W i) a b ha (hW i)) + choose C hC he using fun A : Finset (Fin K)=>low_all_gaussian_dyads η S hS hbad ell hell hsum + a b ε ha hε hε1 (V A) (hV A) W0 W1 a0 b0 a1 b1 B0 B1 ha0 ha1 hab1 hB0 hB1 + hW0 hW1 hW0s hW1s hWB0 hWB1 + let C0 := (∑A∈(Finset.univ : Finset (Fin K)).powerset,C A)+1 + have hC0 : 0(hC A).le) + dsimp only [C0] + linarith + refine ⟨C0,hC0,?_⟩ + filter_upwards [Filter.eventually_all.mpr he] with Z hZ + have hz1 : 1canonicalSlotSupport_nonzero _ (hT i) + rw [hidentity η (calibrationForSet S hS) W0 W1 + (HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW0) + (HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW1) + _ hslots (fun i=>Z^(ell i)) (fun i=>by positivity) + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z (by positivity) (by positivity) hz] + apply (norm_sum_le _ _).trans + have hterm (A : Finset (Fin K)) : + ‖∑'j : ℕ,lowCommonDyad η (calibrationForSet S hS) W0 W1 (fun i=>canonicalSlotSupport (T i)) W + (fun i=>Z^(ell i)) A (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) ((2:ℝ)^j) + (Z*∏i∈Finset.univ\A,Z^(ell i)) (V A) (hV A)‖≤C A*Z^(3/16+256*ε) := by + have hc : Z*(∏i∈Finset.univ\A,Z^(ell i))=Z^(1+lowSelectedLength ell A) := by + rw [lowSelectedScale_product ell A Z hz,Real.rpow_add hz,Real.rpow_one] + rw [hc] + exact ((hZ A).2 T hT hout hdis hnorm A W hWnorm).2 + have hh := Finset.sum_le_sum (fun A (_ : A∈(Finset.univ : Finset (Fin K)).powerset)=>hterm A) + apply hh.trans + rw [←Finset.sum_mul] + exact mul_le_mul_of_nonneg_right (by dsimp [C0];linarith) (Real.rpow_nonneg hz.le _) + +theorem original_ray_compensatedPhysicalProbe_low (η : HeckeFamily.Character) + (S : Finset Id) (hS : SourceExclusions S) (hmax : ∀P∈S,P.IsMaximal) + {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hinj : Function.Injective ell) + (hsum : ∑i,ell i≤1/6) (R : Set Id) + (a b ε : ℝ) (ha : 0canonicalSlotSupport (ProbeRaySlots.pool R S a b (Z^(ell i)))) W (fun i=>Z^(ell i)) + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z‖≤C*Z^(3/16+256*ε) := by + obtain ⟨C,hC,he⟩ := compensatedPhysicalProbe_low η S hmax hS.bad ell hell hsum + a b ε ha hε hε1 W hW hWnorm W0 W1 a0 b0 a1 b1 B0 B1 ha0 ha1 hab1 hB0 hB1 + hW0 hW1 hW0s hW1s hWB0 hWB1 + refine ⟨C,hC,?_⟩ + filter_upwards [he,ProbeRaySlots.power_pools_eventually_disjoint R S (fun _=>a) (fun _=>b) ell + (fun _=>ha) (fun _=>hab) hinj] with Z hZ hd + have hz : 0ProbeRaySlots.pool_supported R S hS a b (Z^(ell i))) + (fun i P hP=>((ProbeRaySlots.mem_pool R S a b (Z^(ell i)) P).mp hP).2.2.2) + (fun i j hij=>hd i j hij) + intro i P hP + have hh := ProbeRaySlots.pool_norm_bounds R S ha.le hab (Real.rpow_pos_of_pos hz _) P hP + simpa only [mul_comm] using And.intro hh.1.le hh.2 + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowCompensation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowCompensation.lean new file mode 100644 index 0000000000000000000000000000000000000000..d99716fc995533acc9a563582f1d313e8587890d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowCompensation.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSeparated +import OAI.NumberTheory.DirichletL.Detector.GaussianSubset + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open ProbeCompleted CanonicalRowCompletion RayFourExpansion ProbeRow CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowMarkedInverseRow (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (D : Id) (T t : ℝ) (σ : RayRing) (m : O) : ℂ := + ∑χ : RayCharacter,correctionCoeff χ* + InverseMoment.markedCompletedT + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (calibrationForSet S hS).generator 1 m) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T + (fun A=>if D∣A then (1:ℂ) else 0) + +lemma lowMarkedInverseRow_eq (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) (D : Id) (T t : ℝ) (hT : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma summand_zero_completedIndex (Ψ : O→*ℂ) (W : ℝ→ℂ) (X : ℝ) (I J : Id) + (h : completedIndex I J=0) : summand Ψ W X I J=0 := by + have hprod : primaryGenerator I*primaryGenerator J^3=0 := h + rcases mul_eq_zero.mp hprod with hI|hJ + · simp only [summand,columnWeight,squarefreeGaussCoefficient,hI,ne_eq,not_true_eq_false, + and_false,dite_false,zero_mul,zero_div] + · have hj : primaryGenerator J=0 := (pow_eq_zero_iff (by decide : 3≠0)).mp hJ + have hc : cubeWeight Ψ J=0 := by + change star (FiniteGaussPhase.angularFactor (primaryGenerator J))^3* + Ψ (primaryGenerator J)^3/(Ideal.absNorm J:ℂ)=0 + simp only [hj,FiniteGaussPhase.angularFactor,map_zero,norm_zero,Complex.ofReal_zero, + div_zero,star_zero,zero_pow (by decide : (3:ℕ)≠0),zero_mul,zero_div] + simp only [summand,hc,mul_zero,zero_mul] + +lemma markedSummand_eq_punctured (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (D : Id) (Ψ : O→*ℂ) (W : ℝ→ℂ) (X : ℝ) (I J : Id) : + markedSummand S D Ψ W X I J= + summand (coprimalityMask (calibrationForSet S hS).generator*Ψ) W X I J* + (if D∣I*J^3 then (1:ℂ) else 0) := by + rw [summand_mul_fixed_twist] + change completedMask S D I J*summand Ψ W X I J= + coprimalityMask (calibrationForSet S hS).generator (completedIndex I J)*summand Ψ W X I J* + (if D∣I*J^3 then (1:ℂ) else 0) + by_cases hA : completedIndex I J=0 + · rw [summand_zero_completedIndex Ψ W X I J hA] + simp only [mul_zero,zero_mul] + · have he := calibration_coprime_iff_excluded_span S hS (completedIndex I J) + rw [completedIndex_eq_primaryGenerator] at he hA + rw [(primaryGenerator_spec (I*J^3) hA).1] at he + change _=(if IsCoprime (calibrationForSet S hS).generator (completedIndex I J) then (1:ℂ) else 0)*_ * _ + rw [completedIndex_eq_primaryGenerator,he] + unfold completedMask + by_cases hd : D∣I*J^3 <;> by_cases hx : ∀P∈S,¬P∣I*J^3 <;> + simp only [hd,hx,and_self,and_false,true_and,false_and,ite_true,ite_false,mul_one,mul_zero,zero_mul] ; simp_all + +lemma markedCompletedT_eq_punctured (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (D : Id) (Ψ : O→*ℂ) (W : ℝ→ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0if D∣A then (1:ℂ) else 0) := by + rw [InverseMoment.markedCompletedT_eq_tsum _ W hW X hX] + unfold ProbeCompleted.markedCompletedT + apply tsum_congr + intro p + exact markedSummand_eq_punctured S hS D Ψ W X p.1 p.2 + +lemma inverseMarkedCompletedT_congr_primary (Ψ Φ : O→*ℂ) + (h : ∀n : O,ConcretePrimeRowBridge.goodLambda^2∣n-1→Ψ n=Φ n) + (W : ℝ→ℂ) (X : ℝ) (d : Id→ℂ) : + InverseMoment.markedCompletedT Ψ W X d=InverseMoment.markedCompletedT Φ W X d := by + unfold InverseMoment.markedCompletedT + apply tsum_congr + intro I + apply tsum_congr + intro J + rw [summand,summand,columnWeight_congr_primary Ψ Φ h,cubeWeight_congr_primary Ψ Φ h] + +def calibrationLowData (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) : + GoodMaskRowData (calibrationForSet S hS).generator 1 (calibrationForSet S hS).generator := + goodMaskRowData _ 1 _ (calibrationForSet S hS).generator_ne_zero one_ne_zero + (calibrationForSet S hS).generator_ne_zero + +theorem correctedPhysicalRow_eq_periodic_inverse (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (s : O) (hs : Supported (Ideal.span {s})) (z : O) (D : Id) + (W : ℝ→ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0if D∣A then (1:ℂ) else 0) := by + rw [correctedCompletedT_ray_expansion S D _ W hW X hX] + apply Finset.sum_congr rfl + intro χ _ + rw [markedCompletedT_eq_punctured S hS D _ W hW X hX] + congr 1 + apply inverseMarkedCompletedT_congr_primary + intro n hn + exact (lowPeriodicRow_eq_primary η (calibrationForSet S hS) (calibrationForSet S hS).generator E + (calibration_generator_bad S hS hbad).1 (calibration_generator_bad S hS hbad).2 s hs χ z n hn).symm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowCutoff.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowCutoff.lean new file mode 100644 index 0000000000000000000000000000000000000000..b62093834abb674ab633779b5100e1c2ba2f2805 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowCutoff.lean @@ -0,0 +1,99 @@ +import OAI.NumberTheory.DirichletL.Detector.LowRay +import OAI.NumberTheory.DirichletL.Detector.GaussianPartition + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +namespace SevenEighths.ProbePhysical +local notation "O" => ActualEisensteinCubic.O + +def lowOuterCutoff (a b x : ℝ) : ℂ := + (Real.smoothTransition (2*x/a-1):ℂ)*(Real.smoothTransition (2-x/b):ℂ) + +lemma lowOuterCutoff_small (a b : ℝ) (ha : 0hz (physicalRowWeight_inner_zero C W0 W1 X Y r h) + have h1 : W1 ((Ideal.absNorm r.1.val:ℝ)/Y)≠0 := + fun h=>hz (physicalRowWeight_outer_zero C W0 W1 X Y r h) + have hq : (0:ℝ) ActualEisensteinCubic.O +local notation "Id" => Ideal O +local instance : Fintype Oˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def lowElementRowPoint (m : O) : Oˣ×Id := + (InitialMeanSquare.sourceLabelUnit m,Ideal.span {m}) + +def lowIdealRowElement (p : Oˣ×Id) : O := p.1.val*idealGenerator p.2 + +lemma lowIdealRowElement_point (m : O) : lowIdealRowElement (lowElementRowPoint m)=m := + (InitialMeanSquare.sourceLabelUnit_spec m).symm + +lemma lowElementRowPoint_injective : Function.Injective lowElementRowPoint := + Function.LeftInverse.injective lowIdealRowElement_point + +lemma lowIdealRowElement_span (p : Oˣ×Id) : Ideal.span {lowIdealRowElement p}=p.2 := by + rw [lowIdealRowElement,Ideal.span_singleton_mul_left_unit p.1.isUnit,span_idealGenerator] + +lemma lowElementRowPoint_element (p : Oˣ×Id) (hp : p.2≠0) : + lowElementRowPoint (lowIdealRowElement p)=p := by + apply Prod.ext + · apply Units.ext + have hh := InitialMeanSquare.sourceLabelUnit_spec (lowIdealRowElement p) + rw [lowIdealRowElement_span] at hh + exact (mul_right_cancel₀ (idealGenerator_ne_zero p.2 hp) hh).symm + · exact lowIdealRowElement_span p + +lemma lowIdealRowElement_norm (p : Oˣ×Id) : + elementNorm (lowIdealRowElement p)=(Ideal.absNorm p.2:ℝ) := by + unfold elementNorm + rw [lowIdealRowElement_span] + +def lowIdealRows (R : Finset O) : Finset Id := R.image (fun m=>Ideal.span {m}) + +lemma lowIdealRows_nonzero (R : Finset O) (hR : ∀m∈R,m≠0) (I : Id) (hI : I∈lowIdealRows R) : I≠0 := by + obtain ⟨m,hm,rfl⟩ := Finset.mem_image.mp hI + exact Ideal.span_singleton_eq_bot.not.mpr (hR m hm) + +lemma lowIdealRows_norm_bound (R : Finset O) (Q : ℝ) (hR : ∀m∈R,elementNorm m≤Q) + (I : Id) (hI : I∈lowIdealRows R) : (Ideal.absNorm I:ℝ)≤Q := by + obtain ⟨m,hm,rfl⟩ := Finset.mem_image.mp hI + exact hR m hm + +theorem sum_low_element_rows (R : Finset O) (hR : ∀m∈R,m≠0) (F : O→ℂ) : + (∑m∈R,F m)=∑u : Oˣ,∑I∈lowIdealRows R, + if u.val*idealGenerator I∈R then F (u.val*idealGenerator I) else 0 := by + let P := (Finset.univ×ˢlowIdealRows R).filter (fun p : Oˣ×Id=>lowIdealRowElement p∈R) + have he : (∑m∈R,F m)=∑p∈P,F (lowIdealRowElement p) := by + apply Finset.sum_bij (fun m hm=>lowElementRowPoint m) + · intro m hm + apply Finset.mem_filter.mpr + refine ⟨Finset.mem_product.mpr ⟨Finset.mem_univ _,?_⟩,?_⟩ + · exact Finset.mem_image.mpr ⟨m,hm,rfl⟩ + · rwa [lowIdealRowElement_point] + · intro m hm n hn he + exact lowElementRowPoint_injective he + · intro p hp + obtain ⟨hp,hpr⟩ := Finset.mem_filter.mp hp + refine ⟨lowIdealRowElement p,hpr,?_⟩ + exact lowElementRowPoint_element p (lowIdealRows_nonzero R hR _ (Finset.mem_product.mp hp).2) + · intro m hm + rw [lowIdealRowElement_point] + rw [he] + dsimp only [P] + rw [Finset.sum_filter,Finset.sum_product] + rfl + +theorem low_element_energy_le_units (R : Finset O) (_hR : ∀m∈R,m≠0) (F : O→ℂ) : + (∑m∈R,‖F m‖^2)≤∑u : Oˣ,∑I∈lowIdealRows R,‖F (u.val*idealGenerator I)‖^2 := by + let P : Finset (Oˣ×Id) := Finset.univ×ˢlowIdealRows R + have hsub : R.image lowElementRowPoint⊆P := by + intro p hp + obtain ⟨m,hm,rfl⟩ := Finset.mem_image.mp hp + exact Finset.mem_product.mpr ⟨Finset.mem_univ _,Finset.mem_image.mpr ⟨m,hm,rfl⟩⟩ + have he : (∑m∈R,‖F m‖^2)=∑p∈R.image lowElementRowPoint,‖F (lowIdealRowElement p)‖^2 := by + rw [Finset.sum_image (fun m _ n _ h=>lowElementRowPoint_injective h)] + simp only [lowIdealRowElement_point] + rw [he] + have hh := Finset.sum_le_sum_of_subset_of_nonneg hsub + (fun p _ _=>sq_nonneg ‖F (lowIdealRowElement p)‖) + simpa only [P,Finset.sum_product,lowIdealRowElement] using hh + +lemma low_rowTwist_label_one (Ψ : O→*ℂ) (m : O) (u : Oˣ) (I : Id) : + CanonicalRowCompletion.rowTwist Ψ m 1 (u.val*idealGenerator I)= + CanonicalRowCompletion.rowTwist Ψ m (idealGenerator (1:Id)) + (((InitialMeanSquare.sourceLabelUnit 1)^4*u).val*idealGenerator I) := by + have he : (InitialMeanSquare.sourceLabelUnit (1:O)).val*idealGenerator (1:Id)=1 := by + simpa only [Ideal.span_singleton_one,Ideal.one_eq_top] using (InitialMeanSquare.sourceLabelUnit_spec (1:O)).symm + have harg : m^6*(idealGenerator (1:Id))^4* + (((InitialMeanSquare.sourceLabelUnit 1)^4*u).val*idealGenerator I)=m^6*1^4*(u.val*idealGenerator I) := by + simp only [Units.val_mul,Units.val_pow_eq_pow_val,one_pow] + calc + _=m^6*((InitialMeanSquare.sourceLabelUnit (1:O)).val*idealGenerator (1:Id))^4*(u.val*idealGenerator I) := by ring + _=_ := by rw [he];ring + unfold CanonicalRowCompletion.rowTwist + rw [harg] + +lemma low_units_label_one_sum (F : (O→*ℂ)→ℝ) (Ψ : O→*ℂ) (m : O) (I : Id) : + (∑u : Oˣ,F (CanonicalRowCompletion.rowTwist Ψ m 1 (u.val*idealGenerator I)))= + ∑u : Oˣ,F (CanonicalRowCompletion.rowTwist Ψ m (idealGenerator (1:Id)) (u.val*idealGenerator I)) := by + simp_rw [low_rowTwist_label_one] + exact Equiv.sum_comp (Equiv.mulLeft ((InitialMeanSquare.sourceLabelUnit (1:O))^4)) + (fun u : Oˣ=>F (CanonicalRowCompletion.rowTwist Ψ m (idealGenerator (1:Id)) (u.val*idealGenerator I))) + +lemma low_element_rowTwist_energy (R : Finset O) (hR : ∀z∈R,z≠0) + (Ψ : O→*ℂ) (m : O) (F : (O→*ℂ)→ℂ) : + (∑z∈R,‖F (CanonicalRowCompletion.rowTwist Ψ m 1 z)‖^2)≤ + ∑u : Oˣ,∑I∈lowIdealRows R, + ‖F (CanonicalRowCompletion.rowTwist Ψ m (idealGenerator (1:Id)) (u.val*idealGenerator I))‖^2 := by + apply (low_element_energy_le_units R hR (fun z=>F (CanonicalRowCompletion.rowTwist Ψ m 1 z))).trans_eq + rw [Finset.sum_comm,Finset.sum_comm (f:=fun (u : Oˣ) (I : Id)=> + ‖F (CanonicalRowCompletion.rowTwist Ψ m (idealGenerator (1:Id)) (u.val*idealGenerator I))‖^2)] + apply Finset.sum_congr rfl + intro I hI + exact low_units_label_one_sum (fun Ψ=>‖F Ψ‖^2) Ψ m I + +lemma lowNumeratorRows_nonzero (a b : ℝ) (ha : 0if D k∣A then (1:ℂ) else 0)‖^2 := by + apply (lowSelectedInverseRow_energy F c η S hS D X t σ R).trans + apply mul_le_mul_of_nonneg_left _ lowCorrectionEnergy_nonneg + apply Finset.sum_le_sum + intro χ hχ + exact low_element_rowTwist_energy R hR (physicalRayPeriodicBase η S hS σ χ) + (calibrationForSet S hS).generator (fun Ψ=>∑k∈F,c k*InverseMoment.markedCompletedT Ψ + (CompletedHeight.normTwistedSource gaussianFixedWindow t) X (fun A=>if D k∣A then (1:ℂ) else 0)) + +lemma low_unit_card : Fintype.card Oˣ=6 := by + simpa only [Nat.card_eq_fintype_card] using PrimaryIdealUnitReindex.card_units_eq_six + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..e8fae11a093d820879a75d9c1ea38fc6e42e2561 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussEnergy.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Detector.LowRayAmplitude +import OAI.NumberTheory.DirichletL.Moments.ReflectedChild + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion CenteredMomentGaussEnergy +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowGaussColumn (C : CalibrationData) (W1 : ℝ→ℂ) (Y : ℝ) + (σ : RayRing) (v : ℝ) (s : {I : Id // Supported I}) : ℂ := + if physicalIdealRay s=σ then + (Y:ℂ)⁻¹*W1 ((Ideal.absNorm s.val:ℝ)/Y)*lowArithmeticCoefficient C s* + (((Ideal.absNorm s.val:ℝ)/Y:ℝ):ℂ)^(-(1/2:ℂ)+(v:ℂ)*Complex.I) + else 0 + +lemma lowGaussColumn_row (C : CalibrationData) (W1 : ℝ→ℂ) (Y : ℝ) + (σ : RayRing) (v : ℝ) (s : {I : Id // Supported I}) (m : O) : + (if physicalIdealRay s=σ then lowAdditiveCoefficient C W1 Y s m v else 0)= + lowGaussColumn C W1 Y σ v s* + gaussRow (primaryGenerator s.val) ((supported_span_primaryGenerator_iff s.val).mpr s.property) (-m) := by + have he := (primaryGenerator_spec s.val (supported_primaryGenerator_ne_zero s.val s.property)).1 + unfold lowGaussColumn gaussRow + rw [congrArg Ideal.absNorm he] + split_ifs + · rw [lowAdditiveCoefficient_eq] + simp only [div_eq_mul_inv] + ring + · simp + +theorem lowRayAmplitude_gaussPolynomial (C : CalibrationData) (W1 : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0primaryGenerator s.val) + (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) (-m) := by + obtain ⟨F,hF⟩ := lowRayAmplitude_eq_finite C W1 hW1 Y hY + refine ⟨F,?_⟩ + intro σ v m + rw [hF σ m v] + unfold gaussPolynomial + apply Finset.sum_congr rfl + intro s hs + exact lowGaussColumn_row C W1 Y σ v s m + +theorem lowRayAmplitude_energy (C : CalibrationData) (W1 : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0primaryGenerator s.val) + (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) U Q).re := by + obtain ⟨F,hF⟩ := lowRayAmplitude_gaussPolynomial C W1 hW1 Y hY + refine ⟨F,?_⟩ + intro σ v U Q hQ rows hU hmajor + simp_rw [hF σ v] + exact CenteredMomentReflectedChild.finite_reflected_energy_le_gaussEnergy F + (fun s=>primaryGenerator s.val) (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) U Q hQ rows hU hmajor + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianCentral.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianCentral.lean new file mode 100644 index 0000000000000000000000000000000000000000..46d68f3c6e684984312b3b5603643c826cec5be4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianCentral.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGaussianRemote + +namespace OAI + +noncomputable section +open scoped Classical ContDiff SchwartzMap +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma not_lowRemote_bounds (Z ell ε U : ℝ) (hZ : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→a*Z^(ell i)≤(Ideal.absNorm P.val:ℝ) ∧ (Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(W : Fin K→ℝ→ℂ),(∀i x,‖W i x‖≤1)→ + let f := fun j : ℕ=>if lowRemote Z (lowSelectedLength ell J) ε ((2:ℝ)^j) then 0 else + ‖lowCommonDyad η (calibrationForSet S hS) W0 W1 (fun i=>canonicalSlotSupport (T i)) + W (fun i=>Z^(ell i)) J (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) ((2:ℝ)^j) + (Z^(1+lowSelectedLength ell J)) V hV‖ + Summable f ∧ (∑'j : ℕ,f j)≤C*Z^(3/16+256*ε) := by + obtain ⟨degree,C,hC,he⟩ := low_central_gaussian_dyad η S hS hbad ell hell hsum + a b ε ha hε hε1 W0 W1 a0 b0 a1 b1 M ha0 ha1 hab1 hM hW0 hW1 hW0s hW1s hWM + obtain ⟨Cm,hCm,hm⟩ := gaussianJointMoment_summed V hV degree ε hε + refine ⟨C*Cm,mul_pos hC hCm,?_⟩ + filter_upwards [he] with Z hZ + refine ⟨hZ.1,?_⟩ + intro T hT hout hdis hnorm J W hW + let R := Z^(1+lowSelectedLength ell J) + let f := fun j : ℕ=>if lowRemote Z (lowSelectedLength ell J) ε ((2:ℝ)^j) then 0 else + ‖lowCommonDyad η (calibrationForSet S hS) W0 W1 (fun i=>canonicalSlotSupport (T i)) + W (fun i=>Z^(ell i)) J (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) ((2:ℝ)^j) R V hV‖ + have hz : 0positivity + have hsumf := Summable.of_nonneg_of_le hn hb (hsm.mul_left (C*Z^(3/16+254*ε))) + refine ⟨hsumf,?_⟩ + calc + _≤∑'j : ℕ,(C*Z^(3/16+254*ε))*(((2:ℝ)^j)^ε*gaussianJointMoment V hV degree ((2:ℝ)^j/R)) := + hsumf.tsum_le_tsum hb (hsm.mul_left _) + _=(C*Z^(3/16+254*ε))*(∑'j : ℕ,((2:ℝ)^j)^ε*gaussianJointMoment V hV degree ((2:ℝ)^j/R)) := tsum_mul_left + _≤(C*Z^(3/16+254*ε))*(Cm*R^ε) := mul_le_mul_of_nonneg_left hmb (by positivity) + _≤_ := by + dsimp only [R] + rw [←Real.rpow_mul hz.le] + calc + _=(C*Cm)*(Z^(3/16+254*ε)*Z^((1+lowSelectedLength ell J)*ε)) := by ring + _≤_ := by + rw [←Real.rpow_add hz] + apply mul_le_mul_of_nonneg_left _ (mul_pos hC hCm).le + have hh := lowLength_bounds ell hell hsum J + exact Real.rpow_le_rpow_of_exponent_le hZ.1.le (by nlinarith) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianDyad.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianDyad.lean new file mode 100644 index 0000000000000000000000000000000000000000..d890d50dcfdb510ef4dda3bcbccf946173e4537e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianDyad.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Detector.LowCentralTuple +import OAI.NumberTheory.DirichletL.Detector.LowRemoteMass +import OAI.NumberTheory.DirichletL.Detector.GaussianCommon + +namespace OAI + +noncomputable section +open scoped Classical ContDiff SchwartzMap +open MeasureTheory +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowCommonDyad {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W0 W1 : ℝ→ℂ) (slots : Fin K→Finset O) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (J : Finset (Fin K)) (X Y U R : ℝ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) : ℂ := + ∫t : ℝ,(∑p : ∀i,slots i,compensationSubsetWeight η W Yp (fun i=>(p i).val) J* + compensationRowTest η C W0 W1 (fun i=>(p i).val) J X Y U t* + selectedSlotFactor W Yp (fun i=>(p i).val) J t)*gaussianJointDensity V hV (U/R) t + +lemma lowCommonDyad_eq_family {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W0 W1 : ℝ→ℂ) (slots : Fin K→Finset O) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (J : Finset (Fin K)) (X Y U R : ℝ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) : + lowCommonDyad η C W0 W1 slots W Yp J X Y U R V hV= + gaussianPhysicalFamilyIntegral η C W0 W1 (Finset.univ : Finset (∀i,slots i)) + (fun p=>compensationSubsetWeight η W Yp (fun i=>(p i).val) J) + (fun p=>Ideal.span {slotProduct (fun i=>(p i).val) (Finset.univ\J)}) + (fun p=>X/elementNorm (slotProduct (fun i=>(p i).val) J)) + (fun p=>Y/elementNorm (slotProduct (fun i=>(p i).val) J)) + (fun i : SelectedSlot J=>W i.val) + (fun p i=>elementNorm (p i.val).val/Yp i.val) V hV U R := rfl + +lemma lowCommonDyad_norm_of_bound {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W0 W1 : ℝ→ℂ) (slots : Fin K→Finset O) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (J : Finset (Fin K)) (X Y U R B : ℝ) (degree : ℕ) (V : SchwartzMap ℝ ℂ) + (hV : HasCompactSupport (V:ℝ→ℂ)) + (hb : ∀t : ℝ,‖∑p : ∀i,slots i,compensationSubsetWeight η W Yp (fun i=>(p i).val) J* + compensationRowTest η C W0 W1 (fun i=>(p i).val) J X Y U t* + selectedSlotFactor W Yp (fun i=>(p i).val) J t‖≤B*(1+‖t‖)^degree) : + ‖lowCommonDyad η C W0 W1 slots W Yp J X Y U R V hV‖≤ + B*gaussianJointMoment V hV degree (U/R) := by + let f := fun t : ℝ=>(∑p : ∀i,slots i,compensationSubsetWeight η W Yp (fun i=>(p i).val) J* + compensationRowTest η C W0 W1 (fun i=>(p i).val) J X Y U t* + selectedSlotFactor W Yp (fun i=>(p i).val) J t)*gaussianJointDensity V hV (U/R) t + have hi := (JointLogSeparation.weighted_schwartz_integrable (gaussianJointDensity V hV (U/R)) degree).const_mul B + have hmajor (t : ℝ) : ‖f t‖≤B*((1+‖t‖)^degree*‖gaussianJointDensity V hV (U/R) t‖) := by + dsimp only [f] + rw [norm_mul] + simpa only [mul_assoc] using mul_le_mul_of_nonneg_right (hb t) + (norm_nonneg (gaussianJointDensity V hV (U/R) t)) + have hh := norm_integral_le_of_norm_le hi (Filter.Eventually.of_forall hmajor) + simpa only [f,lowCommonDyad,gaussianJointMoment,integral_const_mul] using hh + +theorem low_central_gaussian_dyad (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) + (a b ε : ℝ) (ha : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→a*Z^(ell i)≤(Ideal.absNorm P.val:ℝ) ∧ (Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(U : ℝ),0canonicalSlotSupport (T i)) + W (fun i=>Z^(ell i)) J (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) U + (Z^(1+lowSelectedLength ell J)) V hV‖≤ + C*Z^(3/16+254*ε)*gaussianJointMoment V hV degree (U/Z^(1+lowSelectedLength ell J)) := by + obtain ⟨degree,C,hC,he⟩ := low_central_compensated_tuple η S hS hbad ell hell hsum + a b ε ha hε hε1 W0 W1 a0 b0 a1 b1 M ha0 ha1 hab1 hM hW0 hW1 hW0s hW1s hWM + refine ⟨degree,C,hC,?_⟩ + filter_upwards [he] with Z hZ + refine ⟨hZ.1,?_⟩ + intro T hT hout hdis hnorm J U hU hlo hhi W hW V hV + apply lowCommonDyad_norm_of_bound + intro t + simpa only [mul_assoc,mul_left_comm,mul_comm] using hZ.2 T hT hout hdis hnorm J U hU hlo hhi W hW t + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianRemote.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianRemote.lean new file mode 100644 index 0000000000000000000000000000000000000000..488b9143cccf51fa1bf0b66023e2ecf33ff5f020 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianRemote.lean @@ -0,0 +1,130 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGaussianDyad + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma slotProduct_subtype {K : ℕ} (p : Fin K→O) (J : Finset (Fin K)) : + slotProduct p J=∏i : J,p i.val := by rw [Finset.prod_coe_sort];rfl + +lemma eventually_low_physical_scales {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) + (hsum : ∑i,ell i≤1/6) (b : ℝ) : + ∀ᶠZ : ℝ in Filter.atTop,1(p i).val) J) ∧ + 1≤Z^(23/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J) := by + filter_upwards [Filter.eventually_gt_atTop (1:ℝ), + (tendsto_rpow_atTop (show 0<(3/16:ℝ) by norm_num)).eventually + (Filter.eventually_ge_atTop ((max 1 b)^K))] with Z hZ hc + refine ⟨hZ,?_⟩ + intro slots hn hnorm J p + have hl : 0(p i).val) J) := + slotProduct_norm_pos _ (fun i=>hn i _ (p i).property) J + have hb := lowUnselectedProduct_norm_bound ell hell hsum (max 1 b) Z (le_max_left _ _) hZ.le + slots (fun i n hm=>(hnorm i n hm).trans (mul_le_mul_of_nonneg_right (le_max_right _ _) (by positivity))) + J (fun i=>p i.val) + rw [←slotProduct_subtype (fun i=>(p i).val) J] at hb + have hLX : elementNorm (slotProduct (fun i=>(p i).val) J)≤Z^(17/48:ℝ) := by + apply hb.trans + calc + _≤Z^(3/16:ℝ)*Z^(1/6:ℝ) := mul_le_mul_of_nonneg_right hc (by positivity) + _=_ := by rw [←Real.rpow_add (lt_trans zero_lt_one hZ)];norm_num + constructor + · exact (one_le_div hl).mpr hLX + · exact (one_le_div hl).mpr (hLX.trans + (Real.rpow_le_rpow_of_exponent_le hZ.le (by norm_num))) + +lemma low_remote_power (Z ell ε : ℝ) (N : ℕ) (hZ : 1≤Z) (hell : ell≤1/6) + (hN : 13/3≤(ε/2)*(N:ℝ)) : + Z*(Z^(1+ell))^2/(Z^(ε/2))^N≤Z^(-1:ℝ) := by + have hz : 0if lowRemote Z (lowSelectedLength ell J) ε ((2:ℝ)^j) then + ‖lowCommonDyad η (calibrationForSet S hS) W0 W1 (fun i=>canonicalSlotSupport (T i)) + W (fun i=>Z^(ell i)) J (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) ((2:ℝ)^j) + (Z^(1+lowSelectedLength ell J)) V hV‖ else 0 + Summable f ∧ (∑'j : ℕ,f j)≤C*Z^(-1:ℝ) := by + have hep : 0<ε/2 := by linarith + obtain ⟨N,hN⟩ := exists_nat_gt ((13/3:ℝ)/(ε/2)) + have hN' : (13/3:ℝ)≤(ε/2)*(N:ℝ) := by + have hh := (div_lt_iff₀ hep).mp hN + nlinarith + obtain ⟨Cg,hCg,he⟩ := gaussianPhysicalFamily_remote_polynomial V hV N + a0 b0 a1 b1 B0 B1 ha0 ha1 hB0 hB1 + let q := elementNorm (calibrationForSet S hS).generator + let C0 := Cg*(q*(128*max 1 b)^K) + have hq : 0canonicalSlotSupport_nonzero _ (hT i) + have hnormE : ∀i n,n∈canonicalSlotSupport (T i)→elementNorm n≤b*Z^(ell i) := by + intro i n hn + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hn + rw [primaryTuple_norm P (hT i P hP)] + exact hnorm i P hP + have hs := hZ.2 _ hslots hnormE J + have hh := he η S hS W0 W1 + (HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW0) + (HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW1) + hW0 hW1 hWB0 hWB1 (Finset.univ : Finset (∀i,canonicalSlotSupport (T i))) + (fun p=>compensationSubsetWeight η W (fun i=>Z^(ell i)) (fun i=>(p i).val) J) + (fun p=>Ideal.span {slotProduct (fun i=>(p i).val) (Finset.univ\J)}) + (fun p=>Z^(17/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J)) + (fun p=>Z^(23/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J)) + (fun p _=>(hs p).1) (fun p _=>(hs p).2) + (fun i : SelectedSlot J=>W i.val) (fun p i=>elementNorm (p i.val).val/Z^(ell i.val)) + (Z^(1+lowSelectedLength ell J)) (Z^(ε/2)) (by positivity) (Real.one_le_rpow hZ.1.le hep.le) + simp only [←lowCommonDyad_eq_family] at hh + refine ⟨?_,?_⟩ + · convert hh.1 using 1 + funext j + split_ifs with h <;> simp_all only [ite_true, ite_false] + · have hhFinal := hh.2.trans (show _≤C0*Z^(-1:ℝ) from by + have hm := compensation_scale_mass_bound η (calibrationForSet S hS) ell hell hsum b Z hZ.1.le T hT hnorm J W hW + calc + _≤Cg*((q*(128*max 1 b)^K)*Z)*(Z^(1+lowSelectedLength ell J))^2/(Z^(ε/2))^N := by gcongr + _=C0*(Z*(Z^(1+lowSelectedLength ell J))^2/(Z^(ε/2))^N) := by dsimp [C0];ring + _≤_ := mul_le_mul_of_nonneg_left (low_remote_power Z (lowSelectedLength ell J) ε N hZ.1.le + (by have hb := lowLength_bounds ell hell hsum J;linarith) hN') (by dsimp [C0];positivity)) + convert hhFinal using 1 + apply tsum_congr + intro j + split_ifs with h <;> simp_all only [ite_true, ite_false] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianSum.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..1bfd335a4db0973b7b5a9342a03eab82eddfe60d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGaussianSum.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGaussianCentral + +namespace OAI + +noncomputable section +open scoped Classical ContDiff SchwartzMap +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma low_dyad_norm_split (f : ℕ→ℂ) (p : ℕ→Prop) [DecidablePred p] + (hc : Summable (fun j=>if p j then 0 else ‖f j‖)) + (hr : Summable (fun j=>if p j then ‖f j‖ else 0)) : + Summable f ∧ ‖∑'j,f j‖≤(∑'j,if p j then 0 else ‖f j‖)+(∑'j,if p j then ‖f j‖ else 0) := by + have he (j : ℕ) : ‖f j‖=(if p j then 0 else ‖f j‖)+(if p j then ‖f j‖ else 0) := by + split_ifs <;>ring + have hn : Summable (fun j=>‖f j‖) := (hc.add hr).congr (fun j=>(he j).symm) + refine ⟨hn.of_norm,?_⟩ + apply (norm_tsum_le_tsum_norm hn).trans_eq + exact (tsum_congr he).trans (hc.tsum_add hr) + +theorem low_all_gaussian_dyads (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) + (a b ε : ℝ) (ha : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→a*Z^(ell i)≤(Ideal.absNorm P.val:ℝ) ∧ (Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(W : Fin K→ℝ→ℂ),(∀i x,‖W i x‖≤1)→ + let f := fun j : ℕ=>lowCommonDyad η (calibrationForSet S hS) W0 W1 (fun i=>canonicalSlotSupport (T i)) + W (fun i=>Z^(ell i)) J (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) ((2:ℝ)^j) + (Z^(1+lowSelectedLength ell J)) V hV + Summable f ∧ ‖∑'j : ℕ,f j‖≤C*Z^(3/16+256*ε) := by + obtain ⟨Cc,hCc,hcentral⟩ := low_central_gaussian_dyads η S hS hbad ell hell hsum + a b ε ha hε hε1 V hV W0 W1 a0 b0 a1 b1 B1 ha0 ha1 hab1 hB1 hW0 hW1 hW0s hW1s hWB1 + obtain ⟨Cr,hCr,hremote⟩ := low_remote_gaussian_dyads S hS ell hell hsum b ε hε V hV + W0 W1 a0 b0 a1 b1 B0 B1 ha0 ha1 hB0 hB1 hW0 hW1 hWB0 hWB1 + refine ⟨Cc+Cr,add_pos hCc hCr,?_⟩ + filter_upwards [hcentral,hremote] with Z hc hr + refine ⟨hc.1,?_⟩ + intro T hT hout hdis hnorm J W hW + have hc' := hc.2 T hT hout hdis hnorm J W hW + have hr' := hr.2 η T hT (fun i P hP=>(hnorm i P hP).2) J W hW + dsimp only at hc' hr' ⊢ + have hh := low_dyad_norm_split _ (fun j=>lowRemote Z (lowSelectedLength ell J) ε ((2:ℝ)^j)) hc'.1 hr'.1 + refine ⟨hh.1,hh.2.trans ?_⟩ + have hp : Z^(-1:ℝ)≤Z^(3/16+256*ε) := Real.rpow_le_rpow_of_exponent_le hc.1.le (by linarith) + calc + _≤Cc*Z^(3/16+256*ε)+Cr*Z^(-1:ℝ) := add_le_add hc'.2 hr'.2 + _≤Cc*Z^(3/16+256*ε)+Cr*Z^(3/16+256*ε) := add_le_add le_rfl (mul_le_mul_of_nonneg_left hp hCr.le) + _=_ := by ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGramApplied.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramApplied.lean new file mode 100644 index 0000000000000000000000000000000000000000..6cedd2379fde8f28532b0833dfb4017381ecd54c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramApplied.lean @@ -0,0 +1,57 @@ +import OAI.NumberTheory.DirichletL.Detector.GramBound +import OAI.NumberTheory.DirichletL.Detector.LowSlotPolynomial + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap ContDiff +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve CompletedGauss RayFourExpansion CenteredMomentGaussEnergy +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem lowSeparatedIntegrand_actual_gram (δ : ℝ) (hδ : 0<δ) (hδ1 : δ<1) + (a b M : ℝ) (ha : 0primaryGenerator I.val) + (fun I=>(supported_span_primaryGenerator_iff _).mpr I.property) + (lowGaussColumn (calibrationForSet S hS) W1 Y σ v) (lowGaussMajorant a₀ b₀ ha₀ hb₀) Q).re≤A := + (Complex.re_le_norm _).trans (hgram σ v Y Q hY hQ hP) + apply (lowSeparatedIntegrand_actual_energies a₀ b₀ ha₀ hb₀ (calibrationForSet S hS) + W0 W1 hW1c X Y hX hy B v).trans + rw [mul_assoc] + apply mul_le_mul_of_nonneg_left _ (norm_nonneg _) + calc + _≤∑σ : RayRing,Real.sqrt A*Real.sqrt (∑m∈lowNumeratorRows a₀ b₀ ha₀ hb₀ Q hQ,‖B σ m‖^2) := + Finset.sum_le_sum (fun σ _=>mul_le_mul_of_nonneg_right (Real.sqrt_le_sqrt (hbound σ)) (Real.sqrt_nonneg _)) + _=_ := (Finset.mul_sum ..).symm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGramArithmetic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramArithmetic.lean new file mode 100644 index 0000000000000000000000000000000000000000..70fe0642c437b48b6aa384751944826b9e97ae91 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramArithmetic.lean @@ -0,0 +1,96 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramProfile +import OAI.NumberTheory.DirichletL.Detector.LowPeriod + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ConcreteTraceCRT ProbeRow CanonicalRowCompletion CanonicalQuadraticSieve CompletedGauss +open RayFourExpansion InitialMeanSquare SecondPassArithmetic CanonicalCoefficientClass +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +def gramPeriodicMonoid (C : CalibrationData) (B : O) (D : GoodMaskRowData B 1 C.generator) : O→*ℂ := + conjugateMonoid C.residueMonoid*actualPeriodicRow 1 B D.numeratorUnit D.numeratorLambda D.numeratorTwo + D.numeratorGood D.numeratorSupported + +lemma gramPeriodicMonoid_norm (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (n : O) : ‖gramPeriodicMonoid C B D n‖≤1 := by + rw [gramPeriodicMonoid,MonoidHom.mul_apply,norm_mul] + change ‖star (C.residueMonoid n)‖*_≤1 + rw [norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) (C.residueMonoid_norm_le_one n)).trans (actualPeriodicRow_norm 1 (fun _=>by simp) B D.numeratorUnit D.numeratorLambda D.numeratorTwo + D.numeratorGood D.numeratorSupported n) + +lemma gramPeriodicMonoid_periodic (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) : + FactorsModulo (Ideal.span {C.generator}*calibrationRowModulus C B D) (gramPeriodicMonoid C B D) := by + have hp := actualPeriodicRow_periodic (1:O→*ℂ) 1 (fun _ _ _=>rfl) + B D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported + intro x y hxy + change star (C.residueMonoid x)*_=star (C.residueMonoid y)*_ + congr 1 + · apply congrArg star + apply congrArg C.residue + exact Ideal.Quotient.eq.mpr (Ideal.mul_le_left hxy) + · exact hp x y (Ideal.mul_le_right hxy) + +lemma gramPeriodicMonoid_zero (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (n : O) (hn : ¬IsCoprime B n) : + gramPeriodicMonoid C B D n=0 := by + have hm : coprimalityMask B n=(0:ℂ) := by change (if IsCoprime B n then (1:ℂ) else 0)=0;rw [ite_eq_right hn] + change star (C.residueMonoid n)* + ((((1:O→*ℂ) n*coprimalityMask B n)* + numeratorBadTwist D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported n)* + movingNumeratorRow D.numeratorGood D.numeratorSupported n)=0 + rw [hm] + simp + +lemma gramPeriodicMonoid_primary (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (hBL : λ₀∣B) (hB2 : (2:O)∣B) + (n : O) (hn : Supported (Ideal.span {n})) (hpn : λ₀^2∣n-1) (hc : IsCoprime B n) : + gramPeriodicMonoid C B D n=(C.residueMonoid n)⁻¹*idealRowHom C.generator (Ideal.span {n}) := by + have he := rowTwist_eq_actualPeriodicRow_primary (1:O→*ℂ) B 1 C.generator hBL hB2 + D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported + D.numeratorPrimary D.numeratorFactor n hpn + rw [rowTwist_extract_sixth_mask _ _ _ _ _ hn] at he + have hm : coprimalityMask B n=(1:ℂ) := by change (if IsCoprime B n then (1:ℂ) else 0)=1;rw [ite_eq_left hc] + simp only [MonoidHom.one_apply,hm,one_mul,one_pow] at he + change star (C.residueMonoid n)*_=_ + rw [←he] + congr 1 + let := finite_quotient_span C.generator_ne_zero + let : Fintype (O⧸Ideal.span {C.generator}) := Fintype.ofFinite _ + change star (C.residue (Ideal.Quotient.mk _ n))=(C.residue (Ideal.Quotient.mk _ n))⁻¹ + rw [MulChar.star_apply',MulChar.inv_apply_eq_inv'] + +theorem lowArithmeticCoefficient_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hbad : fixedBadPrimes⊆S) (s : {I : Id // Supported I}) : + lowArithmeticCoefficient (calibrationForSet S hS) s= + (calibrationForSet S hS).tau⁻¹* + gramPeriodicMonoid (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS) (primaryGenerator s.val) := by + let C := calibrationForSet S hS + have hn := supported_primaryGenerator_ne_zero s.val s.property + have he := (primaryGenerator_spec s.val hn).1 + have hp := (primaryGenerator_spec s.val hn).2 + have hsupp := (supported_span_primaryGenerator_iff s.val).mpr s.property + have hb := calibration_generator_bad S hS hbad + by_cases hc : IsCoprime C.generator (primaryGenerator s.val) + · have hguard : ∀P∈C.excluded,¬P∣s.val := by + rw [show C.excluded=S from calibrationForSet_excluded S hS,←he] + exact (calibration_coprime_iff_excluded_span S hS _).mp hc + rw [lowArithmeticCoefficient,ite_eq_left hguard, + gramPeriodicMonoid_primary C C.generator (calibrationLowData S hS) hb.1 hb.2 _ hsupp hp hc,he] + ring + · have hguard : ¬∀P∈C.excluded,¬P∣s.val := by + rw [show C.excluded=S from calibrationForSet_excluded S hS,←he] + exact fun h=>hc ((calibration_coprime_iff_excluded_span S hS _).mpr h) + rw [lowArithmeticCoefficient,ite_eq_right hguard,gramPeriodicMonoid_zero C C.generator (calibrationLowData S hS) _ hc,mul_zero] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGramDiagonal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramDiagonal.lean new file mode 100644 index 0000000000000000000000000000000000000000..a525ecde554e6c3dcb986f4ba46c5ad6205b753a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramDiagonal.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramPoisson +import OAI.NumberTheory.DirichletL.Moments.SecondDiagonal + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion CenteredMomentGaussEnergy +open CenteredMomentSupportedCorrelation CenteredMomentSecondDiagonal EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowGramZeroMode (C : CalibrationData) (W1 : ℝ→ℂ) (hW1 : HasCompactSupport W1) + (Y : ℝ) (hY : 0primaryGenerator s.val) + (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) (lowGaussColumn C W1 Y σ v) + +lemma lowGramZeroMode_eq_source (C : CalibrationData) (W1 : ℝ→ℂ) (hW1 : HasCompactSupport W1) + (Y : ℝ) (hY : 0Ideal.span {z}) h + +theorem lowGramZeroMode_source_bound (a b B : ℝ) (ha : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowGramRemainders (F : Finset O) : Finset Id := + F.image (fun z=>sixthRemainder (Ideal.span {z})) + +lemma lowGramRemainders_nonzero (F : Finset O) (R : Id) (hR : R∈lowGramRemainders F) : R≠0 := by + obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hR + exact sixthRemainder_ne_zero _ + +theorem lowGramRemainders_card (F : Finset O) (G : Id) + (hres : ∀z∈F,∀P∉primeSupport G,valuation (Ideal.span {z}) P%6=0) : + (lowGramRemainders F).card≤6^(primeSupport G).card := by + have hlt (R : lowGramRemainders F) (P : Id) : valuation R.val P<6 := by + obtain ⟨z,hz,he⟩ := Finset.mem_image.mp R.property + rw [←he] + exact sixthRemainder_valuation_lt _ _ + let code : lowGramRemainders F→(primeSupport G→Fin 6) := fun R P=>⟨valuation R.val P.val,hlt R P.val⟩ + have hinj : Function.Injective code := by + intro R T he + apply Subtype.ext + apply ideal_eq_of_valuation_eq (lowGramRemainders_nonzero F R.val R.property) + (lowGramRemainders_nonzero F T.val T.property) + intro P + by_cases hp : P∈primeSupport G + · exact congrArg Fin.val (congrFun he ⟨P,hp⟩) + · obtain ⟨r,hr,her⟩ := Finset.mem_image.mp R.property + obtain ⟨t,ht,het⟩ := Finset.mem_image.mp T.property + rw [←her,←het,sixthRemainder_valuation,sixthRemainder_valuation,hres r hr P hp,hres t ht P hp] + have hh := Fintype.card_le_of_injective code hinj + simpa only [Fintype.card_coe,Fintype.card_fun,Fintype.card_fin] using hh + +theorem lowGramExceptional_raw_count (F : Finset O) (G : Id) (H : ℝ) (hH : 0≤H) + (hF : ∀z∈F,z≠0) + (hres : ∀z∈F,∀P∉primeSupport G,valuation (Ideal.span {z}) P%6=0) + (hN : ∀z∈F,(Ideal.absNorm (Ideal.span {z}):ℝ)≤H) : + (F.card:ℝ)≤768*(6:ℝ)^(primeSupport G).card*H^(1/6:ℝ) := by + have hh := element_count_remainder_family F (lowGramRemainders F) + (lowGramRemainders_nonzero F) H hH hF (fun z hz=>Finset.mem_image.mpr ⟨z,hz,rfl⟩) hN + calc + _ ≤ ∑R∈lowGramRemainders F,768*(H/(Ideal.absNorm R:ℝ))^(1/6:ℝ) := hh + _ ≤ ∑_R∈lowGramRemainders F,768*H^(1/6:ℝ) := by + apply Finset.sum_le_sum + intro R hR + apply mul_le_mul_of_nonneg_left _ (by norm_num) + apply Real.rpow_le_rpow (div_nonneg hH (Nat.cast_nonneg _)) _ (by norm_num) + exact div_le_self hH (norm_one_le (lowGramRemainders_nonzero F R hR)) + _ = (lowGramRemainders F).card*(768*H^(1/6:ℝ)) := by simp + _ ≤ ((6:ℝ)^(primeSupport G).card)*(768*H^(1/6:ℝ)) := by + apply mul_le_mul_of_nonneg_right _ (by positivity) + exact_mod_cast lowGramRemainders_card F G hres + _ = _ := by ring + +theorem lowGramExceptional_count (ε : ℝ) (hε : 0<ε) : + ∃C : ℝ,0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def gramFixedModulus (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) : Id := + (Ideal.span {(calibrationForSet S hS).generator}* + calibrationRowModulus (calibrationForSet S hS) (calibrationForSet S hS).generator (calibrationLowData S hS))* + Ideal.span {(4:O)} + +lemma gramFixedModulus_nonzero (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) : gramFixedModulus S hS≠0 := by + unfold gramFixedModulus + apply mul_ne_zero + · exact mul_ne_zero (Ideal.span_singleton_eq_bot.not.mpr (calibrationForSet S hS).generator_ne_zero) + (calibrationRowModulus_ne_zero _ _ (calibrationForSet S hS).generator_ne_zero _) + · exact Ideal.span_singleton_eq_bot.not.mpr (by norm_num) + +def gramCoefficientExtension (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (n : O) : ℂ := + if physicalRay n=σ then (calibrationForSet S hS).tau⁻¹* + gramPeriodicMonoid (calibrationForSet S hS) (calibrationForSet S hS).generator (calibrationLowData S hS) n + else 0 + +lemma gramCoefficientExtension_norm (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (n : O) : + ‖gramCoefficientExtension S hS σ n‖≤1 := by + unfold gramCoefficientExtension + split_ifs + · rw [norm_mul,norm_inv,calibrationForSet_tau_norm,inv_one,one_mul] + exact gramPeriodicMonoid_norm _ _ _ _ + · simp + +lemma gramCoefficientExtension_zero (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (n : O) + (hn : ¬IsCoprime (calibrationForSet S hS).generator n) : gramCoefficientExtension S hS σ n=0 := by + unfold gramCoefficientExtension + split_ifs + · rw [gramPeriodicMonoid_zero _ _ _ _ hn,mul_zero] + · rfl + +theorem lowGramCoefficient_eq_extension (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hbad : fixedBadPrimes⊆S) (σ : RayRing) (s : {I : Id // Supported I}) : + lowGramCoefficient (calibrationForSet S hS) σ s= + gramCoefficientExtension S hS σ (primaryGenerator s.val) := by + unfold lowGramCoefficient gramCoefficientExtension + change (if physicalRay (primaryGenerator s.val)=σ then _ else 0)=_ + rw [lowArithmeticCoefficient_periodic S hS hbad s] + +theorem gramCoefficientExtension_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (σ : RayRing) (x y : O) (hxy : x-y∈gramFixedModulus S hS) : + gramCoefficientExtension S hS σ x=gramCoefficientExtension S hS σ y := by + have hr : physicalRay x=physicalRay y := Ideal.Quotient.eq.mpr (Ideal.mul_le_right hxy) + have hm := gramPeriodicMonoid_periodic (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS) x y (Ideal.mul_le_left hxy) + simp only [gramCoefficientExtension,hr,hm] + +lemma gramCoefficientExtension_scaled_periodic (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (σ : RayRing) (d x y : O) (hxy : x-y∈gramFixedModulus S hS) : + gramCoefficientExtension S hS σ (d*x)=gramCoefficientExtension S hS σ (d*y) := by + apply gramCoefficientExtension_periodic + rw [←mul_sub] + exact (gramFixedModulus S hS).mul_mem_left d hxy + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGramHeight.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramHeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..8ac054176da757836276b50a9a6a05072df6bdae --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramHeight.lean @@ -0,0 +1,82 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramProfile + +namespace OAI + +noncomputable section +open scoped Classical ContDiff SchwartzMap Topology +open Filter Set CompletedHeight FourierBridge +namespace SevenEighths.ProbePhysical + +def lowGramBaseWindow (W : ℝ→ℂ) (r : ℝ) : ℂ := W r/(r:ℂ) + +lemma lowGramBaseWindow_support (W : ℝ→ℂ) : + Function.support (lowGramBaseWindow W)⊆Function.support W := by + intro r hr hz + exact hr (by simp [lowGramBaseWindow,hz]) + +lemma lowGramBaseWindow_smooth (W : ℝ→ℂ) (a b : ℝ) (ha : 0(0:ℂ)) 0).congr_of_eventuallyEq + filter_upwards [eventually_lt_nhds ha] with x hx + have hz : W x=0 := by + by_contra h + exact (not_le.mpr hx) (hs h).1 + simp [lowGramBaseWindow,hz] + · unfold lowGramBaseWindow + simp only [div_eq_mul_inv] + exact hW.contDiffAt.mul (Complex.ofRealCLM.contDiff.contDiffAt.fun_inv (Complex.ofReal_ne_zero.mpr hr)) + +lemma lowGramProfile_twist (W : ℝ→ℂ) (a b : ℝ) (ha : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma low_mellin_sqrt_weight_bound (W : ℝ→ℂ) (a b : ℝ) (ha : 0Real.sqrt_nonneg _) + have hh (v : ℝ) : ‖lowSeparatedIntegrand (calibrationForSet S hS) W0 W1 + (lowOuterCutoff a₀ b₀) X Y B v‖≤(CM*Real.sqrt K*Real.sqrt A*E)*(1+v^2)⁻¹ := by + have hg := hgram W0 X Y hX hY B v hP + have he : K*(1+|v|)^J*(Q/Y)*(1+(Y^2/Q)^(1/6:ℝ)+(Y^2/Q)^2/Y)*Y^δ= + (1+|v|)^J*(K*A) := by dsimp [A];ring + rw [he,Real.sqrt_mul (by positivity),Real.sqrt_mul hK.le] at hg + calc + _≤(‖mellin W0 ((v:ℂ)*Complex.I)‖*Real.sqrt ((1+|v|)^J))* + (Real.sqrt K*Real.sqrt A*E) := by convert hg using 1 ;ring + _≤(CM/(1+v^2))*(Real.sqrt K*Real.sqrt A*E) := + mul_le_mul_of_nonneg_right (hm v) (by positivity) + _=_ := by rw [div_eq_mul_inv];ring + have hi := norm_integral_le_of_norm_le (integrable_inv_one_add_sq.const_mul + (CM*Real.sqrt K*Real.sqrt A*E)) (Filter.Eventually.of_forall hh) + rw [integral_const_mul,integral_univ_inv_one_add_sq] at hi + convert hi using 1 ;ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowGramPoisson.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramPoisson.lean new file mode 100644 index 0000000000000000000000000000000000000000..53c0dacc2ff53a8b00adc46620d06d5c0bd0c597 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowGramPoisson.lean @@ -0,0 +1,71 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramProfile + +namespace OAI + +noncomputable section +open scoped Classical SchwartzMap +open CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion CenteredMomentGaussEnergy +open CenteredMomentSupportedCorrelation EisensteinSchwartzPoisson ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma lowGram_pair_prefactor (C : CalibrationData) (W1 : ℝ→ℂ) + (Y : ℝ) (hY : 0primaryGenerator s.val) + (fun s=>(supported_span_primaryGenerator_iff s.val).mpr s.property) + (lowGaussColumn C W1 Y σ v) U Q= + ((Q/Y^3:ℝ):ℂ)* + ∑s∈lowGaussColumns W1 hW1 Y hY,∑t∈lowGaussColumns W1 hW1 Y hY, + ((lowGramCoefficient C σ s*lowGramProfile W1 v ((Ideal.absNorm s.val:ℝ)/Y))* + star (lowGramCoefficient C σ t*lowGramProfile W1 v ((Ideal.absNorm t.val:ℝ)/Y)))* + ∑'h : O,actualCorrelation (primaryGenerator s.val) (primaryGenerator t.val) + ((supported_span_primaryGenerator_iff s.val).mpr s.property) + ((supported_span_primaryGenerator_iff t.val).mpr t.property) (-h)* + paperRadialFourier U (Q*‖eisEmbedding h‖^2/‖eisEmbedding (primaryGenerator s.val*primaryGenerator t.val)‖^2) := by + rw [gaussEnergy_poisson _ _ _ _ U Q hQ] + simp_rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro s hs + apply Finset.sum_congr rfl + intro t ht + have hes := congrArg Ideal.absNorm ((primaryGenerator_spec s.val (supported_primaryGenerator_ne_zero s.val s.property)).1) + have het := congrArg Ideal.absNorm ((primaryGenerator_spec t.val (supported_primaryGenerator_ne_zero t.val t.property)).1) + rw [hes,het,←mul_assoc,lowGram_pair_prefactor C W1 Y hY σ v Q s t,mul_assoc] + +theorem lowGram_kernel_scale (Y Q : ℝ) (hY : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowGramCoefficient (C : CalibrationData) (σ : RayRing) + (s : {I : Id // Supported I}) : ℂ := + if physicalIdealRay s=σ then lowArithmeticCoefficient C s else 0 + +def lowGramProfile (W1 : ℝ→ℂ) (v r : ℝ) : ℂ := + W1 r*(r:ℂ)^(-1+(v:ℂ)*Complex.I) + +def lowGramScale (Y : ℝ) : ℂ := (Y:ℂ)⁻¹*(Real.sqrt Y:ℂ)⁻¹ + +lemma lowGramCoefficient_source_norm (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (σ : RayRing) (s : {I : Id // Supported I}) : + ‖lowGramCoefficient (calibrationForSet S hS) σ s‖≤1 := by + unfold lowGramCoefficient + split_ifs + · exact lowArithmeticCoefficient_source_norm S hS s + · simp + +lemma lowGramProfile_norm (W1 : ℝ→ℂ) (v r : ℝ) (hr : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowCorrectionEnergy : ℝ := ∑χ : RayCharacter,‖ProbeCompleted.correctionCoeff χ‖^2 + +lemma lowCorrectionEnergy_nonneg : 0≤lowCorrectionEnergy := + Finset.sum_nonneg (fun _ _=>sq_nonneg _) + +lemma fixed_correction_energy {ι κ : Type*} [Fintype ι] (R : Finset κ) (c : ι→ℂ) (F : ι→κ→ℂ) : + (∑m∈R,‖∑χ : ι,c χ*F χ m‖^2)≤ + (∑χ : ι,‖c χ‖^2)*∑χ : ι,∑m∈R,‖F χ m‖^2 := by + calc + _≤∑m∈R,(∑χ : ι,‖c χ‖^2)*(∑χ : ι,‖F χ m‖^2) := by + apply Finset.sum_le_sum + intro m hm + calc + _≤(∑χ : ι,‖c χ‖*‖F χ m‖)^2 := by + apply (sq_le_sq₀ (norm_nonneg _) (Finset.sum_nonneg (fun _ _=>by positivity))).mpr + simpa only [norm_mul] using norm_sum_le Finset.univ (fun χ=>c χ*F χ m) + _≤_ := Finset.sum_mul_sq_le_sq_mul_sq _ _ _ + _=_ := by rw [←Finset.mul_sum,Finset.sum_comm] + +theorem lowSelectedInverseRow_energy {α : Type*} (F : Finset α) (c : α→ℂ) + (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (D : α→Id) (T t : ℝ) (σ : RayRing) (R : Finset O) : + (∑m∈R,‖lowSelectedInverseRow F c η S hS D T t σ m‖^2)≤ + lowCorrectionEnergy*∑χ : RayCharacter,∑m∈R, + ‖∑k∈F,c k*InverseMoment.markedCompletedT + (CanonicalRowCompletion.rowTwist (physicalRayPeriodicBase η S hS σ χ) + (calibrationForSet S hS).generator 1 m) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T + (fun A=>if D k∣A then (1:ℂ) else 0)‖^2 := by + simp_rw [lowSelectedInverseRow_correction] + exact fixed_correction_energy R ProbeCompleted.correctionCoeff _ + +theorem lowCanonicalSelected_energy {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→CanonicalQuadraticSieve.Supported P.val) + (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) + (X t : ℝ) (σ : RayRing) (R : Finset O) : + (∑m∈R,‖lowSelectedInverseRow Finset.univ + (lowSelectedWeight η (fun i=>canonicalSlotSupport (T i)) J W P t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t σ m‖^2)≤ + lowCorrectionEnergy*∑χ : RayCharacter,∑m∈R, + ‖∑b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J, + (∏i : SelectedSlot J,lowSingleSlotWeight η (W i.val) (P i.val) t (b i).val)* + InverseMoment.markedCompletedT + (CanonicalRowCompletion.rowTwist (physicalRayPeriodicBase η S hS σ χ) + (calibrationForSet S hS).generator 1 m) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) X + (fun A=>∏i : SelectedSlot J,if (lowCanonicalPrimeFamily T hT J b).ideal i∣A then (1:ℂ) else 0)‖^2 := by + have hh := lowSelectedInverseRow_energy Finset.univ + (lowSelectedWeight η (fun i=>canonicalSlotSupport (T i)) J W P t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t σ R + simp_rw [lowSelectedWeight_eq_product] at hh + have he (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + (fun A : Id=>if lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J b∣A then (1:ℂ) else 0)= + (fun A=>∏i : SelectedSlot J,if (lowCanonicalPrimeFamily T hT J b).ideal i∣A then (1:ℂ) else 0) := by + funext A + exact lowCanonicalSelected_mark T hT hdis J b A + simp_rw [he] at hh + exact hh + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowInverseNormalize.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowInverseNormalize.lean new file mode 100644 index 0000000000000000000000000000000000000000..fde2683543c2e75a0d1104b4478efc2809d269f3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowInverseNormalize.lean @@ -0,0 +1,47 @@ +import OAI.NumberTheory.DirichletL.Detector.LowCentralGeometry + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical + +lemma low_inverse_power_cancel (Z d α : ℝ) (hZ : 0(a:ℂ)^(-((v:ℂ)*Complex.I))*(b:ℂ)^((v:ℂ)*Complex.I)* + mellin W ((v:ℂ)*Complex.I)) := by + have hm : Integrable (fun v : ℝ=>mellin W ((v:ℂ)*Complex.I)) := by + have hh := compactMellin_vertical_integrable W a0 b0 ha0 hW hWs 0 + change Integrable (fun v : ℝ=>mellin W ((0:ℂ)+v*Complex.I)) at hh + simpa using hh + have hc : Continuous (fun v : ℝ=>(a:ℂ)^(-((v:ℂ)*Complex.I))*(b:ℂ)^((v:ℂ)*Complex.I)) := + (Continuous.const_cpow (by fun_prop) (Or.inl (Complex.ofReal_ne_zero.mpr ha.ne'))).mul + (Continuous.const_cpow (by fun_prop) (Or.inl (Complex.ofReal_ne_zero.mpr hb.ne'))) + have hp : ∀v : ℝ,‖(a:ℂ)^(-((v:ℂ)*Complex.I))*(b:ℂ)^((v:ℂ)*Complex.I)‖≤1 := by + intro v + rw [norm_mul,Complex.norm_cpow_eq_rpow_re_of_pos ha,Complex.norm_cpow_eq_rpow_re_of_pos hb] + simp + simpa only [mul_comm] using hm.mul_bdd hc.aestronglyMeasurable (Filter.Eventually.of_forall hp) + +lemma low_mellin_ratio (W : ℝ→ℂ) (a0 b0 : ℝ) (ha0 : 0((m/(B*X*Y):ℝ):ℂ)^(-((v:ℂ)*Complex.I))* + (((q/Y:ℝ):ℂ)^(-(1/2:ℂ))*((q/Y:ℝ):ℂ)^((v:ℂ)*Complex.I))*mellin W ((v:ℂ)*Complex.I))= + (fun v : ℝ=>((q/Y:ℝ):ℂ)^(-(1/2:ℂ))* + (((m/(B*X*Y):ℝ):ℂ)^(-((v:ℂ)*Complex.I))*((q/Y:ℝ):ℂ)^((v:ℂ)*Complex.I)*mellin W ((v:ℂ)*Complex.I))) by funext v; ring] + rw [integral_const_mul] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowMellinFubini.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowMellinFubini.lean new file mode 100644 index 0000000000000000000000000000000000000000..72a25136e81eaae63e4279a9977d111a3af94717 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowMellinFubini.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Detector.LowRowMellin + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma lowRowMellinIntegrand_common_support (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (hΩ : HasCompactSupport Ω) + (X Y : ℝ) (hX : 0s.val) Subtype.val_injective.injOn + have hm := elementWindow_finite_support Ω hΩ _ (lowPhysicalScale_pos C X Y hX hY) + refine ⟨hs.toFinset×ˢhm.toFinset,?_⟩ + intro v r hr + simp only [Finset.mem_product,Set.Finite.mem_toFinset,Set.mem_preimage,Function.mem_support] at hr + by_cases h : W1 ((Ideal.absNorm r.1.val:ℝ)/Y)=0 + · unfold lowRowMellinIntegrand + rw [lowAdditiveCoefficient_outer_zero C W1 Y r.1 r.2 v h,mul_zero] + · have ho : Ω (elementNorm r.2/lowPhysicalScale C X Y)=0 := by + by_contra ho + exact hr ⟨h,ho⟩ + simp [lowRowMellinIntegrand,ho] + +lemma lowRowMellinIntegrand_mul_summable (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (hΩ : HasCompactSupport Ω) + (X Y : ℝ) (hX : 0lowRowMellinIntegrand C W0 W1 Ω X Y r v*B r) := by + obtain ⟨R,hR⟩ := lowRowMellinIntegrand_common_support C W0 W1 Ω hW1 hΩ X Y hX hY + apply summable_of_ne_finset_zero (s:=R) + intro r hr + rw [hR v r hr,zero_mul] + +lemma lowRowMellinIntegrand_sum_integrable (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (a0 b0 : ℝ) (ha0 : 0∑'r : PhysicalRowIndex,lowRowMellinIntegrand C W0 W1 Ω X Y r v*B r) := by + obtain ⟨R,hR⟩ := lowRowMellinIntegrand_common_support C W0 W1 Ω hW1 hΩ X Y hX hY + have he (v : ℝ) : (∑'r : PhysicalRowIndex,lowRowMellinIntegrand C W0 W1 Ω X Y r v*B r)= + ∑r∈R,lowRowMellinIntegrand C W0 W1 Ω X Y r v*B r := by + apply tsum_eq_sum + intro r hr + rw [hR v r hr,zero_mul] + simp_rw [he] + exact integrable_finsetSum R (fun r _=>(lowRowMellinIntegrand_integrable C W0 W1 Ω a0 b0 ha0 hW0 hWs hΩ0 X Y hX hY r).mul_const _) + +lemma lowRowMellinIntegrand_tsum_integral (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (a0 b0 : ℝ) (ha0 : 0by simp only [hR _ r hr,zero_mul,integral_zero])] + simp_rw [he] + exact (integral_finsetSum R (fun r _=>(lowRowMellinIntegrand_integrable C W0 W1 Ω a0 b0 ha0 hW0 hWs hΩ0 X Y hX hY r).mul_const _)).symm + +theorem physicalRowWeight_tsum_low_mellin (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem low_selected_nominal_energy (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) + (Ck b ε : ℝ) (hCk : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→(Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(R : Finset O), + (∀z∈R,z≠0 ∧ elementNorm z≤Ck*Z^(5/6-2*lowUnselectedLength ell J))→ + ∀X : ℝ,0canonicalSlotSupport (T i)) J W Y t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t σ z‖^2)≤ + C*(1+‖t‖)^degree*Z^((5/6-2*lowUnselectedLength ell J)+507*ε) := by + obtain ⟨degree,C,Z₀,hC,hZ₀,he⟩ := low_selected_physical_energy η S hS hbad K Ck ε hCk hε hε1 + refine ⟨degree,C,hC,?_⟩ + filter_upwards [eventually_low_selected_caps ell hell b ε hε,Filter.eventually_ge_atTop Z₀] with Z hc hZ + refine ⟨hc.1,?_⟩ + intro T hT hout hdis hnorm J R hR X hX hXlo hXhi W hW Y t σ + obtain ⟨hd,hd1,hs,hscap⟩ := lowLength_bounds ell hell hsum J + have hscale := lowCentralShift_scale Z X (lowSelectedLength ell J+ε/2) hc.1 hX + rw [←hscale] + apply he Z (lowUnselectedLength ell J) (lowSelectedLength ell J+ε/2) + (lowCentralShift Z X (lowSelectedLength ell J+ε/2)) hZ hd hd1 (by linarith) (by linarith) + (lowCentralShift_bound Z X (lowSelectedLength ell J) ε hc.1 hX hε.le hXlo hXhi) + R hR T hT hout hdis J (fun i=>max 1 (b*Z^(ell i.val))) + (fun i=>le_max_left _ _) + (fun i P hP=>(hnorm i.val P hP).trans (le_max_right _ _)) (hc.2 J) W hW Y t σ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowNominalGeometry.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowNominalGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..4ab2dc589c83f01df50817b327583acb8ab8bcf1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowNominalGeometry.lean @@ -0,0 +1,109 @@ +import OAI.NumberTheory.DirichletL.Detector.LowOriginalPools + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve ProbeRaySlots +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowUnselectedLength {K : ℕ} (ell : Fin K→ℝ) (J : Finset (Fin K)) : ℝ := ∑i∈J,ell i + +def lowSelectedLength {K : ℕ} (ell : Fin K→ℝ) (J : Finset (Fin K)) : ℝ := ∑i : SelectedSlot J,ell i.val + +lemma lowLength_sum {K : ℕ} (ell : Fin K→ℝ) (J : Finset (Fin K)) : + lowUnselectedLength ell J+lowSelectedLength ell J=∑i,ell i := by + rw [lowUnselectedLength,lowSelectedLength,Finset.sum_coe_sort] + exact Finset.sum_add_sum_compl J ell + +lemma lowLength_bounds {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) + (hsum : ∑i,ell i≤1/6) (J : Finset (Fin K)) : + 0≤lowUnselectedLength ell J ∧ lowUnselectedLength ell J≤1/6 ∧ + 0≤lowSelectedLength ell J ∧ lowSelectedLength ell J≤1/6-lowUnselectedLength ell J := by + have hu : 0≤lowUnselectedLength ell J := Finset.sum_nonneg (fun i _=>hell i) + have hs : 0≤lowSelectedLength ell J := Finset.sum_nonneg (fun i _=>hell i.val) + have he := lowLength_sum ell J + exact ⟨hu,by linarith,hs,by linarith⟩ + +lemma lowUnselectedProduct_norm_lower {K : ℕ} (ell : Fin K→ℝ) + (a Z : ℝ) (ha : 0by positivity) (fun i _=>hslots i.val _ (p i).property) + +lemma originalPool_element_lower (R : Set Id) (S : Finset Id) (hS : SourceExclusions S) + (a b Y : ℝ) (ha : 0≤a) (hab : a≤b) (hY : 0le_trans zero_le_one (le_max_left _ _)) + intro i hi + apply max_le + · exact one_le_mul_of_one_le_of_one_le (le_max_left _ _) (Real.one_le_rpow hZ (hell i.val)) + · exact mul_le_mul_of_nonneg_right (le_max_right _ _) (by positivity) + _=(max 1 b)^(Fintype.card (SelectedSlot J))*Z^(lowSelectedLength ell J) := by + rw [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ, + ←Real.rpow_sum_of_pos (lt_of_lt_of_le zero_lt_one hZ)] + rfl + _≤_ := mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (le_max_left _ _) hc) (by positivity) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowNormalized.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowNormalized.lean new file mode 100644 index 0000000000000000000000000000000000000000..3a9f0257cdbde8fce7cc026ac62ef672c3e9820c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowNormalized.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Detector.LowWindowBound +import OAI.NumberTheory.DirichletL.PrimeRows.CubeNormalizer + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open Filter +namespace SevenEighths.ProbePhysical +open ProbeRaySlots PrincipalSignalComparison PrincipalMellinResidues ProbePrincipalResidueActual +local notation "O" => HeckeFamily.O + +theorem original_normalized_compensatedPhysicalProbe_low {K : ℕ} + (M : Ideal O) [NeZero M] [Finite (O ⧸ M)] + (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + (S : Finset (Ideal O)) (hS : SourceExclusions S) (hmax : ∀P∈S,P.IsMaximal) + (a b B loss : ℝ) (ha : 0Z^(ell j) + let T := fun j=>pool (RayQuotient.identityClass M H) S a b (Yp j) + let WC : Fin K→ℝ→ℂ := fun j y=>(W j y:ℂ) + let normer := sourceResidueConstant W0 W1 (∏P∈S,P)* + (Probe.principalScalar Finset.univ Z (1/6) (slotMass T (residueWeights W Yp)) : ℂ) + normer≠0 ∧ + ‖compensatedPhysicalProbe η (calibrationForSet S hmax) W0 W1 + (fun j=>canonicalSlotSupport (T j)) WC Yp (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z/normer‖≤ + C*Z^(3/16+loss) := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + let WC : Fin K→ℝ→ℂ := fun j y=>(W j y:ℂ) + have hWC (j : Fin K) : Function.support (WC j)⊆Set.Icc a b := by + intro y hy + apply Set.Ioo_subset_Icc_self (hsupp j _) + intro hz + exact hy (by dsimp [WC];rw [hz];simp) + have hWCB (j : Fin K) (y : ℝ) : ‖WC j y‖≤B := by + simpa only [WC,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (hWB j y).1] using (hWB j y).2 + have hW1' : Function.support W1⊆Set.Icc a1 (max b1 (a1+1)) := by + intro y hy + exact ⟨(hW1 hy).1,(hW1 hy).2.trans (le_max_left _ _)⟩ + have hab1 : a1(hWB j y).1) hne W0 W1 a0 b0 a1 b1 ha0 ha1 + hW0 hW1 hr0 hr1 hp0 hp1 hn0 hn1 (loss/2) (by positivity) + intro η + obtain ⟨Cp,hCp,hprobe⟩ := original_ray_compensatedPhysicalProbe_low_loss S hS hmax ell + (fun j=>(hell j).le) hinj hsum.le (RayQuotient.identityClass M H) a b B (loss/2) + ha hab (by positivity) WC hWC hWCB W0 W1 a0 b0 a1 (max b1 (a1+1)) + (SchwartzMap.seminorm ℝ 0 0 W0) (SchwartzMap.seminorm ℝ 0 0 W1) + ha0 ha1 hab1 (by positivity) (by positivity) hW0 hW1' (W0.smooth (⊤ : ℕ∞)) (W1.smooth (⊤ : ℕ∞)) + (SchwartzMap.norm_le_seminorm ℝ W0) (SchwartzMap.norm_le_seminorm ℝ W1) η + refine ⟨Cp*Cn,by positivity,?_⟩ + filter_upwards [hprobe,hnorm,eventually_gt_atTop (0:ℝ)] with Z hp hn hZ + dsimp only at hn ⊢ + refine ⟨hn.1,?_⟩ + rw [div_eq_mul_inv,norm_mul] + calc + _≤(Cp*Z^(3/16+loss/2))*(Cn*Z^(loss/2)) := + mul_le_mul hp hn.2 (norm_nonneg _) (by positivity) + _=(Cp*Cn)*Z^(3/16+loss) := by + rw [mul_mul_mul_comm,←Real.rpow_add hZ] + congr 2 + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowOriginalPools.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowOriginalPools.lean new file mode 100644 index 0000000000000000000000000000000000000000..6b87f3e42b77e2a33c7330749e222717efd3c036 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowOriginalPools.lean @@ -0,0 +1,48 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSlotScales +import OAI.NumberTheory.DirichletL.Detector.RayPoolGood + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve ProbeRaySlots +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma originalPool_element_norm (R : Set Id) (S : Finset Id) (hS : SourceExclusions S) + (a b Y : ℝ) (ha : 0≤a) (hab : a≤b) (hY : 0canonicalSlotSupport (pool R S a b (Z^(ell i))) + ∀(J : Finset (Fin K))(p : LowUnselectedTuple T J), + let L := elementNorm (∏i : J,(p i).val) + 1≤Z^(23/48:ℝ)/L ∧ + 1≤(Z^(23/48:ℝ)/L)^2/lowPhysicalScale (calibrationForSet S hmax) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) ∧ + ∀δ : ℝ,0≤δ→lowGramFactor (calibrationForSet S hmax) (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) δ≤ + Real.sqrt (3*elementNorm (calibrationForSet S hmax).generator/L)*Z^(3/16+(23/96)*δ:ℝ) := by + filter_upwards [eventually_original_slot_scales (calibrationForSet S hmax) ell hell hsum + (max 1 b) (le_max_left _ _)] with Z hZ + refine ⟨hZ.1,?_⟩ + have hz : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +def calibrationRowModulus (C : CalibrationData) (B : O) (D : GoodMaskRowData B 1 C.generator) : Id := + 1*Ideal.span {B}*Ideal.span {(72:O)}*Ideal.span {D.numeratorGood} + +def periodicCalibrationXi (C : CalibrationData) (B : O) (D : GoodMaskRowData B 1 C.generator) : O→*ℂ := + C.residueMonoid*actualPeriodicRow 1 B D.numeratorUnit D.numeratorLambda D.numeratorTwo + D.numeratorGood D.numeratorSupported + +lemma calibrationRowModulus_ne_zero (C : CalibrationData) (B : O) (hB : B≠0) + (D : GoodMaskRowData B 1 C.generator) : calibrationRowModulus C B D≠0 := by + unfold calibrationRowModulus + apply mul_ne_zero + · apply mul_ne_zero + · exact mul_ne_zero one_ne_zero (Ideal.span_singleton_eq_bot.not.mpr hB) + · apply Ideal.span_singleton_eq_bot.not.mpr + norm_num + · exact D.numeratorSupported.1 + +lemma periodicCalibrationXi_norm (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (a : O) : ‖periodicCalibrationXi C B D a‖≤1 := by + rw [periodicCalibrationXi,MonoidHom.mul_apply,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (C.residueMonoid_norm_le_one a)).trans (actualPeriodicRow_norm 1 (fun _=>by simp) B D.numeratorUnit D.numeratorLambda D.numeratorTwo + D.numeratorGood D.numeratorSupported a) + +lemma periodicCalibrationXi_periodic (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) : + FactorsModulo (Ideal.span {C.generator}*calibrationRowModulus C B D) (periodicCalibrationXi C B D) := by + have hp := actualPeriodicRow_periodic (1:O→*ℂ) 1 (fun _ _ _=>rfl) + B D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported + intro x y hxy + change C.residueMonoid x*_ = C.residueMonoid y*_ + congr 1 + · apply congrArg C.residue + exact Ideal.Quotient.eq.mpr (Ideal.mul_le_left hxy) + · exact hp x y (Ideal.mul_le_right hxy) + +lemma periodicCalibrationXi_eq_primary (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (hBL : λ₀∣B) (hB2 : (2:O)∣B) + (n : O) (hn : Supported (Ideal.span {n})) (hpn : λ₀^2∣n-1) (hc : IsCoprime B n) : + periodicCalibrationXi C B D n=C.Xi n := by + have he := rowTwist_eq_actualPeriodicRow_primary (1:O→*ℂ) B 1 C.generator hBL hB2 + D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported + D.numeratorPrimary D.numeratorFactor n hpn + rw [rowTwist_extract_sixth_mask _ _ _ _ _ hn] at he + have hmask : coprimalityMask B n=(1:ℂ) := by + change (if IsCoprime B n then (1:ℂ) else 0)=1 + rw [ite_eq_left hc] + simp only [MonoidHom.one_apply,hmask,one_mul,one_pow] at he + change C.residueMonoid n*_ = C.residueMonoid n*idealRowHom C.generator (Ideal.span {n}) + rw [←he] + +def lowPeriodicBase (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (s : O) (hs : Supported (Ideal.span {s})) + (χ : RayCharacter) : O→*ℂ := + rayMonoid χ*targetMonoid η*conjugateMonoid (periodicCalibrationXi C B D)*reciprocityPhaseMonoid s hs + +def lowBaseModulus (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) : Id := + η.modulus*(Ideal.span {C.generator}*calibrationRowModulus C B D)*Ideal.span {(4:O)} + +lemma lowBaseModulus_ne_zero (η : HeckeFamily.Character) (C : CalibrationData) (B : O) (hB : B≠0) + (D : GoodMaskRowData B 1 C.generator) : lowBaseModulus η C B D≠0 := by + unfold lowBaseModulus + apply mul_ne_zero + · exact mul_ne_zero η.modulus_ne_bot (mul_ne_zero (Ideal.span_singleton_eq_bot.not.mpr C.generator_ne_zero) + (calibrationRowModulus_ne_zero C B hB D)) + · apply Ideal.span_singleton_eq_bot.not.mpr + norm_num + +lemma lowPeriodicBase_periodic (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (s : O) (hs : Supported (Ideal.span {s})) (χ : RayCharacter) : + FactorsModulo (lowBaseModulus η C B D) (lowPeriodicBase η C B D s hs χ) := by + intro x y hxy + have h4 : (4:O)∣x-y := Ideal.mem_span_singleton.mp (Ideal.mul_le_right hxy) + have hη : targetMonoid η x=targetMonoid η y := by + apply congrArg η.residue + exact Ideal.Quotient.eq.mpr (Ideal.mul_le_left (Ideal.mul_le_left hxy)) + have hc := periodicCalibrationXi_periodic C B D x y (Ideal.mul_le_right (Ideal.mul_le_left hxy)) + change ((rayMonoid χ x*targetMonoid η x)*star (periodicCalibrationXi C B D x))* + sexticReciprocityPhase s x= + ((rayMonoid χ y*targetMonoid η y)*star (periodicCalibrationXi C B D y))*sexticReciprocityPhase s y + rw [hη,hc,sexticReciprocityPhase_congr_right s x y h4] + have hr : rayMonoid χ x=rayMonoid χ y := rayCharacter_eq_of_mod_four χ x y h4 + rw [hr] + +lemma lowPeriodicBase_norm (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (s : O) (hs : Supported (Ideal.span {s})) + (χ : RayCharacter) (a : O) : ‖lowPeriodicBase η C B D s hs χ a‖≤1 := by + have hr : ‖rayMonoid χ a‖≤1 := FiniteRayExpansion.norm_char_le_one χ _ + change ‖((rayMonoid χ a*targetMonoid η a)*star (periodicCalibrationXi C B D a))*sexticReciprocityPhase s a‖≤1 + simp only [norm_mul,norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) ((mul_le_of_le_one_left (norm_nonneg _) ((mul_le_of_le_one_left (norm_nonneg _) hr).trans (targetMonoid_norm_le_one η a))).trans (periodicCalibrationXi_norm C B D a))).trans (sexticReciprocityPhase_norm s a) + +lemma lowPeriodicBase_eq_primary (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (hBL : λ₀∣B) (hB2 : (2:O)∣B) + (s : O) (hs : Supported (Ideal.span {s})) (χ : RayCharacter) + (n : O) (hn : Supported (Ideal.span {n})) (hpn : λ₀^2∣n-1) (hc : IsCoprime B n) : + lowPeriodicBase η C B D s hs χ n=(rayMonoid χ*physicalRowBase η C.Xi s hs) n := by + change ((rayMonoid χ n*targetMonoid η n)*star (periodicCalibrationXi C B D n))*sexticReciprocityPhase s n= + rayMonoid χ n*((targetMonoid η n*star (C.Xi n))*sexticReciprocityPhase s n) + rw [periodicCalibrationXi_eq_primary C B D hBL hB2 n hn hpn hc] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowPeriodFilter.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowPeriodFilter.lean new file mode 100644 index 0000000000000000000000000000000000000000..142b33a5c1815fec04f586feb6732b6e829d27bd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowPeriodFilter.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Detector.LowPeriodSupport + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma sum_tuple_filter_zero {ι α : Type*} [Fintype ι] [DecidableEq α] + (T : ι→Finset α) (good : ι→α→Prop) [∀i,DecidablePred (good i)] + (c : ι→α→ℂ) (hc : ∀i a,a∈T i→¬good i a→c i a=0) (F : (ι→α)→ℂ) : + (∑p : ∀i,T i,(∏i,c i (p i).val)*F (fun i=>(p i).val))= + ∑p : ∀i,(T i).filter (good i),(∏i,c i (p i).val)*F (fun i=>(p i).val) := by + let forget : (∀i,(T i).filter (good i))→(∀i,T i) := fun p i=>⟨(p i).val,(Finset.mem_filter.mp (p i).property).1⟩ + have hinj : Function.Injective forget := by + intro p q h + funext i + exact Subtype.ext (congrArg (fun a=> (a i).val) h) + let H : (∀i,T i)→ℂ := fun p=>(∏i,c i (p i).val)*F (fun i=>(p i).val) + have hz (p : ∀i,T i) (hp : p∉Finset.univ.image forget) : H p=0 := by + by_contra hh + have hn : ∀i,good i (p i).val := by + intro i + by_contra hbad + have hc0 := hc i (p i).val (p i).property hbad + have hprod : (∏j,c j (p j).val)=0 := Finset.prod_eq_zero (Finset.mem_univ i) hc0 + exact hh (by dsimp [H];rw [hprod,zero_mul]) + let q : ∀i,(T i).filter (good i) := fun i=>⟨(p i).val,Finset.mem_filter.mpr ⟨(p i).property,hn i⟩⟩ + exact hp (Finset.mem_image.mpr ⟨q,Finset.mem_univ _,rfl⟩) + have he := Finset.sum_subset (Finset.subset_univ (Finset.univ.image forget)) + (fun p hp hnot=>hz p hnot) + change (∑p,H p)=_ + rw [←he,Finset.sum_image (fun p _ q _ h=>hinj h)] + +def lowPeriodIdeal (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) : Id := + lowBaseModulus η (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS)*Ideal.span {(72:O)} + +def lowPeriodSlotFilter {ι : Type*} (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : ι→Finset O) : ι→Finset O := + fun i=>(T i).filter (fun a=>IsCoprime (Ideal.span {a}) (lowPeriodIdeal η S hS)) + +lemma lowPeriodSlotFilter_coprime {ι : Type*} (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : ι→Finset O) (i : ι) (a : O) + (ha : a∈lowPeriodSlotFilter η S hS T i) : + IsCoprime (Ideal.span {a}) (lowPeriodIdeal η S hS) := (Finset.mem_filter.mp ha).2 + +lemma canonical_prime_calibration_coprime (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (P : PrimeIdeal) (hP : CanonicalQuadraticSieve.Supported P.val) (hout : P.val∉S) : + IsCoprime (calibrationForSet S hS).generator (CompletedGauss.primaryGenerator P.val) := by + apply calibrationForSet_coprime_of_excluded S hS + intro Q hQ hdiv + rw [span_primaryGenerator_of_supported P.val hP] at hdiv + have hpmax := (Ideal.isPrime_of_prime P.property).isMaximal P.property.ne_zero + have he : P.val=Q := Ideal.IsMaximal.eq_of_le hpmax (hS Q hQ).ne_top (Ideal.dvd_iff_le.mp hdiv) + exact hout (he.symm ▸ hQ) + +lemma canonical_slot_calibration_coprime (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (T : Finset PrimeIdeal) + (hT : ∀P∈T,CanonicalQuadraticSieve.Supported P.val) (hout : ∀P∈T,P.val∉S) + (a : O) (ha : a∈canonicalSlotSupport T) : IsCoprime (calibrationForSet S hS).generator a := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp ha + exact canonical_prime_calibration_coprime S hS P (hT P hP) (hout P hP) + +theorem low_slot_polynomial_period_filter {ι : Type*} [Fintype ι] + (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hbad : CanonicalQuadraticSieve.fixedBadPrimes⊆S) (T : ι→Finset O) + (hcop : ∀i a,a∈T i→IsCoprime (calibrationForSet S hS).generator a) + (W : ι→ℝ→ℂ) (P : ι→ℝ) (t : ℝ) (F : (ι→O)→ℂ) : + (∑p : ∀i,T i,(∏i,lowSingleSlotWeight η (W i) (P i) t (p i).val)*F (fun i=>(p i).val))= + ∑p : ∀i,lowPeriodSlotFilter η S hS T i, + (∏i,lowSingleSlotWeight η (W i) (P i) t (p i).val)*F (fun i=>(p i).val) := by + apply sum_tuple_filter_zero T (fun i a=>IsCoprime (Ideal.span {a}) (lowPeriodIdeal η S hS)) + (fun i a=>lowSingleSlotWeight η (W i) (P i) t a) _ F + intro i a ha hnot + exact lowSingleSlotWeight_zero_of_period η S hS hbad (W i) (P i) t a (hcop i a ha) hnot + +def lowPeriodPrimeList (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : Finset PrimeIdeal) : Finset PrimeIdeal := + T.filter (fun P=>IsCoprime P.val (lowPeriodIdeal η S hS)) + +lemma lowPeriodPrimeList_subset (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : Finset PrimeIdeal) : + lowPeriodPrimeList η S hS T⊆T := Finset.filter_subset _ _ + +lemma lowPeriodPrimeList_coprime (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : Finset PrimeIdeal) + (P : PrimeIdeal) (hP : P∈lowPeriodPrimeList η S hS T) : + IsCoprime P.val (lowPeriodIdeal η S hS) := (Finset.mem_filter.mp hP).2 + +lemma lowPeriodPrimeList_disjoint {ι : Type*} (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (T : ι→Finset PrimeIdeal) + (hT : Pairwise (fun i j=>Disjoint (T i) (T j))) : + Pairwise (fun i j=>Disjoint (lowPeriodPrimeList η S hS (T i)) (lowPeriodPrimeList η S hS (T j))) := by + intro i j hij + exact (hT hij).mono (lowPeriodPrimeList_subset η S hS _) (lowPeriodPrimeList_subset η S hS _) + +theorem low_canonical_polynomial_period_filter {ι : Type*} [Fintype ι] + (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hbad : CanonicalQuadraticSieve.fixedBadPrimes⊆S) (T : ι→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→CanonicalQuadraticSieve.Supported P.val) + (hout : ∀i P,P∈T i→P.val∉S) + (W : ι→ℝ→ℂ) (Y : ι→ℝ) (t : ℝ) (F : (ι→PrimeIdeal)→ℂ) : + (∑p : ∀i,T i,(∏i,lowSingleSlotWeight η (W i) (Y i) t (CompletedGauss.primaryGenerator (p i).val.val))*F (fun i=>(p i).val))= + ∑p : ∀i,lowPeriodPrimeList η S hS (T i), + (∏i,lowSingleSlotWeight η (W i) (Y i) t (CompletedGauss.primaryGenerator (p i).val.val))*F (fun i=>(p i).val) := by + apply sum_tuple_filter_zero T (fun i P=>IsCoprime P.val (lowPeriodIdeal η S hS)) + (fun i P=>lowSingleSlotWeight η (W i) (Y i) t (CompletedGauss.primaryGenerator P.val)) _ F + intro i P hP hnot + apply lowSingleSlotWeight_zero_of_period η S hS hbad (W i) (Y i) t _ + (canonical_prime_calibration_coprime S hS P (hT i P hP) (hout i P hP)) + change ¬IsCoprime (Ideal.span {CompletedGauss.primaryGenerator P.val}) (lowPeriodIdeal η S hS) + rwa [span_primaryGenerator_of_supported P.val (hT i P hP)] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowPeriodSupport.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowPeriodSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..19d0a20e72dd41b5fae42ed51a38ba0c8c9fa630 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowPeriodSupport.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Detector.LowPrimeFamily +import OAI.NumberTheory.DirichletL.Hecke.RowClosure + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CanonicalRowCompletion CanonicalQuadraticSieve CompletedGauss +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +lemma lowCalibrationGood_dvd (C : CalibrationData) + (D : GoodMaskRowData C.generator 1 C.generator) : D.numeratorGood∣C.generator := by + refine ⟨D.numeratorUnit.val*λ₀^D.numeratorLambda*(2:O)^D.numeratorTwo,?_⟩ + have hh := D.numeratorFactor + simp only [one_pow,one_mul] at hh + change C.generator=D.numeratorUnit.val*λ₀^D.numeratorLambda*(2:O)^D.numeratorTwo*D.numeratorGood at hh + exact hh.trans (by ring) + +theorem lowBaseModulus_coprime (η : HeckeFamily.Character) (C : CalibrationData) + (D : GoodMaskRowData C.generator 1 C.generator) + (hLam : λ₀∣C.generator) (h2 : (2:O)∣C.generator) + (n : O) (hcn : IsCoprime C.generator n) (hη : HeckeFamily.elementCoeff η n≠0) : + IsCoprime (Ideal.span {n}) (lowBaseModulus η C C.generator D*Ideal.span {(72:O)}) := by + have heta : IsCoprime (Ideal.span {n}) η.modulus := + (IdealCharacter.isUnit_mk_iff_isCoprime _ _).mp (MulChar.apply_ne_zero_iff.mp hη) + have hcal : IsCoprime (Ideal.span {n}) (Ideal.span {C.generator}) := + (Ideal.isCoprime_span_singleton_iff _ _).mpr hcn.symm + have hgood : IsCoprime (Ideal.span {n}) (Ideal.span {D.numeratorGood}) := + (Ideal.isCoprime_span_singleton_iff _ _).mpr + (hcn.of_isCoprime_of_dvd_left (lowCalibrationGood_dvd C D)).symm + have htwo : IsCoprime n (2:O) := (hcn.of_isCoprime_of_dvd_left h2).symm + have hs := supported_of_coprime_bad C.generator n hLam h2 hcn + have hnine := (ShortDraftCRT.nine_coprime_of_not_lambda_dvd n ((supported_span_iff n).mp hs).1).symm + have hseventy : IsCoprime n (72:O) := by + convert (htwo.pow_right : IsCoprime n ((2:O)^3)).mul_right hnine using 1 ;norm_num + have h72 : IsCoprime (Ideal.span {n}) (Ideal.span {(72:O)}) := + (Ideal.isCoprime_span_singleton_iff _ _).mpr hseventy + have h4 : IsCoprime (Ideal.span {n}) (Ideal.span {(4:O)}) := by + apply (Ideal.isCoprime_span_singleton_iff _ _).mpr + convert htwo.pow_right (n:=2) using 1 ;norm_num + unfold lowBaseModulus calibrationRowModulus + exact (heta.mul_right (hcal.mul_right + (((isCoprime_one_right).mul_right hcal).mul_right h72 |>.mul_right hgood))).mul_right h4 |>.mul_right h72 + +theorem lowSingleSlotWeight_zero_of_period (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (W : ℝ→ℂ) (P t : ℝ) (n : O) (hcn : IsCoprime (calibrationForSet S hS).generator n) + (hperiod : ¬IsCoprime (Ideal.span {n}) + (lowBaseModulus η (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS)*Ideal.span {(72:O)})) : + lowSingleSlotWeight η W P t n=0 := by + have heta : HeckeFamily.elementCoeff η n=0 := by + by_contra hh + exact hperiod (lowBaseModulus_coprime η _ _ (calibration_generator_bad S hS hbad).1 + (calibration_generator_bad S hS hbad).2 n hcn hh) + simp [lowSingleSlotWeight,heta] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowPhysicalInverseBound.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowPhysicalInverseBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..58bc871a18d9baa43d1684209027b8a2ebed87d6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowPhysicalInverseBound.lean @@ -0,0 +1,106 @@ +import OAI.NumberTheory.DirichletL.Detector.LowNominalEnergy +import OAI.NumberTheory.DirichletL.Detector.LowInverseNormalize + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem low_physical_inverse_normalized (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) + (a b aCut bCut ε : ℝ) (ha : 0Disjoint (T i) (T j))→ + (∀i P,P∈T i→a*Z^(ell i)≤(Ideal.absNorm P.val:ℝ) ∧ (Ideal.absNorm P.val:ℝ)≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(p : LowUnselectedTuple (fun i=>canonicalSlotSupport (T i)) J), + ∀X : ℝ,0canonicalSlotSupport (T i)) J W (fun i=>Z^(ell i)) t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t)≤ + C*(1+‖t‖)^degree*Z^(507*ε/2) := by + let q := elementNorm (calibrationForSet S hS).generator + let c := (min 1 a)^K + let B := (max 1 b)^K + have hq : 0canonicalSlotSupport_nonzero _ (hT i) n hn) J p + have hnormE (i : Fin K) (n : O) (hn : n∈canonicalSlotSupport (T i)) : + a*Z^(ell i)≤elementNorm n ∧ elementNorm n≤b*Z^(ell i) := by + obtain ⟨P,hP,rfl⟩ := Finset.mem_image.mp hn + rw [primaryTuple_norm P (hT i P hP)] + exact hnorm i P hP + have hLlo : c*Z^(lowUnselectedLength ell J)≤L := + lowUnselectedProduct_norm_lower ell a Z ha hz _ (fun i n hn=>(hnormE i n hn).1) J p + have hLhi : L≤B*Z^(lowUnselectedLength ell J) := + lowUnselectedProduct_norm_upper_nominal ell b Z hz _ (fun i n hn=>(hnormE i n hn).2) J p + have hQ : 0canonicalSlotSupport (T i)) J W (fun i=>Z^(ell i)) t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) X t + have hrows : ∀z∈R,z≠0 ∧ elementNorm z≤Ck*Z^(5/6-2*lowUnselectedLength ell J) := by + intro z hzR + refine ⟨lowNumeratorRows_nonzero aCut bCut haCut hbCut Q hQ z hzR,?_⟩ + apply (lowNumeratorRows_norm_bound aCut bCut haCut hbCut Q hQ z hzR).trans + have hh := mul_le_mul_of_nonneg_left + (lowPhysicalScale_nominal_bound (calibrationForSet S hS) Z L c (lowUnselectedLength ell J) hz hc hLlo) + (show 0≤2*bCut by positivity) + simpa only [Ck,mul_assoc] using hh + have he (σ : RayRing) : (∑z∈R,‖row σ z‖^2)≤ + C*(1+‖t‖)^degree*Z^(5/6-2*lowUnselectedLength ell J+507*ε) := + hZ.2 T hT hout hdis (fun i P hP=>(hnorm i P hP).2) J R hrows X hX hXlo hXhi W hW (fun i=>Z^(ell i)) t σ + have hn (σ : RayRing) : Real.sqrt (∑z∈R,‖row σ z‖^2)/Real.sqrt Q≤ + Real.sqrt (C*B^2/q)*(1+‖t‖)^degree*Z^(507*ε/2) := by + dsimp only [Q] + rw [lowPhysicalScale_source _ Z L hz] + exact low_inverse_sqrt_normalized q C B Z L (lowUnselectedLength ell J) (507*ε) (1+‖t‖) + (∑z∈R,‖row σ z‖^2) degree hq ZC.le hB.le hz hL (le_add_of_nonneg_right (norm_nonneg t)) + (Finset.sum_nonneg (fun _ _=>sq_nonneg _)) (he σ) hLhi + change (Real.sqrt Q)⁻¹/(2*Real.pi)*(∑σ : RayRing,Real.sqrt (∑z∈R,‖row σ z‖^2))≤_ + calc + _=(∑σ : RayRing,Real.sqrt (∑z∈R,‖row σ z‖^2)/Real.sqrt Q)/(2*Real.pi) := by + rw [←Finset.sum_div] + ring + _≤(∑σ : RayRing,Real.sqrt (C*B^2/q)*(1+‖t‖)^degree*Z^(507*ε/2))/(2*Real.pi) := + div_le_div_of_nonneg_right (Finset.sum_le_sum (fun σ _=>hn σ)) (by positivity) + _≤_ := by + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] + dsimp [C0] + calc + _=((Fintype.card RayRing:ℝ)*Real.sqrt (C*B^2/q)/(2*Real.pi))*(1+|t|)^degree*Z^(507*ε/2) := by ring + _≤_ := by gcongr ; linarith + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowPrimeFamily.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowPrimeFamily.lean new file mode 100644 index 0000000000000000000000000000000000000000..1184d6cf4af019e0be512df9e9528148fb6d7258 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowPrimeFamily.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSlotMarks +import OAI.NumberTheory.DirichletL.Detector.LowSlotWeights +import OAI.NumberTheory.DirichletL.Reflection.Canonical + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve CompletedGauss RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma lowCanonicalSelectedPrime_maximal {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : + (lowCanonicalSelectedPrime T hT J b i).val.IsMaximal := + (Ideal.isPrime_of_prime (lowCanonicalSelectedPrime T hT J b i).property).isMaximal + (lowCanonicalSelectedPrime T hT J b i).property.ne_zero + +lemma lowCanonicalSelectedPrime_good {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : + ConcretePrimeRowBridge.goodLambda∉(lowCanonicalSelectedPrime T hT J b i).val ∧ + ringChar (O⧸(lowCanonicalSelectedPrime T hT J b i).val)≠2 := by + have hs := hT i.val _ (lowCanonicalSelectedPrime_mem T hT J b i) + exact hs.2 _ ((Ideal.mem_normalizedFactors_iff hs.1).mpr + ⟨Ideal.isPrime_of_prime (lowCanonicalSelectedPrime T hT J b i).property,le_rfl⟩) + +def lowCanonicalPrimeFamily {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + InverseReflectedPhase.PrimeFamily (SelectedSlot J) where + ideal i := (lowCanonicalSelectedPrime T hT J b i).val + maximal := lowCanonicalSelectedPrime_maximal T hT J b + good i := (lowCanonicalSelectedPrime_good T hT J b i).1 + +lemma lowCanonicalPrimeFamily_generator {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : + (lowCanonicalPrimeFamily T hT J b).generator i=(b i).val := by + let := lowCanonicalSelectedPrime_maximal T hT J b i + change primaryPrime (lowCanonicalSelectedPrime T hT J b i).val=(b i).val + rw [primaryPrime_eq_primaryGenerator] + have hh := congrArg Subtype.val ((canonicalSlotEquiv (T i.val) (hT i.val)).apply_symm_apply (b i)) + simpa only [canonicalSlotEquiv_val,lowCanonicalSelectedPrime] using hh + +lemma lowCanonicalPrimeFamily_pairwise {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + Pairwise (Function.onFun IsCoprime (lowCanonicalPrimeFamily T hT J b).ideal) := by + intro i j hij + exact primeIdeal_coprime _ _ (fun h=>hij (lowCanonicalSelectedPrime_injective T hT hdis J b h)) + +lemma lowCanonicalPrimeFamily_odd {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : + ringChar (O⧸(lowCanonicalPrimeFamily T hT J b).ideal i)≠2 := + (lowCanonicalSelectedPrime_good T hT J b i).2 + +lemma lowCanonicalPrimeFamily_product {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J b= + ∏i : SelectedSlot J,(lowCanonicalPrimeFamily T hT J b).ideal i := by + rw [lowSelectedIdeal_eq_product] + simp_rw [lowCanonicalSelectedPrime_span T hT J b] + rfl + +theorem lowCanonicalInverseRow_eq {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) + (R t : ℝ) (σ : RayRing) (m : O) : + lowMarkedInverseRow η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J b) R t σ m= + ∑χ : RayCharacter,ProbeCompleted.correctionCoeff χ* + InverseMoment.markedCompletedT + (CanonicalRowCompletion.rowTwist (physicalRayPeriodicBase η S hS σ χ) + (calibrationForSet S hS).generator 1 m) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) R + (fun A=>∏i : SelectedSlot J,if (lowCanonicalPrimeFamily T hT J b).ideal i∣A then (1:ℂ) else 0) := by + unfold lowMarkedInverseRow + have he : (fun A : Id=>if lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J b∣A then (1:ℂ) else 0)= + (fun A : Id=>∏i : SelectedSlot J,if (lowCanonicalPrimeFamily T hT J b).ideal i∣A then (1:ℂ) else 0) := by + funext A + exact lowCanonicalSelected_mark T hT hdis J b A + rw [he] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowPuncture.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowPuncture.lean new file mode 100644 index 0000000000000000000000000000000000000000..9e644ec9384147800db0fdb75f1edc269de5ee2c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowPuncture.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Detector.LowPeriod +import OAI.NumberTheory.DirichletL.Detector.CalibrationSupport + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeRow ProbeCompleted CanonicalRowCompletion CanonicalQuadraticSieve CompletedGauss +open RayFourExpansion InitialMeanSquare SecondPassArithmetic CanonicalCoefficientClass ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +lemma calibration_generator_dvd (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (a : O) (ha : Ideal.span {a}∈S) : a∣(calibrationForSet S hS).generator := by + apply Ideal.span_singleton_dvd_span_singleton_iff_dvd.mp + rw [calibrationForSet_span] + exact Finset.dvd_prod_of_mem (fun P : Id=>P) ha + +lemma calibration_generator_bad (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) : + λ₀∣(calibrationForSet S hS).generator ∧ (2:O)∣(calibrationForSet S hS).generator := by + constructor + · apply calibration_generator_dvd S hS + apply hbad + simp only [fixedBadPrimes,Finset.mem_insert,Finset.mem_singleton] + exact Or.inl rfl + · apply calibration_generator_dvd S hS + apply hbad + simp only [fixedBadPrimes,Finset.mem_insert,Finset.mem_singleton] + exact Or.inr trivial + +lemma supported_of_coprime_bad (B n : O) (hBL : λ₀∣B) (hB2 : (2:O)∣B) + (hc : IsCoprime B n) : Supported (Ideal.span {n}) := by + apply supported_span_iff n |>.mpr + constructor + · exact PrimaryIdealUnitReindex.lambda_prime_actual.irreducible.coprime_iff_not_dvd.mp + (hc.of_isCoprime_of_dvd_left hBL) + · have h2 : IsCoprime (-2:O) n := (hc.of_isCoprime_of_dvd_left hB2).neg_left + have hn := negative_two_prime.irreducible.coprime_iff_not_dvd.mp h2 + simpa only [neg_dvd] using hn + +lemma lowPeriodicBase_zero_of_not_coprime (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (s : O) (hs : Supported (Ideal.span {s})) + (χ : RayCharacter) (n : O) (hc : ¬IsCoprime B n) : lowPeriodicBase η C B D s hs χ n=0 := by + have hm : coprimalityMask B n=(0:ℂ) := by change (if IsCoprime B n then (1:ℂ) else 0)=0;rw [ite_eq_right hc] + change ((rayMonoid χ n*targetMonoid η n)*star (C.residueMonoid n* + ((((1:O→*ℂ) n*coprimalityMask B n)* + numeratorBadTwist D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported n)* + movingNumeratorRow D.numeratorGood D.numeratorSupported n)))*sexticReciprocityPhase s n=0 + rw [hm] + simp only [mul_zero,zero_mul,star_zero] + +lemma lowPeriodicRow_eq_primary (η : HeckeFamily.Character) (C : CalibrationData) (B : O) + (D : GoodMaskRowData B 1 C.generator) (hBL : λ₀∣B) (hB2 : (2:O)∣B) + (s : O) (hs : Supported (Ideal.span {s})) (χ : RayCharacter) (z n : O) (hpn : λ₀^2∣n-1) : + rowTwist (lowPeriodicBase η C B D s hs χ) B 1 z n= + (coprimalityMask B*(rayMonoid χ*rowCoefficient η C.Xi s hs z)) n := by + by_cases hc : IsCoprime B n + · have hn := supported_of_coprime_bad B n hBL hB2 hc + have hm : coprimalityMask B n=(1:ℂ) := by change (if IsCoprime B n then (1:ℂ) else 0)=1;rw [ite_eq_left hc] + rw [rowTwist_extract_sixth_mask _ _ _ _ _ hn,lowPeriodicBase_eq_primary η C B D hBL hB2 s hs χ n hn hpn hc] + simp only [MonoidHom.mul_apply,hm,mul_one,one_pow,one_mul] + change (rayMonoid χ n*((targetMonoid η n*star (C.Xi n))*sexticReciprocityPhase s n))* + idealRowHom z (Ideal.span {n})=rayMonoid χ n* + (((targetMonoid η n*star (C.Xi n))*sexticReciprocityPhase s n)*idealRowHom z (Ideal.span {n})) + ring + · have hm : coprimalityMask B n=(0:ℂ) := by change (if IsCoprime B n then (1:ℂ) else 0)=0;rw [ite_eq_right hc] + change lowPeriodicBase η C B D s hs χ n*idealRowHom (B^6*1^4*z) (Ideal.span {n})= + coprimalityMask B n*(rayMonoid χ n*rowCoefficient η C.Xi s hs z n) + rw [lowPeriodicBase_zero_of_not_coprime η C B D s hs χ n hc,hm,zero_mul,zero_mul] + +lemma calibration_coprime_iff_excluded_span (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (a : O) : + IsCoprime (calibrationForSet S hS).generator a ↔ ∀P∈S,¬P∣Ideal.span {a} := by + rw [calibrationForSet_coprime_iff] + constructor + · intro h P hP hd + exact h P hP (Ideal.dvd_iff_le.mp hd (Ideal.subset_span (by simp))) + · intro h P hP ha + apply h P hP + exact Ideal.dvd_iff_le.mpr (Ideal.span_le.mpr (Set.singleton_subset_iff.mpr ha)) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowRay.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowRay.lean new file mode 100644 index 0000000000000000000000000000000000000000..5873fb85610c3d3965ee3a979c4be13f1dcc1baa --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowRay.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalRows + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow CompletedGauss CanonicalQuadraticSieve CanonicalRowCompletion +open RayFourExpansion CanonicalCoefficientClass +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev PhysicalRayElement := {s : O // Supported (Ideal.span {s})} + +def physicalRay (s : O) : RayRing := Ideal.Quotient.mk (Ideal.span {(4:O)}) s + +def physicalRayRepresentative (σ : RayRing) : PhysicalRayElement := + if h : ∃s : PhysicalRayElement,physicalRay s.val=σ then Classical.choose h + else ⟨1,by + simp [Supported,Ideal.span_singleton_one,←Ideal.one_eq_top] + change (1:Id)≠0 + exact one_ne_zero⟩ + +lemma physicalRayRepresentative_spec (s : PhysicalRayElement) : + physicalRay (physicalRayRepresentative (physicalRay s.val)).val=physicalRay s.val := by + have hh : ∃r : PhysicalRayElement,physicalRay r.val=physicalRay s.val := ⟨s,rfl⟩ + simp only [physicalRayRepresentative,dite_eq_left hh] + exact Classical.choose_spec hh + +lemma rowCoefficient_congr_ray (η : HeckeFamily.Character) (Xi : O→*ℂ) + (s r : PhysicalRayElement) (h : physicalRay s.val=physicalRay r.val) (m : O) : + rowCoefficient η Xi s.val s.property m=rowCoefficient η Xi r.val r.property m := by + apply MonoidHom.ext + intro n + rw [rowCoefficient_apply,rowCoefficient_apply] + have hd : (4:O)∣s.val-r.val := Ideal.mem_span_singleton.mp (Ideal.Quotient.eq.mp h) + have he : sexticReciprocityPhase s.val n=sexticReciprocityPhase r.val n := by + unfold sexticReciprocityPhase + rw [QuadraticGaussRay.residue_eq_of_four_dvd_sub s.val r.val hd] + rw [he] + +def physicalRayRowMonoid (η : HeckeFamily.Character) (C : CalibrationData) + (σ : RayRing) (m : O) : O→*ℂ := + rowCoefficient η C.Xi (physicalRayRepresentative σ).val (physicalRayRepresentative σ).property m + +def physicalIdealRay (s : {I : Id // Supported I}) : RayRing := physicalRay (primaryGenerator s.val) + +lemma physicalRowMonoid_eq_ray (η : HeckeFamily.Character) (C : CalibrationData) (r : PhysicalRowIndex) : + physicalRowMonoid η C r=physicalRayRowMonoid η C (physicalIdealRay r.1) r.2 := by + let s : PhysicalRayElement := + ⟨primaryGenerator r.1.val,(supported_span_primaryGenerator_iff r.1.val).mpr r.1.property⟩ + exact rowCoefficient_congr_ray η C.Xi s (physicalRayRepresentative (physicalRay s.val)) + (physicalRayRepresentative_spec s).symm r.2 + +lemma physicalRayRowMonoid_norm (η : HeckeFamily.Character) (C : CalibrationData) + (σ : RayRing) (m n : O) : ‖physicalRayRowMonoid η C σ m n‖≤1 := + rowCoefficient_norm_le_one η C.Xi C.Xi_norm_le_one _ _ m n + +def physicalRayPeriodicBase (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (χ : RayCharacter) : O→*ℂ := + lowPeriodicBase η (calibrationForSet S hS) (calibrationForSet S hS).generator + (calibrationLowData S hS) (physicalRayRepresentative σ).val + (physicalRayRepresentative σ).property χ + +theorem physicalRayPeriodicBase_uniform (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : + ∃L : Id,L≠0 ∧ ∀σ : RayRing,∀χ : RayCharacter, + FactorsModulo L (physicalRayPeriodicBase η S hS σ χ) ∧ + ∀n : O,‖physicalRayPeriodicBase η S hS σ χ n‖≤1 := by + refine ⟨lowBaseModulus η (calibrationForSet S hS) (calibrationForSet S hS).generator (calibrationLowData S hS), + lowBaseModulus_ne_zero η _ _ (calibrationForSet S hS).generator_ne_zero _,?_⟩ + intro σ χ + exact ⟨lowPeriodicBase_periodic η _ _ _ _ _ χ,lowPeriodicBase_norm η _ _ _ _ _ χ⟩ + +theorem physicalRayRow_eq_periodic_inverse (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (σ : RayRing) (m : O) (D : Id) (W : ℝ→ℂ) (hW : HasCompactSupport W) + (T : ℝ) (hT : 0if D∣A then (1:ℂ) else 0) := + correctedPhysicalRow_eq_periodic_inverse η S hS hbad + (physicalRayRepresentative σ).val (physicalRayRepresentative σ).property m D W hW T hT + (calibrationLowData S hS) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowRayAmplitude.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowRayAmplitude.lean new file mode 100644 index 0000000000000000000000000000000000000000..2998ee5874c1b2dfd3f1fd4940070682645fea45 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowRayAmplitude.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Detector.LowRowMellin + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowRayAmplitude (C : CalibrationData) (W1 : ℝ→ℂ) (Y : ℝ) + (σ : RayRing) (m : O) (v : ℝ) : ℂ := + ∑'s : {I : Id // Supported I},if physicalIdealRay s=σ then lowAdditiveCoefficient C W1 Y s m v else 0 + +lemma lowAdditiveCoefficient_common_support (C : CalibrationData) (W1 : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0s.val) Subtype.val_injective.injOn + refine ⟨ho.toFinset,?_⟩ + intro m v s hs + apply lowAdditiveCoefficient_outer_zero + simpa only [Set.Finite.mem_toFinset,Set.mem_preimage,Function.mem_support,not_not] using hs + +lemma lowAdditiveCoefficient_mul_summable (C : CalibrationData) (W1 : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0lowAdditiveCoefficient C W1 Y s m v*F s) := by + obtain ⟨R,hR⟩ := lowAdditiveCoefficient_common_support C W1 hW1 Y hY + apply summable_of_ne_finset_zero (s:=R) + intro s hs + rw [hR m v s hs,zero_mul] + +lemma lowRayAmplitude_eq_finite (C : CalibrationData) (W1 : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (Y : ℝ) (hY : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma canonicalSlot_count (T : Finset PrimeIdeal) (hT : ∀P∈T,Supported P.val) + (H : ℝ) (hH : 1≤H) (hnorm : ∀P∈T,(Ideal.absNorm P.val:ℝ)≤H) : + ((canonicalSlotSupport T).card:ℝ)≤128*H := by + have hh := DescentFiberCost.finite_ideal_count_real (lowPrimeIdealList T) H hH + (fun I hI=>(lowPrimeIdealList_prime T I hI).ne_zero) (lowPrimeIdealList_norm T H hnorm) + have he := Fintype.card_congr (canonicalSlotEquiv T hT) + simp only [Fintype.card_coe] at he + rw [lowPrimeIdealList,Finset.card_image_of_injective _ Subtype.val_injective,he] at hh + exact hh + +lemma canonicalTuple_count {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) + (hsum : ∑i,ell i≤1/6) (b Z : ℝ) (hZ : 1≤Z) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→Supported P.val) + (hnorm : ∀i P,P∈T i→(Ideal.absNorm P.val:ℝ)≤b*Z^(ell i)) : + (Fintype.card (∀i,canonicalSlotSupport (T i)):ℝ)≤(128*max 1 b)^K*Z^(1/6:ℝ) := by + rw [Fintype.card_pi,Nat.cast_prod] + calc + _≤∏i,128*(max 1 b*Z^(ell i)) := by + apply Finset.prod_le_prod₀ (fun i _=>Nat.cast_nonneg _) + intro i hi + simp only [Fintype.card_coe] + apply canonicalSlot_count _ (hT i) _ + (one_le_mul_of_one_le_of_one_le (le_max_left _ _) (Real.one_le_rpow hZ (hell i))) + intro P hP + exact (hnorm i P hP).trans (mul_le_mul_of_nonneg_right (le_max_right _ _) (by positivity)) + _=(128*max 1 b)^K*Z^(∑i,ell i) := by + simp_rw [←mul_assoc] + rw [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_fin, + ←Real.rpow_sum_of_pos (lt_of_lt_of_le zero_lt_one hZ)] + _≤_ := mul_le_mul_of_nonneg_left (Real.rpow_le_rpow_of_exponent_le hZ hsum) (by positivity) + +lemma slotProduct_norm_ge_one {K : ℕ} (p : Fin K→O) (hp : ∀i,p i≠0) (J : Finset (Fin K)) : + 1≤elementNorm (slotProduct p J) := by + unfold elementNorm + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr (slotProduct_nonzero p hp J))) + +lemma compensationSubsetWeight_norm_le_one {K : ℕ} (η : HeckeFamily.Character) + (W : Fin K→ℝ→ℂ) (hW : ∀i x,‖W i x‖≤1) (Y : Fin K→ℝ) + (p : Fin K→O) (hp : ∀i,p i≠0) (J : Finset (Fin K)) : + ‖compensationSubsetWeight η W Y p J‖≤1 := by + rw [compensationSubsetWeight,norm_mul] + apply (mul_le_of_le_one_left (norm_nonneg _) _).trans _ + · rw [compensationSubsetCoefficient,norm_mul,norm_mul,norm_pow,norm_neg,norm_one,one_pow,one_mul, + Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (Real.rpow_nonneg (slotProduct_norm_pos p hp J).le _),norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) (Real.rpow_le_one_of_one_le_of_nonpos (slotProduct_norm_ge_one p hp J) (by norm_num))).trans (ProbeRow.targetMonoid_norm_le_one η _) + · rw [norm_prod] + exact Finset.prod_le_one₀ (fun _ _=>norm_nonneg _) (fun i _=>hW i _) + +lemma compensation_scale_mass_bound {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) + (b Z : ℝ) (hZ : 1≤Z) (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) + (hnorm : ∀i P,P∈T i→(Ideal.absNorm P.val:ℝ)≤b*Z^(ell i)) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (hW : ∀i x,‖W i x‖≤1) : + gaussianPhysicalScaleMass C (Finset.univ : Finset (∀i,canonicalSlotSupport (T i))) + (fun p=>compensationSubsetWeight η W (fun i=>Z^(ell i)) (fun i=>(p i).val) J) + (fun p=>Z^(17/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J)) + (fun p=>Z^(23/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J)) + (fun i : SelectedSlot J=>W i.val) + (fun p i=>elementNorm (p i.val).val/Z^(ell i.val))≤ + (elementNorm C.generator*(128*max 1 b)^K)*Z := by + have hz : 0Z^(ell i)) (fun i=>(p i).val) J‖* + (∏i : SelectedSlot J,‖W i.val (elementNorm (p i.val).val/Z^(ell i.val))‖)* + lowPhysicalScale C (Z^(17/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J)) + (Z^(23/48:ℝ)/elementNorm (slotProduct (fun i=>(p i).val) J))≤ + elementNorm C.generator*Z^(5/6:ℝ) := by + have hcoeff : ‖compensationSubsetWeight η W (fun i=>Z^(ell i)) (fun i=>(p i).val) J‖* + (∏i : SelectedSlot J,‖W i.val (elementNorm (p i.val).val/Z^(ell i.val))‖)≤1 := (mul_le_of_le_one_left (Finset.prod_nonneg (fun _ _=>norm_nonneg _)) (compensationSubsetWeight_norm_le_one η W hW _ _ (hp p) J)).trans (Finset.prod_le_one₀ (fun _ _=>norm_nonneg _) (fun (i : SelectedSlot J) _=>hW i.val _)) + have hL := slotProduct_norm_ge_one _ (hp p) J + rw [lowPhysicalScale_source C Z _ hz] + apply (mul_le_of_le_one_left (by unfold elementNorm;positivity) hcoeff).trans + exact div_le_self (by unfold elementNorm;positivity) (one_le_pow₀ hL) + unfold gaussianPhysicalScaleMass + apply (Finset.sum_le_sum (fun p _=>hterm p)).trans + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] + have hc := mul_le_mul_of_nonneg_right (canonicalTuple_count ell hell hsum b Z hZ T hT hnorm) + (show 0≤elementNorm C.generator*Z^(5/6:ℝ) by unfold elementNorm;positivity) + apply hc.trans_eq + calc + _=(elementNorm C.generator*(128*max 1 b)^K)*(Z^(1/6:ℝ)*Z^(5/6:ℝ)) := by ring + _=_ := by rw [←Real.rpow_add hz];norm_num + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowRow.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowRow.lean new file mode 100644 index 0000000000000000000000000000000000000000..9584c20ae9c7a63302d00d12845dbf4c864d0a5d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowRow.lean @@ -0,0 +1,68 @@ +import OAI.NumberTheory.DirichletL.Detector.Physical +import OAI.NumberTheory.DirichletL.Descent.Completion + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeRow ProbeCompleted CanonicalRowCompletion CanonicalQuadraticSieve CompletedGauss +open RayFourExpansion InitialMeanSquare SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def physicalRowBase (η : HeckeFamily.Character) (Xi : O→*ℂ) + (s : O) (hs : Supported (Ideal.span {s})) : O→*ℂ := + targetMonoid η*conjugateMonoid Xi*reciprocityPhaseMonoid s hs + +lemma physicalRowBase_norm (η : HeckeFamily.Character) (Xi : O→*ℂ) + (hXi : ∀a,‖Xi a‖≤1) (s : O) (hs : Supported (Ideal.span {s})) (a : O) : + ‖physicalRowBase η Xi s hs a‖≤1 := by + change ‖(targetMonoid η a*star (Xi a))*sexticReciprocityPhase s a‖≤1 + rw [norm_mul,norm_mul,norm_star] + exact (mul_le_of_le_one_left (norm_nonneg _) ((mul_le_of_le_one_left (norm_nonneg _) (targetMonoid_norm_le_one η a)).trans (hXi a))).trans (sexticReciprocityPhase_norm s a) + +lemma ray_rowCoefficient_eq_rowTwist (η : HeckeFamily.Character) (Xi : O→*ℂ) + (s : O) (hs : Supported (Ideal.span {s})) (m f z n : O) (hn : n=m^6*f^4*z) + (χ : RayCharacter) : + rayMonoid χ*rowCoefficient η Xi s hs n= + rowTwist (rayMonoid χ*physicalRowBase η Xi s hs) m f z := by + subst n + ext a + change rayMonoid χ a*((targetMonoid η a*star (Xi a))*sexticReciprocityPhase s a* + idealRowHom (m^6*f^4*z) (Ideal.span {a}))= + (rayMonoid χ a*((targetMonoid η a*star (Xi a))*sexticReciprocityPhase s a))* + idealRowHom (m^6*f^4*z) (Ideal.span {a}) + ring + +def wholeIdealMask (S : Finset Id) (D A : Id) : ℂ := + if D∣A ∧ ∀P∈S,¬P∣A then 1 else 0 + +lemma markedCompletedT_eq_inverse (S : Finset Id) (D : Id) (Ψ : O→*ℂ) + (W : ℝ→ℂ) (hW : HasCompactSupport W) (X : ℝ) (hX : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowAdditiveCoefficient (C : CalibrationData) (W1 : ℝ→ℂ) (Y : ℝ) + (s : {I : Id // Supported I}) (m : O) (v : ℝ) : ℂ := + if ∀P∈C.excluded,¬P∣s.val then + let a := primaryGenerator s.val + let ha := supported_primaryGenerator_ne_zero s.val s.property + let q : ℝ := Ideal.absNorm s.val + (Y:ℂ)⁻¹*W1 (q/Y)*idealRowHom C.generator s.val/(C.tau*C.residueMonoid a)* + ((q/Y:ℝ):ℂ)^(-(1/2:ℂ)+(v:ℂ)*Complex.I)*(Real.sqrt q:ℂ)⁻¹*sexticGauss a ha (-m) + else 0 + +def lowPhysicalScale (C : CalibrationData) (X Y : ℝ) : ℝ := elementNorm C.generator*X*Y + +def lowRowMellinIntegrand (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (X Y : ℝ) (r : PhysicalRowIndex) (v : ℝ) : ℂ := + mellin W0 ((v:ℂ)*Complex.I)*Ω (elementNorm r.2/lowPhysicalScale C X Y)*C.residueMonoid r.2* + ((elementNorm r.2/lowPhysicalScale C X Y:ℝ):ℂ)^(-((v:ℂ)*Complex.I))* + lowAdditiveCoefficient C W1 Y r.1 r.2 v + +lemma calibration_elementNorm_pos (C : CalibrationData) : 0 simp [h] + +lemma lowRowMellinIntegrand_nonzero_form (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (X Y : ℝ) (hY : 0lowRowMellinIntegrand C W0 W1 Ω X Y r v) + simp_rw [lowRowMellinIntegrand_nonzero_form C W0 W1 Ω X Y hY r _ hc] + exact (low_mellin_ratio_integrable W0 a0 b0 ha0 hW0 hWs _ _ + (div_pos hmpos (lowPhysicalScale_pos C X Y hX hY)) (div_pos hq hY)).const_mul _ + · have he : lowRowMellinIntegrand C W0 W1 Ω X Y r=0 := by + funext v + simp [lowRowMellinIntegrand,lowAdditiveCoefficient,hc] + rw [he] + exact integrable_zero _ _ _ + +theorem physicalRowWeight_low_mellin (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0by dsimp only [Ω]; ring) + · simp [physicalRowWeight,lowRowMellinIntegrand,lowAdditiveCoefficient,hc] + +lemma lowAdditiveCoefficient_height (C : CalibrationData) (W1 : ℝ→ℂ) (Y : ℝ) (hY : 0 simp only [mul_zero,zero_mul] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSelectedBound.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSelectedBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..695d81de46038693b9c701d55e81fe43d18d52d2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSelectedBound.lean @@ -0,0 +1,111 @@ +import OAI.NumberTheory.DirichletL.Detector.LowActualReflectedEnergy +import OAI.NumberTheory.DirichletL.Reflection.LowOriginalEnergy + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve CanonicalRowCompletion RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local instance : Fintype Oˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +lemma gaussianFixedWindow_support : Function.support gaussianFixedWindow⊆Set.Icc (1/2:ℝ) 2 := by + intro y hy + constructor + · by_contra h; exact hy (gaussianFixedWindow_small y (le_of_lt (lt_of_not_ge h))) + · by_contra h; exact hy (gaussianFixedWindow_large y (le_of_lt (lt_of_not_ge h))) + +lemma lowReflectionMask_bad_ideals (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) : + ∀P∈fixedBadPrimes,P∣Ideal.span {lowReflectionMask η S hS}*(1:Id) := by + intro P hP + rw [mul_one,lowReflectionMask,←Ideal.span_singleton_mul_span_singleton,calibrationForSet_span] + exact dvd_mul_of_dvd_left (Finset.dvd_prod_of_mem (fun P : Id=>P) (hbad hP)) _ + +theorem low_selected_physical_energy (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (K : ℕ) (Ck ε : ℝ) (hCk : 0Disjoint (T i) (T j))→ + ∀(J : Finset (Fin K))(H : SelectedSlot J→ℝ), + (∀i,1≤H i)→(∀i P,P∈T i.val→(Ideal.absNorm P.val:ℝ)≤H i)→(∏i,H i)≤Z^ell0→ + ∀(W : Fin K→ℝ→ℂ),(∀i x,‖W i x‖≤1)→∀(Y : Fin K→ℝ)(t : ℝ)(σ : RayRing), + (∑z∈R,‖lowSelectedInverseRow Finset.univ + (lowSelectedWeight η (fun i=>canonicalSlotSupport (T i)) J W Y t) + η S hS (lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J) (Z^(1+ell0+shift)) t σ z‖^2)≤ + C*(1+‖t‖)^degree*Z^((5/6-2*d)+507*ε) := by + obtain ⟨degree,C,Z₀,hC,hZ₀,he⟩ := InverseReflectedPhase.low_original_completed_energy + (lowReflectionPeriod η S hS) (lowReflectionPeriod_ne_zero η S hS) + (1:Id) squarefree_one (lowReflectionMask η S hS) (lowReflectionMask_ne_zero η S hS) + (lowReflectionMask_bad η S hS hbad).1 (lowReflectionMask_bad η S hS hbad).2 + (lowReflectionMask_period η S hS) (lowReflectionMask_bad_ideals η S hS hbad) + (1/2) 2 (by norm_num) gaussianFixedWindow gaussianFixedWindow_support gaussianFixedWindow_contDiff + Ck ε hCk hε hε1 K + let C0 := (lowCorrectionEnergy+1)*((Fintype.card RayCharacter:ℝ)+1)*6*C + have hC0 : 0lowPrimeIdealList (lowPeriodPrimeList η S hS (T i.val)) + have hLP (i : SelectedSlot J) : lowPeriodPrimeList η S hS (T i.val)⊆T i.val := Finset.filter_subset _ _ + have hLS (i : SelectedSlot J) : ∀P∈lowPeriodPrimeList η S hS (T i.val),Supported P.val := + fun P hP=>hT i.val P (hLP i hP) + have hlists : Pairwise (fun i j=>Disjoint (L i) (L j)) := + lowPrimeIdealList_disjoint _ (lowPeriodPrimeList_disjoint η S hS _ + (fun i j hij=>hdis (fun h=>hij (Subtype.ext h)))) + have hparents : ∀I∈lowIdealRows R,I≠0 ∧ (Ideal.absNorm I:ℝ)≤Ck*Z^(5/6-2*d) := + fun I hI=>⟨lowIdealRows_nonzero R (fun z hz=>(hR z hz).1) I hI, + lowIdealRows_norm_bound R _ (fun z hz=>(hR z hz).2) I hI⟩ + have hcard : Fintype.card (SelectedSlot J)≤K := by + simpa only [Fintype.card_coe,Finset.card_univ,Fintype.card_fin] using + Finset.card_le_card (Finset.subset_univ (Finset.univ\J)) + have hrow (χ : RayCharacter) (u : Oˣ) : + (∑I∈lowIdealRows R,‖lowActualIdealPolynomial L + (fun i I=>lowSingleSlotWeight η (W i.val) (Y i.val) t (primaryGenerator I)) + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (lowReflectionMask η S hS) + (ConcretePrimeRowBridge.idealGenerator (1:Id)) (u.val*ConcretePrimeRowBridge.idealGenerator I)) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) (Z^(1+ell0+shift))‖^2)≤ + C*(1+‖t‖)^degree*Z^((5/6-2*d)+507*ε) := by + convert he Z d ell0 shift hZ hd hd1 hell hellcap hshift (lowIdealRows R) hparents hcard L H + hlists (fun i=>lowPrimeIdealList_maximal _) + (fun i P hP=>(lowPrimeIdealList_good_odd _ (hLS i) P hP).1) + (fun i=>lowPrimeIdealList_prime _) + (fun i P hP=>(lowPrimeIdealList_good_odd _ (hLS i) P hP).2) + hH1 (fun i=>lowPrimeIdealList_norm _ _ (fun P hP=>hH i P (hLP i hP))) hprod + (physicalRayPeriodicBase η S hS σ χ) (lowReflectionPeriod_actual η S hS σ χ).2 + (lowReflectionPeriod_actual η S hS σ χ).1 u t + (fun i P=>lowSingleSlotWeight η (W i.val) (Y i.val) t (primaryGenerator P.val)) + (fun i P=>low_actual_ideal_weight_bound η (W i.val) (hW i.val) (Y i.val) t P.val) using 1 + apply Finset.sum_congr rfl + intro I hI + congr 2 + unfold lowActualIdealPolynomial + congr 1 + ext p + simp + apply (lowSelectedInverseRow_actual_reflected_energy η S hS hbad T hT hout hdis J W Y + (Z^(1+ell0+shift)) t σ R (fun z hz=>(hR z hz).1)).trans + have hh := Finset.sum_le_sum (fun χ (_ : χ∈(Finset.univ:Finset RayCharacter))=> + Finset.sum_le_sum (fun u (_ : u∈(Finset.univ:Finset Oˣ))=>hrow χ u)) + have hm := mul_le_mul_of_nonneg_left hh lowCorrectionEnergy_nonneg + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,low_unit_card] at hm + simp only [Nat.cast_ofNat,Real.norm_eq_abs] at hm ⊢ + apply hm.trans + dsimp [C0] + have hc0 := lowCorrectionEnergy_nonneg + have hcount : 0≤(Fintype.card RayCharacter:ℝ) := Nat.cast_nonneg _ + have hzpos : 0≤Z^((5/6-2*d)+507*ε) := Real.rpow_nonneg (le_trans zero_le_one (hZ₀.le.trans hZ)) _ + have htpos : 0≤(1+|t|)^degree := by positivity + calc + _=(lowCorrectionEnergy*(Fintype.card RayCharacter:ℝ)*6*C)*(1+|t|)^degree* + Z^((5/6-2*d)+507*ε) := by ring + _≤_ := by gcongr <;> linarith + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSelectedSum.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSelectedSum.lean new file mode 100644 index 0000000000000000000000000000000000000000..a54eb9ec6a5beb0db57ce9baa658718aab808af1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSelectedSum.lean @@ -0,0 +1,71 @@ +import OAI.NumberTheory.DirichletL.Detector.LowCompensation + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma lowSeparatedIntegrand_finite_sum {α : Type*} (F : Finset α) (c : α→ℂ) + (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) (hW1 : HasCompactSupport W1) (hΩ : HasCompactSupport Ω) + (X Y : ℝ) (hX : 0∑k∈F,c k*B k σ m) v := by + simp_rw [←lowSeparatedIntegrand_eq C W0 W1 Ω hW1 hΩ X Y hX hY] + simp_rw [←tsum_mul_left] + rw [←Summable.tsum_finsetSum (fun k _=> + (lowRowMellinIntegrand_mul_summable C W0 W1 Ω hW1 hΩ X Y hX hY v + (fun r=>B k (physicalIdealRay r.1) r.2)).mul_left (c k))] + apply tsum_congr + intro r + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro k hk + ring + +lemma lowSeparatedIntegral_finite_sum {α : Type*} (F : Finset α) (c : α→ℂ) + (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (a0 b0 : ℝ) (ha0 : 0∑k∈F,c k*B k σ m) v := by + simp_rw [←integral_const_mul] + rw [←integral_finsetSum F (fun k _=>(lowSeparatedIntegrand_integrable C W0 W1 Ω + a0 b0 ha0 hW0 hWs hW1 hΩ hΩ0 X Y hX hY (B k)).const_mul (c k))] + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun v=>lowSeparatedIntegrand_finite_sum F c C W0 W1 Ω hW1 hΩ X Y hX hY B v) + +def lowSelectedInverseRow {α : Type*} (F : Finset α) (c : α→ℂ) + (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (D : α→Id) (T t : ℝ) (σ : RayRing) (m : O) : ℂ := + ∑k∈F,c k*lowMarkedInverseRow η S hS (D k) T t σ m + +lemma lowSelectedInverseRow_correction {α : Type*} (F : Finset α) (c : α→ℂ) + (η : HeckeFamily.Character) (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (D : α→Id) (T t : ℝ) (σ : RayRing) (m : O) : + lowSelectedInverseRow F c η S hS D T t σ m= + ∑χ : RayCharacter,ProbeCompleted.correctionCoeff χ* + ∑k∈F,c k*InverseMoment.markedCompletedT + (CanonicalRowCompletion.rowTwist (physicalRayPeriodicBase η S hS σ χ) + (calibrationForSet S hS).generator 1 m) + (CompletedHeight.normTwistedSource gaussianFixedWindow t) T + (fun A=>if D k∣A then (1:ℂ) else 0) := by + unfold lowSelectedInverseRow lowMarkedInverseRow + simp only [Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro χ hχ + apply Finset.sum_congr rfl + intro k hk + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSeparated.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSeparated.lean new file mode 100644 index 0000000000000000000000000000000000000000..a6f7aab556b30edd188915bf227a5b140c4265f2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSeparated.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Detector.LowMellinFubini +import OAI.NumberTheory.DirichletL.Detector.LowRayAmplitude + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion ProbeCompleted +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowSeparatedIntegrand (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (X Y : ℝ) (B : RayRing→O→ℂ) (v : ℝ) : ℂ := + mellin W0 ((v:ℂ)*Complex.I)* + ∑'m : O,Ω (elementNorm m/lowPhysicalScale C X Y)*C.residueMonoid m* + ((elementNorm m/lowPhysicalScale C X Y:ℝ):ℂ)^(-((v:ℂ)*Complex.I))* + ∑σ : RayRing,lowRayAmplitude C W1 Y σ m v*B σ m + +lemma lowSeparatedIntegrand_eq (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (hW1 : HasCompactSupport W1) (hΩ : HasCompactSupport Ω) + (X Y : ℝ) (hX : 0B (physicalIdealRay r.1) r.2) + rw [hs.tsum_prod,←hs.tsum_comm] + unfold lowSeparatedIntegrand + rw [←tsum_mul_left] + apply tsum_congr + intro m + rw [←lowRayAmplitude_group C W1 hW1 Y hY m v (fun σ=>B σ m)] + repeat rw [←tsum_mul_left] + apply tsum_congr + intro s + unfold lowRowMellinIntegrand + ring + +lemma lowSeparatedIntegrand_integrable (C : CalibrationData) (W0 W1 Ω : ℝ→ℂ) + (a0 b0 : ℝ) (ha0 : 0B (physicalIdealRay r.1) r.2) + simpa only [lowSeparatedIntegrand_eq C W0 W1 Ω hW1 hΩ X Y hX hY B] using hh + +theorem physicalRowWeight_low_separated (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0correctedCompletedT C.excluded D (physicalRayRowMonoid η C σ m) gaussianCompletedProfile Z) v := by + have hW0c : HasCompactSupport W0 := HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW0 + have hW1c : HasCompactSupport W1 := HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW1 + rw [markedPhysicalProbe_eq_gaussian_rows η C D W0 W1 hW0c hW1c X Y Z hX hY hZ] + simp_rw [physicalRowMonoid_eq_ray] + exact physicalRowWeight_low_separated C W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 hWs X Y hX hY + (fun σ m=>correctedCompletedT C.excluded D (physicalRayRowMonoid η C σ m) gaussianCompletedProfile Z) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotMarks.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotMarks.lean new file mode 100644 index 0000000000000000000000000000000000000000..4dbdd321565d5bc171f5766608a367d2ee1da15a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotMarks.lean @@ -0,0 +1,90 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSlotPolynomial +import OAI.NumberTheory.DirichletL.Detector.CanonicalSlots + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma lowSelectedIdeal_eq_product {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (b : LowSelectedTuple slots J) : + lowSelectedIdeal slots J b=∏i : SelectedSlot J,Ideal.span {(b i).val} := by + change CanonicalRowCompletion.principalIdealHom (∏i : SelectedSlot J,(b i).val)=_ + exact map_prod CanonicalRowCompletion.principalIdealHom _ _ + +lemma lowSelectedIdeal_dvd_iff {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (b : LowSelectedTuple slots J) + (hcop : Pairwise (fun i j : SelectedSlot J=>IsCoprime (Ideal.span {(b i).val}) (Ideal.span {(b j).val}))) + (A : Id) : lowSelectedIdeal slots J b∣A ↔ ∀i : SelectedSlot J,Ideal.span {(b i).val}∣A := by + rw [lowSelectedIdeal_eq_product] + constructor + · intro h i + exact (Finset.dvd_prod_of_mem (fun i : SelectedSlot J=>Ideal.span {(b i).val}) (Finset.mem_univ i)).trans h + · exact Fintype.prod_dvd_of_coprime hcop + +lemma lowSelectedIdeal_mark {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (b : LowSelectedTuple slots J) + (hcop : Pairwise (fun i j : SelectedSlot J=>IsCoprime (Ideal.span {(b i).val}) (Ideal.span {(b j).val}))) + (A : Id) : + (if lowSelectedIdeal slots J b∣A then (1:ℂ) else 0)= + ∏i : SelectedSlot J,if Ideal.span {(b i).val}∣A then (1:ℂ) else 0 := by + rw [lowSelectedIdeal_dvd_iff slots J b hcop] + by_cases h : ∀i : SelectedSlot J,Ideal.span {(b i).val}∣A + · simp [h] + · obtain ⟨i,hi⟩ := not_forall.mp h + rw [ite_eq_right (fun hall=>hi (hall i))] + exact (Finset.prod_eq_zero (Finset.mem_univ i) (ite_eq_right hi)).symm + +def lowCanonicalSelectedPrime {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : PrimeIdeal := + ((canonicalSlotEquiv (T i.val) (hT i.val)).symm (b i)).val + +lemma lowCanonicalSelectedPrime_mem {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : + lowCanonicalSelectedPrime T hT J b i∈T i.val := + ((canonicalSlotEquiv (T i.val) (hT i.val)).symm (b i)).property + +lemma lowCanonicalSelectedPrime_span {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (J : Finset (Fin K)) + (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (i : SelectedSlot J) : + Ideal.span {(b i).val}=(lowCanonicalSelectedPrime T hT J b i).val := by + have hh := canonicalSlotEquiv_span (T i.val) (hT i.val) + ((canonicalSlotEquiv (T i.val) (hT i.val)).symm (b i)) + simpa only [Equiv.apply_symm_apply,lowCanonicalSelectedPrime] using hh + +lemma lowCanonicalSelectedPrime_injective {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + Function.Injective (lowCanonicalSelectedPrime T hT J b) := by + intro i j hij + apply Subtype.ext + by_contra hne + exact Finset.disjoint_left.mp (hdis hne) (lowCanonicalSelectedPrime_mem T hT J b i) + (hij.symm ▸ lowCanonicalSelectedPrime_mem T hT J b j) + +lemma lowCanonicalSelected_coprime {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) : + Pairwise (fun i j : SelectedSlot J=>IsCoprime (Ideal.span {(b i).val}) (Ideal.span {(b j).val})) := by + intro i j hij + rw [lowCanonicalSelectedPrime_span T hT J b i,lowCanonicalSelectedPrime_span T hT J b j] + exact primeIdeal_coprime _ _ (fun h=>hij (lowCanonicalSelectedPrime_injective T hT hdis J b h)) + +theorem lowCanonicalSelected_mark {K : ℕ} (T : Fin K→Finset PrimeIdeal) + (hT : ∀i P,P∈T i→Supported P.val) (hdis : Pairwise (fun i j=>Disjoint (T i) (T j))) + (J : Finset (Fin K)) (b : LowSelectedTuple (fun i=>canonicalSlotSupport (T i)) J) (A : Id) : + (if lowSelectedIdeal (fun i=>canonicalSlotSupport (T i)) J b∣A then (1:ℂ) else 0)= + ∏i : SelectedSlot J,if (lowCanonicalSelectedPrime T hT J b i).val∣A then (1:ℂ) else 0 := by + rw [lowSelectedIdeal_mark _ J b (lowCanonicalSelected_coprime T hT hdis J b)] + simp_rw [lowCanonicalSelectedPrime_span T hT J b] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotPolynomial.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotPolynomial.lean new file mode 100644 index 0000000000000000000000000000000000000000..b1dcb5a1e51afad1d39ccd91fa58a764e39629ba --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotPolynomial.lean @@ -0,0 +1,123 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSlotSplit + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowUnselectedWeight {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (a : LowUnselectedTuple slots J) : ℂ := + (-1:ℂ)^J.card*((elementNorm (∏i : J,(a i).val)^(-(3/2:ℝ)):ℝ):ℂ)* + ∏i : J,W i.val (elementNorm (a i).val/P i.val) + +def lowSelectedWeight {K : ℕ} (η : HeckeFamily.Character) (slots : Fin K→Finset O) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (t : ℝ) + (b : LowSelectedTuple slots J) : ℂ := + star (HeckeFamily.elementCoeff η (∏i : SelectedSlot J,(b i).val))* + ∏i : SelectedSlot J,W i.val (elementNorm (b i).val/P i.val)* + FourierBridge.logPhase (-t) (Real.log (elementNorm (b i).val/P i.val)) + +def lowSelectedIdeal {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (b : LowSelectedTuple slots J) : Id := Ideal.span {∏i : SelectedSlot J,(b i).val} + +lemma lowSlotJoin_weight {K : ℕ} (η : HeckeFamily.Character) (slots : Fin K→Finset O) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (t : ℝ) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) : + compensationSubsetWeight η W P (lowSlotJoin slots J a b) J* + selectedSlotFactor W P (lowSlotJoin slots J a b) J t= + lowUnselectedWeight slots J W P a*lowSelectedWeight η slots J W P t b := by + unfold compensationSubsetWeight compensationSubsetCoefficient + rw [lowSlotJoin_unselectedProduct,lowSlotJoin_selectedProduct,lowSlotJoin_selectedFactor] + rw [←Finset.prod_coe_sort J (fun i=>W i (elementNorm (lowSlotJoin slots J a b i)/P i))] + simp only [lowSlotJoin_unselected] + unfold lowUnselectedWeight lowSelectedWeight + ring + +lemma lowUnselectedProduct_norm_pos {K : ℕ} (slots : Fin K→Finset O) + (hslots : ∀i x,x∈slots i→x≠0) (J : Finset (Fin K)) (a : LowUnselectedTuple slots J) : + 0hslots i.val _ (a i).property) + +lemma compensationRowTest_join_low {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (W0 W1 : ℝ→ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0(p i).val) J* + compensationRowTest η (calibrationForSet S hS) W0 W1 (fun i=>(p i).val) J X Y T t* + selectedSlotFactor W P (fun i=>(p i).val) J t)= + ∑a : LowUnselectedTuple slots J,lowUnselectedWeight slots J W P a* + ((Real.sqrt (lowPhysicalScale (calibrationForSet S hS) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val))):ℂ)⁻¹*(1/(2*Real.pi):ℂ))* + ∫v : ℝ,lowSeparatedIntegrand (calibrationForSet S hS) W0 W1 + (lowOuterCutoff (a0*a1) (max 1 (b0*b1))) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val)) + (lowSelectedInverseRow Finset.univ (lowSelectedWeight η slots J W P t) + η S hS (lowSelectedIdeal slots J) T t) v := by + rw [sum_lowSlotJoin slots J (fun p=>compensationSubsetWeight η W P p J* + compensationRowTest η (calibrationForSet S hS) W0 W1 p J X Y T t*selectedSlotFactor W P p J t)] + apply Finset.sum_congr rfl + intro a ha + let L := elementNorm (∏i : J,(a i).val) + have hL : 0 ActualEisensteinCubic.O + +lemma elementNorm_finset_prod {ι : Type*} (F : Finset ι) (p : ι→O) : + elementNorm (∏i∈F,p i)=∏i∈F,elementNorm (p i) := by + induction F using Finset.induction_on with + | empty => simp [elementNorm_one] + | @insert i F hi ih => simp only [Finset.prod_insert hi,elementNorm_mul,ih] + +lemma lowUnselectedProduct_norm_ge_one {K : ℕ} (slots : Fin K→Finset O) + (hslots : ∀i x,x∈slots i→x≠0) (J : Finset (Fin K)) (a : LowUnselectedTuple slots J) : + 1≤elementNorm (∏i : J,(a i).val) := by + have hn : (∏i : J,(a i).val)≠0 := Finset.prod_ne_zero_iff.mpr (fun i _=>hslots i.val _ (a i).property) + unfold elementNorm + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hn)) + +lemma lowUnselectedProduct_norm_bound {K : ℕ} (ell : Fin K→ℝ) + (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) + (b Z : ℝ) (hb : 1≤b) (hZ : 1≤Z) (slots : Fin K→Finset O) + (hslots : ∀i x,x∈slots i→elementNorm x≤b*Z^(ell i)) + (J : Finset (Fin K)) (a : LowUnselectedTuple slots J) : + elementNorm (∏i : J,(a i).val)≤b^K*Z^(1/6:ℝ) := by + have hz : 0hell i)).trans hsum + have hc : J.card≤K := by simpa using Finset.card_le_card (Finset.subset_univ J) + rw [elementNorm_finset_prod] + calc + _≤∏i : J,b*Z^(ell i.val) := Finset.prod_le_prod₀ (fun _ _=>by unfold elementNorm;positivity) + (fun i _=>hslots i.val _ (a i).property) + _=b^J.card*Z^(∑i∈J,ell i) := by + rw [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_coe, + ←Real.rpow_sum_of_pos hz,Finset.sum_coe_sort] + _≤b^K*Z^(1/6:ℝ) := mul_le_mul (pow_le_pow_right₀ hb hc) + (Real.rpow_le_rpow_of_exponent_le hZ hsub) (by positivity) (by positivity) + +theorem eventually_original_slot_scales {K : ℕ} (C : CalibrationData) (ell : Fin K→ℝ) + (hell : ∀i,0≤ell i) (hsum : ∑i,ell i≤1/6) (b : ℝ) (hb : 1≤b) : + ∀ᶠ Z : ℝ in Filter.atTop,1≤Z ∧ + ∀(slots : Fin K→Finset O)(_hslots : ∀i x,x∈slots i→x≠0), + (∀i x,x∈slots i→elementNorm x≤b*Z^(ell i))→ + ∀(J : Finset (Fin K))(a : LowUnselectedTuple slots J), + let L := elementNorm (∏i : J,(a i).val) + 1≤Z^(23/48:ℝ)/L ∧ + 1≤(Z^(23/48:ℝ)/L)^2/lowPhysicalScale C (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) ∧ + ∀δ : ℝ,0≤δ→lowGramFactor C (Z^(17/48:ℝ)/L) (Z^(23/48:ℝ)/L) δ≤ + Real.sqrt (3*elementNorm C.generator/L)*Z^(3/16+(23/96)*δ:ℝ) := by + filter_upwards [eventually_compensated_source_scales C (b^K)] with Z hZ + refine ⟨hZ.1,?_⟩ + intro slots hslots hnorm J a + exact hZ.2.2 _ (lowUnselectedProduct_norm_ge_one slots hslots J a) + (lowUnselectedProduct_norm_bound ell hell hsum b Z hb hZ.1 slots hnorm J a) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotSplit.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotSplit.lean new file mode 100644 index 0000000000000000000000000000000000000000..8c8fe01a1b3fffe3b06839c2befc2ddae39a2c9b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotSplit.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSelectedSum + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +local notation "O" => ActualEisensteinCubic.O + +abbrev LowUnselectedTuple {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) := + ∀i : J,↥(slots i.val) +abbrev LowSelectedTuple {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) := + ∀i : SelectedSlot J,↥(slots i.val) + +def lowSlotTupleEquiv {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) : + (∀i,↥(slots i)) ≃ LowUnselectedTuple slots J×LowSelectedTuple slots J where + toFun p := (fun i=>p i.val,fun i=>p i.val) + invFun p i := if hi : i∈J then p.1 ⟨i,hi⟩ else p.2 ⟨i,by simp [hi]⟩ + left_inv p := by + funext i + dsimp only + split_ifs <;> rfl + right_inv p := by + apply Prod.ext + · funext i + simp only [dite_eq_left i.property] + · funext i + have hi : i.val∉J := (Finset.mem_sdiff.mp i.property).2 + simp only [dite_eq_right hi] + +def lowSlotJoin {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) : Fin K→O := + fun i=>((lowSlotTupleEquiv slots J).symm (a,b) i).val + +lemma lowSlotJoin_nonzero {K : ℕ} (slots : Fin K→Finset O) + (hslots : ∀i x,x∈slots i→x≠0) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) (i : Fin K) : + lowSlotJoin slots J a b i≠0 := hslots i _ ((lowSlotTupleEquiv slots J).symm (a,b) i).property + +lemma lowSlotJoin_unselected {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) (i : J) : + lowSlotJoin slots J a b i.val=(a i).val := by + simp only [lowSlotJoin,lowSlotTupleEquiv,Equiv.coe_fn_symm_mk,dite_eq_left i.property] + +lemma lowSlotJoin_selected {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) (i : SelectedSlot J) : + lowSlotJoin slots J a b i.val=(b i).val := by + have hi : i.val∉J := (Finset.mem_sdiff.mp i.property).2 + simp only [lowSlotJoin,lowSlotTupleEquiv,Equiv.coe_fn_symm_mk,dite_eq_right hi] + +lemma lowSlotJoin_unselectedProduct {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) : + slotProduct (lowSlotJoin slots J a b) J=∏i : J,(a i).val := by + unfold slotProduct + rw [←Finset.prod_coe_sort J] + simp only [lowSlotJoin_unselected] + +lemma lowSlotJoin_selectedProduct {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) : + slotProduct (lowSlotJoin slots J a b) (Finset.univ\J)=∏i : SelectedSlot J,(b i).val := by + unfold slotProduct + rw [←Finset.prod_coe_sort (Finset.univ\J)] + simp only [lowSlotJoin_selected] + +lemma lowSlotJoin_selectedFactor {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (a : LowUnselectedTuple slots J) (b : LowSelectedTuple slots J) + (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (t : ℝ) : + selectedSlotFactor W P (lowSlotJoin slots J a b) J t= + ∏i : SelectedSlot J,W i.val (elementNorm (b i).val/P i.val)* + FourierBridge.logPhase (-t) (Real.log (elementNorm (b i).val/P i.val)) := by + unfold selectedSlotFactor + simp only [lowSlotJoin_selected] + +theorem sum_lowSlotJoin {K : ℕ} (slots : Fin K→Finset O) (J : Finset (Fin K)) + (F : (Fin K→O)→ℂ) : + (∑p : (∀i,↥(slots i)),F (fun i=>(p i).val))= + ∑a : LowUnselectedTuple slots J,∑b : LowSelectedTuple slots J,F (lowSlotJoin slots J a b) := by + calc + _ = ∑p : LowUnselectedTuple slots J×LowSelectedTuple slots J,F (lowSlotJoin slots J p.1 p.2) := + (Equiv.sum_comp (lowSlotTupleEquiv slots J).symm (fun p=>F (fun i=>(p i).val))).symm + _ = _ := Fintype.sum_prod_type _ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotWeights.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..e4eb47739d81fd4f6df1c8ca91eefa0b20ac6530 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSlotWeights.lean @@ -0,0 +1,58 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSlotPolynomial + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeRow FourierBridge +local notation "O" => ActualEisensteinCubic.O + +def lowSingleSlotWeight (η : HeckeFamily.Character) (W : ℝ→ℂ) (P t : ℝ) (a : O) : ℂ := + star (HeckeFamily.elementCoeff η a)*W (elementNorm a/P)*logPhase (-t) (Real.log (elementNorm a/P)) + +lemma lowSelectedWeight_eq_product {K : ℕ} (η : HeckeFamily.Character) (slots : Fin K→Finset O) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (t : ℝ) + (b : LowSelectedTuple slots J) : + lowSelectedWeight η slots J W P t b= + ∏i : SelectedSlot J,lowSingleSlotWeight η (W i.val) (P i.val) t (b i).val := by + have he : HeckeFamily.elementCoeff η (∏i : SelectedSlot J,(b i).val)= + ∏i : SelectedSlot J,HeckeFamily.elementCoeff η (b i).val := map_prod (targetMonoid η) _ _ + unfold lowSelectedWeight lowSingleSlotWeight + rw [he,star_prod] + simp only [Finset.prod_mul_distrib,mul_assoc] + +lemma lowSingleSlotWeight_norm (η : HeckeFamily.Character) (W : ℝ→ℂ) (P t : ℝ) (a : O) : + ‖lowSingleSlotWeight η W P t a‖≤‖W (elementNorm a/P)‖ := by + rw [lowSingleSlotWeight,norm_mul,norm_mul,norm_star,logPhase_norm,mul_one] + exact mul_le_of_le_one_left (norm_nonneg _) (targetMonoid_norm_le_one η a) + +lemma lowSingleSlotWeight_height_norm (η : HeckeFamily.Character) (W : ℝ→ℂ) (P t : ℝ) (a : O) : + ‖lowSingleSlotWeight η W P t a‖=‖lowSingleSlotWeight η W P 0 a‖ := by + simp only [lowSingleSlotWeight,norm_mul,logPhase_norm,mul_one] + +lemma lowSelectedWeight_norm {K : ℕ} (η : HeckeFamily.Character) (slots : Fin K→Finset O) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (t : ℝ) + (b : LowSelectedTuple slots J) : + ‖lowSelectedWeight η slots J W P t b‖≤∏i : SelectedSlot J,‖W i.val (elementNorm (b i).val/P i.val)‖ := by + rw [lowSelectedWeight_eq_product,norm_prod] + exact Finset.prod_le_prod₀ (fun _ _=>norm_nonneg _) (fun i _=>lowSingleSlotWeight_norm η (W i.val) (P i.val) t (b i).val) + +lemma lowSelectedWeight_height_norm {K : ℕ} (η : HeckeFamily.Character) (slots : Fin K→Finset O) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) (t : ℝ) + (b : LowSelectedTuple slots J) : + ‖lowSelectedWeight η slots J W P t b‖=‖lowSelectedWeight η slots J W P 0 b‖ := by + rw [lowSelectedWeight_eq_product,lowSelectedWeight_eq_product,norm_prod,norm_prod] + exact Finset.prod_congr rfl (fun i _=>lowSingleSlotWeight_height_norm η (W i.val) (P i.val) t (b i).val) + +lemma lowSelectedWeight_norm_le_one {K : ℕ} (η : HeckeFamily.Character) (slots : Fin K→Finset O) + (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) + (hW : ∀i x,‖W i x‖≤1) (t : ℝ) (b : LowSelectedTuple slots J) : + ‖lowSelectedWeight η slots J W P t b‖≤1 := + (lowSelectedWeight_norm η slots J W P t b).trans + (Finset.prod_le_one₀ (fun _ _=>norm_nonneg _) (fun i _=>hW i.val _)) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowSourceScales.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowSourceScales.lean new file mode 100644 index 0000000000000000000000000000000000000000..a8daf50139b43d07facdb1bcce19f0404a42cfdb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowSourceScales.lean @@ -0,0 +1,108 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramScale +import OAI.NumberTheory.DirichletL.Detector.LowTupleGram +import OAI.NumberTheory.DirichletL.Detector.PhysicalCrudeMass + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical + +lemma source_scale_ratio (Z : ℝ) (hZ : 0lowGramFactor_source_bound C Z L δ hZ hL hq hLl hδ⟩ + rw [lowPhysicalScale,compensated_gram_ratio _ _ _ _ (calibration_elementNorm_pos C) + (by positivity) (by positivity) hl] + exact (le_div_iff₀ (mul_pos (calibration_elementNorm_pos C) (by positivity))).mpr (by simpa using hp) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowTruePeriodPuncture.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowTruePeriodPuncture.lean new file mode 100644 index 0000000000000000000000000000000000000000..7b77da5ecb4b9849ca47163d57386615e59582e5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowTruePeriodPuncture.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Detector.LowPeriodFilter +import OAI.NumberTheory.DirichletL.Reflection.PunctureAbsorption + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CanonicalRowCompletion CanonicalQuadraticSieve CompletedGauss RayFourExpansion SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma physicalRayPeriodicBase_support (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) (σ : RayRing) (χ : RayCharacter) + (n : O) (hn : physicalRayPeriodicBase η S hS σ χ n≠0) : + IsCoprime (Ideal.span {n}) (lowPeriodIdeal η S hS) := by + let C := calibrationForSet S hS + let D := calibrationLowData S hS + change ((rayMonoid χ n*HeckeFamily.elementCoeff η n)* + star (C.residueMonoid n*CanonicalRowCompletion.actualPeriodicRow 1 C.generator + D.numeratorUnit D.numeratorLambda D.numeratorTwo D.numeratorGood D.numeratorSupported n))* + _≠0 at hn + have ha := left_ne_zero_of_mul hn + have heta := right_ne_zero_of_mul (left_ne_zero_of_mul ha) + have hres := left_ne_zero_of_mul (star_ne_zero.mp (right_ne_zero_of_mul ha)) + have hc : IsCoprime C.generator n := by + apply (Ideal.isCoprime_span_singleton_iff _ _).mp + exact ((IdealCharacter.isUnit_mk_iff_isCoprime _ _).mp + (C.residue.apply_ne_zero_iff.mp hres)).symm + exact lowBaseModulus_coprime η C D (calibration_generator_bad S hS hbad).1 + (calibration_generator_bad S hS hbad).2 n hc heta + +def lowTruePeriodGenerator (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : O := ConcretePrimeRowBridge.idealGenerator (lowPeriodIdeal η S hS) + +lemma lowPeriodIdeal_ne_zero (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : lowPeriodIdeal η S hS≠0 := by + unfold lowPeriodIdeal + apply mul_ne_zero + · exact lowBaseModulus_ne_zero η _ _ (calibrationForSet S hS).generator_ne_zero _ + · apply Ideal.span_singleton_eq_bot.not.mpr + norm_num + +lemma lowTruePeriodGenerator_ne_zero (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : lowTruePeriodGenerator η S hS≠0 := + ConcretePrimeRowBridge.idealGenerator_ne_zero _ (lowPeriodIdeal_ne_zero η S hS) + +lemma lowTruePeriodGenerator_span (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : Ideal.span {lowTruePeriodGenerator η S hS}=lowPeriodIdeal η S hS := + ConcretePrimeRowBridge.span_idealGenerator _ + +lemma physicalRayPeriodicBase_zero_true_puncture (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) (σ : RayRing) (χ : RayCharacter) + (n : O) (hn : ¬IsCoprime (lowTruePeriodGenerator η S hS) n) : + physicalRayPeriodicBase η S hS σ χ n=0 := by + by_contra hh + apply hn + apply (Ideal.isCoprime_span_singleton_iff _ _).mp + rw [lowTruePeriodGenerator_span] + exact (physicalRayPeriodicBase_support η S hS hbad σ χ n hh).symm + +theorem physical_row_absorb_true_period (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) (σ : RayRing) (χ : RayCharacter) + (f z : O) : + rowTwist (physicalRayPeriodicBase η S hS σ χ) + ((calibrationForSet S hS).generator*lowTruePeriodGenerator η S hS) f z= + rowTwist (physicalRayPeriodicBase η S hS σ χ) (calibrationForSet S hS).generator f z := by + exact InverseReflectedPhase.rowTwist_absorb_puncture _ _ _ f z + (calibration_generator_bad S hS hbad).1 (calibration_generator_bad S hS hbad).2 + (physicalRayPeriodicBase_zero_true_puncture η S hS hbad σ χ) + +lemma physical_true_period_residual_coprime (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (I F : Id) : + IsCoprime (lowPeriodIdeal η S hS) + (rowResidualPart I + (Ideal.span {(calibrationForSet S hS).generator*lowTruePeriodGenerator η S hS}*F)) := by + apply InverseReflectedPhase.rowResidualPart_coprime_enlarged_period + rw [lowTruePeriodGenerator_span] + +def lowReflectionPeriod (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : Id := + lowBaseModulus η (calibrationForSet S hS) (calibrationForSet S hS).generator (calibrationLowData S hS) + +lemma lowReflectionPeriod_ne_zero (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : lowReflectionPeriod η S hS≠0 := + lowBaseModulus_ne_zero η _ _ (calibrationForSet S hS).generator_ne_zero _ + +lemma lowReflectionPeriod_actual (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (σ : RayRing) (χ : RayCharacter) : + CanonicalCoefficientClass.FactorsModulo (lowReflectionPeriod η S hS) (physicalRayPeriodicBase η S hS σ χ) ∧ + ∀n : O,‖physicalRayPeriodicBase η S hS σ χ n‖≤1 := by + exact ⟨lowPeriodicBase_periodic η _ _ _ _ _ χ,lowPeriodicBase_norm η _ _ _ _ _ χ⟩ + +def lowReflectionMask (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : O := + (calibrationForSet S hS).generator*lowTruePeriodGenerator η S hS + +lemma lowReflectionMask_ne_zero (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : lowReflectionMask η S hS≠0 := + mul_ne_zero (calibrationForSet S hS).generator_ne_zero (lowTruePeriodGenerator_ne_zero η S hS) + +lemma lowReflectionMask_bad (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) : + ConcretePrimeRowBridge.goodLambda∣lowReflectionMask η S hS ∧ (2:O)∣lowReflectionMask η S hS := by + exact ⟨dvd_mul_of_dvd_left (calibration_generator_bad S hS hbad).1 _, + dvd_mul_of_dvd_left (calibration_generator_bad S hS hbad).2 _⟩ + +lemma lowReflectionMask_period (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) : lowPeriodIdeal η S hS∣Ideal.span {lowReflectionMask η S hS} := by + rw [lowReflectionMask,←Ideal.span_singleton_mul_span_singleton,lowTruePeriodGenerator_span] + exact dvd_mul_left _ _ + +lemma physical_markedCompletedT_absorb_true_period (η : HeckeFamily.Character) (S : Finset Id) + (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) (σ : RayRing) (χ : RayCharacter) + (f z : O) (W : ℝ→ℂ) (X : ℝ) (mark : Id→ℂ) : + InverseMoment.markedCompletedT + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (lowReflectionMask η S hS) f z) W X mark= + InverseMoment.markedCompletedT + (rowTwist (physicalRayPeriodicBase η S hS σ χ) (calibrationForSet S hS).generator f z) W X mark := by + rw [lowReflectionMask,physical_row_absorb_true_period η S hS hbad σ χ] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowTupleGram.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowTupleGram.lean new file mode 100644 index 0000000000000000000000000000000000000000..710598c8bef4d1a1ec98aa7e68b00369962c3d17 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowTupleGram.lean @@ -0,0 +1,100 @@ +import OAI.NumberTheory.DirichletL.Detector.LowGramIntegrated +import OAI.NumberTheory.DirichletL.Detector.LowInverseEnergy + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +open MeasureTheory +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve CompletedGauss RayFourExpansion +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def lowGramFactor (C : CalibrationData) (X Y δ : ℝ) : ℝ := + Real.sqrt ((lowPhysicalScale C X Y/Y)*(1+(Y^2/lowPhysicalScale C X Y)^(1/6:ℝ)+ + (Y^2/lowPhysicalScale C X Y)^2/Y)*Y^δ) + +def lowInverseMass (C : CalibrationData) (a b : ℝ) (ha : 0Real.sqrt_nonneg _) + +lemma low_mellin_normalizer_norm (Q : ℝ) (_hQ : 0(p i).val) J* + compensationRowTest η (calibrationForSet S hS) W0 W1 (fun i=>(p i).val) J X Y T t* + selectedSlotFactor W P (fun i=>(p i).val) J t‖≤ + C*∑a : LowUnselectedTuple slots J, + ‖lowUnselectedWeight slots J W P a‖* + ((Real.sqrt (lowPhysicalScale (calibrationForSet S hS) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val))))⁻¹/(2*Real.pi))* + lowGramFactor (calibrationForSet S hS) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val)) δ* + lowInverseMass (calibrationForSet S hS) (a0*a1) (max 1 (b0*b1)) + (mul_pos ha0 ha1) (lt_of_lt_of_le zero_lt_one (le_max_left _ _)) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val)) + (div_pos hX (lowUnselectedProduct_norm_pos slots hslots J a)) + (div_pos hY (lowUnselectedProduct_norm_pos slots hslots J a)) + (lowSelectedInverseRow Finset.univ (lowSelectedWeight η slots J W P t) + η S hS (lowSelectedIdeal slots J) T t) := by + have hW1c : HasCompactSupport W1 := HasCompactSupport.of_support_subset_isCompact isCompact_Icc hW1 + intro S hS hbad + obtain ⟨C,hC,hgram⟩ := lowSeparatedIntegral_actual_gram δ hδ hδ1 a1 b1 M ha1 hab1 hM + W1 hW1c hW1 hW1s hWM (a0*a1) (max 1 (b0*b1)) (mul_pos ha0 ha1) + (lt_of_lt_of_le zero_lt_one (le_max_left _ _)) W0 a0 b0 ha0 hW0 hW0s S hS hbad + refine ⟨C,hC,?_⟩ + intro K η slots hslots J W P X Y T t hX hY hT hYs hPs + rw [compensation_tuple_low_polynomial η S hS hbad W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 hW0s + slots hslots J W P X Y T t hX hY hT] + apply (norm_sum_le _ _).trans + rw [Finset.mul_sum] + apply Finset.sum_le_sum + intro a ha + have hL := lowUnselectedProduct_norm_pos slots hslots J a + have hh := hgram (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val)) + (div_pos hX hL) (hYs a) + (lowSelectedInverseRow Finset.univ (lowSelectedWeight η slots J W P t) + η S hS (lowSelectedIdeal slots J) T t) (hPs a) + rw [norm_mul,norm_mul,low_mellin_normalizer_norm _ (lowPhysicalScale_pos _ _ _ (div_pos hX hL) (div_pos hY hL))] + calc + _≤‖lowUnselectedWeight slots J W P a‖* + ((Real.sqrt (lowPhysicalScale (calibrationForSet S hS) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val))))⁻¹/(2*Real.pi))* + (C*lowGramFactor (calibrationForSet S hS) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val)) δ* + lowInverseMass (calibrationForSet S hS) (a0*a1) (max 1 (b0*b1)) + (mul_pos ha0 ha1) (lt_of_lt_of_le zero_lt_one (le_max_left _ _)) + (X/elementNorm (∏i : J,(a i).val)) (Y/elementNorm (∏i : J,(a i).val)) + (div_pos hX hL) (div_pos hY hL) _) := + mul_le_mul_of_nonneg_left hh (by positivity) + _=_ := by ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowUnselectedMass.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowUnselectedMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..4233ef473b8a71d4a331d0eb5ddc0c6cd7dacb4f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowUnselectedMass.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Detector.LowSlotScales +import OAI.NumberTheory.DirichletL.Detector.GramIdealSummation + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "SupportedIdeal" => {I : Ideal O // Supported I} + +lemma canonical_slot_inverse_square : ∃C : ℝ,0⟨P.val.val,hT P.val P.property⟩ + have hf : Function.Injective f := by + intro P Q h + apply Subtype.ext + apply Subtype.ext + exact congrArg (fun I : SupportedIdeal=>I.val) h + have he : (∑a : canonicalSlotSupport T,elementNorm a.val^(-2:ℝ))= + ∑I∈Finset.univ.image f,ProbeGramCommon.gramIdealNorm I^(-2:ℝ) := by + rw [Finset.sum_image (fun P _ Q _ h=>hf h)] + have hh := (canonicalSlotEquiv T hT).sum_comp (fun a=>elementNorm a.val^(-2:ℝ)) + rw [←hh] + apply Finset.sum_congr rfl + intro P hP + rw [canonicalSlotEquiv_norm] + rfl + rw [he] + exact hb _ + +lemma lowUnselectedWeight_norm_identity {K : ℕ} (slots : Fin K→Finset O) + (hslots : ∀i x,x∈slots i→x≠0) (J : Finset (Fin K)) (W : Fin K→ℝ→ℂ) (P : Fin K→ℝ) + (a : LowUnselectedTuple slots J) : + ‖lowUnselectedWeight slots J W P a‖*elementNorm (∏i : J,(a i).val)^(-(1/2:ℝ))= + ∏i : J,elementNorm (a i).val^(-2:ℝ)*‖W i.val (elementNorm (a i).val/P i.val)‖ := by + have hL := lowUnselectedProduct_norm_pos slots hslots J a + rw [lowUnselectedWeight,norm_mul,norm_mul,norm_pow,norm_neg,norm_one,one_pow,one_mul, + Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (Real.rpow_nonneg hL.le _),norm_prod] + calc + _=(elementNorm (∏i : J,(a i).val)^(-(3/2:ℝ))*elementNorm (∏i : J,(a i).val)^(-(1/2:ℝ)))* + ∏i : J,‖W i.val (elementNorm (a i).val/P i.val)‖ := by ring + _=elementNorm (∏i : J,(a i).val)^(-2:ℝ)*∏i : J,‖W i.val (elementNorm (a i).val/P i.val)‖ := by + rw [←Real.rpow_add hL] + norm_num + _=_ := by + rw [elementNorm_finset_prod,Finset.prod_mul_distrib,Real.finsetProd_rpow Finset.univ + (fun i : J=>elementNorm (a i).val) (fun i _=>by unfold elementNorm;positivity)] + +theorem lowUnselectedMass_bound (K : ℕ) (M : ℝ) (hM : 0≤M) : + ∃C : ℝ,0canonicalSlotSupport (T i)) J, + ‖lowUnselectedWeight (fun i=>canonicalSlotSupport (T i)) J W P a‖* + elementNorm (∏i : J,(a i).val)^(-(1/2:ℝ)))≤C := by + obtain ⟨C,hC,hb⟩ := canonical_slot_inverse_square + refine ⟨(max 1 (C*M))^K,by positivity,?_⟩ + intro T hT J W P hW + simp_rw [lowUnselectedWeight_norm_identity _ (fun i=>canonicalSlotSupport_nonzero _ (hT i))] + rw [←Fintype.prod_sum (fun (i : J) (a : canonicalSlotSupport (T i.val))=> + elementNorm a.val^(-2:ℝ)*‖W i.val (elementNorm a.val/P i.val)‖)] + calc + _≤∏i : J,C*M := by + apply Finset.prod_le_prod₀ (fun i _=>Finset.sum_nonneg (fun a _=>mul_nonneg (Real.rpow_nonneg (by unfold elementNorm;positivity) _) (norm_nonneg _))) + intro i hi + calc + _≤∑a : canonicalSlotSupport (T i.val),elementNorm a.val^(-2:ℝ)*M := by + apply Finset.sum_le_sum + intro a ha + exact mul_le_mul_of_nonneg_left (hW i.val _) (Real.rpow_nonneg (by unfold elementNorm;positivity) _) + _=(∑a : canonicalSlotSupport (T i.val),elementNorm a.val^(-2:ℝ))*M := (Finset.sum_mul ..).symm + _≤C*M := mul_le_mul_of_nonneg_right (hb _ (hT i.val)) hM + _≤∏_i : J,max 1 (C*M) := Finset.prod_le_prod₀ (fun _ _=>by positivity) (fun _ _=>le_max_right _ _) + _≤_ := by + simp only [Finset.prod_const,Finset.card_univ,Fintype.card_coe] + exact pow_le_pow_right₀ (le_max_left _ _) (by simpa using Finset.card_le_card (Finset.subset_univ J)) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/LowWindowBound.lean b/lean/OAI/NumberTheory/DirichletL/Detector/LowWindowBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..d16ab5fbe03f86b3ee4aef949129a18835979573 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/LowWindowBound.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Detector.LowCommonBound + +namespace OAI + +noncomputable section +open scoped Classical ContDiff +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma compensatedPhysicalProbe_window_scale {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W0 W1 : ℝ→ℂ) (slots : Fin K→Finset O) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (X Y Z : ℝ) (c : ℂ) : + compensatedPhysicalProbe η C W0 W1 slots (fun i x=>c*W i x) Yp X Y Z= + c^K*compensatedPhysicalProbe η C W0 W1 slots W Yp X Y Z := by + unfold compensatedPhysicalProbe + simp_rw [Finset.prod_mul_distrib,Finset.prod_const,Finset.card_univ,Fintype.card_fin,mul_assoc] + exact (Finset.mul_sum ..).symm + +theorem original_ray_compensatedPhysicalProbe_low_loss + (S : Finset Id) (hS : SourceExclusions S) (hmax : ∀P∈S,P.IsMaximal) + {K : ℕ} (ell : Fin K→ℝ) (hell : ∀i,0≤ell i) (hinj : Function.Injective ell) + (hsum : ∑i,ell i≤1/6) (R : Set Id) + (a b B loss : ℝ) (ha : 0canonicalSlotSupport (ProbeRaySlots.pool R S a b (Z^(ell i)))) W (fun i=>Z^(ell i)) + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z‖≤C*Z^(3/16+loss) := by + let D := max 1 B + have hD : 0W i x/(D:ℂ) + have hWn : ∀i,Function.support (Wn i)⊆Set.Icc a b := by + intro i x hx + apply hW i + intro hz + exact hx (by dsimp [Wn];rw [hz,zero_div]) + have hn : ∀i x,‖Wn i x‖≤1 := by + intro i x + dsimp only [Wn] + rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hD] + exact (div_le_one hD).mpr ((hWnorm i x).trans (le_max_right _ _)) + have hscale : (fun i x=>(D:ℂ)*Wn i x)=W := by + funext i x + dsimp [Wn] + field_simp + let ε := min (loss/512) (1/2) + have he : 0<ε := by dsimp [ε];positivity + have he1 : ε<1 := lt_of_le_of_lt (min_le_right _ _) (by norm_num) + have heloss : 256*ε≤loss := by have hh := min_le_left (loss/512) (1/2:ℝ);dsimp only [ε];linarith + intro η + obtain ⟨C,hC,hbound⟩ := original_ray_compensatedPhysicalProbe_low η S hS hmax ell hell hinj hsum R + a b ε ha hab he he1 Wn hWn hn W0 W1 a0 b0 a1 b1 B0 B1 ha0 ha1 hab1 hB0 hB1 + hW0 hW1 hW0s hW1s hWB0 hWB1 + refine ⟨D^K*C,by positivity,?_⟩ + filter_upwards [hbound,Filter.eventually_ge_atTop (1:ℝ)] with Z hb hZ + have heq := compensatedPhysicalProbe_window_scale η (calibrationForSet S hmax) W0 W1 + (fun i=>canonicalSlotSupport (ProbeRaySlots.pool R S a b (Z^(ell i)))) Wn (fun i=>Z^(ell i)) + (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z (D:ℂ) + rw [hscale] at heq + rw [heq,norm_mul,norm_pow,Complex.norm_real,Real.norm_eq_abs,abs_of_pos hD] + calc + _≤D^K*(C*Z^(3/16+256*ε)) := mul_le_mul_of_nonneg_left hb (by positivity) + _≤D^K*(C*Z^(3/16+loss)) := by gcongr + _=_ := by ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MarkedEuler.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..a00bd5f7d7063cd09b99f78f782fa1674924b579 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedEuler.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Detector.MarkedValuations + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ProbeEulerFinsupp +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def excludedHighArray (S : Finset Id) (η : HeckeFamily.Character) (x w z : ℂ) (a : HighIdeal) : ℂ := + markedIdealHighSummand S 1 η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2 + +lemma excludedHighArray_one (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (x w z : ℂ) : excludedHighArray S η x w z 1=1 := by + simp only [excludedHighArray,Prod.fst_one,Prod.snd_one,markedIdealHighSummand, + highIdealMask_unmarked_one S hS,bareIdealHighSummand_one,one_mul] + +lemma excludedHighArray_mul (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (x w z : ℂ) (a b : HighIdeal) + (hc : IsCoprime (a.1.1*a.1.2*a.2.1*a.2.2) (b.1.1*b.1.2*b.2.1*b.2.2)) : + excludedHighArray S η x w z (a*b)=excludedHighArray S η x w z a*excludedHighArray S η x w z b := by + simp only [excludedHighArray,Prod.fst_mul,Prod.snd_mul,markedIdealHighSummand, + highIdealMask_unmarked_mul S hS a b, + bareIdealHighSummand_mul η x w z _ _ _ _ _ _ _ _ hc] + ring + +def excludedHighPrimeTerm (S : Finset Id) (η : HeckeFamily.Character) (x w z : ℂ) + (P : PrimeIdeal) (b : HighValuation) : ℂ := + excludedHighArray S η x w z ((P.val^b.1.1,P.val^b.1.2),(P.val^b.2.1,P.val^b.2.2)) + +lemma excludedHighArray_prod (S : Finset Id) (hS : ∀P∈S,Prime P) + (η : HeckeFamily.Character) (x w z : ℂ) (v : PrimeIdeal→₀HighValuation) : + excludedHighArray S η x w z (highIdeals v)=v.prod (excludedHighPrimeTerm S η x w z) := + highArray_val_prod _ (excludedHighArray_one S hS η x w z) (excludedHighArray_mul S hS η x w z) v + +lemma markedHighArray_val (S : Finset Id) (hS : ∀P∈S,Prime P) (T : Finset PrimeIdeal) + (η : HeckeFamily.Character) (x w z : ℂ) (v : PrimeIdeal→₀HighValuation) : + markedIdealHighSummand S (∏P∈T,P.val) η 1 x w z + (highIdeals v).1.1 (highIdeals v).1.2 (highIdeals v).2.1 (highIdeals v).2.2= + markedArray T completedValuationMark (excludedHighPrimeTerm S η x w z) v := by + rw [markedIdealHighSummand_mark,markedArray,completedValuationMark_product] + change _*excludedHighArray S η x w z (highIdeals v)=_ + rw [excludedHighArray_prod S hS] + +theorem markedIdealHighSeries_hasProd (S : Finset Id) (hS : ∀P∈S,Prime P) + (T : Finset PrimeIdeal) (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2∑'b : HighValuation, + markedLocal T completedValuationMark (excludedHighPrimeTerm S η x w z) P b) + (markedIdealHighSeries S (∏P∈T,P.val) η 1 x w z) := by + have h0 (P : PrimeIdeal) : excludedHighPrimeTerm S η x w z P 0=1 := by + simp only [excludedHighPrimeTerm,Prod.fst_zero,Prod.snd_zero,pow_zero] + exact excludedHighArray_one S hS η x w z + have hs := (markedIdealHighSummand_summable S 1 η 1 x w z hx hw hz).norm.comp_injective highIdeals_injective + change Summable (fun v=>‖excludedHighArray S η x w z (highIdeals v)‖) at hs + simp only [excludedHighArray_prod S hS] at hs + have he := marked_hasProd T completedValuationMark (excludedHighPrimeTerm S η x w z) h0 hs + (fun P _ b=>completedValuationMark_norm P b) + have hsum : (∑'v : PrimeIdeal→₀HighValuation, + markedArray T completedValuationMark (excludedHighPrimeTerm S η x w z) v)= + markedIdealHighSeries S (∏P∈T,P.val) η 1 x w z := by + simp only [←markedHighArray_val S hS T η x w z] + unfold markedIdealHighSeries + apply highIdeals_injective.tsum_eq (f:=fun a : HighIdeal=> + markedIdealHighSummand S (∏P∈T,P.val) η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2) + intro a ha + have hh : bareIdealHighSummand η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2≠0 := + (mul_ne_zero_iff.mp ha).2 + have hc := bareIdealHighSummand_support η 1 x w z a.1.1 a.1.2 a.2.1 a.2.2 hh + let b : (NonzeroIdeal×NonzeroIdeal)×(NonzeroIdeal×NonzeroIdeal) := + ((⟨a.1.1,hc.2.1.1⟩,⟨a.1.2,hc.2.2.1.1⟩),(⟨a.2.1,hc.2.2.2.1.1⟩,⟨a.2.2,hc.2.2.2.2.1⟩)) + refine ⟨highValuationEquiv b,?_⟩ + rw [highIdeals_eq_equiv,highValuationEquiv.symm_apply_apply] + simpa only [hsum] using he + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MarkedLocal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedLocal.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e0eafaacc3fc6f734c51b83b4ba72a4a648dd40 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedLocal.lean @@ -0,0 +1,104 @@ +import OAI.NumberTheory.DirichletL.Detector.MarkedEuler +import OAI.NumberTheory.DirichletL.Detector.HighExcludedLocal +import OAI.NumberTheory.DirichletL.Detector.HighEulerRational + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve CanonicalRowCompletion CompletedGauss ProbeEuler ProbeRow ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def idealMarkedLocalFactor (η : HeckeFamily.Character) (P : PrimeIdeal) (x w z : ℂ) : ℂ := + ∑e : Fin 2,∑'l,∑'k,∑'m, + completedValuationMark P ((e.val,l),(k,m))*highPrimeTerm η x w z P ((e.val,l),(k,m)) + +lemma markedPrimeTerm_summable_norm (η : HeckeFamily.Character) (P : PrimeIdeal) (x w z : ℂ) + (hx : 3/2‖completedValuationMark P b*highPrimeTerm η x w z P b‖) := by + apply Summable.of_nonneg_of_le (fun _=>norm_nonneg _) _ (highPrimeTerm_summable_norm η x w z hx hw hz P) + intro b + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (completedValuationMark_norm P b) + +lemma markedPrimeTerm_tsum (η : HeckeFamily.Character) (P : PrimeIdeal) (x w z : ℂ) + (hx : 3/2by + have hh : 2≤e := Nat.le_of_not_gt (by simpa only [Finset.mem_range] using he) + simp only [highPrimeTerm_zero_of_two_le η x w z P e _ _ _ hh,mul_zero,tsum_zero]), + ←Fin.sum_univ_eq_sum_range] + rfl + +lemma selectedLocal_outside (S : Finset Id) (hS : ∀P∈S,Prime P) (T : Finset PrimeIdeal) + (η : HeckeFamily.Character) (P : PrimeIdeal) (hP : P.val∉S) (x w z : ℂ) + (hx : 3/2 rw [hspan] + rw [hterm] + by_cases ht : e.val+3*l=0 + · have he0 : e.val=0 := by omega + have hl0 : l=0 := by omega + simp only [completedValuationMark,ht,ne_eq,not_true_eq_false,ite_false,zero_mul] + rw [he0,hl0] + simpa only [hspan] using (markedTerm_zero_index p hp hg.1 (targetMonoid η p) + (actualACube η p) ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) (coordV (Ideal.absNorm (Ideal.span {p})) z) k m).symm + · simp only [completedValuationMark,ht,ne_eq,not_false_eq_true,ite_true,one_mul] + simpa only [hspan] using sourcePrincipalTerm_pos p hp hg.1 (targetMonoid η p) (actualACube η p) x w z e.val l k m ht + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MarkedProduct.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedProduct.lean new file mode 100644 index 0000000000000000000000000000000000000000..c493312c2d7d17918be7b543a6ea6b4cff9def29 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedProduct.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Detector.MarkedLocal +import OAI.NumberTheory.DirichletL.Detector.SourceExclusions + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ProbeEuler ProbeEulerFinsupp +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma source_idealHighLocalFactor_ne_zero (S : Finset Id) (hS : SourceExclusions S) + (η : HeckeFamily.Character) (P : PrimeIdeal) (hP : P.val∉S) (x w z : ℂ) + (hx : 3/2if P∈T then + idealMarkedLocalFactor η P x w z/idealHighLocalFactor η P.val x w z else 1 + have hR : HasProd R (∏P∈T,idealMarkedLocalFactor η P x w z/idealHighLocalFactor η P.val x w z) := by + have hh := hasProd_prod_of_ne_finset_one (s:=T) (f:=R) (L:=SummationFilter.unconditional PrimeIdeal) (fun P hP=>ite_eq_right hP) + simpa only [R,Finset.prod_ite_mem,Finset.inter_self] using hh + have he := (excludedIdealHighSeries_hasProd S hS.prime η x w z hx hw hz).mul hR + have heq (P : PrimeIdeal) : + (∑'b : HighValuation,excludedHighPrimeTerm S η x w z P b)*R P= + ∑'b : HighValuation,markedLocal T completedValuationMark (excludedHighPrimeTerm S η x w z) P b := by + by_cases hp : P∈T + · rw [selectedLocal_outside S hS.prime T η P (hT P hp) x w z hx hw hz,ite_eq_left hp] + have hu : (∑'b : HighValuation,excludedHighPrimeTerm S η x w z P b)=idealHighLocalFactor η P.val x w z := by + simpa only [excludedHighPrimeTerm,excludedHighArray,ite_eq_right (hT P hp)] using + excludedHighLocalFactor S hS.prime η x w z hx hw hz P + rw [hu,show R P=idealMarkedLocalFactor η P x w z/idealHighLocalFactor η P.val x w z from ite_eq_left hp] + exact mul_div_cancel₀ _ (source_idealHighLocalFactor_ne_zero S hS η P (hT P hp) x w z hx hw hz) + · simp only [R,hp,ite_false,mul_one,markedLocal,one_mul] + have he' : HasProd (fun P : PrimeIdeal=>∑'b : HighValuation, + markedLocal T completedValuationMark (excludedHighPrimeTerm S η x w z) P b) + (markedIdealHighSeries S 1 η 1 x w z * + ∏P∈T,idealMarkedLocalFactor η P x w z/idealHighLocalFactor η P.val x w z) := by + convert he using 1 + funext P + exact (heq P).symm + exact (markedIdealHighSeries_hasProd S hS.prime T η x w z hx hw hz).unique he' + +theorem source_markedHigh_L_factorization (S : Finset Id) (hS : SourceExclusions S) + (T : Finset PrimeIdeal) (hT : ∀P∈T,P.val∉S) (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2 ActualEisensteinCubic.O + +def idealMarkedClosed (η : HeckeFamily.Character) (P : PrimeIdeal) (x w z : ℂ) : ℂ := + let Q : ℝ := Ideal.absNorm P.val + let R := coordR Q (actualAPhase η (primaryGenerator P.val)) x z + markedFactor R (coordV Q z) (Q:ℂ)⁻¹ (coordK Q (HeckeFamily.idealCoeff η P.val) x w) + (-coordD Q (HeckeFamily.idealCoeff η P.val) 1 x+coordW Q 1 w*R) 1 + +theorem idealMarkedLocalFactor_rational (η : HeckeFamily.Character) (P : PrimeIdeal) + (hs : Supported P.val) (x w z : ℂ) (hx : 3/2 simp only [hspan,p] + · simp only [idealMarkedClosed,coordD,coordW,star_one,mul_one,one_mul] + simp only [hspan,p,targetMonoid_primaryGenerator η P.val hs,Complex.ofReal_natCast,neg_mul] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MarkedValuations.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedValuations.lean new file mode 100644 index 0000000000000000000000000000000000000000..17d4c8ae315af80bdb573671df6886d9950bc501 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MarkedValuations.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Detector.HighExcludedEuler +import OAI.NumberTheory.DirichletL.Detector.EulerMarked + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic UniqueFactorizationMonoid ProbeCompleted +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma prime_dvd_iff_valuation (P : PrimeIdeal) (I : Id) (hI : I≠0) : + P.val∣I ↔ primeValuations I P≠0 := by + rw [primeValuations_apply,Multiset.count_ne_zero,mem_normalizedFactors_iff hI] + exact ⟨fun h=>⟨P.property,h⟩,fun h=>h.2⟩ + +lemma prime_dvd_high_completed (P : PrimeIdeal) (v : PrimeIdeal→₀HighValuation) : + P.val∣(highIdeals v).1.1*(highIdeals v).1.2^3 ↔ (v P).1.1+3*(v P).1.2≠0 := by + have hI : (highIdeals v).1.1≠0 := idealFromValuations_ne_zero _ + have hJ : (highIdeals v).1.2≠0 := idealFromValuations_ne_zero _ + rw [prime_dvd_iff_valuation P _ (mul_ne_zero hI (pow_ne_zero _ hJ)), + primeValuations_mul _ _ hI (pow_ne_zero _ hJ),primeValuations_pow] + simp only [highIdeals,primeValuations_idealFromValuations,Finsupp.add_apply, + Finsupp.mapRange_apply,Finsupp.coe_smul,Pi.smul_apply,smul_eq_mul] + +lemma primeProduct_dvd (T : Finset PrimeIdeal) (I : Id) : + (∏P∈T,P.val)∣I ↔ ∀P∈T,P.val∣I := by + constructor + · intro h P hP + exact (Finset.dvd_prod_of_mem _ hP).trans h + · intro h + exact Finset.prod_dvd_of_coprime (fun P _ Q _ hPQ=>primeIdeal_coprime P Q hPQ) h + +def completedValuationMark (_P : PrimeIdeal) (b : HighValuation) : ℂ := + if b.1.1+3*b.1.2≠0 then 1 else 0 + +lemma completedValuationMark_norm (_P : PrimeIdeal) (b : HighValuation) : + ‖completedValuationMark _P b‖≤1 := by + unfold completedValuationMark + split_ifs <;> norm_num + +lemma completedValuationMark_product (T : Finset PrimeIdeal) (v : PrimeIdeal→₀HighValuation) : + (∏P∈T,completedValuationMark P (v P))= + if (∏P∈T,P.val)∣(highIdeals v).1.1*(highIdeals v).1.2^3 then 1 else 0 := by + rw [primeProduct_dvd] + simp only [prime_dvd_high_completed] + by_cases h : ∀P∈T,(v P).1.1+3*(v P).1.2≠0 + · rw [ite_eq_left h] + apply Finset.prod_eq_one + intro P hP + exact ite_eq_left (h P hP) + · rw [ite_eq_right h] + push Not at h + obtain ⟨P,hP,hv⟩ := h + apply Finset.prod_eq_zero hP + simp only [completedValuationMark,hv,ne_eq,not_true_eq_false,ite_false] + +lemma highIdealMask_mark (S : Finset Id) (D I J K L : Id) : + highIdealMask S D I J K L=(if D∣I*J^3 then 1 else 0)*highIdealMask S 1 I J K L := by + unfold highIdealMask completedMask + simp only [one_dvd,true_and] + split_ifs <;> simp_all + +lemma markedIdealHighSummand_mark (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) (I J K L : Id) : + markedIdealHighSummand S D η u x w z I J K L= + (if D∣I*J^3 then 1 else 0)*markedIdealHighSummand S 1 η u x w z I J K L := by + rw [markedIdealHighSummand,highIdealMask_mark,markedIdealHighSummand,mul_assoc] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MellinBoundary.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MellinBoundary.lean new file mode 100644 index 0000000000000000000000000000000000000000..92a45a7d1849352a8bb72a3415557e3f7bf37b04 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MellinBoundary.lean @@ -0,0 +1,825 @@ +import OAI.NumberTheory.DirichletL.PrincipalMellinResidues +import OAI.NumberTheory.DirichletL.ContinuationPolynomialContour +import Mathlib.MeasureTheory.Group.Prod + +namespace OAI + +noncomputable section + +open MeasureTheory Set Filter Complex +open scoped Topology +namespace SevenEighths.ProbeMellinBoundary +open PrincipalMellinResidues HeckeFamily EisensteinSchwartzPoisson + +def height (t : ℝ) : ℝ := 1+|t| +lemma height_pos (t : ℝ) : 0 F ((a:ℂ)+t*I))) + (hb : Continuous (fun t : ℝ => F ((b:ℂ)+t*I))) + (hla : ∀t : ℝ, ‖F ((a:ℂ)+t*I)‖≤C*cauchy t) + (hlb : ∀t : ℝ, ‖F ((b:ℂ)+t*I)‖≤C*cauchy t) + (hjoin : ∀x∈uIcc a b, ∀t : ℝ, 1≤|t| → ‖F ((x:ℂ)+t*I)‖≤C*cauchy t) : + BoundaryControl F a b := by + have hi (h : Continuous (fun t : ℝ => F ((a:ℂ)+t*I))) := + (cauchy_integrable.const_mul C).mono' h.aestronglyMeasurable (Eventually.of_forall hla) + have hj (ε : ℝ) (hε : |ε|=1) : + Tendsto (fun T : ℝ => ∫x : ℝ in a..b, F ((x:ℂ)+(ε*T)*I)) atTop (𝓝 0) := by + apply tendsto_zero_iff_norm_tendsto_zero.mpr + apply squeeze_zero' (Eventually.of_forall (fun _ => norm_nonneg _)) ?_ + (by simpa using (cauchy_tendsto.const_mul C).mul_const |b-a|) + filter_upwards [eventually_ge_atTop 1] with T hT + apply intervalIntegral.norm_integral_le_of_norm_le_const + intro x hx + have ht : |ε*T|=T := by rw [abs_mul,hε,one_mul,abs_of_nonneg (by linarith)] + have hh := hjoin x (uIoc_subset_uIcc hx) (ε*T) (by simpa [ht] using hT) + have he : cauchy (ε*T)=cauchy T := by + unfold cauchy + have hs : (ε*T)^2=T^2 := by nlinarith [sq_abs (ε*T)] + rw [hs] + simpa [he] using hh + refine ⟨hi ha, (cauchy_integrable.const_mul C).mono' hb.aestronglyMeasurable + (Eventually.of_forall hlb), ?_, ?_⟩ + · simpa using hj (-1) (by norm_num) + · simpa using hj 1 (by norm_num) + +lemma pole_distance_vertical (p x t : ℝ) : |x-p|≤‖(x:ℂ)+t*I-p‖ := by + simpa using Complex.abs_re_le_norm ((x:ℂ)+t*I-p) +lemma pole_distance_horizontal (p x t : ℝ) : |t|≤‖(x:ℂ)+t*I-p‖ := by + simpa using Complex.abs_im_le_norm ((x:ℂ)+t*I-p) + +theorem boundaryControl_of_pole_product (F V G : ℂ → ℂ) {a b p C D δ : ℝ} (J : ℕ) + (hδ : 0<δ) (hδ1 : δ≤1) (hpa : δ≤|a-p|) (hpb : δ≤|b-p|) + (hF : ∀x∈uIcc a b, ∀t : ℝ, (x:ℂ)+t*I≠p → + F ((x:ℂ)+t*I)=V ((x:ℂ)+t*I)*G ((x:ℂ)+t*I)/((x:ℂ)+t*I-p)) + (hV : ContinuousOn V {z : ℂ | z.re∈uIcc a b}) + (hG : ContinuousOn G {z : ℂ | z.re∈uIcc a b}) + (_hC : 0≤C) (hD : 0≤D) + (hVbd : ∀x∈uIcc a b, ∀t : ℝ, height t^(J+2)*‖V ((x:ℂ)+t*I)‖≤C) + (hGbd : ∀x∈uIcc a b, ∀t : ℝ, (x=a ∨ x=b ∨ 1≤|t|) → + ‖G ((x:ℂ)+t*I)‖≤D*height t^J) : + BoundaryControl F a b := by + have hne (x t : ℝ) (hd : δ≤‖(x:ℂ)+t*I-p‖) : (x:ℂ)+t*I≠p := by + intro h + rw [h, sub_self, norm_zero] at hd + linarith + have hc (x : ℝ) (hx : x∈uIcc a b) (hd : δ≤|x-p|) : + Continuous (fun t : ℝ => F ((x:ℂ)+t*I)) := by + have hn (t : ℝ) : (x:ℂ)+t*I≠p := hne x t (hd.trans (pole_distance_vertical p x t)) + have hv := hV.comp_continuous (by fun_prop : Continuous (fun t : ℝ => (x:ℂ)+t*I)) + (by intro t; simpa using hx) + have hg := hG.comp_continuous (by fun_prop : Continuous (fun t : ℝ => (x:ℂ)+t*I)) + (by intro t; simpa using hx) + exact ((hv.mul hg).div (by fun_prop) (fun t => sub_ne_zero.mpr (hn t))).congr + (fun t => (hF x hx t (hn t)).symm) + have hbound (x : ℝ) (hx : x∈uIcc a b) (t : ℝ) + (hd : δ≤‖(x:ℂ)+t*I-p‖) (hboundary : x=a ∨ x=b ∨ 1≤|t|) : ‖F ((x:ℂ)+t*I)‖≤(C*D/δ)*cauchy t := by + have hn := hne x t hd + have hv : height t^2 * (height t^J*‖V ((x:ℂ)+t*I)‖)≤C := by + simpa [pow_add, mul_assoc, mul_left_comm, mul_comm] using hVbd x hx t + have hv' := CubicReflectionKernel.weighted_two_to_cauchy + (mul_nonneg (pow_nonneg (height_pos t).le _) (norm_nonneg _)) t hv + change height t^J*‖V ((x:ℂ)+t*I)‖≤C*cauchy t at hv' + rw [hF x hx t hn, norm_div, norm_mul] + apply (div_le_div₀ (mul_nonneg (norm_nonneg _) (mul_nonneg hD (pow_nonneg (height_pos t).le _))) + (mul_le_mul_of_nonneg_left (hGbd x hx t hboundary) (norm_nonneg _)) hδ hd).trans + calc + ‖V ((x:ℂ)+t*I)‖*(D*height t^J)/δ = D/δ*(height t^J*‖V ((x:ℂ)+t*I)‖) := by ring + _ ≤ D/δ*(C*cauchy t) := mul_le_mul_of_nonneg_left hv' (div_nonneg hD hδ.le) + _ = _ := by ring + apply boundaryControl_of_cauchy F (hc a (left_mem_uIcc) hpa) (hc b (right_mem_uIcc) hpb) + · intro t + exact hbound a left_mem_uIcc t (hpa.trans (pole_distance_vertical p a t)) (Or.inl rfl) + · intro t + exact hbound b right_mem_uIcc t (hpb.trans (pole_distance_vertical p b t)) (Or.inr (Or.inl rfl)) + · intro x hx t ht + exact hbound x hx t ((hδ1.trans ht).trans (pole_distance_horizontal p x t)) (Or.inr (Or.inr ht)) + +def scaleBound (q lo hi : ℝ) : ℝ := Real.exp (max (Real.log q*lo) (Real.log q*hi)) +lemma scaleBound_pos (q lo hi : ℝ) : 0 H w z*B w z) {w : ℂ | (19/20:ℝ)≤w.re ∧ w.re≤cw}) + (hHBbd : ∀x∈Icc (19/20:ℝ) cw, ∀t : ℝ, (x=19/20 ∨ x=cw ∨ 1≤|t|) → + ‖H ((x:ℂ)+t*I) z * B ((x:ℂ)+t*I) z‖≤AH*height t^JH) + (hLbd : ∀x∈Icc (19/20:ℝ) cw, ∀t : ℝ, (x=19/20 ∨ x=cw ∨ 1≤|t|) → + ‖HeckeOrigin.poleRemoved (fixedPrincipal M) ((x:ℂ)+t*I)‖≤AL*height t^JL) : + BoundaryControl (fun w => sourceMultiplier W0 W1 X Y Z eta s H B w z * + LFunction (fixedPrincipal M) w) (19/20) cw := by + let δ : ℝ := min (1/20) (cw-1) + have hδ : 0<δ := lt_min (by norm_num) (sub_pos.mpr hcw) + have hab : (19/20:ℝ)≤cw := by linarith + have hu : uIcc (19/20:ℝ) cw=Icc (19/20:ℝ) cw := uIcc_of_le hab + obtain ⟨C,hC,hV⟩ := CubicReflectionKernel.compact_source_mellin_strip_decay W1 a1 b1 ha1 hW1 + (W1.smooth ⊤) (19/20) cw (JH+JL+2) + let G (w : ℂ) := wScalar W0 X Z eta s z * (Y:ℂ)^(w-1) * + (H w z*B w z) * HeckeOrigin.poleRemoved (fixedPrincipal M) w + have hGc : ContinuousOn G {w : ℂ | w.re∈uIcc (19/20:ℝ) cw} := by + apply ContinuousOn.mul + · apply ContinuousOn.mul + · exact (continuous_const.mul ((continuous_id.sub continuous_const).const_cpow + (Or.inl (Complex.ofReal_ne_zero.mpr hY.ne')))).continuousOn + · rw [hu]; exact hHB + · exact (HeckeOrigin.poleRemoved_entire (fixedPrincipal M)).continuous.continuousOn + apply boundaryControl_of_pole_product _ (mellin W1) G (p:=1) (δ:=δ) (C:=C) + (D:=‖wScalar W0 X Z eta s z‖*scaleBound Y (19/20-1) (cw-1)*AH*AL) (JH+JL) + hδ (by dsimp [δ]; exact (min_le_left _ _).trans (by norm_num)) + (by dsimp [δ]; norm_num) + (by dsimp [δ]; rw [abs_of_pos (sub_pos.mpr hcw)]; exact min_le_right _ _) ?_ + (CubicReflectionKernel.compact_source_mellin_differentiable W1 a1 b1 ha1 hW1 + (W1.smooth ⊤)).continuous.continuousOn hGc hC.le + (by unfold scaleBound; positivity) (by intro x hx t; exact hV x (hu ▸ hx) t) ?_ + · intro x hx t hn + have hxp := (hu ▸ hx).1 + have h0 : (x:ℂ)+t*I≠0 := by intro h; have := congrArg Complex.re h; simp at this; linarith + have h1 : (x:ℂ)+t*I≠1 := by simpa using hn + dsimp only [G] + rw [HeckeOrigin.poleRemoved_eq _ h0 h1] + unfold sourceMultiplier wScalar + norm_num only [Complex.ofReal_one] + field_simp [hEta] + · intro x hx t hboundary + have hv := cpow_le_scaleBound hY (((x:ℂ)+t*I)-1) + (show (((x:ℂ)+t*I)-1).re∈Icc (19/20-1) (cw-1) by + simp only [sub_re,add_re,ofReal_re,mul_re,ofReal_im,I_re,mul_zero,zero_mul, + sub_zero,add_zero,one_re] + exact ⟨sub_le_sub_right (hu ▸ hx).1 1, sub_le_sub_right (hu ▸ hx).2 1⟩) + dsimp only [G] + rw [norm_mul,norm_mul,norm_mul] + calc + _ ≤ ‖wScalar W0 X Z eta s z‖ * scaleBound Y (19/20-1) (cw-1) * + (AH*height t^JH) * (AL*height t^JL) := by + have hscale := (scaleBound_pos Y (19/20-1) (cw-1)).le + have hp := (height_pos t).le + exact mul_le_mul + (mul_le_mul (mul_le_mul_of_nonneg_left hv (norm_nonneg _)) + (hHBbd x (hu ▸ hx) t hboundary) (norm_nonneg _) (by positivity)) + (hLbd x (hu ▸ hx) t hboundary) (norm_nonneg _) (by positivity) + _ = _ := by rw [pow_add]; ring + +lemma gaussian_strip_norm_le (s : ℂ) {a b x : ℝ} (ha : 0 linarith [neg_abs_le s.re, le_abs_self s.re, hx.2] + have hsq := pow_le_pow_left₀ (abs_nonneg (s.re+x-1)) hA 2 + rw [sq_abs] at hsq + nlinarith [sq_nonneg (s.im+t)] + +def zScalar (W1 : SchwartzMap ℝ ℂ) (X Z : ℝ) (eta : Character) (s z : ℂ) : ℂ := + (X:ℂ)^(1/2-z)*(Z:ℂ)^(s+z-1)*Complex.exp ((s+z-1)^2)*mellin W1 1 / LFunction eta s + +def zScaleBound (W1 : SchwartzMap ℝ ℂ) (X Z : ℝ) (eta : Character) (s : ℂ) (a b : ℝ) : ℝ := + scaleBound X (1/2-b) (1/2-a) * scaleBound Z (s.re+a-1) (s.re+b-1) * + Real.exp ((|s.re|+b+1)^2) * ‖mellin W1 1‖ / ‖LFunction eta s‖ + +lemma zScalar_continuous (W1 : SchwartzMap ℝ ℂ) {X Z : ℝ} (hX : 0 H 1 z*B 1 z) + {z : ℂ | (33/200:ℝ)≤z.re ∧ z.re≤1/6+e}) + (hHBbd : ∀x∈Icc (33/200:ℝ) (1/6+e), ∀t : ℝ, (x=33/200 ∨ x=1/6+e ∨ 1≤|t|) → + ‖H 1 ((x:ℂ)+t*I) * B 1 ((x:ℂ)+t*I)‖≤AH*height t^JH) + (hLbd : ∀x∈Icc (33/200:ℝ) (1/6+e), ∀t : ℝ, (x=33/200 ∨ x=1/6+e ∨ 1≤|t|) → + ‖HeckeOrigin.poleRemoved (fixedPrincipal M) (6*((x:ℂ)+t*I))‖≤AL*height t^JL) : + BoundaryControl (fun z => sourceMultiplier W0 W1 X Y Z eta s H B 1 z * + LFunction (fixedPrincipal M) (6*z)) (33/200) (1/6+e) := by + let δ : ℝ := min (1/600) e + have hδ : 0<δ := lt_min (by norm_num) he + have hab : (33/200:ℝ)≤1/6+e := by linarith + have hu : uIcc (33/200:ℝ) (1/6+e)=Icc (33/200:ℝ) (1/6+e) := uIcc_of_le hab + obtain ⟨C,hC,hV⟩ := ProbeRadialMellin.radial_mellin_strip_decay W0 a0 b0 ha0 hW0 + (33/200) (1/6+e) (by norm_num) (JH+JL+2) + let G (z : ℂ) := zScalar W1 X Z eta s z * (H 1 z*B 1 z) * + HeckeOrigin.poleRemoved (fixedPrincipal M) (6*z) / 6 + have hGc : ContinuousOn G {z : ℂ | z.re∈uIcc (33/200:ℝ) (1/6+e)} := by + apply ContinuousOn.div_const + apply ContinuousOn.mul + · exact (zScalar_continuous W1 hX hZ eta s).continuousOn.mul (by rw [hu]; exact hHB) + · exact ((HeckeOrigin.poleRemoved_entire (fixedPrincipal M)).continuous.comp + (continuous_const.mul continuous_id)).continuousOn + apply boundaryControl_of_pole_product _ (mellin (paperRadialFourier W0)) G + (p:=1/6) (δ:=δ) (C:=C) + (D:=zScaleBound W1 X Z eta s (33/200) (1/6+e)*AH*AL/6) (JH+JL) + hδ (by dsimp [δ]; exact (min_le_left _ _).trans (by norm_num)) + (by dsimp [δ]; norm_num) + (by dsimp [δ]; rw [show (1/6+e:ℝ)-1/6=e by ring, abs_of_pos he]; exact min_le_right _ _) + ?_ ?_ hGc hC.le (by unfold zScaleBound scaleBound; positivity) (by intro x hx t; exact hV x (hu ▸ hx) t) ?_ + · intro x hx t hn + have hxp := (hu ▸ hx).1 + have h0 : 6*((x:ℂ)+t*I)≠0 := by intro h; have := congrArg Complex.re h; simp at this; linarith + have h1 : 6*((x:ℂ)+t*I)≠1 := by + intro h + apply hn + push_cast + linear_combination h/6 + have hd : (x:ℂ)+t*I-(1/6:ℂ)≠0 := sub_ne_zero.mpr (by simpa using hn) + dsimp only [G] + rw [HeckeOrigin.poleRemoved_eq _ h0 h1] + norm_num only [Complex.ofReal_div,Complex.ofReal_one,Complex.ofReal_ofNat] + apply (eq_div_iff hd).mpr + unfold sourceMultiplier zScalar + norm_num only [sub_self,Complex.cpow_zero,mul_one] + field_simp [hEta] + · apply (ProbeRadialMellin.radial_mellin_differentiable W0).continuousOn.mono + intro z hz + have := (hu ▸ hz).1 + change 0 (p.1+p.2,p.2)) + (volume.prod volume) (volume.prod volume) := by + have hp0 : MeasurePreserving (fun p : ℝ×ℝ => (p.2,p.2+p.1)) + (volume.prod volume) (volume.prod volume) := measurePreserving_prod_add_swap volume volume + have hp1 := (Measure.measurePreserving_swap (μ:=(volume : Measure ℝ)) (ν:=volume)).comp hp0 + simpa only [Function.comp_def,Prod.swap,add_comm] using! hp1 + have ht := hp.prod (MeasurePreserving.id (volume : Measure ℝ)) + have hi := ((gaussianMoment_integrable J).mul_prod cauchy_integrable).mul_prod cauchy_integrable + exact ht.integrable_comp_of_integrable hi + +def onLines (W0 W1 : SchwartzMap ℝ ℂ) (σ ξ υ : ℝ) (p : HeightSpace) : ℂ := + profile W0 W1 ((σ:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) + +lemma onLines_norm (W0 W1 : SchwartzMap ℝ ℂ) (σ ξ υ : ℝ) (p : HeightSpace) : + ‖onLines W0 W1 σ ξ υ p‖ = Real.exp ((σ+ξ-1)^2)*Real.exp (-((p.1.1+p.1.2)^2))* + ‖mellin (paperRadialFourier W0) ((ξ:ℂ)+p.1.2*I)‖ * + ‖mellin W1 ((υ:ℂ)+p.2*I)‖ := by + unfold onLines profile + rw [norm_mul,norm_mul,Complex.norm_exp] + have hr : ((((σ:ℂ)+p.1.1*I)+((ξ:ℂ)+p.1.2*I)-1)^2).re = + (σ+ξ-1)^2+(-((p.1.1+p.1.2)^2)) := by simp [pow_two]; ring + rw [hr,Real.exp_add] + +lemma onLines_continuous (W0 W1 : SchwartzMap ℝ ℂ) (a1 b1 : ℝ) + (ha1 : 0 mellin (paperRadialFourier W0) ((ξ:ℂ)+t*I)) := + (ProbeRadialMellin.radial_mellin_differentiable W0).continuousOn.comp_continuous + (by fun_prop) (by intro t; simpa using hξ) + have hW := (CubicReflectionKernel.compact_source_mellin_differentiable W1 a1 b1 ha1 hW1 + (W1.smooth ⊤)).continuous + unfold onLines profile + apply Continuous.mul + · apply Continuous.mul + · fun_prop + · exact hR.comp (continuous_snd.comp continuous_fst) + · exact hW.comp (by fun_prop) + +def realGaussianBound (slo shi zlo zhi : ℝ) : ℝ := + Real.exp ((|slo|+|shi|+|zlo|+|zhi|+1)^2) +lemma realGaussianBound_pos (slo shi zlo zhi : ℝ) : 0 linarith [hσ.1,hσ.2,neg_abs_le slo,le_abs_self shi,abs_nonneg slo,abs_nonneg shi] + have hz : |ξ|≤|zlo|+|zhi| := by + rw [abs_le] + constructor <;> linarith [hξ.1,hξ.2,neg_abs_le zlo,le_abs_self zhi,abs_nonneg zlo,abs_nonneg zhi] + have hh : |σ+ξ-1|≤|slo|+|shi|+|zlo|+|zhi|+1 := by + rw [abs_le] + constructor <;> linarith [neg_abs_le σ,le_abs_self σ,neg_abs_le ξ,le_abs_self ξ] + apply Real.exp_le_exp.mpr + have hp := pow_le_pow_left₀ (abs_nonneg (σ+ξ-1)) hh 2 + simpa [sq_abs] using hp + +lemma profile_moment_majorant (W0 W1 : SchwartzMap ℝ ℂ) (J : ℕ) + {slo shi zlo zhi σ ξ υ C D : ℝ} (hσ : σ∈Icc slo shi) (hξ : ξ∈Icc zlo zhi) + (hC : 0≤C) (hD : 0≤D) + (hR : ∀v : ℝ, height v^(J+2)*‖mellin (paperRadialFourier W0) ((ξ:ℂ)+v*I)‖≤C) + (hW : ∀w : ℝ, height w^(J+2)*‖mellin W1 ((υ:ℂ)+w*I)‖≤D) (p : HeightSpace) : + jointHeight p.1.1 p.1.2 p.2^J*‖onLines W0 W1 σ ξ υ p‖ ≤ + (realGaussianBound slo shi zlo zhi*2^J*C*D)*jointEnvelope J p := by + have hb := weighted_coupled_cauchy J p.1.1 p.1.2 p.2 + ‖mellin (paperRadialFourier W0) ((ξ:ℂ)+p.1.2*I)‖ ‖mellin W1 ((υ:ℂ)+p.2*I)‖ C D + (norm_nonneg _) (norm_nonneg _) hC hD (hR _) (hW _) + rw [onLines_norm] + calc + _ = Real.exp ((σ+ξ-1)^2) * (jointHeight p.1.1 p.1.2 p.2^J* + Real.exp (-((p.1.1+p.1.2)^2))* + ‖mellin (paperRadialFourier W0) ((ξ:ℂ)+p.1.2*I)‖*‖mellin W1 ((υ:ℂ)+p.2*I)‖) := by ring + _ ≤ realGaussianBound slo shi zlo zhi * + ((2:ℝ)^J*C*D*(gaussianMoment J (p.1.1+p.1.2)*cauchy p.1.2*cauchy p.2)) := + mul_le_mul (realGaussian_le hσ hξ) hb + (by have := (jointHeight_pos p.1.1 p.1.2 p.2).le; positivity) + (realGaussianBound_pos _ _ _ _).le + _ = _ := by unfold jointEnvelope; ring + +theorem profile_uniform_moments (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 jointHeight p.1.1 p.1.2 p.2^J* + ‖onLines W0 W1 σ ξ υ p‖) heightMeasure ∧ + (∫p : HeightSpace, jointHeight p.1.1 p.1.2 p.2^J*‖onLines W0 W1 σ ξ υ p‖ ∂heightMeasure)≤K := by + obtain ⟨C,hC,hR⟩ := ProbeRadialMellin.radial_mellin_strip_decay W0 a0 b0 ha0 hW0 zlo zhi hzlo (J+2) + obtain ⟨D,hD,hW⟩ := CubicReflectionKernel.compact_source_mellin_strip_decay W1 a1 b1 ha1 hW1 + (W1.smooth ⊤) wlo whi (J+2) + let A := realGaussianBound slo shi zlo zhi*2^J*C*D + have hA : 0 jointHeight p.1.1 p.1.2 p.2^J* + ‖onLines W0 W1 σ ξ υ p‖) heightMeasure := by + apply ((jointEnvelope_integrable J).const_mul A).mono' + · exact ((by unfold jointHeight; fun_prop : Continuous (fun p : HeightSpace => + jointHeight p.1.1 p.1.2 p.2^J)).mul hc.norm).aestronglyMeasurable + · apply Eventually.of_forall + intro p + have hn : 0≤jointHeight p.1.1 p.1.2 p.2^J*‖onLines W0 W1 σ ξ υ p‖ := + mul_nonneg (pow_nonneg (jointHeight_pos _ _ _).le _) (norm_nonneg _) + rw [Real.norm_eq_abs,abs_of_nonneg hn] + exact hbound p + refine ⟨hf,?_⟩ + calc + _ ≤ ∫p, A*jointEnvelope J p ∂heightMeasure := integral_mono hf + ((jointEnvelope_integrable J).const_mul A) hbound + _ = A*(∫p, jointEnvelope J p ∂heightMeasure) := integral_const_mul _ _ + _ ≤ _ := by + have hh := le_abs_self (∫p, jointEnvelope J p ∂heightMeasure) + exact mul_le_mul_of_nonneg_left (by linarith) hA.le + +def outsideBox (T : ℝ) : Set HeightSpace := + {p | T < |p.1.1| ∨ T < |p.1.2| ∨ T < |p.2|} +lemma outsideBox_measurable (T : ℝ) : MeasurableSet (outsideBox T) := by + unfold outsideBox + measurability +lemma height_le_joint_on_tail {T : ℝ} {p : HeightSpace} (hp : p∈outsideBox T) : + 1+T≤jointHeight p.1.1 p.1.2 p.2 := by + rcases hp with h|h|h <;> unfold jointHeight <;> + linarith [abs_nonneg p.1.1,abs_nonneg p.1.2,abs_nonneg p.2] + +lemma weighted_tail_pointwise (f : HeightSpace → ℂ) (J N : ℕ) {T : ℝ} (hT : 0≤T) + {p : HeightSpace} (hp : p∈outsideBox T) : + jointHeight p.1.1 p.1.2 p.2^J*‖f p‖ ≤ + (jointHeight p.1.1 p.1.2 p.2^(J+N)*‖f p‖)/(1+T)^N := by + apply (le_div_iff₀ (by positivity)).mpr + have hn := pow_le_pow_left₀ (by linarith : 0≤1+T) (height_le_joint_on_tail hp) N + have hh := mul_le_mul_of_nonneg_left hn + (mul_nonneg (pow_nonneg (jointHeight_pos p.1.1 p.1.2 p.2).le J) (norm_nonneg (f p))) + convert hh using 1 ; rw [pow_add] ; ring + +theorem profile_uniform_tails (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 mul_nonneg + (pow_nonneg (jointHeight_pos _ _ _).le _) (norm_nonneg _)) + _ ≤ _ := div_le_div_of_nonneg_right hb (by positivity) + +theorem profile_arithmetic_integrable (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 G p*onLines W0 W1 σ ξ υ p) heightMeasure := by + obtain ⟨K,hK,hM⟩ := profile_uniform_moments W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + σ σ ξ ξ υ υ hξ J + have hi := (hM σ ⟨le_rfl,le_rfl⟩ ξ ⟨le_rfl,le_rfl⟩ υ ⟨le_rfl,le_rfl⟩).1 + apply (hi.const_mul A).mono' + · exact hG.mul (onLines_continuous W0 W1 a1 b1 ha1 hW1 σ ξ υ hξ).aestronglyMeasurable + · apply Eventually.of_forall + intro p + rw [norm_mul] + simpa only [mul_assoc] using mul_le_mul_of_nonneg_right (hbound p) (norm_nonneg _) + +inductive SliceAxis where + | s | z | w + +def sliceMap (axis : SliceAxis) (T : ℝ) (q : ℝ×ℝ) : HeightSpace := + match axis with + | .s => ((T,q.1),q.2) + | .z => ((q.1,T),q.2) + | .w => ((q.1,q.2),T) + +lemma sliceMap_continuous (axis : SliceAxis) (T : ℝ) : Continuous (sliceMap axis T) := by + cases axis <;> unfold sliceMap <;> fun_prop + +lemma slice_height_le (axis : SliceAxis) (T : ℝ) (q : ℝ×ℝ) : + height T≤jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 (sliceMap axis T q).2 := by + cases axis <;> unfold sliceMap height jointHeight <;> + linarith [abs_nonneg q.1,abs_nonneg q.2] + +lemma cauchy_le_one (t : ℝ) : cauchy t≤1 := by + simpa [cauchy] using inv_anti₀ (by norm_num : (0:ℝ)<1) + (show 1≤1+t^2 by nlinarith [sq_nonneg t]) + +def sliceEnvelope (axis : SliceAxis) (J : ℕ) (T : ℝ) (q : ℝ×ℝ) : ℝ := + match axis with + | .s | .z => gaussianMoment J (T+q.1)*cauchy q.2 + | .w => gaussianMoment J (q.1+q.2)*cauchy q.2 + +def sliceMass (J : ℕ) : ℝ := (∫u : ℝ, gaussianMoment J u)*(∫v : ℝ, cauchy v) + +lemma sliceEnvelope_nonneg (axis : SliceAxis) (J : ℕ) (T : ℝ) (q : ℝ×ℝ) : + 0≤sliceEnvelope axis J T q := by + cases axis <;> exact mul_nonneg (gaussianMoment_nonneg _ _) (cauchy_nonneg _) + +lemma jointEnvelope_slice_le (axis : SliceAxis) (J : ℕ) (T : ℝ) (q : ℝ×ℝ) : + jointEnvelope J (sliceMap axis T q)≤sliceEnvelope axis J T q := by + cases axis + · change gaussianMoment J (T+q.1)*cauchy q.1*cauchy q.2 ≤ gaussianMoment J (T+q.1)*cauchy q.2 + have hh := mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left (cauchy_le_one q.1) (gaussianMoment_nonneg J (T+q.1))) (cauchy_nonneg q.2) + simpa using hh + · change gaussianMoment J (q.1+T)*cauchy T*cauchy q.2 ≤ gaussianMoment J (T+q.1)*cauchy q.2 + have hh := mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_left (cauchy_le_one T) (gaussianMoment_nonneg J (q.1+T))) (cauchy_nonneg q.2) + simpa [add_comm] using hh + · change gaussianMoment J (q.1+q.2)*cauchy q.2*cauchy T ≤ gaussianMoment J (q.1+q.2)*cauchy q.2 + simpa using mul_le_mul_of_nonneg_left (cauchy_le_one T) + (mul_nonneg (gaussianMoment_nonneg _ _) (cauchy_nonneg _)) + +lemma pairEnvelope_integrable (J : ℕ) : + Integrable (fun q : ℝ×ℝ => gaussianMoment J (q.1+q.2)*cauchy q.2) (volume.prod volume) := by + have hp0 : MeasurePreserving (fun p : ℝ×ℝ => (p.2,p.2+p.1)) + (volume.prod volume) (volume.prod volume) := measurePreserving_prod_add_swap volume volume + have hp1 := (Measure.measurePreserving_swap (μ:=(volume : Measure ℝ)) (ν:=volume)).comp hp0 + have hi := hp1.integrable_comp_of_integrable ((gaussianMoment_integrable J).mul_prod cauchy_integrable) + simpa only [Function.comp_def,Prod.swap,add_comm] using! hi + +lemma sliceEnvelope_integrable (axis : SliceAxis) (J : ℕ) (T : ℝ) : + Integrable (sliceEnvelope axis J T) (volume.prod volume) := by + cases axis + · exact ((gaussianMoment_integrable J).comp_add_left T).mul_prod cauchy_integrable + · exact ((gaussianMoment_integrable J).comp_add_left T).mul_prod cauchy_integrable + · exact pairEnvelope_integrable J + +lemma sliceEnvelope_integral (axis : SliceAxis) (J : ℕ) (T : ℝ) : + (∫q : ℝ×ℝ, sliceEnvelope axis J T q ∂volume.prod volume)=sliceMass J := by + cases axis + · change (∫q : ℝ×ℝ, gaussianMoment J (T+q.1)*cauchy q.2 ∂volume.prod volume)=_ + rw [integral_prod_mul (fun u : ℝ => gaussianMoment J (T+u)) cauchy,integral_add_left_eq_self] + rfl + · change (∫q : ℝ×ℝ, gaussianMoment J (T+q.1)*cauchy q.2 ∂volume.prod volume)=_ + rw [integral_prod_mul (fun u : ℝ => gaussianMoment J (T+u)) cauchy,integral_add_left_eq_self] + rfl + · change (∫q : ℝ×ℝ, gaussianMoment J (q.1+q.2)*cauchy q.2 ∂volume.prod volume)=_ + rw [integral_prod_symm _ (pairEnvelope_integrable J)] + simp_rw [integral_mul_const,integral_add_right_eq_self] + exact integral_const_mul _ _ + +lemma weighted_slice_pointwise (f : HeightSpace → ℂ) (axis : SliceAxis) (J N : ℕ) (T : ℝ) (q : ℝ×ℝ) : + jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 (sliceMap axis T q).2^J* + ‖f (sliceMap axis T q)‖ ≤ + (jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 (sliceMap axis T q).2^(J+N)* + ‖f (sliceMap axis T q)‖)/height T^N := by + apply (le_div_iff₀ (pow_pos (height_pos T) N)).mpr + have hn := pow_le_pow_left₀ (height_pos T).le (slice_height_le axis T q) N + have hh := mul_le_mul_of_nonneg_left hn + (mul_nonneg (pow_nonneg (jointHeight_pos (sliceMap axis T q).1.1 + (sliceMap axis T q).1.2 (sliceMap axis T q).2).le J) (norm_nonneg (f (sliceMap axis T q)))) + convert hh using 1 ; rw [pow_add] ; ring + +theorem profile_uniform_slices (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 + jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 (sliceMap axis T q).2^J* + ‖onLines W0 W1 σ ξ υ (sliceMap axis T q)‖) (volume.prod volume) ∧ + (∫q : ℝ×ℝ, + jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 (sliceMap axis T q).2^J* + ‖onLines W0 W1 σ ξ υ (sliceMap axis T q)‖ ∂volume.prod volume)≤K/height T^N := by + obtain ⟨C,hC,hR⟩ := ProbeRadialMellin.radial_mellin_strip_decay W0 a0 b0 ha0 hW0 + zlo zhi hzlo (J+N+2) + obtain ⟨D,hD,hW⟩ := CubicReflectionKernel.compact_source_mellin_strip_decay W1 a1 b1 ha1 hW1 + (W1.smooth ⊤) wlo whi (J+N+2) + let A := realGaussianBound slo shi zlo zhi*2^(J+N)*C*D + have hA : 0 unfold sliceMap jointHeight <;> fun_prop : Continuous (fun q : ℝ×ℝ => + jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 (sliceMap axis T q).2^J)).mul hc.norm).aestronglyMeasurable + · exact Eventually.of_forall (fun q => by rw [Real.norm_eq_abs,abs_of_nonneg (hfnonneg q)]; exact hbound q) + refine ⟨hf,?_⟩ + calc + _ ≤ ∫q : ℝ×ℝ, (A/height T^N)*sliceEnvelope axis (J+N) T q ∂volume.prod volume := + integral_mono hf ((sliceEnvelope_integrable axis (J+N) T).const_mul _) hbound + _ = (A/height T^N)*sliceMass (J+N) := by rw [integral_const_mul,sliceEnvelope_integral] + _ ≤ (A/height T^N)*(1+|sliceMass (J+N)|) := by + apply mul_le_mul_of_nonneg_left _ (div_nonneg hA.le (pow_nonneg (height_pos T).le N)) + linarith [le_abs_self (sliceMass (J+N))] + _ = _ := by ring + +theorem profile_arithmetic_tails (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 G p*onLines W0 W1 σ ξ υ p) heightMeasure ∧ + ∀T : ℝ, 0≤T → + (∫p : HeightSpace in outsideBox T, ‖G p*onLines W0 W1 σ ξ υ p‖ ∂heightMeasure) + ≤ A*K/(1+T)^N := by + obtain ⟨K,hK,hT⟩ := profile_uniform_tails W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + slo shi zlo zhi wlo whi hzlo J N + obtain ⟨K0,hK0,hM⟩ := profile_uniform_moments W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + slo shi zlo zhi wlo whi hzlo J + refine ⟨K,hK,?_⟩ + intro σ hσ ξ hξ υ hυ A hA G hG hbound + have hi := profile_arithmetic_integrable W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + σ ξ υ (hzlo.trans_le hξ.1) G hG A J hbound + refine ⟨hi,?_⟩ + intro T hT0 + calc + _ ≤ ∫p : HeightSpace in outsideBox T, + A*(jointHeight p.1.1 p.1.2 p.2^J*‖onLines W0 W1 σ ξ υ p‖) ∂heightMeasure := by + apply setIntegral_mono_on hi.norm.integrableOn + (((hM σ hσ ξ hξ υ hυ).1).const_mul A).integrableOn (outsideBox_measurable T) + intro p hp + rw [norm_mul] + simpa only [mul_assoc] using mul_le_mul_of_nonneg_right (hbound p) (norm_nonneg _) + _ = A*(∫p : HeightSpace in outsideBox T, + jointHeight p.1.1 p.1.2 p.2^J*‖onLines W0 W1 σ ξ υ p‖ ∂heightMeasure) := + integral_const_mul _ _ + _ ≤ A*(K/(1+T)^N) := mul_le_mul_of_nonneg_left (hT σ hσ ξ hξ υ hυ T hT0) hA + _ = _ := by ring + +theorem profile_arithmetic_slices (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 G q*onLines W0 W1 σ ξ υ (sliceMap axis T q)) (volume.prod volume) ∧ + (∫q : ℝ×ℝ, ‖G q*onLines W0 W1 σ ξ υ (sliceMap axis T q)‖ ∂volume.prod volume) + ≤ A*K/height T^N := by + obtain ⟨K,hK,hM⟩ := profile_uniform_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + slo shi zlo zhi wlo whi hzlo J N + refine ⟨K,hK,?_⟩ + intro σ hσ ξ hξ υ hυ axis T A hA G hG hbound + obtain ⟨hm,hmb⟩ := hM σ hσ ξ hξ υ hυ axis T + have hdom (q : ℝ×ℝ) : ‖G q*onLines W0 W1 σ ξ υ (sliceMap axis T q)‖≤ + A*(jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 + (sliceMap axis T q).2^J*‖onLines W0 W1 σ ξ υ (sliceMap axis T q)‖) := by + rw [norm_mul] + simpa only [mul_assoc] using mul_le_mul_of_nonneg_right (hbound q) (norm_nonneg _) + have hi : Integrable (fun q => G q*onLines W0 W1 σ ξ υ (sliceMap axis T q)) + (volume.prod volume) := by + apply (hm.const_mul A).mono' + · exact hG.mul (((onLines_continuous W0 W1 a1 b1 ha1 hW1 σ ξ υ + (hzlo.trans_le hξ.1)).comp (sliceMap_continuous axis T)).aestronglyMeasurable) + · exact Eventually.of_forall hdom + refine ⟨hi,?_⟩ + calc + _ ≤ ∫q : ℝ×ℝ, + A*(jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 + (sliceMap axis T q).2^J*‖onLines W0 W1 σ ξ υ (sliceMap axis T q)‖) ∂volume.prod volume := + integral_mono hi.norm (hm.const_mul A) hdom + _ = A*(∫q : ℝ×ℝ, + jointHeight (sliceMap axis T q).1.1 (sliceMap axis T q).1.2 + (sliceMap axis T q).2^J*‖onLines W0 W1 σ ξ υ (sliceMap axis T q)‖ ∂volume.prod volume) := + integral_const_mul _ _ + _ ≤ A*(K/height T^N) := mul_le_mul_of_nonneg_left hmb hA + _ = _ := by ring + +theorem profile_arithmetic_fubini (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0 ActualEisensteinCubic.O + +def physicalMellinCoefficientTerm (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D I J : Ideal O) (s : O) (hs : Supported (Ideal.span {s})) + (X : ℝ) (H : O) (t z : ℂ) : ℂ := + if hA : completedIndex I J≠0 then + let K := elementNorm C.generator*elementNorm s*X + idealRowHom C.generator (Ideal.span {s}) / + (C.tau*C.residueMonoid s*(Real.sqrt K:ℂ)) * (Real.sqrt (elementNorm s):ℂ)⁻¹ * + spectralSummand S D (baseRowCoefficient η C.Xi s hs) t I J * + ((K/elementNorm (C.generator*completedIndex I J):ℝ):ℂ)* + actualCongruenceCoefficient C (completedIndex I J) s hA H * + ((K*elementNorm H/elementNorm ((C.generator*completedIndex I J)*s)):ℂ)^(-z) + else 0 + +def guardedHighMellinCoefficient (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D I J : Ideal O) (s : O) (X : ℝ) (H : O) (x z : ℂ) : ℂ := + if h : Squarefree I ∧ Supported I ∧ Supported J then + (X:ℂ)^(1/2-z)*(elementNorm H:ℂ)^(-z)*completedMask S D I J*star (C.residueMonoid H)* + bareSourceCoefficient η I (supported_primaryGenerator_ne_zero I h.2.1) + (completedIndex I J) s (supportedElement_ne_zero _ (supported_completed _ _ + ((supported_span_primaryGenerator_iff I).mpr h.2.1) + ((supported_span_primaryGenerator_iff J).mpr h.2.2))) H * + (fullIdealWeight (x+1/2) I*fullIdealWeight (1+3*x) J) + else 0 + +theorem physicalMellinCoefficientTerm_eq_guarded (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hbad : fixedBadPrimes⊆S) + (D I J : Ideal O) (s : O) (hs : Supported (Ideal.span {s})) + (hcs : IsCoprime (calibrationForSet S hS).generator s) + (X : ℝ) (hX : 0 simp only [hz,mul_zero,zero_mul] + +theorem guardedHighMellinCoefficient_eq_high (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) (D I J K : Ideal O) + (hK : Supported K) (hKS : ∀P∈S,¬P∣K) (X : ℝ) (H : O) (x w z : ℂ) : + guardedHighMellinCoefficient η C S D I J (primaryGenerator K) X H x z * + fullIdealWeight w K = + (X:ℂ)^(1/2-z)*(elementNorm H:ℂ)^(-z)*star (C.residueMonoid H)* + markedIdealHighSummand S D η H x w z I J K 1 := by + have h1 : ∀P∈S,¬P∣(1:Ideal O) := by + intro P hP hd + exact (hS P hP).not_isUnit (isUnit_of_dvd_one hd) + have hw : fullIdealWeight (6*z) (1:Ideal O)=1 := (IdealEuler.normWeight (6*z)).map_one + unfold guardedHighMellinCoefficient markedIdealHighSummand highIdealMask + bareIdealHighSummand bareIdealHighCoefficient + simp only [ite_eq_left hKS,ite_eq_left h1,mul_one,hw,primaryGenerator_one,one_pow] + by_cases hg : Squarefree I ∧ Supported I ∧ Supported J + · have hfull : Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported (1:Ideal O) := + ⟨hg.1,hg.2.1,hg.2.2,hK,supported_one_ideal⟩ + rw [dite_eq_left hg,dite_eq_left hfull] + dsimp only [completedIndex] + ring + · have hfull : ¬(Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported (1:Ideal O)) := + fun h=>hg ⟨h.1,h.2.1,h.2.2.1⟩ + rw [dite_eq_right hg,dite_eq_right hfull] + simp only [mul_zero,zero_mul] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MellinPoisson.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MellinPoisson.lean new file mode 100644 index 0000000000000000000000000000000000000000..95f5ed82c6b1c8652a36361be38fe7fae989152b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MellinPoisson.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Detector.SpectralPoisson + +namespace OAI + +noncomputable section +open scoped Classical BigOperators ContDiff +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss ProbeCompleted ProbeRow CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O + +lemma finiteSupport_verticalIntegral {α : Type*} (c : α → ℂ) + (hc : (Function.support c).Finite) (F : α → ℂ → ℂ) (σ : ℝ) + (hF : ∀ a, Integrable (fun y : ℝ => F a ((σ:ℂ)+y*Complex.I))) : + verticalIntegral σ (fun t => ∑' a, c a * F a t) = + ∑' a, c a * verticalIntegral σ (F a) := by + have hz (a : α) (ha : a∉hc.toFinset) : c a=0 := by + simpa only [Set.Finite.mem_toFinset, Function.mem_support, not_not] using ha + have he (t : ℂ) : (∑' a, c a*F a t) = ∑ a∈hc.toFinset, c a*F a t := + tsum_eq_sum (fun a ha => by rw [hz a ha, zero_mul]) + rw [tsum_eq_sum (s := hc.toFinset) (fun a ha => by rw [hz a ha, zero_mul])] + unfold verticalIntegral + simp_rw [he] + rw [integral_finsetSum _ (fun a ha => (hF a).const_mul (c a)), Finset.mul_sum] + apply Finset.sum_congr rfl + intro a ha + rw [integral_const_mul] + ring + +theorem inner_mellin_poisson (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (s : O) (hs : Supported (Ideal.span {s})) + (W : ℝ → ℂ) (hWc : HasCompactSupport W) (hWs : ContDiff ℝ ∞ W) + (K Z : ℝ) (hK : 0 (Z:ℂ)^t * Complex.exp (t^2) * + spectralRow C.excluded D (rowCoefficient η C.Xi s hs m) t)) = + verticalIntegral 4 (fun t => (Real.sqrt (elementNorm s):ℂ)⁻¹ * + ((Z:ℂ)^t * Complex.exp (t^2)) * + ∑' p : Ideal O × Ideal O, transformedSpectralTerm η C C.excluded D s hs W K t p.1 p.2) := by + let c (m : O) := C.residueMonoid m * (Real.sqrt (elementNorm s):ℂ)⁻¹ * + sexticGauss s (supportedElement_ne_zero s hs) (-m) * W (elementNorm m/K) + have hc : (Function.support c).Finite := by + apply (elementWindow_finite_support W hWc K hK).subset + intro m hm hz + exact hm (by simp only [c, hz, mul_zero]) + rw [← finiteSupport_verticalIntegral c hc + (fun m t => (Z:ℂ)^t * Complex.exp (t^2) * + spectralRow C.excluded D (rowCoefficient η C.Xi s hs m) t) 4 + (fun m => physicalRow_integrable η C D s hs m Z hZ)] + unfold verticalIntegral + congr 1 + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro y + dsimp only + norm_num only [Complex.ofReal_ofNat] + have ht : 1 < ((4:ℂ)+(y:ℂ)*Complex.I).re := by simp + rw [← physical_spectral_poisson η C C.excluded D s hs W hWc hWs K hK _ ht, + ← tsum_mul_left] + apply tsum_congr + intro m + dsimp only [c] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/MellinPowers.lean b/lean/OAI/NumberTheory/DirichletL/Detector/MellinPowers.lean new file mode 100644 index 0000000000000000000000000000000000000000..ffd4afdd2383de2e968b3a2ed54ad45cd945ad71 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/MellinPowers.lean @@ -0,0 +1,46 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalNorms + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ProbeEuler + +lemma sourceNormPower_identity (I J H X : ℝ) (hI : 0((p.1.1,p.2.1),(p.1.2,p.2.2)));fun_prop + measurable_invFun := by change Measurable (fun p : (A×C)×(B×D)=>((p.1.1,p.2.1),(p.1.2,p.2.2)));fun_prop + +lemma quadShuffle_preserving {A B C D : Type*} [MeasurableSpace A] [MeasurableSpace B] + [MeasurableSpace C] [MeasurableSpace D] (μA : Measure A) (μB : Measure B) + (μC : Measure C) (μD : Measure D) [SFinite μA] [SFinite μB] [SFinite μC] [SFinite μD] : + MeasurePreserving (quadShuffle : (A×B)×(C×D) ≃ᵐ (A×C)×(B×D)) + ((μA.prod μB).prod (μC.prod μD)) ((μA.prod μC).prod (μB.prod μD)) := by + have h1 := measurePreserving_prodAssoc μA μB (μC.prod μD) + have h2 := (MeasurePreserving.id μA).prod ((measurePreserving_prodAssoc μB μC μD).symm MeasurableEquiv.prodAssoc) + have h3 := (MeasurePreserving.id μA).prod + ((Measure.measurePreserving_swap (μ:=μB) (ν:=μC)).prod (MeasurePreserving.id μD)) + have h4 := (MeasurePreserving.id μA).prod (measurePreserving_prodAssoc μC μB μD) + have h5 := (measurePreserving_prodAssoc μA μC (μB.prod μD)).symm MeasurableEquiv.prodAssoc + exact h5.comp (h4.comp (h3.comp (h2.comp h1))) + +def physicalNestingEquiv {A B C D E F : Type*} [MeasurableSpace A] [MeasurableSpace B] + [MeasurableSpace C] [MeasurableSpace D] [MeasurableSpace E] [MeasurableSpace F] : + (A×(B×C))×((D×E)×F) ≃ᵐ A×(F×(D×(B×(E×C)))) where + toFun p := (p.1.1,(p.2.2,(p.2.1.1,(p.1.2.1,(p.2.1.2,p.1.2.2))))) + invFun p := ((p.1,(p.2.2.2.1,p.2.2.2.2.2)),((p.2.2.1,p.2.2.2.2.1),p.2.1)) + left_inv p := rfl + right_inv p := rfl + measurable_toFun := by + change Measurable (fun p : (A×(B×C))×((D×E)×F)=> + (p.1.1,(p.2.2,(p.2.1.1,(p.1.2.1,(p.2.1.2,p.1.2.2)))))) + fun_prop + measurable_invFun := by + change Measurable (fun p : A×(F×(D×(B×(E×C))))=> + ((p.1,(p.2.2.2.1,p.2.2.2.2.2)),((p.2.2.1,p.2.2.2.2.1),p.2.1))) + fun_prop + +lemma physicalNesting_preserving {A B C D E F : Type*} [MeasurableSpace A] [MeasurableSpace B] + [MeasurableSpace C] [MeasurableSpace D] [MeasurableSpace E] [MeasurableSpace F] + (μA : Measure A) (μB : Measure B) (μC : Measure C) + (μD : Measure D) (μE : Measure E) (μF : Measure F) + [SFinite μA] [SFinite μB] [SFinite μC] [SFinite μD] [SFinite μE] [SFinite μF] : + MeasurePreserving (physicalNestingEquiv : (A×(B×C))×((D×E)×F) ≃ᵐ A×(F×(D×(B×(E×C))))) + ((μA.prod (μB.prod μC)).prod ((μD.prod μE).prod μF)) + (μA.prod (μF.prod (μD.prod (μB.prod (μE.prod μC))))) := by + have h1 := measurePreserving_prodAssoc μA (μB.prod μC) ((μD.prod μE).prod μF) + have hr := (Measure.measurePreserving_swap (μ:=(μB.prod μC).prod (μD.prod μE)) (ν:=μF)).comp + ((measurePreserving_prodAssoc (μB.prod μC) (μD.prod μE) μF).symm MeasurableEquiv.prodAssoc) + have hq := quadShuffle_preserving μB μC μD μE + have hs := (Measure.measurePreserving_swap (μ:=μB) (ν:=μD)).prod + (Measure.measurePreserving_swap (μ:=μC) (ν:=μE)) + have ha := measurePreserving_prodAssoc μD μB (μE.prod μC) + exact ((MeasurePreserving.id μA).prod + (((MeasurePreserving.id μF).prod (ha.comp (hs.comp hq))).comp hr)).comp h1 + +lemma integral_count_eq_tsum {A : Type*} [Countable A] [MeasurableSpace A] + [MeasurableSingletonClass A] (f : A→ℂ) (hf : Integrable f Measure.count) : + (∫a,f a ∂Measure.count)=∑'a,f a := by + simpa using integral_countable hf + +theorem integral_physical_nesting {A B C : Type*} [Countable A] [Countable B] [Countable C] + [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] + [MeasurableSingletonClass A] [MeasurableSingletonClass B] [MeasurableSingletonClass C] + (F : A×(ℝ×(ℝ×(B×(ℝ×C))))→ℂ) + (hF : Integrable F ((Measure.count:Measure A).prod (volume.prod (volume.prod + ((Measure.count:Measure B).prod (volume.prod (Measure.count:Measure C))))))) : + (∫p,F p ∂((Measure.count:Measure A).prod (volume.prod (volume.prod + ((Measure.count:Measure B).prod (volume.prod (Measure.count:Measure C)))))))= + ∑'a : A,∫w : ℝ,∫t : ℝ,∑'b : B,∫z : ℝ,∑'c : C,F (a,(w,(t,(b,(z,c))))) := by + rw [integral_prod _ hF,integral_count_eq_tsum _ hF.integral_prod_left] + apply tsum_congr + intro a + have ha := (Measure.ae_count_iff.mp hF.prod_right_ae) a + rw [integral_prod _ ha] + apply integral_congr_ae + filter_upwards [ha.prod_right_ae] with w hw + rw [integral_prod _ hw] + apply integral_congr_ae + filter_upwards [hw.prod_right_ae] with t ht + rw [integral_prod _ ht,integral_count_eq_tsum _ ht.integral_prod_left] + apply tsum_congr + intro b + have hb := (Measure.ae_count_iff.mp ht.prod_right_ae) b + rw [integral_prod _ hb] + apply integral_congr_ae + filter_upwards [hb.prod_right_ae] with z hz + exact integral_count_eq_tsum _ hz + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/NestedMellin.lean b/lean/OAI/NumberTheory/DirichletL/Detector/NestedMellin.lean new file mode 100644 index 0000000000000000000000000000000000000000..c7e5750c35850f5768b062548701d4b78cfd93ae --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/NestedMellin.lean @@ -0,0 +1,57 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalRadial +import OAI.NumberTheory.DirichletL.Detector.OuterMellin + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve ProbeRow +local notation "O" => ActualEisensteinCubic.O + +def nestedMellinPhysicalProbe (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z ξ υ : ℝ) : ℂ := + ∑'s : {I : Ideal O // Supported I}, + if ∀P∈C.excluded,¬P∣s.val then + let a := primaryGenerator s.val + let has := (supported_span_primaryGenerator_iff s.val).mpr s.property + let qs : ℝ := Ideal.absNorm s.val + verticalIntegral υ (fun w=>(Y:ℂ)^(w-1)*(qs:ℂ)^(-w)*mellin W1 w* + (CanonicalRowCompletion.idealRowHom C.generator s.val / + (C.tau*C.residueMonoid a*(Real.sqrt (elementNorm C.generator*qs*X):ℂ)))* + verticalIntegral 4 (fun t=>(Real.sqrt qs:ℂ)⁻¹*((Z:ℂ)^t*Complex.exp (t^2))* + ∑'p : Ideal O×Ideal O,radialMellinSpectralTerm η C C.excluded D a has W0 + (elementNorm C.generator*qs*X) ξ t p.1 p.2)) + else 0 + +lemma verticalIntegral_mul_const (σ : ℝ) (F : ℂ→ℂ) (c : ℂ) : + verticalIntegral σ (fun s=>F s*c)=verticalIntegral σ F*c := by + unfold verticalIntegral + rw [integral_mul_const,mul_assoc] + +theorem markedPhysicalProbe_eq_nested_mellin (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hSne : S.Nonempty) + (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 ‖Complex.log (F i)‖) := by + apply (hb.mul_left (3/2)).of_nonneg_of_le (fun _ => norm_nonneg _) + intro i + exact (norm_log_le_defect _ ((hF i).trans (hhalf i))).trans + (mul_le_mul_of_nonneg_left (hF i) (by norm_num)) + +lemma product_eq_exp_log {ι : Type*} (F : ι → ℂ) (b : ι → ℝ) + (hb : Summable b) (hF : ∀ i, ‖F i-1‖ ≤ b i) (hhalf : ∀ i, b i ≤ 1/2) : + (∏' i, F i) = Complex.exp (∑' i, Complex.log (F i)) := by + apply HasProd.tprod_eq + apply ((log_summable_of_defect F b hb hF hhalf).of_norm.hasSum.cexp).congr + intro s + apply Finset.prod_congr rfl + intro i hi + exact Complex.exp_log (factor_ne_zero_of_defect _ ((hF i).trans (hhalf i))) + +lemma norm_log_sum_le {ι : Type*} (F : ι → ℂ) (b : ι → ℝ) + (hb : Summable b) (hF : ∀ i, ‖F i-1‖ ≤ b i) (hhalf : ∀ i, b i ≤ 1/2) : + ‖∑' i, Complex.log (F i)‖ ≤ (3/2:ℝ) * ∑' i, b i := by + have hs := log_summable_of_defect F b hb hF hhalf + calc + _ ≤ ∑' i, ‖Complex.log (F i)‖ := norm_tsum_le_tsum_norm hs + _ ≤ ∑' i, (3/2:ℝ)*b i := Summable.tsum_le_tsum + (fun i => (norm_log_le_defect _ ((hF i).trans (hhalf i))).trans + (mul_le_mul_of_nonneg_left (hF i) (by norm_num))) hs (hb.mul_left _) + _ = _ := tsum_mul_left + +theorem product_defect_le {ι : Type*} (F : ι → ℂ) (b : ι → ℝ) + (hb : Summable b) (hF : ∀ i, ‖F i-1‖ ≤ b i) (hhalf : ∀ i, b i ≤ 1/2) + (hsmall : (∑' i, b i) ≤ 1/6) : ‖(∏' i, F i)-1‖ ≤ 1/2 := by + have hlog := norm_log_sum_le F b hb hF hhalf + have hlog1 : ‖∑' i, Complex.log (F i)‖ ≤ 1 := by linarith + rw [product_eq_exp_log F b hb hF hhalf] + exact (Complex.norm_exp_sub_one_le hlog1).trans (by linarith) + +theorem normalProduct_analytic {ι : Type*} (F : ι → ℂ → ℂ) (b : ι → ℝ) + (U : Set ℂ) (hU : IsOpen U) (hb : Summable b) + (hF : ∀ i, AnalyticOnNhd ℂ (F i) U) + (hbound : ∀ i s, s ∈ U → ‖F i s-1‖ ≤ b i) + (hhalf : ∀ i, b i ≤ 1/2) : + AnalyticOnNhd ℂ (fun s => ∏' i, F i s) U := by + have hlogs : ∀ i, DifferentiableOn ℂ (fun s => Complex.log (F i s)) U := by + intro i + apply (hF i).differentiableOn.clog + intro s hs + have hsmall : ‖F i s-1‖ < 1 := lt_of_le_of_lt ((hbound i s hs).trans (hhalf i)) (by norm_num) + simpa only [add_sub_cancel] using Complex.mem_slitPlane_of_norm_lt_one hsmall + have hd := Complex.differentiableOn_tsum_of_summable_norm (hb.mul_left (3/2)) hlogs hU + (fun i s hs => (norm_log_le_defect _ ((hbound i s hs).trans (hhalf i))).trans + (mul_le_mul_of_nonneg_left (hbound i s hs) (by norm_num))) + apply DifferentiableOn.analyticOnNhd _ hU + apply hd.cexp.congr + intro s hs + exact product_eq_exp_log (fun i => F i s) b hb (fun i => hbound i s hs) hhalf + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/OuterIndex.lean b/lean/OAI/NumberTheory/DirichletL/Detector/OuterIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..9cc84585e7f6db6cc3227bbc7258eae1800f0bdb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/OuterIndex.lean @@ -0,0 +1,35 @@ +import OAI.NumberTheory.DirichletL.Detector.RawIndexGrouping + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O + +def sourceOuterEquiv (S : Finset (Ideal O)) : SourceOuter S ≃ + {K : {I : Ideal O // Supported I} // ∀P∈S,¬P∣K.val} where + toFun K := ⟨⟨K.val,K.property.1⟩,K.property.2⟩ + invFun K := ⟨K.val.val,K.val.property,K.property⟩ + left_inv _K := rfl + right_inv _K := rfl + +lemma sourceOuter_tsum (S : Finset (Ideal O)) (f : {I : Ideal O // Supported I}→ℂ) : + (∑'K : {I : Ideal O // Supported I},if ∀P∈S,¬P∣K.val then f K else 0)= + ∑'K : SourceOuter S,f ⟨K.val,K.property.1⟩ := by + have hs := tsum_subtype {K : {I : Ideal O // Supported I} | ∀P∈S,¬P∣K.val} f + have he := (sourceOuterEquiv S).tsum_eq (fun K=>f K.val) + calc + _ = ∑' K : {I : Ideal O // Supported I}, + Set.indicator {K | ∀ P ∈ S, ¬P ∣ K.val} f K := by + apply tsum_congr + intro K + simp only [Set.indicator, Set.mem_ofPred_eq] + split_ifs <;> rfl + _ = _ := hs.symm.trans he.symm + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/OuterMellin.lean b/lean/OAI/NumberTheory/DirichletL/Detector/OuterMellin.lean new file mode 100644 index 0000000000000000000000000000000000000000..940f8e6bac27e080b7efa4473b5eeaf43c775f1f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/OuterMellin.lean @@ -0,0 +1,34 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialScales + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open CompletedGauss + +lemma outer_source_vertical_inverse (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0(r:ℂ)^(-w)*mellin W w) := by + simpa only [verticalIntegral,Complex.ofReal_div,Complex.ofReal_one,Complex.ofReal_mul, + Complex.ofReal_ofNat] using compactMellin_inversion W a b ha hW (W.smooth (⊤:ℕ∞)) σ r hr + +lemma outer_source_scaled_inverse (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0(Y:ℂ)^(w-1)*(N:ℂ)^(-w)*mellin W w) := by + rw [outer_source_vertical_inverse W a b ha hW σ (N/Y) (div_pos hN hY)] + have hy : (Y:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hY.ne' + have he (w : ℂ) : (Y:ℂ)⁻¹*((N/Y:ℝ):ℂ)^(-w)=(Y:ℂ)^(w-1)*(N:ℂ)^(-w) := by + rw [Complex.ofReal_div,Complex.div_cpow_ofReal_nonneg hN.le hY.le,div_eq_mul_inv, + ←Complex.cpow_neg,neg_neg] + rw [show w-1=(-1)+w by ring,Complex.cpow_add _ _ hy,Complex.cpow_neg_one] + ring + unfold verticalIntegral + simp_rw [←he,mul_assoc,integral_const_mul] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PairPhase.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PairPhase.lean new file mode 100644 index 0000000000000000000000000000000000000000..899cfbf7ef4c7b7e3bfb37b9097adc068208d5cd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PairPhase.lean @@ -0,0 +1,51 @@ +import OAI.NumberTheory.DirichletL.Detector.PhasePowers + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhase +open ActualEisensteinCubic ActualEisensteinCoordinates CompletedGauss +open CanonicalRowCompletion CanonicalQuadraticSieve ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +def sexticPair (p q : O) : ℂ := + idealRowHom q (Ideal.span {p}) * idealRowHom p (Ideal.span {q}) + +theorem sexticPair_cube (p q : O) (hp : Prime p) (hq : Prime q) + (hprimaryP : goodLambda ^ 2 ∣ p - 1) (hprimaryQ : goodLambda ^ 2 ∣ q - 1) + (hsP : Supported (Ideal.span {p})) (hsQ : Supported (Ideal.span {q})) + (hcop : IsCoprime (Ideal.span {p} : Ideal O) (Ideal.span {q})) : + sexticPair p q ^ 3 = reciprocitySign p q := by + have hr : idealRowHom q (Ideal.span {p}) = + reciprocitySign p q * idealRowHom p (Ideal.span {q}) := + idealRowHom_prime_reciprocity p q hp hq hprimaryP hprimaryQ hsP hsQ + have h6 := idealRowHom_sixth_mask p (Ideal.span {q}) hsQ + rw [idealRowHom_argument_pow _ _ _ hsQ, ite_eq_left hcop.symm] at h6 + have h2 := reciprocitySign_sq p q (supported_residue_odd p hsP) (supported_residue_odd q hsQ) + calc + sexticPair p q ^ 3 = reciprocitySign p q ^ 3 * idealRowHom p (Ideal.span {q}) ^ 6 := by + unfold sexticPair + rw [hr] + ring + _ = reciprocitySign p q := by rw [h6, mul_one, pow_succ, h2, one_mul] + +theorem completed_pair_phase (p q : O) (hp : Prime p) (hq : Prime q) + (hprimaryP : goodLambda ^ 2 ∣ p - 1) (hprimaryQ : goodLambda ^ 2 ∣ q - 1) + (hsP : Supported (Ideal.span {p})) (hsQ : Supported (Ideal.span {q})) + (hcop : IsCoprime (Ideal.span {p} : Ideal O) (Ideal.span {q})) (e f l k : ℕ) : + sexticPair p q ^ ((e + 3 * l) * (f + 3 * k)) / sexticPair p q ^ (e * f) = + reciprocitySign p q ^ (e * k + f * l + l * k) := by + have h3 := sexticPair_cube p q hp hq hprimaryP hprimaryQ hsP hsQ hcop + have h2 := reciprocitySign_sq p q (supported_residue_odd p hsP) (supported_residue_odd q hsQ) + have hr : reciprocitySign p q ≠ 0 := by intro h; rw [h, zero_pow (by decide)] at h2; norm_num at h2 + have hz : sexticPair p q ≠ 0 := by intro h; rw [h, zero_pow (by decide)] at h3; exact hr h3.symm + have hexp : (e + 3 * l) * (f + 3 * k) = e * f + 3 * (e * k + f * l + 3 * l * k) := by ring + rw [hexp, pow_add, pow_mul (sexticPair p q) 3 (e * k + f * l + 3 * l * k), + h3, mul_div_cancel_left₀ _ (pow_ne_zero _ hz)] + have htail : e * k + f * l + 3 * l * k = (e * k + f * l + l * k) + 2 * (l * k) := by ring + rw [htail, pow_add, pow_mul (reciprocitySign p q) 2 (l * k), h2, one_pow, mul_one] + +end SevenEighths.ProbePhase +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Phase.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Phase.lean new file mode 100644 index 0000000000000000000000000000000000000000..84b40938b30795d03fa2da6dcb476b7cbb84c5a3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Phase.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Foundation + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhase +open ActualEisensteinCubic ActualEisensteinCoordinates QuadraticGaussRay ConcreteTraceCRT +open QuadraticAllOddCRT +local notation "O" => ActualEisensteinCubic.O + +def G (a : O) : ℂ := fixedGQuotientValue (Ideal.Quotient.mk (Ideal.span {(4 : O)}) a) + +def reciprocitySign (a b : O) : ℂ := + (quadraticRaySign (residue a) (residue b) : ℂ) + +theorem G_mul (a b : O) + (ha : EisensteinEPrimaryPhase.odd (residue a)) + (hb : EisensteinEPrimaryPhase.odd (residue b)) : + G (a * b) = G a * G b * reciprocitySign a b := by + change fixedGValue (residue (a * b)) = fixedGValue (residue a) * fixedGValue (residue b) * reciprocitySign a b + simp only [fixedGValue, ← fixed_two_mk_eq_residue_lift] + simp only [map_mul, mul_inv_rev, residue_mul] + rw [quadraticRayValue_mul _ _ ha hb] + unfold reciprocitySign + ring + +theorem reciprocitySign_mul_right (a b c : O) : + reciprocitySign a (b * c) = reciprocitySign a b * reciprocitySign a c := by + simp only [reciprocitySign, residue_mul, quadraticRaySign_mul_right, Int.cast_mul] + +theorem reciprocitySign_sq (a b : O) + (ha : EisensteinEPrimaryPhase.odd (residue a)) + (hb : EisensteinEPrimaryPhase.odd (residue b)) : + reciprocitySign a b ^ 2 = 1 := by + unfold reciprocitySign + exact_mod_cast quadraticRaySign_sq (residue a) (residue b) ha hb + +theorem reciprocitySign_cube_right (a b : O) + (ha : EisensteinEPrimaryPhase.odd (residue a)) + (hb : EisensteinEPrimaryPhase.odd (residue b)) : + reciprocitySign a (b ^ 3) = reciprocitySign a b := by + rw [show b ^ 3 = b ^ 2 * b by ring, reciprocitySign_mul_right, + pow_two, reciprocitySign_mul_right] + have hs := reciprocitySign_sq a b ha hb + calc + _ = reciprocitySign a b ^ 2 * reciprocitySign a b := by ring + _ = reciprocitySign a b := by rw [hs, one_mul] + +theorem G_completed_index (c n : O) + (hc : EisensteinEPrimaryPhase.odd (residue c)) + (hn : EisensteinEPrimaryPhase.odd (residue n)) : + G (c * n ^ 3) = G c * reciprocitySign c n * G (n ^ 3) := by + have hn3 : EisensteinEPrimaryPhase.odd (residue (n ^ 3)) := by + rw [show n ^ 3 = (n * n) * n by ring, residue_mul, residue_mul] + exact QuadraticAllOddCRT.odd_mul _ _ (QuadraticAllOddCRT.odd_mul _ _ hn hn) hn + rw [G_mul c (n ^ 3) hc hn3, reciprocitySign_cube_right c n hc hn] + ring + +theorem quadraticRayValue_cube (r : EisensteinEPrimaryPhase.Coord) + (hr : EisensteinEPrimaryPhase.odd r) : + quadraticRayValue (EisensteinEPrimaryPhase.mul + (EisensteinEPrimaryPhase.mul r r) r) = quadraticRayValue r := by + have he : ∀ r : EisensteinEPrimaryPhase.Coord, EisensteinEPrimaryPhase.odd r → + quadraticRayExponent (EisensteinEPrimaryPhase.mul + (EisensteinEPrimaryPhase.mul r r) r) = quadraticRayExponent r := by decide + rw [quadraticRayValue_eq_fourthRoot _ (odd_mul _ _ (odd_mul _ _ hr hr) hr), + he r hr, ← quadraticRayValue_eq_fourthRoot r hr] + +theorem G_cube (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) + (hu : IsUnit (Ideal.Quotient.mk cubicTwoIdeal a)) : + G (a ^ 3) = quadraticRayValue (residue a) := by + have hχ := congrArg + (fun η : MulChar (O ⧸ cubicTwoIdeal) O => η (Ideal.Quotient.mk cubicTwoIdeal a)) + (cubicChar_pow_three cubicTwoIdeal cubicTwoIdeal_good) + simp only [MulChar.pow_apply' _ (by decide : (3 : ℕ) ≠ 0), MulChar.one_apply hu] at hχ + have hc := congrArg eisEmbedding hχ + simp only [map_pow, map_one] at hc + change fixedGValue (residue (a ^ 3)) = quadraticRayValue (residue a) + simp only [fixedGValue, ← fixed_two_mk_eq_residue_lift] + simp only [map_pow, hc, inv_one, one_mul] + rw [show a ^ 3 = (a * a) * a by ring, residue_mul, residue_mul] + exact quadraticRayValue_cube (residue a) ha + +end SevenEighths.ProbePhase +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhaseCancellation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhaseCancellation.lean new file mode 100644 index 0000000000000000000000000000000000000000..e31f194d2e1cd590848e01c8b084bc60d43fa37d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhaseCancellation.lean @@ -0,0 +1,66 @@ +import OAI.NumberTheory.DirichletL.Detector.Phase + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhase +open ActualEisensteinCubic ActualEisensteinCoordinates QuadraticGaussRay ConcreteTraceCRT +open QuadraticAllOddCRT CanonicalRowCompletion CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O + +theorem quadraticRayValue_norm_one (r : EisensteinEPrimaryPhase.Coord) + (hr : EisensteinEPrimaryPhase.odd r) : ‖quadraticRayValue r‖ = 1 := by + rw [quadraticRayValue_eq_fourthRoot r hr] + simp [fourthRoot] + +theorem G_norm_one (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) + (hu : IsUnit (Ideal.Quotient.mk cubicTwoIdeal a)) : ‖G a‖ = 1 := by + have hχ := congrArg + (fun η : MulChar (O ⧸ cubicTwoIdeal) O => η (Ideal.Quotient.mk cubicTwoIdeal a)) + (cubicChar_pow_three cubicTwoIdeal cubicTwoIdeal_good) + simp only [MulChar.pow_apply' _ (by decide : (3 : ℕ) ≠ 0), MulChar.one_apply hu] at hχ + have hc := congrArg eisEmbedding hχ + simp only [map_pow, map_one] at hc + have hn := Complex.norm_eq_one_of_pow_eq_one hc (by decide : (3 : ℕ) ≠ 0) + change ‖fixedGValue (residue a)‖ = 1 + simp only [fixedGValue, ← fixed_two_mk_eq_residue_lift, norm_mul, norm_inv, + hn, inv_one, one_mul] + exact quadraticRayValue_norm_one _ ha + +theorem cubicTwo_isUnit_of_odd (a : O) + (ha : EisensteinEPrimaryPhase.odd (residue a)) : + IsUnit (Ideal.Quotient.mk cubicTwoIdeal a) := by + let : Field (O ⧸ cubicTwoIdeal) := Ideal.Quotient.field _ + apply isUnit_iff_ne_zero.mpr + intro hz + have hm := Ideal.Quotient.eq_zero_iff_mem.mp hz + have hd : (2 : O) ∣ a := by + simpa only [cubicTwoIdeal, Ideal.mem_span_singleton, neg_dvd] using hm + exact ((odd_residue_iff_not_two_dvd a).mp ha) hd + +theorem G_norm_one_of_odd (a : O) + (ha : EisensteinEPrimaryPhase.odd (residue a)) : ‖G a‖ = 1 := + G_norm_one a ha (cubicTwo_isUnit_of_odd a ha) + +theorem G_conjugate_cancel (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) + (hu : IsUnit (Ideal.Quotient.mk cubicTwoIdeal a)) : star (G a) * G a = 1 := by + have hn := G_norm_one a ha hu + have hs : star (G a) = (G a)⁻¹ := (Complex.inv_eq_conj hn).symm + rw [hs] + exact inv_mul_cancel₀ (norm_ne_zero_iff.mp (by rw [hn]; norm_num)) + +theorem completed_phase_cancel (c n : O) + (hc : EisensteinEPrimaryPhase.odd (residue c)) + (hn : EisensteinEPrimaryPhase.odd (residue n)) + (hu : IsUnit (Ideal.Quotient.mk cubicTwoIdeal (c * n ^ 3))) : + star (G (c * n ^ 3)) * (G c * reciprocitySign c n * G (n ^ 3)) = 1 := by + rw [← G_completed_index c n hc hn] + apply G_conjugate_cancel _ _ hu + rw [show c * n ^ 3 = c * ((n * n) * n) by ring] + simp only [residue_mul] + exact odd_mul _ _ hc (odd_mul _ _ (odd_mul _ _ hn hn) hn) + +end SevenEighths.ProbePhase +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhasePowers.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhasePowers.lean new file mode 100644 index 0000000000000000000000000000000000000000..955d0a202cccd11b0114c1856cd46da450bc11eb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhasePowers.lean @@ -0,0 +1,99 @@ +import OAI.NumberTheory.DirichletL.Detector.PrimePhase + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbePhase +open ActualEisensteinCubic ActualEisensteinCoordinates QuadraticGaussRay QuadraticAllOddCRT +local notation "O" => ActualEisensteinCubic.O + +lemma residue_one_mod_four : residue (1 : O) = (1, 0) := by + have he : (1 : O) = eval 1 0 := by simp [eval] + rw [he, residue_eval] + norm_num + +lemma odd_residue_one : EisensteinEPrimaryPhase.odd (residue (1 : O)) := by + rw [residue_one_mod_four] + decide + +lemma odd_residue_pow (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) (n : ℕ) : + EisensteinEPrimaryPhase.odd (residue (a ^ n)) := by + induction n with + | zero => simpa only [pow_zero] using odd_residue_one + | succ n ih => + rw [pow_succ, residue_mul] + exact odd_mul _ _ ih ha + +lemma reciprocitySign_symm (a b : O) : reciprocitySign a b = reciprocitySign b a := by + simp only [reciprocitySign, quadraticRaySign_symm] + +lemma reciprocitySign_one_left (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) : + reciprocitySign 1 a = 1 := by + have ht : ∀ r : EisensteinEPrimaryPhase.Coord, EisensteinEPrimaryPhase.odd r → + quadraticRaySign (1, 0) r = 1 := by decide + unfold reciprocitySign + rw [residue_one_mod_four] + exact_mod_cast ht (residue a) ha + +lemma reciprocitySign_mul_left (a b c : O) : + reciprocitySign (a * b) c = reciprocitySign a c * reciprocitySign b c := by + simp only [reciprocitySign, residue_mul, quadraticRaySign_mul_left, Int.cast_mul] + +lemma reciprocitySign_pow_left (a b : O) + (hb : EisensteinEPrimaryPhase.odd (residue b)) (n : ℕ) : + reciprocitySign (a ^ n) b = reciprocitySign a b ^ n := by + induction n with + | zero => simp only [pow_zero, reciprocitySign_one_left b hb] + | succ n ih => rw [pow_succ, reciprocitySign_mul_left, ih, pow_succ] + +lemma reciprocitySign_pow_right (a b : O) + (ha : EisensteinEPrimaryPhase.odd (residue a)) (n : ℕ) : + reciprocitySign a (b ^ n) = reciprocitySign a b ^ n := by + rw [reciprocitySign_symm, reciprocitySign_pow_left b a ha n, reciprocitySign_symm b a] + +lemma G_one : G (1 : O) = 1 := by + have hq : quadraticRayValue (residue (1 : O)) = 1 := by + rw [residue_one_mod_four] + change breveGaussianFourTerms 1 0 = 1 + rw [breveGaussianFourTerms_formula] + norm_num + have he := G_cube (1 : O) odd_residue_one (cubicTwo_isUnit_of_odd 1 odd_residue_one) + simpa only [one_pow, hq] using he + +theorem G_pow (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) (n : ℕ) : + G (a ^ n) = G a ^ n * reciprocitySign a a ^ (n.choose 2) := by + induction n with + | zero => simp [G_one] + | succ n ih => + rw [pow_succ, G_mul (a ^ n) a (odd_residue_pow a ha n) ha, ih, + reciprocitySign_pow_left a a ha n, Nat.choose_succ_succ, Nat.choose_one_right, + pow_add, pow_succ] + ring + +theorem reciprocitySign_cube_self (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) : + reciprocitySign (a ^ 3) (a ^ 3) = reciprocitySign a a := by + rw [reciprocitySign_cube_right (a ^ 3) a (odd_residue_pow a ha 3) ha, + reciprocitySign_symm, reciprocitySign_cube_right a a ha ha] + +theorem G_cube_power (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) (l : ℕ) : + G (a ^ (3 * l)) = G (a ^ 3) ^ l * reciprocitySign a a ^ (l.choose 2) := by + rw [pow_mul, G_pow (a ^ 3) (odd_residue_pow a ha 3), reciprocitySign_cube_self a ha] + +theorem G_completed_prime_power (a : O) (ha : EisensteinEPrimaryPhase.odd (residue a)) + (e l : ℕ) (he : e ≤ 1) : + G (a ^ (e + 3 * l)) = + G a ^ e * G (a ^ 3) ^ l * reciprocitySign a a ^ (e * l + l.choose 2) := by + have hc : e = 0 ∨ e = 1 := by omega + rcases hc with rfl | rfl + · simpa only [zero_add, zero_mul, pow_zero, one_mul] using G_cube_power a ha l + · rw [pow_add, pow_one, G_mul a (a ^ (3 * l)) ha (odd_residue_pow a ha _), + G_cube_power a ha l, pow_mul, reciprocitySign_pow_right a (a ^ 3) ha l, + reciprocitySign_cube_right a a ha ha] + simp only [pow_one, one_mul, pow_add] + ring + +end SevenEighths.ProbePhase +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Physical.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Physical.lean new file mode 100644 index 0000000000000000000000000000000000000000..f0012db7d94f8f23893732b923c3b346f2fc89bf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Physical.lean @@ -0,0 +1,118 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.Row +import OAI.NumberTheory.DirichletL.Detector.Compensation + +namespace OAI + +noncomputable section + +open scoped BigOperators Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open CubicEisenstein ProbeCompleted ProbeRow + +local notation "O" => ActualEisensteinCubic.O + +structure CalibrationData where + excluded : Finset (Ideal O) + generator : O + generator_ne_zero : generator ≠ 0 + residue : MulChar (O ⧸ Ideal.span {generator}) ℂ + +def elementNorm (a : O) : ℝ := Ideal.absNorm (Ideal.span {a}) + +def CalibrationData.residueMonoid (C : CalibrationData) : O →* ℂ := + C.residue.toMonoidHom.comp (Ideal.Quotient.mk (Ideal.span {C.generator})).toMonoidHom + +def CalibrationData.Xi (C : CalibrationData) : O →* ℂ := + C.residueMonoid * (idealRowHom C.generator).toMonoidHom.comp principalIdealHom.toMonoidHom + +def CalibrationData.tau (C : CalibrationData) : ℂ := + (∑' d : O ⧸ Ideal.span {C.generator}, C.residue d * + quotientTrace C.generator C.generator_ne_zero d) / + (Real.sqrt (elementNorm C.generator) : ℂ) + +def sexticGauss (s : O) (hs : s ≠ 0) (h : O) : ℂ := + ∑' d : O ⧸ Ideal.span {s}, + idealRowHom (GaussianShiftedPartition.representative s d) (Ideal.span {s}) * + quotientTrace s hs (Ideal.Quotient.mk _ h * d) + +theorem sexticGauss_coefficient_mk (s : O) (a : O) : + idealRowHom (GaussianShiftedPartition.representative s + (Ideal.Quotient.mk (Ideal.span {s}) a)) (Ideal.span {s}) = + idealRowHom a (Ideal.span {s}) := by + apply idealRowHom_congr_mod + apply Ideal.Quotient.eq.mp + exact GaussianShiftedPartition.representative_spec _ _ + +def verticalIntegral (σ : ℝ) (F : ℂ → ℂ) : ℂ := + ((1 / (2 * Real.pi) : ℝ) : ℂ) * ∫ y : ℝ, F ((σ : ℂ) + y * Complex.I) + +def markedPhysicalProbe (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W₀ W₁ : ℝ → ℂ) (X Y Z : ℝ) : ℂ := + (Y : ℂ)⁻¹ * ∑' s : {I : Ideal O // Supported I}, + if ∀ p ∈ C.excluded, ¬p ∣ s.val then + let a := primaryGenerator s.val + let ha := supported_primaryGenerator_ne_zero s.val s.property + let has := (supported_span_primaryGenerator_iff s.val).mpr s.property + let q_s : ℝ := Ideal.absNorm s.val + W₁ (q_s / Y) * idealRowHom C.generator s.val / + (C.tau * C.residueMonoid a * (Real.sqrt (elementNorm C.generator * q_s * X) : ℂ)) * + ∑' m : O, + C.residueMonoid m * (Real.sqrt q_s : ℂ)⁻¹ * sexticGauss a ha (-m) * + W₀ (elementNorm m / (elementNorm C.generator * q_s * X)) * + verticalIntegral 4 (fun t => (Z : ℂ) ^ t * Complex.exp (t ^ 2) * + spectralRow C.excluded D (rowCoefficient η C.Xi a has m) t) + else 0 + +def physicalProbe (η : HeckeFamily.Character) (C : CalibrationData) + (W₀ W₁ : ℝ → ℂ) (X Y Z : ℝ) : ℂ := + markedPhysicalProbe η C 1 W₀ W₁ X Y Z + +def slotProduct {K : ℕ} (p : Fin K → O) (J : Finset (Fin K)) : O := ∏ i ∈ J, p i + +def compensatedTuple {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W₀ W₁ : ℝ → ℂ) (p : Fin K → O) (X Y Z : ℝ) : ℂ := + ProbeCompensation.tupleOperation p elementNorm (HeckeFamily.elementCoeff η) + (fun a => markedPhysicalProbe η C (Ideal.span {a}) W₀ W₁) X Y Z + +@[simp] theorem elementNorm_one : elementNorm (1 : O) = 1 := by + simp [elementNorm] + +attribute [local irreducible] markedPhysicalProbe + +theorem compensatedTuple_zero (η : HeckeFamily.Character) (C : CalibrationData) + (W₀ W₁ : ℝ → ℂ) (p : Fin 0 → O) (X Y Z : ℝ) : + compensatedTuple η C W₀ W₁ p X Y Z = physicalProbe η C W₀ W₁ X Y Z := by + unfold compensatedTuple + rw [ProbeCompensation.tupleOperation_zero p elementNorm (HeckeFamily.elementCoeff η) + elementNorm_one (HeckeFamily.elementCoeff_one η)] + change markedPhysicalProbe η C (Ideal.span {(1 : O)}) W₀ W₁ X Y Z = + markedPhysicalProbe η C 1 W₀ W₁ X Y Z + rw [Ideal.span_singleton_one, Ideal.one_eq_top] + +theorem compensatedTuple_one (η : HeckeFamily.Character) (C : CalibrationData) + (W₀ W₁ : ℝ → ℂ) (p : Fin 1 → O) (X Y Z : ℝ) : + compensatedTuple η C W₀ W₁ p X Y Z = + star (HeckeFamily.elementCoeff η (p 0)) * + markedPhysicalProbe η C (Ideal.span {p 0}) W₀ W₁ X Y (Z * elementNorm (p 0)) - + (elementNorm (p 0) ^ (-(3 / 2 : ℝ)) : ℝ) * + physicalProbe η C W₀ W₁ (X / elementNorm (p 0)) (Y / elementNorm (p 0)) Z := by + unfold compensatedTuple + rw [ProbeCompensation.tupleOperation_one p elementNorm (HeckeFamily.elementCoeff η) + elementNorm_one (HeckeFamily.elementCoeff_one η)] + change _ = _ - _ * markedPhysicalProbe η C 1 W₀ W₁ _ _ Z + rw [Ideal.span_singleton_one, Ideal.one_eq_top] + +def compensatedPhysicalProbe {K : ℕ} (η : HeckeFamily.Character) (C : CalibrationData) + (W₀ W₁ : ℝ → ℂ) (slotPrimes : Fin K → Finset O) + (slotWindow : Fin K → ℝ → ℂ) (slotScale : Fin K → ℝ) (X Y Z : ℝ) : ℂ := + ∑ p : ((i : Fin K) → {a : O // a ∈ slotPrimes i}), + (∏ i : Fin K, slotWindow i (elementNorm (p i).val / slotScale i)) * + compensatedTuple η C W₀ W₁ (fun i => (p i).val) X Y Z + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalAnalytic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalAnalytic.lean new file mode 100644 index 0000000000000000000000000000000000000000..e68ffb8310680af93f8aece99872ba7b9b2b3aa3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalAnalytic.lean @@ -0,0 +1,62 @@ +import OAI.NumberTheory.DirichletL.Detector.Physical +import OAI.NumberTheory.DirichletL.Detector.RowAnalytic + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open MeasureTheory ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open ProbeRow CubicEisenstein CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O + +theorem CalibrationData.residueMonoid_norm_le_one (C : CalibrationData) (a : O) : + ‖C.residueMonoid a‖ ≤ 1 := by + let : Finite (O ⧸ Ideal.span {C.generator}) := + ConcreteTraceCRT.finite_quotient_span C.generator_ne_zero + let : Fintype (O ⧸ Ideal.span {C.generator}) := Fintype.ofFinite _ + exact FiniteRayExpansion.norm_char_le_one C.residue (Ideal.Quotient.mk _ a) + +theorem CalibrationData.Xi_norm_le_one (C : CalibrationData) (a : O) : + ‖C.Xi a‖ ≤ 1 := by + change ‖C.residueMonoid a * idealRowHom C.generator (Ideal.span {a})‖ ≤ 1 + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (C.residueMonoid_norm_le_one a)).trans + (idealRowHom_norm _ _) + +theorem CalibrationData.Xi_norm_one (C : CalibrationData) (a : O) + (ha : Supported (Ideal.span {a})) (hcop : IsCoprime C.generator a) : + ‖C.Xi a‖ = 1 := by + let : Finite (O ⧸ Ideal.span {C.generator}) := + ConcreteTraceCRT.finite_quotient_span C.generator_ne_zero + let : Fintype (O ⧸ Ideal.span {C.generator}) := Fintype.ofFinite _ + have hu := (CubicEisenstein.isUnit_quotient_span_iff C.generator a).mpr hcop + have hξ : ‖C.residueMonoid a‖ = 1 := by + exact (FiniteRayExpansion.norm_char_unit C.residue hu.unit) + have hc : IsCoprime (Ideal.span {a} : Ideal O) (Ideal.span {C.generator}) := + (Ideal.isCoprime_span_singleton_iff a C.generator).mpr hcop.symm + have h6 := idealRowHom_sixth_mask C.generator (Ideal.span {a}) ha + rw [idealRowHom_argument_pow _ _ _ ha, ite_eq_left hc] at h6 + change ‖C.residueMonoid a * idealRowHom C.generator (Ideal.span {a})‖ = 1 + rw [norm_mul, hξ, Complex.norm_eq_one_of_pow_eq_one h6 (by decide : (6 : ℕ) ≠ 0), mul_one] + +theorem calibrated_rowCoefficient_apply (η : HeckeFamily.Character) (C : CalibrationData) + (s : O) (hs : Supported (Ideal.span {s})) (m a : O) + (ha : Supported (Ideal.span {a})) (hcop : IsCoprime C.generator a) : + rowCoefficient η C.Xi s hs m a = HeckeFamily.elementCoeff η a * (C.Xi a)⁻¹ * + sexticReciprocityPhase a s * idealRowHom m (Ideal.span {a}) := + rowCoefficient_apply_unit η C.Xi s hs m a (C.Xi_norm_one a ha hcop) + +theorem physicalRow_integrable (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (s : O) (hs : Supported (Ideal.span {s})) (m : O) + (Z : ℝ) (hZ : 0 < Z) : + Integrable (fun y : ℝ => (Z : ℂ) ^ ((4 : ℂ) + y * Complex.I) * + Complex.exp (((4 : ℂ) + y * Complex.I) ^ 2) * + spectralRow C.excluded D (rowCoefficient η C.Xi s hs m) ((4 : ℂ) + y * Complex.I)) := by + exact spectralRow_vertical_integrable C.excluded D (rowCoefficient η C.Xi s hs m) + (fun a => rowCoefficient_norm_le_one η C.Xi C.Xi_norm_le_one s hs m a) + 4 (by norm_num) Z hZ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCRT.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCRT.lean new file mode 100644 index 0000000000000000000000000000000000000000..64f999ca4c4e6b0a2eac4e14d1a6149b2bdeb338 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCRT.lean @@ -0,0 +1,229 @@ +import OAI.NumberTheory.DirichletL.Detector.CalibrationRemoval + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein CanonicalRowCompletion GaussianShiftedPartition +open CanonicalQuadraticSieve CenteredMomentCorrelation CenteredMomentCommonSupport +open CenteredMomentFourier CenteredMomentFirstPoisson CenteredMomentSupportedCorrelation +local notation "O" => ActualEisensteinCubic.O + +theorem coprime_function_fourier (a b : O) (ha : a ≠ 0) (hb : b ≠ 0) + (hcop : IsCoprime a b) + [Fintype (Residue a)] [Fintype (Residue b)] [Fintype (Residue (a * b))] + (Fa : Residue a → ℂ) (F : Residue b → ℂ) + (h : Residue (a * b)) : + (∑ x : Residue (a * b), + Fa (frequencyReduction a (a * b) (dvd_mul_right a b) x) * + F (frequencyReduction b (a * b) (dvd_mul_left b a) x) * + quotientTrace (a * b) (mul_ne_zero ha hb) (h * x)) = + (∑ x : Residue a, Fa (Ideal.Quotient.mk _ b*x) * + quotientTrace a ha (frequencyReduction a (a*b) (dvd_mul_right a b) h*x)) * + (∑ y : Residue b, F (Ideal.Quotient.mk _ a*y) * + quotientTrace b hb (frequencyReduction b (a*b) (dvd_mul_left b a) h*y)) := by + let ua := residueUnit a b hcop + let ub := residueUnit b a hcop.symm + let e : Residue a × Residue b ≃ Residue (a * b) := + (ua.mulLeft.prodCongr ub.mulLeft).trans (principalCRT a b hcop).toEquiv.symm + have heproj (x : Residue a × Residue b) : principalCRT a b hcop (e x) = + ((ua : Residue a) * x.1, (ub : Residue b) * x.2) := by + change (principalCRT a b hcop).toEquiv + ((principalCRT a b hcop).toEquiv.symm ((ua : Residue a) * x.1, (ub : Residue b) * x.2)) = _ + exact (principalCRT a b hcop).toEquiv.apply_symm_apply _ + have he (x : Residue a × Residue b) : e x = + scaledResidue a b (a * b) rfl x.1 + scaledResidue b a (a * b) (mul_comm a b) x.2 := by + apply (principalCRT a b hcop).injective + rw [heproj, map_add, principalCRT_scaled_left, principalCRT_scaled_right] + simp only [Prod.mk_add_mk, add_zero, zero_add, ua, ub, residueUnit_coe] + have hproj (x : Residue (a * b)) : + (frequencyReduction a (a * b) (dvd_mul_right a b) x, + frequencyReduction b (a * b) (dvd_mul_left b a) x) = principalCRT a b hcop x := by + obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective x + simp only [frequencyReduction_mk, principalCRT_mk] + have hprojA (x : Residue a × Residue b) : + frequencyReduction a (a * b) (dvd_mul_right a b) (e x) = Ideal.Quotient.mk _ b * x.1 := by + have ht := congrArg Prod.fst (hproj (e x)) + rw [heproj] at ht + simpa only [ua, residueUnit_coe] using ht + have hprojB (x : Residue a × Residue b) : + frequencyReduction b (a * b) (dvd_mul_left b a) (e x) = Ideal.Quotient.mk _ a * x.2 := by + have ht := congrArg Prod.snd (hproj (e x)) + rw [heproj] at ht + simpa only [ub, residueUnit_coe] using ht + rw [← e.sum_comp] + simp_rw [hprojA, hprojB] + simp only [ he, mul_add, AddChar.map_add_eq_mul, + quotientTrace_scaled a b (a * b) rfl ha hb (mul_ne_zero ha hb), + quotientTrace_scaled b a (a * b) (mul_comm a b) hb ha (mul_ne_zero ha hb)] + simp only [Fintype.sum_prod_type, ] + simp only [Finset.mul_sum, Finset.sum_mul] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro x _ + apply Finset.sum_congr rfl + intro y _ + ring + +theorem sexticGauss_coprime_product (a b : O) + (ha : Supported (Ideal.span {a})) (hb : Supported (Ideal.span {b})) + (hcop : IsCoprime a b) (H : O) : + sexticGauss (a*b) (mul_ne_zero (supportedElement_ne_zero a ha) (supportedElement_ne_zero b hb)) H = + idealRowHom b (Ideal.span {a}) * idealRowHom a (Ideal.span {b}) * + sexticGauss a (supportedElement_ne_zero a ha) H * + sexticGauss b (supportedElement_ne_zero b hb) H := by + let := finite_quotient_span (supportedElement_ne_zero a ha) + let := finite_quotient_span (supportedElement_ne_zero b hb) + let := finite_quotient_span (mul_ne_zero (supportedElement_ne_zero a ha) (supportedElement_ne_zero b hb)) + let : Fintype (Residue a) := Fintype.ofFinite _ + let : Fintype (Residue b) := Fintype.ofFinite _ + let : Fintype (Residue (a*b)) := Fintype.ofFinite _ + have he := coprime_character_fourier a b (supportedElement_ne_zero a ha) (supportedElement_ne_zero b hb) + hcop (supportedModulusCharacter a ha) (supportedModulusCharacter b hb) (Ideal.Quotient.mk _ H) + simp only [frequencyReduction_mk, supportedModulusCharacter_mk, + residueGauss_supported_mk] at he + rw [← he] + unfold sexticGauss + rw [tsum_fintype] + apply Finset.sum_congr rfl + intro x hx + obtain ⟨m,rfl⟩ := Ideal.Quotient.mk_surjective x + rw [sexticGauss_coefficient_mk] + simp only [frequencyReduction_mk, supportedModulusCharacter_mk] + congr 1 + rw [← Ideal.span_singleton_mul_span_singleton, map_mul] + +lemma elementFourier_const_mul (c : O) (hc : c≠0) (F : O → ℂ) (H : O) (B : ℂ) : + elementFourier c hc (fun m => B*F m) H = B*elementFourier c hc F H := by + simp only [elementFourier, mul_assoc, tsum_mul_left] + +lemma bareMoving_product (A B s r : O) (hs : Supported (Ideal.span {s})) + (hr : Supported (Ideal.span {r})) (hcop : IsCoprime s r) (m : O) : + idealRowHom m (Ideal.span {A*B}) * + sexticGauss (s*r) (mul_ne_zero (supportedElement_ne_zero s hs) (supportedElement_ne_zero r hr)) (-m) = + (idealRowHom r (Ideal.span {s}) * idealRowHom s (Ideal.span {r})) * + ((idealRowHom m (Ideal.span {A}) * sexticGauss s (supportedElement_ne_zero s hs) (-m)) * + (idealRowHom m (Ideal.span {B}) * sexticGauss r (supportedElement_ne_zero r hr) (-m))) := by + rw [sexticGauss_coprime_product s r hs hr hcop] + rw [← Ideal.span_singleton_mul_span_singleton, map_mul] + ring + +theorem barePhysicalFourier_product (A B s r : O) (hA : A≠0) (hB : B≠0) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hcop : IsCoprime (A*s) (B*r)) (H : O) : + barePhysicalFourier (A*B) (s*r) (mul_ne_zero hA hB) + (mul_ne_zero (supportedElement_ne_zero s hs) (supportedElement_ne_zero r hr)) H = + (idealRowHom r (Ideal.span {s}) * idealRowHom s (Ideal.span {r})) * + (idealRowHom (B*r) (Ideal.span {A}) * (idealRowHom (B*r) (Ideal.span {s}))⁻¹) * + (idealRowHom (A*s) (Ideal.span {B}) * (idealRowHom (A*s) (Ideal.span {r}))⁻¹) * + barePhysicalFourier A s hA (supportedElement_ne_zero s hs) H * + barePhysicalFourier B r hB (supportedElement_ne_zero r hr) H := by + have hsc : IsCoprime s r := hcop.of_mul_left_right.of_mul_right_right + have hc1 : IsCoprime (B*r) s := hcop.of_mul_left_right.symm + have hc2 : IsCoprime (A*s) r := hcop.of_mul_right_right + have hAs := mul_ne_zero hA (supportedElement_ne_zero s hs) + have hBr := mul_ne_zero hB (supportedElement_ne_zero r hr) + let := finite_quotient_span hAs + let := finite_quotient_span hBr + let := finite_quotient_span (mul_ne_zero hAs hBr) + let : Fintype (Residue (A*s)) := Fintype.ofFinite _ + let : Fintype (Residue (B*r)) := Fintype.ofFinite _ + let : Fintype (Residue ((A*s)*(B*r))) := Fintype.ofFinite _ + have he := coprime_function_fourier (A*s) (B*r) hAs hBr hcop + (movingQuotient A s (supportedElement_ne_zero s hs)) + (movingQuotient B r (supportedElement_ne_zero r hr)) (Ideal.Quotient.mk _ H) + simp only [frequencyReduction_mk] at he + simp_rw [movingQuotient_unit_scale A s hs (B*r) hc1, + movingQuotient_unit_scale B r hr (A*s) hc2, mul_assoc] at he + simp only [← Finset.mul_sum] at he + have hexpand : elementFourier ((A*s)*(B*r)) (mul_ne_zero hAs hBr) + (fun m => (idealRowHom m (Ideal.span {A}) * sexticGauss s (supportedElement_ne_zero s hs) (-m)) * + (idealRowHom m (Ideal.span {B}) * sexticGauss r (supportedElement_ne_zero r hr) (-m))) H = + (idealRowHom (B*r) (Ideal.span {A}) * (idealRowHom (B*r) (Ideal.span {s}))⁻¹) * + (idealRowHom (A*s) (Ideal.span {B}) * (idealRowHom (A*s) (Ideal.span {r}))⁻¹) * + barePhysicalFourier A s hA (supportedElement_ne_zero s hs) H * + barePhysicalFourier B r hB (supportedElement_ne_zero r hr) H := by + unfold elementFourier + rw [tsum_fintype] + calc + _ = _ := by + apply Finset.sum_congr rfl + intro x hx + have hmk := representative_spec ((A*s)*(B*r)) x + have hred1 : frequencyReduction (A*s) ((A*s)*(B*r)) (dvd_mul_right _ _) x = + Ideal.Quotient.mk _ (representative ((A*s)*(B*r)) x) := by + conv_lhs => rw [← hmk] + rfl + have hred2 : frequencyReduction (B*r) ((A*s)*(B*r)) (dvd_mul_left _ _) x = + Ideal.Quotient.mk _ (representative ((A*s)*(B*r)) x) := by + conv_lhs => rw [← hmk] + rfl + rw [hred1, hred2, movingQuotient_mk, movingQuotient_mk] + ring + _ = _ := he + _ = _ := by + simp only [barePhysicalFourier, elementFourier, movingQuotient, tsum_fintype] + ring + simp only [barePhysicalFourier] at hexpand + unfold barePhysicalFourier + rw [elementFourier_congr ((A*B)*(s*r)) ((A*s)*(B*r)) _ (mul_ne_zero hAs hBr) _ H (by ring)] + simp_rw [bareMoving_product A B s r hs hr hsc] + rw [elementFourier_const_mul, hexpand] + ring + +theorem bareCongruenceCoefficient_product (A B s r : O) (hA : A≠0) (hB : B≠0) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hcop : IsCoprime (A*s) (B*r)) (H : O) : + bareCongruenceCoefficient (A*B) (s*r) (mul_ne_zero hA hB) H = + (idealRowHom r (Ideal.span {s}) * idealRowHom s (Ideal.span {r})) * + (idealRowHom (B*r) (Ideal.span {A}) * (idealRowHom (B*r) (Ideal.span {s}))⁻¹) * + (idealRowHom (A*s) (Ideal.span {B}) * (idealRowHom (A*s) (Ideal.span {r}))⁻¹) * + bareCongruenceCoefficient A s hA H * bareCongruenceCoefficient B r hB H := by + have he := barePhysicalFourier_product A B s r hA hB hs hr hcop H + simp only [barePhysicalFourier_eq] at he + have hnorm : Ideal.absNorm (Ideal.span {s*r}) = + Ideal.absNorm (Ideal.span {s}) * Ideal.absNorm (Ideal.span {r}) := by + rw [← Ideal.span_singleton_mul_span_singleton, map_mul] + rw [hnorm, Nat.cast_mul] at he + have hns : (Ideal.absNorm (Ideal.span {s}):ℂ)≠0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr (supportedElement_ne_zero s hs)) + have hnr : (Ideal.absNorm (Ideal.span {r}):ℂ)≠0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr (supportedElement_ne_zero r hr)) + apply mul_left_cancel₀ (mul_ne_zero hns hnr) + rw [he] + ring + +lemma idealRowHom_ne_zero_of_coprime (s a : O) + (hs : Supported (Ideal.span {s})) (hc : IsCoprime s a) : + idealRowHom a (Ideal.span {s})≠0 := by + rw [← supportedModulusCharacter_mk s hs a] + exact (supportedModulusCharacter s hs).apply_ne_zero_iff.mpr + ((isUnit_quotient_span_iff s a).mpr hc) + +theorem bareCongruenceCoefficient_product_reduced (A B s r : O) (hA : A≠0) (hB : B≠0) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hcop : IsCoprime (A*s) (B*r)) (H : O) : + bareCongruenceCoefficient (A*B) (s*r) (mul_ne_zero hA hB) H = + (idealRowHom B (Ideal.span {A}) * idealRowHom r (Ideal.span {A}) * + idealRowHom A (Ideal.span {B}) * idealRowHom s (Ideal.span {B})) / + (idealRowHom B (Ideal.span {s}) * idealRowHom A (Ideal.span {r})) * + bareCongruenceCoefficient A s hA H * bareCongruenceCoefficient B r hB H := by + rw [bareCongruenceCoefficient_product A B s r hA hB hs hr hcop H] + have hsr := idealRowHom_ne_zero_of_coprime s r hs + hcop.of_mul_left_right.of_mul_right_right + have hrs := idealRowHom_ne_zero_of_coprime r s hr + hcop.of_mul_left_right.of_mul_right_right.symm + have hsB := idealRowHom_ne_zero_of_coprime s B hs + hcop.of_mul_left_right.of_mul_right_left + have hrA := idealRowHom_ne_zero_of_coprime r A hr + hcop.of_mul_left_left.of_mul_right_right.symm + simp only [idealRowHom_argument_mul] + field_simp + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCoefficient.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCoefficient.lean new file mode 100644 index 0000000000000000000000000000000000000000..e08f777a01e53727650ddec2f76e7c1572d7f492 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCoefficient.lean @@ -0,0 +1,107 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalFourier + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CubicEisenstein GaussianShiftedPartition CanonicalRowCompletion +local notation "O" => ActualEisensteinCubic.O + +def calibratedNumerator (C : CalibrationData) (A m : O) : ℂ := + C.residueMonoid m * idealRowHom m (Ideal.span {A}) + +lemma calibratedNumerator_congr (C : CalibrationData) (A m n : O) + (h : m-n ∈ (Ideal.span {C.generator*A} : Ideal O)) : + calibratedNumerator C A m = calibratedNumerator C A n := by + have hd : C.generator*A ∣ m-n := Ideal.mem_span_singleton.mp h + have hb : Ideal.Quotient.mk (Ideal.span {C.generator}) m = + Ideal.Quotient.mk (Ideal.span {C.generator}) n := by + apply Ideal.Quotient.eq.mpr + exact Ideal.mem_span_singleton.mpr ((dvd_mul_right C.generator A).trans hd) + have hA : m-n ∈ (Ideal.span {A} : Ideal O) := + Ideal.mem_span_singleton.mpr ((dvd_mul_left A C.generator).trans hd) + unfold calibratedNumerator CalibrationData.residueMonoid + simp only [MonoidHom.comp_apply, RingHom.toMonoidHom_eq_coe, + MonoidHom.coe_coe, hb, idealRowHom_congr_mod (Ideal.span {A}) m n hA] + +def calibratedQuotient (C : CalibrationData) (A : O) + (m : O ⧸ Ideal.span {C.generator*A}) : ℂ := + calibratedNumerator C A (representative (C.generator*A) m) + +lemma calibratedQuotient_mk (C : CalibrationData) (A m : O) : + calibratedQuotient C A (Ideal.Quotient.mk _ m) = calibratedNumerator C A m := by + apply calibratedNumerator_congr + exact Ideal.Quotient.eq.mp (representative_spec _ _) + +def outerQuotient (s : O) (d : O ⧸ Ideal.span {s}) : ℂ := + idealRowHom (representative s d) (Ideal.span {s}) + +lemma rawFourier_outer (s : O) (hs : s≠0) (h : O) : + rawFourier s hs (outerQuotient s) h = sexticGauss s hs h := rfl + +def actualCongruenceCoefficient (C : CalibrationData) (A s : O) (hA : A≠0) (H : O) : ℂ := + congruenceCoefficient (C.generator*A) s (mul_ne_zero C.generator_ne_zero hA) + (calibratedQuotient C A) (outerQuotient s) H + +def actualPhysicalFourier (C : CalibrationData) (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : ℂ := + ∑' m : O ⧸ Ideal.span {(C.generator*A)*s}, + calibratedNumerator C A (representative ((C.generator*A)*s) m) * + sexticGauss s hs (-representative ((C.generator*A)*s) m) * + quotientTrace ((C.generator*A)*s) (mul_ne_zero (mul_ne_zero C.generator_ne_zero hA) hs) + (Ideal.Quotient.mk _ H*m) + +theorem actualPhysicalFourier_eq (C : CalibrationData) (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : + actualPhysicalFourier C A s hA hs H = + (Ideal.absNorm (Ideal.span {s}):ℂ) * actualCongruenceCoefficient C A s hA H := by + unfold actualCongruenceCoefficient + rw [← fullFourier_eq_congruence (C.generator*A) s (mul_ne_zero C.generator_ne_zero hA) hs] + unfold actualPhysicalFourier fullFourier + apply tsum_congr + intro m + rw [rawFourier_outer] + have he : conductorReduction (C.generator*A) s m = + Ideal.Quotient.mk (Ideal.span {C.generator*A}) (representative ((C.generator*A)*s) m) := by + conv_lhs => rw [← representative_spec ((C.generator*A)*s) m] + rfl + rw [he, calibratedQuotient_mk] + +lemma calibratedNumerator_norm_le (C : CalibrationData) (A m : O) : + ‖calibratedNumerator C A m‖≤1 := by + let := ConcreteTraceCRT.finite_quotient_span C.generator_ne_zero + let : Fintype (O ⧸ Ideal.span {C.generator}) := Fintype.ofFinite _ + have hC : ‖C.residueMonoid m‖≤1 := + QuadraticInitialBound.norm_finite_character_le_one C.residue _ + rw [calibratedNumerator, norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) hC).trans (idealRowHom_norm _ _) + +theorem actualCongruenceCoefficient_norm_le (C : CalibrationData) (A s : O) + (hA : A≠0) (hs : s≠0) (H : O) : + ‖actualCongruenceCoefficient C A s hA H‖ ≤ + (Ideal.absNorm (Ideal.span {s}):ℝ) * + (Ideal.absNorm (Ideal.span {C.generator*A}):ℝ) := by + apply congruenceCoefficient_norm_le _ _ _ hs + · intro m + exact calibratedNumerator_norm_le C A _ + · intro d + exact idealRowHom_norm _ _ + +theorem normalizedPhysicalFourier_eq (C : CalibrationData) (A s : O) + (hA : A≠0) (hs : s≠0) (H : O) : + (Real.sqrt (Ideal.absNorm (Ideal.span {s})):ℂ)⁻¹ * actualPhysicalFourier C A s hA hs H = + (Real.sqrt (Ideal.absNorm (Ideal.span {s})):ℂ) * actualCongruenceCoefficient C A s hA H := by + have hQ : 0<(Ideal.absNorm (Ideal.span {s}):ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hs)) + have hroot : (Real.sqrt (Ideal.absNorm (Ideal.span {s})):ℂ) ≠ 0 := by + exact_mod_cast (Real.sqrt_pos.mpr hQ).ne' + have he : (Ideal.absNorm (Ideal.span {s}):ℂ) = + (Real.sqrt (Ideal.absNorm (Ideal.span {s})):ℂ)^2 := by + exact_mod_cast (Real.sq_sqrt hQ.le).symm + rw [actualPhysicalFourier_eq, he] + field_simp + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCoefficientScaling.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCoefficientScaling.lean new file mode 100644 index 0000000000000000000000000000000000000000..5845711b2c1581188520f7dc8094279fd57782b5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCoefficientScaling.lean @@ -0,0 +1,53 @@ +import OAI.NumberTheory.DirichletL.Detector.SpectralCoefficient +import OAI.NumberTheory.DirichletL.Detector.PhysicalNorms +import OAI.NumberTheory.DirichletL.Detector.RadialIdentity + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ProbeCompleted ProbeRow CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem physical_spectral_coefficient_scale (S : Finset (Ideal O)) (D I J : Ideal O) + (η : HeckeFamily.Character) (C : CalibrationData) (s : O) (hs : Supported (Ideal.span {s})) + (hI : Supported I) (hJ : Supported J) (hsf : Squarefree I) + (hcop : IsCoprime C.generator (completedIndex I J)) (X : ℝ) (hX : 0v* + (idealRowHom C.generator (Ideal.span {s})/(C.tau*C.residueMonoid s))* + (completedMask S D I J * + (gaussTwo I (supported_primaryGenerator_ne_zero I hI)* + star (FiniteGaussPhase.angularFactor (completedIndex I J)*ProbePhase.G (completedIndex I J))* + targetMonoid η (completedIndex I J)*(C.Xi (completedIndex I J))⁻¹* + ProbePhase.reciprocitySign (completedIndex I J) s)/ + ((Real.sqrt (Ideal.absNorm I):ℂ)*(Ideal.absNorm J:ℂ)))* + (fullIdealWeight t I*fullIdealWeight (3*t) J)* + actualCongruenceCoefficient C (completedIndex I J) s hA H) he + convert hh using 1 <;> ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCrudeMass.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCrudeMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..685b742da372de1b5533144778234219deb5e05a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalCrudeMass.lean @@ -0,0 +1,163 @@ +import OAI.NumberTheory.DirichletL.Detector.LowActualEnergies + +namespace OAI + +noncomputable section +open scoped Classical +open CompletedGauss +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve CanonicalRowCompletion ConcreteTraceCRT CubicEisenstein +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma calibration_elementNorm_ge_one (C : CalibrationData) : 1≤elementNorm C.generator := by + unfold elementNorm + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr C.generator_ne_zero)) + +lemma sexticGauss_norm_le (s : O) (hs : s≠0) (m : O) : ‖sexticGauss s hs m‖≤elementNorm s := by + let := finite_quotient_span hs + let : Fintype (O⧸Ideal.span {s}) := Fintype.ofFinite _ + rw [sexticGauss,tsum_fintype] + calc + _ ≤ ∑d : O⧸Ideal.span {s},‖idealRowHom (GaussianShiftedPartition.representative s d) (Ideal.span {s})* + quotientTrace s hs (Ideal.Quotient.mk _ m*d)‖ := norm_sum_le _ _ + _ ≤ ∑_d : O⧸Ideal.span {s},(1:ℝ) := Finset.sum_le_sum (fun d _=>by + rw [norm_mul,(quotientTrace s hs).norm_apply,mul_one] + exact idealRowHom_norm _ _) + _ = _ := by simp [elementNorm,Ideal.absNorm_apply,Submodule.cardQuot_apply,Nat.card_eq_fintype_card] + +lemma physicalRowWeight_arithmetic_form (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (X Y : ℝ) (r : PhysicalRowIndex) : + physicalRowWeight C W0 W1 X Y r= + (Y:ℂ)⁻¹*W1 ((Ideal.absNorm r.1.val:ℝ)/Y)*lowArithmeticCoefficient C r.1* + (Real.sqrt (elementNorm C.generator*(Ideal.absNorm r.1.val:ℝ)*X):ℂ)⁻¹* + C.residueMonoid r.2*(Real.sqrt (Ideal.absNorm r.1.val):ℂ)⁻¹* + sexticGauss (primaryGenerator r.1.val) (supported_primaryGenerator_ne_zero r.1.val r.1.property) (-r.2)* + W0 (elementNorm r.2/(elementNorm C.generator*(Ideal.absNorm r.1.val:ℝ)*X)) := by + unfold physicalRowWeight lowArithmeticCoefficient + split_ifs <;> simp only [mul_zero,zero_mul] + simp only [div_eq_mul_inv,mul_inv_rev] + ring + +lemma physicalRowWeight_crude_point (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (B0 B1 : ℝ) (hB0 : 0≤B0) (hB1 : 0≤B1) + (hW0 : ∀x,‖W0 x‖≤B0) (hW1 : ∀x,‖W1 x‖≤B1) + (X Y : ℝ) (hX : 1≤X) (hY : 0hr (Finset.mem_product.mpr ⟨hs,hm⟩) + have hz : lowOuterCutoff (a0*a1) (max 1 (b0*b1)) (elementNorm r.2/lowPhysicalScale C X Y)=0 := by + simpa only [lowNumeratorRows_mem,not_not] using hm + rw [physicalRowWeight_insert_cutoff C W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y hY r] + change lowOuterCutoff _ _ (elementNorm r.2/lowPhysicalScale C X Y)*_=0 + rw [hz,zero_mul] + · apply physicalRowWeight_outer_zero + simpa only [lowGaussColumns_mem,not_not] using hs + +theorem physicalRowWeight_source_mass (a0 b0 a1 b1 B0 B1 : ℝ) + (ha0 : 0hpoint r) + _ = (F.card:ℝ)*(R.card:ℝ)*(B0*B1/Y) := by simp [Finset.card_product,mul_assoc] + _ ≤ (128*max 1 b1*Y)*(256*max 1 (b0*b1)*Q)*(B0*B1/Y) := by gcongr + _ = (32768*max 1 b1*max 1 (b0*b1)*B0*B1)*Q := by field_simp;ring + _ ≤ K*Q := mul_le_mul_of_nonneg_right (by dsimp only [K];linarith) (le_trans zero_le_one hQ) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalFourier.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..1f2ddf51b3d1dfa27c6bb39da1028c293b6e5066 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalFourier.lean @@ -0,0 +1,117 @@ +import OAI.NumberTheory.DirichletL.Detector.LiftedFourier +import OAI.NumberTheory.DirichletL.Detector.Physical + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein GaussianShiftedPartition ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +def rawFourier (a : O) (ha : a≠0) (F : (O ⧸ Ideal.span {a}) → ℂ) (H : O) : ℂ := + ∑' m : O ⧸ Ideal.span {a}, F m * quotientTrace a ha (Ideal.Quotient.mk _ H * m) + +theorem rawFourier_exactQuotient (a s : O) (ha : a≠0) (hs : s≠0) + (F : (O ⧸ Ideal.span {a}) → ℂ) (H : O) : + conductorFourier a s ha hs F H = + (Ideal.absNorm (Ideal.span {s}):ℂ) * + (if h : s∣H then rawFourier a ha F (exactQuotient H s h) else 0) := by + by_cases h : s∣H + · rw [dite_eq_left h] + conv_lhs => rw [exactQuotient_spec H s h] + exact conductorFourier_lift a s ha hs F _ + · rw [dite_eq_right h, mul_zero] + by_contra hn + exact h (conductorFourier_support a s ha hs F H hn) + +def congruenceCoefficient (a s : O) (ha : a≠0) + (F : (O ⧸ Ideal.span {a}) → ℂ) (χ : (O ⧸ Ideal.span {s}) → ℂ) (H : O) : ℂ := + ∑' d : O ⧸ Ideal.span {s}, χ d * + (if h : s ∣ H-a*representative s d then + rawFourier a ha F (exactQuotient (H-a*representative s d) s h) else 0) + +lemma trace_split_product (a s : O) (ha : a≠0) (hs : s≠0) (H m d : O) : + quotientTrace (a*s) (mul_ne_zero ha hs) (Ideal.Quotient.mk _ (H*m)) * + quotientTrace s hs (Ideal.Quotient.mk _ ((-m)*d)) = + quotientTrace (a*s) (mul_ne_zero ha hs) (Ideal.Quotient.mk _ ((H-a*d)*m)) := by + have he := quotientTrace_split_frequency s a hs ha H d m + simp only [quotientTrace_mk] at he ⊢ + simpa only [mul_comm s a] using he.symm + +def fullFourier (a s : O) (ha : a≠0) (hs : s≠0) + (F : (O ⧸ Ideal.span {a}) → ℂ) (χ : (O ⧸ Ideal.span {s}) → ℂ) (H : O) : ℂ := + ∑' m : O ⧸ Ideal.span {a*s}, F (conductorReduction a s m) * + rawFourier s hs χ (-representative (a*s) m) * + quotientTrace (a*s) (mul_ne_zero ha hs) (Ideal.Quotient.mk _ H*m) + +theorem fullFourier_eq_congruence (a s : O) (ha : a≠0) (hs : s≠0) + (F : (O ⧸ Ideal.span {a}) → ℂ) (χ : (O ⧸ Ideal.span {s}) → ℂ) (H : O) : + fullFourier a s ha hs F χ H = + (Ideal.absNorm (Ideal.span {s}):ℂ) * congruenceCoefficient a s ha F χ H := by + let : Finite (O ⧸ Ideal.span {a*s}) := finite_quotient_span (mul_ne_zero ha hs) + let : Finite (O ⧸ Ideal.span {s}) := finite_quotient_span hs + let : Fintype (O ⧸ Ideal.span {a*s}) := Fintype.ofFinite _ + let : Fintype (O ⧸ Ideal.span {s}) := Fintype.ofFinite _ + unfold fullFourier rawFourier + simp_rw [tsum_fintype, Finset.mul_sum, Finset.sum_mul] + rw [Finset.sum_comm] + unfold congruenceCoefficient + rw [tsum_fintype, Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + calc + _ = χ d * conductorFourier a s ha hs F (H-a*representative s d) := by + rw [conductorFourier, tsum_fintype, Finset.mul_sum] + apply Finset.sum_congr rfl + intro m hm + have ht := trace_split_product a s ha hs H (representative (a*s) m) (representative s d) + simp only [map_mul, representative_spec] at ht + rw [← ht] + ring + _ = _ := by rw [rawFourier_exactQuotient]; ring + +theorem rawFourier_norm_le (a : O) (ha : a≠0) (F : (O ⧸ Ideal.span {a}) → ℂ) + (hF : ∀ m, ‖F m‖≤1) (H : O) : + ‖rawFourier a ha F H‖ ≤ (Ideal.absNorm (Ideal.span {a}):ℝ) := by + let := finite_quotient_span ha + let : Fintype (O ⧸ Ideal.span {a}) := Fintype.ofFinite _ + rw [rawFourier, tsum_fintype] + calc + _ ≤ ∑ m : O ⧸ Ideal.span {a}, ‖F m * quotientTrace a ha (Ideal.Quotient.mk _ H*m)‖ := + norm_sum_le _ _ + _ ≤ ∑ _m : O ⧸ Ideal.span {a}, (1:ℝ) := by + apply Finset.sum_le_sum + intro m hm + rw [norm_mul, AddChar.norm_apply, mul_one] + exact hF m + _ = _ := by simp [Ideal.absNorm_apply, Submodule.cardQuot_apply, Nat.card_eq_fintype_card] + +theorem congruenceCoefficient_norm_le (a s : O) (ha : a≠0) (hs : s≠0) + (F : (O ⧸ Ideal.span {a}) → ℂ) (χ : (O ⧸ Ideal.span {s}) → ℂ) + (hF : ∀ m, ‖F m‖≤1) (hχ : ∀ d, ‖χ d‖≤1) (H : O) : + ‖congruenceCoefficient a s ha F χ H‖ ≤ + (Ideal.absNorm (Ideal.span {s}):ℝ) * (Ideal.absNorm (Ideal.span {a}):ℝ) := by + let := finite_quotient_span hs + let : Fintype (O ⧸ Ideal.span {s}) := Fintype.ofFinite _ + unfold congruenceCoefficient + rw [tsum_fintype] + calc + _ ≤ ∑ d : O ⧸ Ideal.span {s}, ‖χ d * + (if h : s ∣ H-a*representative s d then + rawFourier a ha F (exactQuotient (H-a*representative s d) s h) else 0)‖ := norm_sum_le _ _ + _ ≤ ∑ _d : O ⧸ Ideal.span {s}, (Ideal.absNorm (Ideal.span {a}):ℝ) := by + apply Finset.sum_le_sum + intro d hd + split_ifs + · rw [norm_mul] + exact (mul_le_mul (hχ d) (rawFourier_norm_le a ha F hF _) + (norm_nonneg _) (by norm_num)).trans_eq (one_mul _) + · simp only [mul_zero, norm_zero] + positivity + _ = _ := by simp [Ideal.absNorm_apply, Submodule.cardQuot_apply, Nat.card_eq_fintype_card] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalLocalEuler.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalLocalEuler.lean new file mode 100644 index 0000000000000000000000000000000000000000..ca45793700cea064afc8fba3e1f3773a849d0d0b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalLocalEuler.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Detector.LocalPhysical +import OAI.NumberTheory.DirichletL.Detector.SourceLocal + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge CanonicalRowCompletion +open CubicEisenstein GaussianShiftedPartition ProbePrimePower ProbeEuler ProbeLocal +local notation "O" => ActualEisensteinCubic.O + +lemma outerQuotient_mk (s H : O) : + outerQuotient s (Ideal.Quotient.mk _ H)=idealRowHom H (Ideal.span {s}) := by + unfold outerQuotient + apply idealRowHom_congr_mod + exact Ideal.Quotient.eq.mp (representative_spec _ _) + +theorem bareCongruenceCoefficient_all_prime_powers (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) (t k j : ℕ) : + bareCongruenceCoefficient (p^t) (p^k) (pow_ne_zero _ hp.ne_zero) (p^j) = + sourceScalar p hp hg t k j := by + cases t with + | zero => + simp only [pow_zero] + rw [bareCongruenceCoefficient_inner_one _ (pow_ne_zero _ hp.ne_zero), outerQuotient_mk] + unfold sourceScalar + rw [ite_eq_left rfl] + by_cases hk : k=0 + · subst k + simp only [pow_zero, Ideal.span_singleton_one, ← Ideal.one_eq_top, map_one, ite_true] + · rw [ite_eq_right hk, ← Ideal.span_singleton_pow, map_pow, idealRowHom_prime _ _ hg, + MulChar.pow_apply' _ hk] + | succ n => + rw [bareCongruenceCoefficient_prime_power p hp hg n k j] + simp only [sourceScalar, Nat.add_eq_zero_iff, Nat.one_ne_zero, and_false, ite_false, + Nat.add_sub_cancel] + +def physicalPrincipalSeries (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (eta a x w z : ℂ) : ℂ := + ∑ e : Fin 2, ∑' l, ∑' k, ∑' m, + sourceWeightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (localGamma p hp.ne_zero hg 1) (star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) x w z + (bareCongruenceCoefficient (p^(e.val+3*l)) (p^k) (pow_ne_zero _ hp.ne_zero) (p^(6*m))) + e.val l k m + +theorem physicalPrincipalSeries_eq (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (eta a x w z : ℂ) : + physicalPrincipalSeries p hp hg eta a x w z = sourcePrincipalSeries p hp hg eta a x w z := by + simp only [physicalPrincipalSeries, sourcePrincipalSeries, sourcePrincipalTerm, + bareCongruenceCoefficient_all_prime_powers p hp hg] + +theorem physicalPrincipalSeries_euler_identity (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hc : ringChar (O ⧸ Ideal.span {p})≠2) (eta a x w z : ℂ) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖coordR (Ideal.absNorm (Ideal.span {p})) (a^2) x z‖<1) + (hW : ‖coordW (Ideal.absNorm (Ideal.span {p})) 1 w‖<1) + (hD : 1-coordD (Ideal.absNorm (Ideal.span {p})) eta 1 x≠0) : + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + physicalPrincipalSeries p hp hg eta a x w z = + (1-coordD Q eta 1 x) / ((1-coordV Q z)*(1-coordW Q 1 w)) * + unramifiedClosed Q (a^2) eta 1 x w z := by + rw [physicalPrincipalSeries_eq] + exact sourcePrincipalSeries_euler_identity p hp hg hc eta a x w z hV hR hW hD + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalMellinCoefficient.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalMellinCoefficient.lean new file mode 100644 index 0000000000000000000000000000000000000000..f968032c8eae5fc3569d70f83963e1742a40fa43 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalMellinCoefficient.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalCoefficientScaling +import OAI.NumberTheory.DirichletL.Detector.MellinPowers + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ProbeCompleted ProbeRow CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +lemma completedIndex_norm (I J : Ideal O) (hI : Supported I) (hJ : Supported J) : + elementNorm (completedIndex I J)=(Ideal.absNorm I:ℝ)*(Ideal.absNorm J:ℝ)^3 := by + rw [completedIndex, elementNorm_mul, elementNorm_pow] + unfold elementNorm + rw [(primaryGenerator_spec I (supported_primaryGenerator_ne_zero I hI)).1, + (primaryGenerator_spec J (supported_primaryGenerator_ne_zero J hJ)).1] + +theorem physical_mellin_coefficient (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) + (D I J : Ideal O) (η : HeckeFamily.Character) (s : O) (hs : Supported (Ideal.span {s})) + (hI : Supported I) (hJ : Supported J) (hsf : Squarefree I) + (hcop : IsCoprime (calibrationForSet S hS).generator (completedIndex I J*s)) + (X : ℝ) (hX : 0 (r : ℂ)) (physical_radial_argument + (calibrationForSet S hS).generator (completedIndex I J) s H X + (elementNorm_pos _ (calibrationForSet S hS).generator_ne_zero).ne' + (elementNorm_pos _ (supportedElement_ne_zero s hs)).ne') + simp only [Complex.ofReal_div, Complex.ofReal_mul] at hr + simp only [Complex.ofReal_mul] + rw [hr] + rw [completedIndex_norm I J hI hJ] + have hi : (0:ℝ)v*completedMask S D I J* + star ((calibrationForSet S hS).residueMonoid H)* + bareSourceCoefficient η I (supported_primaryGenerator_ne_zero I hI) (completedIndex I J) s + (supportedElement_ne_zero _ hA) H) hn + convert he using 1 <;> ring_nf + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalNorms.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalNorms.lean new file mode 100644 index 0000000000000000000000000000000000000000..36f6fd2f2b11ec0954bb7cf56c5c1d3484b99897 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalNorms.lean @@ -0,0 +1,43 @@ +import OAI.NumberTheory.DirichletL.Detector.MellinScaling +import OAI.NumberTheory.DirichletL.Detector.SpectralWeights + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical + +lemma elementNorm_mul (a b : ActualEisensteinCubic.O) : + elementNorm (a*b)=elementNorm a*elementNorm b := by + simp only [elementNorm,←Ideal.span_singleton_mul_span_singleton,map_mul,Nat.cast_mul] + +lemma elementNorm_pow (a : ActualEisensteinCubic.O) (n : ℕ) : + elementNorm (a^n)=elementNorm a^n := by + simp only [elementNorm,←Ideal.span_singleton_pow,map_pow,Nat.cast_pow] + +lemma physical_radial_argument (B A s H : ActualEisensteinCubic.O) (X : ℝ) + (hB : elementNorm B≠0) (hs : elementNorm s≠0) : + (elementNorm B*elementNorm s*X)*elementNorm H/elementNorm ((B*A)*s)= + X*elementNorm H/elementNorm A := by + simp only [elementNorm_mul] + field_simp + +lemma physical_poisson_prefactor (B A S X : ℝ) (hB : 0 ActualEisensteinCubic.O + +lemma sexticGauss_frequency_congr (s : O) (hs : s≠0) (h k : O) + (he : h-k ∈ (Ideal.span {s}:Ideal O)) : sexticGauss s hs h = sexticGauss s hs k := by + have hmk := Ideal.Quotient.eq.mpr he + simp only [sexticGauss, hmk] + +def physicalQuotient (C : CalibrationData) (A s : O) (hs : s≠0) + (m : O ⧸ Ideal.span {(C.generator*A)*s}) : ℂ := + calibratedNumerator C A (representative ((C.generator*A)*s) m) * + sexticGauss s hs (-representative ((C.generator*A)*s) m) + +lemma physicalQuotient_mk (C : CalibrationData) (A s : O) (hs : s≠0) (m : O) : + physicalQuotient C A s hs (Ideal.Quotient.mk _ m) = + calibratedNumerator C A m * sexticGauss s hs (-m) := by + have hd : (C.generator*A)*s ∣ representative ((C.generator*A)*s) (Ideal.Quotient.mk _ m)-m := + Ideal.mem_span_singleton.mp (Ideal.Quotient.eq.mp (representative_spec _ _)) + have hA : representative ((C.generator*A)*s) (Ideal.Quotient.mk _ m)-m ∈ + (Ideal.span {C.generator*A}:Ideal O) := + Ideal.mem_span_singleton.mpr ((dvd_mul_right (C.generator*A) s).trans hd) + have hs' : -representative ((C.generator*A)*s) (Ideal.Quotient.mk _ m)-(-m) ∈ + (Ideal.span {s}:Ideal O) := by + apply Ideal.mem_span_singleton.mpr + rw [show -representative ((C.generator*A)*s) (Ideal.Quotient.mk _ m)-(-m) = + -(representative ((C.generator*A)*s) (Ideal.Quotient.mk _ m)-m) by ring] + exact dvd_neg.mpr ((dvd_mul_left s (C.generator*A)).trans hd) + unfold physicalQuotient + rw [calibratedNumerator_congr C A _ m hA, sexticGauss_frequency_congr s hs _ (-m) hs'] + +theorem physical_row_poisson (C : CalibrationData) (A s : O) (hA : A≠0) (hs : s≠0) + (W : ℝ → ℂ) (hWc : HasCompactSupport W) (hWs : ContDiff ℝ ∞ W) + (K : ℝ) (hK : 0 ActualEisensteinCubic.O + +def radialMellinPhysicalProbe (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W0 : SchwartzMap ℝ ℂ) (W1 : ℝ→ℂ) (X Y Z σ : ℝ) : ℂ := + (Y:ℂ)⁻¹*∑'s : {I : Ideal O // Supported I}, + if ∀P∈C.excluded,¬P∣s.val then + let a := primaryGenerator s.val + let has := (supported_span_primaryGenerator_iff s.val).mpr s.property + let qs : ℝ := Ideal.absNorm s.val + W1 (qs/Y)*CanonicalRowCompletion.idealRowHom C.generator s.val / + (C.tau*C.residueMonoid a*(Real.sqrt (elementNorm C.generator*qs*X):ℂ))* + verticalIntegral 4 (fun t=>(Real.sqrt qs:ℂ)⁻¹*((Z:ℂ)^t*Complex.exp (t^2))* + ∑'p : Ideal O×Ideal O,radialMellinSpectralTerm η C C.excluded D a has W0 + (elementNorm C.generator*qs*X) σ t p.1 p.2) + else 0 + +theorem markedPhysicalProbe_eq_radial_mellin (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hSne : S.Nonempty) + (D : Ideal O) (W0 : SchwartzMap ℝ ℂ) (W1 : ℝ→ℂ) + (a b : ℝ) (ha : 0 ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable +local instance : MeasurableSpace O := ⊤ +local instance : MeasurableSingletonClass O := ⟨fun _=>trivial⟩ +local instance : MeasurableSpace (Ideal O) := ⊤ +local instance : MeasurableSingletonClass (Ideal O) := ⟨fun _=>trivial⟩ +local instance (S : Finset (Ideal O)) : MeasurableSpace (SourceRawIndex S) := ⊤ +local instance (S : Finset (Ideal O)) : MeasurableSingletonClass (SourceRawIndex S) := ⟨fun _=>trivial⟩ + +def rawPhysicalTotalIntegral (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (hS : ∀P∈S,P.IsMaximal) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3* + ∫p : SourceRawIndex S×HeightSpace,originalRawOnLines η S hS D W0 W1 X Y Z p.1 p.2 + ∂((Measure.count:Measure (SourceRawIndex S)).prod heightMeasure) + +theorem rawNestedPhysicalProbe_eq_integral (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0by rw [calibrationForSet_excluded]) + rw [←e.tsum_eq] + apply tsum_congr + intro K + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro w + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + apply tsum_congr + intro IJ + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro z + apply tsum_congr + intro H + congr 1 ; ring + +theorem markedPhysicalProbe_eq_raw_integral (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (hSne : S.Nonempty) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 ActualEisensteinCubic.O + +lemma supportedElement_ne_zero (s : O) (hs : Supported (Ideal.span {s})) : s≠0 := by + intro h + apply hs.1 + simp [h] + +lemma finite_support_tsum_comm {α β : Type*} (f : α → β → ℂ) (S : Finset α) + (hz : ∀ a, a∉S → ∀ b, f a b=0) (hs : ∀ a∈S, Summable (f a)) : + (∑' a, ∑' b, f a b) = ∑' b, ∑' a, f a b := by + calc + _ = ∑ a∈S, ∑' b, f a b := tsum_eq_sum (fun a ha => by simp only [hz a ha, tsum_zero]) + _ = ∑' b, ∑ a∈S, f a b := (Summable.tsum_finsetSum hs).symm + _ = _ := by + apply tsum_congr + intro b + exact (tsum_eq_sum (fun a ha => hz a ha b)).symm + +theorem physical_spectral_reopen (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D : Ideal O) (s : O) + (hs : Supported (Ideal.span {s})) (W : ℝ → ℂ) (hW : HasCompactSupport W) + (K : ℝ) (hK : 0 hsum m) + calc + _ = ∑' m : O, ∑' p : Ideal O × Ideal O, F m p := by + simp only [F, spectralRow, tsum_mul_left] + _ = ∑' p : Ideal O × Ideal O, ∑' m : O, F m p := he + _ = _ := by + apply tsum_congr + intro p + rw [← tsum_mul_left] + apply tsum_congr + intro m + unfold F + rw [spectralSummand_row_separation] + unfold calibratedNumerator + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalRows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..6e5fc3ecb2b29d6d35eb91ff42a4ad701d6ef952 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PhysicalRows.lean @@ -0,0 +1,126 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussianTuple +import OAI.NumberTheory.DirichletL.Detector.Windows + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow CanonicalQuadraticSieve CompletedGauss +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev PhysicalRowIndex := {I : Id // Supported I}×O + +def physicalRowMonoid (η : HeckeFamily.Character) (C : CalibrationData) (r : PhysicalRowIndex) : O→*ℂ := + rowCoefficient η C.Xi (primaryGenerator r.1.val) + ((supported_span_primaryGenerator_iff r.1.val).mpr r.1.property) r.2 + +def physicalRowWeight (C : CalibrationData) (W0 W1 : ℝ→ℂ) (X Y : ℝ) (r : PhysicalRowIndex) : ℂ := + if ∀P∈C.excluded,¬P∣r.1.val then + let a := primaryGenerator r.1.val + let ha := supported_primaryGenerator_ne_zero r.1.val r.1.property + let q : ℝ := Ideal.absNorm r.1.val + (Y:ℂ)⁻¹*W1 (q/Y)*CanonicalRowCompletion.idealRowHom C.generator r.1.val/ + (C.tau*C.residueMonoid a*(Real.sqrt (elementNorm C.generator*q*X):ℂ))* + C.residueMonoid r.2*(Real.sqrt q:ℂ)⁻¹*sexticGauss a ha (-r.2)* + W0 (elementNorm r.2/(elementNorm C.generator*q*X)) + else 0 + +lemma physicalRowMonoid_norm (η : HeckeFamily.Character) (C : CalibrationData) + (r : PhysicalRowIndex) (n : O) : ‖physicalRowMonoid η C r n‖≤1 := + rowCoefficient_norm_le_one η C.Xi C.Xi_norm_le_one _ _ r.2 n + +lemma physicalRowWeight_outer_zero (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (X Y : ℝ) (r : PhysicalRowIndex) (h : W1 ((Ideal.absNorm r.1.val:ℝ)/Y)=0) : + physicalRowWeight C W0 W1 X Y r=0 := by + unfold physicalRowWeight + split_ifs <;> simp [h] + +lemma physicalRowWeight_inner_zero (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (X Y : ℝ) (r : PhysicalRowIndex) + (h : W0 (elementNorm r.2/(elementNorm C.generator*(Ideal.absNorm r.1.val:ℝ)*X))=0) : + physicalRowWeight C W0 W1 X Y r=0 := by + unfold physicalRowWeight + split_ifs <;> simp [h] + +lemma physicalRowScale_pos (C : CalibrationData) (X : ℝ) (hX : 0s.val) Subtype.val_injective.injOn + apply Set.Finite.of_finite_fibers Prod.fst + · apply ho.subset + rintro s ⟨r,hr,rfl⟩ + exact fun hz=>hr (physicalRowWeight_outer_zero C W0 W1 X Y r hz) + · intro s hs + have hm := elementWindow_finite_support W0 hW0 _ (physicalRowScale_pos C X hX s) + apply ((Set.finite_singleton s).prod hm).subset + intro r hr + have he : r.1=s := hr.2 + refine ⟨he,?_⟩ + intro hz + apply hr.1 + apply physicalRowWeight_inner_zero C W0 W1 X Y r + simpa only [he] using hz + +lemma physicalRowWeight_mul_summable (C : CalibrationData) (W0 W1 : ℝ→ℂ) + (hW0 : HasCompactSupport W0) (hW1 : HasCompactSupport W1) + (X Y : ℝ) (hX : 0physicalRowWeight C W0 W1 X Y r*F r) := by + apply summable_of_hasFiniteSupport + apply (physicalRowWeight_finite_support C W0 W1 hW0 hW1 X Y hX hY).subset + intro r hr hz + exact hr (by dsimp only; rw [hz,zero_mul]) + +theorem markedPhysicalProbe_eq_rows (η : HeckeFamily.Character) (C : CalibrationData) + (D : Id) (W0 W1 : ℝ→ℂ) (hW0 : HasCompactSupport W0) (hW1 : HasCompactSupport W1) + (X Y Z : ℝ) (hX : 0(Z:ℂ)^t*Complex.exp (t^2)*spectralRow C.excluded D (physicalRowMonoid η C r) t) := by + have hf := physicalRowWeight_mul_summable C W0 W1 hW0 hW1 X Y hX hY + (fun r=>verticalIntegral 4 (fun t=>(Z:ℂ)^t*Complex.exp (t^2)*spectralRow C.excluded D (physicalRowMonoid η C r) t)) + rw [hf.tsum_prod] + unfold markedPhysicalProbe + rw [←tsum_mul_left] + apply tsum_congr + intro s + by_cases hc : ∀P∈C.excluded,¬P∣s.val + · simp only [physicalRowWeight,physicalRowMonoid] + try dsimp only + simp only [ite_eq_left hc] + rw [←tsum_mul_left,←tsum_mul_left] + apply tsum_congr + intro m + ring + · simp only [physicalRowWeight] + try dsimp only + simp only [ite_eq_right hc,zero_mul,mul_zero,tsum_zero] + +theorem markedPhysicalProbe_eq_gaussian_rows (η : HeckeFamily.Character) (C : CalibrationData) + (D : Id) (W0 W1 : ℝ→ℂ) (hW0 : HasCompactSupport W0) (hW1 : HasCompactSupport W1) + (X Y Z : ℝ) (hX : 0 ActualEisensteinCubic.O + +def localGamma (p : O) (hp : p ≠ 0) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (r : ℕ) : ℂ := + ConcreteBreveE.normalizedTraceGauss p hp (actualSextic (Ideal.span {p}) hg ^ r) + +lemma localGamma_norm_one (p : O) (hp : p ≠ 0) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (r : ℕ) (hr : r ≠ 0) (hr6 : r < 6) : ‖localGamma p hp hg r‖ = 1 := + MixedGaussConversion.norm_localGauss p hp hg hc r hr hr6 + +lemma actualSextic_six (P : Ideal O) [P.IsMaximal] + (hg : goodLambda ∉ P) (hc : ringChar (O ⧸ P) ≠ 2) : actualSextic P hg ^ 6 = 1 := + (actualSextic_pow_eq_one_iff P hg hc 6).mpr (by decide) + +lemma actualSextic_neg_one_sq (P : Ideal O) [P.IsMaximal] + (hg : goodLambda ∉ P) : actualSextic P hg (-1)^2 = 1 := by + rw [← map_pow] + norm_num + +theorem localGamma_inverse_pair (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (r : ℕ) (hr : r ≠ 0) (hr6 : r < 6) : + localGamma p hp hg r * localGamma p hp hg (6-r) = + actualSextic (Ideal.span {p}) hg (-1)^r := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + let χ := actualSextic (Ideal.span {p}) hg + have hχ : χ^r ≠ 1 := by + intro he + have hd := (actualSextic_pow_eq_one_iff _ hg hc r).mp he + exact (Nat.not_dvd_of_pos_of_lt (Nat.pos_of_ne_zero hr) hr6) hd + have hinv : (χ^r)⁻¹ = χ^(6-r) := by + apply inv_eq_of_mul_eq_one_right + rw [← pow_add, Nat.add_sub_of_le hr6.le] + exact actualSextic_six _ hg hc + have hψ : (quotientTrace p hp).IsPrimitive := + GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive p hp + have he := ProbeGauss.normalizedGauss_inverse_pair (χ^r) (quotientTrace p hp) hχ hψ + rw [hinv] at he + simp only [localGamma, ProbePhase.normalizedTraceGauss_eq_normalizedGauss] + simpa only [MulChar.pow_apply' _ hr] using he + +lemma localGamma_two_four (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) : + localGamma p hp hg 2 * localGamma p hp hg 4 = 1 := by + have he := localGamma_inverse_pair p hp hg hc 2 (by decide) (by decide) + simpa only [show 6-2=4 from rfl, actualSextic_neg_one_sq] using he + +theorem localGamma_one_two_signal (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (hprimary : goodLambda^2 ∣ p-1) : + localGamma p hp hg 1 * localGamma p hp hg 2 = + -FiniteGaussPhase.angularFactor p * MixedGaussConversion.localG p hp hg := by + have he := breveGamma1_gamma2_eq_neg_alpha_G (Ideal.span {p}) hg hc p rfl hp hprimary + simpa only [localGamma, ConcreteBreveE.normalizedTraceGauss, pow_one, + breveGamma1, breveGamma2, MixedGaussConversion.localG, FiniteGaussPhase.angularFactor, + neg_div] using he + +lemma actualSextic_pow_six_mul_add (P : Ideal O) [P.IsMaximal] + (hg : goodLambda ∉ P) (hc : ringChar (O ⧸ P) ≠ 2) (r j : ℕ) : + actualSextic P hg ^ (6*r+j) = actualSextic P hg ^ j := by + rw [pow_add, pow_mul, actualSextic_six P hg hc, one_pow, one_mul] + +lemma actualSextic_fifth_inverse (P : Ideal O) [P.IsMaximal] + (hg : goodLambda ∉ P) (hc : ringChar (O ⧸ P) ≠ 2) : + actualSextic P hg ^ 5 = (actualSextic P hg)⁻¹ := by + symm + apply inv_eq_of_mul_eq_one_right + rw [← pow_succ'] + exact actualSextic_six P hg hc + +lemma primeGauss_inverse_pair (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (hχ : χ ≠ 1) : + primeGauss p hp χ 1 * primeGauss p hp χ⁻¹ 1 = + χ (-1) * (Ideal.absNorm (Ideal.span {p}):ℂ) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + have ht := ProbeGauss.gauss_inverse_pair χ (quotientTrace p hp) hχ + (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive p hp) + have hcard : Nat.card (O ⧸ Ideal.span {p}) = Ideal.absNorm (Ideal.span {p}) := rfl + simpa only [primeGauss, tsum_fintype, map_one, one_mul, gaussSum, + ← Nat.card_eq_fintype_card, hcard] using ht + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrimePhase.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrimePhase.lean new file mode 100644 index 0000000000000000000000000000000000000000..db9737902b5dd0820f7eddde047501b92a432663 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrimePhase.lean @@ -0,0 +1,97 @@ +import OAI.NumberTheory.DirichletL.Detector.PhaseCancellation +import OAI.NumberTheory.DirichletL.Detector.Sextic + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbePhase +open ActualEisensteinCubic ActualEisensteinCoordinates CompletedGauss +open ConcreteTraceCRT ConcretePrimeRowBridge QuadraticGaussRay FiniteGaussPhase CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem normalizedTraceGauss_eq_normalizedGauss (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) : + letI : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + letI : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + ConcreteBreveE.normalizedTraceGauss p hp χ = + ProbeGauss.normalizedGauss χ (quotientTrace p hp) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + have hn : Real.sqrt (Nat.card (O ⧸ Ideal.span {p}) : ℝ) = ‖eisEmbedding p‖ := by + change Real.sqrt (Ideal.absNorm (Ideal.span {p}) : ℝ) = _ + rw [← eisEmbedding_norm_sq_eq_absNorm_span, Real.sqrt_sq (norm_nonneg _)] + simp only [ConcreteBreveE.normalizedTraceGauss, ProbeGauss.normalizedGauss, + quotientTrace, ← Nat.card_eq_fintype_card, hn] + +theorem quadraticRayValue_eq_normalizedTraceGauss (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) : + quadraticRayValue (residue p) = + ConcreteBreveE.normalizedTraceGauss p hp (actualSextic (Ideal.span {p}) hg ^ 3) := by + let pp : Unit → O := fun _ => p + have hpp : ∀ i, pp i ≠ 0 := fun _ => hp + have hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {pp i})) := by + intro i j hij + exact (hij (Subsingleton.elim i j)).elim + have he := canonicalProductGauss_three_eq_rayValue pp hpp hcop (fun _ => hg) (fun _ => hc) + rw [canonicalProductGauss_cross_factors pp hpp hcop (fun _ => hg) (fun _ => 3)] at he + simpa [pp] using he.symm + +theorem G_cube_eq_normalizedTraceGauss (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (ho : EisensteinEPrimaryPhase.odd (residue p)) : + G (p ^ 3) = + ConcreteBreveE.normalizedTraceGauss p hp (actualSextic (Ideal.span {p}) hg ^ 3) := by + rw [G_cube p ho (cubicTwo_isUnit_of_odd p ho)] + exact quadraticRayValue_eq_normalizedTraceGauss p hp hg hc + +theorem normalizedTraceGauss_three_sq (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) : + ConcreteBreveE.normalizedTraceGauss p hp (actualSextic (Ideal.span {p}) hg ^ 3) ^ 2 = + actualSextic (Ideal.span {p}) hg (-1) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + let χ := actualSextic (Ideal.span {p}) hg + have h6 : χ ^ 6 = 1 := (ProbePrimePower.actualSextic_pow_eq_one_iff _ hg hc 6).mpr (by decide) + have h3 : χ ^ 3 ≠ 1 := fun h => (by decide : ¬6 ∣ 3) + ((ProbePrimePower.actualSextic_pow_eq_one_iff _ hg hc 3).mp h) + have hi : (χ ^ 3)⁻¹ = χ ^ 3 := by + apply inv_eq_of_mul_eq_one_right + rw [← pow_add] + exact h6 + have hψ : (quotientTrace p hp).IsPrimitive := + GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive p hp + have he := ProbeGauss.normalizedGauss_inverse_pair (χ ^ 3) (quotientTrace p hp) h3 hψ + rw [hi, ← pow_two] at he + rw [normalizedTraceGauss_eq_normalizedGauss] + rw [he] + simp only [MulChar.pow_apply' _ (by decide : (3 : ℕ) ≠ 0), ← map_pow] + norm_num + rfl + +theorem reciprocitySign_self_eq_sextic_neg_one (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (ho : EisensteinEPrimaryPhase.odd (residue p)) : + reciprocitySign p p = actualSextic (Ideal.span {p}) hg (-1) := by + have hq := QuadraticAllOddCRT.quadraticRayValue_mul (residue p) (residue p) ho ho + rw [quadraticRayValue_square _ ho] at hq + have hprod : reciprocitySign p p * quadraticRayValue (residue p) ^ 2 = 1 := by + simpa only [reciprocitySign, pow_two, mul_assoc] using hq.symm + have he := normalizedTraceGauss_three_sq p hp hg hc + rw [← quadraticRayValue_eq_normalizedTraceGauss p hp hg hc] at he + rw [he] at hprod + calc + reciprocitySign p p = reciprocitySign p p * 1 := (mul_one _).symm + _ = reciprocitySign p p * (reciprocitySign p p * actualSextic (Ideal.span {p}) hg (-1)) := by rw [hprod] + _ = reciprocitySign p p ^ 2 * actualSextic (Ideal.span {p}) hg (-1) := by ring + _ = _ := by rw [reciprocitySign_sq p p ho ho, one_mul] + +end SevenEighths.ProbePhase +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrimePower.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrimePower.lean new file mode 100644 index 0000000000000000000000000000000000000000..5bad3212e490b99f8212f1c1d669e2efb4eaa023 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrimePower.lean @@ -0,0 +1,148 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Detector.Gauss + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CubicEisenstein + +local notation "O" => ActualEisensteinCubic.O + +def primeGauss (p : O) (hp : p ≠ 0) (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) + (h : O) : ℂ := + ∑' x : O ⧸ Ideal.span {p}, χ x * quotientTrace p hp (Ideal.Quotient.mk _ h * x) + +def primePowerGauss (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h : O) : ℂ := + conductorFourier p (p ^ n) hp (pow_ne_zero _ hp) χ h + +theorem primePowerGauss_support (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h : O) + (hG : primePowerGauss p hp χ n h ≠ 0) : p ^ n ∣ h := + conductorFourier_support p (p ^ n) hp (pow_ne_zero _ hp) χ h hG + +theorem primePowerGauss_zero_off_support (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h : O) + (hdiv : ¬p ^ n ∣ h) : primePowerGauss p hp χ n h = 0 := by + by_contra hG + exact hdiv (primePowerGauss_support p hp χ n h hG) + +theorem primePowerGauss_lift (p : O) (hp : p ≠ 0) + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h : O) : + primePowerGauss p hp χ n (p ^ n * h) = + (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n * primeGauss p hp χ h := by + unfold primePowerGauss primeGauss + rw [conductorFourier_lift] + have hn : Ideal.absNorm (Ideal.span {p ^ n}) = Ideal.absNorm (Ideal.span {p}) ^ n := by + rw [← Ideal.span_singleton_pow, map_pow] + rw [hn, Nat.cast_pow] + +theorem primePowerGauss_nonprincipal_extra_divisibility (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (hχ : χ ≠ 1) (n : ℕ) (h : O) + (hph : p ∣ h) : primePowerGauss p hp χ n (p ^ n * h) = 0 := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Finite (O ⧸ Ideal.span {p}) := ConcreteTraceCRT.finite_quotient_span hp + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + rw [primePowerGauss_lift] + have hz : Ideal.Quotient.mk (Ideal.span {p}) h = 0 := + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr hph) + have hzero : primeGauss p hp χ h = 0 := by + rw [primeGauss, tsum_fintype] + simp only [hz, zero_mul, AddChar.map_zero_eq_one, mul_one] + exact MulChar.sum_eq_zero_of_ne_one hχ + rw [hzero, mul_zero] + +theorem primePowerGauss_principal (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hψ : quotientTrace p hp ≠ 1) (n : ℕ) (h : O) : + primePowerGauss p hp 1 n (p ^ n * h) = + (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n * + (if p ∣ h then (Nat.card (O ⧸ Ideal.span {p})ˣ : ℂ) else -1) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Finite (O ⧸ Ideal.span {p}) := ConcreteTraceCRT.finite_quotient_span hp + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + rw [primePowerGauss_lift] + congr 1 + have hdiv : Ideal.Quotient.mk (Ideal.span {p}) h = 0 ↔ p ∣ h := by + rw [Ideal.Quotient.eq_zero_iff_mem, Ideal.mem_span_singleton] + simpa only [primeGauss, tsum_fintype, ProbeGauss.frequencyGauss, hdiv] using + ProbeGauss.frequencyGauss_principal (quotientTrace p hp) hψ + (Ideal.Quotient.mk (Ideal.span {p}) h) + +theorem higher_outer_lift_annihilated (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ ξ : MulChar (O ⧸ Ideal.span {p}) ℂ) {n : ℕ} (hn : 0 < n) (m : O) : + ξ (Ideal.Quotient.mk (Ideal.span {p}) m) * primePowerGauss p hp χ n (-m) = 0 := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + by_cases hG : primePowerGauss p hp χ n (-m) = 0 + · rw [hG, mul_zero] + · have hdneg := primePowerGauss_support p hp χ n (-m) hG + have hdpow : p ∣ p ^ n := dvd_pow_self p (Nat.ne_of_gt hn) + have hdm : p ∣ m := dvd_neg.mp (hdpow.trans hdneg) + have hz : Ideal.Quotient.mk (Ideal.span {p}) m = 0 := + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr hdm) + rw [hz, MulChar.map_zero, zero_mul] + +def scalarKOne (p : O) (hp : p ≠ 0) + (χ ξ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h : O) : ℂ := + ∑' d : O ⧸ Ideal.span {p}, χ d * primePowerGauss p hp ξ n + (h - p ^ n * GaussianShiftedPartition.representative p d) + +theorem scalarKOne_eq (p : O) (hp : p ≠ 0) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ ξ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n : ℕ) (h : O) : + scalarKOne p hp χ ξ n h = + χ⁻¹ (-1) * primeGauss p hp χ 1 * primePowerGauss p hp (ξ * χ⁻¹) n h := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Finite (O ⧸ Ideal.span {p}) := ConcreteTraceCRT.finite_quotient_span hp + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + by_cases hdiv : p ^ n ∣ h + · obtain ⟨k, rfl⟩ := hdiv + have hmk (d : O ⧸ Ideal.span {p}) : + Ideal.Quotient.mk (Ideal.span {p}) + (k - GaussianShiftedPartition.representative p d) = + Ideal.Quotient.mk (Ideal.span {p}) k - d := by + rw [map_sub, GaussianShiftedPartition.representative_spec] + have hscalar : scalarKOne p hp χ ξ n (p ^ n * k) = + (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n * + ∑ d : O ⧸ Ideal.span {p}, χ d * ProbeGauss.frequencyGauss ξ + (quotientTrace p hp) (Ideal.Quotient.mk _ k - d) := by + unfold scalarKOne + rw [tsum_fintype, Finset.mul_sum] + apply Finset.sum_congr rfl + intro d _ + rw [← mul_sub, primePowerGauss_lift] + have he : primeGauss p hp ξ (k - GaussianShiftedPartition.representative p d) = + ProbeGauss.frequencyGauss ξ (quotientTrace p hp) (Ideal.Quotient.mk _ k - d) := by + rw [primeGauss, tsum_fintype] + simp only [hmk, ProbeGauss.frequencyGauss] + rw [he] + ring + rw [hscalar, ProbeGauss.finite_gauss_convolution, primePowerGauss_lift] + have hG : primeGauss p hp χ 1 = gaussSum χ (quotientTrace p hp) := by + simp [primeGauss, tsum_fintype, gaussSum] + have hF : primeGauss p hp (ξ * χ⁻¹) k = + ProbeGauss.frequencyGauss (ξ * χ⁻¹) (quotientTrace p hp) (Ideal.Quotient.mk _ k) := by + simp only [primeGauss, tsum_fintype, ProbeGauss.frequencyGauss] + rw [hG, hF] + ring + · rw [primePowerGauss_zero_off_support p hp (ξ * χ⁻¹) n h hdiv, mul_zero] + unfold scalarKOne + rw [tsum_fintype] + apply Finset.sum_eq_zero + intro d _ + have hndiv : ¬p ^ n ∣ h - p ^ n * GaussianShiftedPartition.representative p d := by + intro hd + apply hdiv + have ha := dvd_add hd (dvd_mul_right (p ^ n) + (GaussianShiftedPartition.representative p d)) + simpa only [sub_add_cancel] using ha + rw [primePowerGauss_zero_off_support p hp ξ n _ hndiv, mul_zero] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalContours.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalContours.lean new file mode 100644 index 0000000000000000000000000000000000000000..77906808d1e2cd862ec4ad2aef4e3e14a2bba933 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalContours.lean @@ -0,0 +1,1195 @@ +import OAI.NumberTheory.DirichletL.Detector.FiniteProductX +import OAI.NumberTheory.DirichletL.Hecke.ReciprocalGrowth +import Mathlib.MeasureTheory.Constructions.Polish.Basic + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators Topology +open Complex Set MeasureTheory Filter +namespace SevenEighths.ProbePrincipalContours +open HeckeFamily ProbePhysical ProbeEuler ProbeLocal CompletedGauss +open ProbeFiniteProductBounds ProbeFiniteProductX PrincipalMellinResidues +open PrincipalMellinGrowth ProbeMellinBoundary +local notation "Id" => Ideal ActualEisensteinCubic.O +local instance : Countable ActualEisensteinCubic.O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable Id := ConcretePrimeRowBridge.idealGenerator_injective.countable + +@[fun_prop] lemma measurable_const_cpow {α : Type*} [MeasurableSpace α] (Q : ℝ) (hQ : 0 (Q:ℂ)^f x) := by + have hn : (Q:ℂ)≠0 := by exact_mod_cast hQ.ne' + exact ((differentiable_id.const_cpow (Or.inl hn)).continuous.measurable).comp hf + +lemma ideal_correction_measurable {α : Type*} [MeasurableSpace α] + (η : Character) (P : PrimeIdeal) (x w z : α → ℂ) + (hx : Measurable x) (hw : Measurable w) (hz : Measurable z) : + Measurable (fun t => idealClosedCorrection η P (x t) (w t) (z t)) := by + have hQ : 0<(Ideal.absNorm P.val : ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr P.property.ne_zero) + unfold idealClosedCorrection unramifiedClosed continuedCorrection markedFactor + coordR coordV coordW coordD coordK + dsimp only + fun_prop (disch := aesop) + +lemma global_correction_measurable {α : Type*} [MeasurableSpace α] + (η : Character) (S : Finset Id) (x w z : α → ℂ) + (hx : Measurable x) (hw : Measurable w) (hz : Measurable z) : + Measurable (fun t => globalClosedCorrection η S (x t) (w t) (z t)) := by + unfold globalClosedCorrection + exact Measurable.tprod (fun P => ideal_correction_measurable η P.val x w z hx hw hz) + +lemma local_multiplier_measurable {α : Type*} [MeasurableSpace α] + (η : Character) (P : PrimeIdeal) (x w z : α → ℂ) + (hx : Measurable x) (hw : Measurable w) (hz : Measurable z) : + Measurable (fun t => localMultiplier η P (x t) (w t) (z t)) := by + have hQ : 0<(Ideal.absNorm P.val : ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr P.property.ne_zero) + have hc := ideal_correction_measurable η P x w z hx hw hz + unfold localMultiplier compensatedReplacement idealMarkedClosed markedFactor + coordR coordV coordW coordD coordK + dsimp only + fun_prop (disch := aesop) + +lemma slot_multiplier_measurable {α ι : Type*} [MeasurableSpace α] + (η : Character) (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (x w z : α → ℂ) (hx : Measurable x) (hw : Measurable w) (hz : Measurable z) : + Measurable (fun t => slotMultiplier η J T b (x t) (w t) (z t)) := by + unfold slotMultiplier + apply Finset.measurable_prod + intro j hj + apply Finset.measurable_sum + intro P hP + exact measurable_const.mul (local_multiplier_measurable η P x w z hx hw hz) + +def zBoxAmplitude (M : Id) (Bz : ℝ) : ℝ := + 36*max 6 (6*Bz+1)*principalConstant M + +lemma zBoxAmplitude_nonneg (M : Id) [NeZero M] (Bz : ℝ) : 0≤zBoxAmplitude M Bz := by + unfold zBoxAmplitude + exact mul_nonneg (mul_nonneg (by norm_num) (le_trans (by norm_num) (le_max_left _ _))) + (principalConstant_pos M).le + +lemma fixed_principal_z_box_growth (M : Id) [NeZero M] (Bz ξ t : ℝ) + (hξ : ξ∈Icc (33/200 : ℝ) Bz) : + ‖HeckeOrigin.poleRemoved (fixedPrincipal M) (6*((ξ:ℂ)+t*I))‖≤zBoxAmplitude M Bz*height t^3 := by + have hb := principal_poleRemoved_growth (fixedPrincipal M) rfl + (show (19/20 : ℝ)≤(6*((ξ:ℂ)+t*I) : ℂ).re by simp; linarith [hξ.1]) + have hn : ‖6*((ξ:ℂ)+t*I)+1‖≤max 6 (6*Bz+1)*height t := by + apply (Complex.norm_le_abs_re_add_abs_im _).trans + have hm : (6:ℝ)≤max 6 (6*Bz+1) := le_max_left _ _ + have hm' : 6*ξ+1≤max 6 (6*Bz+1) := (by linarith [hξ.2] : 6*ξ+1≤6*Bz+1).trans (le_max_right _ _) + simp only [add_re,add_im,ofReal_re,ofReal_im,mul_re,mul_im,I_re,I_im, + mul_zero,sub_zero,add_zero,zero_add,mul_one,one_re,one_im] + norm_num only [show (6:ℂ).re=6 by norm_num,show (6:ℂ).im=0 by norm_num,zero_mul,sub_zero,add_zero] + rw [abs_of_pos (by linarith [hξ.1] : 0<6*ξ+1),abs_mul] + norm_num + unfold height + nlinarith [mul_le_mul_of_nonneg_right hm (abs_nonneg t)] + have hi : |(6*((ξ:ℂ)+t*I) : ℂ).im|=6*|t| := by simp [abs_mul] + have ht : (3+6*|t|)^2≤36*height t^2 := by + have hh : 3+6*|t|≤6*height t := by unfold height; linarith + have hp := pow_le_pow_left₀ (by positivity : 0≤3+6*|t|) hh 2 + simpa only [mul_pow,show (6:ℝ)^2=36 by norm_num] using hp + have hC := (principalConstant_pos M).le + have hmax : 0≤max (6:ℝ) (6*Bz+1) := le_trans (by norm_num) (le_max_left _ _) + have hh := (height_pos t).le + rw [hi] at hb + calc + _ ≤ principalConstant M*‖6*((ξ:ℂ)+t*I)+1‖*(3+6*|t|)^2 := hb + _ ≤ principalConstant M*(max 6 (6*Bz+1)*height t)*(36*height t^2) := by + gcongr + _ = _ := by unfold zBoxAmplitude; ring + +lemma LFunction_eq_pole_quotient (χ : Character) {s : ℂ} (h0 : s≠0) (h1 : s≠1) : + LFunction χ s=HeckeOrigin.poleRemoved χ s/(s-1) := by + rw [HeckeOrigin.poleRemoved_eq χ h0 h1] + exact (mul_div_cancel_left₀ _ (sub_ne_zero.mpr h1)).symm + +lemma LFunction_vertical_continuous (χ : Character) (a : ℝ) (ha0 : a≠0) (ha1 : a≠1) : + Continuous (fun t : ℝ => LFunction χ ((a:ℂ)+t*I)) := by + have h0 (t : ℝ) : (a:ℂ)+t*I≠0 := by intro h; exact ha0 (by simpa using congrArg Complex.re h) + have h1 (t : ℝ) : (a:ℂ)+t*I≠1 := by intro h; exact ha1 (by simpa using congrArg Complex.re h) + have hc := ((HeckeOrigin.poleRemoved_entire χ).continuous.comp + (by fun_prop : Continuous (fun t : ℝ => (a:ℂ)+t*I))).div + (by fun_prop : Continuous (fun t : ℝ => (a:ℂ)+t*I-1)) (fun t => sub_ne_zero.mpr (h1 t)) + exact hc.congr (fun t => (LFunction_eq_pole_quotient χ (h0 t) (h1 t)).symm) + +lemma reciprocal_vertical_continuous (χ : Character) (a : ℝ) (ha : HeckeZeroSupremum.beta HeckeReciprocal.reciprocal χ ((a:ℂ)+t*I)) := by + apply continuous_iff_continuousAt.mpr + intro t + exact (HeckeReciprocal.reciprocal_differentiableAt χ (by simpa using ha)).continuousAt.comp + (by fun_prop : Continuous (fun t : ℝ => (a:ℂ)+t*I)).continuousAt + +lemma LFunction_norm_le_of_poleRemoved (χ : Character) (s : ℂ) (h0 : s≠0) (h1 : s≠1) + (A δ : ℝ) (hδ : 0<δ) (hd : δ≤‖s-1‖) (hA : ‖HeckeOrigin.poleRemoved χ s‖≤A) : + ‖LFunction χ s‖≤A/δ := by + apply (le_div_iff₀ hδ).mpr + calc + _ ≤ ‖LFunction χ s‖*‖s-1‖ := mul_le_mul_of_nonneg_left hd (norm_nonneg _) + _ = ‖HeckeOrigin.poleRemoved χ s‖ := by rw [HeckeOrigin.poleRemoved_eq χ h0 h1,norm_mul]; ring + _ ≤ A := hA + +lemma fixed_principal_w_bound (M : Id) [NeZero M] {cw υ : ℝ} (hcw : 1 arithmeticMultiplier η S hS J T b X Y Z + ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)) := by + have hH := global_correction_measurable η S + (fun p : HeightSpace => (a:ℂ)+p.1.1*I) (fun p : HeightSpace => (υ:ℂ)+p.2*I) + (fun p : HeightSpace => (ξ:ℂ)+p.1.2*I) (by fun_prop) (by fun_prop) (by fun_prop) + have hB := slot_multiplier_measurable η J T b + (fun p : HeightSpace => (a:ℂ)+p.1.1*I) (fun p : HeightSpace => (υ:ℂ)+p.2*I) + (fun p : HeightSpace => (ξ:ℂ)+p.1.2*I) (by fun_prop) (by fun_prop) (by fun_prop) + have hR := (reciprocal_vertical_continuous (η.excludePrimes S hS) a ha).measurable.comp + (by fun_prop : Measurable (fun p : HeightSpace => p.1.1)) + have hW := (LFunction_vertical_continuous (fixedSourcePrincipal S hS) υ hυ0 hυ1).measurable.comp + (by fun_prop : Measurable (fun p : HeightSpace => p.2)) + have hZL := (LFunction_vertical_continuous (fixedSourcePrincipal S hS) (6*ξ) + (mul_ne_zero (by norm_num) hξ0) hξ1).measurable.comp + (by fun_prop : Measurable (fun p : HeightSpace => 6*p.1.2)) + have hZL' : Measurable (fun p : HeightSpace => LFunction (fixedSourcePrincipal S hS) + (6*((ξ:ℂ)+p.1.2*I))) := by + convert hZL using 1 + funext p + congr 1 + push_cast + ring + unfold arithmeticMultiplier + fun_prop (disch := aesop) + +def boxScale (X Y Z a Bs Bz cw : ℝ) : ℝ := + scaleBound X (1/2-Bz) (1/2-33/200) * scaleBound Z (a+33/200-1) (Bs+Bz-1) * + scaleBound Y (19/20-1) (cw-1) + +lemma boxScale_pos (X Y Z a Bs Bz cw : ℝ) : 0 linarith [hξ.1,hξ.2]) + have hz := cpow_le_scaleBound hZ (((σ:ℂ)+p.1.1*I)+((ξ:ℂ)+p.1.2*I)-1) + (show ((((σ:ℂ)+p.1.1*I)+((ξ:ℂ)+p.1.2*I)-1) : ℂ).re∈Icc (a+33/200-1) (Bs+Bz-1) by + simp only [sub_re,add_re,ofReal_re,mul_re,ofReal_im,I_re,I_im,mul_zero,zero_mul,sub_self,add_zero,one_re]; constructor <;> linarith [hσ.1,hσ.2,hξ.1,hξ.2]) + have hy := cpow_le_scaleBound hY (((υ:ℂ)+p.2*I)-1) + (show (((υ:ℂ)+p.2*I)-1 : ℂ).re∈Icc (19/20-1) (cw-1) by + simp only [sub_re,add_re,ofReal_re,mul_re,ofReal_im,I_re,I_im,mul_zero,zero_mul,sub_self,add_zero,one_re]; constructor <;> linarith [hυ.1,hυ.2]) + have hr : ‖HeckeReciprocal.reciprocal (η.excludePrimes S hS.prime) ((σ:ℂ)+p.1.1*I)‖≤C*height p.1.1^2 := by + apply (hR _ (by simpa using hσ.1)).trans + simp only [add_im,ofReal_im,mul_im,ofReal_re,I_im,I_re,mul_one,mul_zero,add_zero,zero_add] + apply mul_le_mul_of_nonneg_left _ hC + unfold height + nlinarith [abs_nonneg p.1.1] + have hh := combined_slot_bound η S hS.tail J T b hT ((σ:ℂ)+p.1.1*I) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) Bs Bz + (by simpa using And.intro (ha.trans hσ.1) hσ.2) (by simpa using hυ.1) (by simpa using hξ) + have hw0 : (υ:ℂ)+p.2*I≠0 := by + intro h; have hh := congrArg Complex.re h; simp at hh; linarith [hυ.1] + have hw1 : (υ:ℂ)+p.2*I≠1 := by + intro h; rw [h,sub_self,norm_zero] at hwgap; linarith + have hz0 : (6*((ξ:ℂ)+p.1.2*I) : ℂ)≠0 := by + intro h; have hh := congrArg Complex.re h; simp at hh; linarith [hξ.1] + have hz1 : (6*((ξ:ℂ)+p.1.2*I) : ℂ)≠1 := by + intro h; rw [h,sub_self,norm_zero] at hzgap; linarith + have hlz0 := LFunction_norm_le_of_poleRemoved (fixedPrincipal (∏P∈S,P)) _ hz0 hz1 _ _ hdz hzgap + (fixed_principal_z_box_growth (∏P∈S,P) Bz ξ p.1.2 hξ) + have hlw0 := LFunction_norm_le_of_poleRemoved (fixedPrincipal (∏P∈S,P)) _ hw0 hw1 _ _ hdw hwgap + (fixed_principal_w_growth (∏P∈S,P) hcw hυ p.2) + have hlz : ‖LFunction (fixedPrincipal (∏P∈S,P)) (6*((ξ:ℂ)+p.1.2*I))‖≤ + (zBoxAmplitude (∏P∈S,P) Bz/δz)*height p.1.2^3 := by convert hlz0 using 1; ring + have hlw : ‖LFunction (fixedPrincipal (∏P∈S,P)) ((υ:ℂ)+p.2*I)‖≤ + (wAmplitude (∏P∈S,P) cw/δw)*height p.2^3 := by convert hlw0 using 1; ring + have hp1 := (height_pos p.1.1).le + have hp2 := (height_pos p.1.2).le + have hp3 := (height_pos p.2).le + have hpJ := (jointHeight_pos p.1.1 p.1.2 p.2).le + have hsX := (scaleBound_pos X (1/2-Bz) (1/2-33/200)).le + have hsY := (scaleBound_pos Y (19/20-1) (cw-1)).le + have hsZ := (scaleBound_pos Z (a+33/200-1) (Bs+Bz-1)).le + have hHB := mul_nonneg (by norm_num : (0:ℝ)≤3/2) (slotBound_nonneg J T b Bs Bz) + have hAZ := div_nonneg (zBoxAmplitude_nonneg (∏P∈S,P) Bz) hdz.le + have hAW := div_nonneg (wAmplitude_pos (∏P∈S,P) hcw).le hdw.le + calc + _ = ‖(X:ℂ)^(1/2-((ξ:ℂ)+p.1.2*I))‖ * + ‖(Z:ℂ)^(((σ:ℂ)+p.1.1*I)+((ξ:ℂ)+p.1.2*I)-1)‖ * + ‖(Y:ℂ)^(((υ:ℂ)+p.2*I)-1)‖ * + ‖HeckeReciprocal.reciprocal (η.excludePrimes S hS.prime) ((σ:ℂ)+p.1.1*I)‖ * + ‖globalClosedCorrection η S ((σ:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + slotMultiplier η J T b ((σ:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)‖ * + ‖LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I))‖ * + ‖LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I)‖ := by + simp only [arithmeticMultiplier,norm_mul] + _ ≤ scaleBound X (1/2-Bz) (1/2-33/200)*scaleBound Z (a+33/200-1) (Bs+Bz-1)* + scaleBound Y (19/20-1) (cw-1)*(C*height p.1.1^2)*((3/2)*slotBound J T b Bs Bz)* + ((zBoxAmplitude (∏P∈S,P) Bz/δz)*height p.1.2^3)* + ((wAmplitude (∏P∈S,P) cw/δw)*height p.2^3) := by + gcongr <;> first | positivity | exact hlz | exact hlw + _ ≤ scaleBound X (1/2-Bz) (1/2-33/200)*scaleBound Z (a+33/200-1) (Bs+Bz-1)* + scaleBound Y (19/20-1) (cw-1)*(C*jointHeight p.1.1 p.1.2 p.2^2)*((3/2)*slotBound J T b Bs Bz)* + ((zBoxAmplitude (∏P∈S,P) Bz/δz)*jointHeight p.1.1 p.1.2 p.2^3)* + ((wAmplitude (∏P∈S,P) cw/δw)*jointHeight p.1.1 p.1.2 p.2^3) := by + gcongr <;> first | positivity | exact height_le_joint_s _ _ _ | exact height_le_joint_z _ _ _ | exact height_le_joint_w _ _ _ + _ = _ := by unfold arithmeticAmplitude boxScale; ring + +lemma arithmetic_onLines_bound {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (X Y Z a Bs Bz cw σ ξ υ C : ℝ) (hX : 0 + continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z ((a:ℂ)+p.1.1*I) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I)) heightMeasure := by + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + have hi := profile_arithmetic_integrable W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 a ξ υ + (by linarith) (fun p : HeightSpace => arithmeticMultiplier η S hS.prime J T b X Y Z + ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)) + (arithmetic_onLines_measurable η S hS.prime J T b X Y Z a ξ υ hX hY hZ hβ + (by linarith) hξ1 (by linarith [hυ.1]) hυ1).aestronglyMeasurable + (arithmeticAmplitude S J T b X Y Z a a ξ cw C |υ-1| |6*ξ-1|) 8 + (arithmetic_onLines_bound η S hS J T b hT X Y Z a a ξ cw a ξ υ C hX hY hZ ha + ⟨le_rfl,le_rfl⟩ ⟨hξ,le_rfl⟩ hcw hυ hξ1 hυ1 hC hR) + apply hi.congr + exact Eventually.of_forall (fun p => arithmetic_profile_eq_source η S hS.prime J T b W0 W1 X Y Z _ _ _) + +lemma outer_height_ne_zero_ae : ∀ᵐp : HeightSpace ∂heightMeasure, p.1.1≠0 := by + have hh : ∀ᵐp : ℝ×ℝ ∂volume.prod volume, p.1≠0 := + Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ)) + exact Measure.quasiMeasurePreserving_fst.ae hh + +lemma continued_joint_ae_raw {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S, Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z a ξ υ : ℝ) : + (fun p : HeightSpace => continuedSourceMultiplier η S hS J T b W0 W1 X Y Z + ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)) =ᵐ[heightMeasure] + (fun p : HeightSpace => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS) + ((a:ℂ)+p.1.1*I) (globalClosedCorrection η S ((a:ℂ)+p.1.1*I)) + (slotMultiplier η J T b ((a:ℂ)+p.1.1*I)) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)) := by + filter_upwards [outer_height_ne_zero_ae] with p hp + apply continued_source_eq_raw + · intro h; exact hp (by simpa using congrArg Complex.im h) + · intro h; exact hp (by simpa using congrArg Complex.im h) + +theorem source_joint_integrable {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+p.1.1*I) + (globalClosedCorrection η S ((a:ℂ)+p.1.1*I)) (slotMultiplier η J T b ((a:ℂ)+p.1.1*I)) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I)) heightMeasure := by + apply (continued_source_joint_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ υ cw hX hY hZ ha hβ hξ hcw hυ hξ1 hυ1).congr + filter_upwards [continued_joint_ae_raw η S hS.prime J T b W0 W1 X Y Z a ξ υ] with p hp + rw [hp] + +theorem source_joint_fubini {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+p.1.1*I) + (globalClosedCorrection η S ((a:ℂ)+p.1.1*I)) (slotMultiplier η J T b ((a:ℂ)+p.1.1*I)) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I) + ((∫p, F p ∂heightMeasure)=∫t : ℝ,∫v : ℝ,∫u : ℝ,F ((t,v),u)) ∧ + ((∫p, F p ∂heightMeasure)=∫u : ℝ,∫v : ℝ,∫t : ℝ,F ((t,v),u)) := by + dsimp only + have hi := source_joint_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ υ cw hX hY hZ ha hβ hξ hcw hυ hξ1 hυ1 + constructor + · rw [integral_prod _ hi] + exact integral_prod _ hi.integral_prod_left + · rw [integral_prod_symm _ hi] + apply integral_congr_ae + filter_upwards [hi.prod_left_ae] with u hu + exact integral_prod_symm _ hu + +lemma arithmeticAmplitude_nonneg {ι : Type*} (S : Finset Id) (hS : ∀P∈S,Prime P) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (X Y Z a Bs Bz cw C δw δz : ℝ) (hcw : 1 + continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z ((a:ℂ)+p.1.1*I) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I) + Integrable (fun q : ℝ×ℝ => F (sliceMap axis R q)) (volume.prod volume) ∧ + (∫q : ℝ×ℝ,‖F (sliceMap axis R q)‖ ∂volume.prod volume)≤ + arithmeticAmplitude S J T b X Y Z a a ξ cw C |υ-1| |6*ξ-1| *K/height R^N := by + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + obtain ⟨K,hK,hk⟩ := profile_arithmetic_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a a ξ ξ υ υ (by linarith) 8 N + refine ⟨C,K,hC,hK,?_⟩ + intro axis R + let G : HeightSpace → ℂ := fun p => arithmeticMultiplier η S hS.prime J T b X Y Z + ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) + have hm := arithmetic_onLines_measurable η S hS.prime J T b X Y Z a ξ υ hX hY hZ hβ + (by linarith) hξ1 (by linarith [hυ.1]) hυ1 + have hbound := arithmetic_onLines_bound η S hS J T b hT X Y Z a a ξ cw a ξ υ C hX hY hZ ha + ⟨le_rfl,le_rfl⟩ ⟨hξ,le_rfl⟩ hcw hυ hξ1 hυ1 hC hR + have hh := hk a ⟨le_rfl,le_rfl⟩ ξ ⟨le_rfl,le_rfl⟩ υ ⟨le_rfl,le_rfl⟩ axis R + (arithmeticAmplitude S J T b X Y Z a a ξ cw C |υ-1| |6*ξ-1|) + (arithmeticAmplitude_nonneg S hS.prime J T b X Y Z a a ξ cw C _ _ hcw hC (abs_nonneg _) (abs_nonneg _)) + (fun q => G (sliceMap axis R q)) ((hm.comp (sliceMap_continuous axis R).measurable).aestronglyMeasurable) + (fun q => hbound (sliceMap axis R q)) + simpa only [G,onLines,arithmetic_profile_eq_source] using hh + +theorem source_w_leftover_outer_integrable {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 verticalIntegral (19/20) (fun w => + K w ((1/6+e:ℝ)+v*I)*LFunction (fixedSourcePrincipal S hS.prime) + (6*((1/6+e:ℝ)+v*I))*LFunction (fixedSourcePrincipal S hS.prime) w)) := by + obtain ⟨C,K,hC,hK,hslice⟩ := continued_source_slices η S hS J T b hT W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 X Y Z a (1/6+e) (19/20) 3 hX hY hZ ha hβ + (by linarith) (by norm_num) (by norm_num) (by linarith) (by norm_num) 0 + have hi := (hslice .s t).1 + have hs0 : (a:ℂ)+t*I≠0 := by + intro h; have hh := congrArg Complex.re h; simp at hh; linarith + have hpair : Integrable (fun q : ℝ×ℝ => + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+t*I) + (globalClosedCorrection η S ((a:ℂ)+t*I)) (slotMultiplier η J T b ((a:ℂ)+t*I)) + ((19/20:ℝ)+q.2*I) ((1/6+e:ℝ)+q.1*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((1/6+e:ℝ)+q.1*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((19/20:ℝ)+q.2*I)) (volume.prod volume) := by + simpa only [sliceMap,continued_source_eq_raw η S hS.prime J T b W0 W1 X Y Z _ _ _ hs0 hs1] using hi + simpa only [verticalIntegral] using hpair.integral_prod_left.const_mul (((1/(2*Real.pi):ℝ):ℂ)) + +theorem source_z_boundary_any {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) 1 z * + LFunction (fixedSourcePrincipal S hS.prime) (6*z)) (33/200) (1/6+e) := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + apply ProbeMellinBoundary.source_z_boundary W0 W1 a0 b0 ha0 hW0 (∏P∈S,P) + X Y Z hX hZ (η.excludePrimes S hS.prime) s hη + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + (AH := (3/2)*slotBound J T b s.re (1/6+e)) (AL := zBoxAmplitude (∏P∈S,P) (1/6+e)) + he (mul_nonneg (by norm_num) (slotBound_nonneg J T b _ _)) + (zBoxAmplitude_nonneg _ _) 0 3 + · exact (combined_slot_analytic_z η S hS.tail J T b hT s 1 hs (by norm_num)).continuousOn.mono + (by intro z hz; change (4/25:ℝ) verticalIntegral cw + (fun w => K w z*LFunction π (6*z)*LFunction π w)) = + verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => K w z*LFunction π (6*z)*LFunction π w)) + + HeckeReciprocal.regularizedL π 1*verticalIntegral (33/200) (fun z => K 1 z*LFunction π (6*z)) + + (HeckeReciprocal.regularizedL π 1)^2/6*K 1 (1/6) := by + dsimp only + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + have hs : (7/8 : ℝ)≤(((a:ℂ)+t*I) : ℂ).re := by simpa using ha + have hη := HeckeZeroSupremum.LFunction_ne_zero_of_beta_lt (η.excludePrimes S hS.prime) + (show HeckeZeroSupremum.beta<(((a:ℂ)+t*I) : ℂ).re by simpa using hβ) (Or.inl hs1) + have hzb := source_z_boundary_any η S hS J T b hT W0 W1 a0 b0 ha0 hW0 X Y Z hX hZ + ((a:ℂ)+t*I) hs hη he + apply source_ordered_double_shift (fixedSourcePrincipal S hS.prime) _ hcw he + · intro z hz + apply (source_multiplier_differentiable_w η S hS J T b hT W0 W1 a1 b1 ha1 hW1 + X Y Z hY ((a:ℂ)+t*I) z hs (by rw [hz]; linarith)).mono + intro w hw + change (9/10 : ℝ) verticalIntegral cw + (fun w => K w z*LFunction π (6*z)*LFunction π w)) = + verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => K w z*LFunction π (6*z)*LFunction π w)) + + HeckeReciprocal.regularizedL π 1*verticalIntegral (33/200) (fun z => K 1 z*LFunction π (6*z)) + + (HeckeReciprocal.regularizedL π 1)^2/6*K 1 (1/6) := by + filter_upwards [Measure.ae_ne volume (0:ℝ)] with t ht + apply source_ordered_at_height η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a e t cw hX hY hZ ha hβ hcw he + intro h + exact ht (by simpa using congrArg Complex.im h) + +def residueArithmetic {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S,Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (X Z : ℝ) (s z : ℂ) : ℂ := + (X:ℂ)^(1/2-z)*(Z:ℂ)^(s+z-1)*HeckeReciprocal.reciprocal (η.excludePrimes S hS) s * + (globalClosedCorrection η S s 1 z*slotMultiplier η J T b s 1 z)* + LFunction (fixedSourcePrincipal S hS) (6*z) + +lemma residue_profile_eq_source {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S,Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (s z : ℂ) : + residueArithmetic η S hS J T b X Z s z*profile W0 W1 s 1 z = + continuedSourceMultiplier η S hS J T b W0 W1 X Y Z s 1 z * + LFunction (fixedSourcePrincipal S hS) (6*z) := by + unfold residueArithmetic profile continuedSourceMultiplier + simp only [sub_self,Complex.cpow_zero,mul_one] + ring + +lemma residue_arithmetic_measurable {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S,Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (X Z a ξ : ℝ) (hX : 0 residueArithmetic η S hS J T b X Z + ((a:ℂ)+q.1*I) ((ξ:ℂ)+q.2*I)) := by + have hH := global_correction_measurable η S (fun q : ℝ×ℝ => (a:ℂ)+q.1*I) + (fun _ : ℝ×ℝ => (1:ℂ)) (fun q : ℝ×ℝ => (ξ:ℂ)+q.2*I) (by fun_prop) (by fun_prop) (by fun_prop) + have hB := slot_multiplier_measurable η J T b (fun q : ℝ×ℝ => (a:ℂ)+q.1*I) + (fun _ : ℝ×ℝ => (1:ℂ)) (fun q : ℝ×ℝ => (ξ:ℂ)+q.2*I) (by fun_prop) (by fun_prop) (by fun_prop) + have hR := (reciprocal_vertical_continuous (η.excludePrimes S hS) a hβ).measurable.comp + (by fun_prop : Measurable (fun q : ℝ×ℝ => q.1)) + have hL := (LFunction_vertical_continuous (fixedSourcePrincipal S hS) (6*ξ) + (mul_ne_zero (by norm_num) hξ0) hξ1).measurable.comp + (by fun_prop : Measurable (fun q : ℝ×ℝ => 6*q.2)) + have hL' : Measurable (fun q : ℝ×ℝ => LFunction (fixedSourcePrincipal S hS) + (6*((ξ:ℂ)+q.2*I))) := by + convert hL using 1 + funext q + congr 1 + push_cast + ring + unfold residueArithmetic + fun_prop (disch := aesop) + +def residueAmplitude {ι : Type*} (S : Finset Id) (J : Finset ι) + (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) (X Z a ξ C : ℝ) : ℝ := + X^(1/2-ξ)*Z^(a+ξ-1)*C*((3/2)*slotBound J T b a ξ)* + (zBoxAmplitude (∏P∈S,P) ξ/|6*ξ-1|) + +lemma residue_arithmetic_bound {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (X Z a ξ C : ℝ) (hX : 0 first | positivity | exact height_le_joint_s _ _ _ | exact height_le_joint_z _ _ _ + _ = _ := by unfold residueAmplitude; ring + +lemma residueAmplitude_nonneg {ι : Type*} (S : Finset Id) (hS : ∀P∈S,Prime P) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) (X Z a ξ C : ℝ) + (hX : 0≤X) (hZ : 0≤Z) (hC : 0≤C) : 0≤residueAmplitude S J T b X Z a ξ C := by + let : NeZero (∏P∈S,P) := ⟨fixedPrimeProduct_ne_zero S hS⟩ + have hb := slotBound_nonneg J T b a ξ + have hza := zBoxAmplitude_nonneg (∏P∈S,P) ξ + unfold residueAmplitude + positivity + +theorem continued_residue_pair_integrable {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((a:ℂ)+q.1*I) 1 ((ξ:ℂ)+q.2*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))) (volume.prod volume) := by + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + obtain ⟨K,hK,hk⟩ := profile_arithmetic_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a a ξ ξ 1 1 (by linarith) 5 0 + have hm := residue_arithmetic_measurable η S hS.prime J T b X Z a ξ hX hZ hβ (by linarith) hξ1 + have hb := residue_arithmetic_bound η S hS J T b hT X Z a ξ C hX hZ ha hξ hξ1 hC hR + have hh := (hk a ⟨le_rfl,le_rfl⟩ ξ ⟨le_rfl,le_rfl⟩ 1 ⟨le_rfl,le_rfl⟩ .w 0 + (residueAmplitude S J T b X Z a ξ C) + (residueAmplitude_nonneg S hS.prime J T b X Z a ξ C hX.le hZ.le hC) + (fun q : ℝ×ℝ => residueArithmetic η S hS.prime J T b X Z ((a:ℂ)+q.1*I) ((ξ:ℂ)+q.2*I)) + hm.aestronglyMeasurable hb).1 + apply hh.congr + apply Eventually.of_forall + intro q + simpa only [sliceMap,onLines,ofReal_one,ofReal_zero,zero_mul,add_zero] using + residue_profile_eq_source η S hS.prime J T b W0 W1 X Y Z ((a:ℂ)+q.1*I) ((ξ:ℂ)+q.2*I) + +theorem residue_pair_integrable {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) + ((a:ℂ)+q.1*I) (globalClosedCorrection η S ((a:ℂ)+q.1*I)) (slotMultiplier η J T b ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))) (volume.prod volume) := by + apply (continued_residue_pair_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hZ ha hβ hξ hξ1).congr + have hh : ∀ᵐq : ℝ×ℝ ∂volume.prod volume,q.1≠0 := + Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ)) + filter_upwards [hh] with q hq + have h0 : (a:ℂ)+q.1*I≠0 := by intro h; exact hq (by simpa using congrArg Complex.im h) + have h1 : (a:ℂ)+q.1*I≠1 := by intro h; exact hq (by simpa using congrArg Complex.im h) + rw [continued_source_eq_raw η S hS.prime J T b W0 W1 X Y Z _ _ _ h0 h1] + +theorem source_iterated_integrable {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 verticalIntegral ξ (fun z => verticalIntegral υ (fun w => + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+t*I) + (globalClosedCorrection η S ((a:ℂ)+t*I)) (slotMultiplier η J T b ((a:ℂ)+t*I)) w z * + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w))) := by + have hi := source_joint_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ υ cw hX hY hZ ha hβ hξ hcw hυ hξ1 hυ1 + simpa only [verticalIntegral,integral_const_mul,mul_assoc] using + (hi.integral_prod_left.integral_prod_left.const_mul (((1/(2*Real.pi):ℝ):ℂ))).const_mul (((1/(2*Real.pi):ℝ):ℂ)) + +theorem residue_iterated_integrable {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 verticalIntegral ξ (fun z => + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+t*I) + (globalClosedCorrection η S ((a:ℂ)+t*I)) (slotMultiplier η J T b ((a:ℂ)+t*I)) 1 z * + LFunction (fixedSourcePrincipal S hS.prime) (6*z))) := by + have hi := residue_pair_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hZ ha hβ hξ hξ1 + simpa only [verticalIntegral] using hi.integral_prod_left.const_mul (((1/(2*Real.pi):ℝ):ℂ)) + +theorem source_ordered_outer {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + let R := HeckeReciprocal.regularizedL π 1 + verticalIntegral a (fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral cw + (fun w => K s w z*LFunction π (6*z)*LFunction π w))) = + verticalIntegral a (fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => K s w z*LFunction π (6*z)*LFunction π w))) + + R*verticalIntegral a (fun s => verticalIntegral (33/200) (fun z => K s 1 z*LFunction π (6*z))) + + R^2/6*verticalIntegral a (fun s => K s 1 (1/6)) := by + let K := fun s => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + let R := HeckeReciprocal.regularizedL π 1 + let A := fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral cw + (fun w => K s w z*LFunction π (6*z)*LFunction π w)) + let B := fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => K s w z*LFunction π (6*z)*LFunction π w)) + let D := fun s => R*verticalIntegral (33/200) (fun z => K s 1 z*LFunction π (6*z)) + let E := fun s => R^2/6*K s 1 (1/6) + have hA : Integrable (fun t : ℝ => A ((a:ℂ)+t*I)) := + source_iterated_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a (1/6+e) cw cw hX hY hZ ha hβ (by linarith) hcw ⟨by linarith,le_rfl⟩ + (by linarith) (ne_of_gt hcw) + have hB : Integrable (fun t : ℝ => B ((a:ℂ)+t*I)) := + source_iterated_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a (1/6+e) (19/20) cw hX hY hZ ha hβ (by linarith) hcw ⟨le_rfl,by linarith⟩ + (by linarith) (by norm_num) + have hD : Integrable (fun t : ℝ => D ((a:ℂ)+t*I)) := + (residue_iterated_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a (33/200) hX hZ ha hβ le_rfl (by norm_num)).const_mul R + have hp : ∀ᵐt : ℝ,A ((a:ℂ)+t*I)=B ((a:ℂ)+t*I)+D ((a:ℂ)+t*I)+E ((a:ℂ)+t*I) := + source_ordered_ae η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a e cw hX hY hZ ha hβ hcw he + have hE : Integrable (fun t : ℝ => E ((a:ℂ)+t*I)) := by + apply ((hA.sub hB).sub hD).congr + filter_upwards [hp] with t ht + change A ((a:ℂ)+t*I)-B ((a:ℂ)+t*I)-D ((a:ℂ)+t*I)=E ((a:ℂ)+t*I) + rw [ht] + ring + have heq : verticalIntegral a A=verticalIntegral a (fun s => B s+D s+E s) := by + unfold verticalIntegral + congr 1 + exact integral_congr_ae hp + rw [verticalIntegral_add a _ _ (hB.add hD) hE,verticalIntegral_add a _ _ hB hD] at heq + change verticalIntegral a A=verticalIntegral a B+R*verticalIntegral a _+R^2/6*verticalIntegral a _ + rw [heq] + simp only [D,E,verticalIntegral,integral_const_mul] + ring + +theorem source_initial_ordered {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + let R := HeckeReciprocal.regularizedL π 1 + verticalIntegral 3 (fun s => verticalIntegral 2 (fun z => verticalIntegral 3 + (fun w => K s w z*LFunction π (6*z)*LFunction π w))) = + verticalIntegral 3 (fun s => verticalIntegral 2 (fun z => verticalIntegral (19/20) + (fun w => K s w z*LFunction π (6*z)*LFunction π w))) + + R*verticalIntegral 3 (fun s => verticalIntegral (33/200) (fun z => K s 1 z*LFunction π (6*z))) + + R^2/6*verticalIntegral 3 (fun s => K s 1 (1/6)) := by + simpa only [show (1/6+11/6:ℝ)=2 by norm_num] using + source_ordered_outer η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z 3 (11/6) 3 hX hY hZ (by norm_num) + (by linarith [HeckeZeroSupremum.beta_le_one]) (by norm_num) (by norm_num) + +theorem source_uniform_joint_tails {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 if s=1 then LFunction χ 1 else HeckeOrigin.poleRemoved χ s/(s-1)) := + Measurable.ite (measurableSet_singleton (1:ℂ)) + (measurable_const : Measurable (fun _ : ℂ => LFunction χ 1)) hm + have h0 : Measurable (fun s : ℂ => if s=0 then LFunction χ 0 else + if s=1 then LFunction χ 1 else HeckeOrigin.poleRemoved χ s/(s-1)) := + Measurable.ite (measurableSet_singleton (0:ℂ)) + (measurable_const : Measurable (fun _ : ℂ => LFunction χ 0)) h1 + convert h0 using 1 + funext s + split_ifs with hs0 hs1 + · subst s; rfl + · subst s; rfl + · exact LFunction_eq_pole_quotient χ hs0 hs1 + +lemma arithmetic_onLines_measurable_all {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S,Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (X Y Z a ξ υ : ℝ) (hX : 0 arithmeticMultiplier η S hS J T b X Y Z + ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)) := by + have hH := global_correction_measurable η S + (fun p : HeightSpace => (a:ℂ)+p.1.1*I) (fun p : HeightSpace => (υ:ℂ)+p.2*I) + (fun p : HeightSpace => (ξ:ℂ)+p.1.2*I) (by fun_prop) (by fun_prop) (by fun_prop) + have hB := slot_multiplier_measurable η J T b + (fun p : HeightSpace => (a:ℂ)+p.1.1*I) (fun p : HeightSpace => (υ:ℂ)+p.2*I) + (fun p : HeightSpace => (ξ:ℂ)+p.1.2*I) (by fun_prop) (by fun_prop) (by fun_prop) + have hR := (reciprocal_vertical_continuous (η.excludePrimes S hS) a ha).measurable.comp + (by fun_prop : Measurable (fun p : HeightSpace => p.1.1)) + have hW := (LFunction_measurable (fixedSourcePrincipal S hS)).comp + (by fun_prop : Measurable (fun p : HeightSpace => (υ:ℂ)+p.2*I)) + have hZL := (LFunction_measurable (fixedSourcePrincipal S hS)).comp + (by fun_prop : Measurable (fun p : HeightSpace => 6*((ξ:ℂ)+p.1.2*I))) + unfold arithmeticMultiplier + fun_prop (disch := aesop) + +def joinWGap (axis : SliceAxis) (υ : ℝ) : ℝ := if axis=.w then 1 else |υ-1| +def joinZGap (axis : SliceAxis) (ξ : ℝ) : ℝ := if axis=.z then 6 else |6*ξ-1| + +lemma joinWGap_pos (axis : SliceAxis) (υ : ℝ) (hυ : axis≠.w→υ≠1) : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((σ:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I) + Integrable (fun q : ℝ×ℝ => F (sliceMap axis R q)) (volume.prod volume) ∧ + (∫q : ℝ×ℝ,‖F (sliceMap axis R q)‖ ∂volume.prod volume) ≤ + arithmeticAmplitude S J T b X Y Z a Bs Bz cw C (joinWGap axis υ) (joinZGap axis ξ) * K/height R^N := by + obtain ⟨K,hK,hk⟩ := profile_arithmetic_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a Bs (33/200) Bz (19/20) cw (by norm_num) 8 N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hY hZ + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + refine ⟨C,hC,?_⟩ + intro σ hσ ξ hξ υ hυ axis hυ1 hξ1 R hR0 + have hm := arithmetic_onLines_measurable_all η S hS.prime J T b X Y Z σ ξ υ hX hY hZ (hβ.trans_le hσ.1) + have hb (q : ℝ×ℝ) := arithmetic_onLines_bound_of_gaps η S hS J T b hT X Y Z a Bs Bz cw σ ξ υ C + hX hY hZ ha hσ hξ hcw hυ (joinWGap axis υ) (joinZGap axis ξ) + (joinWGap_pos axis υ hυ1) (joinZGap_pos axis ξ hξ1) hC hR (sliceMap axis R q) + (slice_w_gap axis R υ hR0 q) (slice_z_gap axis R ξ hR0 q) + have hh := hk σ hσ ξ hξ υ hυ axis R + (arithmeticAmplitude S J T b X Y Z a Bs Bz cw C (joinWGap axis υ) (joinZGap axis ξ)) + (arithmeticAmplitude_nonneg S hS.prime J T b X Y Z a Bs Bz cw C _ _ hcw hC + (joinWGap_pos axis υ hυ1).le (joinZGap_pos axis ξ hξ1).le) + (fun q : ℝ×ℝ => arithmeticMultiplier η S hS.prime J T b X Y Z + ((σ:ℂ)+(sliceMap axis R q).1.1*I) ((υ:ℂ)+(sliceMap axis R q).2*I) + ((ξ:ℂ)+(sliceMap axis R q).1.2*I)) + (hm.comp (sliceMap_continuous axis R).measurable).aestronglyMeasurable hb + simpa only [onLines,arithmetic_profile_eq_source] using hh + +theorem residue_uniform_moments {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+q.1*I) + (globalClosedCorrection η S ((a:ℂ)+q.1*I)) (slotMultiplier η J T b ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I)) + Integrable (fun q : ℝ×ℝ => jointHeight q.1 q.2 0^N*‖F q‖) (volume.prod volume) ∧ + (∫q : ℝ×ℝ,jointHeight q.1 q.2 0^N*‖F q‖ ∂volume.prod volume)≤residueAmplitude S J T b X Z a ξ C*K := by + obtain ⟨K,hK,hk⟩ := profile_uniform_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a a ξ ξ 1 1 (by linarith) (5+N) 0 + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hZ + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + refine ⟨C,hC,?_⟩ + let A := residueAmplitude S J T b X Z a ξ C + have hA : 0≤A := residueAmplitude_nonneg S hS.prime J T b X Z a ξ C hX.le hZ.le hC + let F : ℝ×ℝ → ℂ := fun q => residueArithmetic η S hS.prime J T b X Z ((a:ℂ)+q.1*I) ((ξ:ℂ)+q.2*I) * + onLines W0 W1 a ξ 1 (sliceMap .w 0 q) + have hm := residue_arithmetic_measurable η S hS.prime J T b X Z a ξ hX hZ hβ (by linarith) hξ1 + have hFc : AEStronglyMeasurable F (volume.prod volume) := hm.aestronglyMeasurable.mul + (((onLines_continuous W0 W1 a1 b1 ha1 hW1 a ξ 1 (by linarith)).comp + (sliceMap_continuous .w 0)).aestronglyMeasurable) + have hb := residue_arithmetic_bound η S hS J T b hT X Z a ξ C hX hZ ha hξ hξ1 hC hR + have hmom := hk a ⟨le_rfl,le_rfl⟩ ξ ⟨le_rfl,le_rfl⟩ 1 ⟨le_rfl,le_rfl⟩ .w 0 + have hdom (q : ℝ×ℝ) : jointHeight q.1 q.2 0^N*‖F q‖≤ + A*(jointHeight q.1 q.2 0^(5+N)*‖onLines W0 W1 a ξ 1 (sliceMap .w 0 q)‖) := by + dsimp only [F] + rw [norm_mul] + calc + _ ≤ jointHeight q.1 q.2 0^N * ((A*jointHeight q.1 q.2 0^5)* + ‖onLines W0 W1 a ξ 1 (sliceMap .w 0 q)‖) := + mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_right (hb q) (norm_nonneg _)) + (pow_nonneg (jointHeight_pos _ _ _).le _) + _ = _ := by rw [pow_add]; ring + have hi : Integrable (fun q : ℝ×ℝ => jointHeight q.1 q.2 0^N*‖F q‖) (volume.prod volume) := by + apply (hmom.1.const_mul A).mono' + · exact (by unfold jointHeight; fun_prop : Continuous (fun q : ℝ×ℝ => jointHeight q.1 q.2 0^N)).aestronglyMeasurable.mul hFc.norm + · apply Eventually.of_forall + intro q + simpa only [Real.norm_eq_abs,abs_of_nonneg (mul_nonneg (pow_nonneg (jointHeight_pos _ _ _).le _) (norm_nonneg _)),sliceMap] using hdom q + have hn : (∫q : ℝ×ℝ,jointHeight q.1 q.2 0^N*‖F q‖ ∂volume.prod volume)≤A*K := by + calc + _ ≤ ∫q : ℝ×ℝ,A*(jointHeight q.1 q.2 0^(5+N)*‖onLines W0 W1 a ξ 1 (sliceMap .w 0 q)‖) + ∂volume.prod volume := integral_mono hi (hmom.1.const_mul A) hdom + _ = A*(∫q : ℝ×ℝ,jointHeight q.1 q.2 0^(5+N)*‖onLines W0 W1 a ξ 1 (sliceMap .w 0 q)‖ + ∂volume.prod volume) := integral_const_mul _ _ + _ ≤ A*K := mul_le_mul_of_nonneg_left (by simpa only [sliceMap,pow_zero,div_one] using hmom.2) hA + have heq : F =ᵐ[volume.prod volume] (fun q : ℝ×ℝ => + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+q.1*I) + (globalClosedCorrection η S ((a:ℂ)+q.1*I)) (slotMultiplier η J T b ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))) := by + have hh : ∀ᵐq : ℝ×ℝ ∂volume.prod volume,q.1≠0 := + Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ)) + filter_upwards [hh] with q hq + have h0 : (a:ℂ)+q.1*I≠0 := by intro h; exact hq (by simpa using congrArg Complex.im h) + have h1 : (a:ℂ)+q.1*I≠1 := by intro h; exact hq (by simpa using congrArg Complex.im h) + dsimp only [F,onLines,sliceMap] + simp only [ofReal_one,ofReal_zero,zero_mul,add_zero] + rw [residue_profile_eq_source η S hS.prime J T b W0 W1 X Y Z, + continued_source_eq_raw η S hS.prime J T b W0 W1 X Y Z _ _ _ h0 h1] + have hweight : (fun q : ℝ×ℝ => jointHeight q.1 q.2 0^N)=ᵐ[volume.prod volume] + (fun q : ℝ×ℝ => jointHeight q.1 q.2 0^N) := Eventually.of_forall (fun _ => rfl) + have heqw := hweight.mul (heq.fun_comp (fun z : ℂ => ‖z‖)) + exact ⟨hi.congr heqw, (integral_congr_ae heqw).symm.trans_le hn⟩ + +def residueOutside (R : ℝ) : Set (ℝ×ℝ) := {q | R < |q.1| ∨ R < |q.2|} +lemma residueOutside_measurable (R : ℝ) : MeasurableSet (residueOutside R) := by + unfold residueOutside + measurability + +theorem residue_uniform_tails {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+q.1*I) + (globalClosedCorrection η S ((a:ℂ)+q.1*I)) (slotMultiplier η J T b ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I)) + (∫q : ℝ×ℝ in residueOutside R,‖F q‖ ∂volume.prod volume)≤ + residueAmplitude S J T b X Z a ξ C*K/(1+R)^N := by + obtain ⟨K,hK,hk⟩ := residue_uniform_moments W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 a ξ ha hβ hξ hξ1 N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hZ + obtain ⟨C,hC,hi,hb⟩ := hk η S hS J T b hT X Y Z hX hZ + refine ⟨C,hC,?_⟩ + intro R hR + let F := fun q : ℝ×ℝ => + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+q.1*I) + (globalClosedCorrection η S ((a:ℂ)+q.1*I)) (slotMultiplier η J T b ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I)) + have hF := residue_pair_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hZ ha hβ hξ hξ1 + have hdom (q : ℝ×ℝ) (hq : q∈residueOutside R) : + ‖F q‖≤jointHeight q.1 q.2 0^N*‖F q‖/(1+R)^N := by + have hh : 1+R≤jointHeight q.1 q.2 0 := by + rcases hq with h|h <;> unfold jointHeight <;> simp only [abs_zero,add_zero] <;> + linarith [abs_nonneg q.1,abs_nonneg q.2] + have hp := pow_le_pow_left₀ (by linarith : 0≤1+R) hh N + apply (le_div_iff₀ (pow_pos (by linarith : 0<1+R) N)).mpr + simpa only [mul_comm] using mul_le_mul_of_nonneg_left hp (norm_nonneg (F q)) + change (∫q : ℝ×ℝ in residueOutside R,‖F q‖ ∂volume.prod volume)≤_ + calc + _ ≤ ∫q : ℝ×ℝ in residueOutside R,jointHeight q.1 q.2 0^N*‖F q‖/(1+R)^N + ∂volume.prod volume := setIntegral_mono_on hF.norm.integrableOn (hi.div_const _).integrableOn + (residueOutside_measurable R) hdom + _ = (∫q : ℝ×ℝ in residueOutside R,jointHeight q.1 q.2 0^N*‖F q‖ ∂volume.prod volume)/(1+R)^N := integral_div _ _ + _ ≤ (∫q : ℝ×ℝ,jointHeight q.1 q.2 0^N*‖F q‖ ∂volume.prod volume)/(1+R)^N := by + apply div_le_div_of_nonneg_right _ (by positivity) + exact setIntegral_le_integral hi (Eventually.of_forall (fun q => + mul_nonneg (pow_nonneg (jointHeight_pos _ _ _).le _) (norm_nonneg _))) + _ ≤ _ := div_le_div_of_nonneg_right hb (by positivity) + +lemma continued_high_slice_ae_raw {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S,Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z σ ξ υ : ℝ) + (axis : SliceAxis) (R : ℝ) (hR : R≠0) : + (fun q : ℝ×ℝ => let p := sliceMap axis R q + continuedSourceMultiplier η S hS J T b W0 W1 X Y Z + ((σ:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS) (6*((ξ:ℂ)+p.1.2*I))* + LFunction (fixedSourcePrincipal S hS) ((υ:ℂ)+p.2*I)) =ᵐ[volume.prod volume] + (fun q : ℝ×ℝ => let p := sliceMap axis R q + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS) ((σ:ℂ)+p.1.1*I) + (globalClosedCorrection η S ((σ:ℂ)+p.1.1*I)) (slotMultiplier η J T b ((σ:ℂ)+p.1.1*I)) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS) (6*((ξ:ℂ)+p.1.2*I))* + LFunction (fixedSourcePrincipal S hS) ((υ:ℂ)+p.2*I)) := by + have hh : ∀ᵐq : ℝ×ℝ ∂volume.prod volume,(sliceMap axis R q).1.1≠0 := by + cases axis + · exact Eventually.of_forall (fun _ => hR) + · exact Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ)) + · exact Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ)) + filter_upwards [hh] with q hq + have h0 : (σ:ℂ)+(sliceMap axis R q).1.1*I≠0 := by + intro h; exact hq (by simpa using congrArg Complex.im h) + have h1 : (σ:ℂ)+(sliceMap axis R q).1.1*I≠1 := by + intro h; exact hq (by simpa using congrArg Complex.im h) + dsimp only + rw [continued_source_eq_raw η S hS J T b W0 W1 X Y Z _ _ _ h0 h1] + +lemma source_axis_gaps {e : ℝ} (he : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) + ((σ:ℂ)+p.1.1*I) (globalClosedCorrection η S ((σ:ℂ)+p.1.1*I)) + (slotMultiplier η J T b ((σ:ℂ)+p.1.1*I)) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) * + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I)) * + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I) + Integrable (fun q : ℝ×ℝ => F (sliceMap axis R q)) (volume.prod volume) ∧ + (∫q : ℝ×ℝ,‖F (sliceMap axis R q)‖ ∂volume.prod volume) ≤ + arithmeticAmplitude S J T b X Y Z a Bs Bz cw C (joinWGap axis υ) (joinZGap axis ξ) * K/height R^N := by + obtain ⟨K,hK,hk⟩ := source_uniform_high_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a Bs Bz cw ha hβ hcw N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hY hZ + obtain ⟨C,hC,hc⟩ := hk η S hS J T b hT X Y Z hX hY hZ + refine ⟨C,hC,?_⟩ + intro σ hσ ξ hξ υ hυ axis hυ1 hξ1 R hR + have hh := hc σ hσ ξ hξ υ hυ axis hυ1 hξ1 R hR + have heq := continued_high_slice_ae_raw η S hS.prime J T b W0 W1 X Y Z σ ξ υ axis R + (by intro h; norm_num [h] at hR) + exact ⟨hh.1.congr heq,(integral_congr_ae (heq.fun_comp norm)).symm.trans_le hh.2⟩ + +end SevenEighths.ProbePrincipalContours +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalEulerIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalEulerIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..049f243132381c15e69df67ed8584efce79b97a7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalEulerIdentity.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Detector.LocalSummation +import OAI.NumberTheory.DirichletL.Detector.EulerCoordinates + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +lemma evenRatio_eq_coordR (Q : ℝ) (hQ : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma principalTuple_source_integrand {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : SourceExclusions S) (P : Fin K→PrimeIdeal) + (hP : Function.Injective P) (hPS : ∀i,(P i).val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (x w z : ℂ) + (hx : 3/2primaryGenerator (P i).val) 1 x w z= + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) x + (globalClosedCorrection η S x) (slotMultiplier η Finset.univ (fun i=>{P i}) (fun _ _=>1) x) w z* + HeckeFamily.LFunction (fixedSourcePrincipal S hS.prime) (6*z)* + HeckeFamily.LFunction (fixedSourcePrincipal S hS.prime) w := by + have hnorm (i : Fin K) : (elementNorm (primaryGenerator (P i).val):ℂ)=(Ideal.absNorm (P i).val:ℂ) := by + rw [primaryTuple_norm (P i) (outside_prime_supported S hS.bad (P i) (hPS i))] + norm_cast + rw [indexedCompensatedHigh_principal_continued η S hS P hP hPS x w z hx hw hz] + unfold sourceMultiplier sourceMellinWeight + simp only [hnorm,slotMultiplier,Finset.sum_singleton,one_mul,localMultiplier, + Complex.ofReal_natCast,Finset.prod_mul_distrib] + ring + +theorem principalRowIntegral_eq_sourceMultiplier {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : SourceExclusions S) (P : Fin K→PrimeIdeal) + (hP : Function.Injective P) (hPS : ∀i,(P i).val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : + principalRowIntegral η S (fun i=>primaryGenerator (P i).val) W0 W1 X Y Z= + ((1/(2*Real.pi):ℝ):ℂ)^3*∫t : HeightSpace, + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((3:ℂ)+t.1.1*Complex.I) + (globalClosedCorrection η S ((3:ℂ)+t.1.1*Complex.I)) + (slotMultiplier η Finset.univ (fun i=>{P i}) (fun _ _=>1) ((3:ℂ)+t.1.1*Complex.I)) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + HeckeFamily.LFunction (fixedSourcePrincipal S hS.prime) (6*((2:ℂ)+t.1.2*Complex.I))* + HeckeFamily.LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+t.2*Complex.I) ∂heightMeasure := by + unfold principalRowIntegral + congr 1 + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + exact principalTuple_source_integrand η S hS P hP hPS W0 W1 X Y Z + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalNormalized.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalNormalized.lean new file mode 100644 index 0000000000000000000000000000000000000000..c749586412adeb357f696b17208fabbe408c668c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalNormalized.lean @@ -0,0 +1,115 @@ +import OAI.NumberTheory.DirichletL.Detector.PrincipalPhysicalRemainder +import OAI.NumberTheory.DirichletL.Detector.PrincipalResidueActual +import OAI.NumberTheory.DirichletL.Detector.RayPoolThresholds + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ContDiff +open Complex Filter +namespace SevenEighths.ProbePrincipalNormalized +open HeckeFamily ProbePhysical CompletedGauss ProbeFiniteProductBounds +open PrincipalMellinResidues PrincipalSignalComparison ProbePrincipalResidueActual ProbeRaySlots +local notation "Id" => Ideal HeckeFamily.O + +lemma normalized_error (A R F N : ℂ) (c d v : ℝ) + (hc : 0≤c) (hA : ‖A-R‖≤c) (hN : ‖N⁻¹‖≤v) + (hR : ‖R/N-F‖≤d) : ‖A/N-F‖≤c*v+d := by + calc + _ = ‖(A-R)*N⁻¹+(R/N-F)‖ := by congr 1; simp only [div_eq_mul_inv];ring + _ ≤ ‖(A-R)*N⁻¹‖+‖R/N-F‖ := norm_add_le _ _ + _ ≤ c*v+d := by rw [norm_mul];gcongr + +theorem actual_ray_principal_comparison {K : ℕ} + (M : Id) [NeZero M] [Finite (HeckeFamily.O ⧸ M)] + (H : Subgroup (HeckeFamily.O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (c d B ellMin : ℝ) (hc : 0pool (RayQuotient.identityClass M H) S c d (Z^(ell j)) + let normer := sourceResidueConstant W0 W1 (∏p∈S,p)* + (Probe.principalScalar Finset.univ Z (1/6) + (slotMass T (residueWeights W (fun j=>Z^(ell j)))) : ℂ) + normer≠0 ∧ + ‖(∑P:(∀j,T j),(∏j,(W j ((Ideal.absNorm (P j).val.val:ℝ)/Z^(ell j)):ℂ))* + principalRowIntegral η S (fun j=>primaryGenerator (P j).val.val) + W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z)/normer- + HeckeSignal.signal (η.excludePrimes S hS.prime) (sourceCorrection η S) (-11/16) Z‖≤ + C*(Z^(HeckeZeroSupremum.beta-11/16-17/48000+nu)+ + Z^(HeckeZeroSupremum.beta-11/16+e-(7/8)*ellMin)) := by + let : NeZero (∏p∈S,p) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + obtain ⟨C0,hC0,hrem⟩ := ProbePrincipalPhysical.physical_principal_residue_remainder + η S hS c d B hc hd hB W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 e he hehi ha ha2 (K:=K) + obtain ⟨D,hD,hres⟩ := normalized_actual_window_residue S hS η ha ha2 (by linarith) (Finset.univ : Finset (Fin K)) + let cs := sourceResidueConstant W0 W1 (∏p∈S,p) + let C := C0/e*‖cs⁻¹‖+D*c^(-(7/8:ℝ))+1 + refine ⟨C,by dsimp [C];positivity,?_⟩ + have hpos (j : Fin K) : tsupport (W j)⊆Set.Ioi 0 := by + apply subset_trans (closure_minimal (Set.Subset.trans (hsupp j) Set.Ioo_subset_Icc_self) isClosed_Icc) + intro y hy; exact lt_of_lt_of_le hc hy.1 + filter_upwards [power_pool_thresholds (RayQuotient.identityClass M H) S η c d ellMin hc hd hmin ell hell, + power_ray_mass_and_normalizer M H hH S W c d hc hd hsupp hW hcompact hpos + (fun j y=>(hWbounds j y).1) hne ell (fun j=>hmin.trans_le (hell j)) nu hnu, + power_pool_tuples_eventually_injective (RayQuotient.identityClass M H) S + (fun _=>c) (fun _=>d) ell (fun _=>hc) (fun _=>hd) hdis] with Z hthreshold hmass htuple + rcases hthreshold with ⟨hZ,h480,hsmall,hslot,hpool⟩ + have hZ0 : 0pool (RayQuotient.identityClass M H) S c d (Z^(ell j)) + let normer := cs*(Probe.principalScalar Finset.univ Z (1/6) + (slotMass T (residueWeights W (fun j=>Z^(ell j)))) : ℂ) + have hr := hres W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 hr0 hr1 hp0 hp1 hn0 hn1 + T W (fun j=>Z^(ell j)) (c*Z^ellMin) (Z^(23/48:ℝ)) Z h480 hsmall + (fun j _ p _=>(hWbounds j _).1) (fun j _ p hp=>(hpool j p hp).1) + (fun j _ p hp=>(hpool j p hp).2.1) (fun j _=>hmass.1 j) hZ + dsimp only at hr ⊢ + refine ⟨hr.1,?_⟩ + have hraw := hrem ell hsum W hWbounds (fun j=>Set.Subset.trans (hsupp j) Set.Ioo_subset_Icc_self) + T (fun j p hp=>(hpool j p hp).2.2) htuple Z hZ (fun j=>(hslot j).1) (fun j=>(hslot j).2) + have hinv : ‖normer⁻¹‖≤‖cs⁻¹‖*Z^nu := by + dsimp only [normer] + rw [mul_inv_rev,norm_mul,←Complex.ofReal_inv,norm_real] + simpa only [hsum,Real.norm_eq_abs,mul_comm] using mul_le_mul_of_nonneg_left hmass.2 (norm_nonneg cs⁻¹) + have hh := normalized_error _ _ _ normer _ _ _ (by positivity) hraw hinv hr.2.2 + have hpw : (c*Z^ellMin)^(-(7/8:ℝ))=c^(-(7/8:ℝ))*Z^(-(7/8:ℝ)*ellMin) := by + rw [Real.mul_rpow hc.le (Real.rpow_nonneg hZ0.le _),←Real.rpow_mul hZ0.le] + congr 2;ring + have heq1 : (C0/e*Z^(HeckeZeroSupremum.beta-11/16-17/48000))*(‖cs⁻¹‖*Z^nu)= + (C0/e*‖cs⁻¹‖)*Z^(HeckeZeroSupremum.beta-11/16-17/48000+nu) := by + rw [Real.rpow_add hZ0];ring + have heq2 : D*Z^(HeckeZeroSupremum.beta+e-11/16)*(c*Z^ellMin)^(-(7/8:ℝ))= + (D*c^(-(7/8:ℝ)))*Z^(HeckeZeroSupremum.beta-11/16+e-(7/8)*ellMin) := by + rw [hpw] + rw [show HeckeZeroSupremum.beta-11/16+e-(7/8)*ellMin= + (HeckeZeroSupremum.beta+e-11/16)+(-(7/8:ℝ)*ellMin) by ring,Real.rpow_add hZ0] + ring + apply hh.trans + rw [heq1,heq2] + have h1 : C0/e*‖cs⁻¹‖≤C := by + dsimp [C] + have : 0≤D*c^(-(7/8:ℝ)) := by positivity + linarith + have h2 : D*c^(-(7/8:ℝ))≤C := by + dsimp [C] + have : 0≤C0/e*‖cs⁻¹‖ := by positivity + linarith + calc + _ ≤ C*Z^(HeckeZeroSupremum.beta-11/16-17/48000+nu)+ + C*Z^(HeckeZeroSupremum.beta-11/16+e-(7/8)*ellMin) := by gcongr + _ = _ := by ring +end SevenEighths.ProbePrincipalNormalized +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalNormalizer.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalNormalizer.lean new file mode 100644 index 0000000000000000000000000000000000000000..890de70fac5b637af0cb803f3d8c691df6c668b2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalNormalizer.lean @@ -0,0 +1,63 @@ +import OAI.NumberTheory.DirichletL.Hecke.PrincipalResidue +import OAI.NumberTheory.DirichletL.PrincipalSignalComparison +import OAI.NumberTheory.DirichletL.Detector.RadialMellin + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePrincipalNormalizer +open HeckeFamily PrincipalMellinResidues PrincipalSignalComparison +local notation "O" => HeckeFamily.O + +theorem sourceResidueConstant_positive (M : Ideal O) [NeZero M] + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 Ideal HeckeFamily.O + +lemma slotMultiplier_as_tuples {K : ℕ} (η : Character) (T : Fin K→Finset PrimeIdeal) + (b : Fin K→PrimeIdeal→ℂ) (s w z : ℂ) : + slotMultiplier η Finset.univ T b s w z= + ∑P : (∀i,T i),(∏i,b i (P i).val)* + slotMultiplier η Finset.univ (fun i=>{(P i).val}) (fun _ _=>1) s w z := by + simp only [slotMultiplier,Finset.sum_singleton,one_mul] + simp_rw [←Finset.prod_mul_distrib] + rw [←Fintype.prod_sum (fun i (p : T i)=>b i p.val*localMultiplier η p.val s w z)] + congr 1 + funext i + exact (Finset.sum_coe_sort (T i) (fun p=>b i p*localMultiplier η p s w z)).symm + +def principalPoolKernel {K : ℕ} (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (T : Fin K→Finset PrimeIdeal) (b : Fin K→PrimeIdeal→ℂ) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (s w z : ℂ) : ℂ := + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η Finset.univ T b s) w z * + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w + +lemma principalPoolKernel_as_tuples {K : ℕ} (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (T : Fin K→Finset PrimeIdeal) (b : Fin K→PrimeIdeal→ℂ) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (s w z : ℂ) : + principalPoolKernel η S hS T b W0 W1 X Y Z s w z= + ∑P : (∀i,T i),(∏i,b i (P i).val)* + principalPoolKernel η S hS (fun i=>{(P i).val}) (fun _ _=>1) W0 W1 X Y Z s w z := by + unfold principalPoolKernel sourceMultiplier + rw [slotMultiplier_as_tuples] + simp only [Finset.mul_sum,Finset.sum_mul] + apply Finset.sum_congr rfl + intro P hP + ring + +theorem principal_physical_pool_initial {K : ℕ} (η : Character) + (S : Finset Id) (hS : SourceExclusions S) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→P.val∉S) + (hdis : ∀P:(∀i,T i),Function.Injective (fun i=>(P i).val)) + (b : Fin K→PrimeIdeal→ℂ) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0primaryGenerator (P i).val.val) W0 W1 X Y Z)= + ((1/(2*Real.pi):ℝ):ℂ)^3*∫t : HeightSpace, + principalPoolKernel η S hS T b W0 W1 X Y Z + ((3:ℂ)+t.1.1*I) ((3:ℂ)+t.2*I) ((2:ℂ)+t.1.2*I) ∂heightMeasure := by + let F (P : ∀i,T i) (t : HeightSpace) := + principalPoolKernel η S hS (fun i=>{(P i).val}) (fun _ _=>1) W0 W1 X Y Z + ((3:ℂ)+t.1.1*I) ((3:ℂ)+t.2*I) ((2:ℂ)+t.1.2*I) + have hF (P : ∀i,T i) : Integrable (F P) heightMeasure := by + apply source_joint_integrable η S hS Finset.univ (fun i=>{(P i).val}) (fun _ _=>1) + (by intro i hi p hp;simp only [Finset.mem_singleton] at hp;subst p;exact hT i _ (P i).property) + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z 3 2 3 3 hX hY hZ + (by norm_num) (lt_of_le_of_lt HeckeZeroSupremum.beta_le_one (by norm_num)) + (by norm_num) (by norm_num) (by norm_num) (by norm_num) (by norm_num) + simp_rw [principalPoolKernel_as_tuples η S hS T b W0 W1 X Y Z] + rw [integral_finsetSum Finset.univ (fun P _=>(hF P).const_mul (∏i,b i (P i).val)),Finset.mul_sum] + apply Finset.sum_congr rfl + intro P hP + rw [principalRowIntegral_eq_sourceMultiplier η S hS (fun i=>(P i).val) (hdis P) + (fun i=>hT i _ (P i).property) W0 W1 X Y Z,integral_const_mul] + dsimp only [F,principalPoolKernel] + ring + +theorem principal_physical_pool_ordered {K : ℕ} (η : Character) + (S : Finset Id) (hS : SourceExclusions S) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→P.val∉S) + (hdis : ∀P:(∀i,T i),Function.Injective (fun i=>(P i).val)) + (b : Fin K→PrimeIdeal→ℂ) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η Finset.univ T b s) + let π := fixedSourcePrincipal S hS.prime + let R := HeckeReciprocal.regularizedL π 1 + (∑P : (∀i,T i),(∏i,b i (P i).val)* + principalRowIntegral η S (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z)= + verticalIntegral a (fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => F s w z*LFunction π (6*z)*LFunction π w)))+ + R*verticalIntegral a (fun s => verticalIntegral (33/200) (fun z => F s 1 z*LFunction π (6*z)))+ + R^2/6*verticalIntegral a (fun s => F s 1 (1/6)) := by + dsimp only + rw [principal_physical_pool_initial η S hS T hT hdis b W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 X Y Z hX hY hZ] + exact ProbePrincipalTransport.source_initial_joint_ordered_at_a η S hS Finset.univ T b + (fun i _ p hp=>hT i p hp) W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a e hX hY hZ ha ha3 hβ he he2 + +lemma finitePhysicalRows_principal {K : ℕ} (S : Finset Id) (hmax : ∀P∈S,P.IsMaximal) + (η : Character) (T : Fin K→Finset PrimeIdeal) (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : + ProbeHighRowFamily.finitePhysicalRows S hmax η {principalFreeRow} T W Yp W0 W1 X Y Z= + ∑P : (∀i,T i),(∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + principalRowIntegral η S (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z := by + simp only [ProbeHighRowFamily.finitePhysicalRows,Finset.sum_singleton,rowIntegral_principal] + +theorem compensatedPhysicalProbe_principal_pool_split {K : ℕ} (η : Character) + (S : Finset Id) (hS : SourceExclusions S) (hmax : ∀P∈S,P.IsMaximal) + (T : Fin K→Finset PrimeIdeal) (hT : ∀i P,P∈T i→Supported P.val) + (W : Fin K→ℝ→ℂ) (Yp : Fin K→ℝ) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0canonicalSlotSupport (T i)) W Yp X Y Z= + ProbeHighRowFamily.finitePhysicalRows S hmax η {principalFreeRow} T W Yp W0 W1 X Y Z+ + ∑'u : HeckeInverseAmplification.FreeRow,if u=principalFreeRow then 0 else + ∑P : (∀i,T i),(∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + rowIntegral η S (calibrationForSet S hmax) (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z u := by + have hSne : S.Nonempty := (by simp [fixedBadPrimes] : fixedBadPrimes.Nonempty).mono hS.bad + rw [compensatedPhysicalProbe_eq_canonical_rows η S hmax hS.prime hS.bad hSne T hT W Yp + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ] + have hs (P : ∀i,T i) : Summable (fun u : HeckeInverseAmplification.FreeRow=> + (∏i,W i ((Ideal.absNorm (P i).val.val:ℝ)/Yp i))* + rowIntegral η S (calibrationForSet S hmax) (fun i=>primaryGenerator (P i).val.val) W0 W1 X Y Z u) := + (rowIntegral_summable η S _ _ (fun i=>supported_primaryGenerator_ne_zero _ (hT i _ (P i).property)) + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ).mul_left _ + rw [(summable_sum (s:=Finset.univ) (fun P _=>hs P)).tsum_eq_add_tsum_ite principalFreeRow] + simp only [ProbeHighRowFamily.finitePhysicalRows,Finset.sum_singleton] + +end SevenEighths.ProbePrincipalPhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalPhysicalRemainder.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalPhysicalRemainder.lean new file mode 100644 index 0000000000000000000000000000000000000000..7ef666c8b8c6a9e2f3c47cc0a7b3ccb7c73d6f68 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalPhysicalRemainder.lean @@ -0,0 +1,70 @@ +import OAI.NumberTheory.DirichletL.Detector.PrincipalPhysical +import OAI.NumberTheory.DirichletL.Detector.PrincipalRemainderBounds + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +open Complex MeasureTheory +namespace SevenEighths.ProbePrincipalPhysical +open HeckeFamily ProbePhysical CompletedGauss ProbeFiniteProductBounds +open PrincipalMellinResidues PrincipalSignalComparison ProbeMellinBoundary ProbePrincipalContours +local notation "Id" => Ideal HeckeFamily.O + +theorem physical_principal_residue_remainder {K : ℕ} + (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (c d B : ℝ) (hc : 0(P j).val)) → + ∀Z : ℝ,1≤Z → (∀j,480≤c*Z^(ell j)) → (∀j,(Ideal.absNorm η.modulus:ℝ)primaryGenerator (P j).val.val) + W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z)- + sourceResidueIntegral W0 W1 (∏p∈S,p) (η.excludePrimes S hS.prime) + (HeckeZeroSupremum.beta+e) (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z + (globalClosedCorrection η S) + (windowMultiplier η Finset.univ T (fun j x=>(W j x:ℂ)) (fun j=>Z^(ell j)))‖≤ + C/e*Z^(HeckeZeroSupremum.beta-11/16-17/48000) := by + let : NeZero (∏p∈S,p) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + obtain ⟨C,hC,hbound⟩ := ProbePrincipalRemainderBounds.source_remainders_strict_saving η S hS + (Finset.univ : Finset (Fin K)) c d B hc hd hB W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 e he hehi ⟨ha.le,ha2⟩ + refine ⟨2*C,by positivity,?_⟩ + intro ell hell W hW hsupp T hT hdis Z hZ hthreshold hmod + have hZ0 : 0hW j) (fun j _=>hsupp j) T (fun j _ p hp=>hT j p hp) + Z hZ (fun j _=>hthreshold j) (fun j _=>hmod j) + dsimp only at hb + have heq := principal_physical_pool_ordered η S hS T hT hdis + (fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/Z^(ell j)):ℂ)) W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z (HeckeZeroSupremum.beta+e) e + (Real.rpow_pos_of_pos hZ0 _) (Real.rpow_pos_of_pos hZ0 _) hZ0 ha (by linarith) (by linarith) he (by linarith) + dsimp only at heq + have hres (F : ℂ→ℂ) : + (HeckeReciprocal.regularizedL (fixedSourcePrincipal S hS.prime) 1)^2/6* + verticalIntegral (HeckeZeroSupremum.beta+e) F= + verticalIntegral (HeckeZeroSupremum.beta+e) (fun s=>fixedPrincipalResidue (∏p∈S,p)^2/6*F s) := by + rw [verticalIntegral,verticalIntegral,integral_const_mul] + dsimp only [fixedPrincipalResidue,fixedPrincipal,fixedSourcePrincipal] + ring + rw [heq] + unfold sourceResidueIntegral windowMultiplier + rw [hres,add_sub_cancel_right] + have hn := (norm_add_le _ _).trans (add_le_add hb.1 hb.2) + change _≤(2*C)/e*Z^(HeckeZeroSupremum.beta-11/16-17/48000) + apply hn.trans + have hCe : C≤C/e := (le_div_iff₀ he).mpr (by nlinarith) + have hzpow : 0≤Z^(HeckeZeroSupremum.beta-11/16-17/48000) := Real.rpow_nonneg hZ0.le _ + have htwo : (2*C)/e=2*(C/e) := by ring + rw [htwo] + nlinarith +end SevenEighths.ProbePrincipalPhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalProduct.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalProduct.lean new file mode 100644 index 0000000000000000000000000000000000000000..3bed6f64ccd9e7cbe616de7d25ab08bfc1d74ace --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalProduct.lean @@ -0,0 +1,122 @@ +import OAI.NumberTheory.DirichletL.Detector.EulerHolomorphic +import OAI.NumberTheory.DirichletL.Detector.NormalProduct + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss SmoothMobiusCorrection +local notation "O" => ActualEisensteinCubic.O + +def primeDefectBound (P : PrimeIdeal) : ℝ := + 240 * (Ideal.absNorm P.val : ℝ) ^ (-(363/200:ℝ)) + +def principalLocal (eta : HeckeFamily.Character) (P : PrimeIdeal) (s : ℂ) : ℂ := + unramifiedClosed (Ideal.absNorm P.val) (actualAPhase eta (primaryGenerator P.val)) + (HeckeFamily.elementCoeff eta (primaryGenerator P.val)) 1 s 1 (1/6) + +def principalCorrection (eta : HeckeFamily.Character) (S : Finset (Ideal O)) (s : ℂ) : ℂ := + ∏' P : {P : PrimeIdeal // P.val ∉ S}, principalLocal eta P.val s + +lemma primeDefectBound_nonneg (P : PrimeIdeal) : 0 ≤ primeDefectBound P := by + unfold primeDefectBound + positivity + +lemma primeDefectBound_summable : Summable primeDefectBound := by + have h : Summable (fun P : PrimeIdeal => ‖CubicEisenstein.fullIdealWeight ((363/200:ℝ):ℂ) P.val‖) := + (CubicEisenstein.fullIdealWeight_summable_norm ((363/200:ℝ):ℂ) (by norm_num)).comp_injective + Subtype.val_injective + apply (h.mul_left 240).congr + intro P + unfold primeDefectBound CubicEisenstein.fullIdealWeight + simp only [P.property.ne_zero, ite_false] + rw [Complex.norm_natCast_cpow_of_pos (Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr P.property.ne_zero))] + norm_num + +lemma principalLocal_bound (eta : HeckeFamily.Character) (P : PrimeIdeal) + (hP : 4 ≤ Ideal.absNorm P.val) (s : ℂ) (hs : 7/8 < s.re) : + ‖principalLocal eta P s-1‖ ≤ primeDefectBound P := by + apply unramifiedClosed_second_region_bound + · exact_mod_cast hP + · exact actualAPhase_norm_le_one eta _ + · exact ProbeRow.targetMonoid_norm_le_one eta _ + · simp + · exact hs.le + · norm_num + · norm_num + +lemma principalLocal_analytic (eta : HeckeFamily.Character) (P : PrimeIdeal) + (hP : 4 ≤ Ideal.absNorm P.val) : + AnalyticOnNhd ℂ (principalLocal eta P) {s : ℂ | 7/8 < s.re} := by + apply principalClosed_analytic + · exact_mod_cast hP + · exact actualAPhase_norm_le_one eta _ + · exact ProbeRow.targetMonoid_norm_le_one eta _ + +theorem exists_uniform_principal_cutoff : + ∃ N : ℕ, 4 ≤ N ∧ ∀ (S : Finset (Ideal O)), + (∀ P : PrimeIdeal, Ideal.absNorm P.val ≤ N → P.val ∈ S) → + ∀ eta : HeckeFamily.Character, + AnalyticOnNhd ℂ (principalCorrection eta S) {s : ℂ | 7/8 < s.re} ∧ + ∀ s : ℂ, 7/8 < s.re → ‖principalCorrection eta S s-1‖ ≤ 1/2 := by + have ht := (tendsto_order.1 (tendsto_tsum_compl_atTop_zero primeDefectBound)).2 (1/6) (by norm_num) + obtain ⟨F, hF⟩ := ht.exists + let N := max 4 (F.sup (fun P => Ideal.absNorm P.val)) + refine ⟨N, le_max_left _ _, ?_⟩ + intro S hS eta + let T := {P : PrimeIdeal // P.val ∉ S} + have hnot (P : T) : P.val ∉ F := by + intro hm + apply P.property + apply hS P.val + exact (Finset.le_sup (f := fun Q : PrimeIdeal => Ideal.absNorm Q.val) hm).trans (le_max_right _ _) + let inc : T → {P : PrimeIdeal // P ∉ F} := fun P => ⟨P.val, hnot P⟩ + have hi : Function.Injective inc := by + intro P Q h + apply Subtype.ext + exact congrArg (fun t : {P : PrimeIdeal // P ∉ F} => t.val) h + have hnorm (P : T) : 4 ≤ Ideal.absNorm P.val.val := by + have hh : ¬ Ideal.absNorm P.val.val ≤ N := fun h => P.property (hS P.val h) + exact (le_max_left _ _).trans (Nat.le_of_lt (Nat.lt_of_not_ge hh)) + have hsum : Summable (fun P : T => primeDefectBound P.val) := + primeDefectBound_summable.subtype _ + have hsmall : (∑' P : T, primeDefectBound P.val) ≤ 1/6 := by + apply le_trans ?_ hF.le + exact Summable.tsum_le_tsum_of_inj inc hi + (fun P _ => primeDefectBound_nonneg P.val) (fun _ => le_rfl) + hsum (primeDefectBound_summable.subtype _) + have hhalf (P : T) : primeDefectBound P.val ≤ 1/2 := by + have hterm := Summable.le_tsum hsum P (fun Q _ => primeDefectBound_nonneg Q.val) + linarith + constructor + · exact normalProduct_analytic (fun P : T => principalLocal eta P.val) + (fun P : T => primeDefectBound P.val) _ (Complex.isOpen_re_gt _) hsum + (fun P => principalLocal_analytic eta P.val (hnorm P)) + (fun P s hs => principalLocal_bound eta P.val (hnorm P) s hs) hhalf + · intro s hs + exact product_defect_le (fun P : T => principalLocal eta P.val s) + (fun P : T => primeDefectBound P.val) hsum + (fun P => principalLocal_bound eta P.val (hnorm P) s hs) hhalf hsmall + +def smallPrimeSet (N : ℕ) : Finset (Ideal O) := + (Ideal.finite_setOfPred_absNorm_le N).toFinset.filter Prime + +lemma mem_smallPrimeSet (N : ℕ) (P : PrimeIdeal) : + P.val ∈ smallPrimeSet N ↔ Ideal.absNorm P.val ≤ N := by + simp [smallPrimeSet, P.property] + +theorem exists_principal_correction (S₀ : Finset (Ideal O)) : + ∃ S : Finset (Ideal O), S₀ ⊆ S ∧ ∀ eta : HeckeFamily.Character, + AnalyticOnNhd ℂ (principalCorrection eta S) {s : ℂ | 7/8 < s.re} ∧ + ∀ s : ℂ, 7/8 < s.re → ‖principalCorrection eta S s-1‖ ≤ 1/2 := by + obtain ⟨N, hN, hcut⟩ := exists_uniform_principal_cutoff + refine ⟨S₀ ∪ smallPrimeSet N, Finset.subset_union_left, ?_⟩ + apply hcut + intro P hP + exact Finset.mem_union_right _ ((mem_smallPrimeSet N P).mpr hP) + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalRemainderBounds.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalRemainderBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..361a138067aa2de390100307ae794147eb98dc48 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalRemainderBounds.lean @@ -0,0 +1,640 @@ +import OAI.NumberTheory.DirichletL.Detector.PrincipalTransport +import OAI.NumberTheory.DirichletL.PrincipalSignalComparison + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators Topology +open Complex Set MeasureTheory Filter +namespace SevenEighths.ProbePrincipalRemainderBounds +open HeckeFamily ProbePhysical ProbeEuler ProbeLocal CompletedGauss +open ProbeFiniteProductBounds ProbeFiniteProductX PrincipalMellinResidues +open PrincipalMellinGrowth ProbeMellinBoundary ProbePrincipalContours +local notation "Id" => Ideal ActualEisensteinCubic.O + +lemma active_prime_sum_bound (T : Finset PrimeIdeal) (W : ℝ→ℝ) + (c d B P ξ : ℝ) (hc : 0W ((Ideal.absNorm p.val:ℝ)/P)≠0) + have hA (p : PrimeIdeal) (hp : p∈A) : + c*P≤(Ideal.absNorm p.val:ℝ) ∧ (Ideal.absNorm p.val:ℝ)≤d*P := by + have h := hsupp (Finset.mem_filter.mp hp).2 + exact ⟨(le_div_iff₀ hP).mp h.1,(div_le_iff₀ hP).mp h.2⟩ + have he : (∑p∈T,W ((Ideal.absNorm p.val:ℝ)/P)*(Ideal.absNorm p.val:ℝ)^(ξ-1))= + ∑p∈A,W ((Ideal.absNorm p.val:ℝ)/P)*(Ideal.absNorm p.val:ℝ)^(ξ-1) := by + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro p hp hn + have hw : W ((Ideal.absNorm p.val:ℝ)/P)=0 := by + by_contra hh + exact hn (Finset.mem_filter.mpr ⟨hp,hh⟩) + simp [hw] + have hcount : (A.card:ℝ)≤128*(d*P) := by + have h := DescentFiberCost.finite_ideal_count_real (A.image Subtype.val) (d*P) + (by nlinarith) (by + intro I hI; obtain ⟨p,hp,rfl⟩ := Finset.mem_image.mp hI; exact p.property.ne_zero) + (by intro I hI; obtain ⟨p,hp,rfl⟩ := Finset.mem_image.mp hI; exact (hA p hp).2) + simpa only [Finset.card_image_of_injective _ Subtype.val_injective] using h + have hp (p : PrimeIdeal) (hp : p∈A) : (Ideal.absNorm p.val:ℝ)^(ξ-1)≤c^(ξ-1)*P^(ξ-1) := by + rw [←Real.mul_rpow hc.le hP.le] + exact Real.rpow_le_rpow_of_nonpos (mul_pos hc hP) (hA p hp).1 (by linarith) + rw [he] + calc + _≤∑_p∈A,B*(c^(ξ-1)*P^(ξ-1)) := Finset.sum_le_sum (fun p hpA=> + mul_le_mul (hW _).2 (hp p hpA) (Real.rpow_nonneg (Nat.cast_nonneg _) _) hB) + _=(A.card:ℝ)*(B*(c^(ξ-1)*P^(ξ-1))) := by simp + _≤(128*(d*P))*(B*(c^(ξ-1)*P^(ξ-1))) := + mul_le_mul_of_nonneg_right hcount (by positivity) + _=(128*d*B*c^(ξ-1))*P^ξ := by + have heP : P*P^(ξ-1)=P^ξ := by + calc + _=P^(1:ℝ)*P^(ξ-1) := by rw [Real.rpow_one] + _=P^ξ := by rw [←Real.rpow_add hP];congr 1;ring + calc + _=(128*d*B*c^(ξ-1))*(P*P^(ξ-1)) := by ring + _=_ := by rw [heP] + +def slotConstant {ι : Type*} (J : Finset ι) (c d B ξ : ℝ) : ℝ := + (3/2)*∏_j∈J,(1+1440*(480:ℝ)^(-(7/8:ℝ)))*(128*d*B*c^(ξ-1)) + +lemma slotConstant_nonneg {ι : Type*} (J : Finset ι) {c d B ξ : ℝ} + (hc : 0by positivity) + +theorem window_sharp_bound {ι : Type*} (η : Character) (S : Finset Id) + (hS : CorrectionTail S) (J : Finset ι) (c d B ξ : ℝ) + (hc : 0(W j x:ℂ)) P s w z‖≤ + slotConstant J c d B ξ * ∏j∈J,(P j)^ξ := by + let A (j : ι) := (T j).filter (fun p=>W j ((Ideal.absNorm p.val:ℝ)/P j)≠0) + have hA (j : ι) (hj : j∈J) (p : PrimeIdeal) (hp : p∈A j) : c*P j≤(Ideal.absNorm p.val:ℝ) := + (le_div_iff₀ (hP j hj)).mp ((hsupp j hj) (Finset.mem_filter.mp hp).2).1 + have he : windowMultiplier η J T (fun j x=>(W j x:ℂ)) P s w z = + slotMultiplier η J A (fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ)) s w z := by + unfold windowMultiplier slotMultiplier + apply Finset.prod_congr rfl + intro j hj + symm + apply Finset.sum_subset (Finset.filter_subset _ _) + intro p hp hn + have hh : W j ((Ideal.absNorm p.val:ℝ)/P j)=0 := by + by_contra h; exact hn (Finset.mem_filter.mpr ⟨hp,h⟩) + simp [hh] + rw [he] + have h := combined_slot_bound_sharp η S hS J A + (fun j p=>W j ((Ideal.absNorm p.val:ℝ)/P j)) 480 (by norm_num) + (fun j hj p _=>(hW j hj _).1) + (fun j hj p hp=>(hthreshold j hj).trans (hA j hj p hp)) + (fun j hj p hp=>PrincipalSignalComparison.idealCoeff_norm_one_of_coprime η p.val p.property.ne_zero + (PrincipalSignalComparison.prime_coprime_of_norm_gt η p (by + exact_mod_cast (hmod j hj).trans_le (hA j hj p hp)))) s w z hs hw (by rw [hz];exact hzlo) + apply h.trans + simp only [hz] + calc + _≤(3/2)*∏j∈J,(1+1440*(480:ℝ)^(-(7/8:ℝ)))*((128*d*B*c^(ξ-1))*(P j)^ξ) := by + apply mul_le_mul_of_nonneg_left _ (by norm_num) + apply Finset.prod_le_prod₀ + · intro j hj; apply mul_nonneg (by positivity);exact Finset.sum_nonneg (fun p _=>by + exact mul_nonneg (hW j hj _).1 (Real.rpow_nonneg (Nat.cast_nonneg _) _)) + · intro j hj + exact mul_le_mul_of_nonneg_left (active_prime_sum_bound (A j) (W j) c d B (P j) ξ + hc hd hB (hP j hj) (hthreshold j hj) hξ (hW j hj) (hsupp j hj)) (by positivity) + _=_ := by simp only [slotConstant,←mul_assoc,Finset.prod_mul_distrib] + +def scalePower (X Y Z a ξ υ : ℝ) : ℝ := + X^(1/2-ξ)*Z^(a+ξ-1)*Y^(υ-1) + +lemma scalePower_nonneg {X Y Z a ξ υ : ℝ} (hX : 0≤X) (hY : 0≤Y) (hZ : 0≤Z) : + 0≤scalePower X Y Z a ξ υ := by unfold scalePower;positivity + +section Pointwise +variable {ι : Type*} (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (c d B ξ : ℝ) (hc : 0(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ)) W0 W1 X Y Z + ((a:ℂ)+t*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+v*I)‖ ≤ + scalePower X Y Z a ξ υ*(C*slotConstant J c d B ξ)*(∏j∈J,(P j)^ξ)* + jointHeight t v u^2*‖onLines W0 W1 a ξ υ ((t,v),u)‖ := by + have hslot := window_sharp_bound η S hS.tail J c d B ξ hc hd hB hξ W hW hsupp + P hP hthreshold hmod T ((a:ℂ)+t*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+v*I) + (by simpa using ha) (by simpa using hυ) (by simp) hzlo + have hr : ‖HeckeReciprocal.reciprocal (η.excludePrimes S hS.prime) ((a:ℂ)+t*I)‖≤C*jointHeight t v u^2 := by + apply (hR _ (by simp)).trans + simp only [add_im,ofReal_im,mul_im,ofReal_re,I_im,I_re,mul_one,mul_zero,add_zero,zero_add] + apply mul_le_mul_of_nonneg_left _ hC + have hh := height_le_joint_s t v u + have hh0 := height_pos t + unfold height jointHeight at * + nlinarith [abs_nonneg t,abs_nonneg v,abs_nonneg u] + have hx : ‖(X:ℂ)^(1/2-((ξ:ℂ)+v*I))‖=X^(1/2-ξ) := by + rw [Complex.norm_cpow_eq_rpow_re_of_pos hX];congr 1;simp + have hz : ‖(Z:ℂ)^(((a:ℂ)+t*I)+((ξ:ℂ)+v*I)-1)‖=Z^(a+ξ-1) := by + rw [Complex.norm_cpow_eq_rpow_re_of_pos hZ];congr 1;simp + have hy : ‖(Y:ℂ)^(((υ:ℂ)+u*I)-1)‖=Y^(υ-1) := by + rw [Complex.norm_cpow_eq_rpow_re_of_pos hY];congr 1;simp + have he : continuedSourceMultiplier η S hS.prime J T + (fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ)) W0 W1 X Y Z + ((a:ℂ)+t*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+v*I) = + (X:ℂ)^(1/2-((ξ:ℂ)+v*I))*(Z:ℂ)^(((a:ℂ)+t*I)+((ξ:ℂ)+v*I)-1)* + (Y:ℂ)^(((υ:ℂ)+u*I)-1)*HeckeReciprocal.reciprocal (η.excludePrimes S hS.prime) ((a:ℂ)+t*I)* + (globalClosedCorrection η S ((a:ℂ)+t*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+v*I)* + windowMultiplier η J T (fun j x=>(W j x:ℂ)) P ((a:ℂ)+t*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+v*I))* + onLines W0 W1 a ξ υ ((t,v),u) := by + unfold continuedSourceMultiplier windowMultiplier onLines profile;ring + rw [he,norm_mul,norm_mul,norm_mul,norm_mul,norm_mul,hx,hz,hy] + calc + _≤X^(1/2-ξ)*Z^(a+ξ-1)*Y^(υ-1)*(C*jointHeight t v u^2)* + (slotConstant J c d B ξ*(∏j∈J,(P j)^ξ))*‖onLines W0 W1 a ξ υ ((t,v),u)‖ := by + gcongr + _=_ := by unfold scalePower;ring + +lemma full_sharp_pointwise (hυhi : υ≤2) (hυ1 : υ≠1) (hξ1 : 6*ξ≠1) (p : HeightSpace) : + ‖continuedSourceMultiplier η S hS.prime J T + (fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ)) W0 W1 X Y Z + ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I)‖ ≤ + (C*slotConstant J c d B ξ*(zBoxAmplitude (∏q∈S,q) 1/|6*ξ-1|)* + (wAmplitude (∏q∈S,q) 2/|υ-1|)) * + (scalePower X Y Z a ξ υ*(∏j∈J,(P j)^ξ))* + (jointHeight p.1.1 p.1.2 p.2^8*‖onLines W0 W1 a ξ υ p‖) := by + let : NeZero (∏q∈S,q) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + have h0 := continued_source_sharp_pointwise η S hS J c d B ξ hc hd hB hξ W hW hsupp P hP + hthreshold hmod T W0 W1 X Y Z a υ C hX hY hZ ha hυ hzlo hC hR p.1.1 p.1.2 p.2 + have hlz := fixed_principal_z_bound (∏q∈S,q) 1 ξ p.1.2 ⟨hzlo,hξ⟩ hξ1 + have hlw := fixed_principal_w_bound (∏q∈S,q) (by norm_num : (1:ℝ)<2) ⟨hυ,hυhi⟩ hυ1 p.2 + have hAZ := div_nonneg (zBoxAmplitude_nonneg (∏q∈S,q) 1) (abs_nonneg (6*ξ-1)) + have hAW := div_nonneg (wAmplitude_pos (∏q∈S,q) (by norm_num : (1:ℝ)<2)).le (abs_nonneg (υ-1)) + have hmass : 0≤∏j∈J,(P j)^ξ := Finset.prod_nonneg (fun j hj=>Real.rpow_nonneg (hP j hj).le _) + have hslot := slotConstant_nonneg J (ξ:=ξ) hc hd hB + have hs := scalePower_nonneg (a:=a) (ξ:=ξ) (υ:=υ) hX.le hY.le hZ.le + have ht := (height_pos p.1.1).le + have hv := (height_pos p.1.2).le + have hu := (height_pos p.2).le + have hj := (jointHeight_pos p.1.1 p.1.2 p.2).le + rw [norm_mul,norm_mul] + calc + _≤(scalePower X Y Z a ξ υ*(C*slotConstant J c d B ξ)*(∏j∈J,(P j)^ξ)* + jointHeight p.1.1 p.1.2 p.2^2*‖onLines W0 W1 a ξ υ p‖)* + ((zBoxAmplitude (∏q∈S,q) 1/|6*ξ-1|)*height p.1.2^3)* + ((wAmplitude (∏q∈S,q) 2/|υ-1|)*height p.2^3) := by + gcongr <;> first | positivity | exact h0 | exact hlz | exact hlw + _≤(scalePower X Y Z a ξ υ*(C*slotConstant J c d B ξ)*(∏j∈J,(P j)^ξ)* + jointHeight p.1.1 p.1.2 p.2^2*‖onLines W0 W1 a ξ υ p‖)* + ((zBoxAmplitude (∏q∈S,q) 1/|6*ξ-1|)*jointHeight p.1.1 p.1.2 p.2^3)* + ((wAmplitude (∏q∈S,q) 2/|υ-1|)*jointHeight p.1.1 p.1.2 p.2^3) := by + have hs := scalePower_nonneg (a:=a) (ξ:=ξ) (υ:=υ) hX.le hY.le hZ.le + gcongr <;> first | positivity | exact height_le_joint_z _ _ _ | exact height_le_joint_w _ _ _ + _=_ := by ring + +omit hυ in +lemma residue_sharp_pointwise (hξ1 : 6*ξ≠1) (q : ℝ×ℝ) : + ‖continuedSourceMultiplier η S hS.prime J T + (fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ)) W0 W1 X Y Z + ((a:ℂ)+q.1*I) 1 ((ξ:ℂ)+q.2*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))‖ ≤ + (C*slotConstant J c d B ξ*(zBoxAmplitude (∏p∈S,p) 1/|6*ξ-1|)) * + (scalePower X Y Z a ξ 1*(∏j∈J,(P j)^ξ))* + (jointHeight q.1 q.2 0^5*‖onLines W0 W1 a ξ 1 ((q.1,q.2),0)‖) := by + let : NeZero (∏p∈S,p) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + have h0 := continued_source_sharp_pointwise η S hS J c d B ξ hc hd hB hξ W hW hsupp P hP + hthreshold hmod T W0 W1 X Y Z a 1 C hX hY hZ ha (by norm_num) hzlo hC hR q.1 q.2 0 + simp only [ofReal_one,ofReal_zero,zero_mul,add_zero] at h0 + have hlz := fixed_principal_z_bound (∏p∈S,p) 1 ξ q.2 ⟨hzlo,hξ⟩ hξ1 + have hAZ := div_nonneg (zBoxAmplitude_nonneg (∏p∈S,p) 1) (abs_nonneg (6*ξ-1)) + have hmass : 0≤∏j∈J,(P j)^ξ := Finset.prod_nonneg (fun j hj=>Real.rpow_nonneg (hP j hj).le _) + have hslot := slotConstant_nonneg J (ξ:=ξ) hc hd hB + have hs := scalePower_nonneg (a:=a) (ξ:=ξ) (υ:=1) hX.le hY.le hZ.le + have hv := (height_pos q.2).le + rw [norm_mul] + calc + _≤(scalePower X Y Z a ξ 1*(C*slotConstant J c d B ξ)*(∏j∈J,(P j)^ξ)* + jointHeight q.1 q.2 0^2*‖onLines W0 W1 a ξ 1 ((q.1,q.2),0)‖)* + ((zBoxAmplitude (∏p∈S,p) 1/|6*ξ-1|)*height q.2^3) := by + gcongr ; first | positivity | exact h0 | exact hlz + _≤(scalePower X Y Z a ξ 1*(C*slotConstant J c d B ξ)*(∏j∈J,(P j)^ξ)* + jointHeight q.1 q.2 0^2*‖onLines W0 W1 a ξ 1 ((q.1,q.2),0)‖)* + ((zBoxAmplitude (∏p∈S,p) 1/|6*ξ-1|)*jointHeight q.1 q.2 0^3) := by + gcongr ; first | positivity | exact height_le_joint_z _ _ _ + _=_ := by ring +end Pointwise + +lemma vertical_triple_eq_joint (F : ℂ→ℂ→ℂ→ℂ) (a ξ υ : ℝ) + (hi : Integrable (fun p : HeightSpace=>F ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) + ((ξ:ℂ)+p.1.2*I)) heightMeasure) : + verticalIntegral a (fun s=>verticalIntegral ξ (fun z=>verticalIntegral υ (fun w=>F s w z))) = + (((1/(2*Real.pi):ℝ):ℂ))^3* + ∫p : HeightSpace,F ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I) ∂heightMeasure := by + rw [integral_prod _ hi,integral_prod _ hi.integral_prod_left] + simp only [verticalIntegral,integral_const_mul] + ring + +lemma vertical_pair_eq_joint (F : ℂ→ℂ→ℂ) (a ξ : ℝ) + (hi : Integrable (fun q : ℝ×ℝ=>F ((a:ℂ)+q.1*I) ((ξ:ℂ)+q.2*I)) (volume.prod volume)) : + verticalIntegral a (fun s=>verticalIntegral ξ (fun z=>F s z)) = + (((1/(2*Real.pi):ℝ):ℂ))^2* + ∫q : ℝ×ℝ,F ((a:ℂ)+q.1*I) ((ξ:ℂ)+q.2*I) ∂volume.prod volume := by + rw [integral_prod _ hi] + simp only [verticalIntegral,integral_const_mul] + ring + +lemma normalizer_norm_pos : 0<‖(((1/(2*Real.pi):ℝ):ℂ))‖ := by + apply norm_pos_iff.mpr + exact_mod_cast (one_div_ne_zero (mul_ne_zero (by norm_num : (2:ℝ)≠0) Real.pi_ne_zero)) + +section Uniform +variable {ι : Type*} (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (c d B : ℝ) (hc : 0 + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+p.1.1*I) + (globalClosedCorrection η S ((a:ℂ)+p.1.1*I)) + (windowMultiplier η J T (fun j x=>(W j x:ℂ)) P ((a:ℂ)+p.1.1*I)) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I) + Integrable F heightMeasure ∧ + (∫p,‖F p‖ ∂heightMeasure)≤K/(|6*ξ-1| *|υ-1|)* + (scalePower X Y Z a ξ υ*(∏j∈J,(P j)^ξ)) := by + let : NeZero (∏q∈S,q) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + obtain ⟨D,hD,hprofile⟩ := profile_uniform_moments W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + (7/8) 2 (33/200) 1 (19/20) 2 (by norm_num) 8 + let K := C*slotConstant J c d B ξ*zBoxAmplitude (∏q∈S,q) 1*wAmplitude (∏q∈S,q) 2*D + have hslot := slotConstant_nonneg J (ξ:=ξ) hc hd hB + have hZA := zBoxAmplitude_nonneg (∏q∈S,q) 1 + have hWA := (wAmplitude_pos (∏q∈S,q) (by norm_num : (1:ℝ)<2)).le + have hK : 0≤K := by dsimp [K];positivity + refine ⟨K+1,by positivity,?_⟩ + intro W hW hsupp P hP hthreshold hmod T hT X Y Z hX hY hZ + dsimp only + let b : ι→PrimeIdeal→ℂ := fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ) + have hi := continued_source_joint_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ υ 2 hX hY hZ ha.1 hβ hξ.1 (by norm_num) hυ hξ1 hυ1 + have hae := continued_joint_ae_raw η S hS.prime J T b W0 W1 X Y Z a ξ υ + have hae' := (hae.mul (EventuallyEq.rfl (f:=fun p : HeightSpace=> + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I))))).mul + (EventuallyEq.rfl (f:=fun p : HeightSpace=>LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I))) + refine ⟨hi.congr hae',?_⟩ + refine (integral_congr_ae (hae'.fun_comp norm)).symm.le.trans ?_ + let A := C*slotConstant J c d B ξ*(zBoxAmplitude (∏q∈S,q) 1/|6*ξ-1|)*(wAmplitude (∏q∈S,q) 2/|υ-1|) + let E := scalePower X Y Z a ξ υ*(∏j∈J,(P j)^ξ) + have hA : 0≤A := by dsimp [A];positivity + have hE : 0≤E := mul_nonneg (scalePower_nonneg hX.le hY.le hZ.le) + (Finset.prod_nonneg (fun j hj=>Real.rpow_nonneg (hP j hj).le _)) + have hp := hprofile a ha ξ hξ υ hυ + calc + _≤∫p : HeightSpace,A*E*(jointHeight p.1.1 p.1.2 p.2^8*‖onLines W0 W1 a ξ υ p‖) ∂heightMeasure := by + apply integral_mono hi.norm (hp.1.const_mul (A*E)) + intro p + exact full_sharp_pointwise η S hS J c d B ξ hc hd hB hξ.2 W hW hsupp P hP hthreshold + hmod T W0 W1 X Y Z a υ C hX hY hZ ha.1 hυ.1 hξ.1 hC hR hυ.2 hυ1 hξ1 p + _=A*E*(∫p : HeightSpace,jointHeight p.1.1 p.1.2 p.2^8*‖onLines W0 W1 a ξ υ p‖ ∂heightMeasure) := integral_const_mul _ _ + _≤A*E*D := mul_le_mul_of_nonneg_left hp.2 (mul_nonneg hA hE) + _=K/(|6*ξ-1| *|υ-1|)*E := by dsimp [A,K];simp only [div_eq_mul_inv,mul_inv_rev];ring + _≤(K+1)/(|6*ξ-1| *|υ-1|)*E := by gcongr;linarith + +theorem residue_scale_bound : + ∃K : ℝ,0 + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+q.1*I) + (globalClosedCorrection η S ((a:ℂ)+q.1*I)) + (windowMultiplier η J T (fun j x=>(W j x:ℂ)) P ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I)) + Integrable F (volume.prod volume) ∧ + (∫q,‖F q‖ ∂volume.prod volume)≤K/|6*ξ-1| * + (scalePower X Y Z a ξ 1*(∏j∈J,(P j)^ξ)) := by + let : NeZero (∏p∈S,p) := ⟨fixedPrimeProduct_ne_zero S hS.prime⟩ + obtain ⟨C,hC,hR⟩ := HeckeReciprocalGrowth.polynomial_reciprocal_bound (η.excludePrimes S hS.prime) a hβ + obtain ⟨D,hD,hprofile⟩ := profile_uniform_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + (7/8) 2 (33/200) 1 1 1 (by norm_num) 5 0 + let K := C*slotConstant J c d B ξ*zBoxAmplitude (∏p∈S,p) 1*D + have hslot := slotConstant_nonneg J (ξ:=ξ) hc hd hB + have hZA := zBoxAmplitude_nonneg (∏p∈S,p) 1 + have hK : 0≤K := by dsimp [K];positivity + refine ⟨K+1,by positivity,?_⟩ + intro W hW hsupp P hP hthreshold hmod T hT X Y Z hX hY hZ + dsimp only + let b : ι→PrimeIdeal→ℂ := fun j p=>(W j ((Ideal.absNorm p.val:ℝ)/P j):ℂ) + have hi := continued_residue_pair_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hZ ha.1 hβ hξ.1 hξ1 + have hae : (fun q : ℝ×ℝ => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((a:ℂ)+q.1*I) 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))) =ᵐ[volume.prod volume] + (fun q : ℝ×ℝ => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) + ((a:ℂ)+q.1*I) (globalClosedCorrection η S ((a:ℂ)+q.1*I)) + (windowMultiplier η J T (fun j x=>(W j x:ℂ)) P ((a:ℂ)+q.1*I)) 1 ((ξ:ℂ)+q.2*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))) := by + have hh : ∀ᵐq : ℝ×ℝ ∂volume.prod volume,q.1≠0 := + Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ)) + filter_upwards [hh] with q hq + have h0 : (a:ℂ)+q.1*I≠0 := by intro h;exact hq (by simpa using congrArg Complex.im h) + have h1 : (a:ℂ)+q.1*I≠1 := by intro h;exact hq (by simpa using congrArg Complex.im h) + rw [continued_source_eq_raw η S hS.prime J T b W0 W1 X Y Z _ _ _ h0 h1] + rfl + refine ⟨hi.congr hae,?_⟩ + refine (integral_congr_ae (hae.fun_comp norm)).symm.le.trans ?_ + let A := C*slotConstant J c d B ξ*(zBoxAmplitude (∏p∈S,p) 1/|6*ξ-1|) + let E := scalePower X Y Z a ξ 1*(∏j∈J,(P j)^ξ) + have hA : 0≤A := by dsimp [A];positivity + have hE : 0≤E := mul_nonneg (scalePower_nonneg hX.le hY.le hZ.le) + (Finset.prod_nonneg (fun j hj=>Real.rpow_nonneg (hP j hj).le _)) + have hp := hprofile a ha ξ hξ 1 ⟨le_rfl,le_rfl⟩ .w 0 + simp only [sliceMap,pow_zero,div_one] at hp + calc + _≤∫q : ℝ×ℝ,A*E*(jointHeight q.1 q.2 0^5*‖onLines W0 W1 a ξ 1 ((q.1,q.2),0)‖) ∂volume.prod volume := by + apply integral_mono hi.norm (hp.1.const_mul (A*E)) + intro q + exact residue_sharp_pointwise η S hS J c d B ξ hc hd hB hξ.2 W hW hsupp P hP hthreshold + hmod T W0 W1 X Y Z a C hX hY hZ ha.1 hξ.1 hC hR hξ1 q + _=A*E*(∫q : ℝ×ℝ,jointHeight q.1 q.2 0^5*‖onLines W0 W1 a ξ 1 ((q.1,q.2),0)‖ ∂volume.prod volume) := integral_const_mul _ _ + _≤A*E*D := mul_le_mul_of_nonneg_left hp.2 (mul_nonneg hA hE) + _=K/|6*ξ-1| *E := by dsimp [A,K];ring + _≤(K+1)/|6*ξ-1| *E := by gcongr;linarith + +theorem full_vertical_scale_bound (υ : ℝ) (hυ : υ∈Icc (19/20:ℝ) 2) (hυ1 : υ≠1) : + ∃K : ℝ,0sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (windowMultiplier η J T (fun j x=>(W j x:ℂ)) P s) + let π := fixedSourcePrincipal S hS.prime + ‖verticalIntegral a (fun s=>verticalIntegral ξ (fun z=>verticalIntegral υ + (fun w=>K0 s w z*LFunction π (6*z)*LFunction π w)))‖≤ + K/(|6*ξ-1| *|υ-1|)*(scalePower X Y Z a ξ υ*(∏j∈J,(P j)^ξ)) := by + obtain ⟨K,hK,hbound⟩ := full_scale_bound η S hS J c d B hc hd hB W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 a ξ ha hβ hξ hξ1 υ hυ hυ1 + let k := ‖(((1/(2*Real.pi):ℝ):ℂ))‖^3 + have hk : 0(W j x:ℂ)) P ((a:ℂ)+p.1.1*I)) + ((υ:ℂ)+p.2*I) ((ξ:ℂ)+p.1.2*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.1.2*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((υ:ℂ)+p.2*I)‖ ∂heightMeasure) := + mul_le_mul_of_nonneg_left (norm_integral_le_integral_norm _) hk.le + _≤k*(K/(|6*ξ-1| *|υ-1|)*(scalePower X Y Z a ξ υ*(∏j∈J,(P j)^ξ))) := + mul_le_mul_of_nonneg_left hh.2 hk.le + _=_ := by ring + +theorem residue_vertical_scale_bound : + ∃K : ℝ,0sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (windowMultiplier η J T (fun j x=>(W j x:ℂ)) P s) + let π := fixedSourcePrincipal S hS.prime + ‖HeckeReciprocal.regularizedL π 1 * verticalIntegral a (fun s=>verticalIntegral ξ + (fun z=>K0 s 1 z*LFunction π (6*z)))‖≤ + K/|6*ξ-1| *(scalePower X Y Z a ξ 1*(∏j∈J,(P j)^ξ)) := by + obtain ⟨K,hK,hbound⟩ := residue_scale_bound η S hS J c d B hc hd hB W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 a ξ ha hβ hξ hξ1 + let R := HeckeReciprocal.regularizedL (fixedSourcePrincipal S hS.prime) 1 + let k := ‖(((1/(2*Real.pi):ℝ):ℂ))‖^2 + have hk : 0(W j x:ℂ)) P ((a:ℂ)+q.1*I)) + 1 ((ξ:ℂ)+q.2*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+q.2*I))‖ ∂volume.prod volume)) := by + apply mul_le_mul (by dsimp [R];linarith [norm_nonneg (HeckeReciprocal.regularizedL (fixedSourcePrincipal S hS.prime) 1)]) + (mul_le_mul_of_nonneg_left (norm_integral_le_integral_norm _) hk.le) (by positivity) (by positivity) + _≤(1+‖R‖)*(k*(K/|6*ξ-1| *(scalePower X Y Z a ξ 1*(∏j∈J,(P j)^ξ)))) := by + gcongr;exact hh.2 + _=_ := by ring +end Uniform + +theorem ordered_remainders_scale_bound {ι : Type*} + (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (c d B : ℝ) (hc : 0sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (windowMultiplier η J T (fun j x=>(W j x:ℂ)) P s) + let π := fixedSourcePrincipal S hS.prime + (‖verticalIntegral a (fun s=>verticalIntegral (1/6+e) (fun z=>verticalIntegral (19/20) + (fun w=>K0 s w z*LFunction π (6*z)*LFunction π w)))‖≤ + C/e*(scalePower X Y Z a (1/6+e) (19/20)*(∏j∈J,(P j)^(1/6+e)))) ∧ + (‖HeckeReciprocal.regularizedL π 1 * verticalIntegral a (fun s=>verticalIntegral (33/200) + (fun z=>K0 s 1 z*LFunction π (6*z)))‖≤ + C*(scalePower X Y Z a (33/200) 1*(∏j∈J,(P j)^(33/200:ℝ)))) := by + obtain ⟨A,hA,hfirst⟩ := full_vertical_scale_bound η S hS J c d B hc hd hB W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 a (1/6+e) ha hβ ⟨by linarith,by linarith⟩ (by linarith) + (19/20) (by norm_num) (by norm_num) + obtain ⟨D,hD,hsecond⟩ := residue_vertical_scale_bound η S hS J c d B hc hd hB W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 a (33/200) ha hβ (by norm_num) (by norm_num) + refine ⟨(10/3)*A+100*D,by positivity,?_⟩ + intro W hW hsupp P hP hthreshold hmod T hT X Y Z hX hY hZ + dsimp only + have hf := hfirst W hW hsupp P hP hthreshold hmod T hT X Y Z hX hY hZ + have hg := hsecond W hW hsupp P hP hthreshold hmod T hT X Y Z hX hY hZ + dsimp only at hf hg + have hegap : |6*((1/6:ℝ)+e)-1|=6*e := by rw [abs_of_pos (by linarith)];ring + rw [hegap] at hf + norm_num only [show |(19/20:ℝ)-1|=1/20 by norm_num] at hf + norm_num only [show |6*(33/200:ℝ)-1|=1/100 by norm_num] at hg + have hm (ξ : ℝ) : 0≤∏j∈J,(P j)^ξ := Finset.prod_nonneg (fun j hj=>Real.rpow_nonneg (hP j hj).le _) + constructor + · apply hf.trans + apply mul_le_mul_of_nonneg_right _ (mul_nonneg (scalePower_nonneg hX.le hY.le hZ.le) (hm _)) + have heq : A/(6*e*(1/20))=((10/3)*A)/e := by field_simp;ring + rw [heq] + apply div_le_div_of_nonneg_right _ he.le + nlinarith + · apply hg.trans + apply mul_le_mul_of_nonneg_right _ (mul_nonneg (scalePower_nonneg hX.le hY.le hZ.le) (hm _)) + norm_num + linarith + +lemma source_scale_identity {ι : Type*} (J : Finset ι) (ell : ι→ℝ) + (hell : ∑j∈J,ell j=1/6) (Z a ξ υ : ℝ) (hZ : 0sourceMultiplier W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z + (η.excludePrimes S hS.prime) s (globalClosedCorrection η S s) + (windowMultiplier η J T (fun j x=>(W j x:ℂ)) (fun j=>Z^(ell j)) s) + let π := fixedSourcePrincipal S hS.prime + (‖verticalIntegral a (fun s=>verticalIntegral (1/6+e) (fun z=>verticalIntegral (19/20) + (fun w=>K0 s w z*LFunction π (6*z)*LFunction π w)))‖≤ + C/e*Z^(a-11/16+(13/16)*e-23/960)) ∧ + (‖HeckeReciprocal.regularizedL π 1 * verticalIntegral a (fun s=>verticalIntegral (33/200) + (fun z=>K0 s 1 z*LFunction π (6*z)))‖≤C*Z^(a-11/16-13/9600)) := by + obtain ⟨C,hC,hbound⟩ := ordered_remainders_scale_bound η S hS J c d B hc hd hB + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 a e ha hβ he hehi + refine ⟨C,hC,?_⟩ + intro ell hell W hW hsupp T hT Z hZ hthreshold hmod + dsimp only + have hh := hbound W hW hsupp (fun j=>Z^(ell j)) (fun _ _=>Real.rpow_pos_of_pos hZ _) + hthreshold hmod T hT (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z + (Real.rpow_pos_of_pos hZ _) (Real.rpow_pos_of_pos hZ _) hZ + dsimp only at hh + rw [source_w_scale_identity J ell hell Z a e hZ,source_z_scale_identity J ell hell Z a hZ] at hh + exact hh + +lemma source_w_strict_exponent (β e : ℝ) (he : e≤1/1000) : + (β+e)-11/16+(13/16)*e-23/960≤β-11/16-17/48000 := by linarith + +lemma source_z_strict_exponent (β e : ℝ) (he : e≤1/1000) : + (β+e)-11/16-13/9600≤β-11/16-17/48000 := by linarith + +theorem source_remainders_strict_saving {ι : Type*} + (η : Character) (S : Finset Id) (hS : SourceExclusions S) + (J : Finset ι) (c d B : ℝ) (hc : 0sourceMultiplier W0 W1 (Z^(17/48:ℝ)) (Z^(23/48:ℝ)) Z + (η.excludePrimes S hS.prime) s (globalClosedCorrection η S s) + (windowMultiplier η J T (fun j x=>(W j x:ℂ)) (fun j=>Z^(ell j)) s) + let π := fixedSourcePrincipal S hS.prime + (‖verticalIntegral (HeckeZeroSupremum.beta+e) (fun s=>verticalIntegral (1/6+e) + (fun z=>verticalIntegral (19/20) (fun w=>K0 s w z*LFunction π (6*z)*LFunction π w)))‖≤ + C/e*Z^(HeckeZeroSupremum.beta-11/16-17/48000)) ∧ + (‖HeckeReciprocal.regularizedL π 1 * verticalIntegral (HeckeZeroSupremum.beta+e) + (fun s=>verticalIntegral (33/200) (fun z=>K0 s 1 z*LFunction π (6*z)))‖≤ + C*Z^(HeckeZeroSupremum.beta-11/16-17/48000)) := by + obtain ⟨C,hC,hbound⟩ := source_remainders_power_bound η S hS J c d B hc hd hB + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 (HeckeZeroSupremum.beta+e) e ha (by linarith) he (by linarith) + refine ⟨C,hC,?_⟩ + intro ell hell W hW hsupp T hT Z hZ hthreshold hmod + dsimp only + have hh := hbound ell hell W hW hsupp T hT Z (by linarith) hthreshold hmod + dsimp only at hh + constructor + · exact hh.1.trans (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow_of_exponent_le hZ (source_w_strict_exponent HeckeZeroSupremum.beta e hehi)) + (div_nonneg hC.le he.le)) + · exact hh.2.trans (mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow_of_exponent_le hZ (source_z_strict_exponent HeckeZeroSupremum.beta e hehi)) hC.le) + +end SevenEighths.ProbePrincipalRemainderBounds + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalResidueActual.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalResidueActual.lean new file mode 100644 index 0000000000000000000000000000000000000000..2f336d8cfb0e6ec157ad1d43099372eb61961381 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalResidueActual.lean @@ -0,0 +1,72 @@ +import OAI.NumberTheory.DirichletL.Detector.PrincipalNormalizer +import OAI.NumberTheory.DirichletL.Detector.FiniteProductBounds + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +open Complex MeasureTheory +namespace SevenEighths.ProbePrincipalResidueActual +open HeckeFamily PrincipalMellinResidues PrincipalSignalComparison +open ProbeFiniteProductBounds ProbeEuler ProbeLocal HeckeSignal ProbePhysical Continuation +open ActualEisensteinCubic CompletedGauss + +def residueWeights {κ : Type*} (W : κ → ℝ → ℝ) (scale : κ → ℝ) + (j : κ) (p : PrimeIdeal) : ℝ := + W j ((Ideal.absNorm p.val : ℝ)/scale j) * (Ideal.absNorm p.val : ℝ)^(-(5/6 : ℝ)) + +theorem actual_window_residue {κ : Type*} (η : Character) (S : Finset κ) + (T : κ → Finset PrimeIdeal) (W : κ → ℝ → ℝ) (scale : κ → ℝ) (s : ℂ) : + windowMultiplier η S T (fun j t => (W j t : ℂ)) scale s 1 (1/6) = + slotProduct S T (residueWeights W scale) (fun _ p => Ideal.absNorm p.val) + (fun _ p => actualAPhase η (primaryGenerator p.val)) + (fun _ p => idealCoeff η p.val) s := by + exact window_at_residue η S T W scale s + +theorem normalized_actual_window_residue {κ : Type*} + (E : Finset (Ideal HeckeFamily.O)) (hE : SourceExclusions E) (η : Character) + {a : ℝ} (ha : 7/8 (W j t : ℂ)) scale + let normer := sourceResidueConstant W0 W1 (∏p∈E,p) * + (Probe.principalScalar S Z (1/6) (slotMass T (residueWeights W scale)) : ℂ) + normer≠0 ∧ + Integrable (fun t : ℝ => fixedPrincipalResidue (∏p∈E,p)^2/6 * + sourceMultiplier W0 W1 (Z^(17/48 : ℝ)) Y Z (η.excludePrimes E hE.prime) + ((a : ℂ)+t*I) (globalClosedCorrection η E ((a : ℂ)+t*I)) + (B ((a : ℂ)+t*I)) 1 (1/6)) ∧ + ‖sourceResidueIntegral W0 W1 (∏p∈E,p) (η.excludePrimes E hE.prime) + a (Z^(17/48 : ℝ)) Y Z (globalClosedCorrection η E) B / normer - + signal (η.excludePrimes E hE.prime) (sourceCorrection η E) (-11/16) Z‖ ≤ + D*Z^(a-11/16)*P^(-(7/8 : ℝ)) := by + dsimp only + let : NeZero (∏p∈E,p) := ⟨fixedPrimeProduct_ne_zero E hE.prime⟩ + obtain ⟨D,hD,hbound⟩ := exists_normalized_actual_source_bound E hE η ha ha2 hβ S + refine ⟨D,hD,?_⟩ + intro W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 hr0 hr1 hp0 hp1 hn0 hn1 + T W scale P Y Z hP hsmall hW hnorm hcop hmass hZ + refine hbound W0 W1 T (residueWeights W scale) P Y Z + (windowMultiplier η S T (fun j t => (W j t : ℂ)) scale) + hP hsmall ?_ hnorm hcop hmass hZ ?_ ?_ + · intro j hj p hp + exact mul_nonneg (hW j hj p hp) (Real.rpow_nonneg (by positivity) _) + · exact ProbePrincipalNormalizer.sourceResidueConstant_ne_zero (∏p∈E,p) + W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 hr0 hr1 hp0 hp1 hn0 hn1 + · intro t + exact actual_window_residue η S T W scale _ + +end SevenEighths.ProbePrincipalResidueActual +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalSplit.lean b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalSplit.lean new file mode 100644 index 0000000000000000000000000000000000000000..39a7b9d64fc841e7fc3e48d41a1086e6a00b41cb --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/PrincipalSplit.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Detector.CompensatedRows + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary HeckeInverseAmplification +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : MeasurableSpace FreeRow := ⊤ +local instance : MeasurableSingletonClass FreeRow := ⟨fun _=>trivial⟩ + +def principalFreeRow : FreeRow := ⟨1,one_ne_zero,by + intro P + simp [Ideal.span_singleton_one,←Ideal.one_eq_top]⟩ + +def rowIntegral {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) + (p : Fin K→O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (u : FreeRow) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3* + ∫t,compensatedRowOnLines η S C p W0 W1 X Y Z ⟨u.val,u.property.1⟩ t ∂heightMeasure + +def principalRowIntegral {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (p : Fin K→O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3*∫t : HeightSpace, + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + (∏i,(elementNorm (p i):ℂ)^(((2:ℂ)+t.1.2*Complex.I)-1))* + indexedCompensatedHigh η S p 1 ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) ∂heightMeasure + +lemma rowIntegral_principal {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) + (p : Fin K→O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : + rowIntegral η S C p W0 W1 X Y Z principalFreeRow=principalRowIntegral η S p W0 W1 X Y Z := by + simp only [rowIntegral,principalRowIntegral,compensatedRowOnLines,principalFreeRow, + frequencyWeight,elementNorm_one,map_one,star_one,Complex.ofReal_one,Complex.one_cpow,one_mul] + +lemma rowIntegral_summable {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) (C : CalibrationData) + (p : Fin K→O) (hp : ∀i,p i≠0) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0⟨u.val,u.property.1⟩ + have he : Function.Injective e := fun a b h=>Subtype.ext (congrArg (fun v : NonzeroFrequency=>v.val) h) + have hi := (compensatedRows_counting_product_integrable e he η S C p hp W0 W1 + a0 b0 a1 b1 ha0 ha1 hW0 hW1 X Y Z hX hY hZ).integral_prod_left + rw [integrable_count_iff] at hi + exact hi.of_norm.mul_left _ + +theorem compensatedRowTripleIntegral_principal_split {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (C : CalibrationData) (p : Fin K→O) (hp : ∀i,p i≠0) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 Ideal ActualEisensteinCubic.O + +lemma gaussianMoment_tendsto (n : ℕ) : Tendsto (gaussianMoment n) atTop (𝓝 0) := by + have hb (t : ℝ) : gaussianMoment n t ≤ (2:ℝ)^(n-1)*Continuation.polynomialGaussian n t := by + have h := add_pow_le (by norm_num : (0:ℝ)≤1) (abs_nonneg t) n + unfold gaussianMoment height Continuation.polynomialGaussian + calc + _ ≤ ((2:ℝ)^(n-1)*(1^n+|t|^n))*Real.exp (-(t^2)) := + mul_le_mul_of_nonneg_right h (Real.exp_pos _).le + _ = _ := by simp only [one_pow]; ring + exact squeeze_zero (gaussianMoment_nonneg n) hb + (by simpa using (Continuation.polynomialGaussian_tendsto n).const_mul ((2:ℝ)^(n-1))) + +lemma gaussianMoment_even (n : ℕ) (t : ℝ) : gaussianMoment n (-t)=gaussianMoment n t := by + simp [gaussianMoment,height] + +lemma gaussianMoment_tendsto_bot (n : ℕ) : Tendsto (gaussianMoment n) atBot (𝓝 0) := by + have h := (gaussianMoment_tendsto n).comp tendsto_neg_atBot_atTop + simpa only [Function.comp_def,gaussianMoment_even] using h + +lemma shifted_gaussian_integrable (n : ℕ) (v : ℝ) : + Integrable (fun t : ℝ => gaussianMoment n (t+v)) := by + exact (measurePreserving_add_right volume v).integrable_comp_of_integrable (gaussianMoment_integrable n) + +lemma shifted_gaussian_top (n : ℕ) (v : ℝ) : + Tendsto (fun t : ℝ => gaussianMoment n (t+v)) atTop (𝓝 0) := + (gaussianMoment_tendsto n).comp (tendsto_atTop_add_const_right _ v tendsto_id) + +lemma shifted_gaussian_bottom (n : ℕ) (v : ℝ) : + Tendsto (fun t : ℝ => gaussianMoment n (-t+v)) atTop (𝓝 0) := +by + convert shifted_gaussian_top n (-v) using 1 + funext t + rw [←gaussianMoment_even n (t + -v)] + congr 1 + ring + +theorem verticalIntegral_eq_of_shifted_gaussian (F : ℂ → ℂ) {a c A : ℝ} + (n : ℕ) (v : ℝ) (hac : a≤c) + (hF : DifferentiableOn ℂ F {s : ℂ | a≤s.re ∧ s.re≤c}) + (hb : ∀σ∈Icc a c,∀t : ℝ,‖F ((σ:ℂ)+t*I)‖≤A*gaussianMoment n (t+v)) : + verticalIntegral a F=verticalIntegral c F := by + have hc (σ : ℝ) (hσ : σ∈Icc a c) : Continuous (fun t : ℝ => F ((σ:ℂ)+t*I)) := + hF.continuousOn.comp_continuous (by fun_prop) (by intro t; simpa using hσ) + have hi (σ : ℝ) (hσ : σ∈Icc a c) : Integrable (fun t : ℝ => F ((σ:ℂ)+t*I)) := + ((shifted_gaussian_integrable n v).const_mul A).mono' (hc σ hσ).aestronglyMeasurable + (Eventually.of_forall (hb σ hσ)) + have hj (T : ℝ) : ‖∫σ : ℝ in a..c,F ((σ:ℂ)+T*I)‖≤A*gaussianMoment n (T+v)*|c-a| := by + apply intervalIntegral.norm_integral_le_of_norm_le_const + intro σ hσ + exact hb σ (by simpa [uIcc_of_le hac] using uIoc_subset_uIcc hσ) T + have ht : Tendsto (fun T : ℝ => ∫σ : ℝ in a..c,F ((σ:ℂ)+T*I)) atTop (𝓝 0) := by + apply tendsto_zero_iff_norm_tendsto_zero.mpr + exact squeeze_zero (fun _ => norm_nonneg _) hj + (by simpa using ((shifted_gaussian_top n v).const_mul A).mul_const |c-a|) + have hbot : Tendsto (fun T : ℝ => ∫σ : ℝ in a..c,F ((σ:ℂ)+(-T)*I)) atTop (𝓝 0) := by + apply tendsto_zero_iff_norm_tendsto_zero.mpr + exact squeeze_zero (fun _ => norm_nonneg _) (fun T => by simpa only [Complex.ofReal_neg] using hj (-T)) + (by simpa using ((shifted_gaussian_bottom n v).const_mul A).mul_const |c-a|) + unfold verticalIntegral + congr 1 + exact Continuation.vertical_integral_eq_of_horizontal_vanish F hac hF + (hi a ⟨le_rfl,hac⟩) (hi c ⟨hac,le_rfl⟩) hbot ht + +theorem principal_box_majorant {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + s ((3:ℂ)+u*I) ((ξ:ℂ)+v*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+v*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+u*I)) = + verticalIntegral 3 (fun s => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + s ((3:ℂ)+u*I) ((ξ:ℂ)+v*I)*LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+v*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+u*I)) := by + obtain ⟨A,hA,hb⟩ := principal_box_majorant η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hY hZ ha.le hβ hξ + have hh := continued_source_differentiable_strip η S hS J T b hT W0 W1 X Y Z hZ + ((3:ℂ)+u*I) ((ξ:ℂ)+v*I) (by norm_num) (by simpa using (show (4/25:ℝ)≤ξ by linarith)) ha hβ + (c:=3) + apply verticalIntegral_eq_of_shifted_gaussian _ 8 v ha3 + ((hh.mul_const _).mul_const _) (A:=A*cauchy v*cauchy u) + intro σ hσ t + have h := hb σ hσ ξ ⟨le_rfl,hξ2⟩ ((t,v),u) + simpa only [jointEnvelope,Prod.fst,Prod.snd,mul_assoc,mul_left_comm,mul_comm] using h + +lemma continued_source_differentiable_z {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (hX : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z) + {z : ℂ | 4/25 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z)= + (fun z => ((Y:ℂ)^(w-1)*mellin W1 w*HeckeReciprocal.reciprocal (η.excludePrimes S hS.prime) s)* + (X:ℂ)^(1/2-z)*(Z:ℂ)^(s+z-1)*Complex.exp ((s+z-1)^2)* + mellin (EisensteinSchwartzPoisson.paperRadialFourier W0) z* + (globalClosedCorrection η S s w z*slotMultiplier η J T b s w z)) := by + funext z; unfold continuedSourceMultiplier; ring + rw [he] + fun_prop (disch := first | assumption | exact Or.inl hnX | exact Or.inl hnZ) + +lemma continued_principal_differentiable_z {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (hX : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z* + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w) + {z : ℂ | 1/6 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((a:ℂ)+t*I) ((3:ℂ)+u*I) z*LFunction (fixedSourcePrincipal S hS.prime) (6*z)* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+u*I)) = + verticalIntegral 2 (fun z => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((a:ℂ)+t*I) ((3:ℂ)+u*I) z*LFunction (fixedSourcePrincipal S hS.prime) (6*z)* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+u*I)) := by + obtain ⟨A,hA,hb⟩ := principal_box_majorant η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hY hZ ha hβ hξ + have hh := continued_principal_differentiable_z η S hS J T b hT W0 W1 X Y Z hX hZ + ((a:ℂ)+t*I) ((3:ℂ)+u*I) (by simpa using ha) (by norm_num) + apply verticalIntegral_eq_of_shifted_gaussian _ 8 t hξ2 + (hh.mono (by intro z hz; change (1/6:ℝ) F ((a:ℂ)+q.1*I) ((b:ℂ)+q.2*I)) (volume.prod volume)) : + verticalIntegral a (fun z => verticalIntegral b (F z))= + verticalIntegral b (fun w => verticalIntegral a (fun z => F z w)) := by + simp only [verticalIntegral,integral_const_mul] + congr 2 + exact integral_integral_swap (f:=fun t u : ℝ => F ((a:ℂ)+t*I) ((b:ℂ)+u*I)) hi + +lemma verticalIntegral_triple_reverse (F : ℂ → ℂ → ℂ → ℂ) (a ξ υ : ℝ) + (hi : Integrable (fun p : HeightSpace => F ((a:ℂ)+p.1.1*I) ((υ:ℂ)+p.2*I) + ((ξ:ℂ)+p.1.2*I)) heightMeasure) : + verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral υ (fun w => F s w z)))= + verticalIntegral υ (fun w => verticalIntegral ξ (fun z => verticalIntegral a (fun s => F s w z))) := by + have h1 := integral_prod _ hi + have h2 := integral_prod _ hi.integral_prod_left + have h3 := integral_prod_symm _ hi + have h4 : (∫u : ℝ,∫q : ℝ×ℝ,F ((a:ℂ)+q.1*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+q.2*I) ∂volume.prod volume)= + ∫u : ℝ,∫v : ℝ,∫t : ℝ,F ((a:ℂ)+t*I) ((υ:ℂ)+u*I) ((ξ:ℂ)+v*I) := by + apply integral_congr_ae + filter_upwards [hi.prod_left_ae] with u hu + exact integral_prod_symm _ hu + have he := h2.symm.trans (h1.symm.trans (h3.trans h4)) + simp only [verticalIntegral,integral_const_mul] + congr 3 + +lemma verticalIntegral_congr_line (F G : ℂ → ℂ) (a : ℝ) + (h : ∀t : ℝ,F ((a:ℂ)+t*I)=G ((a:ℂ)+t*I)) : verticalIntegral a F=verticalIntegral a G := by + unfold verticalIntegral + congr 1 + exact integral_congr_ae (Eventually.of_forall h) + +theorem continued_triple_x_shift {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z* + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w + verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral 3 (fun w => F s w z)))= + verticalIntegral 3 (fun s => verticalIntegral ξ (fun z => verticalIntegral 3 (fun w => F s w z))) := by + let F := fun s w z => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z* + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w + have hiA := continued_source_joint_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ 3 3 hX hY hZ ha.le hβ (by linarith) (by norm_num) (by norm_num) (by linarith) (by norm_num) + have hi3 := continued_source_joint_integrable η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z 3 ξ 3 3 hX hY hZ (by norm_num) (hβ.trans_le ha3) (by linarith) + (by norm_num) (by norm_num) (by linarith) (by norm_num) + change verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral 3 (fun w => F s w z)))=_ + rw [verticalIntegral_triple_reverse F a ξ 3 hiA,verticalIntegral_triple_reverse F 3 ξ 3 hi3] + apply verticalIntegral_congr_line + intro u + apply verticalIntegral_congr_line + intro v + exact continued_x_shift η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hY hZ ha ha3 hβ hξ hξ2 v u + +theorem continued_triple_z_shift {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z* + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w + verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral 3 (fun w => F s w z)))= + verticalIntegral a (fun s => verticalIntegral 2 (fun z => verticalIntegral 3 (fun w => F s w z))) := by + let F := fun s w z => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z s w z* + LFunction (fixedSourcePrincipal S hS.prime) (6*z)*LFunction (fixedSourcePrincipal S hS.prime) w + obtain ⟨Cξ,Kξ,hCξ,hKξ,hξi⟩ := continued_source_slices η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ 3 3 hX hY hZ ha hβ (by linarith) (by norm_num) (by norm_num) (by linarith) (by norm_num) 0 + obtain ⟨C2,K2,hC2,hK2,h2i⟩ := continued_source_slices η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a 2 3 3 hX hY hZ ha hβ (by norm_num) (by norm_num) (by norm_num) (by norm_num) (by norm_num) 0 + change verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral 3 (fun w => F s w z)))=_ + apply verticalIntegral_congr_line + intro t + have hiξ := (hξi .s t).1 + have hi2 := (h2i .s t).1 + rw [verticalIntegral_swap (fun z w => F ((a:ℂ)+t*I) w z) ξ 3 hiξ, + verticalIntegral_swap (fun z w => F ((a:ℂ)+t*I) w z) 2 3 hi2] + apply verticalIntegral_congr_line + intro u + exact continued_z_shift η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a ξ hX hY hZ ha ha3 hβ hξ hξ2 t u + +lemma continued_triple_eq_raw {ι : Type*} (η : Character) (S : Finset Id) + (hS : ∀P∈S,Prime P) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z a ξ υ : ℝ) : + verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral υ (fun w => + continuedSourceMultiplier η S hS J T b W0 W1 X Y Z s w z* + LFunction (fixedSourcePrincipal S hS) (6*z)*LFunction (fixedSourcePrincipal S hS) w)))= + verticalIntegral a (fun s => verticalIntegral ξ (fun z => verticalIntegral υ (fun w => + sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) w z* + LFunction (fixedSourcePrincipal S hS) (6*z)*LFunction (fixedSourcePrincipal S hS) w))) := by + unfold verticalIntegral + congr 1 + apply integral_congr_ae + filter_upwards [Measure.ae_ne volume (0:ℝ)] with t ht + have h0 : (a:ℂ)+t*I≠0 := by intro h; exact ht (by simpa using congrArg Complex.im h) + have h1 : (a:ℂ)+t*I≠1 := by intro h; exact ht (by simpa using congrArg Complex.im h) + simp_rw [continued_source_eq_raw η S hS J T b W0 W1 X Y Z _ _ _ h0 h1] + +theorem source_initial_placement {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + verticalIntegral 3 (fun s => verticalIntegral 2 (fun z => verticalIntegral 3 + (fun w => K s w z*LFunction π (6*z)*LFunction π w)))= + verticalIntegral a (fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral 3 + (fun w => K s w z*LFunction π (6*z)*LFunction π w))) := by + dsimp only + rw [←continued_triple_eq_raw η S hS.prime J T b W0 W1 X Y Z 3 2 3, + ←continued_triple_eq_raw η S hS.prime J T b W0 W1 X Y Z a (1/6+e) 3] + have hx := continued_triple_x_shift η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a 2 hX hY hZ ha ha3 hβ (by norm_num) le_rfl + have hz := continued_triple_z_shift η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a (1/6+e) hX hY hZ ha.le ha3 hβ (by linarith) (by linarith) + exact hx.symm.trans hz.symm + +theorem source_initial_ordered_at_a {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + let R := HeckeReciprocal.regularizedL π 1 + verticalIntegral 3 (fun s => verticalIntegral 2 (fun z => verticalIntegral 3 + (fun w => K s w z*LFunction π (6*z)*LFunction π w)))= + verticalIntegral a (fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => K s w z*LFunction π (6*z)*LFunction π w)))+ + R*verticalIntegral a (fun s => verticalIntegral (33/200) (fun z => K s 1 z*LFunction π (6*z)))+ + R^2/6*verticalIntegral a (fun s => K s 1 (1/6)) := by + exact (source_initial_placement η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a e hX hY hZ ha ha3 hβ he he2).trans + (source_ordered_outer η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a e 3 hX hY hZ ha.le hβ (by norm_num) he) + +lemma continued_principal_measurable (η : Character) (S : Finset Id) (hS : ∀P∈S,Prime P) + {ι : Type*} (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (W0 W1 : SchwartzMap ℝ ℂ) (a1 b1 : ℝ) (ha1 : 0 continuedSourceMultiplier η S hS J T b W0 W1 X Y Z (x p) (w p) (z p)* + LFunction (fixedSourcePrincipal S hS) (6*z p)*LFunction (fixedSourcePrincipal S hS) (w p)) := by + have hH := global_correction_measurable η S x w z hx.measurable hw.measurable hz.measurable + have hB := slot_multiplier_measurable η J T b x w z hx.measurable hw.measurable hz.measurable + have hR : Continuous (fun p => HeckeReciprocal.reciprocal (η.excludePrimes S hS) (x p)) := by + apply continuous_iff_continuousAt.mpr + intro p + exact (HeckeReciprocal.reciprocal_differentiableAt _ (hβ p)).continuousAt.comp hx.continuousAt + have hM0 : Continuous (fun p => mellin (EisensteinSchwartzPoisson.paperRadialFourier W0) (z p)) := by + apply continuous_iff_continuousAt.mpr + intro p + exact (ProbeRadialMellin.radial_mellin_analytic W0 _ (hz0 p)).continuousAt.comp hz.continuousAt + have hM1 := (CubicReflectionKernel.compact_source_mellin_differentiable W1 a1 b1 ha1 hW1 + (W1.smooth ⊤)).continuous.comp hw + have hL6 := (LFunction_measurable (fixedSourcePrincipal S hS)).comp + (by fun_prop : Measurable (fun p => 6*z p)) + have hLw := (LFunction_measurable (fixedSourcePrincipal S hS)).comp hw.measurable + have hm0 := hM0.measurable + have hm1 := hM1.measurable + have hmr := hR.measurable + have hmx := hx.measurable + have hmw := hw.measurable + have hmz := hz.measurable + unfold continuedSourceMultiplier + fun_prop (disch := aesop) + +lemma strip_integrable_of_uniform_slices (F : ℝ×(ℝ×ℝ) → ℂ) (l r D : ℝ) + (hlr : l≤r) (hm : AEStronglyMeasurable F ((volume.restrict (Icc l r)).prod (volume.prod volume))) + (hs : ∀σ∈Icc l r,Integrable (fun q => F (σ,q)) (volume.prod volume)) + (hb : ∀σ∈Icc l r,(∫q : ℝ×ℝ,‖F (σ,q)‖ ∂volume.prod volume)≤D) : + Integrable F ((volume.restrict (Icc l r)).prod (volume.prod volume)) ∧ + (∫p : ℝ×(ℝ×ℝ),‖F p‖ ∂(volume.restrict (Icc l r)).prod (volume.prod volume))≤(r-l)*D := by + have hm' := hm.norm.integral_prod_right' + have hb' : ∀ᵐσ : ℝ ∂volume.restrict (Icc l r), + ‖∫q : ℝ×ℝ,‖F (σ,q)‖ ∂volume.prod volume‖≤D := by + filter_upwards [ae_restrict_mem measurableSet_Icc] with σ hσ + rw [Real.norm_eq_abs,abs_of_nonneg (integral_nonneg (fun _ => norm_nonneg _))] + exact hb σ hσ + have hi' : Integrable (fun σ : ℝ => ∫q : ℝ×ℝ,‖F (σ,q)‖ ∂volume.prod volume) + (volume.restrict (Icc l r)) := + (integrableOn_const (s:=Icc l r) (C:=D) (hs:=by simp [Real.volume_Icc])).mono' hm' hb' + have hi : Integrable F ((volume.restrict (Icc l r)).prod (volume.prod volume)) := by + apply (integrable_prod_iff hm).mpr + refine ⟨?_,hi'⟩ + filter_upwards [ae_restrict_mem measurableSet_Icc] with σ hσ + exact hs σ hσ + refine ⟨hi,?_⟩ + rw [integral_prod _ hi.norm] + calc + _ ≤ ∫σ : ℝ in Icc l r,D := integral_mono_ae hi' (integrableOn_const (hs:=by simp [Real.volume_Icc])) (by + filter_upwards [ae_restrict_mem measurableSet_Icc] with σ hσ + exact hb σ hσ) + _ = _ := by simp [sub_nonneg.mpr hlr,mul_comm] + +theorem uniform_high_x_joins {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((p.1:ℂ)+R*I) ((3:ℂ)+p.2.2*I) ((ξ:ℂ)+p.2.1*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.2.1*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+p.2.2*I) + Integrable F ((volume.restrict (Icc a 3)).prod (volume.prod volume)) ∧ + (∫p : ℝ×(ℝ×ℝ),‖F p‖ ∂(volume.restrict (Icc a 3)).prod (volume.prod volume))≤ + (3-a)*(arithmeticAmplitude S J T b X Y Z a 3 2 3 C 2 |6*ξ-1| *K/height R^N) := by + obtain ⟨K,hK,hk⟩ := source_uniform_high_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a 3 2 3 ha hβ (by norm_num) N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hY hZ + obtain ⟨C,hC,hc⟩ := hk η S hS J T b hT X Y Z hX hY hZ + refine ⟨C,hC,?_⟩ + intro ξ hξ R hR + dsimp only + let F := fun p : ℝ×(ℝ×ℝ) => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((p.1:ℂ)+R*I) ((3:ℂ)+p.2.2*I) ((ξ:ℂ)+p.2.1*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.2.1*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+p.2.2*I) + have hcut := continued_principal_measurable η S hS.prime J T b W0 W1 a1 b1 ha1 hW1 X Y Z hX hY hZ + (fun p : ℝ×(ℝ×ℝ) => ((max a p.1:ℝ):ℂ)+R*I) + (fun p : ℝ×(ℝ×ℝ) => (3:ℂ)+p.2.2*I) + (fun p : ℝ×(ℝ×ℝ) => (ξ:ℂ)+p.2.1*I) (by fun_prop) (by fun_prop) (by fun_prop) + (by intro p; simpa using hβ.trans_le (le_max_left a p.1)) + (by intro p; simpa using (show (0:ℝ)<ξ by linarith [hξ.1])) + have hm : AEStronglyMeasurable F ((volume.restrict (Icc a 3)).prod (volume.prod volume)) := by + apply hcut.aestronglyMeasurable.congr + have hh : ∀ᵐp : ℝ×(ℝ×ℝ) ∂(volume.restrict (Icc a 3)).prod (volume.prod volume),p.1∈Icc a 3 := + Measure.quasiMeasurePreserving_fst.ae (ae_restrict_mem measurableSet_Icc) + filter_upwards [hh] with p hp + dsimp [F] + rw [max_eq_right hp.1] + have hh (σ : ℝ) (hσ : σ∈Icc a 3) := hc σ hσ ξ ⟨by linarith [hξ.1],hξ.2⟩ + 3 (by norm_num) .s (by intro _; norm_num) (by intro _; linarith [hξ.1]) R hR + have hs (σ : ℝ) (hσ : σ∈Icc a 3) : Integrable (fun q => F (σ,q)) (volume.prod volume) := by + simpa only [F,sliceMap,ofReal_ofNat] using (hh σ hσ).1 + have hb (σ : ℝ) (hσ : σ∈Icc a 3) : (∫q : ℝ×ℝ,‖F (σ,q)‖ ∂volume.prod volume)≤ + arithmeticAmplitude S J T b X Y Z a 3 2 3 C 2 |6*ξ-1| *K/height R^N := by + have ht := (hh σ hσ).2 + norm_num [joinWGap,joinZGap,sliceMap] at ht + simpa only [F,norm_mul] using ht + exact strip_integrable_of_uniform_slices F a 3 _ ha3 hm hs hb + +theorem uniform_high_z_joins {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((a:ℂ)+p.2.1*I) ((3:ℂ)+p.2.2*I) ((p.1:ℂ)+R*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((p.1:ℂ)+R*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+p.2.2*I) + Integrable F ((volume.restrict (Icc ξlo 2)).prod (volume.prod volume)) ∧ + (∫p : ℝ×(ℝ×ℝ),‖F p‖ ∂(volume.restrict (Icc ξlo 2)).prod (volume.prod volume))≤ + (2-ξlo)*(arithmeticAmplitude S J T b X Y Z a 3 2 3 C 2 6*K/height R^N) := by + obtain ⟨K,hK,hk⟩ := source_uniform_high_slices W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a 3 2 3 ha hβ (by norm_num) N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hY hZ + obtain ⟨C,hC,hc⟩ := hk η S hS J T b hT X Y Z hX hY hZ + refine ⟨C,hC,?_⟩ + intro R hR + dsimp only + let F := fun p : ℝ×(ℝ×ℝ) => continuedSourceMultiplier η S hS.prime J T b W0 W1 X Y Z + ((a:ℂ)+p.2.1*I) ((3:ℂ)+p.2.2*I) ((p.1:ℂ)+R*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((p.1:ℂ)+R*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+p.2.2*I) + have hcut := continued_principal_measurable η S hS.prime J T b W0 W1 a1 b1 ha1 hW1 X Y Z hX hY hZ + (fun p : ℝ×(ℝ×ℝ) => (a:ℂ)+p.2.1*I) + (fun p : ℝ×(ℝ×ℝ) => (3:ℂ)+p.2.2*I) + (fun p : ℝ×(ℝ×ℝ) => ((max ξlo p.1:ℝ):ℂ)+R*I) (by fun_prop) (by fun_prop) (by fun_prop) + (by intro p; simpa using hβ) + (by intro p; simpa using (show (0:ℝ) F (ξ,q)) (volume.prod volume) := by + simpa only [F,sliceMap,ofReal_ofNat] using (hh ξ hξ).1 + have hb (ξ : ℝ) (hξ : ξ∈Icc ξlo 2) : (∫q : ℝ×ℝ,‖F (ξ,q)‖ ∂volume.prod volume)≤ + arithmeticAmplitude S J T b X Y Z a 3 2 3 C 2 6*K/height R^N := by + have ht := (hh ξ hξ).2 + norm_num [joinWGap,joinZGap,sliceMap] at ht + simpa only [F,norm_mul] using ht + exact strip_integrable_of_uniform_slices F ξlo 2 _ hξ2 hm hs hb + +lemma high_x_join_ae_raw {ι : Type*} (η : Character) (S : Finset Id) (hS : ∀P∈S,Prime P) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z a ξ R : ℝ) (hR : R≠0) : + (fun p : ℝ×(ℝ×ℝ) => continuedSourceMultiplier η S hS J T b W0 W1 X Y Z + ((p.1:ℂ)+R*I) ((3:ℂ)+p.2.2*I) ((ξ:ℂ)+p.2.1*I)* + LFunction (fixedSourcePrincipal S hS) (6*((ξ:ℂ)+p.2.1*I))* + LFunction (fixedSourcePrincipal S hS) ((3:ℂ)+p.2.2*I)) + =ᵐ[(volume.restrict (Icc a 3)).prod (volume.prod volume)] + (fun p : ℝ×(ℝ×ℝ) => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS) ((p.1:ℂ)+R*I) + (globalClosedCorrection η S ((p.1:ℂ)+R*I)) (slotMultiplier η J T b ((p.1:ℂ)+R*I)) + ((3:ℂ)+p.2.2*I) ((ξ:ℂ)+p.2.1*I)* + LFunction (fixedSourcePrincipal S hS) (6*((ξ:ℂ)+p.2.1*I))* + LFunction (fixedSourcePrincipal S hS) ((3:ℂ)+p.2.2*I)) := by + apply Eventually.of_forall + intro p + have h0 : (p.1:ℂ)+R*I≠0 := by intro h; exact hR (by simpa using congrArg Complex.im h) + have h1 : (p.1:ℂ)+R*I≠1 := by intro h; exact hR (by simpa using congrArg Complex.im h) + dsimp only + rw [continued_source_eq_raw η S hS J T b W0 W1 X Y Z _ _ _ h0 h1] + +lemma high_z_join_ae_raw {ι : Type*} (η : Character) (S : Finset Id) (hS : ∀P∈S,Prime P) + (J : Finset ι) (T : ι → Finset PrimeIdeal) (b : ι → PrimeIdeal → ℂ) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z a ξlo R : ℝ) : + (fun p : ℝ×(ℝ×ℝ) => continuedSourceMultiplier η S hS J T b W0 W1 X Y Z + ((a:ℂ)+p.2.1*I) ((3:ℂ)+p.2.2*I) ((p.1:ℂ)+R*I)* + LFunction (fixedSourcePrincipal S hS) (6*((p.1:ℂ)+R*I))* + LFunction (fixedSourcePrincipal S hS) ((3:ℂ)+p.2.2*I)) + =ᵐ[(volume.restrict (Icc ξlo 2)).prod (volume.prod volume)] + (fun p : ℝ×(ℝ×ℝ) => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS) ((a:ℂ)+p.2.1*I) + (globalClosedCorrection η S ((a:ℂ)+p.2.1*I)) (slotMultiplier η J T b ((a:ℂ)+p.2.1*I)) + ((3:ℂ)+p.2.2*I) ((p.1:ℂ)+R*I)* + LFunction (fixedSourcePrincipal S hS) (6*((p.1:ℂ)+R*I))* + LFunction (fixedSourcePrincipal S hS) ((3:ℂ)+p.2.2*I)) := by + have hh : ∀ᵐp : ℝ×(ℝ×ℝ) ∂(volume.restrict (Icc ξlo 2)).prod (volume.prod volume),p.2.1≠0 := + Measure.quasiMeasurePreserving_snd.ae + (Measure.quasiMeasurePreserving_fst.ae (Measure.ae_ne volume (0:ℝ))) + filter_upwards [hh] with p hp + have h0 : (a:ℂ)+p.2.1*I≠0 := by intro h; exact hp (by simpa using congrArg Complex.im h) + have h1 : (a:ℂ)+p.2.1*I≠1 := by intro h; exact hp (by simpa using congrArg Complex.im h) + rw [continued_source_eq_raw η S hS J T b W0 W1 X Y Z _ _ _ h0 h1] + +theorem raw_uniform_high_x_joins {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((p.1:ℂ)+R*I) + (globalClosedCorrection η S ((p.1:ℂ)+R*I)) (slotMultiplier η J T b ((p.1:ℂ)+R*I)) ((3:ℂ)+p.2.2*I) ((ξ:ℂ)+p.2.1*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((ξ:ℂ)+p.2.1*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+p.2.2*I) + Integrable F ((volume.restrict (Icc a 3)).prod (volume.prod volume)) ∧ + (∫p : ℝ×(ℝ×ℝ),‖F p‖ ∂(volume.restrict (Icc a 3)).prod (volume.prod volume))≤ + (3-a)*(arithmeticAmplitude S J T b X Y Z a 3 2 3 C 2 |6*ξ-1| *K/height R^N) := by + obtain ⟨K,hK,hk⟩ := uniform_high_x_joins W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a ξlo ha ha3 hβ hξlo N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hY hZ + obtain ⟨C,hC,hc⟩ := hk η S hS J T b hT X Y Z hX hY hZ + refine ⟨C,hC,?_⟩ + intro ξ hξ R hR + have hh := hc ξ hξ R hR + have heq := high_x_join_ae_raw η S hS.prime J T b W0 W1 X Y Z a ξ R + (by intro h; norm_num [h] at hR) + exact ⟨hh.1.congr heq,(integral_congr_ae (heq.fun_comp norm)).symm.trans_le hh.2⟩ + +theorem raw_uniform_high_z_joins {ι : Type*} + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) ((a:ℂ)+p.2.1*I) + (globalClosedCorrection η S ((a:ℂ)+p.2.1*I)) (slotMultiplier η J T b ((a:ℂ)+p.2.1*I)) ((3:ℂ)+p.2.2*I) ((p.1:ℂ)+R*I)* + LFunction (fixedSourcePrincipal S hS.prime) (6*((p.1:ℂ)+R*I))* + LFunction (fixedSourcePrincipal S hS.prime) ((3:ℂ)+p.2.2*I) + Integrable F ((volume.restrict (Icc ξlo 2)).prod (volume.prod volume)) ∧ + (∫p : ℝ×(ℝ×ℝ),‖F p‖ ∂(volume.restrict (Icc ξlo 2)).prod (volume.prod volume))≤ + (2-ξlo)*(arithmeticAmplitude S J T b X Y Z a 3 2 3 C 2 6*K/height R^N) := by + obtain ⟨K,hK,hk⟩ := uniform_high_z_joins W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + a ξlo ha ha3 hβ hξlo hξ2 N + refine ⟨K,hK,?_⟩ + intro η S hS J T b hT X Y Z hX hY hZ + obtain ⟨C,hC,hc⟩ := hk η S hS J T b hT X Y Z hX hY hZ + refine ⟨C,hC,?_⟩ + intro R hR + have hh := hc R hR + have heq := high_z_join_ae_raw η S hS.prime J T b W0 W1 X Y Z a ξlo R + exact ⟨hh.1.congr heq,(integral_congr_ae (heq.fun_comp norm)).symm.trans_le hh.2⟩ + +theorem source_initial_joint_ordered_at_a {ι : Type*} (η : Character) (S : Finset Id) + (hS : SourceExclusions S) (J : Finset ι) (T : ι → Finset PrimeIdeal) + (b : ι → PrimeIdeal → ℂ) (hT : ∀j∈J,∀P∈T j,P.val∉S) + (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) (ha0 : 0 sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + let R := HeckeReciprocal.regularizedL π 1 + (((1/(2*Real.pi):ℝ):ℂ)^3)*(∫p : HeightSpace, + K ((3:ℂ)+p.1.1*I) ((3:ℂ)+p.2*I) ((2:ℂ)+p.1.2*I)* + LFunction π (6*((2:ℂ)+p.1.2*I))*LFunction π ((3:ℂ)+p.2*I) ∂heightMeasure)= + verticalIntegral a (fun s => verticalIntegral (1/6+e) (fun z => verticalIntegral (19/20) + (fun w => K s w z*LFunction π (6*z)*LFunction π w)))+ + R*verticalIntegral a (fun s => verticalIntegral (33/200) (fun z => K s 1 z*LFunction π (6*z)))+ + R^2/6*verticalIntegral a (fun s => K s 1 (1/6)) := by + let K := fun s => sourceMultiplier W0 W1 X Y Z (η.excludePrimes S hS.prime) s + (globalClosedCorrection η S s) (slotMultiplier η J T b s) + let π := fixedSourcePrincipal S hS.prime + have hh := source_initial_ordered_at_a η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z a e hX hY hZ ha ha3 hβ he he2 + have hf := (source_joint_fubini η S hS J T b hT W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z 3 2 3 3 hX hY hZ (by norm_num) (hβ.trans_le ha3) (by norm_num) + (by norm_num) (by norm_num) (by norm_num) (by norm_num)).1 + have hi : (((1/(2*Real.pi):ℝ):ℂ)^3)*(∫p : HeightSpace, + K ((3:ℂ)+p.1.1*I) ((3:ℂ)+p.2*I) ((2:ℂ)+p.1.2*I)* + LFunction π (6*((2:ℂ)+p.1.2*I))*LFunction π ((3:ℂ)+p.2*I) ∂heightMeasure)= + verticalIntegral 3 (fun s => verticalIntegral 2 (fun z => verticalIntegral 3 + (fun w => K s w z*LFunction π (6*z)*LFunction π w))) := by + dsimp [K,π] + simp only [ofReal_ofNat] at hf + rw [hf] + simp only [verticalIntegral,integral_const_mul,ofReal_ofNat] + ring + exact hi.trans hh + +end SevenEighths.ProbePrincipalTransport +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RadialExchange.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RadialExchange.lean new file mode 100644 index 0000000000000000000000000000000000000000..ca955035df9e8173385a110de85172ca252a3724 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RadialExchange.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Detector.RadialMellin +import OAI.NumberTheory.DirichletL.Detector.HighAbsolute +import OAI.NumberTheory.DirichletL.Detector.FrequencySupport +import Mathlib.MeasureTheory.Integral.DominatedConvergence + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +lemma radialFourier_vertical_inverse (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0(r:ℂ)^(-z)*mellin (paperRadialFourier W) z) := by + have he := ProbeRadialMellin.radial_mellin_inversion W a b ha hW σ r hσ hr + simpa only [mellinInv,verticalIntegral,Complex.real_smul,smul_eq_mul] using he.symm + +lemma radial_sum_exchange {ι : Type*} [Countable ι] (W : SchwartzMap ℝ ℂ) + (a b : ℝ) (ha : 0‖c i‖*(r i)^(-σ))) : + (∑'i,c i*paperRadialFourier W (r i))= + verticalIntegral σ (fun z=>∑'i,c i*(r i:ℂ)^(-z)*mellin (paperRadialFourier W) z) := by + let F := fun i (t : ℝ)=>c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))* + mellin (paperRadialFourier W) ((σ:ℂ)+t*Complex.I) + have hF (i) : Integrable (F i) := by + simpa only [F,mul_assoc] using + (ProbeRadialMellin.radial_mellin_inverse_integrable W a b ha hW σ (r i) hσ (hr i)).const_mul (c i) + have hn (i) (t : ℝ) : ‖F i t‖=(‖c i‖*(r i)^(-σ))* + ‖mellin (paperRadialFourier W) ((σ:ℂ)+t*Complex.I)‖ := by + simp only [F,norm_mul,Complex.norm_cpow_eq_rpow_re_of_pos (hr i)] + simp + have hsum : Summable (fun i=>∫t : ℝ,‖F i t‖) := by + simp only [hn,integral_const_mul] + exact hc.mul_right _ + have he := integral_tsum_of_summable_integral_norm hF hsum + simp_rw [radialFourier_vertical_inverse W a b ha hW σ _ hσ (hr _)] + unfold verticalIntegral + have hi (i) : c i*(↑(1/(2*Real.pi))*(∫t : ℝ, + (r i:ℂ)^(-((σ:ℂ)+t*Complex.I))*mellin (paperRadialFourier W) ((σ:ℂ)+t*Complex.I)))= + (↑(1/(2*Real.pi)):ℂ)*(∫t : ℝ,F i t) := by + simp only [F,mul_assoc,integral_const_mul] + ring + simp_rw [hi] + rw [tsum_mul_left,he] + +lemma frequency_rpow_summable (σ : ℝ) (hσ : 1<σ) : + Summable (fun H : NonzeroFrequency=>(elementNorm H.val)^(-σ)) := by + have he (H : NonzeroFrequency) : ‖frequencyWeight (σ:ℂ) H‖=(elementNorm H.val)^(-σ) := by + have hH : 0‖actualCongruenceCoefficient C A s hA H.val‖* + (K*elementNorm H.val/elementNorm ((C.generator*A)*s))^(-σ)) := by + have hd : 0mul_nonneg (norm_nonneg _) + (mul_nonneg (Real.rpow_nonneg (div_pos hK hd).le _) (Real.rpow_nonneg (by unfold elementNorm;positivity) _))) _ hb + intro H + rw [←mul_assoc] + exact mul_le_mul_of_nonneg_right + (mul_le_mul_of_nonneg_right (actualCongruenceCoefficient_norm_le C A s hA hs H.val) + (Real.rpow_nonneg (div_pos hK hd).le _)) (Real.rpow_nonneg (by unfold elementNorm;positivity) _) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RadialIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RadialIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..61b473931089d141ce3b4e273bd6ae8e4d4348e4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RadialIdentity.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Detector.RadialExchange +import OAI.NumberTheory.DirichletL.Detector.CalibrationSupport + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma elementNorm_pos (a : O) (ha : a≠0) : 0∑'H : NonzeroFrequency, + actualCongruenceCoefficient C A s hA H.val* + ((K*elementNorm H.val/elementNorm ((C.generator*A)*s)):ℂ)^(-z)* + mellin (paperRadialFourier W) z) := by + let : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable + have he := radial_sum_exchange W a b ha hW σ (by linarith) + (fun H : NonzeroFrequency=>actualCongruenceCoefficient C A s hA H.val) + (fun H=>K*elementNorm H.val/elementNorm ((C.generator*A)*s)) (by + intro H + exact div_pos (mul_pos hK (elementNorm_pos H.val H.property)) + (elementNorm_pos _ (mul_ne_zero (mul_ne_zero C.generator_ne_zero hA) hs))) + (actualFrequency_moment_summable C A s hA hs K hK σ hσ) + simpa only [Complex.ofReal_mul,Complex.ofReal_div] using he + +theorem actualFrequency_mellin (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hSne : S.Nonempty) + (A s : O) (hA : A≠0) (hs : s≠0) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) + (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0∑'H : NonzeroFrequency, + actualCongruenceCoefficient C A s hA H.val* + ((K*elementNorm H.val/elementNorm ((C.generator*A)*s)):ℂ)^(-z)* + mellin (paperRadialFourier W) z) := by + dsimp only + rw [←actualFrequency_mellin_nonzero (calibrationForSet S hS) A s hA hs W a b ha hW K hK σ hσ] + symm + apply (Subtype.val_injective : Function.Injective (fun H : NonzeroFrequency=>H.val)).tsum_eq + (f:=fun H : O=>actualCongruenceCoefficient (calibrationForSet S hS) A s hA H* + paperRadialFourier W (K*elementNorm H/elementNorm (((calibrationForSet S hS).generator*A)*s))) + intro H hH + have hn : H≠0 := by + intro hz + subst H + exact hH (by dsimp only; rw [actualCongruenceCoefficient_zero_frequency S hS hSne A s hA hs hcop,zero_mul]) + exact ⟨⟨H,hn⟩,rfl⟩ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RadialMellin.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RadialMellin.lean new file mode 100644 index 0000000000000000000000000000000000000000..c4e100314745bb365ed47582a7ba8003e0d0a187 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RadialMellin.lean @@ -0,0 +1,550 @@ +import OAI.NumberTheory.DirichletL.Foundation +import Mathlib.Analysis.MellinInversion + +namespace OAI + +noncomputable section +open MeasureTheory Set Filter Asymptotics +open scoped FourierTransform RealInnerProductSpace Topology +namespace SevenEighths.ProbeRadialMellin + +def laplace (f : ℝ → ℂ) (t : ℝ) : ℂ := + ∫ r : ℝ in Ioi 0, f r * Complex.exp (-(t*r : ℝ)) + +lemma mellin_real (f : ℝ → ℂ) (s : ℝ) : + mellin f (s : ℂ) = ∫ r : ℝ in Ioi 0, (r^(s-1) : ℝ) • f r := by + apply setIntegral_congr_fun measurableSet_Ioi + intro r hr + change (r:ℂ)^((s:ℂ)-1)*f r = (r^(s-1):ℝ)*f r + rw [show (s:ℂ)-1=((s-1:ℝ):ℂ) by push_cast; rfl, + ← Complex.ofReal_cpow (le_of_lt hr)] + +lemma mellinConvergent_real (f : ℝ → ℂ) (s : ℝ) : + MellinConvergent f (s : ℂ) ↔ + IntegrableOn (fun r : ℝ => (r^(s-1) : ℝ) • f r) (Ioi 0) := by + apply integrable_congr + filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr + change (r:ℂ)^((s:ℂ)-1)*f r = (r^(s-1):ℝ)*f r + rw [show (s:ℂ)-1=((s-1:ℝ):ℂ) by push_cast; rfl, + ← Complex.ofReal_cpow (le_of_lt hr)] + +lemma gamma_scaled_integrable {s r : ℝ} (hs : 0 t^(s-1)*Real.exp (-(r*t))) (Ioi 0) := by + have hg : MellinConvergent (fun t : ℝ => (Real.exp (-t) : ℂ)) (s : ℂ) := by + rw [mellinConvergent_real] + simpa only [Complex.real_smul, RCLike.ofReal_eq_complex_ofReal, + Complex.ofReal_mul, mul_comm] using! + (Real.GammaIntegral_convergent hs).ofReal (𝕜 := ℂ) + have hh := (MellinConvergent.comp_mul_left (f := fun t : ℝ => (Real.exp (-t) : ℂ)) + (s := (s : ℂ)) hr).mpr hg + rw [mellinConvergent_real] at hh + simpa only [RCLike.smul_re, RCLike.ofReal_re] using! hh.re + +lemma gamma_scaled_integral {s r : ℝ} (hs : 0 f p.1 * + ((p.2:ℂ)^(s-1)*Complex.exp (-(p.1*p.2:ℝ)))) + ((volume.restrict (Ioi 0)).prod (volume.restrict (Ioi 0))) := by + have hm : AEStronglyMeasurable (fun p : ℝ×ℝ => f p.1 * + ((p.2:ℂ)^(s-1)*Complex.exp (-(p.1*p.2:ℝ)))) + ((volume.restrict (Ioi 0)).prod (volume.restrict (Ioi 0))) := by + exact hf.comp_fst.mul (by fun_prop) + have hn (r t : ℝ) (ht : 0 r^(-s.re)*‖f r‖) (Ioi 0) := by + apply hconv.norm.congr + filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr + simp only [norm_smul, Complex.norm_cpow_eq_rpow_re_of_pos hr, + Complex.sub_re, Complex.one_re] + congr 2 + ring + apply (hw.const_mul (Real.Gamma s.re)).congr + filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr + have hi : (fun t : ℝ => ‖f r*((t:ℂ)^(s-1)*Complex.exp (-(r*t:ℝ)))‖) =ᵐ[ + volume.restrict (Ioi 0)] (fun t => ‖f r‖*(t^(s.re-1)*Real.exp (-(r*t)))) := by + filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + exact hn r t ht + rw [integral_congr_ae hi] + rw [integral_const_mul, gamma_scaled_integral hs hr] + ring + +lemma mellin_laplace (f : ℝ → ℂ) (s : ℂ) (hs : 0 paperE (-(p.2*p.1))*f p.2*g p.1) := by + apply (hg.norm.mul_prod hf.norm).mono' + · have hp : Continuous (fun p : (ℂ × ℂ) => paperE (-(p.2*p.1))) := by + simp_rw [paperE_eq_exp] + fun_prop + exact (hp.aestronglyMeasurable.mul hf.aestronglyMeasurable.comp_snd).mul + hg.aestronglyMeasurable.comp_fst + · exact Eventually.of_forall fun p => by + simp only [norm_mul, paperE_norm, one_mul] + exact le_of_eq (mul_comm _ _) + simp only [paperFourier, Complex.real_smul] + simp_rw [mul_assoc, ← integral_mul_const, ← integral_const_mul] + rw [integral_integral_swap (hi.const_mul ((2/Real.sqrt 3:ℝ):ℂ))] + apply integral_congr_ae + exact Eventually.of_forall fun z => by + dsimp only + apply integral_congr_ae + exact Eventually.of_forall fun u => by dsimp only; rw [mul_comm z u]; ring + +lemma paper_gaussian_fourier (t : ℝ) (ht : 0 Complex.exp (-(t:ℂ)*‖z‖^2)) u = + (paperConstant/t:ℝ)*Complex.exp (-(paperConstant^2*‖u‖^2/t:ℝ)) := by + rw [paperFourier_eq_standard, + fourier_gaussian_innerProductSpace (by simpa using ht)] + norm_num only [Complex.finrank_real_complex, Nat.cast_ofNat, + div_self (by norm_num : (2:ℂ)≠0), Complex.cpow_one] + simp only [Complex.real_smul, ← Complex.ofReal_pow, paperFrequency_norm_sq, paperConstant_sq] + push_cast + have he : -(Real.pi:ℂ)^2*((4/3:ℝ)*‖u‖^2:ℝ)/(t:ℂ) = + -((4*Real.pi^2/3*‖u‖^2/t:ℝ):ℂ) := by push_cast; ring + push_cast at he + rw [he] + unfold paperConstant + push_cast + ring + +lemma radial_continuous (W : SchwartzMap ℝ ℂ) : Continuous (paperRadialFourier W) := by + rw [paperRadialFourier_eq_ray] + exact (paperFourierRayCLM W).continuous.comp Real.continuous_sqrt + +lemma radial_isBigO_top (W : SchwartzMap ℝ ℂ) (A : ℕ) : + paperRadialFourier W =O[atTop] (fun r : ℝ => r^(-(A:ℝ))) := by + obtain ⟨C, hC, hb⟩ := paperRadialFourier_euler_bound W A 0 + apply isBigO_iff.mpr + refine ⟨C, ?_⟩ + filter_upwards [eventually_gt_atTop (0:ℝ)] with r hr + have hh := hb 0 (by omega) r hr + simp only [LocalLogFourier.eulerDeriv, iteratedDeriv_zero, Real.exp_zero, mul_one] at hh + have hp : r^A * ‖paperRadialFourier W r‖ ≤ C := + (mul_le_mul_of_nonneg_right (pow_le_pow_left₀ hr.le (by linarith : r≤1+r) A) + (norm_nonneg _)).trans hh + rw [Real.norm_eq_abs, abs_of_pos (Real.rpow_pos_of_pos hr _), + Real.rpow_neg hr.le, Real.rpow_natCast, ← div_eq_mul_inv] + exact (le_div_iff₀ (pow_pos hr A)).mpr (by simpa [mul_comm] using hp) + +lemma radial_isBigO_zero (W : SchwartzMap ℝ ℂ) : + paperRadialFourier W =O[𝓝[>] 0] (fun r : ℝ => r^(-(0:ℝ))) := by + obtain ⟨C, hC, hb⟩ := paperRadialFourier_euler_bound W 0 0 + apply isBigO_iff.mpr + refine ⟨C, ?_⟩ + filter_upwards [self_mem_nhdsWithin] with r hr + simpa [LocalLogFourier.eulerDeriv] using hb 0 (by omega) r hr + +theorem radial_mellin_convergent (W : SchwartzMap ℝ ℂ) (z : ℂ) (hz : 0 W (‖z‖^2)) := (radialTestCLM W).integrable + have hg : Integrable (fun z : ℂ => Complex.exp (-(t:ℂ)*‖z‖^2)) := by + simpa only [zero_mul, add_zero] using + GaussianFourier.integrable_cexp_neg_mul_sq_norm_add (by simpa using ht) 0 (0:ℂ) + have h := paper_fourier_pairing _ _ hf hg + have hleft : (∫ u : ℂ, paperFourier (fun z : ℂ => W (‖z‖^2)) u * + Complex.exp (-(t:ℂ)*‖u‖^2)) = (Real.pi:ℂ)*laplace (paperRadialFourier W) t := by + simp_rw [paperFourier_radial] + rw [laplace, ← CubicEisenstein.integral_radial_sq] + apply integral_congr_ae + exact Eventually.of_forall fun u => by simp [Complex.ofReal_mul] + have hright : (∫ z : ℂ, W (‖z‖^2)*paperFourier + (fun u : ℂ => Complex.exp (-(t:ℂ)*‖u‖^2)) z) = + (Real.pi:ℂ)*((paperConstant/t:ℝ)*laplace W (paperConstant^2/t)) := by + simp_rw [paper_gaussian_fourier t ht] + rw [laplace, ← integral_const_mul, ← CubicEisenstein.integral_radial_sq] + apply integral_congr_ae + exact Eventually.of_forall fun u => by + dsimp only + have he : paperConstant^2*‖u‖^2/t = paperConstant^2/t*‖u‖^2 := by ring + rw [he] + ring + rw [hleft, hright] at h + exact mul_left_cancel₀ (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero) h + +lemma mellin_reciprocal_laplace (W : ℝ → ℂ) (z : ℂ) : + mellin (fun t : ℝ => (paperConstant/t:ℝ)*laplace W (paperConstant^2/t)) (1-z) = + (paperConstant:ℂ)*((paperConstant^2:ℝ):ℂ)^(-z)*mellin (laplace W) z := by + have hfun : (fun t : ℝ => (paperConstant/t:ℝ)*laplace W (paperConstant^2/t)) = + (fun t : ℝ => (paperConstant:ℂ) • ((t:ℂ)^(-1:ℂ) • + laplace W (paperConstant^2*t⁻¹))) := by + funext t + simp [Complex.cpow_neg_one, div_eq_mul_inv, smul_eq_mul, mul_assoc] + rw [hfun, mellin_const_smul, mellin_cpow_smul] + rw [show 1-z+(-1) = -z by ring] + have hh := mellin_comp_inv (fun t : ℝ => laplace W (paperConstant^2*t)) (-z) + rw [neg_neg] at hh + rw [hh, mellin_comp_mul_left _ _ (sq_pos_of_pos paperConstant_pos)] + simp only [smul_eq_mul] + ring + +theorem radial_mellin_gamma (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 (paperConstant/t:ℝ)*laplace W (paperConstant^2/t)) (1-z) := by + unfold mellin + apply setIntegral_congr_fun measurableSet_Ioi + intro t ht + dsimp only + rw [radial_laplace_duality W t ht] + rw [hL, sub_sub_cancel, mellin_reciprocal_laplace, hR] at he + have hg : Complex.Gamma (1-z) ≠ 0 := Complex.Gamma_ne_zero_of_re_pos (by + simp only [Complex.sub_re, Complex.one_re]; linarith) + apply (mul_left_cancel₀ hg) + rw [he] + field_simp + +lemma paper_prefactor (z : ℂ) : + (paperConstant:ℂ)*((paperConstant^2:ℝ):ℂ)^(-z) = + (paperConstant:ℂ)^(1-2*z) := by + have hn : (paperConstant:ℂ)≠0 := Complex.ofReal_ne_zero.mpr paperConstant_pos.ne' + have hh := Complex.cpow_nat_mul' (x := (paperConstant:ℂ)) (n := 2) + (by simp [Complex.arg_ofReal_of_nonneg paperConstant_pos.le, Real.pi_pos]) + (by simp [Complex.arg_ofReal_of_nonneg paperConstant_pos.le, Real.pi_nonneg]) (-z) + push_cast + rw [← hh, show 1-2*z = 1+2*(-z) by ring, Complex.cpow_add _ _ hn, + Complex.cpow_one] + norm_num + +theorem radial_mellin_identity (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 simp [hreal] + have he : mellin W (s:ℂ) = + (((∫ r : ℝ in Ioi 0, r^(s-1)*(W r).re):ℝ):ℂ) := by + rw [mellin_real, ← integral_complex_ofReal] + apply setIntegral_congr_fun measurableSet_Ioi + intro r _ + dsimp only + rw [hr r, Complex.real_smul, Complex.ofReal_mul] + simp + rw [he] + simp only [Complex.ofReal_re, Complex.ofReal_im, and_true] + have hi : IntegrableOn (fun r : ℝ => r^(s-1)*(W r).re) (Ioi 0) := by + have hh := ((mellinConvergent_real W s).mp hc).re + simpa only [RCLike.smul_re] using! hh + apply (setIntegral_pos_iff_support_of_nonneg_ae ?_ hi).mpr + · have hset : Function.support (fun r : ℝ => r^(s-1)*(W r).re) ∩ Ioi 0 = + Function.support (fun r : ℝ => (W r).re) := by + ext r + simp only [mem_inter_iff, Function.mem_support, mem_Ioi] + constructor + · intro hh + exact fun h => hh.1 (by rw [h, mul_zero]) + · intro hh + have hw : W r≠0 := fun h => hh (by rw [h]; rfl) + have hp := ha.trans_le (hW hw).1 + exact ⟨mul_ne_zero (Real.rpow_pos_of_pos hp _).ne' hh, hp⟩ + rw [hset] + apply ((Complex.continuous_re.comp W.continuous).isOpen_support).measure_pos volume + by_contra h + apply hne + ext r + have hh : (W r).re=0 := by + by_contra hn + exact h ⟨r,hn⟩ + change W r = 0 + rw [hr r, hh, Complex.ofReal_zero] + · filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr + exact mul_nonneg (Real.rpow_nonneg hr.le _) (hnonneg r) + +theorem radial_mellin_positive (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 + ((paperConstant:ℂ)^(1-2*z)*Complex.Gamma z / Complex.Gamma (1-z))* + mellin W (1-z) + have hop : IsOpen D := isOpen_lt continuous_const Complex.continuous_re + have hcv : Convex ℝ D := (convex_Ioi (0:ℝ)).linear_preimage Complex.reCLM.toLinearMap + have hf : AnalyticOnNhd ℂ (mellin (paperRadialFourier W)) D := + (radial_mellin_differentiable W).analyticOnNhd hop + have hG : DifferentiableOn ℂ G D := by + intro w hw + have h1 : DifferentiableAt ℂ (fun z : ℂ => (paperConstant:ℂ)^(1-2*z)) w := + (differentiableAt_const _ |>.sub (differentiableAt_id.const_mul 2)).const_cpow + (Or.inl (Complex.ofReal_ne_zero.mpr paperConstant_pos.ne')) + have h2 := CubicReflectionKernel.Gamma_differentiableAt_of_re_pos w hw + have h3 := (Complex.differentiable_one_div_Gamma (1-w)).comp w + (differentiableAt_const _ |>.sub differentiableAt_id) + have h4 := (CubicReflectionKernel.compact_source_mellin_differentiable W a b ha hW + (W.smooth ⊤) (1-w)).comp w (differentiableAt_const _ |>.sub differentiableAt_id) + simpa only [G, div_eq_mul_inv, Pi.mul_apply, Function.comp_apply] using! (((h1.mul h2).mul h3).mul h4).differentiableWithinAt + have hev : mellin (paperRadialFourier W) =ᶠ[𝓝 (1/2:ℂ)] G := by + have hstrip : IsOpen {w:ℂ | 0 paperConstant^(1-2*σ)) := + (Real.continuous_const_rpow paperConstant_pos.ne').comp + (continuous_const.sub (continuous_const.mul continuous_id)) + obtain ⟨B,hB⟩ := isCompact_Icc.bddAbove_image (hc.continuousOn (s := Icc lo hi)) + let Cp := |B|+1 + have hCp : 0 (le_div_iff₀ (by positivity)).mpr ?_⟩ + simpa only [mul_comm] using hb σ hσ t + +theorem radial_mellin_vertical_integrable (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 mellin (paperRadialFourier W) ((σ:ℂ)+t*Complex.I)) := by + apply continuous_iff_continuousAt.mpr + intro t + apply (radial_mellin_analytic W _ (by simpa using hσ)).continuousAt.comp + fun_prop + apply (integrable_inv_one_add_sq.const_mul C).mono' hc.aestronglyMeasurable + exact Eventually.of_forall fun t => by + simpa only [div_eq_mul_inv] using CubicReflectionKernel.weighted_two_to_cauchy + (norm_nonneg _) t (hb σ ⟨le_rfl,le_rfl⟩ t) + +theorem radial_mellin_inverse_integrable (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 (x:ℂ)^(-((σ:ℂ)+t*Complex.I))* + mellin (paperRadialFourier W) ((σ:ℂ)+t*Complex.I)) := by + have hi := radial_mellin_vertical_integrable W a b ha hW σ hσ + apply (hi.norm.const_mul (x^(-σ))).mono' + · have hm := hi.aestronglyMeasurable + have hc : Continuous (fun t : ℝ => (x:ℂ)^(-((σ:ℂ)+t*Complex.I))) := + (by fun_prop : Continuous (fun t : ℝ => -((σ:ℂ)+t*Complex.I))).const_cpow + (Or.inl (Complex.ofReal_ne_zero.mpr hx.ne')) + exact hc.aestronglyMeasurable.mul hm + · exact Eventually.of_forall fun t => by + rw [norm_mul, Complex.norm_cpow_eq_rpow_re_of_pos hx] + simp + +theorem radial_mellin_inversion (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma spectralSummand_mask_nonzero (S : Finset Id) (D I J : Id) (Ψ : O→*ℂ) (t : ℂ) + (h : spectralSummand S D Ψ t I J≠0) : completedMask S D I J≠0 := by + intro hz + exact h (by simp only [spectralSummand,hz,zero_mul]) + +lemma spectralSummand_calibration_coprime (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (D I J : Id) (Ψ : O→*ℂ) (t : ℂ) (h : spectralSummand S D Ψ t I J≠0) : + IsCoprime (calibrationForSet S hS).generator (completedIndex I J) := by + have hm := spectralSummand_mask_nonzero S D I J Ψ t h + have hA : completedIndex I J≠0 := by + intro hz + exact h (spectralSummand_zero_completedIndex S D I J Ψ t hz) + have hout : ∀P∈S,¬P∣I*J^3 := by + unfold completedMask at hm + split_ifs at hm with hd + · exact hd.2 + · exact False.elim (hm rfl) + apply calibrationForSet_coprime_of_excluded S hS + rw [completedIndex_eq_primaryGenerator] at hA ⊢ + rw [(primaryGenerator_spec (I*J^3) hA).1] + exact hout + +def radialMellinSpectralTerm (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset Id) (D : Id) (s : O) (hs : Supported (Ideal.span {s})) + (W : SchwartzMap ℝ ℂ) (K σ : ℝ) (t : ℂ) (I J : Id) : ℂ := + if hA : completedIndex I J≠0 then + spectralSummand S D (baseRowCoefficient η C.Xi s hs) t I J * + ((K/elementNorm (C.generator*completedIndex I J):ℝ):ℂ) * + verticalIntegral σ (fun z=>∑'H : NonzeroFrequency, + actualCongruenceCoefficient C (completedIndex I J) s hA H.val* + ((K*elementNorm H.val/elementNorm ((C.generator*completedIndex I J)*s)):ℂ)^(-z)* + mellin (paperRadialFourier W) z) + else 0 + +theorem transformedSpectralTerm_radial_mellin (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hSne : S.Nonempty) (D : Id) + (s : O) (hs : Supported (Ideal.span {s})) (hcs : IsCoprime (calibrationForSet S hS).generator s) + (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0 ActualEisensteinCubic.O + +def rawArithmeticSeries (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (C : CalibrationData) (x w z : ℂ) : ℂ := + ∑'p : RawHighIndex,fullHighCoefficient S D η (fun H=>star (C.residueMonoid H.val)) + x w z (rawHighEmbedding p) + +lemma rawHighCoefficient_outer_support (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (mask : NonzeroFrequency→ℂ) (x w z : ℂ) (p : RawHighIndex) + (hp : fullHighCoefficient S D η mask x w z (rawHighEmbedding p)≠0) : + Supported p.2.2 ∧ ∀P∈S,¬P∣p.2.2 := by + have hb : bareIdealHighCoefficient η p.1.val p.2.1.1 p.2.1.2 p.2.2 1≠0 := by + intro hz + exact hp (by simp only [fullHighCoefficient,rawHighEmbedding,markedIdealHighSummand,bareIdealHighSummand,hz,mul_zero,zero_mul]) + have hs : Supported p.2.2 := by + unfold bareIdealHighCoefficient at hb + split_ifs at hb with hh + · exact hh.2.2.2.1 + · exact False.elim (hb rfl) + refine ⟨hs,?_⟩ + by_contra hn + exact hp (by simp [fullHighCoefficient,rawHighEmbedding,markedIdealHighSummand,highIdealMask,hn]) + +lemma rawArithmeticSeries_eq_sourceRaw (S : Finset (Ideal O)) (D : Ideal O) (η : HeckeFamily.Character) + (C : CalibrationData) (x w z : ℂ) : + rawArithmeticSeries S D η C x w z= + ∑'i : SourceRawIndex S,fullHighCoefficient S D η (fun H=>star (C.residueMonoid H.val)) + x w z (sourceRawEmbedding S i) := by + unfold rawArithmeticSeries sourceRawEmbedding + change _ = ∑'i : {p : RawHighIndex // Supported p.2.2 ∧ ∀P∈S,¬P∣p.2.2}, _ + symm + apply tsum_subtype_eq_of_support_subset (f:=fun p : RawHighIndex=> + fullHighCoefficient S D η (fun H=>star (C.residueMonoid H.val)) x w z (rawHighEmbedding p)) + (s:={p : RawHighIndex | Supported p.2.2 ∧ ∀P∈S,¬P∣p.2.2}) + intro p hp + exact rawHighCoefficient_outer_support S D η _ x w z p hp + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RawIndexGrouping.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RawIndexGrouping.lean new file mode 100644 index 0000000000000000000000000000000000000000..102edf502a81b69653f03c9e65fced480f3a8b92 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RawIndexGrouping.lean @@ -0,0 +1,47 @@ +import OAI.NumberTheory.DirichletL.Detector.MixedFubini + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable + +abbrev SourceOuter (S : Finset (Ideal O)) := {K : Ideal O // Supported K ∧ ∀P∈S,¬P∣K} +abbrev CompletedPair := Ideal O×Ideal O + +def sourceRawGrouping (S : Finset (Ideal O)) : + SourceRawIndex S ≃ SourceOuter S×(CompletedPair×NonzeroFrequency) where + toFun i := (⟨i.val.2.2,i.property⟩,(i.val.2.1,i.val.1)) + invFun i := ⟨(i.2.2,(i.2.1,i.1.val)),i.1.property⟩ + left_inv _i := rfl + right_inv _i := rfl + +def sourceRawGroupingMeasurable (S : Finset (Ideal O)) + [MeasurableSpace (SourceRawIndex S)] [MeasurableSingletonClass (SourceRawIndex S)] + [MeasurableSpace (SourceOuter S)] [MeasurableSingletonClass (SourceOuter S)] + [MeasurableSpace CompletedPair] [MeasurableSingletonClass CompletedPair] + [MeasurableSpace NonzeroFrequency] [MeasurableSingletonClass NonzeroFrequency] : + SourceRawIndex S ≃ᵐ SourceOuter S×(CompletedPair×NonzeroFrequency) where + toEquiv := sourceRawGrouping S + measurable_toFun := measurable_of_countable _ + measurable_invFun := measurable_of_countable _ + +lemma sourceRawGrouping_preserving (S : Finset (Ideal O)) + [MeasurableSpace (SourceRawIndex S)] [MeasurableSingletonClass (SourceRawIndex S)] + [MeasurableSpace (SourceOuter S)] [MeasurableSingletonClass (SourceOuter S)] + [MeasurableSpace CompletedPair] [MeasurableSingletonClass CompletedPair] + [MeasurableSpace NonzeroFrequency] [MeasurableSingletonClass NonzeroFrequency] : + MeasurePreserving (sourceRawGroupingMeasurable S) Measure.count + ((Measure.count:Measure (SourceOuter S)).prod + ((Measure.count:Measure CompletedPair).prod (Measure.count:Measure NonzeroFrequency))) := by + rw [count_product,count_product] + exact count_equiv_preserving _ + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RawMellinTerm.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RawMellinTerm.lean new file mode 100644 index 0000000000000000000000000000000000000000..ab2f5efe24e2c7576a11f7b8fdaae487b2ac4151 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RawMellinTerm.lean @@ -0,0 +1,44 @@ +import OAI.NumberTheory.DirichletL.Detector.InitialSubseries +import OAI.NumberTheory.DirichletL.Detector.ContourShear + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ProbeCompleted ProbeRow CompletedGauss CanonicalQuadraticSieve CubicEisenstein +open EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +def rawPhysicalMellinTerm (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D I J K : Ideal O) (hK : Supported K) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (H : O) (t w z : ℂ) : ℂ := + physicalMellinCoefficientTerm η C S D I J (primaryGenerator K) + ((supported_span_primaryGenerator_iff K).mpr hK) X H t z *fullIdealWeight w K* + (Y:ℂ)^(w-1)*(Z:ℂ)^t*Complex.exp (t^2)*mellin (paperRadialFourier W0) z*mellin W1 w + +theorem rawPhysicalMellinTerm_eq_source (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D I J K : Ideal O) (hK : Supported K) + (hKS : ∀P∈S,¬P∣K) (W0 W1 : SchwartzMap ℝ ℂ) + (X Y Z : ℝ) (hX : 0star ((calibrationForSet S hS).residueMonoid h.val)) + (t+1-z) w z (rawHighEmbedding (H,((I,J),K))) := by + have hcs : IsCoprime (calibrationForSet S hS).generator (primaryGenerator K) := by + apply calibrationForSet_coprime_of_excluded S hS + rw [(primaryGenerator_spec K (supported_primaryGenerator_ne_zero K hK)).1] + exact hKS + unfold rawPhysicalMellinTerm + rw [physicalMellinCoefficientTerm_eq_guarded η S hS hbad D I J (primaryGenerator K) + ((supported_span_primaryGenerator_iff K).mpr hK) hcs X hX H.val H.property t z, + guardedHighMellinCoefficient_eq_high η (calibrationForSet S hS) S hpS D I J K hK hKS X H.val + (t+1-z) w z,sourceMellinWeight_shear] + simp only [fullHighCoefficient,frequencyWeight,rawHighEmbedding] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RawNestedJoin.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RawNestedJoin.lean new file mode 100644 index 0000000000000000000000000000000000000000..fd3f233802616bb6db11e7f527b50efe53622b62 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RawNestedJoin.lean @@ -0,0 +1,46 @@ +import OAI.NumberTheory.DirichletL.Detector.RawRadialJoin +import OAI.NumberTheory.DirichletL.Detector.OuterIndex + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve ProbeRow CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +def rawNestedPhysicalProbe (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z ξ υ : ℝ) : ℂ := + ∑'K : SourceOuter C.excluded,verticalIntegral υ (fun w=>verticalIntegral 4 (fun t=> + ∑'IJ : CompletedPair,verticalIntegral ξ (fun z=>∑'H : NonzeroFrequency, + rawPhysicalMellinTerm η C C.excluded D IJ.1 IJ.2 K.val K.property.1 W0 W1 X Y Z H.val t w z))) + +theorem nestedMellinPhysicalProbe_eq_raw (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z ξ υ : ℝ) : + nestedMellinPhysicalProbe η C D W0 W1 X Y Z ξ υ= + rawNestedPhysicalProbe η C D W0 W1 X Y Z ξ υ := by + unfold nestedMellinPhysicalProbe rawNestedPhysicalProbe + rw [sourceOuter_tsum] + apply tsum_congr + intro K + dsimp only + simp_rw [rawPhysicalMellinTerm_radial_join,tsum_mul_left] + apply congrArg (verticalIntegral υ) + funext w + unfold rawRadialOuterFactor + simp only [fullIdealWeight,ite_eq_right K.property.1.1] + unfold verticalIntegral + simp_rw [mul_assoc,integral_const_mul] + simp only [Complex.ofReal_natCast] + ring_nf + congr 1 + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro a + ring_nf + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RawNesting.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RawNesting.lean new file mode 100644 index 0000000000000000000000000000000000000000..562997f8ad2cde9caa62834ff42fb874ae71c75f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RawNesting.lean @@ -0,0 +1,67 @@ +import OAI.NumberTheory.DirichletL.Detector.RawIndexGrouping + +namespace OAI + +noncomputable section +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable +local instance : MeasurableSpace O := ⊤ +local instance : MeasurableSingletonClass O := ⟨fun _=>trivial⟩ +local instance : MeasurableSpace (Ideal O) := ⊤ +local instance : MeasurableSingletonClass (Ideal O) := ⟨fun _=>trivial⟩ + +local instance (S : Finset (Ideal O)) : MeasurableSpace (SourceRawIndex S) := ⊤ +local instance (S : Finset (Ideal O)) : MeasurableSingletonClass (SourceRawIndex S) := ⟨fun _=>trivial⟩ + +abbrev PhysicalNestedSpace (S : Finset (Ideal O)) := SourceOuter S×(ℝ×(ℝ×(CompletedPair×(ℝ×NonzeroFrequency)))) + +def physicalRawNesting (S : Finset (Ideal O)) : SourceRawIndex S×HeightSpace ≃ᵐ PhysicalNestedSpace S := + ((sourceRawGroupingMeasurable S).prodCongr (MeasurableEquiv.refl HeightSpace)).trans physicalNestingEquiv + +lemma physicalRawNesting_preserving (S : Finset (Ideal O)) : + MeasurePreserving (physicalRawNesting S) + ((Measure.count:Measure (SourceRawIndex S)).prod heightMeasure) + ((Measure.count:Measure (SourceOuter S)).prod (volume.prod (volume.prod + ((Measure.count:Measure CompletedPair).prod (volume.prod (Measure.count:Measure NonzeroFrequency)))))) := by + exact (physicalNesting_preserving Measure.count Measure.count Measure.count volume volume volume).comp + ((sourceRawGrouping_preserving S).prod (MeasurePreserving.id heightMeasure)) + +def originalNestedOnLines (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (hS : ∀P∈S,P.IsMaximal) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) + (p : PhysicalNestedSpace S) : ℂ := + originalRawOnLines η S hS D W0 W1 X Y Z + ⟨(p.2.2.2.2.2,(p.2.2.2.1,p.1.val)),p.1.property⟩ ((p.2.2.1,p.2.2.2.2.1),p.2.1) + +theorem originalRaw_integral_eq_nesting (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable + +def SourceRawIndex (S : Finset (Ideal O)) := + {p : RawHighIndex // Supported p.2.2 ∧ ∀P∈S,¬P∣p.2.2} + +instance (S : Finset (Ideal O)) : Countable (SourceRawIndex S) := inferInstanceAs (Countable {_p : RawHighIndex // _}) + +def sourceRawEmbedding (S : Finset (Ideal O)) (i : SourceRawIndex S) : FullHighIndex := + rawHighEmbedding i.val + +lemma sourceRawEmbedding_injective (S : Finset (Ideal O)) : Function.Injective (sourceRawEmbedding S) := + rawHighEmbedding_injective.comp Subtype.val_injective + +def originalRawOnLines (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (hS : ∀P∈S,P.IsMaximal) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) + (i : SourceRawIndex S) (p : HeightSpace) : ℂ := + rawPhysicalMellinTerm η (calibrationForSet S hS) S D i.val.2.1.1 i.val.2.1.2 i.val.2.2 i.property.1 + W0 W1 X Y Z i.val.1.val ((4:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) + +theorem originalRaw_counting_product_integrable (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) [MeasurableSpace (SourceRawIndex S)] [MeasurableSingletonClass (SourceRawIndex S)] + (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (a0 b0 a1 b1 : ℝ) + (ha0 : 0originalRawOnLines η S hS D W0 W1 X Y Z p.1 p.2) + ((Measure.count:Measure (SourceRawIndex S)).prod heightMeasure) := by + let mask := fun H : NonzeroFrequency=>star ((calibrationForSet S hS).residueMonoid H.val) + have hm (H : NonzeroFrequency) : ‖mask H‖≤1 := by + simpa only [mask,norm_star] using (calibrationForSet S hS).residueMonoid_norm_le_one H.val + let T := fun p : HeightSpace=>sourceMellinWeight W0 W1 X Y Z + ((3:ℂ)+p.1.1*Complex.I) ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) + have hT : Integrable T heightMeasure := sourceMellinWeight_initial_integrable W0 W1 a0 b0 a1 b1 + ha0 ha1 hW0 hW1 X Y Z hX hY hZ 3 2 3 (by norm_num) + have hcT : Continuous T := sourceMellinWeight_initial_continuous W0 W1 a1 b1 ha1 hW1 + X Y Z hX hY hZ 3 2 3 (by norm_num) + have hi := initialHigh_counting_product_integrable (sourceRawEmbedding S) (sourceRawEmbedding_injective S) + S D η mask hm 3 3 2 (by norm_num) (by norm_num) (by norm_num) T hT hcT + have hp := (MeasurePreserving.id (Measure.count:Measure (SourceRawIndex S))).prod + (sourceHeightShear_preserving.symm sourceHeightShear) + have hh := hp.integrable_comp_of_integrable hi + apply hh.congr + apply Filter.Eventually.of_forall + intro p + dsimp only [Function.comp_def,Prod.map] + rw [originalRawOnLines,rawPhysicalMellinTerm_eq_source η S hS hpS hbad D _ _ _ p.1.property.1 + p.1.property.2 W0 W1 X Y Z hX p.1.val.1] + have he : (4:ℂ)+p.2.1.1*Complex.I+1-((2:ℂ)+p.2.1.2*Complex.I)= + 3+((p.2.1.1-p.2.1.2:ℝ):ℂ)*Complex.I := by push_cast;ring + have hsh : sourceHeightShear.symm p.2=((p.2.1.1-p.2.1.2,p.2.1.2),p.2.2) := rfl + simp only [he,initialHighOnLines,T,hsh,sourceRawEmbedding,mask,id_eq,Complex.ofReal_ofNat] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RawRadialJoin.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RawRadialJoin.lean new file mode 100644 index 0000000000000000000000000000000000000000..48fec3ae86451a476112459ec1a9279ec8252397 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RawRadialJoin.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.Detector.RawMellinTerm +import OAI.NumberTheory.DirichletL.Detector.NestedMellin + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve CanonicalRowCompletion ProbeCompleted ProbeRow CubicEisenstein +open EisensteinSchwartzPoisson +local notation "O" => ActualEisensteinCubic.O + +lemma verticalIntegral_const_mul (σ : ℝ) (F : ℂ→ℂ) (c : ℂ) : + verticalIntegral σ (fun z=>c*F z)=c*verticalIntegral σ F := by + unfold verticalIntegral + rw [integral_const_mul] + ring + +def rawRadialOuterFactor (C : CalibrationData) (K : Ideal O) + (W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) (t w : ℂ) : ℂ := + (Y:ℂ)^(w-1)*fullIdealWeight w K*mellin W1 w* + (idealRowHom C.generator K / + (C.tau*C.residueMonoid (primaryGenerator K)*(Real.sqrt (elementNorm C.generator*(Ideal.absNorm K:ℝ)*X):ℂ)))* + (Real.sqrt (Ideal.absNorm K):ℂ)⁻¹*((Z:ℂ)^t*Complex.exp (t^2)) + +lemma rawPhysicalMellinTerm_radial_join (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D I J K : Ideal O) (hK : Supported K) + (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z ξ : ℝ) (t w : ℂ) : + verticalIntegral ξ (fun z=>∑'H : NonzeroFrequency, + rawPhysicalMellinTerm η C S D I J K hK W0 W1 X Y Z H.val t w z)= + rawRadialOuterFactor C K W1 X Y Z t w* + radialMellinSpectralTerm η C S D (primaryGenerator K) + ((supported_span_primaryGenerator_iff K).mpr hK) W0 + (elementNorm C.generator*(Ideal.absNorm K:ℝ)*X) ξ t I J := by + have hgen := (primaryGenerator_spec K (supported_primaryGenerator_ne_zero K hK)).1 + have hn : elementNorm (primaryGenerator K)=(Ideal.absNorm K:ℝ) := by + unfold elementNorm + rw [hgen] + unfold rawPhysicalMellinTerm physicalMellinCoefficientTerm radialMellinSpectralTerm + split_ifs with hA + · dsimp only + simp only [hn,hgen] + let c := rawRadialOuterFactor C K W1 X Y Z t w * + (spectralSummand S D (baseRowCoefficient η C.Xi (primaryGenerator K) + ((supported_span_primaryGenerator_iff K).mpr hK)) t I J * + ((elementNorm C.generator*(Ideal.absNorm K:ℝ)*X/elementNorm (C.generator*completedIndex I J):ℝ):ℂ)) + have hp (z : ℂ) (H : NonzeroFrequency) : + idealRowHom C.generator K / + (C.tau*C.residueMonoid (primaryGenerator K)* + (Real.sqrt (elementNorm C.generator*(Ideal.absNorm K:ℝ)*X):ℂ)) * + (Real.sqrt (Ideal.absNorm K):ℂ)⁻¹ * + spectralSummand S D (baseRowCoefficient η C.Xi (primaryGenerator K) + ((supported_span_primaryGenerator_iff K).mpr hK)) t I J * + ((elementNorm C.generator*(Ideal.absNorm K:ℝ)*X/elementNorm (C.generator*completedIndex I J):ℝ):ℂ) * + actualCongruenceCoefficient C (completedIndex I J) (primaryGenerator K) hA H.val * + ((elementNorm C.generator*(Ideal.absNorm K:ℝ)*X*elementNorm H.val / + elementNorm ((C.generator*completedIndex I J)*primaryGenerator K):ℝ):ℂ)^(-z) * + fullIdealWeight w K*(Y:ℂ)^(w-1)*(Z:ℂ)^t*Complex.exp (t^2)* + mellin (paperRadialFourier W0) z*mellin W1 w = + c*(actualCongruenceCoefficient C (completedIndex I J) (primaryGenerator K) hA H.val * + ((elementNorm C.generator*(Ideal.absNorm K:ℝ)*X*elementNorm H.val / + elementNorm ((C.generator*completedIndex I J)*primaryGenerator K):ℝ):ℂ)^(-z)* + mellin (paperRadialFourier W0) z) := by + dsimp only [c,rawRadialOuterFactor] + ring + simp only [Complex.ofReal_mul,Complex.ofReal_div] at hp ⊢ + simp_rw [hp,tsum_mul_left] + rw [verticalIntegral_const_mul] + dsimp only [c] + simp only [Complex.ofReal_mul,Complex.ofReal_div] + ring_nf + congr 1 + apply congrArg (verticalIntegral ξ) + funext z + apply tsum_congr + intro H + congr 1 ; congr 1 ; ring_nf + · simp only [zero_mul,tsum_zero,verticalIntegral,integral_zero,mul_zero] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RawSourceIntegral.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RawSourceIntegral.lean new file mode 100644 index 0000000000000000000000000000000000000000..e8d01e1ba65b79a2f197846bfaedc684bf7a88fd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RawSourceIntegral.lean @@ -0,0 +1,125 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalRawIntegral +import OAI.NumberTheory.DirichletL.Detector.RawArithmetic + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable +local instance (S : Finset (Ideal O)) : MeasurableSpace (SourceRawIndex S) := ⊤ +local instance (S : Finset (Ideal O)) : MeasurableSingletonClass (SourceRawIndex S) := ⟨fun _=>trivial⟩ + +def rawSourceOnLines (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (hS : ∀P∈S,P.IsMaximal) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) + (i : SourceRawIndex S) (p : HeightSpace) : ℂ := + initialHighOnLines S D η (fun H=>star ((calibrationForSet S hS).residueMonoid H.val)) + 3 3 2 (sourceRawEmbedding S i) p *sourceMellinWeight W0 W1 X Y Z + ((3:ℂ)+p.1.1*Complex.I) ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) + +lemma originalRawOnLines_eq_source (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (X Y Z : ℝ) (hX : 0rawSourceOnLines η S hS D W0 W1 X Y Z p.1 p.2) + ((Measure.count:Measure (SourceRawIndex S)).prod heightMeasure) := by + have hm (H : NonzeroFrequency) : ‖star ((calibrationForSet S hS).residueMonoid H.val)‖≤1 := by + simpa only [norm_star] using (calibrationForSet S hS).residueMonoid_norm_le_one H.val + unfold rawSourceOnLines + apply initialHigh_counting_product_integrable (sourceRawEmbedding S) (sourceRawEmbedding_injective S) + S D η (fun H=>star ((calibrationForSet S hS).residueMonoid H.val)) hm 3 3 2 + (by norm_num) (by norm_num) (by norm_num) + (fun p : HeightSpace=>sourceMellinWeight W0 W1 X Y Z + ((3:ℂ)+p.1.1*Complex.I) ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I)) + · exact sourceMellinWeight_initial_integrable W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z hX hY hZ 3 2 3 (by norm_num) + · exact sourceMellinWeight_initial_continuous W0 W1 a1 b1 ha1 hW1 + X Y Z hX hY hZ 3 2 3 (by norm_num) + +lemma rawPhysicalTotalIntegral_eq_source (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (X Y Z : ℝ) (hX : 0 + rawSourceOnLines η S hS D W0 W1 X Y Z p.1 p.2) + refine Eq.trans ?_ he + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro p + exact originalRawOnLines_eq_source η S hS hpS hbad D W0 W1 X Y Z hX p.1 p.2 + +def rawSourceTripleIntegral (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (hS : ∀P∈S,P.IsMaximal) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3*∫p : HeightSpace, + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I)* + rawArithmeticSeries S D η (calibrationForSet S hS) ((3:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) ∂heightMeasure + +lemma rawPhysicalTotalIntegral_eq_triple (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 HeckeFamily.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +def fixedTwistSupport : Finset (Ideal O) := + (normalizedFactors (M*Ideal.span {rowMaskElement}*Ideal.span {(72:O)})).toFinset + +omit [NeZero M] in +theorem fixedTwistSupport_prime : ∀P∈fixedTwistSupport M,Prime P := by + intro P hP + exact prime_of_normalized_factor P (Multiset.mem_toFinset.mp hP) + +lemma inverse_twist_base_modulus (θ : RayQuotient.Characters M H) : + ((fixedSourcePrincipal ∅ (by simp)).product + (HeckeRayQuotient.character M H hH θ).inverse).modulus=M := by + change (1:Ideal O)⊓M=M + simp + +theorem large_supported_twists_nonprincipal (u : FreeRow) + (hs : Supported (Ideal.span {u.val})) + (hl : (HeckeExceptionalRows.bound (fixedTwistSupport M):ℝ).trans inv_one + have hfixed := HeckeRowNonprincipal.principal_row_fixed_support η χ rowMaskElement 1 u.val + rowMaskElement_ne_zero (dvd_mul_left _ _) (dvd_mul_right _ _) v⁻¹ 0 0 r hr hv hx hχ hprincipal + (fun P _=>hspan.symm ▸ u.property.2 P) + have hη : η.modulus=M := inverse_twist_base_modulus M H hH θ + rw [hη] at hfixed + have hn := HeckeExceptionalRows.row_norm_bound (fixedTwistSupport M) (fixedTwistSupport_prime M) hfixed + rw [hspan] at hn + exact not_lt_of_ge (show rowNorm u≤(HeckeExceptionalRows.bound (fixedTwistSupport M):ℝ) by unfold rowNorm;exact_mod_cast hn) hl + +theorem raw_twisted_conductor (u : FreeRow) (θ : RayQuotient.Characters M H) : + (HeckePrimeRay.twistedFamily M H hH (rawRow u).inverse θ).modulus.absNorm≤ + conductorConstant*M.absNorm*(Ideal.span {u.val}:Ideal O).absNorm := by + have ht := HeckePrimeScale.twisted_modulus_bound M H hH (rawRow u).inverse θ + change _≤(rawRow u).modulus.absNorm*M.absNorm at ht + exact ht.trans (by simpa only [mul_assoc,mul_left_comm,mul_comm] using + Nat.mul_le_mul_right M.absNorm (rawRow_conductor u)) +omit [NeZero M] in +theorem canonical_amplitude_raw (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (u : FreeRow) (W : ℝ→ℂ) (a b D : ℝ) + (hD : 0 simp [HeckeDyadic.shift] + simp only [HeckePrimeAnnular.annularWeight,he] + by_cases hw : W ((P.absNorm:ℝ)/D)=0 + · simp [hw] + have hPS : P∉S := by + intro hPS + have hh := (lt_div_iff₀ hD).mp (hW hw).1 + have := hsmall P hPS + linarith + rw [idealCoeff_inverse_conj,rawRow_prime_outside S hS hbad u ⟨P,hp⟩ hPS] + exact mul_assoc _ _ _ + +omit H hH in +theorem large_supported_twists_eventually (d : ℝ) (hd : 0 Ideal HeckeFamily.O + +theorem log_power_absorption (c ell d : ℝ) (hc : 0(Real.rpow_nonneg hZ0.le _).trans (hm i hi) + have hprod : Z^(∑i∈J,(ell i/6-d))≤∏i∈J,mass i := by + rw [Real.rpow_sum_of_pos hZ0] + exact Finset.prod_le_prod₀ (fun i _=>Real.rpow_nonneg hZ0.le _) hm + have hn : |Probe.principalScalar J Z (∑i∈J,ell i) mass|= + Z^(-(∑i∈J,ell i)/6)*(∏i∈J,mass i) := by + unfold Probe.principalScalar + rw [abs_mul,abs_mul,abs_pow,abs_neg,abs_one,one_pow,one_mul, + abs_of_pos (Real.rpow_pos_of_pos hZ0 _),abs_of_nonneg (Finset.prod_nonneg hm0)] + have hpow : Z^(-(∑i∈J,ell i)/6)*Z^(∑i∈J,(ell i/6-d))=Z^(-d*J.card) := by + rw [←Real.rpow_add hZ0] + congr 1 + rw [Finset.sum_sub_distrib,←Finset.sum_div,Finset.sum_const,nsmul_eq_mul] + ring + have hl : Z^(-eps)≤|Probe.principalScalar J Z (∑i∈J,ell i) mass| := by + calc + _ ≤ Z^(-d*J.card) := Real.rpow_le_rpow_of_exponent_le hZ (by linarith) + _ = Z^(-(∑i∈J,ell i)/6)*Z^(∑i∈J,(ell i/6-d)) := hpow.symm + _ ≤ _ := by rw [hn];exact mul_le_mul_of_nonneg_left hprod (Real.rpow_nonneg hZ0.le _) + rw [abs_inv] + have hi := (inv_le_inv₀ ((Real.rpow_pos_of_pos hZ0 (-eps)).trans_le hl) + (Real.rpow_pos_of_pos hZ0 (-eps))).mpr hl + simpa only [Real.rpow_neg hZ0.le,inv_inv] using hi + +variable (M : Id) [NeZero M] +local instance : Finite (HeckeFamily.O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (HeckeFamily.O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) +include hH + +theorem ray_slot_subpower_lower (S : Finset Id) (W : ℝ→ℝ) + (a b : ℝ) (ha : 0 + ∑P∈pool (RayQuotient.identityClass M H) S (a i) (b i) (Z^(ell i)), + W i ((Ideal.absNorm P.val:ℝ)/(Z^(ell i)))*(Ideal.absNorm P.val:ℝ)^(-(5/6:ℝ))))⁻¹|≤Z^eps := by + let d : ℝ := eps/(J.card+1) + have hd : 0 Ideal HeckeFamily.O + +lemma pool_sum_complex (C : Set Id) (S : Finset Id) (a b x : ℝ) (f : Id→ℂ) : + (∑P∈pool C S a b x,f P.val)=∑P∈annularPrimeIdeals C a b x\S,f P := by + apply Finset.sum_bij (fun P _=>P.val) + · intro P hP;exact Finset.mem_subtype.mp hP + · intro P hP Q hQ he;exact Subtype.ext he + · intro P hP + have hp : Prime P := ((mem_annularPrimeIdeals C a b x P).mp (Finset.mem_sdiff.mp hP).1).2.1 + exact ⟨⟨P,hp⟩,Finset.mem_subtype.mpr hP,rfl⟩ + · intro P hP;rfl + +theorem weighted_pool_eq_annular (C : Set Id) (S : Finset Id) + (W : ℝ→ℂ) (a b D : ℝ) (ha : 0Prime P ∧ P∈C), + W ((P.absNorm:ℝ)/D)*g P := by + rw [pool_sum_complex C S a b D (fun P=>W ((P.absNorm:ℝ)/D)*g P)] + have hsub : annularPrimeIdeals C a b D\S⊆ + (HeckePrimeAnnular.annulusSet b D).filter (fun P=>Prime P ∧ P∈C) := by + intro P hP + have hp := (mem_annularPrimeIdeals C a b D P).mp (Finset.mem_sdiff.mp hP).1 + apply Finset.mem_filter.mpr + refine ⟨?_,hp.2.1,hp.1⟩ + apply ConcretePrimeRowBridge.mem_idealsUpTo.mpr + refine ⟨Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hp.2.1.ne_zero),?_⟩ + apply hp.2.2.2.trans + apply Nat.floor_mono + nlinarith [le_max_right (1:ℝ) b] + apply Finset.sum_subset hsub + intro P hP hnot + have hw : W ((P.absNorm:ℝ)/D)=0 := by + by_contra hn + have hy := hW hn + have hp := (Finset.mem_filter.mp hP).2 + apply hnot + apply Finset.mem_sdiff.mpr + constructor + · apply (mem_annularPrimeIdeals C a b D P).mpr + refine ⟨hp.2,hp.1,?_,?_⟩ + · apply (Nat.floor_lt (mul_nonneg hD.le ha.le)).mpr + have := (lt_div_iff₀ hD).mp hy.1 + nlinarith + · apply Nat.le_floor + have := (div_lt_iff₀ hD).mp hy.2 + nlinarith + · intro hs + have := hS P hs + have := (lt_div_iff₀ hD).mp hy.1 + linarith + simp only [hw,zero_mul] + +theorem central_phase_eq_amplitude (M : Id) [NeZero M] + [Finite (HeckeFamily.O ⧸ M)] (H : Subgroup (HeckeFamily.O ⧸ M)ˣ) + (S : Finset Id) (u : HeckeFamily.O) (W : ℝ→ℂ) (a b D : ℝ) + (ha : 0(P.absNorm:ℂ)^(z-1)*(-star (CanonicalRowCompletion.idealRowHom u P))) + simp_rw [mul_assoc] at ⊢ + rw [he] + unfold HeckePrimeRow.canonicalPrimeAmplitude + rw [←mul_assoc,neg_mul,←Complex.cpow_add _ _ (Complex.ofReal_ne_zero.mpr hD.ne')] + have hexp : (z-(1/2:ℂ)) + -(1/2:ℂ)=z-1 := by ring + rw [hexp,Finset.mul_sum] + apply Finset.sum_congr rfl + intro P hP + have hprime := (Finset.mem_filter.mp hP).2.1 + have hn : (0:ℝ)Nat.cast_nonneg _) hP + _ ≤ a*Z^ellMin := hnorm + _ ≤ a*Z^(ell j) := mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow_of_exponent_le hZ (hell j)) ha.le + +end SevenEighths.ProbeRaySlots +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RayPhaseBins.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RayPhaseBins.lean new file mode 100644 index 0000000000000000000000000000000000000000..a142c41312001ba064d7a53023070b92dffafd27 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RayPhaseBins.lean @@ -0,0 +1,80 @@ +import OAI.NumberTheory.DirichletL.Detector.RayCharacterFamily +import OAI.NumberTheory.DirichletL.Hecke.PrimeAmplitudeActual + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ContDiff +open Filter Set +namespace SevenEighths.ProbeRayPhaseBins +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily ProbeRayCharacterFamily +open HeckePrimeAmplitudeBins ProbeRaySlots +local notation "O" => HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_phase_bins (S : Finset (Ideal O)) (hS : ∀P∈S,Prime P) + (hbad : CanonicalQuadraticSieve.fixedBadPrimes⊆S) + (W : ℝ→ℂ) (A B : ℝ) (hA : 0p.val.1*p.val.2) + (fun p=>mul_le_mul p.property.1 p.property.2 hrmin.le (hdmin.trans_le p.property.1).le) + filter_upwards [hb,hn,ht,eventually_ge_atTop (1:ℝ)] with Z hb hn ht hZ + intro d hd hd' hU hT η u hu hs hcond a i ha ha' hbin r z hr hr' hσ hσ' hf hh + have hZp : 0 Ideal HeckeFamily.O + +lemma annular_power_separation (a b r s : ℝ) (ha : 0(hn hij).elim) + have hne : ell i≠ell j := fun h=>hij (hell h) + rcases lt_or_gt_of_ne hne with hlt|hgt + · filter_upwards [annular_power_separation (a j) (b i) (ell i) (ell j) (ha j) hlt, + eventually_gt_atTop (0:ℝ)] with Z hsep hZ _ + apply Finset.disjoint_left.mpr + intro P hPi hPj + have hi := pool_norm_bounds C S (ha i).le (hab i) (Real.rpow_pos_of_pos hZ _) P hPi + have hj := pool_norm_bounds C S (ha j).le (hab j) (Real.rpow_pos_of_pos hZ _) P hPj + nlinarith + · filter_upwards [annular_power_separation (a i) (b j) (ell j) (ell i) (ha i) hgt, + eventually_gt_atTop (0:ℝ)] with Z hsep hZ _ + apply Finset.disjoint_left.mpr + intro P hPi hPj + have hi := pool_norm_bounds C S (ha i).le (hab i) (Real.rpow_pos_of_pos hZ _) P hPi + have hj := pool_norm_bounds C S (ha j).le (hab j) (Real.rpow_pos_of_pos hZ _) P hPj + nlinarith + +theorem power_pool_tuples_eventually_injective {ι : Type*} [Fintype ι] + (C : Set Id) (S : Finset Id) (a b ell : ι→ℝ) + (ha : ∀i,0(P i).val) := by + filter_upwards [power_pools_eventually_disjoint C S a b ell ha hab hell] with Z hZ P + intro i j heq + by_contra hn + have hq : (P i).val=(P j).val := heq + exact Finset.disjoint_left.mp (hZ i j hn) (P i).property (by rw [hq];exact (P j).property) +end SevenEighths.ProbeRaySlots +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RayPoolGood.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RayPoolGood.lean new file mode 100644 index 0000000000000000000000000000000000000000..5427114fc2368ce04ed748b66818efbb37368491 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RayPoolGood.lean @@ -0,0 +1,51 @@ +import OAI.NumberTheory.DirichletL.Detector.RaySlots + +namespace OAI + +noncomputable section +open scoped Classical Topology +open Filter +namespace SevenEighths.ProbeRaySlots +open HeckeFamily ProbePhysical CanonicalQuadraticSieve PrincipalSignalComparison +local notation "Id" => Ideal HeckeFamily.O + +theorem prime_coprime_of_norm_gt (η : Character) (P : PrimeIdeal) + (hN : (η.modulus.absNorm:ℝ)<(P.val.absNorm:ℝ)) : IsCoprime P.val η.modulus := by + apply Ideal.coprime_of_no_prime_ge + intro J hPJ hηJ hJ + have hmax := (Ideal.isPrime_of_prime P.property).isMaximal P.property.ne_zero + have heq := hmax.eq_of_le hJ.ne_top hPJ + rw [←heq] at hηJ + have hd : P.val∣η.modulus := Ideal.dvd_iff_le.mpr hηJ + have hn := Nat.le_of_dvd (Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr η.modulus_ne_bot)) + (map_dvd Ideal.absNorm hd) + exact (not_le_of_gt hN) (by exact_mod_cast hn) + +theorem pool_eventually_target_coprime (C : Set Id) (S : Finset Id) (η : Character) + (a b : ℝ) (ha : 0 Ideal HeckeFamily.O + +theorem power_pool_thresholds {ι : Type*} [Fintype ι] + (C : Set Id) (S : Finset Id) (η : Character) (c d ellMin : ℝ) + (hc : 01440*(c*Z^ellMin)^(-(7/8:ℝ))) atTop (nhds 0) := by + simpa only [mul_zero,Function.comp_def] using ((tendsto_rpow_neg_atTop (by norm_num : (0:ℝ)<7/8)).comp ht).const_mul (1440:ℝ) + filter_upwards [eventually_ge_atTop (1:ℝ),ht.eventually (eventually_ge_atTop (480:ℝ)), + ht.eventually (eventually_gt_atTop (η.modulus.absNorm:ℝ)), + hs.eventually (eventually_lt_nhds (by norm_num : (0:ℝ)<1))] with Z hZ h480 hmod hsmall + have hZ0 : 0⟨h480.trans (hmono j),hmod.trans_le (hmono j)⟩,?_⟩ + intro j P hP + have hp := pool_norm_bounds C S hc.le hd (Real.rpow_pos_of_pos hZ0 _) P hP + have hn : c*Z^ellMin<(P.val.absNorm:ℝ) := (hmono j).trans_lt (by simpa only [mul_comm] using hp.1) + exact ⟨hn.le,prime_coprime_of_norm_gt η P (hmod.trans hn),(mem_pool C S c d _ P).mp hP |>.2.2.2⟩ + +variable (M : Id) [NeZero M] +local instance : Finite (HeckeFamily.O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (HeckeFamily.O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) +include hH + +theorem power_ray_mass_and_normalizer {ι : Type*} [Fintype ι] + (S : Finset Id) (W : ι→ℝ→ℝ) (c d : ℝ) (hc : 0pool (RayQuotient.identityClass M H) S c d (Z^(ell j)) + (∀j,0Z^(ell j))) j) ∧ + |(Probe.principalScalar Finset.univ Z (∑j,ell j) + (slotMass T (residueWeights W (fun j=>Z^(ell j)))))⁻¹|≤Z^eps := by + have hm : ∀ᶠZ : ℝ in atTop,∀j,0pool (RayQuotient.identityClass M H) S c d (Z^(ell j))) + (residueWeights W (fun j=>Z^(ell j))) j := by + apply Filter.eventually_all.mpr + intro j + exact (tendsto_rpow_atTop (hell j)).eventually + (ray_pool_mass_eventually_positive M H hH S (W j) c d hc hd (hsupp j) + (hW j) (hcompact j) (hp j) (hW0 j) (hne j)) + have hi := ProbeRayNormalization.ray_principalScalar_inverse_subpower M H hH Finset.univ S W + (fun _=>c) (fun _=>d) ell (fun _ _=>hc) (fun _ _=>hd) (fun j _=>hsupp j) + (fun j _=>hW j) (fun j _=>hcompact j) (fun j _=>hp j) (fun j _=>hW0 j) (fun j _=>hne j) + (fun j _=>hell j) eps heps + filter_upwards [hm,hi] with Z hmass hinv + exact ⟨hmass,hinv⟩ +end SevenEighths.ProbeRaySlots +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RaySlots.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RaySlots.lean new file mode 100644 index 0000000000000000000000000000000000000000..6f4d2da063a01b75960fe2fc38751d8b712120f9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RaySlots.lean @@ -0,0 +1,84 @@ +import OAI.NumberTheory.DirichletL.RayPrimeNormalizer +import OAI.NumberTheory.DirichletL.Detector.PrincipalResidueActual + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ContDiff +open Filter +namespace SevenEighths.ProbeRaySlots +open HeckeFamily ProbePhysical PNT.AnnularPrimeMass +open PrincipalSignalComparison ProbePrincipalResidueActual +local notation "Id" => Ideal HeckeFamily.O + +def pool (C : Set Id) (S : Finset Id) (a b x : ℝ) : Finset PrimeIdeal := + (annularPrimeIdeals C a b x \ S).subtype (fun P=>Prime P) + +@[simp] theorem mem_pool (C : Set Id) (S : Finset Id) (a b x : ℝ) (P : PrimeIdeal) : + P∈pool C S a b x ↔ P.val∈C ∧ ⌊x*a⌋₊P.val) + · intro P hP + exact Finset.mem_subtype.mp hP + · intro P hP Q hQ he + exact Subtype.ext he + · intro P hP + have hp : Prime P := ((mem_annularPrimeIdeals C a b x P).mp (Finset.mem_sdiff.mp hP).1).2.1 + exact ⟨⟨P,hp⟩,Finset.mem_subtype.mpr hP,rfl⟩ + · intro P hP + rfl + +theorem pool_mass_eq_deleted (C : Set Id) (S : Finset Id) (W : ℝ→ℝ) + {a b x : ℝ} (ha : 0W ((Ideal.absNorm P:ℝ)/x)*(Ideal.absNorm P:ℝ)^(-(5/6:ℝ))), + weightedPrimeSumDeleted_eq_annular C S W ha hab hsupp hx] + norm_num + +variable (M : Id) [NeZero M] +local instance : Finite (HeckeFamily.O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (HeckeFamily.O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +include hH + +theorem ray_pool_mass_eventually_positive (S : Finset Id) (W : ℝ→ℝ) + (a b : ℝ) (ha : 0 ActualEisensteinCubic.O + +def reciprocityCoefficient (A s : O) (hA : A≠0) (H : O) : ℂ := + reciprocitySign A s * bareCongruenceCoefficient A s hA H + +theorem reciprocityCoefficient_product (A B s r : O) + (hA : Supported (Ideal.span {A})) (hB : Supported (Ideal.span {B})) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hpA : goodLambda^2∣A-1) (hpB : goodLambda^2∣B-1) + (hps : goodLambda^2∣s-1) (hpr : goodLambda^2∣r-1) + (hcop : IsCoprime (A*s) (B*r)) (H : O) : + reciprocityCoefficient (A*B) (s*r) + (mul_ne_zero (supportedElement_ne_zero A hA) (supportedElement_ne_zero B hB)) H = + (idealRowHom B (Ideal.span {A}) * idealRowHom A (Ideal.span {B})) * + reciprocityCoefficient A s (supportedElement_ne_zero A hA) H * + reciprocityCoefficient B r (supportedElement_ne_zero B hB) H := by + have hsB := idealRowHom_ne_zero_of_coprime s B hs hcop.of_mul_left_right.of_mul_right_left + have hrA := idealRowHom_ne_zero_of_coprime r A hr hcop.of_mul_left_left.of_mul_right_right.symm + have hAr : idealRowHom r (Ideal.span {A}) = reciprocitySign A r * idealRowHom A (Ideal.span {r}) := + idealRowHom_primary_reciprocity A r hpA hpr hA hr + have hBs : idealRowHom s (Ideal.span {B}) = reciprocitySign B s * idealRowHom B (Ideal.span {s}) := + idealRowHom_primary_reciprocity B s hpB hps hB hs + have hratio : + (idealRowHom B (Ideal.span {A}) * idealRowHom r (Ideal.span {A}) * + idealRowHom A (Ideal.span {B}) * idealRowHom s (Ideal.span {B})) / + (idealRowHom B (Ideal.span {s}) * idealRowHom A (Ideal.span {r})) = + (idealRowHom B (Ideal.span {A}) * idealRowHom A (Ideal.span {B})) * + reciprocitySign A r * reciprocitySign B s := by + rw [hAr, hBs] + field_simp + have hsign : reciprocitySign (A*B) (s*r) * reciprocitySign A r * reciprocitySign B s = + reciprocitySign A s * reciprocitySign B r := by + calc + _ = reciprocitySign A s * reciprocitySign B r * + reciprocitySign A r ^ 2 * reciprocitySign B s ^ 2 := by + simp only [reciprocitySign_mul_left, reciprocitySign_mul_right] + ring + _ = _ := by + rw [reciprocitySign_sq A r (supported_residue_odd A hA) (supported_residue_odd r hr), + reciprocitySign_sq B s (supported_residue_odd B hB) (supported_residue_odd s hs), + mul_one, mul_one] + unfold reciprocityCoefficient + rw [bareCongruenceCoefficient_product_reduced A B s r (supportedElement_ne_zero A hA) + (supportedElement_ne_zero B hB) hs hr hcop H, hratio] + calc + _ = (reciprocitySign (A*B) (s*r) * reciprocitySign A r * reciprocitySign B s) * + (idealRowHom B (Ideal.span {A}) * idealRowHom A (Ideal.span {B})) * + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H * + bareCongruenceCoefficient B r (supportedElement_ne_zero B hB) H := by ring + _ = _ := by rw [hsign]; ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Row.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Row.lean new file mode 100644 index 0000000000000000000000000000000000000000..d4faf3e78ce4a3bedf58665009d12cbc8c3196cf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Row.lean @@ -0,0 +1,101 @@ +import OAI.NumberTheory.DirichletL.Foundation +import OAI.NumberTheory.DirichletL.Hecke.Family +import OAI.NumberTheory.DirichletL.Detector.Completed + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +namespace SevenEighths.ProbeRow +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +open CanonicalQuadraticSieve InitialMeanSquare ProbeCompleted + +local notation "O" => ActualEisensteinCubic.O + +def targetMonoid (η : HeckeFamily.Character) : O →* ℂ where + toFun := HeckeFamily.elementCoeff η + map_one' := HeckeFamily.elementCoeff_one η + map_mul' := HeckeFamily.elementCoeff_mul η + +theorem targetMonoid_norm_le_one (η : HeckeFamily.Character) (a : O) : + ‖targetMonoid η a‖ ≤ 1 := by + let : Finite (O ⧸ η.modulus) := Ring.HasFiniteQuotients.finiteQuotient η.modulus_ne_bot + let : Fintype (O ⧸ η.modulus) := Fintype.ofFinite _ + exact FiniteRayExpansion.norm_char_le_one η.residue (Ideal.Quotient.mk η.modulus a) + +def rowCoefficient (η : HeckeFamily.Character) (Xi : O →* ℂ) + (s : O) (hs : Supported (Ideal.span {s})) (m : O) : O →* ℂ := + targetMonoid η * conjugateMonoid Xi * reciprocityPhaseMonoid s hs * + (idealRowHom m).toMonoidHom.comp principalIdealHom.toMonoidHom + +theorem rowCoefficient_apply (η : HeckeFamily.Character) (Xi : O →* ℂ) + (s : O) (hs : Supported (Ideal.span {s})) (m a : O) : + rowCoefficient η Xi s hs m a = HeckeFamily.elementCoeff η a * star (Xi a) * + sexticReciprocityPhase s a * idealRowHom m (Ideal.span {a}) := rfl + +theorem rowCoefficient_apply_unit (η : HeckeFamily.Character) (Xi : O →* ℂ) + (s : O) (hs : Supported (Ideal.span {s})) (m a : O) (hXi : ‖Xi a‖ = 1) : + rowCoefficient η Xi s hs m a = HeckeFamily.elementCoeff η a * (Xi a)⁻¹ * + sexticReciprocityPhase a s * idealRowHom m (Ideal.span {a}) := by + rw [rowCoefficient_apply] + have hc : star (Xi a) = (Xi a)⁻¹ := (Complex.inv_eq_conj hXi).symm + have hsym : sexticReciprocityPhase s a = sexticReciprocityPhase a s := by + simp only [sexticReciprocityPhase, QuadraticAllOddCRT.quadraticRaySign_symm] + rw [hc, hsym] + +theorem rowCoefficient_norm_le_one (η : HeckeFamily.Character) (Xi : O →* ℂ) + (hXi : ∀ a, ‖Xi a‖ ≤ 1) (s : O) (hs : Supported (Ideal.span {s})) (m a : O) : + ‖rowCoefficient η Xi s hs m a‖ ≤ 1 := by + rw [rowCoefficient_apply] + simp only [norm_mul, norm_star] + refine (mul_le_of_le_one_left (norm_nonneg _) ?_).trans (idealRowHom_norm _ _) + refine (mul_le_of_le_one_left (norm_nonneg _) ?_).trans (sexticReciprocityPhase_norm _ _) + exact (mul_le_of_le_one_left (norm_nonneg _) (targetMonoid_norm_le_one η a)).trans (hXi a) + +def spectralSummand (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (t : ℂ) (I J : Ideal O) : ℂ := + (completedMask S D I J * completedCorrection I J * + (columnWeight Ψ I / (Real.sqrt (Ideal.absNorm I) : ℂ)) * cubeWeight Ψ J) * + (CubicEisenstein.fullIdealWeight t I * CubicEisenstein.fullIdealWeight (3 * t) J) + +def spectralRow (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) (t : ℂ) : ℂ := + ∑' p : Ideal O × Ideal O, spectralSummand S D Ψ t p.1 p.2 + +theorem spectralSummand_norm_le (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (t : ℂ) (I J : Ideal O) : + ‖spectralSummand S D Ψ t I J‖ ≤ + 2 * (‖CubicEisenstein.fullIdealWeight t I‖ * + ‖CubicEisenstein.fullIdealWeight (3 * t) J‖) := by + have hmc : ‖completedMask S D I J * completedCorrection I J‖ ≤ 2 := by + rw [norm_mul] + exact (mul_le_mul (completedMask_norm_le_one S D I J) + (completedCorrection_norm_le_two I J) (norm_nonneg _) (by norm_num)).trans_eq (by norm_num) + have hcol := columnWeight_div_sqrt_norm_le_one Ψ hΨ I + have hcube := cubeWeight_norm_le_one Ψ hΨ J + have hc : ‖completedMask S D I J * completedCorrection I J * + (columnWeight Ψ I / (Real.sqrt (Ideal.absNorm I) : ℂ)) * cubeWeight Ψ J‖ ≤ 2 := by + rw [norm_mul, norm_mul] + exact (mul_le_of_le_one_right (mul_nonneg (norm_nonneg _) (norm_nonneg _)) hcube).trans + ((mul_le_of_le_one_right (norm_nonneg _) hcol).trans hmc) + unfold spectralSummand + simpa only [norm_mul] using mul_le_mul_of_nonneg_right hc (mul_nonneg + (norm_nonneg (CubicEisenstein.fullIdealWeight t I)) + (norm_nonneg (CubicEisenstein.fullIdealWeight (3 * t) J))) + +theorem spectralRow_summable (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (t : ℂ) (ht : 1 < t.re) : + Summable (fun p : Ideal O × Ideal O => spectralSummand S D Ψ t p.1 p.2) := by + have ht3 : 1 < (3 * t).re := by + norm_num [Complex.mul_re] + linarith + have h1 := CubicEisenstein.fullIdealWeight_summable_norm t ht + have h3 := CubicEisenstein.fullIdealWeight_summable_norm (3 * t) ht3 + apply Summable.of_norm + exact Summable.of_nonneg_of_le (fun _ => norm_nonneg _) + (fun p => spectralSummand_norm_le S D Ψ hΨ t p.1 p.2) + ((h1.mul_of_nonneg h3 (fun _ => norm_nonneg _) (fun _ => norm_nonneg _)).mul_left 2) + +end SevenEighths.ProbeRow +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RowAnalytic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RowAnalytic.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e1d2ab36cda0ae412c116a925fccf07090650e6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RowAnalytic.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Detector.Row +import Mathlib.Analysis.Normed.Group.FunctionSeries +import Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +open MeasureTheory +namespace SevenEighths.ProbeRow +open ActualEisensteinCubic CompletedGauss CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem fullIdealWeight_norm_eq_of_re (s t : ℂ) (h : s.re = t.re) (I : Ideal O) : + ‖fullIdealWeight s I‖ = ‖fullIdealWeight t I‖ := by + by_cases hI : I = 0 + · simp [hI, fullIdealWeight] + · exact (norm_fullIdealWeight s ⟨I, hI⟩).trans + ((by rw [h] : _ = _).trans (norm_fullIdealWeight t ⟨I, hI⟩).symm) + +theorem fullIdealWeight_continuous (I : Ideal O) : Continuous (fun t => fullIdealWeight t I) := by + by_cases hI : I = 0 + · simp only [hI, fullIdealWeight] + exact continuous_const + · have hn : (Ideal.absNorm I : ℂ) ≠ 0 := by + exact_mod_cast (Ideal.absNorm_ne_zero_iff I).mpr + (Ring.HasFiniteQuotients.finiteQuotient hI) + simp only [fullIdealWeight, ite_eq_right hI] + exact continuous_id.neg.const_cpow (Or.inl hn) + +def rowMajorant (σ : ℝ) (p : Ideal O × Ideal O) : ℝ := + 2 * (‖fullIdealWeight (σ : ℂ) p.1‖ * ‖fullIdealWeight (3 * (σ : ℂ)) p.2‖) + +theorem rowMajorant_summable (σ : ℝ) (hσ : 1 < σ) : Summable (rowMajorant σ) := by + have h3 : 1 < (3 * (σ : ℂ)).re := by norm_num; linarith + exact ((fullIdealWeight_summable_norm (σ : ℂ) hσ).mul_of_nonneg + (fullIdealWeight_summable_norm (3 * (σ : ℂ)) h3) + (fun _ => norm_nonneg _) (fun _ => norm_nonneg _)).mul_left 2 + +theorem spectralSummand_vertical_bound (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (σ y : ℝ) (p : Ideal O × Ideal O) : + ‖spectralSummand S D Ψ ((σ : ℂ) + y * Complex.I) p.1 p.2‖ ≤ rowMajorant σ p := by + have h1 : ((σ : ℂ) + y * Complex.I).re = (σ : ℂ).re := by simp + have h3 : (3 * ((σ : ℂ) + y * Complex.I)).re = (3 * (σ : ℂ)).re := by simp + simpa only [rowMajorant, fullIdealWeight_norm_eq_of_re _ _ h1, + fullIdealWeight_norm_eq_of_re _ _ h3] using + spectralSummand_norm_le S D Ψ hΨ ((σ : ℂ) + y * Complex.I) p.1 p.2 + +theorem spectralRow_continuous_vertical (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (σ : ℝ) (hσ : 1 < σ) : + Continuous (fun y : ℝ => spectralRow S D Ψ ((σ : ℂ) + y * Complex.I)) := by + apply continuous_tsum _ (rowMajorant_summable σ hσ) + (fun p y => spectralSummand_vertical_bound S D Ψ hΨ σ y p) + intro p + have hc : Continuous (fun y : ℝ => (σ : ℂ) + y * Complex.I) := by fun_prop + exact continuous_const.mul ((fullIdealWeight_continuous p.1).comp hc |>.mul + ((fullIdealWeight_continuous p.2).comp (continuous_const.mul hc))) + +theorem spectralRow_vertical_bound (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (σ : ℝ) (hσ : 1 < σ) (y : ℝ) : + ‖spectralRow S D Ψ ((σ : ℂ) + y * Complex.I)‖ ≤ ∑' p, rowMajorant σ p := by + have hs := spectralRow_summable S D Ψ hΨ ((σ : ℂ) + y * Complex.I) (by simpa using hσ) + exact (norm_tsum_le_tsum_norm hs.norm).trans + (hs.norm.tsum_le_tsum (fun p => spectralSummand_vertical_bound S D Ψ hΨ σ y p) + (rowMajorant_summable σ hσ)) + +theorem verticalKernel_norm (Z : ℝ) (hZ : 0 < Z) (σ y : ℝ) : + ‖(Z : ℂ) ^ ((σ : ℂ) + y * Complex.I) * + Complex.exp (((σ : ℂ) + y * Complex.I) ^ 2)‖ = + Z ^ σ * Real.exp (σ ^ 2) * Real.exp (-1 * y ^ 2) := by + rw [norm_mul, Complex.norm_cpow_eq_rpow_re_of_pos hZ, Complex.norm_exp] + have hre : (((σ : ℂ) + y * Complex.I) ^ 2).re = σ ^ 2 + (-1 * y ^ 2) := by + simp [pow_two, Complex.mul_re, Complex.mul_im] + ring + rw [hre, Real.exp_add] + simp only [Complex.add_re, Complex.ofReal_re, Complex.mul_re, + Complex.ofReal_im, Complex.I_re, Complex.I_im, mul_zero, zero_mul, sub_zero, add_zero] + ring + +theorem spectralRow_vertical_integrable (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (σ : ℝ) (hσ : 1 < σ) + (Z : ℝ) (hZ : 0 < Z) : + Integrable (fun y : ℝ => (Z : ℂ) ^ ((σ : ℂ) + y * Complex.I) * + Complex.exp (((σ : ℂ) + y * Complex.I) ^ 2) * + spectralRow S D Ψ ((σ : ℂ) + y * Complex.I)) := by + let B : ℝ := ∑' p, rowMajorant σ p + have hg := (integrable_exp_neg_mul_sq (b := 1) (by norm_num)).const_mul + (Z ^ σ * Real.exp (σ ^ 2) * B) + have hc : Continuous (fun y : ℝ => (σ : ℂ) + y * Complex.I) := by fun_prop + have hk := (hc.const_cpow (Or.inl (Complex.ofReal_ne_zero.mpr hZ.ne'))).mul ((hc.pow 2).cexp) + apply hg.mono' (hk.mul (spectralRow_continuous_vertical S D Ψ hΨ σ hσ)).aestronglyMeasurable + apply Filter.Eventually.of_forall + intro y + dsimp only [Pi.mul_apply, Pi.pow_apply] + rw [norm_mul, verticalKernel_norm Z hZ σ y] + calc + _ ≤ (Z ^ σ * Real.exp (σ ^ 2) * Real.exp (-1 * y ^ 2)) * B := + mul_le_mul_of_nonneg_left (spectralRow_vertical_bound S D Ψ hΨ σ hσ y) + (mul_nonneg (mul_nonneg (Real.rpow_nonneg hZ.le _) (Real.exp_pos _).le) (Real.exp_pos _).le) + _ = _ := by ring + +end SevenEighths.ProbeRow +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RowInterchange.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RowInterchange.lean new file mode 100644 index 0000000000000000000000000000000000000000..5d703cb7d55802241dcef8df8b35854ae9c84fb9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RowInterchange.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Detector.RowAnalytic + +namespace OAI + +noncomputable section +open scoped BigOperators Classical +open MeasureTheory +namespace SevenEighths.ProbeRow +open ActualEisensteinCubic CompletedGauss CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem spectralSummand_norm_eq_of_re (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (s t : ℂ) (h : s.re = t.re) (I J : Ideal O) : + ‖spectralSummand S D Ψ s I J‖ = ‖spectralSummand S D Ψ t I J‖ := by + have h3 : (3 * s).re = (3 * t).re := by simp [Complex.mul_re, h] + simp only [spectralSummand, norm_mul, fullIdealWeight_norm_eq_of_re _ _ h, + fullIdealWeight_norm_eq_of_re _ _ h3] + +def mellinSummand (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (σ Z : ℝ) (p : Ideal O × Ideal O) (y : ℝ) : ℂ := + (Z : ℂ) ^ ((σ : ℂ) + y * Complex.I) * Complex.exp (((σ : ℂ) + y * Complex.I) ^ 2) * + spectralSummand S D Ψ ((σ : ℂ) + y * Complex.I) p.1 p.2 + +theorem mellinSummand_norm (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (σ Z : ℝ) (hZ : 0 < Z) (p : Ideal O × Ideal O) (y : ℝ) : + ‖mellinSummand S D Ψ σ Z p y‖ = + (Z ^ σ * Real.exp (σ ^ 2) * ‖spectralSummand S D Ψ (σ : ℂ) p.1 p.2‖) * + Real.exp (-1 * y ^ 2) := by + unfold mellinSummand + rw [norm_mul, verticalKernel_norm Z hZ σ y, + spectralSummand_norm_eq_of_re S D Ψ _ (σ : ℂ) (by simp)] + ring + +theorem mellinSummand_integrable (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (σ Z : ℝ) (hZ : 0 < Z) (p : Ideal O × Ideal O) : + Integrable (mellinSummand S D Ψ σ Z p) := by + have hc : Continuous (fun y : ℝ => (σ : ℂ) + y * Complex.I) := by fun_prop + have ht : Continuous (fun y : ℝ => spectralSummand S D Ψ + ((σ : ℂ) + y * Complex.I) p.1 p.2) := + continuous_const.mul ((fullIdealWeight_continuous p.1).comp hc |>.mul + ((fullIdealWeight_continuous p.2).comp (continuous_const.mul hc))) + have hk := (hc.const_cpow (Or.inl (Complex.ofReal_ne_zero.mpr hZ.ne'))).mul ((hc.pow 2).cexp) + apply ((integrable_exp_neg_mul_sq (b := 1) (by norm_num)).const_mul + (Z ^ σ * Real.exp (σ ^ 2) * ‖spectralSummand S D Ψ (σ : ℂ) p.1 p.2‖)).mono' + (hk.mul ht).aestronglyMeasurable + exact Filter.Eventually.of_forall (fun y => (mellinSummand_norm S D Ψ σ Z hZ p y).le) + +theorem mellinSummand_integral_norm (S : Finset (Ideal O)) (D : Ideal O) (Ψ : O →* ℂ) + (σ Z : ℝ) (hZ : 0 < Z) (p : Ideal O × Ideal O) : + (∫ y : ℝ, ‖mellinSummand S D Ψ σ Z p y‖) = + ‖spectralSummand S D Ψ (σ : ℂ) p.1 p.2‖ * + (Z ^ σ * Real.exp (σ ^ 2) * ∫ y : ℝ, Real.exp (-1 * y ^ 2)) := by + simp only [mellinSummand_norm S D Ψ σ Z hZ, integral_const_mul] + ring + +theorem spectralRow_integral_eq_tsum (S : Finset (Ideal O)) (D : Ideal O) + (Ψ : O →* ℂ) (hΨ : ∀ a, ‖Ψ a‖ ≤ 1) (σ : ℝ) (hσ : 1 < σ) + (Z : ℝ) (hZ : 0 < Z) : + (∫ y : ℝ, (Z : ℂ) ^ ((σ : ℂ) + y * Complex.I) * + Complex.exp (((σ : ℂ) + y * Complex.I) ^ 2) * + spectralRow S D Ψ ((σ : ℂ) + y * Complex.I)) = + ∑' p, ∫ y : ℝ, mellinSummand S D Ψ σ Z p y := by + let : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable + let : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable + have hs : Summable (fun p => ∫ y : ℝ, ‖mellinSummand S D Ψ σ Z p y‖) := by + simp only [mellinSummand_integral_norm S D Ψ σ Z hZ] + exact (spectralRow_summable S D Ψ hΨ (σ : ℂ) hσ).norm.mul_right _ + rw [integral_tsum_of_summable_integral_norm + (fun p => mellinSummand_integrable S D Ψ σ Z hZ p) hs] + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro y + simp only [mellinSummand, tsum_mul_left, spectralRow] + +end SevenEighths.ProbeRow +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RowRadicalConductor.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RowRadicalConductor.lean new file mode 100644 index 0000000000000000000000000000000000000000..fa2eb0ae148af1aeef41ed3a68ff2fcdf781aedc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RowRadicalConductor.lean @@ -0,0 +1,408 @@ +import OAI.NumberTheory.DirichletL.PrimeRows.Conductor +import OAI.NumberTheory.DirichletL.Hecke.LocalRamification + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeRowRadicalConductor +open HeckeFamily HeckeRowClosure CanonicalRowCompletion CanonicalQuadraticSieve +open UniqueFactorizationMonoid +local notation "O" => HeckeFamily.O +local notation "λ₀" => ConcretePrimeRowBridge.goodLambda + +theorem canonicalPrimePower_descent (P : Ideal O) [P.IsMaximal] + (hg : λ₀ ∉ P) {c : ℕ} (hc : 1 ≤ c) (x : O ⧸ P ^ c) : + CenteredMomentCanonical.canonicalPrimePowerCharacter P hg hc x = + (CompletedGauss.actualSextic P hg ^ c) + (CenteredMomentCorrelation.primePowerReduction P hc x) := rfl + +theorem idealRowHom_congr_radical (I : Ideal O) (x y : O) + (hxy : x-y ∈ I.radical) : idealRowHom x I = idealRowHom y I := by + by_cases hI : I = 0 + · subst I + simp only [map_zero] + change (if I=0 then 0 else _) = (if I=0 then 0 else _) + rw [ite_eq_right hI, ite_eq_right hI] + congr 1 + apply Multiset.map_congr rfl + intro P hP + have hp := Ideal.isPrime_of_prime (prime_of_normalized_factor P hP) + have hle : I.radical ≤ P := hp.radical_le_iff.mpr + (((Ideal.mem_normalizedFactors_iff hI).mp hP).2) + unfold localRowValue + split_ifs with hg + · let : P.IsMaximal := hg.1 + congr 1 + exact Ideal.Quotient.eq.mpr (hle hxy) + · rfl + +theorem radical_ne_bot (I : Ideal O) (hI : I ≠ ⊥) : I.radical ≠ ⊥ := by + intro h + exact hI (bot_unique (h ▸ I.le_radical)) + +theorem movingNumeratorRow_radical_periodic (r : O) + (hr : Supported (Ideal.span {r})) : + CanonicalCoefficientClass.FactorsModulo (Ideal.span {r}).radical + (movingNumeratorRow r hr) := idealRowHom_congr_radical _ + +theorem actualPeriodicRow_radical_periodic (Ψ : O →* ℂ) (Q : Ideal O) + (hΨ : CanonicalCoefficientClass.FactorsModulo Q Ψ) + (m : O) (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) : + CanonicalCoefficientClass.FactorsModulo + (Q * Ideal.span {m} * Ideal.span {(72 : O)} * (Ideal.span {r}).radical) + (actualPeriodicRow Ψ m u a b r hr) := by + intro x y hxy + have hQ : x-y ∈ Q := Ideal.mul_le_left (Ideal.mul_le_left (Ideal.mul_le_left hxy)) + have hm : x-y ∈ Ideal.span {m} := Ideal.mul_le_right (Ideal.mul_le_left (Ideal.mul_le_left hxy)) + have h72 : x-y ∈ Ideal.span {(72 : O)} := Ideal.mul_le_right (Ideal.mul_le_left hxy) + have hrxy : x-y ∈ (Ideal.span {r}).radical := Ideal.mul_le_right hxy + change ((Ψ x * coprimalityMask m x) * numeratorBadTwist u a b r hr x) * + movingNumeratorRow r hr x = + ((Ψ y * coprimalityMask m y) * numeratorBadTwist u a b r hr y) * + movingNumeratorRow r hr y + rw [hΨ x y hQ, coprimalityMask_periodic m x y hm, + numeratorBadTwist_periodic u a b r hr x y h72, + movingNumeratorRow_radical_periodic r hr x y hrxy] + +theorem rowTwist_radical_periodic (η : Character) (m f z : O) + (hmLam : λ₀ ∣ m) (hm2 : (2 : O) ∣ m) + (u : Oˣ) (a b : ℕ) (r : O) (hr : Supported (Ideal.span {r})) + (hpr : λ₀ ^ 2 ∣ r-1) (hx : f^4*z = (u : O)*λ₀^a*(2 : O)^b*r) : + CanonicalCoefficientClass.FactorsModulo + (η.modulus * Ideal.span {m} * Ideal.span {(72 : O)} * (Ideal.span {r}).radical) + (rowTwist (elementHom η) m f z) := by + refine periodic_of_primary _ ?_ _ (actualPeriodicRow (elementHom η) m u a b r hr) + (actualPeriodicRow_radical_periodic _ _ (elementHom_periodic η) _ _ _ _ _ hr) + (rowTwist_unit_mul η m f z) ?_ ?_ + · have hd3 : λ₀ ^ 2 ∣ (3 : O) := ActualEisensteinCubic.lambda_sq_dvd_three + have hd72 : λ₀ ^ 2 ∣ (72 : O) := hd3.trans ⟨24, by norm_num⟩ + exact (Ideal.mul_le_left.trans Ideal.mul_le_right).trans + ((Ideal.span_singleton_le_iff_mem _).mpr (Ideal.mem_span_singleton.mpr hd72)) + · intro n hn + apply rowTwist_zero_of_not_supported _ _ _ _ _ hmLam hm2 + intro hs + exact ((supported_span_iff n).mp hs).1 hn + · exact rowTwist_eq_actualPeriodicRow_primary _ _ _ _ hmLam hm2 u a b r hr hpr hx + +theorem rowTwist_nonzero_radical_unit (η : Character) (m f z n : O) + (hmLam : λ₀ ∣ m) (hm2 : (2 : O) ∣ m) + (u : Oˣ) (a b : ℕ) (r : O) + (hx : f^4*z = (u : O)*λ₀^a*(2 : O)^b*r) + (hn : rowTwist (elementHom η) m f z n ≠ 0) : + IsUnit (Ideal.Quotient.mk + (η.modulus * Ideal.span {m} * Ideal.span {(72 : O)} * (Ideal.span {r}).radical) n) := by + have hu := rowTwist_nonzero_unit η m f z n hmLam hm2 u a b r hx hn + have hle : η.modulus * Ideal.span {m} * Ideal.span {(72 : O)} * Ideal.span {r} ≤ + η.modulus * Ideal.span {m} * Ideal.span {(72 : O)} * (Ideal.span {r}).radical := + Ideal.mul_mono_right (Ideal.span {r}).le_radical + exact hu.map (Ideal.Quotient.factor hle) + +theorem exists_row_character_radical (η : Character) (m f z : O) + (hm : m ≠ 0) (hf : f ≠ 0) (hz : z ≠ 0) + (hmLam : λ₀ ∣ m) (hm2 : (2 : O) ∣ m) : + ∃ χ : Character, + χ.modulus.absNorm ≤ η.modulus.absNorm * (Ideal.span {m}).absNorm * + (Ideal.span {(72 : O)}).absNorm * (Ideal.span {f^4*z}).radical.absNorm ∧ + ∀ n : O, elementCoeff χ n = rowTwist (elementHom η) m f z n := by + obtain ⟨u, a, b, r, hr, hpr, hx, _, _, _, _⟩ := + exists_actual_periodic_row (elementHom η) η.modulus η.modulus_ne_bot + (elementHom_periodic η) (elementHom_norm η) m f z hm hf hz hmLam hm2 + change f^4*z = (u : O)*λ₀^a*(2 : O)^b*r at hx + let M := η.modulus * Ideal.span {m} * Ideal.span {(72 : O)} * (Ideal.span {r}).radical + have hM : M ≠ ⊥ := mul_ne_zero + (mul_ne_zero (mul_ne_zero η.modulus_ne_bot + (Ideal.span_singleton_eq_bot.not.mpr hm)) + (Ideal.span_singleton_eq_bot.not.mpr (by norm_num))) + (radical_ne_bot _ hr.1) + have hG := rowTwist_radical_periodic η m f z hmLam hm2 u a b r hr hpr hx + refine ⟨HeckeRowClosure.rowCharacter M hM _ hG (rowTwist_unit η m f z), ?_, ?_⟩ + · change M.absNorm ≤ _ + have hfr : Ideal.span {f^4*z} ≤ (Ideal.span {r} : Ideal O) := by + apply (Ideal.span_singleton_le_iff_mem _).mpr + exact Ideal.mem_span_singleton.mpr ⟨(u : O)*λ₀^a*(2 : O)^b, by rw [hx]; ring⟩ + have hF : (Ideal.span {f^4*z} : Ideal O).radical ≠ ⊥ := + radical_ne_bot _ (Ideal.span_singleton_eq_bot.not.mpr (mul_ne_zero (pow_ne_zero _ hf) hz)) + let : Finite (O ⧸ (Ideal.span {f^4*z} : Ideal O).radical) := + Ring.HasFiniteQuotients.finiteQuotient hF + have hn := FiniteConductor.absNorm_le_of_le (Ideal.radical_mono hfr) + simpa only [M, map_mul] using Nat.mul_le_mul_left + (η.modulus.absNorm * (Ideal.span {m}).absNorm * (Ideal.span {(72 : O)}).absNorm) hn + · intro n + rw [elementCoeff_rowCharacter] + split_ifs with hn + · rfl + · exact Eq.symm (not_not.mp (fun h => hn + (rowTwist_nonzero_radical_unit η m f z n hmLam hm2 u a b r hx h))) + +theorem periodic_sup (G : O →* ℂ) (I J : Ideal O) + (hI : CanonicalCoefficientClass.FactorsModulo I G) + (hJ : CanonicalCoefficientClass.FactorsModulo J G) : + CanonicalCoefficientClass.FactorsModulo (I ⊔ J) G := by + intro x y hxy + obtain ⟨a, ha, b, hb, hab⟩ := Submodule.mem_sup.mp hxy + calc + G x = G (x-a) := hI _ _ (by convert ha using 1; ring) + _ = G y := hJ _ _ (by convert hb using 1; linear_combination -hab) + +theorem primitive_of_equal_elements (χ θ : Character) + (hel : ∀ n : O, elementCoeff χ n = elementCoeff θ n) : + ∃ ψ : Character, χ.modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + ψ.modulus.absNorm ≤ θ.modulus.absNorm ∧ + ∀ I : Ideal O, idealCoeff χ I = + if IsCoprime I χ.modulus then idealCoeff ψ I else 0 := by + have hθ : CanonicalCoefficientClass.FactorsModulo θ.modulus (elementHom χ) := by + intro x y hxy + change elementCoeff χ x = elementCoeff χ y + rw [hel x, hel y] + exact elementHom_periodic θ x y hxy + let M := χ.modulus ⊔ θ.modulus + have hM : M ≠ ⊥ := fun h => χ.modulus_ne_bot (bot_unique (h ▸ le_sup_left)) + have hG := periodic_sup (elementHom χ) χ.modulus θ.modulus (elementHom_periodic χ) hθ + have hu : ∀ u : Oˣ, elementHom χ (u : O) = 1 := fun u => χ.unit_trivial u + let ρ := HeckeRowClosure.rowCharacter M hM (elementHom χ) hG hu + have hr (n : O) : elementCoeff ρ n = elementCoeff χ n := by + change elementCoeff (HeckeRowClosure.rowCharacter M hM _ hG hu) n = _ + rw [elementCoeff_rowCharacter] + split_ifs with hn + · rfl + · have hz : elementCoeff χ n = 0 := by + by_contra hne + have hu : IsUnit (Ideal.Quotient.mk χ.modulus n) := MulChar.apply_ne_zero_iff.mp hne + exact hn (hu.map (Ideal.Quotient.factor (show χ.modulus ≤ M from le_sup_left))) + exact hz.symm + obtain ⟨ψ, hψ, hp, hn, hmask⟩ := exists_primitive_character ρ + refine ⟨ψ, le_sup_left.trans hψ, hp, ?_, ?_⟩ + · let : Finite (O ⧸ θ.modulus) := Ring.HasFiniteQuotients.finiteQuotient θ.modulus_ne_bot + exact hn.trans (FiniteConductor.absNorm_le_of_le (show θ.modulus ≤ M from le_sup_right)) + · intro I + by_cases hI : I = 0 + · subst I + simp only [map_zero, ite_self] + let n := ConcretePrimeRowBridge.idealGenerator I + have hn0 : n ≠ 0 := ConcretePrimeRowBridge.idealGenerator_ne_zero I hI + have hs : Ideal.span {n} = I := ConcretePrimeRowBridge.span_idealGenerator I + have hre : idealCoeff ρ I = idealCoeff χ I := by + rw [← hs, idealCoeff_span _ hn0, idealCoeff_span _ hn0, hr] + by_cases hc : IsCoprime I χ.modulus + · have hu : IsUnit (Ideal.Quotient.mk χ.modulus n) := + (IdealCharacter.isUnit_mk_iff_isCoprime _ _).mpr (hs.symm ▸ hc) + have huM : IsUnit (Ideal.Quotient.mk M n) := + hu.map (Ideal.Quotient.factor (show χ.modulus ≤ M from le_sup_left)) + have hcM : IsCoprime I M := hs ▸ (IdealCharacter.isUnit_mk_iff_isCoprime _ _).mp huM + simpa only [hre, show ρ.modulus = M from rfl, hcM, hc, ite_true] using hmask I + · rw [ite_eq_right hc] + simpa only [hc, ite_false] using idealCoeff_source_mask χ I + +theorem rawRow_small_presentation (u : HeckeInverseAmplification.FreeRow) : + ∃ θ : Character, + θ.modulus.absNorm ≤ ProbeHighRowFamily.conductorConstant * + (Ideal.span {u.val} : Ideal O).radical.absNorm ∧ + ∀ n : O, elementCoeff (ProbeHighRowFamily.rawRow u) n = elementCoeff θ n := by + obtain ⟨θ, hn, he⟩ := exists_row_character_radical + (ProbePhysical.fixedSourcePrincipal ∅ (by simp)) ProbeHighRowFamily.rowMaskElement 1 u.val + ProbeHighRowFamily.rowMaskElement_ne_zero one_ne_zero u.property.1 + (dvd_mul_left _ _) (dvd_mul_right _ _) + refine ⟨θ, ?_, ?_⟩ + · simpa [ProbeHighRowFamily.conductorConstant, ProbePhysical.fixedSourcePrincipal, + HeckeRayFamily.character, Character.ofResidue] using hn + · intro n + have ho := (Classical.choose_spec + (exists_row_character_with_conductor (ProbePhysical.fixedSourcePrincipal ∅ (by simp)) + ProbeHighRowFamily.rowMaskElement 1 u.val ProbeHighRowFamily.rowMaskElement_ne_zero + one_ne_zero u.property.1 (dvd_mul_left _ _) (dvd_mul_right _ _))).2 n + exact ho.trans (he n).symm + +theorem rawRow_primitive_radical (u : HeckeInverseAmplification.FreeRow) : + ∃ ψ : Character, (ProbeHighRowFamily.rawRow u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + ψ.modulus.absNorm ≤ ProbeHighRowFamily.conductorConstant * + (Ideal.span {u.val} : Ideal O).radical.absNorm ∧ + ∀ I : Ideal O, idealCoeff (ProbeHighRowFamily.rawRow u) I = + if IsCoprime I (ProbeHighRowFamily.rawRow u).modulus then idealCoeff ψ I else 0 := by + obtain ⟨θ, hn, he⟩ := rawRow_small_presentation u + obtain ⟨ψ, hle, hp, hb, hmask⟩ := primitive_of_equal_elements _ θ he + exact ⟨ψ, hle, hp, hb.trans hn, hmask⟩ + +theorem equal_elements_excludePrimes (χ θ : Character) + (he : ∀ n : O, elementCoeff χ n = elementCoeff θ n) + (S : Finset (Ideal O)) (hS : ∀ P ∈ S, Prime P) (n : O) : + elementCoeff (χ.excludePrimes S hS) n = elementCoeff (θ.excludePrimes S hS) n := by + have hc : IsCoprime (Ideal.span {n}) χ.modulus ↔ IsCoprime (Ideal.span {n}) θ.modulus := by + have huχ : elementCoeff χ n ≠ 0 ↔ IsCoprime (Ideal.span {n}) χ.modulus := + MulChar.apply_ne_zero_iff.trans (IdealCharacter.isUnit_mk_iff_isCoprime _ _) + have huθ : elementCoeff θ n ≠ 0 ↔ IsCoprime (Ideal.span {n}) θ.modulus := + MulChar.apply_ne_zero_iff.trans (IdealCharacter.isUnit_mk_iff_isCoprime _ _) + rw [he n] at huχ + exact huχ.symm.trans huθ + simp only [Character.excludePrimes, elementCoeff_refineModulus, + IdealCharacter.isUnit_mk_iff_isCoprime, IsCoprime.mul_right_iff, hc, he n] + +def fixedConductorConstant (S : Finset (Ideal O)) : ℕ := + ProbeHighRowFamily.conductorConstant * (∏ P ∈ S, P).absNorm + +theorem rowCharacter_primitive_radical (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (u : HeckeInverseAmplification.FreeRow) : + ∃ ψ : Character, (ProbeHighRowFamily.rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + ψ.modulus.absNorm ≤ fixedConductorConstant S * + (Ideal.span {u.val} : Ideal O).radical.absNorm ∧ + ∀ I : Ideal O, idealCoeff (ProbeHighRowFamily.rowCharacter S hS u) I = + if IsCoprime I (ProbeHighRowFamily.rowCharacter S hS u).modulus + then idealCoeff ψ I else 0 := by + obtain ⟨θ, hn, he⟩ := rawRow_small_presentation u + obtain ⟨ψ, hle, hp, hb, hmask⟩ := primitive_of_equal_elements + (ProbeHighRowFamily.rowCharacter S hS u) (θ.excludePrimes S hS) + (equal_elements_excludePrimes _ θ he S hS) + refine ⟨ψ, hle, hp, hb.trans ?_, hmask⟩ + change (θ.modulus * ∏ P ∈ S, P).absNorm ≤ _ + rw [map_mul] + simpa only [fixedConductorConstant, mul_assoc, mul_comm, mul_left_comm] using + Nat.mul_le_mul_right ((∏ P ∈ S, P).absNorm) hn + +theorem prod_le_radical_prod_pow {ι : Type*} (T : Finset ι) + (P : ι → Ideal O) (e : ι → ℕ) (he : ∀ i ∈ T, 1 ≤ e i) : + (∏ i ∈ T, P i) ≤ (∏ i ∈ T, P i ^ e i).radical := by + induction T using Finset.induction_on with + | empty => simp + | @insert i T hi ih => + have hei : e i ≠ 0 := by have := he i (Finset.mem_insert_self i T); omega + have hpow : (P i ^ e i).radical = (P i).radical := Ideal.radical_pow (P i) hei + rw [Finset.prod_insert hi, Finset.prod_insert hi, Ideal.radical_mul, hpow] + exact Ideal.mul_le_inf.trans (inf_le_inf (P i).le_radical + (ih (fun j hj => he j (Finset.mem_insert_of_mem hj)))) + +theorem radical_norm_selected_deficit {ι : Type*} [Fintype ι] + (I : Ideal O) (hI : I ≠ 0) (P : ι → Ideal O) + (hP : ∀ i, Prime (P i)) (hdis : Function.Injective P) + (e : ι → ℕ) (he : ∀ i, 1 ≤ e i) (hdiv : ∀ i, P i ^ e i ∣ I) : + I.radical.absNorm * ∏ i, (P i).absNorm ^ (e i - 1) ≤ I.absNorm := by + let (i : ι) : (P i).IsMaximal := (Ideal.isPrime_of_prime (hP i)).isMaximal (hP i).ne_zero + have hcop : Pairwise (fun i j => IsCoprime (P i ^ e i) (P j ^ e j)) := by + intro i j hij + exact (Ideal.isCoprime_of_isMaximal (hdis.ne hij)).pow + obtain ⟨B, hB⟩ := Fintype.prod_dvd_of_coprime hcop hdiv + have hB0 : B ≠ 0 := by + intro hz + apply hI + rw [hB, hz, mul_zero] + have hsmall0 : (∏ i, P i) * B ≠ 0 := + mul_ne_zero (Finset.prod_ne_zero_iff.mpr (fun i _ => (hP i).ne_zero)) hB0 + have hsmall : (∏ i, P i) * B ≤ I.radical := by + rw [hB, Ideal.radical_mul] + exact Ideal.mul_le_inf.trans (inf_le_inf + (prod_le_radical_prod_pow Finset.univ P e (fun i _ => he i)) B.le_radical) + let : Finite (O ⧸ (∏ i, P i) * B) := Ring.HasFiniteQuotients.finiteQuotient hsmall0 + have hn := FiniteConductor.absNorm_le_of_le hsmall + have hprod : (∏ i, P i) * (∏ i, P i ^ (e i-1)) = ∏ i, P i ^ e i := by + rw [← Finset.prod_mul_distrib] + apply Finset.prod_congr rfl + intro i _ + rw [← pow_succ'] + congr 1 + exact Nat.sub_add_cancel (he i) + calc + I.radical.absNorm * ∏ i, (P i).absNorm ^ (e i-1) ≤ + ((∏ i, P i) * B).absNorm * (∏ i, P i ^ (e i-1)).absNorm := by + simpa only [map_prod, map_pow] using Nat.mul_le_mul_right + (∏ i, (P i).absNorm ^ (e i-1)) hn + _ = I.absNorm := by + rw [← map_mul] + congr 1 + calc + ((∏ i, P i) * B) * (∏ i, P i ^ (e i-1)) = + ((∏ i, P i) * (∏ i, P i ^ (e i-1))) * B := by ring + _ = I := by rw [hprod, ← hB] + +theorem rowCharacter_primitive_selected_deficit (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (u : HeckeInverseAmplification.FreeRow) : + ∃ ψ : Character, (ProbeHighRowFamily.rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + (∀ I : Ideal O, idealCoeff (ProbeHighRowFamily.rowCharacter S hS u) I = + if IsCoprime I (ProbeHighRowFamily.rowCharacter S hS u).modulus + then idealCoeff ψ I else 0) ∧ + ∀ (k : ℕ) (P : Fin k → Ideal O), (∀ i, Prime (P i)) → Function.Injective P → + ∀ (e : Fin k → ℕ), (∀ i, 2 ≤ e i) → + (∀ i, P i ^ e i ∣ Ideal.span {u.val}) → + ψ.modulus.absNorm * ∏ i, (P i).absNorm ^ (e i-1) ≤ + fixedConductorConstant S * (Ideal.span {u.val} : Ideal O).absNorm := by + obtain ⟨ψ, hle, hp, hn, hm⟩ := rowCharacter_primitive_radical S hS u + refine ⟨ψ, hle, hp, hm, ?_⟩ + intro k P hP hdis e he hdiv + have hb := radical_norm_selected_deficit (Ideal.span {u.val}) + (Ideal.span_singleton_eq_bot.not.mpr u.property.1) P hP hdis e + (fun i => (by have := he i; omega)) hdiv + calc + _ ≤ (fixedConductorConstant S * (Ideal.span {u.val} : Ideal O).radical.absNorm) * + ∏ i, (P i).absNorm ^ (e i-1) := Nat.mul_le_mul_right _ hn + _ ≤ _ := by simpa only [mul_assoc] using Nat.mul_le_mul_left (fixedConductorConstant S) hb + +theorem canonicalCRT_radical_congr {ι : Type*} [Fintype ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (hg : ∀ i, λ₀ ∉ P i) (e : ι → ℕ) (he : ∀ i, 1 ≤ e i) + (hcop : Pairwise (Function.onFun IsCoprime P)) (x y : O) + (hxy : x-y ∈ (∏ i, P i ^ e i).radical) : + CenteredMomentCanonical.canonicalCRTCharacter P hg e he hcop + (Ideal.Quotient.mk (∏ i, P i ^ e i) x) = + CenteredMomentCanonical.canonicalCRTCharacter P hg e he hcop + (Ideal.Quotient.mk (∏ i, P i ^ e i) y) := by + rw [CenteredMomentCanonical.canonicalCRTCharacter_mk, + CenteredMomentCanonical.canonicalCRTCharacter_mk] + exact idealRowHom_congr_radical _ x y hxy + +theorem fixedConductorConstant_pos (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) : 0 < fixedConductorConstant S := by + have hnorm (I : Ideal O) (hI : I ≠ 0) : 0 < I.absNorm := + Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hI) + unfold fixedConductorConstant ProbeHighRowFamily.conductorConstant + exact mul_pos (mul_pos + (hnorm _ (Ideal.span_singleton_eq_bot.not.mpr ProbeHighRowFamily.rowMaskElement_ne_zero)) + (hnorm _ (Ideal.span_singleton_eq_bot.not.mpr (by norm_num)))) + (hnorm _ (Finset.prod_ne_zero_iff.mpr (fun P hP => (hS P hP).ne_zero))) + +theorem sourceRow_primitive_radical (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (hbad : CanonicalQuadraticSieve.fixedBadPrimes ⊆ S) + (u : HeckeInverseAmplification.FreeRow) : + ∃ ψ : Character, (ProbeHighRowFamily.rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + ψ.modulus.absNorm ≤ fixedConductorConstant S * + (Ideal.span {u.val} : Ideal O).radical.absNorm ∧ + ∀ I : Ideal O, ProbePhysical.highExclusion S hS I * idealRowHom u.val I = + if IsCoprime I (ProbeHighRowFamily.rowCharacter S hS u).modulus + then idealCoeff ψ I else 0 := by + obtain ⟨ψ, hle, hp, hn, hm⟩ := rowCharacter_primitive_radical S hS u + refine ⟨ψ, hle, hp, hn, ?_⟩ + intro I + rw [← ProbeHighRowFamily.rowCharacter_coeff S hS hbad u I] + exact hm I + +theorem rowCharacter_primitive_selected_div (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (u : HeckeInverseAmplification.FreeRow) : + ∃ ψ : Character, (ProbeHighRowFamily.rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + (∀ I : Ideal O, idealCoeff (ProbeHighRowFamily.rowCharacter S hS u) I = + if IsCoprime I (ProbeHighRowFamily.rowCharacter S hS u).modulus + then idealCoeff ψ I else 0) ∧ + ∀ (k : ℕ) (P : Fin k → Ideal O), (∀ i, Prime (P i)) → Function.Injective P → + ∀ (e : Fin k → ℕ), (∀ i, 2 ≤ e i) → + (∀ i, P i ^ e i ∣ Ideal.span {u.val}) → + (ψ.modulus.absNorm : ℝ) ≤ + ((fixedConductorConstant S : ℝ) * (Ideal.span {u.val} : Ideal O).absNorm) / + ∏ i, ((P i).absNorm : ℝ) ^ (e i-1) := by + obtain ⟨ψ, hle, hp, hm, hb⟩ := rowCharacter_primitive_selected_deficit S hS u + refine ⟨ψ, hle, hp, hm, ?_⟩ + intro k P hP hdis e he hdiv + have hpos : 0 < ∏ i, ((P i).absNorm : ℝ) ^ (e i-1) := by + apply Finset.prod_pos + intro i _ + apply pow_pos + exact_mod_cast Nat.pos_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr (hP i).ne_zero) + apply (le_div_iff₀ hpos).mpr + exact_mod_cast hb k P hP hdis e he hdiv + +end SevenEighths.ProbeRowRadicalConductor + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/RowReflectedAllocation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/RowReflectedAllocation.lean new file mode 100644 index 0000000000000000000000000000000000000000..5be827610f8fc8efb19cced8f6ff32623fc6f69c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/RowReflectedAllocation.lean @@ -0,0 +1,351 @@ +import OAI.NumberTheory.DirichletL.Detector.RowRadicalConductor +import OAI.NumberTheory.DirichletL.Hecke.DyadicReflectedControl +import OAI.NumberTheory.DirichletL.PrimeRows.DiskControl +import OAI.NumberTheory.DirichletL.PrimeRows.BufferedBin +import OAI.NumberTheory.DirichletL.PrimeRows.PrincipalMask +import OAI.NumberTheory.DirichletL.PrimeRows.Valuation + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology ComplexConjugate +open Set Complex +namespace SevenEighths.ProbeRowReflectedAllocation +open HeckeFamily HeckeInverseAmplification ProbeHighRowFamily +open HeckeFiniteDeletion HeckeReciprocalGrowth HeckeDeletionBounds +open ProbeRowRadicalConductor +local notation "O" => HeckeFamily.O + +lemma prod_rpow_nonneg {ι : Type*} (T : Finset ι) (q : ι → ℝ) + (hq : ∀ i ∈ T, 0 ≤ q i) (A : ℝ) : + (∏ i ∈ T, q i) ^ A = ∏ i ∈ T, (q i) ^ A := by + induction T using Finset.induction_on with + | empty => simp + | @insert i T hi ih => + rw [Finset.prod_insert hi, Finset.prod_insert hi, + Real.mul_rpow (hq i (Finset.mem_insert_self i T)) + (Finset.prod_nonneg (fun j hj => hq j (Finset.mem_insert_of_mem hj))), + ih (fun j hj => hq j (Finset.mem_insert_of_mem hj))] + +lemma selected_exponent_allocation {a e : ℝ} (ha : 51/100 ≤ a) + (he : 0 < e) {j : ℕ} (hj : 2 ≤ j) : + -(1-a-6*e) ≤ (j-1 : ℕ)*(a-1/2+6*e)-1/2 := by + have hA : 0 ≤ a-1/2+6*e := by linarith + have hj' : (1 : ℝ) ≤ (j-1 : ℕ) := by exact_mod_cast (show 1 ≤ j-1 by omega) + nlinarith [mul_le_mul_of_nonneg_right hj' hA] + +theorem allocation_of_deficit {k : ℕ} (q : Fin k → ℝ) + (hq : ∀ i, 1 ≤ q i) (j : Fin k → ℕ) (hj : ∀ i, 2 ≤ j i) + (N D a e : ℝ) (hN : 0 ≤ N) (ha : 51/100 ≤ a) (he : 0 < e) + (hdef : N * ∏ i, q i ^ (j i-1) ≤ D) : + N ^ (a-1/2+6*e) * ∏ i, q i ^ (-(1-a-6*e)) ≤ + D ^ (a-1/2+6*e) * ∏ i, q i ^ (-(1/2 : ℝ)) := by + let A := a-1/2+6*e + have hA : 0 ≤ A := by dsimp [A]; linarith + have hq0 (i) : 0 ≤ q i := (by linarith [hq i]) + have hlocal (i) : q i ^ (-(1-a-6*e)) ≤ + (q i ^ (j i-1)) ^ A * q i ^ (-(1/2 : ℝ)) := by + rw [← Real.rpow_natCast_mul (hq0 i), ← Real.rpow_add (by linarith [hq i])] + apply Real.rpow_le_rpow_of_exponent_le (hq i) + exact selected_exponent_allocation ha he (hj i) + have hprod := Finset.prod_le_prod₀ (s := Finset.univ) (fun i _ => Real.rpow_nonneg (hq0 i) _) + (fun i _ => hlocal i) + rw [Finset.prod_mul_distrib, ← prod_rpow_nonneg Finset.univ + (fun i => q i ^ (j i-1)) (fun i _ => pow_nonneg (hq0 i) _) A] at hprod + have hD0 : 0 ≤ ∏ i, q i ^ (j i-1) := Finset.prod_nonneg (fun i _ => pow_nonneg (hq0 i) _) + calc + _ ≤ N ^ A * ((∏ i, q i ^ (j i-1)) ^ A * ∏ i, q i ^ (-(1/2 : ℝ))) := + mul_le_mul_of_nonneg_left hprod (Real.rpow_nonneg hN _) + _ = (N * ∏ i, q i ^ (j i-1)) ^ A * ∏ i, q i ^ (-(1/2 : ℝ)) := by + rw [Real.mul_rpow hN hD0]; ring + _ ≤ _ := mul_le_mul_of_nonneg_right + (Real.rpow_le_rpow (mul_nonneg hN hD0) hdef hA) + (Finset.prod_nonneg (fun i _ => Real.rpow_nonneg (hq0 i) _)) + +lemma prime_norm_ge_one (P : Ideal O) (hP : Prime P) : (1 : ℝ) ≤ P.absNorm := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hP.ne_zero) + +lemma original_row_conductor_le (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (u : FreeRow) : + ((rowCharacter S hS u).modulus.absNorm : ℝ) ≤ + (fixedConductorConstant S : ℝ) * (Ideal.span {u.val} : Ideal O).absNorm := by + exact_mod_cast (by simpa only [fixedConductorConstant, mul_assoc, mul_comm, mul_left_comm] + using rowCharacter_conductor S hS u) + +lemma original_row_deletion_radical_le (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (u : FreeRow) : + ((radical (rowCharacter S hS u).modulus).absNorm : ℝ) ≤ + (fixedConductorConstant S : ℝ) * (Ideal.span {u.val} : Ideal O).absNorm := + by + let χ := rowCharacter S hS u + have hd : radical χ.modulus ∣ χ.modulus := by + unfold radical SmoothMobiusCorrection.primeProduct + rw [SmoothMobiusCorrection.prod_primeSet χ.modulus (fun J : Ideal O => J)] + exact IdealMobiusDivisorSum.support_product_dvd χ.modulus_ne_bot (Finset.Subset.refl _) + have hn : ((radical χ.modulus).absNorm : ℝ) ≤ χ.modulus.absNorm := by + exact_mod_cast Nat.le_of_dvd (Nat.pos_iff_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr χ.modulus_ne_bot)) (map_dvd Ideal.absNorm hd) + exact hn.trans (original_row_conductor_le S hS u) + +theorem row_same_primitive_allocation (S : Finset (Ideal O)) + (hS : ∀ P ∈ S, Prime P) (u : FreeRow) : + ∃ ψ : Character, (rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + (∀ I : Ideal O, idealCoeff (rowCharacter S hS u) I = + if IsCoprime I (rowCharacter S hS u).modulus then idealCoeff ψ I else 0) ∧ + ∀ (k : ℕ) (P : Fin k → Ideal O), (∀ i, Prime (P i)) → Function.Injective P → + ∀ (j : Fin k → ℕ), (∀ i, 2 ≤ j i) → + (∀ i, P i ^ j i ∣ Ideal.span {u.val}) → + ∀ a e : ℝ, 51/100 ≤ a → 0 < e → + (ψ.modulus.absNorm : ℝ) ^ (a-1/2+6*e) * + ∏ i, ((P i).absNorm : ℝ) ^ (-(1-a-6*e)) ≤ + ((fixedConductorConstant S : ℝ) * (Ideal.span {u.val} : Ideal O).absNorm) ^ + (a-1/2+6*e) * ∏ i, ((P i).absNorm : ℝ) ^ (-(1/2 : ℝ)) := by + obtain ⟨ψ, hle, hp, hm, hdef⟩ := rowCharacter_primitive_selected_deficit S hS u + refine ⟨ψ, hle, hp, hm, ?_⟩ + intro k P hP hdis j hj hdiv a e ha he + apply allocation_of_deficit _ (fun i => prime_norm_ge_one _ (hP i)) j hj + _ _ a e (by positivity) ha he + exact_mod_cast hdef k P hP hdis j hj hdiv + +lemma actual_multiplicity_divisor (u : FreeRow) (p : O) (hp : Prime p) : + (Ideal.span {p} : Ideal O) ^ multiplicity p u.val ∣ Ideal.span {u.val} ∧ + multiplicity p u.val < 6 := by + refine ⟨⟨Ideal.span {unitPart u p hp}, ?_⟩, multiplicity_lt_six u p hp⟩ + rw [Ideal.span_singleton_pow, Ideal.span_singleton_mul_span_singleton] + exact congrArg (fun x : O => (Ideal.span {x} : Ideal O)) (unitPart_spec u p hp).1 + +lemma actual_ideal_multiplicity (u : FreeRow) (P : Ideal O) (hP : Prime P) : + P ^ multiplicity P (Ideal.span {u.val} : Ideal O) ∣ Ideal.span {u.val} ∧ + multiplicity P (Ideal.span {u.val} : Ideal O) < 6 := by + refine ⟨pow_multiplicity_dvd _ _, ?_⟩ + rw [UniqueFactorizationMonoid.multiplicity_eq_count_normalizedFactors hP.irreducible + (Ideal.span_singleton_eq_bot.not.mpr u.property.1), normalize_eq] + exact u.property.2 P + +theorem buffered_reflected_right_bound (e ε : ℝ) + (he : 0 < e) (he' : e < 1/1000) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {ι : Type*} [Fintype ι] (χ : ι → Character) + (B a : ℝ) (i : ℕ), 2 < B → 51/100 ≤ a → a ≤ 1 → + detectorMaximum χ (3*(i+1 : ℕ)*B) < a+2*e → + ∀ (j : ι), (χ j).residue ≠ 1 → + ∀ w : ℂ, w.re = 1-a-6*e → |w.im| ≤ (3*i+2 : ℕ)*B → + ‖LFunction (χ j) (1-conj w)‖ ≤ + C * (presentationComplexity (χ j) ((3*i+2 : ℕ)*B)) ^ ε := by + obtain ⟨C, hC, hb⟩ := buffered_regular_control e ε he he' hε + refine ⟨C, hC, ?_⟩ + intro ι _ χ B a i hB ha ha1 hmax j hχ w hw hwi + have hwr : (1-conj w).re = a+6*e := by simp; linarith + have hwm : (1-conj w).im = w.im := by simp + have hz : 1-conj w ∈ Metric.closedBall ((2 : ℂ)+w.im*I) (2-a-6*e) := by + rw [Metric.mem_closedBall, dist_eq_norm] + have heq : 1-conj w-((2 : ℂ)+w.im*I) = ((a+6*e-2 : ℝ) : ℂ) := by + apply Complex.ext + · simp; linarith + · simp + rw [heq, Complex.norm_real, Real.norm_eq_abs, abs_of_nonpos (by linarith)] + linarith + have h := hb χ B a i hB ha ha1 hmax j w.im hwi (1-conj w) hz + rw [HeckeLogarithmicInput.regular_eq_nonprincipal _ hχ] at h + have hH : 0 ≤ (3*i+2 : ℕ)*B := (abs_nonneg _).trans hwi + have hc : presentationComplexity (χ j) w.im ≤ + presentationComplexity (χ j) ((3*i+2 : ℕ)*B) := by + unfold presentationComplexity HeckeLogarithmic.complexity + rw [abs_of_nonneg hH] + gcongr + apply (le_trans (le_add_of_nonneg_right (norm_nonneg _)) h).trans + exact mul_le_mul_of_nonneg_left (Real.rpow_le_rpow (by + unfold presentationComplexity HeckeLogarithmic.complexity; positivity) hc hε.le) hC.le + +theorem central_deletion_bound (ε : ℝ) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ (χ ψ : Character) (a e : ℝ), + 0 < e → 51/100 ≤ a → a ≤ 1 → + ∀ w : ℂ, w.re = 1-a-6*e → + ‖factors χ.modulus ψ w‖ * ‖(factors χ.modulus ψ (1-conj w))⁻¹‖ ≤ + C * ((radical χ.modulus).absNorm : ℝ) ^ (6*e+2*ε) := by + obtain ⟨Cl, hCl, hl⟩ := factors_any_re_subpower_bound ε hε + obtain ⟨Cr, hCr, hr⟩ := factors_radical_subpower_bound (1/2) ε (by norm_num) hε + refine ⟨Cl*Cr, mul_pos hCl hCr, ?_⟩ + intro χ ψ a e he ha ha1 w hw + have hR := HeckeDyadic.radical_norm_ge_one χ.modulus + have hR0 : 0 < ((radical χ.modulus).absNorm : ℝ) := by linarith + have hleft : ‖factors χ.modulus ψ w‖ ≤ + Cl * ((radical χ.modulus).absNorm : ℝ) ^ (6*e+ε) := by + apply (hl χ.modulus ψ w).trans + apply mul_le_mul_of_nonneg_left _ hCl.le + apply Real.rpow_le_rpow_of_exponent_le hR + have hm : max (-w.re) 0 ≤ 6*e := max_le (by rw [hw]; linarith) (by positivity) + linarith + have hright : ‖(factors χ.modulus ψ (1-conj w))⁻¹‖ ≤ + Cr * ((radical χ.modulus).absNorm : ℝ) ^ ε := by + exact (le_add_of_nonneg_left (norm_nonneg _)).trans + (hr χ.modulus ψ (1-conj w) (by simp; linarith)) + calc + _ ≤ (Cl * ((radical χ.modulus).absNorm : ℝ) ^ (6*e+ε)) * + (Cr * ((radical χ.modulus).absNorm : ℝ) ^ ε) := + mul_le_mul hleft hright (norm_nonneg _) (by positivity) + _ = _ := by + rw [mul_mul_mul_comm, ← Real.rpow_add hR0] + congr 2 + ring + +theorem buffered_same_primitive_reflected (e ε : ℝ) + (he : 0 < e) (he' : e < 1/1000) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ {ι : Type*} [Fintype ι] (χ : ι → Character) + (B a : ℝ) (i : ℕ), 2 < B → 51/100 ≤ a → a ≤ 1 → + detectorMaximum χ (3*(i+1 : ℕ)*B) < a+2*e → + ∀ (j : ι) (ψ : Character), FiniteFourier.IsPrimitiveOnIdeals ψ.residue → + (χ j).residue ≠ 1 → + (∀ I : Ideal O, idealCoeff (χ j) I = + if IsCoprime I (χ j).modulus then idealCoeff ψ I else 0) → + ∀ w : ℂ, w.re = 1-a-6*e → |w.im| ≤ (3*i+2 : ℕ)*B → + ‖LFunction (χ j) w‖ ≤ C * (ψ.modulus.absNorm : ℝ) ^ (a-1/2+6*e) * + ((radical (χ j).modulus).absNorm : ℝ) ^ (6*e+2*ε) * + (3+(3*i+2 : ℕ)*B)^2 * + (presentationComplexity (χ j) ((3*i+2 : ℕ)*B)) ^ ε := by + obtain ⟨Cg, hCg, hg⟩ := HeckeDyadicReflection.original_reflected_bound + obtain ⟨Cb, hCb, hb⟩ := buffered_reflected_right_bound e ε he he' hε + obtain ⟨Cd, hCd, hd⟩ := central_deletion_bound ε hε + refine ⟨Cg*Cb*Cd, by positivity, ?_⟩ + intro ι _ χ B a i hB ha ha1 hmax j ψ hp hχ hm w hw hwi + have hr := hg (χ j) ψ hp hχ hm w (by rw [hw]; linarith) (by rw [hw]; linarith) + have hexp : 1/2-w.re = a-1/2+6*e := by rw [hw]; ring + rw [hexp] at hr + have hright := hb χ B a i hB ha ha1 hmax j hχ w hw hwi + have hdel := hd (χ j) ψ a e he ha ha1 w hw + have hpc0 : 0 ≤ presentationComplexity (χ j) ((3*i+2 : ℕ)*B) := by + unfold presentationComplexity HeckeLogarithmic.complexity + positivity + calc + _ ≤ Cg * (ψ.modulus.absNorm : ℝ) ^ (a-1/2+6*e) * (3+|w.im|)^2 * + ‖LFunction (χ j) (1-conj w)‖ * + (‖factors (χ j).modulus ψ w‖ * ‖(factors (χ j).modulus ψ (1-conj w))⁻¹‖) := hr + _ ≤ Cg * (ψ.modulus.absNorm : ℝ) ^ (a-1/2+6*e) * (3+(3*i+2 : ℕ)*B)^2 * + (Cb * (presentationComplexity (χ j) ((3*i+2 : ℕ)*B)) ^ ε) * + (Cd * ((radical (χ j).modulus).absNorm : ℝ) ^ (6*e+2*ε)) := by + gcongr + _ = _ := by ring + +theorem source_calibrated_reflected_allocation (e ε : ℝ) + (he : 0 < e) (he' : e < 1/1000) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ (S : Finset (Ideal O)) (hS : ∀ P ∈ S, Prime P) + (hmaxS : ∀ P ∈ S, P.IsMaximal) + (_hbad : CanonicalQuadraticSieve.fixedBadPrimes ⊆ S) + (u : FreeRow), u.val ≠ 1 → + ∃ ψ : Character, (rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + (∀ I : Ideal O, idealCoeff (rowCharacter S hS u) I = + if IsCoprime I (rowCharacter S hS u).modulus then idealCoeff ψ I else 0) ∧ + (((ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val ≠ 0) → + (rowCharacter S hS u).residue ≠ 1 ∧ ψ.residue ≠ 1) ∧ + ∀ {ι : Type*} [Fintype ι] (η : Character) (twists : ι → Character) + (B a : ℝ) (i : ℕ), 2 < B → 51/100 ≤ a → a ≤ 1 → + detectorMaximum (sourceDetectorFamily S hS η u twists) (3*(i+1 : ℕ)*B) < a+2*e → + ∀ (k : ℕ) (P : Fin k → Ideal O), (∀ j, Prime (P j)) → Function.Injective P → + ∀ (v : Fin k → ℕ), (∀ j, 2 ≤ v j) → + (∀ j, P j ^ v j ∣ Ideal.span {u.val}) → + ∀ w : ℂ, w.re = 1-a-6*e → |w.im| ≤ (3*i+2 : ℕ)*B → + ‖star ((ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val) * + HeckeOrigin.continued (rowCharacter S hS u) w‖ * + ∏ j, ((P j).absNorm : ℝ) ^ (-w.re) ≤ + C * (((fixedConductorConstant S : ℝ) * + (Ideal.span {u.val} : Ideal O).absNorm) ^ (a-1/2+6*e) * + ∏ j, ((P j).absNorm : ℝ) ^ (-(1/2 : ℝ))) * + ((radical (rowCharacter S hS u).modulus).absNorm : ℝ) ^ (6*e+2*ε) * + (3+(3*i+2 : ℕ)*B)^2 * + (presentationComplexity (rowCharacter S hS u) ((3*i+2 : ℕ)*B)) ^ ε := by + obtain ⟨C, hC, hb⟩ := buffered_same_primitive_reflected e ε he he' hε + refine ⟨C, hC, ?_⟩ + intro S hS hmaxS hbad u hu + obtain ⟨ψ, hle, hp, hm, hall⟩ := row_same_primitive_allocation S hS u + have hactive (hc : (ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val ≠ 0) : + (rowCharacter S hS u).residue ≠ 1 ∧ ψ.residue ≠ 1 := by + have hn := calibrated_row_nonprincipal S hS hmaxS hbad u hu hc + exact ⟨hn, fun h => hn ((principal_iff_of_mask _ ψ hm).mpr h)⟩ + refine ⟨ψ, hle, hp, hm, hactive, ?_⟩ + intro ι _ η twists B a i hB ha ha1 hbin k P hP hdis v hv hdiv w hw hwi + have hpc0 : 0 ≤ presentationComplexity (rowCharacter S hS u) ((3*i+2 : ℕ)*B) := by + unfold presentationComplexity HeckeLogarithmic.complexity + positivity + by_cases hc : (ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val = 0 + · simp only [hc, star_zero, zero_mul, norm_zero] + positivity + · have hn := (hactive hc).1 + have hL := hb (sourceDetectorFamily S hS η u twists) B a i hB ha ha1 hbin + (Sum.inl true) ψ hp hn hm w hw hwi + simp only [sourceDetectorFamily_numerator] at hL + have hcal : ‖star ((ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val)‖ ≤ 1 := by + rw [norm_star] + exact (ProbePhysical.calibrationForSet S hmaxS).residueMonoid_norm_le_one _ + have hweighted : ‖star ((ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val) * + HeckeOrigin.continued (rowCharacter S hS u) w‖ ≤ ‖LFunction (rowCharacter S hS u) w‖ := by + rw [HeckeOrigin.continued, ite_eq_right hn, norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) hcal + have hal := hall k P hP hdis v hv hdiv a e ha he + rw [← hw] at hal + have hprod0 : 0 ≤ ∏ j, ((P j).absNorm : ℝ) ^ (-w.re) := + Finset.prod_nonneg (fun j _ => Real.rpow_nonneg (by positivity) _) + calc + _ ≤ (C * (ψ.modulus.absNorm : ℝ) ^ (a-1/2+6*e) * + ((radical (rowCharacter S hS u).modulus).absNorm : ℝ) ^ (6*e+2*ε) * + (3+(3*i+2 : ℕ)*B)^2 * + (presentationComplexity (rowCharacter S hS u) ((3*i+2 : ℕ)*B)) ^ ε) * + ∏ j, ((P j).absNorm : ℝ) ^ (-w.re) := + mul_le_mul_of_nonneg_right (hweighted.trans hL) hprod0 + _ = (C * ((radical (rowCharacter S hS u).modulus).absNorm : ℝ) ^ (6*e+2*ε) * + (3+(3*i+2 : ℕ)*B)^2 * + (presentationComplexity (rowCharacter S hS u) ((3*i+2 : ℕ)*B)) ^ ε) * + ((ψ.modulus.absNorm : ℝ) ^ (a-1/2+6*e) * + ∏ j, ((P j).absNorm : ℝ) ^ (-w.re)) := by ring + _ ≤ (C * ((radical (rowCharacter S hS u).modulus).absNorm : ℝ) ^ (6*e+2*ε) * + (3+(3*i+2 : ℕ)*B)^2 * + (presentationComplexity (rowCharacter S hS u) ((3*i+2 : ℕ)*B)) ^ ε) * + ((((fixedConductorConstant S : ℝ) * (Ideal.span {u.val} : Ideal O).absNorm) ^ + (a-1/2+6*e)) * ∏ j, ((P j).absNorm : ℝ) ^ (-(1/2 : ℝ))) := + mul_le_mul_of_nonneg_left hal (by positivity) + _ = _ := by ring + +theorem source_actual_valuation_reflection (e ε : ℝ) + (he : 0 < e) (he' : e < 1/1000) (hε : 0 < ε) : + ∃ C : ℝ, 0 < C ∧ ∀ (S : Finset (Ideal O)) (hS : ∀ P ∈ S, Prime P) + (hmaxS : ∀ P ∈ S, P.IsMaximal) + (_hbad : CanonicalQuadraticSieve.fixedBadPrimes ⊆ S) + (u : FreeRow), u.val ≠ 1 → + ∃ ψ : Character, (rowCharacter S hS u).modulus ≤ ψ.modulus ∧ + FiniteFourier.IsPrimitiveOnIdeals ψ.residue ∧ + (∀ I : Ideal O, idealCoeff (rowCharacter S hS u) I = + if IsCoprime I (rowCharacter S hS u).modulus then idealCoeff ψ I else 0) ∧ + (((ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val ≠ 0) → + (rowCharacter S hS u).residue ≠ 1 ∧ ψ.residue ≠ 1) ∧ + ∀ {ι : Type*} [Fintype ι] (η : Character) (twists : ι → Character) + (B a : ℝ) (i : ℕ), 2 < B → 51/100 ≤ a → a ≤ 1 → + detectorMaximum (sourceDetectorFamily S hS η u twists) (3*(i+1 : ℕ)*B) < a+2*e → + ∀ (k : ℕ) (P : Fin k → Ideal O), (∀ j, Prime (P j)) → Function.Injective P → + (∀ j, 2 ≤ multiplicity (P j) (Ideal.span {u.val} : Ideal O)) → + (∀ j, multiplicity (P j) (Ideal.span {u.val} : Ideal O) < 6) ∧ + ∀ w : ℂ, w.re = 1-a-6*e → |w.im| ≤ (3*i+2 : ℕ)*B → + ‖star ((ProbePhysical.calibrationForSet S hmaxS).residueMonoid u.val) * + HeckeOrigin.continued (rowCharacter S hS u) w‖ * + ∏ j, ((P j).absNorm : ℝ) ^ (-w.re) ≤ + C * (((fixedConductorConstant S : ℝ) * + (Ideal.span {u.val} : Ideal O).absNorm) ^ (a-1/2+6*e) * + ∏ j, ((P j).absNorm : ℝ) ^ (-(1/2 : ℝ))) * + ((radical (rowCharacter S hS u).modulus).absNorm : ℝ) ^ (6*e+2*ε) * + (3+(3*i+2 : ℕ)*B)^2 * + (presentationComplexity (rowCharacter S hS u) ((3*i+2 : ℕ)*B)) ^ ε := by + obtain ⟨C, hC, hb⟩ := source_calibrated_reflected_allocation e ε he he' hε + refine ⟨C, hC, ?_⟩ + intro S hS hmaxS hbad u hu + obtain ⟨ψ, hle, hp, hm, hactive, hbound⟩ := hb S hS hmaxS hbad u hu + refine ⟨ψ, hle, hp, hm, hactive, ?_⟩ + intro ι _ η twists B a i hB ha ha1 hbin k P hP hdis hv + refine ⟨fun j => (actual_ideal_multiplicity u (P j) (hP j)).2, ?_⟩ + exact hbound η twists B a i hB ha ha1 hbin k P hP hdis + (fun j => multiplicity (P j) (Ideal.span {u.val} : Ideal O)) hv + (fun j => (actual_ideal_multiplicity u (P j) (hP j)).1) + +end SevenEighths.ProbeRowReflectedAllocation + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/ScalarTable.lean b/lean/OAI/NumberTheory/DirichletL/Detector/ScalarTable.lean new file mode 100644 index 0000000000000000000000000000000000000000..673f53f73056e09bb27c3ae011df6dfde046c201 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/ScalarTable.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Detector.ScalarVanishing + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +def gaussValuationTable (Q G : ℂ) (r n j : ℕ) : ℂ := + if 6 ∣ r then (if n+1 ≤ j then Q^(n+1) else 0) - (if n ≤ j then Q^n else 0) + else if j=n then Q^n*G else 0 + +theorem actualSextic_gaussValuationTable (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (r n j : ℕ) : + primePowerGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg ^ r) n (p^j) = + gaussValuationTable (Ideal.absNorm (Ideal.span {p})) + (primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg ^ r) 1) r n j := + actualSextic_primePowerGauss_at_pow p hp hg hc r n j + +theorem positiveScalar_actual_table (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (n k j : ℕ) : + let χ := actualSextic (Ideal.span {p}) hg + let Q : ℂ := Ideal.absNorm (Ideal.span {p}) + positiveScalar p hp.ne_zero χ n k j = + if k=0 then gaussValuationTable Q (primeGauss p hp.ne_zero (χ^(n+1)) 1) (n+1) n j + else if k=1 ∧ 1 ≤ j then + (χ (-1))⁻¹ * primeGauss p hp.ne_zero χ 1 * + gaussValuationTable Q (primeGauss p hp.ne_zero (χ^n) 1) n n (j-1) + else 0 := by + dsimp only + rcases k with _ | k + · rw [ite_eq_left rfl, positiveScalar_kzero, actualSextic_gaussValuationTable p hp hg hc] + rcases k with _ | k + · rcases j with _ | j + · simp only [ zero_add, Nat.one_ne_zero, ite_false, + show ¬(1:ℕ) ≤ 0 by omega, and_false] + exact positiveScalar_kone_jzero p hp _ n + · rw [ite_eq_right (by omega : (1:ℕ) ≠ 0), ite_eq_left ⟨rfl, by omega⟩, + positiveScalar_kone p hp.ne_zero, MulChar.inv_apply_eq_inv', + actualSextic_gaussValuationTable p hp hg hc] + simp + · rw [ite_eq_right (by omega), ite_eq_right (by omega), positiveScalar_kge_two p hp] + +theorem zero_index_scalar (p : O) (_hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (k j : ℕ) (_hk : k ≠ 0) : + (χ^k) (Ideal.Quotient.mk _ (p^j)) = if j=0 then 1 else 0 := by + by_cases hj : j=0 + · simp [hj] + · rw [ite_eq_right hj] + have hz : Ideal.Quotient.mk (Ideal.span {p}) (p^j) = 0 := + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr (dvd_pow_self p hj)) + rw [hz, MulChar.map_zero] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/ScalarVanishing.lean b/lean/OAI/NumberTheory/DirichletL/Detector/ScalarVanishing.lean new file mode 100644 index 0000000000000000000000000000000000000000..f4c6b67c88c3dc0bbca87a1c7f932c9e490a4e3d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/ScalarVanishing.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Detector.LiftedFourier + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CubicEisenstein GaussianShiftedPartition +local notation "O" => ActualEisensteinCubic.O + +theorem higher_convolution_zero (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ ξ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n m : ℕ) (H : O) : + (∑' d : O ⧸ Ideal.span {p^(m+2)}, + χ (Ideal.Quotient.mk _ (representative (p^(m+2)) d)) * + primePowerGauss p hp.ne_zero ξ (n+(m+2)) + (H-p^(n+1)*representative (p^(m+2)) d)) = 0 := by + let : Finite (O ⧸ Ideal.span {p^(m+2)}) := + ConcreteTraceCRT.finite_quotient_span (pow_ne_zero _ hp.ne_zero) + let : Fintype (O ⧸ Ideal.span {p^(m+2)}) := Fintype.ofFinite _ + let : Finite (O ⧸ Ideal.span {p*p^(n+(m+2))}) := + ConcreteTraceCRT.finite_quotient_span (mul_ne_zero hp.ne_zero (pow_ne_zero _ hp.ne_zero)) + let : Fintype (O ⧸ Ideal.span {p*p^(n+(m+2))}) := Fintype.ofFinite _ + have hmod : p*p^(n+(m+2)) = p^(m+2)*p^(n+1) := by + rw [← pow_succ', ← pow_add] + congr 1 + omega + have hinner (V : O) : (∑' d : O ⧸ Ideal.span {p^(m+2)}, + χ (Ideal.Quotient.mk _ (representative (p^(m+2)) d)) * + quotientTrace (p^(m+2)) (pow_ne_zero _ hp.ne_zero) + (Ideal.Quotient.mk _ ((-V)*representative (p^(m+2)) d))) = + primePowerGauss p hp.ne_zero χ (m+1) (-V) := by + change quotientFourier p (p^(m+2)) (pow_ne_zero _ hp.ne_zero) χ (-V) = _ + rw [primePowerGauss_eq_quotientFourier] + apply quotientFourier_congr + rw [← pow_succ'] + unfold primePowerGauss conductorFourier + simp_rw [tsum_fintype, Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_eq_zero + intro y hy + obtain ⟨v, rfl⟩ := Ideal.Quotient.mk_surjective y + change (∑ d : O ⧸ Ideal.span {p^(m+2)}, + χ (Ideal.Quotient.mk _ (representative (p^(m+2)) d)) * + (ξ (Ideal.Quotient.mk _ v) * + quotientTrace (p*p^(n+(m+2))) _ + (Ideal.Quotient.mk _ (H-p^(n+1)*representative (p^(m+2)) d)*Ideal.Quotient.mk _ v))) = 0 + have ht (d : O ⧸ Ideal.span {p^(m+2)}) : + quotientTrace (p*p^(n+(m+2))) (mul_ne_zero hp.ne_zero (pow_ne_zero _ hp.ne_zero)) + (Ideal.Quotient.mk _ ((H-p^(n+1)*representative (p^(m+2)) d)*v)) = + quotientTrace (p*p^(n+(m+2))) (mul_ne_zero hp.ne_zero (pow_ne_zero _ hp.ne_zero)) + (Ideal.Quotient.mk _ (H*v)) * + quotientTrace (p^(m+2)) (pow_ne_zero _ hp.ne_zero) + (Ideal.Quotient.mk _ ((-v)*representative (p^(m+2)) d)) := by + have ht := quotientTrace_split_frequency (p^(m+2)) (p^(n+1)) + (pow_ne_zero _ hp.ne_zero) (pow_ne_zero _ hp.ne_zero) H + (representative (p^(m+2)) d) v + simp only [quotientTrace_mk] at ht ⊢ + simpa only [← hmod] using ht + simp_rw [← map_mul, ht] + calc + _ = ξ (Ideal.Quotient.mk _ v) * + quotientTrace (p*p^(n+(m+2))) (mul_ne_zero hp.ne_zero (pow_ne_zero _ hp.ne_zero)) + (Ideal.Quotient.mk _ (H*v)) * + ∑ d : O ⧸ Ideal.span {p^(m+2)}, + χ (Ideal.Quotient.mk _ (representative (p^(m+2)) d)) * + quotientTrace (p^(m+2)) (pow_ne_zero _ hp.ne_zero) + (Ideal.Quotient.mk _ ((-v)*representative (p^(m+2)) d)) := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + ring + _ = quotientTrace (p*p^(n+(m+2))) (mul_ne_zero hp.ne_zero (pow_ne_zero _ hp.ne_zero)) + (Ideal.Quotient.mk _ (H*v)) * + (ξ (Ideal.Quotient.mk _ v) * primePowerGauss p hp.ne_zero χ (m+1) (-v)) := by + have hi := hinner v + rw [tsum_fintype] at hi + rw [hi] + ring + _ = 0 := by rw [higher_outer_lift_annihilated p hp.ne_zero χ ξ (by omega : 0 < m+1) v, mul_zero] + +theorem positiveScalar_kge_two (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (n m j : ℕ) : + positiveScalar p hp.ne_zero χ n (m+2) j = 0 := by + rw [positiveScalar_full_lift p hp χ n (m+2) j (by omega), + higher_convolution_zero p hp (χ^(m+2)) (χ^(n+1)) n m (p^j), mul_zero] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SelectedPrimeIndexed.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SelectedPrimeIndexed.lean new file mode 100644 index 0000000000000000000000000000000000000000..d9826c8ca2f46b3b10a7af05c5e6ece7c351a7c2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SelectedPrimeIndexed.lean @@ -0,0 +1,40 @@ +import OAI.NumberTheory.DirichletL.Detector.SelectedPrimeSums + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeSelectedPrimeSums +local notation "O" => ActualEisensteinCubic.O + +lemma weighted_slot_bound_indexed (eps a b r d B K : ℝ) (heps : 00) + have he (i : ι) : G' (f i)=G i := hf.extend_apply G (fun _=>0) i + have hI (I : Ideal O) (hI : I∈S.image f) : I≠0 := by + obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp hI + exact hS i hi + have hg (I : Ideal O) (hI : I∈S.image f) : + ‖G' I‖≤K*(if I∣U then (Ideal.absNorm I:ℝ)^d else 1) := by + obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp hI + rw [he] + exact hG i hi + have hh := hmain U hU P hP (S.image f) hI W hWS hWB G' hg z hz + rw [Finset.sum_image hf.injOn] at hh + simpa only [he] using hh + +end SevenEighths.ProbeSelectedPrimeSums +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SelectedPrimeSums.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SelectedPrimeSums.lean new file mode 100644 index 0000000000000000000000000000000000000000..7214ce2ff4ea4306e573cf983f70720afd13323b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SelectedPrimeSums.lean @@ -0,0 +1,171 @@ +import OAI.NumberTheory.DirichletL.Detector.HighRowsSelectedActual +import OAI.NumberTheory.DirichletL.Hecke.DeletionBounds + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeSelectedPrimeSums +local notation "O" => ActualEisensteinCubic.O + +lemma finite_ideal_count (S : Finset (Ideal O)) (H : ℝ) (hH : 0≤H) + (hS : ∀I∈S,I≠0) (hN : ∀I∈S,(Ideal.absNorm I:ℝ)≤H) : + (S.card:ℝ)≤128*H := by + by_cases hh : 1≤H + · exact DescentFiberCost.finite_ideal_count_real S H hh hS hN + · have he : S=∅ := by + apply Finset.eq_empty_iff_forall_notMem.mpr + intro I hI + have hp : (1:ℝ)≤Ideal.absNorm I := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr (hS I hI)) + have := hN I hI + linarith + simp only [he,Finset.card_empty,Nat.cast_zero] + positivity + +lemma ramified_card_bound (eps : ℝ) (heps : 0P∣U)).card:ℝ)≤C*(Ideal.absNorm U:ℝ)^eps := by + obtain ⟨C,hC,hb⟩ := IdealDivisorBound.ideal_divisor_small_power eps heps + refine ⟨C,hC,?_⟩ + intro U hU S + apply (show ((S.filter (fun P=>P∣U)).card:ℝ)≤(IdealMobiusDivisorSum.idealDivisors U).card from ?_).trans (hb U hU) + exact_mod_cast Finset.card_le_card (show S.filter (fun P=>P∣U)⊆IdealMobiusDivisorSum.idealDivisors U from by + intro P hP + exact (IdealMobiusDivisorSum.mem_idealDivisors hU).mpr (Finset.mem_filter.mp hP).2) + +def annularPower (a b r : ℝ) : ℝ := max (a^r) (b^r) + +lemma annularPower_nonneg (a b r : ℝ) (ha : 0(hSP I hI).2) + have heP : P*P^(r-1)=P^r := by + calc + _=P^(1:ℝ)*P^(r-1) := by rw [Real.rpow_one] + _=P^r := by rw [←Real.rpow_add hP0];congr 1;ring + have hfirst : (∑I∈S,(Ideal.absNorm I:ℝ)^(r-1))≤128*b*A*P^r := by + calc + _≤∑_I∈S,A*P^(r-1) := Finset.sum_le_sum (fun I hI=>annular_rpow a b P _ _ ha hb hP0 (hSP I hI).1 (hSP I hI).2) + _=(S.card:ℝ)*(A*P^(r-1)) := by simp + _≤(128*(b*P))*(A*P^(r-1)) := mul_le_mul_of_nonneg_right hc (by positivity) + _=128*b*A*(P*P^(r-1)) := by ring + _=128*b*A*P^r := by rw [heP] + have hsecond : (∑I∈S.filter (fun I=>I∣U),(Ideal.absNorm I:ℝ)^(r-1+d))≤ + D*B*(Ideal.absNorm U:ℝ)^eps*P^r := by + have hpP : P^(r-1+d)≤P^r := Real.rpow_le_rpow_of_exponent_le hP (by linarith) + calc + _≤∑_I∈S.filter (fun I=>I∣U),B*P^(r-1+d) := by + apply Finset.sum_le_sum + intro I hI + exact annular_rpow a b P _ _ ha hb hP0 (hSP I (Finset.mem_filter.mp hI).1).1 (hSP I (Finset.mem_filter.mp hI).1).2 + _=((S.filter (fun I=>I∣U)).card:ℝ)*(B*P^(r-1+d)) := by simp + _≤(D*(Ideal.absNorm U:ℝ)^eps)*(B*P^r) := by + gcongr + exact hdiv U hU S + _=D*B*(Ideal.absNorm U:ℝ)^eps*P^r := by ring + have hsum : (∑I∈S,(Ideal.absNorm I:ℝ)^(r-1)*(if I∣U then (Ideal.absNorm I:ℝ)^d else 1))≤ + (∑I∈S,(Ideal.absNorm I:ℝ)^(r-1))+ + ∑I∈S.filter (fun I=>I∣U),(Ideal.absNorm I:ℝ)^(r-1+d) := by + rw [Finset.sum_filter,←Finset.sum_add_distrib] + apply Finset.sum_le_sum + intro I hI + split_ifs + · rw [←Real.rpow_add (hq I hI)] + exact le_add_of_nonneg_left (by positivity) + · simp only [mul_one,add_zero,le_refl] + apply hsum.trans + have hup : 128*b*A*P^r≤128*b*A*(Ideal.absNorm U:ℝ)^eps*P^r := by + nlinarith [mul_nonneg (show 0≤128*b*A*P^r by positivity) (show 0≤(Ideal.absNorm U:ℝ)^eps-1 by linarith)] + nlinarith [mul_nonneg (Real.rpow_nonneg (by positivity : (0:ℝ)≤Ideal.absNorm U) eps) (Real.rpow_nonneg hP0.le r)] + +theorem weighted_slot_bound (eps a b r d B K : ℝ) (heps : 0W ((Ideal.absNorm I:ℝ)/P)≠0) + have hTS : T⊆S := Finset.filter_subset _ _ + have hbounds (I : Ideal O) (hI : I∈T) : a*P≤(Ideal.absNorm I:ℝ) ∧ (Ideal.absNorm I:ℝ)≤b*P := by + have ht := hWS (show (Ideal.absNorm I:ℝ)/P∈Function.support W from (Finset.mem_filter.mp hI).2) + exact ⟨(le_div_iff₀ hP0).mp ht.1,(div_le_iff₀ hP0).mp ht.2⟩ + have he : (∑I∈S,‖W ((Ideal.absNorm I:ℝ)/P)*(Ideal.absNorm I:ℂ)^(z-1)*G I‖)= + ∑I∈T,‖W ((Ideal.absNorm I:ℝ)/P)*(Ideal.absNorm I:ℂ)^(z-1)*G I‖ := by + symm + apply Finset.sum_subset hTS + intro I hI hn + have hw : W ((Ideal.absNorm I:ℝ)/P)=0 := by + by_contra hh + exact hn (Finset.mem_filter.mpr ⟨hI,hh⟩) + simp only [hw,zero_mul,norm_zero] + rw [he] + have hpoint (I : Ideal O) (hI : I∈T) : + ‖W ((Ideal.absNorm I:ℝ)/P)*(Ideal.absNorm I:ℂ)^(z-1)*G I‖≤ + (B*K)*((Ideal.absNorm I:ℝ)^(r-1)*(if I∣U then (Ideal.absNorm I:ℝ)^d else 1)) := by + have hN : (0:ℝ)hS I (hTS hI)) hbounds + calc + _≤∑I∈T,(B*K)*((Ideal.absNorm I:ℝ)^(r-1)*(if I∣U then (Ideal.absNorm I:ℝ)^d else 1)) := + Finset.sum_le_sum hpoint + _=(B*K)*∑I∈T,(Ideal.absNorm I:ℝ)^(r-1)*(if I∣U then (Ideal.absNorm I:ℝ)^d else 1) := + (Finset.mul_sum _ _ _).symm + _≤(B*K)*(C*(Ideal.absNorm U:ℝ)^eps*P^r) := mul_le_mul_of_nonneg_left hmain (mul_nonneg hB hK) + _≤((B*K+1)*C)*(Ideal.absNorm U:ℝ)^eps*P^r := by + nlinarith [mul_nonneg (mul_nonneg hC.le (Real.rpow_nonneg (by positivity : (0:ℝ)≤Ideal.absNorm U) eps)) + (Real.rpow_nonneg hP0.le r)] + +end SevenEighths.ProbeSelectedPrimeSums +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Sextic.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Sextic.lean new file mode 100644 index 0000000000000000000000000000000000000000..7637e778920da530c04b8ca5dea16dfcede93bf1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Sextic.lean @@ -0,0 +1,39 @@ +import OAI.NumberTheory.DirichletL.Detector.GaussValuation +import OAI.NumberTheory.DirichletL.Moments.Canonical + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CompletedGauss ConcreteTraceCRT ConcretePrimeRowBridge CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +theorem actualSextic_pow_eq_one_iff (P : Ideal O) [P.IsMaximal] + (hg : goodLambda ∉ P) (hc : ringChar (O ⧸ P) ≠ 2) (n : ℕ) : + actualSextic P hg ^ n = 1 ↔ 6 ∣ n := by + rw [← orderOf_dvd_iff_pow_eq_one, CenteredMomentCanonical.actualSextic_order_six P hg hc] + +theorem actualSextic_primePowerGauss_at_pow (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + (r n j : ℕ) : + primePowerGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg ^ r) n (p ^ j) = + if 6 ∣ r then + (if n + 1 ≤ j then (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ (n + 1) else 0) - + (if n ≤ j then (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n else 0) + else if j = n then (Ideal.absNorm (Ideal.span {p}) : ℂ) ^ n * + primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg ^ r) 1 else 0 := by + by_cases hr : 6 ∣ r + · rw [ite_eq_left hr, (actualSextic_pow_eq_one_iff _ hg hc r).mpr hr] + apply primePowerGauss_at_pow_principal p hp + have hprim : (quotientTrace p hp.ne_zero).IsPrimitive := + GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive p hp.ne_zero + simpa using hprim (a := 1) one_ne_zero + · rw [ite_eq_right hr] + exact primePowerGauss_at_pow_nonprincipal p hp _ + (fun h => hr ((actualSextic_pow_eq_one_iff _ hg hc r).mp h)) n j + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SixthArray.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SixthArray.lean new file mode 100644 index 0000000000000000000000000000000000000000..8489cfe2d9893b6b84388e13e74b616a7fd39991 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SixthArray.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Detector.SixthMask +import OAI.NumberTheory.DirichletL.Detector.RawArithmetic + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve ProbeCompleted +open HeckeInverseAmplification ConcretePrimeRowBridge CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +lemma bareIdealHighCoefficient_sixth (η : HeckeFamily.Character) + (p : FreeRow×HeckeInverseAmplification.NonzeroIdeal) (hL : Supported p.2.val) + (I J K : Ideal O) : + bareIdealHighCoefficient η (sixthFrequencyEquiv p).val I J K 1= + bareIdealHighCoefficient η p.1.val I J K p.2.val := by + rw [sixthFrequencyEquiv_primary p hL] + unfold bareIdealHighCoefficient + by_cases h : Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K + · simp only [h.1,h.2.1,h.2.2.1,h.2.2.2,hL,supported_one_ideal,and_self,dite_eq_left] + congr 1 + simp only [primaryGenerator_one,one_pow,mul_one] + · have h1 : ¬(Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported (1:Ideal O)) := + fun hh=>h ⟨hh.1,hh.2.1,hh.2.2.1,hh.2.2.2.1⟩ + have h2 : ¬(Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported p.2.val) := + fun hh=>h ⟨hh.1,hh.2.1,hh.2.2.1,hh.2.2.2.1⟩ + rw [dite_eq_right h1,dite_eq_right h2] + +lemma rawHighCoefficient_sixth (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) + (hprime : ∀P∈S,Prime P) (hbad : fixedBadPrimes⊆S) + (D : Ideal O) (η : HeckeFamily.Character) (x w z : ℂ) + (p : FreeRow×HeckeInverseAmplification.NonzeroIdeal) (I J K : Ideal O) : + fullHighCoefficient S D η + (fun H=>star ((calibrationForSet S hS).residueMonoid H.val)) x w z + (rawHighEmbedding (sixthFrequencyEquiv p,((I,J),K)))= + star ((calibrationForSet S hS).residueMonoid p.1.val)* + frequencyWeight z ⟨p.1.val,p.1.property.1⟩* + markedIdealHighSummand S D η p.1.val x w z I J K p.2.val := by + have hOne : ∀P∈S,¬P∣(1:Ideal O) := fun P hP=> (hprime P hP).not_dvd_one + change star ((calibrationForSet S hS).residueMonoid (sixthFrequencyEquiv p).val)* + frequencyWeight z (sixthFrequencyEquiv p)* + markedIdealHighSummand S D η (sixthFrequencyEquiv p).val x w z I J K 1=_ + rw [sixthFrequencyWeight] + rw [sixthFrequencyEquiv_apply,calibration_sixth_frequency_mask] + by_cases hL : ∀P∈S,¬P∣p.2.val + · have hs := supported_of_source_exclusions S hbad p.2.val p.2.property hL + have hb := bareIdealHighCoefficient_sixth η p hs I J K + rw [sixthFrequencyEquiv_apply] at hb + simp only [ite_eq_left hL,mul_one,markedIdealHighSummand,highIdealMask,ite_eq_left hOne, + bareIdealHighSummand,hb] + have hw1 : fullIdealWeight (6*z) (1:Ideal O)=1 := (IdealEuler.normWeight (6*z)).map_one + rw [hw1] + ring + · simp only [ite_eq_right hL,mul_zero,zero_mul,markedIdealHighSummand,highIdealMask] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SixthDecomposition.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SixthDecomposition.lean new file mode 100644 index 0000000000000000000000000000000000000000..947f9862fa4d15c7849bc6ecba5ce12ddb5eaf96 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SixthDecomposition.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Hecke.InverseAmplificationRows +import OAI.NumberTheory.DirichletL.CenteredExceptionalCount +import OAI.NumberTheory.DirichletL.Detector.HighAbsolute + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open CanonicalQuadraticSieve CanonicalRowCompletion ActualEisensteinCubic HeckeInverseAmplification CenteredExceptionalCount ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem sixthRow_surjective (H : NonzeroFrequency) : + ∃p : FreeRow×HeckeInverseAmplification.NonzeroIdeal,rowMap p=H.val := by + let I : Id := Ideal.span {H.val} + have hI : I≠0 := Ideal.span_singleton_eq_bot.not.mpr H.property + let J : Id := sixthQuotient I + have hJ : J≠0 := sixthQuotient_ne_zero I + let a := idealGenerator J + have ha : a≠0 := idealGenerator_ne_zero J hJ + have hspan : Ideal.span {a}=J := span_idealGenerator J + have hd : a^6∣H.val := by + apply Ideal.span_singleton_dvd_span_singleton_iff_dvd.mp + rw [←Ideal.span_singleton_pow,hspan] + change J^6∣I + rw [←sixth_normal_form I hI] + exact dvd_mul_left _ _ + obtain ⟨u,hu⟩ := hd + have hu0 : u≠0 := by + intro hz + rw [hz,mul_zero] at hu + exact H.property hu + have hsu : Ideal.span {u}=sixthRemainder I := by + have hi : Ideal.span {u}*J^6=I := by + rw [←hspan,Ideal.span_singleton_pow,Ideal.span_singleton_mul_span_singleton] + exact congrArg (fun b : O=>Ideal.span {b}) (by simpa only [mul_comm] using hu.symm) + apply mul_right_cancel₀ (pow_ne_zero 6 hJ) + exact hi.trans (sixth_normal_form I hI).symm + have hf : SixthFree (Ideal.span {u}) := by + rw [hsu] + intro P + exact sixthRemainder_valuation_lt I P + refine ⟨(⟨u,hu0,hf⟩,⟨J,hJ⟩),?_⟩ + change u*a^6=H.val + simpa only [mul_comm] using hu.symm + +def sixthFrequencyEquiv : FreeRow×HeckeInverseAmplification.NonzeroIdeal ≃ NonzeroFrequency := + Equiv.ofBijective (fun p=>⟨rowMap p,rowMap_ne_zero p⟩) ⟨ + fun p q h=>rowMap_injective (congrArg Subtype.val h), + fun H=>by obtain ⟨p,hp⟩ := sixthRow_surjective H;exact ⟨p,Subtype.ext hp⟩⟩ + +lemma sixthFrequencyEquiv_apply (p : FreeRow×HeckeInverseAmplification.NonzeroIdeal) : + (sixthFrequencyEquiv p).val=p.1.val*(idealGenerator p.2.val)^6 := rfl + +theorem tsum_sixth_decomposition (f : NonzeroFrequency→ℂ) : + (∑'H : NonzeroFrequency,f H)= + ∑'p : FreeRow×HeckeInverseAmplification.NonzeroIdeal,f (sixthFrequencyEquiv p) := + (sixthFrequencyEquiv.tsum_eq f).symm + +lemma idealGenerator_sixth_eq_primary (I : Id) (hI : CanonicalQuadraticSieve.Supported I) : + (idealGenerator I)^6=(CompletedGauss.primaryGenerator I)^6 := by + have he : Ideal.span {idealGenerator I}=Ideal.span {CompletedGauss.primaryGenerator I} := + (span_idealGenerator I).trans + (CompletedGauss.primaryGenerator_spec I + (supported_primaryGenerator_ne_zero I hI)).1.symm + obtain ⟨u,hu⟩ := Ideal.span_singleton_eq_span_singleton.mp he + have hh := congrArg (fun a : O=>a^6) hu + simpa only [mul_pow,CanonicalUnitEuler.unit_pow_six,mul_one] using hh + +lemma sixthFrequencyEquiv_primary (p : FreeRow×HeckeInverseAmplification.NonzeroIdeal) + (hP : CanonicalQuadraticSieve.Supported p.2.val) : + (sixthFrequencyEquiv p).val=p.1.val*(CompletedGauss.primaryGenerator p.2.val)^6 := by + rw [sixthFrequencyEquiv_apply,idealGenerator_sixth_eq_primary p.2.val hP] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SixthFrequency.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SixthFrequency.lean new file mode 100644 index 0000000000000000000000000000000000000000..8e982ca1eacb9fc1f695e3bd70b544ca44fe4d31 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SixthFrequency.lean @@ -0,0 +1,110 @@ +import OAI.NumberTheory.DirichletL.Detector.SourceCoefficient + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalRowCompletion CanonicalQuadraticSieve CubicEisenstein +open CompletedGauss ConcreteTraceCRT GaussianShiftedPartition CenteredMomentCommonSupport +open CenteredMomentSupportedCorrelation ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +lemma finite_fourier_invariant_unit {R : Type*} [CommRing R] [Fintype R] + (F : R→ℂ) (ψ : AddChar R ℂ) (u : Rˣ) (hF : ∀ x,F ((u:R)*x)=F x) (H : R) : + (∑ x,F x*ψ (((u:R)*H)*x)) = ∑ x,F x*ψ (H*x) := by + symm + rw [← Equiv.sum_comp u.mulLeft (fun x=>F x*ψ (H*x))] + simp only [Units.mulLeft_apply,hF] + apply Finset.sum_congr rfl + intro x hx + congr 1 + congr 1 + ring + +lemma supported_sixth_value (A v : O) (hA : Supported (Ideal.span {A})) + (hcop : IsCoprime A v) : idealRowHom (v^6) (Ideal.span {A})=1 := by + rw [idealRowHom_sixth_mask _ _ hA, ite_eq_left ((Ideal.isCoprime_span_singleton_iff A v).mpr hcop)] + +theorem barePhysicalFourier_sixth_frequency (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (v H : O) (hcop : IsCoprime v (A*s)) : + barePhysicalFourier A s (supportedElement_ne_zero A hA) (supportedElement_ne_zero s hs) (v^6*H) = + barePhysicalFourier A s (supportedElement_ne_zero A hA) (supportedElement_ne_zero s hs) H := by + have hAs := mul_ne_zero (supportedElement_ne_zero A hA) (supportedElement_ne_zero s hs) + let := finite_quotient_span hAs + let : Fintype (Residue (A*s)) := Fintype.ofFinite _ + let u := residueUnit (A*s) (v^6) hcop.pow_left.symm + have hF (x : Residue (A*s)) : + movingQuotient A s (supportedElement_ne_zero s hs) ((u:Residue (A*s))*x) = + movingQuotient A s (supportedElement_ne_zero s hs) x := by + rw [show (u:Residue (A*s))=Ideal.Quotient.mk _ (v^6) by rfl, + movingQuotient_unit_scale A s hs (v^6) hcop.of_mul_right_right.pow_left, + supported_sixth_value A v hA hcop.of_mul_right_left.symm, + supported_sixth_value s v hs hcop.of_mul_right_right.symm,inv_one,one_mul,one_mul] + have he := finite_fourier_invariant_unit (movingQuotient A s (supportedElement_ne_zero s hs)) + (quotientTrace (A*s) hAs) u hF (Ideal.Quotient.mk _ H) + unfold barePhysicalFourier elementFourier + simp only [tsum_fintype] + change (∑ x,movingQuotient A s (supportedElement_ne_zero s hs) x * + quotientTrace (A*s) hAs (Ideal.Quotient.mk _ (v^6*H)*x)) = + ∑ x,movingQuotient A s (supportedElement_ne_zero s hs) x * + quotientTrace (A*s) hAs (Ideal.Quotient.mk _ H*x) + simpa only [u,residueUnit_coe,map_mul] using he + +theorem bareCongruenceCoefficient_sixth_frequency (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (v H : O) (hcop : IsCoprime v (A*s)) : + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) (v^6*H) = + bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H := by + have he := barePhysicalFourier_sixth_frequency A s hA hs v H hcop + simp only [barePhysicalFourier_eq] at he + have hn : (Ideal.absNorm (Ideal.span {s}):ℂ)≠0 := by + exact_mod_cast Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr (supportedElement_ne_zero s hs)) + exact mul_left_cancel₀ hn he + +theorem bareSourceCoefficient_sixth_frequency (η : HeckeFamily.Character) + (I : Ideal O) (hI : primaryGenerator I≠0) (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (v H : O) (hcop : IsCoprime v (A*s)) : + bareSourceCoefficient η I hI A s (supportedElement_ne_zero A hA) (v^6*H) = + bareSourceCoefficient η I hI A s (supportedElement_ne_zero A hA) H := by + unfold bareSourceCoefficient correctedFiniteCoefficient reciprocityCoefficient + rw [bareCongruenceCoefficient_sixth_frequency A s hA hs v H hcop] + +theorem bareSourceCoefficient_product_frequency (η : HeckeFamily.Character) (I J : Ideal O) + (hI : CubicSieve.Admissible I) (hJ : CubicSieve.Admissible J) + (hIJ : CubicSieve.Admissible (I*J)) (hIJcop : IsCoprime I J) + (n m s r : O) + (hc : Supported (Ideal.span {primaryGenerator I})) (hd : Supported (Ideal.span {primaryGenerator J})) + (hn : Supported (Ideal.span {n})) (hm : Supported (Ideal.span {m})) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hpc : goodLambda^2∣primaryGenerator I-1) (hpd : goodLambda^2∣primaryGenerator J-1) + (hpn : goodLambda^2∣n-1) (hpm : goodLambda^2∣m-1) + (hps : goodLambda^2∣s-1) (hpr : goodLambda^2∣r-1) + (hcop : IsCoprime ((primaryGenerator I*n^3)*s) ((primaryGenerator J*m^3)*r)) (a b : O) + (hba : IsCoprime b ((primaryGenerator I*n^3)*s)) + (hab : IsCoprime a ((primaryGenerator J*m^3)*r)) : + let A := primaryGenerator I*n^3 + let B := primaryGenerator J*m^3 + let hA := supportedElement_ne_zero A (supported_completed _ _ hc hn) + let hB := supportedElement_ne_zero B (supported_completed _ _ hd hm) + bareSourceCoefficient η (I*J) hIJ.2 (A*B) (s*r) (mul_ne_zero hA hB) ((a*b)^6) = + bareSourceCoefficient η I hI.2 A s hA (a^6) * bareSourceCoefficient η J hJ.2 B r hB (b^6) := by + have he := bareSourceCoefficient_product η I J hI hJ hIJ hIJcop n m s r + hc hd hn hm hs hr hpc hpd hpn hpm hps hpr hcop ((a*b)^6) + dsimp only at he ⊢ + have hi := bareSourceCoefficient_sixth_frequency η I hI.2 (primaryGenerator I*n^3) s + (supported_completed _ _ hc hn) hs b (a^6) hba + have hj := bareSourceCoefficient_sixth_frequency η J hJ.2 (primaryGenerator J*m^3) r + (supported_completed _ _ hd hm) hr a (b^6) hab + rw [show b^6*a^6=(a*b)^6 by ring] at hi + rw [show a^6*b^6=(a*b)^6 by ring] at hj + rw [hi,hj] at he + exact he + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SixthMask.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SixthMask.lean new file mode 100644 index 0000000000000000000000000000000000000000..3d0b8b23aaf60d1c50cdf4af9c7478c5bd07784d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SixthMask.lean @@ -0,0 +1,67 @@ +import OAI.NumberTheory.DirichletL.Detector.SixthDecomposition +import OAI.NumberTheory.DirichletL.Detector.SpectralSupport + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ConcretePrimeRowBridge CanonicalQuadraticSieve CubicEisenstein +open HeckeInverseAmplification +local notation "O" => ActualEisensteinCubic.O + +lemma calibration_sixth_ideal_mask (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) + (L : Ideal O) : + (calibrationForSet S hS).residueMonoid (idealGenerator L)^6= + if ∀P∈S,¬P∣L then 1 else 0 := by + by_cases hL : ∀P∈S,¬P∣L + · rw [ite_eq_left hL] + apply calibrationForSet_residue_sixth + apply calibrationForSet_coprime_of_excluded + simpa only [span_idealGenerator] using hL + · rw [ite_eq_right hL] + have hz : (calibrationForSet S hS).residueMonoid (idealGenerator L)=0 := by + by_contra hn + have hu := (calibrationForSet S hS).residue.apply_ne_zero_iff.mp hn + have hc := (isUnit_quotient_span_iff (calibrationForSet S hS).generator (idealGenerator L)).mp hu + have ho := (calibrationForSet_coprime_iff S hS (idealGenerator L)).mp hc + apply hL + intro P hP hd + apply ho P hP + apply (Ideal.dvd_iff_le.mp hd) + have hm : idealGenerator L∈Ideal.span ({idealGenerator L}:Set O) := Ideal.subset_span (by simp) + rw [span_idealGenerator L] at hm + exact hm + rw [hz,zero_pow (by decide : 6≠0)] + +lemma calibration_sixth_frequency_mask (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) + (u : O) (L : Ideal O) : + star ((calibrationForSet S hS).residueMonoid (u*idealGenerator L^6))= + star ((calibrationForSet S hS).residueMonoid u)*(if ∀P∈S,¬P∣L then 1 else 0) := by + rw [map_mul,map_pow,calibration_sixth_ideal_mask] + split_ifs <;> simp only [mul_one,mul_zero,star_zero] + +lemma sixthFrequencyWeight (p : FreeRow×HeckeInverseAmplification.NonzeroIdeal) (z : ℂ) : + frequencyWeight z (sixthFrequencyEquiv p)= + frequencyWeight z ⟨p.1.val,p.1.property.1⟩*fullIdealWeight (6*z) p.2.val := by + have hu : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +abbrev SixthInnerIndex := HeckeInverseAmplification.NonzeroIdeal×((Id×Id)×Id) + +def sixthRawEquiv : FreeRow×SixthInnerIndex ≃ RawHighIndex := + (Equiv.prodAssoc _ _ _).symm.trans + (Equiv.prodCongr sixthFrequencyEquiv (Equiv.refl _)) + +def nonzeroLastEquiv : SixthInnerIndex ≃ {p : (Id×Id)×(Id×Id) // p.2.2≠0} where + toFun p := ⟨(p.2.1,(p.2.2,p.1.val)),p.1.property⟩ + invFun p := (⟨p.val.2.2,p.property⟩,(p.val.1,p.val.2.1)) + left_inv _ := rfl + right_inv _ := rfl + +lemma markedIdealHighSummand_last_zero (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) (I J K : Id) : + markedIdealHighSummand S D η u x w z I J K 0=0 := by + have hz : ¬(Squarefree I ∧ Supported I ∧ Supported J ∧ Supported K ∧ Supported (0:Id)) := + fun h=>h.2.2.2.2.1 rfl + simp only [markedIdealHighSummand,bareIdealHighSummand,bareIdealHighCoefficient, + dite_eq_right hz,zero_mul,mul_zero] + +lemma markedIdealHighSeries_eq_sixth_inner (S : Finset Id) (D : Id) (η : HeckeFamily.Character) + (u : O) (x w z : ℂ) : + markedIdealHighSeries S D η u x w z= + ∑'p : SixthInnerIndex,markedIdealHighSummand S D η u x w z p.2.1.1 p.2.1.2 p.2.2 p.1.val := by + have he := nonzeroLastEquiv.tsum_eq (fun p=> + markedIdealHighSummand S D η u x w z p.val.1.1 p.val.1.2 p.val.2.1 p.val.2.2) + change (∑'p : SixthInnerIndex,markedIdealHighSummand S D η u x w z p.2.1.1 p.2.1.2 p.2.2 p.1.val)=_ at he + rw [he] + unfold markedIdealHighSeries + symm + apply tsum_subtype_eq_of_support_subset + (f:=fun p : (Id×Id)×(Id×Id)=>markedIdealHighSummand S D η u x w z p.1.1 p.1.2 p.2.1 p.2.2) + (s:={p : (Id×Id)×(Id×Id) | p.2.2≠0}) + intro p hp hz + apply hp + change markedIdealHighSummand S D η u x w z p.1.1 p.1.2 p.2.1 p.2.2=0 + rw [hz,markedIdealHighSummand_last_zero] + +theorem rawArithmeticSeries_eq_sixth_high (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) + (hprime : ∀P∈S,Prime P) (hbad : fixedBadPrimes⊆S) + (D : Id) (η : HeckeFamily.Character) (x w z : ℂ) + (hx : 3/2star ((calibrationForSet S hS).residueMonoid H.val) + have hm (H : NonzeroFrequency) : ‖mask H‖≤1 := by + simpa only [mask,norm_star] using (calibrationForSet S hS).residueMonoid_norm_le_one H.val + have hs := (fullHighSummand_summable S D η x w z hx hw hz mask hm).comp_injective + rawHighEmbedding_injective + have ht : Summable (fun p : FreeRow×SixthInnerIndex=> + fullHighCoefficient S D η (fun H=>star ((calibrationForSet S hS).residueMonoid H.val)) x w z + (rawHighEmbedding (sixthRawEquiv p))) := hs.comp_injective sixthRawEquiv.injective + unfold rawArithmeticSeries + rw [←sixthRawEquiv.tsum_eq] + rw [ht.tsum_prod] + apply tsum_congr + intro u + rw [markedIdealHighSeries_eq_sixth_inner,←tsum_mul_left] + apply tsum_congr + intro p + exact rawHighCoefficient_sixth S hS hprime hbad D η x w z (u,p.1) p.2.1.1 p.2.1.2 p.2.2 + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceAmplitudeClasses.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceAmplitudeClasses.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce56409a5216a31f6b39ec364a60a995caa87ef2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceAmplitudeClasses.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Detector.SourceBatch +import OAI.NumberTheory.DirichletL.Hecke.DetectorAmplitudeFirst + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology +open Filter +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification HeckeDetectorBatch ProbePhysical +local notation "O" => HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_source_amplitude_batches (S : Finset (Ideal O)) (hS : SourceExclusions S) + (hmax : ∀P∈S,P.IsMaximal) (η : Character) + (dmin dmax τ ε e κ heightCost margin mesh binWidth : ℝ) (I : ℕ) + (hdmin : 0u.val) + W upper (fun j=>ell j/d) z (Z^d) + ∀bin : HeckeDetectorFiberPartition.BinLabel (Finset.univ : Finset (Fin N)) ((2*a-1)/2) binWidth, + let rows' := HeckeDetectorAmplitudeFirst.amplitudeRows rows Finset.univ + (Z^d) ((2*a-1)/2) binWidth hb (fun j=>ell j/d) Q bin + rows'.Nonempty → + let q := HeckeDetectorAmplitudeFirst.classMean Finset.univ ((2*a-1)/2) binWidth (fun j=>ell j/d) bin + ∃B : Batch M H (Sum Bool (RayQuotient.Characters M H)) (Fin N) + (Z^d) a ε (HeckeDetectorAdaptiveCutoff.cutoff (2*a-1) q) (Z^τ) ((Z^d)^(τ/(2*dmax))) i, + B.rows=rows' ∧ B.data=sourceMomentData M H hH S hS.prime η ∧ + B.reverse=sourceMomentReverse M H ∧ B.slots=Finset.univ ∧ + B.widths=(fun j=>ell j/d) ∧ B.profile=W ∧ B.upper=upper ∧ B.external=z ∧ + B.mesh=mesh ∧ B.binWidth=binWidth ∧ + (∀u∈rows',∀j,B.family u j=sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u) j) ∧ + (∀u∈B.rows,HeckeDetectorAmplitudeFirst.rowMean B.slots (Z^d) ((2*a-1)/2) B.binWidth B.widths + (HeckeDetectorPhysicalSelection.physical M H (fun u : FreeRow=>u.val) + B.profile B.upper B.widths B.external (Z^d)) u=q) := by + have hbatches := actual_source_batch M H hH S hS hmax η + dmin dmax τ ε e κ heightCost margin mesh binWidth I hdmin hdmax hdtop hτ hτzero hτheight + hε he he' hκ hκ' hheightCost hmargin hm hb hbudget + filter_upwards [hbatches] with Z hbatch + intro d hd hd' U rows hne hrows hcal hrow a i hi ha ha' hnext hcurrent N ell hell hsmall hsum W upper z + dsimp only + intro bin hne' + let Q := HeckeDetectorPhysicalSelection.physical M H (fun u : FreeRow=>u.val) + W upper (fun j=>ell j/d) z (Z^d) + let rows' := HeckeDetectorAmplitudeFirst.amplitudeRows rows Finset.univ + (Z^d) ((2*a-1)/2) binWidth hb (fun j=>ell j/d) Q bin + let q := HeckeDetectorAmplitudeFirst.classMean Finset.univ ((2*a-1)/2) binWidth (fun j=>ell j/d) bin + have hsub : rows'⊆rows := Finset.filter_subset _ _ + have hcut := HeckeDetectorAdaptiveCutoff.cutoff_bounds (2*a-1) q (by linarith) + obtain ⟨B,hBr,hBd,hRev,hSlots,hWidths,hW,hUpper,hZ,hMesh,hBin,hFam⟩ := + hbatch d hd hd' U rows' hne' (hsub.trans hrows) + (fun u hu=>hcal u (hsub hu)) (fun u hu=>hrow u (hsub hu)) a i hi ha ha' + (fun u hu=>hnext u (hsub hu)) (fun u hu=>hcurrent u (hsub hu)) + (HeckeDetectorAdaptiveCutoff.cutoff (2*a-1) q) hcut.1 hcut.2 N ell hell hsmall hsum W upper z + refine ⟨B,hBr,hBd,hRev,hSlots,hWidths,hW,hUpper,hZ,hMesh,hBin,hFam,?_⟩ + intro u hu + have hu' : u∈rows' := hBr ▸ hu + rw [hSlots,hWidths,hW,hUpper,hZ,hBin] + exact HeckeDetectorAmplitudeFirst.rowMean_eq rows Finset.univ (Z^d) ((2*a-1)/2) + binWidth hb (fun j=>ell j/d) Q bin u hu' +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceBatch.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceBatch.lean new file mode 100644 index 0000000000000000000000000000000000000000..3fc92060b6ee89a199f7c73439e388eec527bc92 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceBatch.lean @@ -0,0 +1,62 @@ +import OAI.NumberTheory.DirichletL.Detector.DetectorBatch +import OAI.NumberTheory.DirichletL.PrimeRows.CubeSupportedWitness + +namespace OAI + +noncomputable section +open scoped Classical BigOperators Topology +open Filter +namespace SevenEighths.ProbeHighRowFamily +open HeckeFamily HeckeInverseAmplification HeckeDetectorBatch ProbePhysical +local notation "O" => HeckeFamily.O +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +theorem actual_source_batch (S : Finset (Ideal O)) (hS : SourceExclusions S) + (hmax : ∀P∈S,P.IsMaximal) (η : Character) + (dmin dmax τ ε e κ heightCost margin mesh binWidth : ℝ) (I : ℕ) + (hdmin : 0ell j/d) ∧ B.profile=W ∧ B.upper=upper ∧ B.external=z ∧ + B.mesh=mesh ∧ B.binWidth=binWidth ∧ + (∀u∈rows,∀j,B.family u j=sourceDetectorFamily S hS.prime η u (rayCubeFamily M H hH u) j) := by + have hw := supported_witnesses_from_source_cube M H hH S hS hmax η + dmin dmax τ ε e κ heightCost margin I hdmin hdmax hτ hτzero hτheight hε he he' hκ hκ' hheightCost hmargin hbudget + filter_upwards [hw,eventually_ge_atTop (1:ℝ)] with Z hw hZ + intro d hd hd' U rows hne hrows hcal hrow a i hi ha ha' hnext hcurrent tstar ht ht' N ell hell hsmall hsum W upper z + obtain ⟨w⟩ := hw d hd hd' U rows hrows hcal hrow a i hi ha ha' + (fun u=>hnext u.val u.property) (fun u=>hcurrent u.val u.property) tstar ht ht' + obtain ⟨u0,h0⟩ := hne + have hnorm (u : FreeRow) (hu : u∈rows) : rowNorm u≤Z^d := + (hrow u hu).trans (Real.rpow_le_rpow_of_exponent_le hZ (by linarith)) + obtain ⟨hwp,hwm,hsp⟩ := physical_slot_widths ell d dmin mesh hdmin hd (hd'.trans hdtop) hell hsmall hsum + let B := retainedSourceBatch M H hH S hS η rows u0 h0 (Z^d) a ε tstar (Z^τ) + ((Z^d)^(τ/(2*dmax))) i (fun u hu=>w ⟨u,hu⟩) hnorm + Finset.univ W upper (fun j=>ell j/d) z mesh binWidth hm hb (fun j _=>hwp j) (fun j _=>hwm j) hsp + refine ⟨B,rfl,rfl,rfl,rfl,rfl,rfl,rfl,rfl,rfl,rfl,?_⟩ + intro u hu j + dsimp [B,retainedSourceBatch] + rw [retainedProjection_of_mem rows u0 u hu] +end SevenEighths.ProbeHighRowFamily + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceBounds.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..7cda8773d484619148b0c86784ffd8f15e9947ea --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceBounds.lean @@ -0,0 +1,46 @@ +import OAI.NumberTheory.DirichletL.Detector.SourceCoefficient +import OAI.NumberTheory.DirichletL.CubicSieve.GaussNorm + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open CubicEisenstein ProbePhase ProbeRow +local notation "O" => ActualEisensteinCubic.O + +theorem bareCongruenceCoefficient_norm_le (A s : O) (hA : A≠0) (hs : s≠0) (H : O) : + ‖bareCongruenceCoefficient A s hA H‖ ≤ + (Ideal.absNorm (Ideal.span {s}):ℝ)*(Ideal.absNorm (Ideal.span {A}):ℝ) := by + apply congruenceCoefficient_norm_le A s hA hs + · intro m + exact idealRowHom_norm _ _ + · intro m + exact idealRowHom_norm _ _ + +theorem bareSourceCoefficient_norm_le (η : HeckeFamily.Character) + (I : Ideal O) (hI : CubicSieve.Admissible I) (A s : O) + (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) (H : O) : + ‖bareSourceCoefficient η I hI.2 A s (supportedElement_ne_zero A hA) H‖ ≤ + (Ideal.absNorm (Ideal.span {s}):ℝ)*(Ideal.absNorm (Ideal.span {A}):ℝ) := by + have hR : ‖reciprocitySign A s‖≤1 := sexticReciprocityPhase_norm A s + have ht := targetMonoid_norm_le_one η A + have hfac : ‖targetMonoid η A‖*‖reciprocitySign A s‖≤1 := + (mul_le_of_le_one_left (norm_nonneg _) ht).trans hR + calc + _ = (‖targetMonoid η A‖*‖reciprocitySign A s‖)* + ‖bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H‖ := by + simp only [bareSourceCoefficient, correctedFiniteCoefficient, reciprocityCoefficient, + norm_mul,norm_star,CubicSieve.gaussTwo_norm_one I hI, + FiniteGaussPhase.norm_angularFactor A (supportedElement_ne_zero A hA), + G_norm_one_of_odd A (supported_residue_odd A hA),one_mul,mul_one] + ring + _ ≤ ‖bareCongruenceCoefficient A s (supportedElement_ne_zero A hA) H‖ := + mul_le_of_le_one_left (norm_nonneg _) hfac + _ ≤ _ := bareCongruenceCoefficient_norm_le A s (supportedElement_ne_zero A hA) + (supportedElement_ne_zero s hs) H + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceCoefficient.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceCoefficient.lean new file mode 100644 index 0000000000000000000000000000000000000000..3f5bdb7c22acfeae99c249a14a430db81b6a7d52 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceCoefficient.lean @@ -0,0 +1,79 @@ +import OAI.NumberTheory.DirichletL.Detector.CompletedCoefficient +import OAI.NumberTheory.DirichletL.Detector.CalibrationCancellation + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ProbePhase ProbeRow ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +def sourceHighCoefficient (C : CalibrationData) (η : HeckeFamily.Character) + (I : Ideal O) (hI : primaryGenerator I≠0) (A s : O) (hA : A≠0) (u a : O) : ℂ := + actualCongruenceCoefficient C A s hA (u*a^6) * idealRowHom C.generator (Ideal.span {s}) / + ((Real.sqrt (elementNorm C.generator):ℂ)*C.tau*C.residueMonoid s*star (C.residueMonoid u)) * + gaussTwo I hI * star (FiniteGaussPhase.angularFactor A * G A) * + targetMonoid η A * (C.Xi A)⁻¹ * reciprocitySign A s + +def bareSourceCoefficient (η : HeckeFamily.Character) (I : Ideal O) + (hI : primaryGenerator I≠0) (A s : O) (hA : A≠0) (H : O) : ℂ := + targetMonoid η A * star (FiniteGaussPhase.angularFactor A) * + correctedFiniteCoefficient I hI A s hA H + +theorem sourceHighCoefficient_eq_bare (S : Finset (Ideal O)) (hS : ∀ P∈S,P.IsMaximal) + (η : HeckeFamily.Character) (I : Ideal O) (hI : primaryGenerator I≠0) + (A s : O) (hA : Supported (Ideal.span {A})) (hs : Supported (Ideal.span {s})) + (hcop : IsCoprime (calibrationForSet S hS).generator (A*s)) (u a : O) + (hH : IsCoprime (calibrationForSet S hS).generator (u*a^6)) : + sourceHighCoefficient (calibrationForSet S hS) η I hI A s (supportedElement_ne_zero A hA) u a = + bareSourceCoefficient η I hI A s (supportedElement_ne_zero A hA) (u*a^6) := by + let C := calibrationForSet S hS + have ha : IsCoprime C.generator a := + hH.of_isCoprime_of_dvd_right (by refine ⟨u*a^5,?_⟩; ring) + have hval : C.residueMonoid (u*a^6)=C.residueMonoid u := by + rw [map_mul,map_pow,calibrationForSet_residue_sixth S hS a ha,mul_one] + have he := calibration_coefficient_cancel S hS A s hA hs hcop (u*a^6) hH + dsimp only at he + dsimp only [C] at hval + rw [hval] at he + unfold sourceHighCoefficient bareSourceCoefficient correctedFiniteCoefficient reciprocityCoefficient + simp only [star_mul] + calc + _ = (actualCongruenceCoefficient (calibrationForSet S hS) A s (supportedElement_ne_zero A hA) (u*a^6) * + idealRowHom (calibrationForSet S hS).generator (Ideal.span {s}) / + ((Real.sqrt (elementNorm (calibrationForSet S hS).generator):ℂ)*(calibrationForSet S hS).tau* + (calibrationForSet S hS).residueMonoid s*star ((calibrationForSet S hS).residueMonoid u)) * + ((calibrationForSet S hS).Xi A)⁻¹) * + (gaussTwo I hI * star (G A) * star (FiniteGaussPhase.angularFactor A) * + targetMonoid η A * reciprocitySign A s) := by ring + _ = _ := by rw [he]; ring + +theorem bareSourceCoefficient_product (η : HeckeFamily.Character) (I J : Ideal O) + (hI : CubicSieve.Admissible I) (hJ : CubicSieve.Admissible J) + (hIJ : CubicSieve.Admissible (I*J)) (hIJcop : IsCoprime I J) + (n m s r : O) + (hc : Supported (Ideal.span {primaryGenerator I})) (hd : Supported (Ideal.span {primaryGenerator J})) + (hn : Supported (Ideal.span {n})) (hm : Supported (Ideal.span {m})) + (hs : Supported (Ideal.span {s})) (hr : Supported (Ideal.span {r})) + (hpc : goodLambda^2∣primaryGenerator I-1) (hpd : goodLambda^2∣primaryGenerator J-1) + (hpn : goodLambda^2∣n-1) (hpm : goodLambda^2∣m-1) + (hps : goodLambda^2∣s-1) (hpr : goodLambda^2∣r-1) + (hcop : IsCoprime ((primaryGenerator I*n^3)*s) ((primaryGenerator J*m^3)*r)) (H : O) : + let A := primaryGenerator I*n^3 + let B := primaryGenerator J*m^3 + let hA := supportedElement_ne_zero A (supported_completed _ _ hc hn) + let hB := supportedElement_ne_zero B (supported_completed _ _ hd hm) + bareSourceCoefficient η (I*J) hIJ.2 (A*B) (s*r) (mul_ne_zero hA hB) H = + bareSourceCoefficient η I hI.2 A s hA H * bareSourceCoefficient η J hJ.2 B r hB H := by + have he := correctedFiniteCoefficient_product I J hI hJ hIJ hIJcop n m s r + hc hd hn hm hs hr hpc hpd hpn hpm hps hpr hcop H + dsimp only at he ⊢ + unfold bareSourceCoefficient + rw [he,map_mul,angularFactor_mul,star_mul] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceExclusions.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceExclusions.lean new file mode 100644 index 0000000000000000000000000000000000000000..438bef0305ffa1afef7198d392a664c32afdac80 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceExclusions.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Detector.HighLFactorization + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CanonicalQuadraticSieve UniqueFactorizationMonoid ProbeEuler +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma outside_prime_supported (S : Finset Id) (hbad : fixedBadPrimes⊆S) + (P : PrimeIdeal) (hP : P.val∉S) : Supported P.val := by + let : P.val.IsPrime := Ideal.isPrime_of_prime P.property + let : P.val.IsMaximal := Ideal.IsPrime.isMaximal inferInstance P.property.ne_zero + refine ⟨P.property.ne_zero,?_⟩ + intro Q hQ + have heq : Q=P.val := by + simpa only [normalizedFactors_irreducible P.property.irreducible,normalize_eq, + Multiset.mem_singleton] using hQ + subst Q + exact (prime_good_iff_not_bad P.val).mpr (fun h=>hP (hbad h)) + +structure SourceExclusions (S : Finset Id) : Prop where + prime : ∀P∈S,Prime P + bad : fixedBadPrimes⊆S + tail : CorrectionTail S + +theorem exists_source_exclusions (S₀ : Finset Id) (hp : ∀P∈S₀,Prime P) + (hbad : fixedBadPrimes⊆S₀) : + ∃S : Finset Id,S₀⊆S ∧ SourceExclusions S := by + obtain ⟨N,hN,hcut⟩ := exists_uniform_global_cutoff + refine ⟨S₀∪smallPrimeSet N,Finset.subset_union_left,?_⟩ + constructor + · intro P hP + rcases Finset.mem_union.mp hP with hP|hP + · exact hp P hP + · exact (Finset.mem_filter.mp hP).2 + · exact hbad.trans Finset.subset_union_left + · apply hcut + intro P hP + exact Finset.mem_union_right _ ((mem_smallPrimeSet N P).mpr hP) + +theorem source_principalHigh_L_factorization (S : Finset Id) (hS : SourceExclusions S) + (η : HeckeFamily.Character) (x w z : ℂ) (hx : 3/2 ActualEisensteinCubic.O +local instance : Countable O := ActualEisensteinCubic.latticeCoordEquiv.injective.countable +local instance : Countable (Ideal O) := ConcretePrimeRowBridge.idealGenerator_injective.countable +local instance (S : Finset (Ideal O)) : MeasurableSpace (SourceRawIndex S) := ⊤ +local instance (S : Finset (Ideal O)) : MeasurableSingletonClass (SourceRawIndex S) := ⟨fun _=>trivial⟩ + +lemma sourceRows_initial_integrable (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I)* + sourceRowSeries η S (calibrationForSet S hS) D ((3:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I)) heightMeasure := by + have hi := rawSourceOnLines_integrable η S hS D W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + X Y Z hX hY hZ + apply hi.integral_prod_right.congr + filter_upwards [hi.prod_left_ae] with p hp + rw [integral_count_eq_tsum _ hp] + have he := rawArithmeticSeries_eq_sixth_high S hS hpS hbad D η + ((3:ℂ)+p.1.1*Complex.I) ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + change rawArithmeticSeries S D η (calibrationForSet S hS) _ _ _= + sourceRowSeries η S (calibrationForSet S hS) D _ _ _ at he + rw [←he,rawArithmeticSeries_eq_sourceRaw] + simp only [rawSourceOnLines,initialHighOnLines,Complex.ofReal_ofNat,tsum_mul_right] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceLocal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceLocal.lean new file mode 100644 index 0000000000000000000000000000000000000000..551ce764a5e304d9afeef84fcb8c5a331bb15e1c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceLocal.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Detector.SpectralWeights +import OAI.NumberTheory.DirichletL.Detector.ZeroIndex + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) + +def sourceScalar (t k j : ℕ) : ℂ := + if t=0 then + if k=0 then 1 else (actualSextic (Ideal.span {p}) hg ^ k) (Ideal.Quotient.mk _ (p^j)) + else positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (t-1) k j + +def sourcePrincipalTerm (eta a x w z : ℂ) (e l k m : ℕ) : ℂ := + sourceWeightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (localGamma p hp.ne_zero hg 1) (star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) x w z + (sourceScalar p hp hg (e+3*l) k (6*m)) e l k m + +lemma sourcePrincipalTerm_pos (eta a x w z : ℂ) (e l k m : ℕ) (ht : e+3*l≠0) : + sourcePrincipalTerm p hp hg eta a x w z e l k m = + principalMarkedTerm p hp hg eta a + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) + (coordV (Ideal.absNorm (Ideal.span {p})) z) e l k m := by + unfold sourcePrincipalTerm + rw [sourceWeightedScalar_actual p hp hg] + simp only [sourceScalar, ht, ite_false, principalMarkedTerm, coordV, Complex.ofReal_natCast] + +lemma sourcePrincipalTerm_zero (eta a x w z : ℂ) (k m : ℕ) : + sourcePrincipalTerm p hp hg eta a x w z 0 0 k m = + zeroIndexTerm p (actualSextic (Ideal.span {p}) hg) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) + (coordV (Ideal.absNorm (Ideal.span {p})) z) k m := by + unfold sourcePrincipalTerm + rw [sourceWeightedScalar_actual p hp hg] + simp only [weightedScalar, localCubePhase, sourceScalar, zeroIndexTerm, coordV, + mul_zero, add_zero, pow_zero, one_mul, zero_mul, Nat.choose_zero_succ, + ite_true, Complex.ofReal_natCast] + +def sourcePrincipalSeries (eta a x w z : ℂ) : ℂ := + ∑ e : Fin 2, ∑' l, ∑' k, ∑' m, sourcePrincipalTerm p hp hg eta a x w z e.val l k m + +include hc in +lemma sourcePrincipalSeries_eq (eta a x w z : ℂ) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖coordR (Ideal.absNorm (Ideal.span {p})) (a^2) x z‖<1) + (hW : ‖coordW (Ideal.absNorm (Ideal.span {p})) 1 w‖<1) : + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + sourcePrincipalSeries p hp hg eta a x w z = + principalFullSeries p hp hg eta a ((Q:ℂ)^(-x)) ((Q:ℂ)^(-w)) (coordV Q z) := by + dsimp only + simp only [Complex.ofReal_natCast] + let X : ℂ := (Ideal.absNorm (Ideal.span {p}):ℂ)^(-x) + let W : ℂ := (Ideal.absNorm (Ideal.span {p}):ℂ)^(-w) + let V : ℂ := coordV (Ideal.absNorm (Ideal.span {p})) z + have hQ : 0 < (Ideal.absNorm (Ideal.span {p}):ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + have hr : ‖evenRatio (Ideal.absNorm (Ideal.span {p})) a X V‖<1 := by + have he := evenRatio_eq_coordR _ hQ a x z + simp only [Complex.ofReal_natCast] at he + change ‖evenRatio _ a _ _‖<1 + rw [he] + exact hR + have hW' : ‖W‖<1 := by simpa only [W, coordW, one_mul, Complex.ofReal_natCast] using hW + have he : Summable (fun l => principalInner p hp hg eta a X W V 0 l) := + (principalInner_even_hasSum p hp hg hc eta a X W V hV hr).summable + have h0 : (fun l => ∑' k, ∑' m, sourcePrincipalTerm p hp hg eta a x w z 0 l k m) = + (fun l => principalInner p hp hg eta a X W V 0 l + + if l=0 then zeroIndexSeries p (actualSextic (Ideal.span {p}) hg) W V else 0) := by + funext l + by_cases hl : l=0 + · subst l + simp only [sourcePrincipalTerm_zero, principalInner_zero p hp hg, ite_true, + zero_add, zeroIndexSeries, W, V] + · rw [ite_eq_right hl, add_zero] + apply tsum_congr + intro k + apply tsum_congr + intro m + exact sourcePrincipalTerm_pos p hp hg eta a x w z 0 l k m (by omega) + have h1 : (fun l => ∑' k, ∑' m, sourcePrincipalTerm p hp hg eta a x w z 1 l k m) = + (fun l => principalInner p hp hg eta a X W V 1 l) := by + funext l + apply tsum_congr + intro k + apply tsum_congr + intro m + exact sourcePrincipalTerm_pos p hp hg eta a x w z 1 l k m (by omega) + unfold sourcePrincipalSeries principalFullSeries principalMarkedSeries + simp only [Fin.sum_univ_two, Fin.val_zero, Fin.val_one] + rw [h0, h1, he.tsum_add (hasSum_ite_eq 0 _).summable, tsum_ite_eq] + rw [zeroIndexSeries_eq p hp _ W V hW' hV] + change _ = 1/(1-V)+W/(1-W)+((∑' l, principalInner p hp hg eta a X W V 0 l)+ + ∑' l, principalInner p hp hg eta a X W V 1 l) + ring + +include hc in + +theorem sourcePrincipalSeries_euler_identity (eta a x w z : ℂ) + (hV : ‖coordV (Ideal.absNorm (Ideal.span {p})) z‖<1) + (hR : ‖coordR (Ideal.absNorm (Ideal.span {p})) (a^2) x z‖<1) + (hW : ‖coordW (Ideal.absNorm (Ideal.span {p})) 1 w‖<1) + (hD : 1-coordD (Ideal.absNorm (Ideal.span {p})) eta 1 x ≠ 0) : + let Q : ℝ := Ideal.absNorm (Ideal.span {p}) + sourcePrincipalSeries p hp hg eta a x w z = + (1-coordD Q eta 1 x) / ((1-coordV Q z)*(1-coordW Q 1 w)) * + unramifiedClosed Q (a^2) eta 1 x w z := by + rw [sourcePrincipalSeries_eq p hp hg hc eta a x w z hV hR hW] + exact principalFullSeries_euler_identity p hp hg hc eta a x w z hV hR hW hD + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourcePrime.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourcePrime.lean new file mode 100644 index 0000000000000000000000000000000000000000..9771fb1b3c2aba5f134f649dd1be075693557a36 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourcePrime.lean @@ -0,0 +1,105 @@ +import OAI.NumberTheory.DirichletL.Detector.SourceCoefficient +import OAI.NumberTheory.DirichletL.Detector.PhysicalLocalEuler + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic ActualEisensteinCoordinates CompletedGauss CanonicalRowCompletion +open CanonicalQuadraticSieve ConcretePrimeRowBridge CubicEisenstein ConcreteTraceCRT +open ProbePhase ProbeEuler ProbePrimePower FiniteGaussPhase QuadraticGaussRay +local notation "O" => ActualEisensteinCubic.O + +theorem gaussTwo_prime_localGamma (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hprimary : goodLambda^2∣p-1) (hI : primaryGenerator (Ideal.span {p})≠0) : + gaussTwo (Ideal.span {p}) hI=localGamma p hp.ne_zero hg 2 := by + let pp : Unit→O := fun _=>p + have hpp : ∀i,pp i≠0 := fun _=>hp.ne_zero + have hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {pp i})) := by + intro i j hij + exact (hij (Subsingleton.elim i j)).elim + have hi : primaryGenerator (Ideal.span {∏i,pp i})≠0 := by simpa [pp] using hI + have he := gaussTwo_eq_canonicalProductGauss pp hpp hcop (fun _=>hg) (fun _=>hprimary) hi + rw [canonicalProductGauss_cross_factors pp hpp hcop (fun _ => hg) (fun _ => 2)] at he + simpa [pp,localGamma,ConcreteBreveE.normalizedTraceGauss] using he + +theorem G_prime_localG (p : O) (hp : p≠0) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) : + G p=MixedGaussConversion.localG p hp hg := by + let pp : Unit→O := fun _=>p + have hpp : ∀i,pp i≠0 := fun _=>hp + have hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {pp i})) := by + intro i j hij + exact (hij (Subsingleton.elim i j)).elim + have he := canonicalProductG_eq_fixedGValue pp hpp hcop (fun _=>hg) + (fun _=>hchar) (fun _=>hprimary) + unfold canonicalProductG at he + rw [canonicalProductGauss_cross_factors pp hpp hcop (fun _ => hg) (fun _ => 3)] at he + simpa [pp,G,fixedGQuotientValue,MixedGaussConversion.localG,breveLocalG,breveGamma3, + ConcreteBreveE.normalizedTraceGauss] using he.symm + +theorem localGamma_one_two_full_signal (p : O) (hp : p≠0) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) : + localGamma p hp hg 1 * localGamma p hp hg 2 = + -FiniteGaussPhase.angularFactor p * G p := by + rw [G_prime_localG p hp hg hchar hprimary] + exact localGamma_one_two_signal p hp hg hchar hprimary + +lemma angularFactor_pow (p : O) (n : ℕ) : angularFactor (p^n)=angularFactor p^n := by + simp only [angularFactor,map_pow,norm_pow,Complex.ofReal_pow,div_pow] + +lemma gaussTwo_one : gaussTwo (1:Ideal O) (by rw [primaryGenerator_one]; exact one_ne_zero)=1 := by + have hI : CubicSieve.Admissible (1:Ideal O) := ⟨squarefree_one,by rw [primaryGenerator_one]; exact one_ne_zero⟩ + rw [gaussTwo_eq_elementFourier (1:Ideal O) hI] + simp only [primaryGenerator_one,map_one,norm_one,Complex.ofReal_one,div_one] + have hrow (a : O) : CubicSieve.cubicRow (1:Ideal O) a=1 := by + rw [CubicSieve.cubicRow,←idealRowHom_square,map_one,one_pow] + rw [show CubicSieve.cubicRow (1:Ideal O)=(fun _=>1) from funext hrow] + have he : elementFourier 1 one_ne_zero (fun _=>1) 1=sexticGauss 1 one_ne_zero 1 := by + unfold elementFourier sexticGauss + apply tsum_congr + intro x + simp only [Ideal.span_singleton_one,←Ideal.one_eq_top,map_one,one_mul] + rw [he,sexticGauss_one] + +lemma gaussTwo_prime_power_small (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hprimary : goodLambda^2∣p-1) (e : ℕ) (he : e≤1) + (hI : primaryGenerator (Ideal.span {p^e})≠0) : + gaussTwo (Ideal.span {p^e}) hI=localGamma p hp.ne_zero hg 2^e := by + have hcases : e=0 ∨ e=1 := by omega + rcases hcases with rfl|rfl + · simpa only [pow_zero,Ideal.span_singleton_one,←Ideal.one_eq_top] using gaussTwo_one + · have hi : primaryGenerator (Ideal.span {p})≠0 := by simpa only [pow_one] using hI + simpa only [pow_one] using gaussTwo_prime_localGamma p hp hg hprimary hi + +lemma corrected_prime_cubic_signal (p : O) (hp : p≠0) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) : + localGamma p hp hg 2 * star (angularFactor p) * star (G p) = -(localGamma p hp hg 1)⁻¹ := by + have hsig := localGamma_one_two_full_signal p hp hg hchar hprimary + have hn := localGamma_norm_one p hp hg hchar 1 (by decide) (by decide) + have hne : localGamma p hp hg 1≠0 := by intro h; rw [h,norm_zero] at hn; norm_num at hn + have hG : G p*star (G p)=1 := by + rw [mul_comm] + exact G_conjugate_cancel p (supported_residue_odd p hs) + (cubicTwo_isUnit_of_odd p (supported_residue_odd p hs)) + apply mul_left_cancel₀ hne + calc + _ = (localGamma p hp hg 1*localGamma p hp hg 2)*star (angularFactor p)*star (G p) := by ring + _ = -1 := by + rw [hsig] + calc + _ = -(angularFactor p*star (angularFactor p))*(G p*star (G p)) := by ring + _ = _ := by rw [angularFactor_mul_star p hp,hG]; ring + _ = _ := by rw [mul_neg,mul_inv_cancel₀ hne] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourcePrimeFactor.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourcePrimeFactor.lean new file mode 100644 index 0000000000000000000000000000000000000000..86dde64a1b4a95075ec4e6de09cb032c336540f3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourcePrimeFactor.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Detector.SourcePrime + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion CanonicalQuadraticSieve +open ConcretePrimeRowBridge CubicEisenstein ProbePhase ProbeEuler ProbePrimePower ProbeRow +local notation "O" => ActualEisensteinCubic.O + +theorem bareSourceCoefficient_prime_formula (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (e l k j : ℕ) (he : e≤1) + (hI : primaryGenerator (Ideal.span {p^e})≠0) : + bareSourceCoefficient η (Ideal.span {p^e}) hI (p^(e+3*l)) (p^k) + (pow_ne_zero _ hp.ne_zero) (p^j) = + (-1:ℂ)^e * ((localGamma p hp.ne_zero hg 1)⁻¹)^e * (targetMonoid η p)^e * + (star (FiniteGaussPhase.angularFactor p)^3 * (targetMonoid η p)^3 * + star (localGamma p hp.ne_zero hg 3))^l * + (actualSextic (Ideal.span {p}) hg (-1))^((e+3*l)*k+e*l+l.choose 2) * + sourceScalar p hp hg (e+3*l) k j := by + have ho := supported_residue_odd p hs + have hself := reciprocitySign_self_eq_sextic_neg_one p hp.ne_zero hg hchar ho + have hstar : star (actualSextic (Ideal.span {p}) hg (-1))= + actualSextic (Ideal.span {p}) hg (-1) := by + rw [←hself,reciprocitySign_star] + unfold bareSourceCoefficient correctedFiniteCoefficient reciprocityCoefficient + rw [gaussTwo_prime_power_small p hp hg hprimary e he hI, + bareCongruenceCoefficient_all_prime_powers p hp hg, + angularFactor_pow,map_pow, + G_completed_prime_power p ho e l he, + G_cube_eq_normalizedTraceGauss p hp.ne_zero hg hchar ho, + reciprocitySign_pow_left p _ (odd_residue_pow p ho k),reciprocitySign_pow_right p p ho, + hself] + change _ = _ + simp only [star_mul,star_pow,hstar] + change (targetMonoid η p)^(e+3*l) * star (FiniteGaussPhase.angularFactor p)^(e+3*l) * + (localGamma p hp.ne_zero hg 2^e * + ((actualSextic (Ideal.span {p}) hg (-1))^(e*l+l.choose 2) * + (star (localGamma p hp.ne_zero hg 3)^l * star (G p)^e)) * + (((actualSextic (Ideal.span {p}) hg (-1))^k)^(e+3*l) * + sourceScalar p hp hg (e+3*l) k j)) = _ + calc + _ = (localGamma p hp.ne_zero hg 2 * star (FiniteGaussPhase.angularFactor p) * star (G p))^e * + (targetMonoid η p)^e * + (star (FiniteGaussPhase.angularFactor p)^3*(targetMonoid η p)^3* + star (localGamma p hp.ne_zero hg 3))^l * + (actualSextic (Ideal.span {p}) hg (-1))^((e+3*l)*k+e*l+l.choose 2) * + sourceScalar p hp hg (e+3*l) k j := by + simp only [pow_add,pow_mul,mul_pow] + ring + _ = _ := by + rw [corrected_prime_cubic_signal p hp.ne_zero hg hchar hprimary hs] + rw [neg_eq_neg_one_mul ((localGamma p hp.ne_zero hg 1)⁻¹),mul_pow] + +theorem bareSourceCoefficient_weighted_prime (η : HeckeFamily.Character) (p : O) (hp : Prime p) + [(Ideal.span {p}:Ideal O).IsMaximal] (hg : goodLambda∉Ideal.span {p}) + (hchar : ringChar (O ⧸ Ideal.span {p})≠2) (hprimary : goodLambda^2∣p-1) + (hs : Supported (Ideal.span {p})) (e l k m : ℕ) (he : e≤1) + (hI : primaryGenerator (Ideal.span {p^e})≠0) (x w z : ℂ) : + bareSourceCoefficient η (Ideal.span {p^e}) hI (p^(e+3*l)) (p^k) + (pow_ne_zero _ hp.ne_zero) (p^(6*m)) * + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(x+1/2)*(e:ℂ)-(1+3*x)*(l:ℂ)-w*(k:ℂ)-6*z*(m:ℂ)) = + sourcePrincipalTerm p hp hg (targetMonoid η p) (actualACube η p) x w z e l k m := by + rw [bareSourceCoefficient_prime_formula η p hp hg hchar hprimary hs e l k (6*m) he hI] + unfold sourcePrincipalTerm sourceWeightedScalar + simp only [zpow_neg,zpow_natCast,←inv_pow,Complex.ofReal_natCast] + have hpdiag := source_signed_phase + (actualACube η p*star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) (actualSextic_neg_one_sq _ hg) e l k + simp only [localCubePhase] at hpdiag + have ha : actualACube η p= + star (FiniteGaussPhase.angularFactor p)^3*(targetMonoid η p)^3 := rfl + rw [ha] at hpdiag ⊢ + calc + _ = ((-1:ℂ)^e*((localGamma p hp.ne_zero hg 1)⁻¹)^e*(targetMonoid η p)^e) * + ((star (FiniteGaussPhase.angularFactor p)^3*(targetMonoid η p)^3* + star (localGamma p hp.ne_zero hg 3))^l * + (actualSextic (Ideal.span {p}) hg (-1))^((e+3*l)*k+e*l+l.choose 2)) * + sourceScalar p hp hg (e+3*l) k (6*m) * + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(x+1/2)*(e:ℂ)-(1+3*x)*(l:ℂ)-w*(k:ℂ)-6*z*(m:ℂ)) := by ring + _ = _ := by rw [←hpdiag]; ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SourceTriple.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SourceTriple.lean new file mode 100644 index 0000000000000000000000000000000000000000..118c852ecd12a7d721be7500378769faa65d5682 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SourceTriple.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Detector.RawSourceIntegral +import OAI.NumberTheory.DirichletL.Detector.SixthSeries + +namespace OAI + +noncomputable section +open scoped Classical +open MeasureTheory +namespace SevenEighths.ProbePhysical +open ProbeMellinBoundary ProbeCompleted HeckeInverseAmplification CanonicalQuadraticSieve +local notation "O" => ActualEisensteinCubic.O + +def sourceRowSeries (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (C : CalibrationData) (D : Ideal O) (x w z : ℂ) : ℂ := + ∑'u : FreeRow,star (C.residueMonoid u.val)*frequencyWeight z ⟨u.val,u.property.1⟩* + markedIdealHighSeries S D η u.val x w z + +def sourceTripleIntegral (η : HeckeFamily.Character) (S : Finset (Ideal O)) + (hS : ∀P∈S,P.IsMaximal) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3*∫p : HeightSpace, + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I)* + sourceRowSeries η S (calibrationForSet S hS) D ((3:ℂ)+p.1.1*Complex.I) + ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) ∂heightMeasure + +lemma rawSourceTripleIntegral_eq_source (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z : ℝ) : + rawSourceTripleIntegral η S hS D W0 W1 X Y Z= + sourceTripleIntegral η S hS D W0 W1 X Y Z := by + unfold rawSourceTripleIntegral sourceTripleIntegral + congr 1 + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro p + dsimp only + congr 1 + unfold sourceRowSeries + exact rawArithmeticSeries_eq_sixth_high S hS hpS hbad D η + ((3:ℂ)+p.1.1*Complex.I) ((3:ℂ)+p.2*Complex.I) ((2:ℂ)+p.1.2*Complex.I) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + (by norm_num [Complex.add_re,Complex.mul_re]) + +theorem markedPhysicalProbe_eq_source_triple (η : HeckeFamily.Character) + (S : Finset (Ideal O)) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (hSne : S.Nonempty) (D : Ideal O) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0 ActualEisensteinCubic.O + +lemma rayMask_supported (a : O) (ha : Supported (Ideal.span {a})) : RayFourExpansion.rayMask a=1 := by + let : (Ideal.span {(2:O)}).IsMaximal := by + simpa only [cubicTwoIdeal,Ideal.span_singleton_neg] using cubicTwoIdeal_isMaximal + let : Field (O⧸Ideal.span {(2:O)}) := Ideal.Quotient.field _ + have h2 : IsCoprime (2:O) a := by + apply (isUnit_quotient_span_iff _ _).mp + apply isUnit_iff_ne_zero.mpr + intro hz + exact ((supported_span_iff a).mp ha).2 + (Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp hz)) + have h4 : IsCoprime (4:O) a := by + simpa only [show (2:O)^2=4 by norm_num] using (h2.pow_left : IsCoprime ((2:O)^2) a) + exact ite_eq_left ((isUnit_quotient_span_iff (4:O) a).mpr h4) + +lemma completedCorrection_supported (I J : Ideal O) (hI : Supported I) (hJ : Supported J) : + completedCorrection I J=star (G (completedIndex I J)) := by + rw [completedCorrection_eq_phase,rayMask_supported] + · exact one_mul _ + · exact supported_completed _ _ ((supported_span_primaryGenerator_iff I).mpr hI) + ((supported_span_primaryGenerator_iff J).mpr hJ) + +lemma baseRowCoefficient_unit_apply (η : HeckeFamily.Character) (C : CalibrationData) + (s : O) (hs : Supported (Ideal.span {s})) (A : O) (hA : Supported (Ideal.span {A})) + (hcop : IsCoprime C.generator A) : + baseRowCoefficient η C.Xi s hs A=targetMonoid η A*(C.Xi A)⁻¹*reciprocitySign A s := by + change targetMonoid η A*star (C.Xi A)*sexticReciprocityPhase s A=_ + have hc : star (C.Xi A)=(C.Xi A)⁻¹ := (Complex.inv_eq_conj (C.Xi_norm_one A hA hcop)).symm + rw [hc] + congr 1 + exact congrArg (fun n : ℤ=>(n:ℂ)) (QuadraticAllOddCRT.quadraticRaySign_symm _ _) + +theorem spectralSummand_source_coefficient (S : Finset (Ideal O)) (D I J : Ideal O) + (η : HeckeFamily.Character) (C : CalibrationData) (s : O) (hs : Supported (Ideal.span {s})) + (hI : Supported I) (hJ : Supported J) (hsf : Squarefree I) + (hcop : IsCoprime C.generator (completedIndex I J)) (t : ℂ) : + spectralSummand S D (baseRowCoefficient η C.Xi s hs) t I J= + completedMask S D I J * + (gaussTwo I (supported_primaryGenerator_ne_zero I hI)* + star (FiniteGaussPhase.angularFactor (completedIndex I J)*G (completedIndex I J))* + targetMonoid η (completedIndex I J)*(C.Xi (completedIndex I J))⁻¹* + reciprocitySign (completedIndex I J) s) / + ((Real.sqrt (Ideal.absNorm I):ℂ)*(Ideal.absNorm J:ℂ)) * + (fullIdealWeight t I*fullIdealWeight (3*t) J) := by + have hA := supported_completed _ _ ((supported_span_primaryGenerator_iff I).mpr hI) + ((supported_span_primaryGenerator_iff J).mpr hJ) + have hb := baseRowCoefficient_unit_apply η C s hs (completedIndex I J) hA hcop + have hangle : FiniteGaussPhase.angularFactor (completedIndex I J)= + FiniteGaussPhase.angularFactor (primaryGenerator I)*FiniteGaussPhase.angularFactor (primaryGenerator J)^3 := by + rw [completedIndex,angularFactor_mul,show primaryGenerator J^3=(primaryGenerator J*primaryGenerator J)*primaryGenerator J by ring, + angularFactor_mul,angularFactor_mul] + ring + have hm : baseRowCoefficient η C.Xi s hs (primaryGenerator I)* + baseRowCoefficient η C.Xi s hs (primaryGenerator J)^3= + targetMonoid η (completedIndex I J)*(C.Xi (completedIndex I J))⁻¹*reciprocitySign (completedIndex I J) s := by + rw [←map_pow,←map_mul] + exact hb + unfold spectralSummand CompletedGauss.columnWeight + rw [completedCorrection_supported I J hI hJ,squarefreeGaussCoefficient_eq I hsf + (supported_primaryGenerator_ne_zero I hI)] + change _*(star (FiniteGaussPhase.angularFactor (primaryGenerator J))^3* + baseRowCoefficient η C.Xi s hs (primaryGenerator J)^3/(Ideal.absNorm J:ℂ))*_=_ + rw [hangle] + simp only [star_mul,star_pow] + calc + _ = completedMask S D I J* + (gaussTwo I (supported_primaryGenerator_ne_zero I hI)* + (star (FiniteGaussPhase.angularFactor (primaryGenerator I))* + star (FiniteGaussPhase.angularFactor (primaryGenerator J))^3)*star (G (completedIndex I J))* + (baseRowCoefficient η C.Xi s hs (primaryGenerator I)*baseRowCoefficient η C.Xi s hs (primaryGenerator J)^3)) / + ((Real.sqrt (Ideal.absNorm I):ℂ)*(Ideal.absNorm J:ℂ))*(fullIdealWeight t I*fullIdealWeight (3*t) J) := by ring + _ = _ := by rw [hm];ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SpectralCompensation.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SpectralCompensation.lean new file mode 100644 index 0000000000000000000000000000000000000000..90afae84a8de93cbafd7aa796298c10d21443633 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SpectralCompensation.lean @@ -0,0 +1,49 @@ +import OAI.NumberTheory.DirichletL.Detector.MarkedProduct +import OAI.NumberTheory.DirichletL.Detector.MarkedRational +import Mathlib.Algebra.BigOperators.Ring.Finset + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def spectralCompensatedHigh (S : Finset Id) (T : Finset PrimeIdeal) + (η : HeckeFamily.Character) (x w z : ℂ) (B q : PrimeIdeal→ℂ) : ℂ := + ∑J∈T.powerset,(-1:ℂ)^J.card*(∏P∈J,q P)*(∏P∈T\J,B P)* + markedIdealHighSeries S (∏P∈T\J,P.val) η 1 x w z + +theorem spectralCompensatedHigh_eq_product (S : Finset Id) (hS : SourceExclusions S) + (T : Finset PrimeIdeal) (hT : ∀P∈T,P.val∉S) (η : HeckeFamily.Character) + (x w z : ℂ) (B q : PrimeIdeal→ℂ) + (hx : 3/2hT P (Finset.mem_sdiff.mp hP).1) η x w z hx hw hz] + simp only [mul_div_assoc,Finset.prod_mul_distrib] + ring + +theorem spectralCompensatedHigh_L_factorization (S : Finset Id) (hS : SourceExclusions S) + (T : Finset PrimeIdeal) (hT : ∀P∈T,P.val∉S) (η : HeckeFamily.Character) + (x w z : ℂ) (B q : PrimeIdeal→ℂ) + (hx : 3/2 ActualEisensteinCubic.O + +def transformedSpectralTerm (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D : Ideal O) (s : O) (hs : Supported (Ideal.span {s})) + (W : ℝ → ℂ) (K : ℝ) (t : ℂ) (I J : Ideal O) : ℂ := + if hA : completedIndex I J≠0 then + spectralSummand S D (baseRowCoefficient η C.Xi s hs) t I J * + ((K/elementNorm (C.generator*completedIndex I J):ℝ):ℂ) * + ∑' H : O, actualCongruenceCoefficient C (completedIndex I J) s hA H * + paperRadialFourier W (K*elementNorm H/elementNorm ((C.generator*completedIndex I J)*s)) + else 0 + +theorem physical_spectral_poisson (η : HeckeFamily.Character) (C : CalibrationData) + (S : Finset (Ideal O)) (D : Ideal O) (s : O) (hs : Supported (Ideal.span {s})) + (W : ℝ → ℂ) (hWc : HasCompactSupport W) (hWs : ContDiff ℝ ∞ W) + (K : ℝ) (hK : 0 ActualEisensteinCubic.O + +def baseRowCoefficient (η : HeckeFamily.Character) (Xi : O →* ℂ) + (s : O) (hs : Supported (Ideal.span {s})) : O →* ℂ := + targetMonoid η * InitialMeanSquare.conjugateMonoid Xi * reciprocityPhaseMonoid s hs + +lemma spectralSummand_mul_fixed_twist (S : Finset (Ideal O)) (D I J : Ideal O) + (φ Ψ : O →* ℂ) (t : ℂ) : + spectralSummand S D (φ*Ψ) t I J = + φ (completedIndex I J) * spectralSummand S D Ψ t I J := by + have hc (η : O →* ℂ) : cubeWeight η J = + star (FiniteGaussPhase.angularFactor (primaryGenerator J))^3 * + η (primaryGenerator J)^3 / (Ideal.absNorm J:ℂ) := rfl + unfold spectralSummand + rw [hc, hc] + simp only [columnWeight, MonoidHom.mul_apply, map_mul, map_pow, mul_pow, completedIndex] + ring + +theorem spectralSummand_row_separation (S : Finset (Ideal O)) (D I J : Ideal O) + (η : HeckeFamily.Character) (Xi : O →* ℂ) (s : O) + (hs : Supported (Ideal.span {s})) (m : O) (t : ℂ) : + spectralSummand S D (rowCoefficient η Xi s hs m) t I J = + idealRowHom m (Ideal.span {completedIndex I J}) * + spectralSummand S D (baseRowCoefficient η Xi s hs) t I J := by + have hr : rowCoefficient η Xi s hs m = + ((idealRowHom m).toMonoidHom.comp principalIdealHom.toMonoidHom) * + baseRowCoefficient η Xi s hs := by + change _ * _ = _ * _ + exact mul_comm _ _ + rw [hr, spectralSummand_mul_fixed_twist] + rfl + +theorem calibrated_spectralSummand_separation (S : Finset (Ideal O)) (D I J : Ideal O) + (η : HeckeFamily.Character) (C : ProbePhysical.CalibrationData) (s : O) + (hs : Supported (Ideal.span {s})) (m : O) (t : ℂ) : + C.residueMonoid m * spectralSummand S D (rowCoefficient η C.Xi s hs m) t I J = + ProbePhysical.calibratedNumerator C (completedIndex I J) m * + spectralSummand S D (baseRowCoefficient η C.Xi s hs) t I J := by + rw [spectralSummand_row_separation] + unfold ProbePhysical.calibratedNumerator + ring + +theorem spectralSummand_zero_completedIndex (S : Finset (Ideal O)) (D I J : Ideal O) + (Ψ : O →* ℂ) (t : ℂ) (hz : completedIndex I J=0) : + spectralSummand S D Ψ t I J=0 := by + rcases mul_eq_zero.mp hz with hI | hJ + · have hg : squarefreeGaussCoefficient I=0 := by + unfold squarefreeGaussCoefficient + rw [dite_eq_right (by simp [hI])] + simp only [spectralSummand, columnWeight, hg, zero_mul, zero_div, mul_zero] + · have hJ' : primaryGenerator J=0 := (pow_eq_zero_iff (by decide : 3≠0)).mp hJ + have hc : cubeWeight Ψ J=0 := by + change star (FiniteGaussPhase.angularFactor (primaryGenerator J))^3 * + Ψ (primaryGenerator J)^3 / (Ideal.absNorm J:ℂ)=0 + simp [hJ', FiniteGaussPhase.angularFactor] + simp only [spectralSummand, hc, mul_zero, zero_mul] + +end SevenEighths.ProbeRow +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SpectralSupport.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SpectralSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..e2f1b9efbe808dcd2d41da18e9789037c34c6f80 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SpectralSupport.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Detector.PhysicalMellinCoefficient +import OAI.NumberTheory.DirichletL.Detector.RadialSpectral + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve +open ProbeCompleted ProbeRow SecondPassArithmetic +local notation "O" => ActualEisensteinCubic.O + +lemma supported_of_source_exclusions (S : Finset (Ideal O)) + (hbad : fixedBadPrimes⊆S) (I : Ideal O) (hI : I≠0) + (hS : ∀P∈S,¬P∣I) : Supported I := by + refine ⟨hI,?_⟩ + intro P hP + have hp : Prime P := UniqueFactorizationMonoid.prime_of_normalized_factor P hP + let : P.IsMaximal := (Ideal.isPrime_of_prime hp).isMaximal hp.ne_zero + apply (prime_good_iff_not_bad P).mpr + intro hb + exact hS P (hbad hb) (UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors hP) + +lemma spectralSummand_support (S : Finset (Ideal O)) (hbad : fixedBadPrimes⊆S) + (D I J : Ideal O) (Ψ : O→*ℂ) (t : ℂ) + (h : spectralSummand S D Ψ t I J≠0) : + Squarefree I ∧ Supported I ∧ Supported J := by + have hI : I≠0 := by + intro hz + subst I + exact h (by simp [spectralSummand]) + have hJ : J≠0 := by + intro hz + subst J + exact h (by simp [spectralSummand]) + have hsf : Squarefree I := by + by_contra hn + exact h (by simp [spectralSummand,columnWeight,squarefreeGaussCoefficient,hn]) + have hm := spectralSummand_mask_nonzero S D I J Ψ t h + have hex : ∀P∈S,¬P∣I*J^3 := by + unfold completedMask at hm + split_ifs at hm with hd + · exact hd.2 + · exact False.elim (hm rfl) + refine ⟨hsf,supported_of_source_exclusions S hbad I hI ?_, + supported_of_source_exclusions S hbad J hJ ?_⟩ + · intro P hP hd + exact hex P hP (dvd_mul_of_dvd_left hd _) + · intro P hP hd + exact hex P hP (dvd_mul_of_dvd_right (hd.trans (dvd_pow_self J (by decide : 3≠0))) _) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/SpectralWeights.lean b/lean/OAI/NumberTheory/DirichletL/Detector/SpectralWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..dcf1e3a445361b7fe90404be92ff68531f3ac85d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/SpectralWeights.lean @@ -0,0 +1,118 @@ +import OAI.NumberTheory.DirichletL.Detector.PrincipalEulerIdentity + +namespace OAI + +noncomputable section +namespace SevenEighths.ProbeEuler + +lemma signed_diagonal_phase (omega : ℂ) (ho : omega^2=1) (e l k : ℕ) : + omega^(((e+3*l)*k:ℕ):ℤ) * omega^(-((e*l+l.choose 2:ℕ):ℤ)) = + omega^((e+3*l)*k+e*l+l.choose 2) := by + have hn : omega≠0 := by intro h; simp [h] at ho + have hi : omega⁻¹=omega := by + apply inv_eq_of_mul_eq_one_left + simpa only [pow_two] using ho + rw [zpow_neg, zpow_natCast, zpow_natCast, ← inv_pow, hi, ← pow_add] + congr 1 + omega + +lemma source_signed_phase (C omega : ℂ) (ho : omega^2=1) (e l k : ℕ) : + C^l * omega^((((e+3*l)*k:ℕ):ℤ)-(e*l+l.choose 2:ℕ)) = + localCubePhase C omega e l k := by + have hn : omega≠0 := by intro h; simp [h] at ho + rw [sub_eq_add_neg, zpow_add₀ hn, signed_diagonal_phase omega ho] + rfl + +lemma spectral_power_split (Q : ℝ) (hQ : 0 ActualEisensteinCubic.O + +lemma firstGauss_eq_gamma_sqrt (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] (hg : goodLambda ∉ Ideal.span {p}) : + primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1 = + localGamma p hp.ne_zero hg 1 * + (Real.sqrt (Ideal.absNorm (Ideal.span {p})):ℂ) := by + let : Field (O ⧸ Ideal.span {p}) := Ideal.Quotient.field _ + let : Fintype (O ⧸ Ideal.span {p}) := Fintype.ofFinite _ + have hQ : 0 < (Ideal.absNorm (Ideal.span {p}):ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + have hs : (Real.sqrt (Ideal.absNorm (Ideal.span {p})):ℂ) ≠ 0 := by + exact_mod_cast (Real.sqrt_pos.mpr hQ).ne' + unfold localGamma + rw [pow_one, ProbePhase.normalizedTraceGauss_eq_normalizedGauss] + simp only [ProbeGauss.normalizedGauss, ← Nat.card_eq_fintype_card] + change _ = (gaussSum _ _ / (Real.sqrt (Ideal.absNorm (Ideal.span {p})):ℂ)) * _ + rw [div_mul_cancel₀ _ hs] + simp only [primeGauss, map_one, one_mul, tsum_fintype, gaussSum] + +theorem sourceWeightedScalar_actual (p : O) (hp : Prime p) + [(Ideal.span {p} : Ideal O).IsMaximal] (hg : goodLambda ∉ Ideal.span {p}) + (eta a x w z scalar : ℂ) (e l k m : ℕ) : + sourceWeightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (localGamma p hp.ne_zero hg 1) (star (localGamma p hp.ne_zero hg 3)) + (actualSextic (Ideal.span {p}) hg (-1)) x w z scalar e l k m = + weightedScalar (Ideal.absNorm (Ideal.span {p})) eta a + (primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1) + (star (localGamma p hp.ne_zero hg 3)) (actualSextic (Ideal.span {p}) hg (-1)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-x)) ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-w)) + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-6*z)) scalar e l k m := by + have hQ : 0 < (Ideal.absNorm (Ideal.span {p}):ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + simpa only [Complex.ofReal_natCast] using + sourceWeightedScalar_eq _ hQ eta a (localGamma p hp.ne_zero hg 1) _ + (star (localGamma p hp.ne_zero hg 3)) (actualSextic (Ideal.span {p}) hg (-1)) + x w z scalar (firstGauss_eq_gamma_sqrt p hp hg) + (actualSextic_neg_one_sq _ hg) e l k m + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Transformed.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Transformed.lean new file mode 100644 index 0000000000000000000000000000000000000000..a23ad2ddb00295cd070ccbe7eac50f858d410d23 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Transformed.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Detector.MellinPoisson + +namespace OAI + +noncomputable section +open scoped Classical BigOperators ContDiff +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve ProbeRow +local notation "O" => ActualEisensteinCubic.O + +def poissonPhysicalProbe (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W₀ W₁ : ℝ → ℂ) (X Y Z : ℝ) : ℂ := + (Y:ℂ)⁻¹ * ∑' s : {I : Ideal O // Supported I}, + if ∀ p∈C.excluded, ¬p∣s.val then + let a := primaryGenerator s.val + let has := (supported_span_primaryGenerator_iff s.val).mpr s.property + let q_s : ℝ := Ideal.absNorm s.val + W₁ (q_s/Y) * CanonicalRowCompletion.idealRowHom C.generator s.val / + (C.tau*C.residueMonoid a*(Real.sqrt (elementNorm C.generator*q_s*X):ℂ)) * + verticalIntegral 4 (fun t => (Real.sqrt q_s:ℂ)⁻¹*((Z:ℂ)^t*Complex.exp (t^2)) * + ∑' p : Ideal O × Ideal O, transformedSpectralTerm η C C.excluded D a has W₀ + (elementNorm C.generator*q_s*X) t p.1 p.2) + else 0 + +theorem markedPhysicalProbe_eq_poisson (η : HeckeFamily.Character) (C : CalibrationData) + (D : Ideal O) (W₀ W₁ : ℝ → ℂ) (hWc : HasCompactSupport W₀) + (hWs : ContDiff ℝ ∞ W₀) (X Y Z : ℝ) (hX : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def tuplePhysicalScalar {K : ℕ} (η : HeckeFamily.Character) (p : Fin K→O) + (J : Finset (Fin K)) : ℂ := + (-1:ℂ)^J.card*((elementNorm (∏i∈J,p i)^(-(3/2:ℝ)):ℝ):ℂ)* + star (HeckeFamily.elementCoeff η (∏i∈Finset.univ\J,p i)) + +lemma tuple_scaled_coefficient {K : ℕ} (η : HeckeFamily.Character) (p : Fin K→O) + (hp : ∀i,p i≠0) (J : Finset (Fin K)) (W0 W1 : SchwartzMap ℝ ℂ) + (X Y Z : ℝ) (hX : 0 ActualEisensteinCubic.O +local notation "Id" => Ideal O + +def tupleSourceSeries {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (p : Fin K→O) (x w z : ℂ) : ℂ := + ∑J∈(Finset.univ:Finset (Fin K)).powerset, + (-1:ℂ)^J.card*(elementNorm (∏i∈J,p i):ℂ)^(z-w-1)* + star (HeckeFamily.elementCoeff η (∏i∈Finset.univ\J,p i))* + (elementNorm (∏i∈Finset.univ\J,p i):ℂ)^(x+z-1)* + sourceRowSeries η S C (Ideal.span {∏i∈Finset.univ\J,p i}) x w z + +def tupleSourceTripleIntegral {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (W0 W1 : SchwartzMap ℝ ℂ) (p : Fin K→O) (X Y Z : ℝ) : ℂ := + ((1/(2*Real.pi):ℝ):ℂ)^3*∫t : HeightSpace, + sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + tupleSourceSeries η S C p ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) ∂heightMeasure + +theorem compensatedTuple_eq_source_triple {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : ∀P∈S,P.IsMaximal) (hpS : ∀P∈S,Prime P) + (hbad : fixedBadPrimes⊆S) (hSne : S.Nonempty) (W0 W1 : SchwartzMap ℝ ℂ) + (a0 b0 a1 b1 : ℝ) (ha0 : 0(-1:ℂ)^J.card* + ((elementNorm (∏i∈J,p i)^(-(3/2:ℝ)):ℝ):ℂ)* + star (HeckeFamily.elementCoeff η (∏i∈Finset.univ\J,p i)) + let F : Finset (Fin K)→HeightSpace→ℂ := fun J t=> + sourceMellinWeight W0 W1 (X/elementNorm (∏i∈J,p i)) (Y/elementNorm (∏i∈J,p i)) + (Z*elementNorm (∏i∈Finset.univ\J,p i)) + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + sourceRowSeries η S (calibrationForSet S hS) (Ideal.span {∏i∈Finset.univ\J,p i}) + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) + have hF (J : Finset (Fin K)) : Integrable (F J) heightMeasure := + sourceRows_initial_integrable η S hS hpS hbad _ W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + _ _ _ (div_pos hX (tuple_norm_pos p hp J)) (div_pos hY (tuple_norm_pos p hp J)) + (mul_pos hZ (tuple_norm_pos p hp (Finset.univ\J))) + have hpoint (J : Finset (Fin K)) (t : HeightSpace) : + A J*F J t=sourceMellinWeight W0 W1 X Y Z ((3:ℂ)+t.1.1*Complex.I) + ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)* + ((-1:ℂ)^J.card*(elementNorm (∏i∈J,p i):ℂ)^(((2:ℂ)+t.1.2*Complex.I)-((3:ℂ)+t.2*Complex.I)-1)* + star (HeckeFamily.elementCoeff η (∏i∈Finset.univ\J,p i))* + (elementNorm (∏i∈Finset.univ\J,p i):ℂ)^(((3:ℂ)+t.1.1*Complex.I)+((2:ℂ)+t.1.2*Complex.I)-1)* + sourceRowSeries η S (calibrationForSet S hS) (Ideal.span {∏i∈Finset.univ\J,p i}) + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I)) := by + have he := sourceMellinWeight_subset W0 W1 X Y Z (elementNorm (∏i∈J,p i)) + (elementNorm (∏i∈Finset.univ\J,p i)) hX hY hZ (tuple_norm_pos p hp J) + (tuple_norm_pos p hp (Finset.univ\J)) + (star (HeckeFamily.elementCoeff η (∏i∈Finset.univ\J,p i))) + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) + dsimp only [A,F] + linear_combination (-1:ℂ)^J.card * he * + sourceRowSeries η S (calibrationForSet S hS) (Ideal.span {∏i∈Finset.univ\J,p i}) + ((3:ℂ)+t.1.1*Complex.I) ((3:ℂ)+t.2*Complex.I) ((2:ℂ)+t.1.2*Complex.I) + have hleft : compensatedTuple η (calibrationForSet S hS) W0 W1 p X Y Z= + ((1/(2*Real.pi):ℝ):ℂ)^3 * + ∑J∈(Finset.univ:Finset (Fin K)).powerset,∫t,A J*F J t ∂heightMeasure := by + unfold compensatedTuple ProbeCompensation.tupleOperation + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + dsimp only + rw [markedPhysicalProbe_eq_source_triple η S hS hpS hbad hSne _ W0 W1 a0 b0 a1 b1 ha0 ha1 hW0 hW1 + _ _ _ (div_pos hX (tuple_norm_pos p hp J)) (div_pos hY (tuple_norm_pos p hp J)) + (mul_pos hZ (tuple_norm_pos p hp (Finset.univ\J)))] + rw [integral_const_mul] + change A J*(((1/(2*Real.pi):ℝ):ℂ)^3*∫t,F J t ∂heightMeasure)=_ + ring + rw [hleft,←integral_finsetSum _ (fun J _=>(hF J).const_mul (A J))] + unfold tupleSourceTripleIntegral + congr 1 + apply integral_congr_ae + apply Filter.Eventually.of_forall + intro t + dsimp only + unfold tupleSourceSeries + rw [Finset.mul_sum] + exact Finset.sum_congr rfl (fun J _=>hpoint J t) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/TuplePrime.lean b/lean/OAI/NumberTheory/DirichletL/Detector/TuplePrime.lean new file mode 100644 index 0000000000000000000000000000000000000000..245679be7b19de96549ab1e7be0f0fb6a5645611 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/TuplePrime.lean @@ -0,0 +1,49 @@ +import OAI.NumberTheory.DirichletL.Detector.TupleRows +import OAI.NumberTheory.DirichletL.Detector.CompensationActual + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve ProbeRow +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma span_tupleProduct {K : ℕ} (p : Fin K→O) (J : Finset (Fin K)) : + Ideal.span {∏i∈J,p i}=∏i∈J,Ideal.span {p i} := by + induction J using Finset.induction_on with + | empty => simp only [Finset.prod_empty,Ideal.span_singleton_one,Ideal.one_eq_top] + | @insert i J hi ih => + rw [Finset.prod_insert hi,←Ideal.span_singleton_mul_span_singleton,ih,Finset.prod_insert hi] + +lemma primaryTuple_norm (P : PrimeIdeal) (hP : Supported P.val) : + elementNorm (primaryGenerator P.val)=(Ideal.absNorm P.val:ℝ) := by + unfold elementNorm + rw [span_primaryGenerator_of_supported P.val hP] + +theorem indexedCompensatedHigh_principal {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (P : Fin K→PrimeIdeal) (hP : Function.Injective P) (hs : ∀i,Supported (P i).val) + (x w z : ℂ) : + indexedCompensatedHigh η S (fun i=>primaryGenerator (P i).val) 1 x w z= + spectralCompensatedHigh S (Finset.univ.image P) η x w z + (fun Q=>star (HeckeFamily.idealCoeff η Q.val)*(Ideal.absNorm Q.val:ℂ)^x) + (fun Q=>(Ideal.absNorm Q.val:ℂ)^(-w)) := by + unfold indexedCompensatedHigh spectralCompensatedHigh + rw [Finset.powerset_image,Finset.sum_image (Finset.image_injective hP).injOn] + apply Finset.sum_congr rfl + intro J hJ + rw [Finset.card_image_of_injective J hP,←Finset.image_sdiff _ _ hP] + simp only [Finset.prod_image hP.injOn] + have hnorm (i : Fin K) : (elementNorm (primaryGenerator (P i).val):ℂ)=(Ideal.absNorm (P i).val:ℂ) := by + rw [primaryTuple_norm (P i) (hs i)] + norm_cast + have hc (i : Fin K) : HeckeFamily.elementCoeff η (primaryGenerator (P i).val)= + HeckeFamily.idealCoeff η (P i).val := targetMonoid_primaryGenerator η (P i).val (hs i) + simp only [tupleIndexedCoefficient,hnorm,hc,span_tupleProduct, + span_primaryGenerator_of_supported _ (hs _)] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/TuplePrincipal.lean b/lean/OAI/NumberTheory/DirichletL/Detector/TuplePrincipal.lean new file mode 100644 index 0000000000000000000000000000000000000000..4da5983e9d30d7aaa991c9edc1112ab7c9027545 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/TuplePrincipal.lean @@ -0,0 +1,38 @@ +import OAI.NumberTheory.DirichletL.Detector.TuplePrime + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open CompletedGauss CanonicalQuadraticSieve ProbeEuler ProbeLocal +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +theorem indexedCompensatedHigh_principal_continued {K : ℕ} (η : HeckeFamily.Character) + (S : Finset Id) (hS : SourceExclusions S) (P : Fin K→PrimeIdeal) + (hP : Function.Injective P) (hPS : ∀i,(P i).val∉S) (x w z : ℂ) + (hx : 3/2primaryGenerator (P i).val) 1 x w z= + (HeckeFamily.LFunction (fixedSourcePrincipal S hS.prime) (6*z)* + HeckeFamily.LFunction (fixedSourcePrincipal S hS.prime) w / + HeckeFamily.LFunction (η.excludePrimes S hS.prime) x*globalClosedCorrection η S x w z)* + ∏i,compensatedReplacement (coordV (Ideal.absNorm (P i).val) z) + (coordW (Ideal.absNorm (P i).val) 1 w) + (coordD (Ideal.absNorm (P i).val) (HeckeFamily.idealCoeff η (P i).val) 1 x) + (idealMarkedClosed η (P i) x w z) + (star (HeckeFamily.idealCoeff η (P i).val)*(Ideal.absNorm (P i).val:ℂ)^x) + ((Ideal.absNorm (P i).val:ℂ)^(-w))/idealClosedCorrection η (P i) x w z := by + have hs (i : Fin K) : Supported (P i).val := outside_prime_supported S hS.bad (P i) (hPS i) + rw [indexedCompensatedHigh_principal η S P hP hs] + have ht : ∀Q∈Finset.univ.image P,Q.val∉S := by + intro Q hQ + obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hQ + exact hPS i + rw [spectralCompensatedHigh_continued S hS (Finset.univ.image P) ht η x w z _ _ hx hw hz, + Finset.prod_image hP.injOn] + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/TupleProducts.lean b/lean/OAI/NumberTheory/DirichletL/Detector/TupleProducts.lean new file mode 100644 index 0000000000000000000000000000000000000000..a98823710e9a8ee40ee766324070811ce80c2db6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/TupleProducts.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Detector.TupleScaling +import OAI.NumberTheory.DirichletL.Detector.PhysicalNorms + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +local notation "O" => ActualEisensteinCubic.O + +lemma tuple_norm_cpow {K : ℕ} (p : Fin K→O) (hp : ∀i,p i≠0) + (J : Finset (Fin K)) (s : ℂ) : + (elementNorm (∏i∈J,p i):ℂ)^s=∏i∈J,(elementNorm (p i):ℂ)^s := by + induction J using Finset.induction_on with + | empty => simp only [Finset.prod_empty,elementNorm_one,Complex.ofReal_one,Complex.one_cpow] + | @insert i J hi ih => + rw [Finset.prod_insert hi,elementNorm_mul,Complex.ofReal_mul, + Complex.mul_cpow_ofReal_nonneg (elementNorm_pos _ (hp i)).le (tuple_norm_pos p hp J).le, + ih,Finset.prod_insert hi] + +lemma tuple_target_star {K : ℕ} (η : HeckeFamily.Character) (p : Fin K→O) + (J : Finset (Fin K)) : + star (HeckeFamily.elementCoeff η (∏i∈J,p i))=∏i∈J,star (HeckeFamily.elementCoeff η (p i)) := by + change star (ProbeRow.targetMonoid η (∏i∈J,p i))=_ + rw [map_prod,star_prod] + rfl + +lemma tuple_source_scalar {K : ℕ} (η : HeckeFamily.Character) (p : Fin K→O) + (hp : ∀i,p i≠0) (J : Finset (Fin K)) (x w z : ℂ) : + (elementNorm (∏i∈J,p i):ℂ)^(z-w-1)* + star (HeckeFamily.elementCoeff η (∏i∈Finset.univ\J,p i))* + (elementNorm (∏i∈Finset.univ\J,p i):ℂ)^(x+z-1)= + (∏i,(elementNorm (p i):ℂ)^(z-1))* + (∏i∈J,(elementNorm (p i):ℂ)^(-w))* + (∏i∈Finset.univ\J,star (HeckeFamily.elementCoeff η (p i))*(elementNorm (p i):ℂ)^x) := by + rw [tuple_norm_cpow p hp J,tuple_norm_cpow p hp (Finset.univ\J),tuple_target_star] + have he (i : Fin K) : (elementNorm (p i):ℂ)^(z-w-1)= + (elementNorm (p i):ℂ)^(z-1)*(elementNorm (p i):ℂ)^(-w) := by + rw [←Complex.cpow_add _ _ (Complex.ofReal_ne_zero.mpr (elementNorm_pos _ (hp i)).ne')] + congr 1 + ring + have hf (i : Fin K) : (elementNorm (p i):ℂ)^(x+z-1)= + (elementNorm (p i):ℂ)^(z-1)*(elementNorm (p i):ℂ)^x := by + rw [←Complex.cpow_add _ _ (Complex.ofReal_ne_zero.mpr (elementNorm_pos _ (hp i)).ne')] + congr 1 + ring + simp only [he,hf,Finset.prod_mul_distrib] + have hc := Finset.prod_sdiff (Finset.subset_univ J) (f:=fun i : Fin K=>(elementNorm (p i):ℂ)^(z-1)) + rw [←hc] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/TupleRows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/TupleRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..6d2b5fa23741f02c31d19ec9f60290eee7c820f7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/TupleRows.lean @@ -0,0 +1,92 @@ +import OAI.NumberTheory.DirichletL.Detector.TupleMellin +import OAI.NumberTheory.DirichletL.Detector.TupleProducts + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open HeckeInverseAmplification +local notation "O" => ActualEisensteinCubic.O +local notation "Id" => Ideal O + +lemma sourceRowSummand_summable (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (D : Id) (x w z : ℂ) + (hx : 3/2star (C.residueMonoid u.val)*frequencyWeight z ⟨u.val,u.property.1⟩* + markedIdealHighSeries S D η u.val x w z) := by + let e : FreeRow×((Id×Id)×(Id×Id))→FullHighIndex := fun p=>(⟨p.1.val,p.1.property.1⟩,p.2) + have he : Function.Injective e := by + intro a b h + apply Prod.ext + · apply Subtype.ext + exact congrArg (fun t : FullHighIndex=>t.1.val) h + · exact congrArg (fun t : FullHighIndex=>t.2) h + have hs := (fullHighSummand_summable S D η x w z hx hw hz + (fun H=>star (C.residueMonoid H.val)) + (fun H=>by simpa only [norm_star] using C.residueMonoid_norm_le_one H.val)).comp_injective he + have ht := hs.prod + apply ht.congr + intro u + dsimp only [Function.comp_def,e] + exact tsum_mul_left (a:=star (C.residueMonoid u.val)*frequencyWeight z ⟨u.val,u.property.1⟩) + (f:=fun c : (Id×Id)×(Id×Id)=>markedIdealHighSummand S D η u.val x w z c.1.1 c.1.2 c.2.1 c.2.2) + +def tupleIndexedCoefficient {K : ℕ} (η : HeckeFamily.Character) (p : Fin K→O) + (J : Finset (Fin K)) (x w : ℂ) : ℂ := + (-1:ℂ)^J.card*(∏i∈J,(elementNorm (p i):ℂ)^(-w))* + (∏i∈Finset.univ\J,star (HeckeFamily.elementCoeff η (p i))*(elementNorm (p i):ℂ)^x) + +def indexedCompensatedHigh {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (p : Fin K→O) (u : O) (x w z : ℂ) : ℂ := + ∑J∈(Finset.univ:Finset (Fin K)).powerset,tupleIndexedCoefficient η p J x w* + markedIdealHighSeries S (Ideal.span {∏i∈Finset.univ\J,p i}) η u x w z + +lemma tupleSourceSeries_common_scale {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (p : Fin K→O) (hp : ∀i,p i≠0) (x w z : ℂ) : + tupleSourceSeries η S C p x w z= + (∏i,(elementNorm (p i):ℂ)^(z-1))* + ∑J∈(Finset.univ:Finset (Fin K)).powerset,tupleIndexedCoefficient η p J x w* + sourceRowSeries η S C (Ideal.span {∏i∈Finset.univ\J,p i}) x w z := by + unfold tupleSourceSeries + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + have he := tuple_source_scalar η p hp J x w z + unfold tupleIndexedCoefficient + linear_combination (-1:ℂ)^J.card*he* + sourceRowSeries η S C (Ideal.span {∏i∈Finset.univ\J,p i}) x w z + +theorem tupleSourceSeries_eq_rows {K : ℕ} (η : HeckeFamily.Character) (S : Finset Id) + (C : CalibrationData) (p : Fin K→O) (hp : ∀i,p i≠0) (x w z : ℂ) + (hx : 3/2tupleIndexedCoefficient η p J x w* + (star (C.residueMonoid u.val)*frequencyWeight z ⟨u.val,u.property.1⟩* + markedIdealHighSeries S (Ideal.span {∏i∈Finset.univ\J,p i}) η u.val x w z) + have hf (J : Finset (Fin K)) : Summable (f J) := + (sourceRowSummand_summable η S C _ x w z hx hw hz).mul_left _ + have hsum := Summable.tsum_finsetSum (s:=(Finset.univ:Finset (Fin K)).powerset) + (f:=f) (fun J _=>hf J) + unfold sourceRowSeries + simp only [←tsum_mul_left] + change (∑J∈(Finset.univ:Finset (Fin K)).powerset,∑'u,f J u)=_ + rw [←hsum] + apply tsum_congr + intro u + unfold indexedCompensatedHigh + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + dsimp only [f] + ring + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/TupleScaling.lean b/lean/OAI/NumberTheory/DirichletL/Detector/TupleScaling.lean new file mode 100644 index 0000000000000000000000000000000000000000..e8563e1231c2888dfc2b81059c3ec9722dceefd7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/TupleScaling.lean @@ -0,0 +1,29 @@ +import OAI.NumberTheory.DirichletL.Detector.MellinScaling +import OAI.NumberTheory.DirichletL.Detector.SourceTriple + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical + +lemma sourceMellinWeight_subset (W0 W1 : SchwartzMap ℝ ℂ) (X Y Z Q R : ℝ) + (hX : 0hp i) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/UnramifiedScalar.lean b/lean/OAI/NumberTheory/DirichletL/Detector/UnramifiedScalar.lean new file mode 100644 index 0000000000000000000000000000000000000000..cf3245f2aa76ae751d822825a8311465cdcb8466 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/UnramifiedScalar.lean @@ -0,0 +1,104 @@ +import OAI.NumberTheory.DirichletL.Detector.ScalarTable +import OAI.NumberTheory.DirichletL.Detector.PrimeConstants + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePrimePower +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge +local notation "O" => ActualEisensteinCubic.O + +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + (hg : goodLambda ∉ Ideal.span {p}) (hc : ringChar (O ⧸ Ideal.span {p}) ≠ 2) +include hc + +theorem unramified_even_kzero (r m : ℕ) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r+5) 0 (6*m) = + if r+1 ≤ m then + (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+5) * ((Ideal.absNorm (Ideal.span {p}):ℂ)-1) + else 0 := by + rw [positiveScalar_kzero, actualSextic_primePowerGauss_at_pow p hp hg hc, + ite_eq_left (by omega : 6 ∣ 6*r+5+1)] + by_cases hm : r+1 ≤ m + · rw [ite_eq_left hm, ite_eq_left (by omega), ite_eq_left (by omega), pow_succ] + ring + · rw [ite_eq_right hm, ite_eq_right (by omega), ite_eq_right (by omega), sub_self] + +theorem unramified_squarefree_kzero (r m : ℕ) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r) 0 (6*m) = + if m=r then (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r) * + primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1 else 0 := by + rw [positiveScalar_kzero, actualSextic_primePowerGauss_at_pow p hp hg hc, + ite_eq_right (by omega : ¬6 ∣ 6*r+1), actualSextic_pow_six_mul_add _ hg hc, pow_one] + by_cases hm : m=r + · rw [ite_eq_left hm, ite_eq_left (by omega)] + · rw [ite_eq_right hm, ite_eq_right (by omega)] + +theorem unramified_squarefree_kone (r m : ℕ) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r) 1 (6*m) = + if r omega), + ite_eq_right (by rcases hd with rfl | rfl <;> omega)] + · rw [gaussValuationTable, ite_eq_right (by rcases hd with rfl | rfl <;> omega), + ite_eq_right (by rcases hd with rfl | rfl <;> omega), mul_zero] + · rfl + +theorem unramified_even_kone (r m : ℕ) : + positiveScalar p hp.ne_zero (actualSextic (Ideal.span {p}) hg) (6*r+5) 1 (6*m) = + if m=r+1 then (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+6) else 0 := by + rw [positiveScalar_actual_table p hp hg hc, ite_eq_right (by decide : (1:ℕ) ≠ 0)] + by_cases hm : m=r+1 + · subst m + rw [ite_eq_left ⟨rfl, by omega⟩, ite_eq_left rfl, gaussValuationTable, + ite_eq_right (by omega : ¬6 ∣ 6*r+5), ite_eq_left (by omega), + actualSextic_pow_six_mul_add _ hg hc, actualSextic_fifth_inverse _ hg hc] + have hχ : actualSextic (Ideal.span {p}) hg ≠ 1 := by + intro h + have hpow : actualSextic (Ideal.span {p}) hg ^ 1 = 1 := by simpa using h + have hdiv := (actualSextic_pow_eq_one_iff _ hg hc 1).mp hpow + norm_num at hdiv + have hi := primeGauss_inverse_pair p hp.ne_zero (actualSextic (Ideal.span {p}) hg) hχ + have hω : actualSextic (Ideal.span {p}) hg (-1) ≠ 0 := + (actualSextic (Ideal.span {p}) hg).apply_ne_zero_iff.mpr (isUnit_one.neg : IsUnit (-1 : O ⧸ Ideal.span {p})) + calc + _ = (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+5) * + ((actualSextic (Ideal.span {p}) hg (-1))⁻¹ * + (primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg) 1 * + primeGauss p hp.ne_zero (actualSextic (Ideal.span {p}) hg)⁻¹ 1)) := by ring + _ = (Ideal.absNorm (Ideal.span {p}):ℂ)^(6*r+5) * (Ideal.absNorm (Ideal.span {p}):ℂ) := by + rw [hi] + field_simp + _ = _ := (pow_succ _ (6*r+5)).symm + · rw [ite_eq_right hm] + by_cases hm0 : m=0 + · subst m + rw [ite_eq_right (by omega)] + · rw [ite_eq_left ⟨rfl, by omega⟩, gaussValuationTable, + ite_eq_right (by omega : ¬6 ∣ 6*r+5), ite_eq_right (by omega), mul_zero] + +end SevenEighths.ProbePrimePower +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/Windows.lean b/lean/OAI/NumberTheory/DirichletL/Detector/Windows.lean new file mode 100644 index 0000000000000000000000000000000000000000..75490657ad5a1769901ed1f0fe951501ed085f6a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/Windows.lean @@ -0,0 +1,52 @@ +import OAI.NumberTheory.DirichletL.Detector.Physical + +namespace OAI + +noncomputable section +open scoped Classical +namespace SevenEighths.ProbePhysical +open ActualEisensteinCubic CompletedGauss +local notation "O" => ActualEisensteinCubic.O + +theorem elementWindow_finite_support (W : ℝ → ℂ) (hW : HasCompactSupport W) + (R : ℝ) (hR : 0 < R) : + (Function.support (fun m : O => W (elementNorm m / R))).Finite := by + obtain ⟨B, hB, hbound⟩ := compact_window_bound W hW + obtain ⟨M, hM⟩ := exists_nat_gt (B * R) + apply (ShortDraftLatticeCount.rowNormBall M).finite_toSet.subset + intro m hm + apply ShortDraftLatticeCount.mem_rowNormBall_of_absNorm_le + have hnorm : elementNorm m ≤ B * R := (div_le_iff₀ hR).mp (hbound _ hm) + unfold elementNorm at hnorm + exact_mod_cast hnorm.trans hM.le + +theorem idealWindow_finite_support (W : ℝ → ℂ) (hW : HasCompactSupport W) + (R : ℝ) (hR : 0 < R) : + (Function.support (fun I : Ideal O => W ((Ideal.absNorm I : ℝ) / R))).Finite := by + obtain ⟨B, hB, hbound⟩ := compact_window_bound W hW + obtain ⟨M, hM⟩ := exists_nat_gt (B * R) + apply (Ideal.finite_setOfPred_absNorm_le M).subset + intro I hI + have hnorm : (Ideal.absNorm I : ℝ) ≤ B * R := (div_le_iff₀ hR).mp (hbound _ hI) + exact_mod_cast hnorm.trans hM.le + +theorem elementWindow_mul_summable (W : ℝ → ℂ) (hW : HasCompactSupport W) + (R : ℝ) (hR : 0 < R) (F : O → ℂ) : + Summable (fun m : O => W (elementNorm m / R) * F m) := by + apply summable_of_hasFiniteSupport + apply (elementWindow_finite_support W hW R hR).subset + intro m hm hzero + exact hm (by simp only [hzero, zero_mul]) + +theorem idealWindow_mul_summable (W : ℝ → ℂ) (hW : HasCompactSupport W) + (R : ℝ) (hR : 0 < R) (F : Ideal O → ℂ) : + Summable (fun I : Ideal O => W ((Ideal.absNorm I : ℝ) / R) * F I) := by + apply summable_of_hasFiniteSupport + apply (idealWindow_finite_support W hW R hR).subset + intro I hI hzero + exact hI (by simp only [hzero, zero_mul]) + +end SevenEighths.ProbePhysical +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Detector/ZeroIndex.lean b/lean/OAI/NumberTheory/DirichletL/Detector/ZeroIndex.lean new file mode 100644 index 0000000000000000000000000000000000000000..debf3a26eceb6ba9f3c9719b2a595ea358860790 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Detector/ZeroIndex.lean @@ -0,0 +1,60 @@ +import OAI.NumberTheory.DirichletL.Detector.PrincipalEulerIdentity + +namespace OAI + +noncomputable section +open scoped Classical BigOperators +namespace SevenEighths.ProbeEuler +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge ProbePrimePower +local notation "O" => ActualEisensteinCubic.O + +variable (p : O) (hp : Prime p) [(Ideal.span {p} : Ideal O).IsMaximal] + +def zeroIndexTerm (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) (k m : ℕ) : ℂ := + (if k=0 then 1 else (χ^k) (Ideal.Quotient.mk _ (p^(6*m)))) * W^k * V^m + +omit [(Ideal.span {p}).IsMaximal] in +lemma zeroIndex_inner_zero (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) + (hV : ‖V‖<1) : + HasSum (fun m => zeroIndexTerm p χ W V 0 m) (1/(1-V)) := by + simpa [zeroIndexTerm, one_div] using hasSum_geometric_of_norm_lt_one hV + +include hp in +lemma zeroIndex_inner_pos (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) + (k : ℕ) (hk : k≠0) : + HasSum (fun m => zeroIndexTerm p χ W V k m) (W^k) := by + apply (hasSum_ite_eq 0 (W^k)).congr + intro s + apply Finset.sum_congr rfl + intro m hm + dsimp only + unfold zeroIndexTerm + rw [ite_eq_right hk, zero_index_scalar p hp χ k (6*m) hk] + by_cases h : m=0 + · subst m; simp + · have h6 : 6*m≠0 := by omega + simp [h, h6] + +def zeroIndexSeries (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) : ℂ := + ∑' k, ∑' m, zeroIndexTerm p χ W V k m + +include hp in +lemma zeroIndexSeries_eq (χ : MulChar (O ⧸ Ideal.span {p}) ℂ) (W V : ℂ) + (hW : ‖W‖<1) (hV : ‖V‖<1) : + zeroIndexSeries p χ W V = 1/(1-V)+W/(1-W) := by + have htail : HasSum (fun k => ∑' m, zeroIndexTerm p χ W V (k+1) m) (W/(1-W)) := by + have he : (fun k => ∑' m, zeroIndexTerm p χ W V (k+1) m) = + (fun k => W * W^k) := by + funext k + rw [(zeroIndex_inner_pos p hp χ W V (k+1) (by omega)).tsum_eq, pow_succ] + ring + rw [he] + simpa [div_eq_mul_inv] using (hasSum_geometric_of_norm_lt_one hW).mul_left W + have hall := HasSum.sum_range_add (f := fun k => ∑' m, zeroIndexTerm p χ W V k m) (k := 1) htail + simpa only [zeroIndexSeries, Finset.sum_range_one, + (zeroIndex_inner_zero p χ W V hV).tsum_eq] using hall.tsum_eq + +end SevenEighths.ProbeEuler +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseAssignedCount.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseAssignedCount.lean new file mode 100644 index 0000000000000000000000000000000000000000..5c761b4e1b17427f3e098f45fcf83ddf9ee27ce3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseAssignedCount.lean @@ -0,0 +1,159 @@ +import OAI.NumberTheory.DirichletL.Moments.SourceMass + +namespace OAI + +noncomputable section +open scoped BigOperators Classical + +namespace SevenEighths.DetectorDictionaryInverseAssignedCount +local notation "O" => ActualEisensteinCubic.O + +def assignedTuples {ι : Type*} [Fintype ι] + (L : ι → Finset (Ideal O)) : Finset (ι → Ideal O) := Fintype.piFinset L + +@[simp] theorem mem_assignedTuples {ι : Type*} [Fintype ι] + (L : ι → Finset (Ideal O)) (q : ι → Ideal O) : + q ∈ assignedTuples L ↔ ∀ i, q i ∈ L i := by + simp [assignedTuples] + +def assignedConstant (K : ℕ) (b : ℝ) : ℝ := (128*b)^K + +theorem assignedConstant_pos (K : ℕ) {b : ℝ} (hb : 1 ≤ b) : + 0 < assignedConstant K b := by + unfold assignedConstant + positivity + +theorem list_card_le (L : Finset (Ideal O)) {H : ℝ} (hH : 0 ≤ H) + (hL : ∀ I ∈ L, I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ H) : + (L.card : ℝ) ≤ 128*H := by + apply le_trans (Nat.cast_le.mpr (Finset.card_le_card (t := + CenteredMomentSourceMass.idealBall H) ?_)) + (CenteredMomentSourceMass.idealBall_card H hH) + intro I hI + exact (CenteredMomentSourceMass.mem_idealBall H I).mpr (hL I hI) + +theorem assigned_card_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {ι : Type*} [Fintype ι] (hK : Fintype.card ι ≤ K) + (ell : ι → ℝ) (L : ι → Finset (Ideal O)) + (hL : ∀ i I, I ∈ L i → I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) : + ((assignedTuples L).card : ℝ) ≤ assignedConstant K b * U^(∑ i, ell i) := by + have hUp : 0 < U := lt_of_lt_of_le zero_lt_one hU + have hb0 : 0 ≤ b := le_trans zero_le_one hb + have hbase : 1 ≤ 128*b := by linarith + simp only [assignedTuples, Fintype.card_piFinset, Nat.cast_prod] + calc + (∏ i, ((L i).card : ℝ)) ≤ ∏ i, 128*(b*U^(ell i)) := + Finset.prod_le_prod₀ (fun _ _ => Nat.cast_nonneg _) + (fun i _ => list_card_le (L i) (by positivity) (hL i)) + _ = (128*b)^(Fintype.card ι) * U^(∑ i, ell i) := by + simp_rw [← mul_assoc] + rw [Finset.prod_mul_distrib, ← Real.rpow_sum_of_pos hUp] + simp + _ ≤ assignedConstant K b * U^(∑ i, ell i) := by + exact mul_le_mul_of_nonneg_right (pow_le_pow_right₀ hbase hK) + (Real.rpow_nonneg hUp.le _) + +def assignedCoefficient {ι : Type*} [Fintype ι] + (a : ι → Ideal O → ℂ) (q : ι → Ideal O) : ℂ := ∏ i, a i (q i) + +theorem assignedCoefficient_norm_le_one {ι : Type*} [Fintype ι] + (L : ι → Finset (Ideal O)) (a : ι → Ideal O → ℂ) + (ha : ∀ i I, I ∈ L i → ‖a i I‖ ≤ 1) + (q : ι → Ideal O) (hq : q ∈ assignedTuples L) : + ‖assignedCoefficient a q‖ ≤ 1 := by + rw [assignedCoefficient, norm_prod] + simpa using Finset.prod_le_prod₀ (fun i _ => norm_nonneg (a i (q i))) + (fun i _ => ha i (q i) ((mem_assignedTuples L q).mp hq i)) + +theorem restricted_mass_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {ι : Type*} [Fintype ι] (hK : Fintype.card ι ≤ K) + (ell : ι → ℝ) (L : ι → Finset (Ideal O)) + (hL : ∀ i I, I ∈ L i → I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) + (a : ι → Ideal O → ℂ) (ha : ∀ i I, I ∈ L i → ‖a i I‖ ≤ 1) + (T : Finset (ι → Ideal O)) (hT : T ⊆ assignedTuples L) : + (∑ q ∈ T, ‖assignedCoefficient a q‖) ≤ + assignedConstant K b * U^(∑ i, ell i) := by + calc + (∑ q ∈ T, ‖assignedCoefficient a q‖) ≤ ∑ _q ∈ T, (1 : ℝ) := + Finset.sum_le_sum (fun q hq => assignedCoefficient_norm_le_one L a ha q (hT hq)) + _ = (T.card : ℝ) := by simp + _ ≤ ((assignedTuples L).card : ℝ) := Nat.cast_le.mpr (Finset.card_le_card hT) + _ ≤ _ := assigned_card_le K hb hU hK ell L hL + +theorem restricted_normalized_mass_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {ι : Type*} [Fintype ι] (hK : Fintype.card ι ≤ K) + (ell : ι → ℝ) (L : ι → Finset (Ideal O)) + (hL : ∀ i I, I ∈ L i → I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) + (a : ι → Ideal O → ℂ) (ha : ∀ i I, I ∈ L i → ‖a i I‖ ≤ 1) + (T : Finset (ι → Ideal O)) (hT : T ⊆ assignedTuples L) : + (∑ q ∈ T, ‖assignedCoefficient a q‖) * U^(-(∑ i, ell i)) ≤ + assignedConstant K b := by + have hUp : 0 < U := lt_of_lt_of_le zero_lt_one hU + calc + _ ≤ (assignedConstant K b * U^(∑ i, ell i)) * U^(-(∑ i, ell i)) := + mul_le_mul_of_nonneg_right (restricted_mass_le K hb hU hK ell L hL a ha T hT) + (Real.rpow_nonneg hUp.le _) + _ = _ := by rw [mul_assoc, ← Real.rpow_add hUp]; simp + +theorem restricted_sum_normalized_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {ι : Type*} [Fintype ι] (hK : Fintype.card ι ≤ K) + (ell : ι → ℝ) (L : ι → Finset (Ideal O)) + (hL : ∀ i I, I ∈ L i → I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) + (a : ι → Ideal O → ℂ) (ha : ∀ i I, I ∈ L i → ‖a i I‖ ≤ 1) + (T : Finset (ι → Ideal O)) (hT : T ⊆ assignedTuples L) : + (∑ q ∈ T, ‖assignedCoefficient a q‖ * U^(-(∑ i, ell i))) ≤ + assignedConstant K b := by + rw [← Finset.sum_mul] + exact restricted_normalized_mass_le K hb hU hK ell L hL a ha T hT + +theorem slots_normalized_mass_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {σ : Type*} (J : Finset σ) (hJ : J.card ≤ K) + (ell : σ → ℝ) (L : σ → Finset (Ideal O)) + (hL : ∀ i ∈ J, ∀ I ∈ L i, I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) + (a : σ → Ideal O → ℂ) (ha : ∀ i ∈ J, ∀ I ∈ L i, ‖a i I‖ ≤ 1) + (T : Finset (J → Ideal O)) (hT : T ⊆ assignedTuples (fun i : J => L i)) : + (∑ q ∈ T, ‖assignedCoefficient (fun i : J => a i) q‖) * U^(-(∑ i ∈ J, ell i)) ≤ + assignedConstant K b := by + simpa only [Finset.sum_coe_sort] using + restricted_normalized_mass_le K hb hU (by simpa using hJ) + (fun i : J => ell i) (fun i : J => L i) + (fun i I hI => hL i i.property I hI) (fun i : J => a i) + (fun i I hI => ha i i.property I hI) T hT + +theorem assigned_sum_normalized_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {ι : Type*} [Fintype ι] (hK : Fintype.card ι ≤ K) + (ell : ι → ℝ) (L : ι → Finset (Ideal O)) + (hL : ∀ i I, I ∈ L i → I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) + (a : ι → Ideal O → ℂ) (ha : ∀ i I, I ∈ L i → ‖a i I‖ ≤ 1) : + (∑ q ∈ assignedTuples L, ‖assignedCoefficient a q‖ * U^(-(∑ i, ell i))) ≤ + assignedConstant K b := + restricted_sum_normalized_le K hb hU hK ell L hL a ha _ (Finset.Subset.refl _) + +theorem slots_card_le (K : ℕ) {b U : ℝ} (hb : 1 ≤ b) (hU : 1 ≤ U) + {σ : Type*} (J : Finset σ) (hJ : J.card ≤ K) + (ell : σ → ℝ) (L : σ → Finset (Ideal O)) + (hL : ∀ i ∈ J, ∀ I ∈ L i, I ≠ 0 ∧ (Ideal.absNorm I : ℝ) ≤ b*U^(ell i)) : + ((assignedTuples (fun i : J => L i)).card : ℝ) ≤ + assignedConstant K b * U^(∑ i ∈ J, ell i) := by + simpa only [Finset.sum_coe_sort] using + assigned_card_le K hb hU (by simpa using hJ) + (fun i : J => ell i) (fun i : J => L i) + (fun i I hI => hL i i.property I hI) + +theorem assignedTuples_eq_empty {ι : Type*} [Fintype ι] + (L : ι → Finset (Ideal O)) (i : ι) (hi : L i = ∅) : + assignedTuples L = ∅ := by + apply Finset.eq_empty_iff_forall_notMem.mpr + intro q hq + have h := (mem_assignedTuples L q).mp hq i + simp only [hi, Finset.notMem_empty] at h + +theorem assignedTuples_card_of_isEmpty {ι : Type*} [Fintype ι] [IsEmpty ι] + (L : ι → Finset (Ideal O)) : (assignedTuples L).card = 1 := by + simp [assignedTuples] + +end SevenEighths.DetectorDictionaryInverseAssignedCount + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseClippedUniform.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseClippedUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..196d4855d76727c6d8d91259de9f4b46832dad73 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseClippedUniform.lean @@ -0,0 +1,291 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseUniformSource +import OAI.NumberTheory.DirichletL.Descent.ClippedEnergy +import OAI.NumberTheory.DirichletL.Inversion.InitialEnergyCallerClipping +import OAI.NumberTheory.DirichletL.Inversion.InitialEnergyCallerUniform + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap FourierTransform ContDiff +open MeasureTheory FourierBridge + +namespace SevenEighths.DetectorDictionaryInverseClippedUniform +open DetectorDictionaryInverseUniform HeckeInverseAmplification +open InverseMoment InverseInitialClippedColumns InverseInitialOverlapFourier +open ActualEisensteinCubic CompletedGauss +local notation "O" => ActualEisensteinCubic.O + +theorem source_support (scaled reverse : Bool) (n : ℕ) (U tstar r σ t : ℝ) : + Function.support (inverseSourceSchwartz scaled reverse n U tstar r σ t : ℝ→ℂ) ⊆ + Set.Icc (1/4 : ℝ) (9/4) := by + let W := inverseDetectorSchwartz reverse n (U^r/U^tstar) σ t + have hw : Function.support (W : ℝ→ℂ) ⊆ Set.Icc (1/4 : ℝ) (9/4) := by + have he : (W : ℝ→ℂ) = twistProfile + (baseProfile reverse n HeckeDetectorProfiles.cutoff + HeckeDetectorDyadicProfiles.positiveAnnular (U^r/U^tstar)) σ t := by + funext x + exact inverseDetectorSchwartz_apply _ _ _ _ _ _ + rw [he] + exact (twistProfile_support _ _ _).trans + ((baseProfile_support _ _ _ _ _).trans HeckeDetectorDyadicProfiles.positiveAnnular_support) + have ht : tsupport (W : ℝ→ℂ) ⊆ Set.Icc (1/4 : ℝ) (9/4) := + closure_minimal hw isClosed_Icc + cases scaled + · exact hw + · intro x hx + by_contra hn + have hz : W x = 0 := by + by_contra h + exact hn (hw h) + have hd : deriv (W : ℝ→ℂ) x = 0 := by + by_contra h + exact hn (ht (support_deriv_subset h)) + apply hx + change scaleCLM W x = 0 + rw [scaleCLM_apply] + simp [scaleProfile, hz, hd] + +theorem source_zero_of_ratio (scaled reverse : Bool) (n : ℕ) (U tstar r σ t : ℝ) + (h : 4 ≤ U^r/U^tstar) : inverseSourceSchwartz scaled reverse n U tstar r σ t = 0 := + inverseDetectorTest_zero_of_four_le scaled reverse n _ σ t h + +theorem exists_reference_window : + ∃w : 𝓢(ℝ,ℂ), HasCompactSupport (w : ℝ→ℂ) ∧ + tsupport (w : ℝ→ℂ) ⊆ Set.Icc (1/18 : ℝ) (13/4) ∧ + ∀x∈Set.Icc (1/9 : ℝ) (9/4), w x = 1 := by + obtain ⟨w,hc,hone,hs⟩ := InverseSecondChildWindows.positive_cutoff + (1/9 : ℝ) (9/4) (by norm_num) (by norm_num) + refine ⟨w,hc,?_,hone⟩ + convert hs using 1 + norm_num + +def referenceWindow : 𝓢(ℝ,ℂ) := Classical.choose exists_reference_window + +theorem referenceWindow_compact : HasCompactSupport (referenceWindow : ℝ→ℂ) := + (Classical.choose_spec exists_reference_window).1 + +theorem referenceWindow_support : tsupport (referenceWindow : ℝ→ℂ) ⊆ + Set.Icc (1/18 : ℝ) (13/4) := + (Classical.choose_spec exists_reference_window).2.1 + +theorem referenceWindow_one (x : ℝ) (hx : x∈Set.Icc (1/9 : ℝ) (9/4)) : + referenceWindow x = 1 := + (Classical.choose_spec exists_reference_window).2.2 x hx + +theorem referenceWindow_agrees (scaled reverse : Bool) (n : ℕ) (U tstar r σ t c y : ℝ) + (hc : 1≤c) (hcb : c≤9/4) (hy : 0 nlinarith [hs.1,hs.2] + rw [referenceWindow_one y hh,one_mul] + +def logSource (scaled reverse : Bool) (n : ℕ) (U tstar r σ t : ℝ) : 𝓢(ℝ,ℂ) := + CubicReflectionKernel.logPullbackCLM (1/4) (9/4) + (inverseSourceSchwartz scaled reverse n U tstar r σ t) + +theorem logSource_apply (scaled reverse : Bool) (n : ℕ) (U tstar r σ t x : ℝ) : + logSource scaled reverse n U tstar r σ t x = + inverseSourceSchwartz scaled reverse n U tstar r σ t (Real.exp x) := + CubicReflectionKernel.logPullbackCLM_eq_actual _ _ (by norm_num) _ + (source_support scaled reverse n U tstar r σ t) x + +theorem logSource_eq_logSchwartz (scaled reverse : Bool) (n : ℕ) (U tstar r σ t : ℝ) : + logSource scaled reverse n U tstar r σ t = + CubicReflectionKernel.logSchwartz (inverseSourceSchwartz scaled reverse n U tstar r σ t) + (1/4) (9/4) (by norm_num) (source_support scaled reverse n U tstar r σ t) + ((inverseSourceSchwartz scaled reverse n U tstar r σ t).smooth ⊤) := by + ext x + rw [logSource_apply,CubicReflectionKernel.logSchwartz_apply] + +def familyDensity (scaled reverse : Bool) (n : ℕ) (U tstar r σ t c v : ℝ) : ℂ := + density (logSource scaled reverse n U tstar r σ t) (Real.log c) v + +theorem familyDensity_formula (scaled reverse : Bool) (n : ℕ) (U tstar r σ t c v : ℝ) : + familyDensity scaled reverse n U tstar r σ t c v = + (𝓕 (logSource scaled reverse n U tstar r σ t)) v * logPhase v (Real.log c) := rfl + +theorem familyDensity_norm (scaled reverse : Bool) (n : ℕ) (U tstar r σ t c v : ℝ) : + ‖familyDensity scaled reverse n U tstar r σ t c v‖ = + ‖(𝓕 (logSource scaled reverse n U tstar r σ t)) v‖ := density_norm _ _ _ + +theorem familyDensity_integrable (J : ℕ) (scaled reverse : Bool) (n : ℕ) + (U tstar r σ t c : ℝ) : + Integrable (fun v : ℝ => (1+‖v‖)^J * ‖familyDensity scaled reverse n U tstar r σ t c v‖) := by + simp only [familyDensity_norm] + exact AnalyticBridge.schwartz_fourier_one_plus_integrable _ _ + +theorem familyDensity_moment (J : ℕ) : + ∃K : ℕ, ∃C : ℝ, 0Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + +theorem canonical_family_mode_integrable + (hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Ψ : O→*ℂ) (m f k : O) (slots : Finset ρ) + (lists : ρ→Finset ι) (a : ρ→ι→ℂ) + (scaled reverse : Bool) (n : ℕ) (U tstar r σ t c θ X : ℝ) : + Integrable (fun v : ℝ => familyDensity scaled reverse n U tstar r σ t c v * + finiteCanonicalMarkedRow p hp hcop hg pool Ψ m f k slots lists a + (childLogTest referenceWindow (θ+v)) X) := + canonical_clipped_mode_integrable p hp hcop hg hpr pool Ψ m f k slots lists a + (logSource scaled reverse n U tstar r σ t) referenceWindow c θ X + +theorem canonical_clipped_family_fourier + (hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Ψ : O→*ℂ) (m f k : O) (slots : Finset ρ) + (lists : ρ→Finset ι) (a : ρ→ι→ℂ) + (scaled reverse : Bool) (n : ℕ) (U tstar r σ t c θ X : ℝ) + (hc : 1≤c) (hcb : c≤9/4) (hX : 0referenceWindow_agrees scaled reverse n U tstar r σ t c y hc hcb hy) +end Rows + +theorem canonical_clipped_family_energy (J : ℕ) : + ∃K : ℕ, ∃C : ℝ, 0Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Ψ : O→*ℂ) (m : O) (slots : Finset ρ) (lists : ρ→Finset ι) (a : ρ→ι→ℂ) + (labels : Finset (Ideal O)) (rows : Finset O) (D : Ideal O→ℝ) (_hD : ∀f∈labels,0≤D f) + (c θ X Z F E : ℝ), 1≤c → c≤9/4 → 0referenceWindow_agrees scaled reverse n U tstar r σ t c y hc hcb hy) he + have hm := hmass scaled reverse n hn U hU tstar r σ hσ t c + simp only [familyDensity_norm,logSource_eq_logSchwartz] at hm + have hs := pow_le_pow_left₀ + (integral_nonneg (fun v : ℝ => by positivity)) hm 2 + apply hb.trans + calc + _ ≤ E*(1+‖θ‖)^(2*J)*(C*(1+‖t‖)^K)^2 := + mul_le_mul_of_nonneg_left hs (by positivity) + _ = _ := by rw [mul_pow,←pow_mul]; ring_nf + +theorem initial_raw_family_energy (J : ℕ) : + ∃K : ℕ, ∃C : ℝ, 0Ideal.span {p i}))) + (hg : ∀i,ConcretePrimeRowBridge.goodLambda∉Ideal.span {p i}) + (_hpr : ∀i,ConcretePrimeRowBridge.goodLambda^2∣p i-1) + (pool : Finset ι) (Ψ : O→*ℂ) (m : O) (slots : Finset ρ) (lists : ρ→Finset ι) (a : ρ→ι→ℂ) + (labels : Finset (Ideal O)) (rows : Finset O) (D : Ideal O→ℝ) (_hD : ∀f∈labels,0≤D f) + (Z N F E : ℝ) (z : JointLogSeparation.Frequency×(Fin 6→ℝ)) (h : ℝ), 1 HeckeFamily.O + +def radialMajorant : 𝓢(ℝ,ℂ) := + Classical.choose DetectorDictionaryInverseRawRadial.exists_raw_radial_majorant + +theorem radialMajorant_compact : HasCompactSupport (radialMajorant : ℝ→ℂ) := + (Classical.choose_spec DetectorDictionaryInverseRawRadial.exists_raw_radial_majorant).1 + +theorem radialMajorant_nonneg (x : ℝ) : 0≤(radialMajorant x).re := + (Classical.choose_spec DetectorDictionaryInverseRawRadial.exists_raw_radial_majorant).2.1 x + +theorem radialMajorant_one (x : ℝ) (hx : x∈Set.Icc (0:ℝ) 1) : radialMajorant x=1 := + (Classical.choose_spec DetectorDictionaryInverseRawRadial.exists_raw_radial_majorant).2.2 x hx + +theorem compact_radial_summable (Φ : 𝓢(ℝ,ℂ)) + (hΦ : HasCompactSupport (Φ : ℝ→ℂ)) (Y : ℝ) (hY : 0radialWeight Φ Y u*‖f u‖^2) := by + obtain ⟨B,hB⟩ := hΦ.isBounded.exists_norm_le + let R := ShortDraftLatticeCount.rowNormBall ⌈B*Y⌉₊ + apply (hasSum_sum_of_ne_finset_zero (s:=R) ?_).summable + intro u hu + have hz : Φ (‖eisEmbedding u‖^2/Y)=0 := by + by_contra hn + have hb := hB _ (subset_tsupport Φ hn) + have hnB : (Ideal.absNorm (Ideal.span {u}):ℝ)≤B*Y := by + rw [Real.norm_eq_abs,abs_of_nonneg (div_nonneg (sq_nonneg _) hY.le)] at hb + rw [eisEmbedding_norm_sq_eq_absNorm_span] at hb + exact (div_le_iff₀ hY).mp hb + apply hu + apply ShortDraftLatticeCount.mem_rowNormBall_of_absNorm_le + exact_mod_cast hnB.trans (Nat.le_ceil (B*Y)) + simp [radialWeight,hz] + +theorem radialMajorant_summable (Y : ℝ) (hY : 0radialWeight radialMajorant Y u*‖f u‖^2) := + compact_radial_summable radialMajorant radialMajorant_compact Y hY f + +theorem finite_source_le_smoothed {Row : Type*} (rows : Finset Row) + (row : Row→O) (hinj : Function.Injective row) (f : O→ℂ) + (Y : ℝ) (hY : 0hinj hab)] + _≤∑'u : O,radialWeight radialMajorant Y u*‖f u‖^2 := + (radialMajorant_summable Y hY f).sum_le_tsum _ + (fun u _=>mul_nonneg (radialMajorant_nonneg _) (sq_nonneg _)) + _=smoothedEnergy radialMajorant Y f := rfl + +variable {M : Ideal O} [NeZero M] {H : Subgroup (O ⧸ M)ˣ} {Label Slot : Type*} + {U a ε tstar T allowance : ℝ} {i : ℕ} + +def selectedSource (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (W : ℝ→ℂ) (σ t bW : ℝ) (u : O) : ℂ := + ∑p∈Fintype.piFinset (fun s:selected=> + livePrimes M H (F.profile s) (F.upper s) (U^(F.widths s))), + (star (∏s:selected,primeProfile (F.profile s) (U^(F.widths s)) (F.external s) (p s))/ + fixedBase F.rowData.η F.rowData.m F.rowData.f (∏s:selected,p s))* + originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*bW⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,p s) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (orientedProfile F.reverse W) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u + +omit [NeZero M] in +theorem selectedSource_norm (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (W : ℝ→ℂ) (σ t bW : ℝ) (lower : Slot→ℝ) + (hU : 0radialWeight radialMajorant Y u* + ‖selectedSource F selected W σ t bW u‖^2) := + radialMajorant_summable Y hY _ + +omit [NeZero M] in +theorem selectedSource_energy + (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (W : ℝ→ℂ) (σ t bW : ℝ) (lower : Slot→ℝ) + (hU : 0u.val) + Subtype.val_injective _ _ (Real.rpow_pos_of_pos hU0 _) + (fun u hu=>(F.row_norm u hu).trans hpad) + +omit [NeZero M] in +theorem fiber_inverse_le_padded_smoothed + (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (n : ℕ) (σ t ρ : ℝ) (lower : Slot→ℝ) + (hU : 1≤U) (hρ : 0≤ρ) + (hV : ∀s∈selected,∀x,F.profile s x≠0 → x∈Set.Icc (lower s) (F.upper s)) + (hlarge : ∀s∈selected,((baseCharacter F.rowData).modulus.absNorm:ℝ) linarith + +omit [NeZero M] in +theorem fiber_padding_margins + (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (ρ : ℝ) (hρ : 0≤ρ) + (hfirst : F.r+2*(∑s∈selected,F.widths s)<1) + (hsecond : 2*F.r+8*(∑s∈selected,F.widths s)<3) : + F.r+2*(∑s∈selected,F.widths s)≤(1+ρ)-ρ ∧ + 2*F.r+8*(∑s∈selected,F.widths s)≤3*(1+ρ)-3*ρ ∧ + InverseMoment.MarkedMargins (1+ρ) F.r (∑s∈selected,F.widths s) ρ := + fixed_padding_margins _ _ ρ hρ hfirst hsecond + +theorem padded_output_budget (U C ρ loss εm : ℝ) (hU : 1≤U) (hC : 0≤C) + (hbudget : ρ+loss≤εm) : C*U^(1+ρ+loss)≤C*U^(1+εm) := by + apply mul_le_mul_of_nonneg_left _ hC + exact Real.rpow_le_rpow_of_exponent_le hU (by linarith) + +end SevenEighths.DetectorDictionaryInverseMarkedPadding + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedPhysicalRows.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedPhysicalRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..548b424ebd90e05d068f59cd98f2b607c7892813 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedPhysicalRows.lean @@ -0,0 +1,139 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceDeleted +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedUniform +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceShift + +namespace OAI + +noncomputable section +open scoped Classical BigOperators + +namespace SevenEighths.DetectorDictionaryInverseMarkedPhysicalRows +open HeckeFamily HeckeDyadic HeckeInverseAmplification HeckeDetectorRawFiber +open HeckeDetectorCoefficientTransfer HeckeDetectorPhysicalSelection +open InverseInitialPhysicalSlots InverseInitialRawDictionary InverseInitialDetectorSource +open DetectorDictionaryInverseMarkedReference DetectorDictionaryInverseRawInitialGates +open InverseInitialExcludedPeriod CanonicalRowCompletion IdealMobiusDivisorSum InverseMoment +local notation "O"=>HeckeFamily.O + + def actualRow (u:FreeRow):NonzeroElement:=⟨u.val,u.property.1⟩ + + theorem actualRow_injective:Function.Injective actualRow:=by + intro u v he + exact Subtype.ext (congrArg (fun w:NonzeroElement=>w.val) he) + + theorem actual_rows_sum (rows:Finset FreeRow)(f:NonzeroElement→ℝ): + (∑u∈rows.image actualRow,f u)=∑u∈rows,f (actualRow u):= + Finset.sum_image (fun _u _ _v _ h=>actualRow_injective h) + + theorem oriented_child (reverse:Bool)(W:ℝ→ℂ)(v:ℝ): + orientedProfile reverse (childLogTest W v)= + childLogTest (orientedProfile reverse W) (orientedFrequency reverse v):=by + cases reverse + · rfl + · exact DetectorDictionaryInverseRawConjugateGates.childLogTest_conjugate W v + +variable {M:Ideal O}[NeZero M]{H:Subgroup (O⧸M)ˣ}{Label Slot:Type*} + {U a ε tstar T allowance:ℝ}{i:ℕ} + +omit [NeZero M] in +theorem physicalProduct_eq (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(u:FreeRow): + F.physicalProduct selected u= + ∏s:selected,HeckePrimeRow.canonicalPrimeAmplitude M H u.val + (F.profile s) (F.upper s) (U^(F.widths s)) (F.external s):=by + simp only [Fiber.physicalProduct,physical] + exact (Finset.prod_coe_sort selected _).symm + + theorem fiber_rows_le_deleted_sources + (F:Fiber M H Label Slot U a ε tstar T allowance i)(selected:Finset Slot) + (W:ℝ→ℂ)(σ freq bW:ℝ)(lower:Slot→ℝ)(hU:1F.profile s) U (shiftedExponent F.rowData U F.r j) + σ (orientedFrequency F.reverse freq) bW + (fun s:selected=>F.upper s) (fun s:selected=>F.widths s) + (fun s:selected=>F.external s) u.val‖^2:=by + have hU0:0∏s:selected, + HeckePrimeRow.canonicalPrimeAmplitude M H u.val (F.profile s) (F.upper s) + (U^(F.widths s)) (F.external s) + have hw:∀x,orientedProfile F.reverse W x≠0→x≤bW:=by + intro x hx + apply hW x + intro hz + exact hx (by cases F.reverse <;> simp [orientedProfile,hz]) + have he:(∑u∈F.rows,‖polynomial (F.family u F.label) true W (U^F.r) σ freq* + F.physicalProduct selected u‖^2)= + ∑u∈F.rows.image actualRow,‖polynomial (F.rowData.character u) true + (orientedProfile F.reverse W) (U^F.r) σ (orientedFrequency F.reverse freq)*mark u‖^2:=by + rw [actual_rows_sum] + apply Finset.sum_congr rfl + intro u hu + have hn:=norm_of_oriented_coefficients (F.family u F.label) + (F.rowData.character (actualRow u)) F.reverse (F.row_coeff u hu) + true W (U^F.r) σ freq (Real.rpow_pos_of_pos hU0 _) + rw [norm_mul,hn,physicalProduct_eq,norm_mul] + rfl + rw [he] + apply (marked_fixed_deletion F.rowData (F.rows.image actualRow) + (orientedProfile F.reverse W) (U^F.r) σ (orientedFrequency F.reverse freq) bW + (Real.rpow_pos_of_pos hU0 _) hw mark).trans_eq + congr 1 + apply Finset.sum_congr rfl + intro j hj + rw [actual_rows_sum] + apply Finset.sum_congr rfl + intro u hu + have hjpos:0<(j.absNorm:ℝ):=zero_lt_one.trans_le (excluded_divisor_norm F.rowData j hj).1 + have hr:U^(shiftedExponent F.rowData U F.r j)=U^F.r/(j.absNorm:ℝ):= + by rw [shiftedExponent,Real.rpow_sub hU0,Real.rpow_logb hU0 (ne_of_gt hU) hjpos] + have hn:=deleted_physical_slots_norm_initial F.rowData (actualRow u) M H + (orientedProfile F.reverse W) (fun s:selected=>F.profile s) + U (shiftedExponent F.rowData U F.r j) σ (orientedFrequency F.reverse freq) bW + (fun s:selected=>lower s) (fun s:selected=>F.upper s) (fun s:selected=>F.widths s) + (fun s:selected=>F.external s) hU0 hw (fun s=>hV s s.property) + (fun s=>hlarge s s.property) + rw [hr] at hn + exact congrArg (fun x:ℝ=>x^2) hn + + theorem fiber_child_rows_le_deleted_sources + (F:Fiber M H Label Slot U a ε tstar T allowance i)(selected:Finset Slot) + (W:ℝ→ℂ)(v bW:ℝ)(lower:Slot→ℝ)(hU:1F.profile s) U (shiftedExponent F.rowData U F.r j) + 0 0 bW (fun s:selected=>F.upper s) (fun s:selected=>F.widths s) + (fun s:selected=>F.external s) u.val‖^2:=by + have hw:∀x,childLogTest W v x≠0→x≤bW:=by + intro x hx + apply hW x + intro hz + exact hx (by simp only [childLogTest,hz,zero_mul]) + have hh:=fiber_rows_le_deleted_sources F selected (childLogTest W v) 0 0 bW lower hU hw hV hlarge + simpa only [oriented_child,orientedFrequency,neg_zero,ite_self] using hh + +omit [NeZero M] in +theorem actual_rows_norm (F:Fiber M H Label Slot U a ε tstar T allowance i) + (u:NonzeroElement)(hu:u∈F.rows.image actualRow): + ((Ideal.span {u.val}).absNorm:ℝ)≤U:=by + obtain ⟨v,hv,rfl⟩:=Finset.mem_image.mp hu + exact F.row_norm v hv + +end SevenEighths.DetectorDictionaryInverseMarkedPhysicalRows + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceArithmetic.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceArithmetic.lean new file mode 100644 index 0000000000000000000000000000000000000000..0eda7d31feaff54ae1e5315ee89d343f30717576 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceArithmetic.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceReindex +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceDeleted + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily CanonicalQuadraticSieve InverseInitialCommonRatios InverseInitialExcludedPool +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +theorem tuple_supported (L:ι→Finset (Ideal O))(hs:∀i,∀P∈L i,Supported P)(q:Tuple L) : + Supported (∏i,(q i).val) := by + have hh (T:Finset ι):Supported (∏i∈T,(q i).val) := by + induction T using Finset.induction_on with + | empty => + simp only [Finset.prod_empty] + exact ⟨one_ne_zero,by intro P hP;simp only [UniqueFactorizationMonoid.normalizedFactors_one,Multiset.notMem_zero] at hP⟩ + | @insert i T hi ih => + rw [Finset.prod_insert hi] + exact (supported_mul_iff _ _).mpr ⟨hs i _ (q i).property,ih⟩ + exact hh Finset.univ + +theorem tuple_admissible (L:ι→Finset (Ideal O))(hp:∀i,∀P∈L i,Prime P) + (hs:∀i,∀P∈L i,Supported P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L)(q:Tuple L) : + Admissible (∏i,(q i).val) := + ⟨(tuple_supported L hs q).1,tuple_product_squarefree _ (fun i=>hp i _ (q i).property) + (tuple_injective L hdis q),(tuple_supported L hs q).2⟩ + +def remainingFromPi (L:ι→Finset (Ideal O))(J:Finset ι) + (t:∀i∈Finset.univ\J,Ideal O)(ht:t∈(Finset.univ\J).pi L) : Remaining L J := + fun i=>⟨t i.val (Finset.mem_sdiff.mpr ⟨Finset.mem_univ _,i.property⟩), + Finset.mem_pi.mp ht i.val (Finset.mem_sdiff.mpr ⟨Finset.mem_univ _,i.property⟩)⟩ + +theorem remainingIdeal_fromPi (L:ι→Finset (Ideal O))(J:Finset ι) + (t:∀i∈Finset.univ\J,Ideal O)(ht:t∈(Finset.univ\J).pi L) : + remainingIdeal L J (remainingFromPi L J t ht)=survivingProduct (Finset.univ\J) t := by + unfold remainingIdeal + rw [remaining_product_attach] + rfl + +theorem remaining_tuple_admissible (L:ι→Finset (Ideal O))(hp:∀i,∀P∈L i,Prime P) + (hs:∀i,∀P∈L i,Supported P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(x:Assigned L J)(t:∀i∈Finset.univ\J,Ideal O) + (ht:t∈(Finset.univ\J).pi L) : + Admissible (assignedIdeal L J x*survivingProduct (Finset.univ\J) t) := by + rw [←remainingIdeal_fromPi L J t ht,←joinTuple_product] + exact tuple_admissible L hp hs hdis _ + +theorem remaining_tuple_coprime (L:ι→Finset (Ideal O))(hp:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(t:∀i∈Finset.univ\J,Ideal O)(ht:t∈(Finset.univ\J).pi L) : + Pairwise (Function.onFun IsCoprime (fun i:↥(Finset.univ\J)=>t i.val i.property)) := by + intro i j hij + have hiP:=hp i.val _ (Finset.mem_pi.mp ht i.val i.property) + have hjP:=hp j.val _ (Finset.mem_pi.mp ht j.val j.property) + let:(t i.val i.property).IsMaximal:=(Ideal.isPrime_of_prime hiP).isMaximal hiP.ne_zero + let:(t j.val j.property).IsMaximal:=(Ideal.isPrime_of_prime hjP).isMaximal hjP.ne_zero + apply Ideal.isCoprime_of_isMaximal + intro he + dsimp only at he + exact Finset.disjoint_left.mp (hdis (Finset.mem_univ i.val) (Finset.mem_univ j.val) + (fun hh=>hij (Subtype.ext hh))) (Finset.mem_pi.mp ht i.val i.property) + (by rw [he];exact Finset.mem_pi.mp ht j.val j.property) + +omit [DecidableEq ι] in +theorem tuple_outside (L:ι→Finset (Ideal O))(E:Finset (Ideal O))(hE:∀P∈E,Prime P) + (hout:∀i,∀P∈L i,outside E P)(q:Tuple L) : outside E (∏i,(q i).val) := by + intro P hP hd + obtain ⟨i,hi,hdi⟩:=((hE P hP).dvd_finsetProd_iff (fun i=>(q i).val)).mp hd + exact hout i _ (q i).property P hP hdi + +theorem remaining_tuple_outside (L:ι→Finset (Ideal O))(E:Finset (Ideal O))(hE:∀P∈E,Prime P) + (hout:∀i,∀P∈L i,outside E P)(J:Finset ι)(x:Assigned L J) + (t:∀i∈Finset.univ\J,Ideal O)(ht:t∈(Finset.univ\J).pi L) : + outside E (assignedIdeal L J x*survivingProduct (Finset.univ\J) t) := by + rw [←remainingIdeal_fromPi L J t ht,←joinTuple_product] + exact tuple_outside L E hE hout _ + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceCoefficients.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceCoefficients.lean new file mode 100644 index 0000000000000000000000000000000000000000..b185fab13a3639fbc4b5da8ee743b3aeb885611a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceCoefficients.lean @@ -0,0 +1,75 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedPadding + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeDyadic HeckeInverseAmplification HeckeDetectorRawFiber +open InverseInitialRawDictionary InverseInitialDetectorSource InverseInitialPhysicalSlots +open DetectorDictionaryInverseMarkedPadding +local notation "O"=>HeckeFamily.O + +def slotCoefficient (data:RowData)(V:ℝ→ℂ)(Y:ℝ)(ζ:ℂ)(P:Ideal O) : ℂ := + star (primeProfile V Y ζ P)/fixedBase data.η data.m data.f P + +theorem slotCoefficient_character (data:RowData)(V:ℝ→ℂ)(Y:ℝ)(ζ:ℂ)(P:Ideal O) : + slotCoefficient data V Y ζ P= + idealCoeff (baseCharacter data).inverse P*star (primeProfile V Y ζ P) := by + rw [slotCoefficient,HeckeDetectorRelativePrime.idealCoeff_inverse,baseCharacter_coeff, + div_eq_mul_inv,mul_comm] + +theorem tuple_coefficient {ι:Type*}[Fintype ι](data:RowData) + (V:ι→ℝ→ℂ)(Y:ι→ℝ)(ζ:ι→ℂ)(P:ι→Ideal O) : + star (∏i,primeProfile (V i) (Y i) (ζ i) (P i))/ + fixedBase data.η data.m data.f (∏i,P i)= + ∏i,slotCoefficient data (V i) (Y i) (ζ i) (P i) := by + simp only [slotCoefficient,star_prod,map_prod,Finset.prod_div_distrib] + +def normalizedSlotCoefficient (data:RowData)(V:ℝ→ℂ)(Y:ℝ)(ζ:ℂ)(C:ℝ)(P:Ideal O) : ℂ := + slotCoefficient data V Y ζ P/(C:ℂ) + +theorem tuple_coefficient_normalized {ι:Type*}[Fintype ι](data:RowData) + (V:ι→ℝ→ℂ)(Y:ι→ℝ)(ζ:ι→ℂ)(C:ι→ℝ)(hC:∀i,C i≠0)(P:ι→Ideal O) : + star (∏i,primeProfile (V i) (Y i) (ζ i) (P i))/ + fixedBase data.η data.m data.f (∏i,P i)= + (∏i,(C i:ℂ))*∏i,normalizedSlotCoefficient data (V i) (Y i) (ζ i) (C i) (P i) := by + rw [tuple_coefficient,←Finset.prod_mul_distrib] + apply Finset.prod_congr rfl + intro i hi + rw [normalizedSlotCoefficient] + field_simp [hC i] + +variable {M:Ideal O}[NeZero M]{H:Subgroup (O⧸M)ˣ}{Label Slot:Type*} + {U a ε tstar T allowance:ℝ}{i:ℕ} + +omit [NeZero M] in +theorem selectedSource_normalized (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(W:ℝ→ℂ)(σ t bW:ℝ)(C:Slot→ℝ)(hC:∀s∈selected,C s≠0)(u:O) : + selectedSource F selected W σ t bW u= + (∏s∈selected,(C s:ℂ))* + ∑p∈Fintype.piFinset (fun s:selected=>livePrimes M H (F.profile s) (F.upper s) (U^(F.widths s))), + (∏s:selected,normalizedSlotCoefficient F.rowData (F.profile s) (U^(F.widths s)) + (F.external s) (C s) (p s))* + InverseInitialConjugateEnergy.originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*bW⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,p s) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (HeckeDetectorCoefficientTransfer.orientedProfile F.reverse W) σ + (HeckeDetectorCoefficientTransfer.orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u := by + unfold selectedSource + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro p hp + rw [tuple_coefficient_normalized F.rowData (fun s:selected=>F.profile s) + (fun s:selected=>U^(F.widths s)) (fun s:selected=>F.external s) + (fun s:selected=>C s) (fun s=>hC s s.property) p] + rw [Finset.prod_coe_sort selected (fun s=>(C s:ℂ))] + ring + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDeleted.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDeleted.lean new file mode 100644 index 0000000000000000000000000000000000000000..40093c449141f9f14af4b0b6f559755d4369a879 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDeleted.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceFiber +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawConjugateGates +import OAI.NumberTheory.DirichletL.Inversion.InitialExcludedEnergy + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeDyadic HeckeInverseAmplification InverseInitialDetectorSource +open InverseInitialRawDictionary InverseInitialConjugateEnergy InverseInitialPhysicalSlots +open InverseInitialMarkedDictionary +open DetectorDictionaryInverseRawInitialGates InverseInitialExcludedPeriod +open CanonicalQuadraticSieve CanonicalRowCompletion +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι] + +theorem deletedBase_zero_unsupported (data:RowData)(I:Ideal O)(hI:¬Supported I) : + idealCoeff (deletedBase data) I=0 := by + unfold deletedBase excluded + rw [idealCoeff_excludePrimes,baseCharacter_coeff, + fixedBase_zero_unsupported data.η data.m data.f data.lambda_dvd data.two_dvd I hI] + split_ifs <;> rfl + +theorem deletedBase_eq_of_ne_zero (data:RowData)(I:Ideal O) + (hI:idealCoeff (deletedBase data) I≠0) : + idealCoeff (deletedBase data) I=fixedBase data.η data.m data.f I := by + unfold deletedBase excluded at hI ⊢ + rw [idealCoeff_excludePrimes,baseCharacter_coeff] at hI ⊢ + split_ifs with h + · rfl + · exact False.elim (hI (by simp [h])) + +def deletedSelectedSource (data:RowData)(M:Ideal O)[NeZero M] + (H:Subgroup (O⧸M)ˣ)(W:ℝ→ℂ)(V:ι→ℝ→ℂ) + (Z r σ freq bW:ℝ)(b ell:ι→ℝ)(ζ:ι→ℂ)(u:O) : ℂ := + ∑p∈Fintype.piFinset (fun i=>livePrimes M H (V i) (b i) (Z^(ell i))), + (star (∏i,primeProfile (V i) (Z^(ell i)) (ζ i) (p i))/ + idealCoeff (deletedBase data) (∏i,p i))* + originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈Z^r*bW⌉₊).filter Supported) + (∏i,p i) (idealCoeff (deletedBase data)).toMonoidHom (fun _=>1) + (twistedProfile W σ freq) Z r (∑i,ell i) u + +theorem deleted_physical_slots_norm_initial (data:RowData)(u:NonzeroElement) + (M:Ideal O)[NeZero M](H:Subgroup (O⧸M)ˣ)(W:ℝ→ℂ)(V:ι→ℝ→ℂ) + (Z r σ freq bW:ℝ)(a b ell:ι→ℝ)(ζ:ι→ℂ)(hZ:0livePrimes M H (V i) (b i) (Z^(ell i)) + let A:=fun p:ι→Ideal O=>∏i,primeProfile (V i) (Z^(ell i)) (ζ i) (p i) + have hn (p:ι→Ideal O)(hp:p∈Fintype.piFinset L)(_ha:A p≠0): + idealCoeff (deletedBase data) (∏i,p i)≠0 := by + rw [map_prod] + apply Finset.prod_ne_zero_iff.mpr + intro i hi + have hd:=livePrime_data M H (V i) (a i) (b i) (Z^(ell i)) + (Real.rpow_pos_of_pos hZ _) (hV i) (p i) (Fintype.mem_piFinset.mp hp i) + exact HeckeDetectorRelativePrime.idealCoeff_ne_zero_of_coprime _ _ hd.1.ne_zero + (ProbeRaySlots.prime_coprime_of_norm_gt (deletedBase data) ⟨p i,hd.1⟩ + ((hlarge i).trans_le hd.2.2.1)) + have he:=indexed_conjugate_mark_norm (Fintype.piFinset L) (fun p=>∏i,p i) A + (idealCoeff (deletedBase data)).toMonoidHom + ((data.character u).excludePrimes (excluded data) (reflectionExcludedPrimes_prime (basePeriod data))) + u.val (actual_deleted_row data u) W Z r (∑i,ell i) σ freq hZ + (ConcretePrimeRowBridge.idealsUpTo ⌈Z^r*bW⌉₊) + (finite_source_cover W (Z^r) bW (Real.rpow_pos_of_pos hZ _) hW) hn + rw [amplitude_product_eq_tuples M H _ _ _ _ _ _ hZ,←mul_assoc] + change ‖polynomial ((data.character u).excludePrimes (excluded data) + (reflectionExcludedPrimes_prime (basePeriod data))) true W (Z^r) σ freq*↑(Z^(-(∑i,ell i)/2))* + (∑p∈Fintype.piFinset L,A p*star (idealRowHom u.val (∏i,p i)))‖=_ + rw [he] + unfold deletedSelectedSource + congr 1 + apply Finset.sum_congr rfl + intro p hp + rw [originalTotal_supported_source _ _ _ (deletedBase_zero_unsupported data)] + rfl + +theorem marked_fixed_deletion (data:RowData)(rows:Finset NonzeroElement) + (W:ℝ→ℂ)(X σ t bW:ℝ)(hX:01) (fun _ _=>zero_le_one) + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDeletedEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDeletedEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..09452f40885c4923f962db69950565657fb7c57d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDeletedEnergy.lean @@ -0,0 +1,103 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferencePaddedEnergy +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferencePrimeGates +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceShift + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap ContDiff Topology +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeInverseAmplification HeckeDyadic CanonicalQuadraticSieve +open CanonicalRowCompletion ConcretePrimeRowBridge ConcreteTraceCRT +open InverseInitialDetectorSource +open InverseMoment InverseInitialProfile InverseInitialRawDictionary InverseInitialPhysicalSlots +open InverseInitialConjugateEnergy InverseInitialEnergyCallerWindow InverseInitialExcludedPeriod +open DetectorDictionaryInverseRawInitialGates DetectorDictionaryInverseRawConjugateGates +open IdealMobiusDivisorSum Filter +local notation "O"=>HeckeFamily.O + +theorem deletedSelectedSource_tuple {ι:Type*}[Fintype ι](data:RowData) + (M:Ideal O)[NeZero M](H:Subgroup (O⧸M)ˣ)(W:ℝ→ℂ)(V:ι→ℝ→ℂ) + (U r bW:ℝ)(b ell:ι→ℝ)(ζ:ι→ℂ)(u:O): + deletedSelectedSource data M H W V U r 0 0 bW b ell ζ u= + ∑x:Tuple (fun i=>livePrimes M H (V i) (b i) (U^(ell i))), + (∏i,star (primeProfile (V i) (U^(ell i)) (ζ i) (x i).val)/ + idealCoeff (deletedBase data) (x i).val)* + originalTotalPolynomial (originalSource U r bW) (∏i,(x i).val) + (idealCoeff (deletedBase data)).toMonoidHom (fun _=>1) W U r (∑i,ell i) u := by + rw [sum_tuple_original (fun i=>livePrimes M H (V i) (b i) (U^(ell i))) + (fun x=>(∏i,star (primeProfile (V i) (U^(ell i)) (ζ i) (x i))/ + idealCoeff (deletedBase data) (x i))* + originalTotalPolynomial (originalSource U r bW) (∏i,x i) + (idealCoeff (deletedBase data)).toMonoidHom (fun _=>1) W U r (∑i,ell i) u)] + unfold deletedSelectedSource + apply Finset.sum_congr rfl + intro x hx + simp only [star_prod,map_prod,Finset.prod_div_distrib] + have ht:twistedProfile W 0 0=W:=by + funext t + simp [twistedProfile,HeckeDyadic.shift] + rw [ht] + rfl + +theorem deleted_source_energy {Δ:ℝ}{D:Parameters.HighData Δ} + (F:ProbeFinalAssembly.SourceData D) + (W:ℝ→ℂ)(ao bo:ℝ)(hao:0livePrimes M H F.W 2 (U^(ell i)))) → + (∀i,((deletedBase data).modulus.absNorm:ℝ)F.W) + U (shiftedExponent data U r j) 0 0 bo (fun _=>2) ell ζ u‖^2)≤ + C*U^(1+εm)*((1+‖θ‖)^degree)^2 := by + obtain ⟨eta,heta,degree,henergy⟩:=padded_source_energy W ao bo hao hab hsW hW εm hεm K + refine ⟨degree,?_⟩ + intro data + obtain ⟨hq,hqset,hn,hperiod⟩:=raw_conjugate_base_gates data + obtain ⟨C,U₀,hC,hU₀,henergy⟩:=henergy (deletedPeriod (basePeriod data)) hq + obtain ⟨Ushift,hshift⟩:=eventually_atTop.mp (marked_shift_eventually data eta heta) + refine ⟨C,max U₀ Ushift,hC,lt_max_of_lt_left hU₀,?_⟩ + intro U hU ι inst hK M neM H ell ζ hell hζ hdis hlarge r hr hfirst hsecond j hj rows hrows θ + have hU0:U₀≤U:=(le_max_left _ _).trans hU + have hUone:1livePrimes M H F.W 2 (U^(ell i)) + let coeff:ι→Ideal O→ℂ:=fun i P=>star (primeProfile F.W (U^(ell i)) (ζ i) P)/ + idealCoeff (deletedBase data) P + have hg (i:ι)(P:Ideal O)(hP:P∈L i): + Prime P ∧ InverseInitialExcludedPool.outside (excluded data) P ∧ + idealCoeff (deletedBase data) P≠0 ∧ ‖idealCoeff (deletedBase data) P‖=1 ∧ + ‖coeff i P‖≤1:= + deleted_source_live_prime F data M H _ (Real.rpow_pos_of_pos hUp _) (ζ i) (hζ i) (hlarge i) P hP + have hratio (i:ι)(P:Ideal O)(hP:P∈L i):((P.absNorm:ℝ)/U^(ell i))∈Set.Icc (1:ℝ) 2:= + F.complex_support (Finset.mem_filter.mp hP).2 + have hh:=henergy U hU0 hK L ell coeff hell + (fun i P hP=>(hg i P hP).1) + (fun i P hP=>deletedBase_supported data P (hg i P hP).2.2.1) + hdis hratio (fun i P hP=>(hg i P hP).2.2.2.2) + (fun i P hP=>by rw [hqset];exact (hg i P hP).2.1) + (fun _=>F.W) (fun _=>F.complex_support) + (fun i P hP=>(Finset.mem_filter.mp hP).2) + (idealCoeff (deletedBase data)).toMonoidHom (idealCoeff_norm_le_one (deletedBase data)) + hperiod (fun I hI=>raw_conjugate_zero_outside data I (by simpa [hqset] using hI)) + r (shiftedExponent data U r j) hr hjshift.1 hjshift.2.1 hfirst hsecond rows hrows θ + simpa only [deletedSelectedSource_tuple,L,coeff] using hh + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDivisors.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDivisors.lean new file mode 100644 index 0000000000000000000000000000000000000000..5b5b9b57519fba5e5123b2d05427417449059893 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceDivisors.lean @@ -0,0 +1,81 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceCoefficients +import OAI.NumberTheory.DirichletL.Inversion.InitialExcludedPolynomial + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily IdealMobiusDivisorSum UniqueFactorizationMonoid +open InverseInitialConjugateEnergy InverseInitialPoissonBridge +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +omit [DecidableEq ι] in +theorem tuple_product_squarefree (P:ι→Ideal O)(hP:∀i,Prime (P i)) + (hinj:Function.Injective P) : Squarefree (∏i,P i) := by + have hs:∀Q∈Finset.univ.image P,Prime Q := by + intro Q hQ + obtain ⟨i,hi,rfl⟩:=Finset.mem_image.mp hQ + exact hP i + have he:(∏Q∈Finset.univ.image P,Q)=∏i,P i := + Finset.prod_image (fun i hi j hj h=>hinj h) + rw [←he] + exact InverseInitialExcludedPolynomial.prime_product_squarefree _ hs + +omit [DecidableEq ι] in +theorem tuple_product_support (P:ι→Ideal O)(hP:∀i,Prime (P i)) + (_hinj:Function.Injective P) : primeSupport (∏i,P i)=Finset.univ.image P := by + have hn:(∏i,P i)≠0:=Finset.prod_ne_zero_iff.mpr (fun i hi=>(hP i).ne_zero) + ext Q + rw [primeSupport,Multiset.mem_toFinset,mem_normalizedFactors_iff hn,Finset.mem_image] + constructor + · rintro ⟨hQ,hd⟩ + obtain ⟨i,hi,hd⟩:=(hQ.dvd_finsetProd_iff P).mp hd + have he:Q=P i:=associated_iff_eq.mp (hQ.associated_of_dvd (hP i) hd) + exact ⟨i,hi,he.symm⟩ + · rintro ⟨i,hi,rfl⟩ + exact ⟨hP i,Finset.dvd_prod_of_mem P hi⟩ + +omit [DecidableEq ι] in +theorem tuple_divisors_eq_subsets (P:ι→Ideal O)(hP:∀i,Prime (P i)) + (hinj:Function.Injective P) : + idealDivisors (∏i,P i)=Finset.univ.powerset.image (fun J:Finset ι=>∏i∈J,P i) := by + have hs:=tuple_product_squarefree P hP hinj + have hf:(idealDivisors (∏i,P i)).filter Squarefree=idealDivisors (∏i,P i) := by + apply Finset.filter_eq_self.mpr + intro J hJ + exact hs.squarefree_of_dvd ((mem_idealDivisors hs.ne_zero).mp hJ) + rw [←hf,squarefree_divisors_eq_image _ hs.ne_zero,tuple_product_support P hP hinj, + Finset.powerset_image,Finset.image_image] + congr 1 + funext J + exact Finset.prod_image (fun i hi j hj h=>hinj h) + +omit [Fintype ι] in +theorem tuple_subset_product_injective (P:ι→Ideal O)(hP:∀i,Prime (P i)) + (hinj:Function.Injective P) : Function.Injective (fun J:Finset ι=>∏i∈J,P i) := by + let:∀i,(P i).IsMaximal:=fun i=>(Ideal.isPrime_of_prime (hP i)).isMaximal (hP i).ne_zero + exact FirstCauchyArithmetic.family_product_injective P hinj + +theorem sum_tuple_divisors (P:ι→Ideal O)(hP:∀i,Prime (P i)) + (hinj:Function.Injective P)(f:Ideal O→ℂ) : + (∑j∈idealDivisors (∏i,P i),f j)=∑J∈Finset.univ.powerset,f (∏i∈J,P i) := by + rw [tuple_divisors_eq_subsets P hP hinj,Finset.sum_image + (fun J hJ K hK he=>tuple_subset_product_injective P hP hinj he)] + +theorem originalTotal_slot_subsets (S:Finset (Ideal O)) + (P:ι→Ideal O)(hP:∀i,Prime (P i))(hinj:Function.Injective P) + (η:Ideal O→*ℂ)(a:Ideal O→ℂ)(W:ℝ→ℂ)(Z r z:ℝ)(hZ:00),sum_tuple_divisors P hP hinj] + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..bdc6885817ebad7db49489a42872bc9787458755 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceEnergy.lean @@ -0,0 +1,147 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceRemaining + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily InverseInitialConjugateEnergy InverseInitialPoissonBridge +open UniqueFactorizationMonoid CanonicalRowCompletion CanonicalQuadraticSieve +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +def assignedMass (L:ι→Finset (Ideal O))(J:Finset ι)(x:Assigned L J) + (coeff:ι→Ideal O→ℂ)(Z G:ℝ) : ℝ := + ‖∏i:↥J,coeff i.val (x i).val‖*Z^(-G) + +def assignedTerm (S:Finset (Ideal O))(L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ) + (W:ℝ→ℂ)(Z r z G:ℝ)(u:O) : ℂ := + (∏i:↥J,coeff i.val (x i).val)*(moebius (assignedIdeal L J x):ℂ)* + (Z^(-G):ℝ)*η (assignedIdeal L J x)^2*(idealRowHom u (assignedIdeal L J x))^2* + star (remainingResidual S L J x coeff η (fun _=>1) W Z r z G u) + +omit [Fintype ι] [DecidableEq ι] in +theorem assignedMass_nonneg (L:ι→Finset (Ideal O))(J:Finset ι)(x:Assigned L J) + (coeff:ι→Ideal O→ℂ)(Z G:ℝ)(hZ:0assignedTerm S L J x coeff η W Z r z G u)).trans ?_ + apply pow_le_pow_left₀ (Finset.sum_nonneg (fun _ _=>Real.sqrt_nonneg _)) + apply Finset.sum_le_sum + intro x hx + have hh:=Real.sqrt_le_sqrt (assignedTerm_energy_le S L hprime hdis J x coeff η + (hj x) (hη x) W Z r z G hZ rows w hw) + rwa [Real.sqrt_mul (sq_nonneg _),Real.sqrt_sq (assignedMass_nonneg L J x coeff Z G hZ)] at hh + +theorem original_energy_of_remaining (S:Finset (Ideal O))(L:ι→Finset (Ideal O)) + (hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ) + (hj:∀J:Finset ι,∀x:Assigned L J,Admissible (assignedIdeal L J x)) + (hη:∀J:Finset ι,∀x:Assigned L J,‖η (assignedIdeal L J x)‖≤1) + (W:ℝ→ℂ)(Z r z:ℝ)(G:Finset ι→ℝ)(hZ:01) W Z r z u‖^2)≤ + (∑J∈Finset.univ.powerset,∑x:Assigned L J,assignedMass L J x coeff Z (G J))^2*E := by + have heq (u:O) : + (∑q:Tuple L,(∏i,coeff i (q i).val)* + originalTotalPolynomial S (∏i,(q i).val) η (fun _=>1) W Z r z u)= + ∑J∈Finset.univ.powerset,∑x:Assigned L J, + assignedTerm S L J x coeff η W Z r z (G J) u := + original_selected_overlap S L hprime hdis coeff η (fun _=>1) W Z r z G hZ u + simp_rw [heq] + have hroot (J:Finset ι) : + Real.sqrt (∑u∈rows,w u*‖∑x:Assigned L J, + assignedTerm S L J x coeff η W Z r z (G J) u‖^2)≤ + (∑x:Assigned L J,assignedMass L J x coeff Z (G J))*Real.sqrt E := by + have hm:0≤∑x:Assigned L J,assignedMass L J x coeff Z (G J) := + Finset.sum_nonneg (fun x _=>assignedMass_nonneg L J x coeff Z (G J) hZ) + have hb:=assigned_family_energy S L hprime hdis J coeff η (hj J) (hη J) + W Z r z (G J) hZ rows w hw + have hc : (∑x:Assigned L J,assignedMass L J x coeff Z (G J)* + Real.sqrt (∑u∈rows,w u*‖remainingPolynomial S L J x coeff η W Z r z (G J) u‖^2))≤ + (∑x:Assigned L J,assignedMass L J x coeff Z (G J))*Real.sqrt E := by + rw [Finset.sum_mul] + apply Finset.sum_le_sum + intro x hx + exact mul_le_mul_of_nonneg_left (Real.sqrt_le_sqrt (hres J x)) + (assignedMass_nonneg L J x coeff Z (G J) hZ) + have hn : 0≤∑x:Assigned L J,assignedMass L J x coeff Z (G J)* + Real.sqrt (∑u∈rows,w u*‖remainingPolynomial S L J x coeff η W Z r z (G J) u‖^2) := + Finset.sum_nonneg (fun x _=>mul_nonneg (assignedMass_nonneg L J x coeff Z (G J) hZ) (Real.sqrt_nonneg _)) + have hh:=Real.sqrt_le_sqrt (hb.trans (pow_le_pow_left₀ hn hc 2)) + rwa [Real.sqrt_sq (mul_nonneg hm (Real.sqrt_nonneg E))] at hh + refine (finite_weighted_triangle Finset.univ.powerset rows w hw + (fun J u=>∑x:Assigned L J,assignedTerm S L J x coeff η W Z r z (G J) u)).trans ?_ + calc + _≤(∑J∈Finset.univ.powerset, + (∑x:Assigned L J,assignedMass L J x coeff Z (G J))*Real.sqrt E)^2 := by + apply pow_le_pow_left₀ (Finset.sum_nonneg (fun _ _=>Real.sqrt_nonneg _)) + exact Finset.sum_le_sum (fun J _=>hroot J) + _=_:=by rw [←Finset.sum_mul,mul_pow,Real.sq_sqrt hE] + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceFiber.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceFiber.lean new file mode 100644 index 0000000000000000000000000000000000000000..9b2f1039360af1186be5c99dc1ec8a7059e71205 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceFiber.lean @@ -0,0 +1,134 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceEnergy + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeDyadic HeckeInverseAmplification HeckeDetectorRawFiber +open InverseInitialRawDictionary InverseInitialDetectorSource InverseInitialPhysicalSlots +open DetectorDictionaryInverseMarkedPadding HeckeDetectorCoefficientTransfer +open InverseInitialConjugateEnergy +local notation "O"=>HeckeFamily.O +variable {M:Ideal O}[NeZero M]{H:Subgroup (O⧸M)ˣ}{Label Slot:Type*} + {U a ε tstar T allowance:ℝ}{i:ℕ} + +def fiberLists (F:Fiber M H Label Slot U a ε tstar T allowance i)(selected:Finset Slot) + (s:selected) : Finset (Ideal O) := + livePrimes M H (F.profile s) (F.upper s) (U^(F.widths s)) + +def fiberCoefficient (F:Fiber M H Label Slot U a ε tstar T allowance i)(s:Slot) + (P:Ideal O) : ℂ := slotCoefficient F.rowData (F.profile s) (U^(F.widths s)) (F.external s) P + +omit [NeZero M] in +theorem fiberLists_prime (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(s:selected)(P:Ideal O)(hP:P∈fiberLists F selected s) : Prime P := by + exact (Finset.mem_filter.mp (Finset.mem_filter.mp hP).1).2.1 + +omit [NeZero M] in +theorem fiberLists_disjoint (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(lower:Slot→ℝ)(hU:0hst (Subtype.ext he)) with h|h <;> + linarith [hp.2.2.1,hp.2.2.2,hq.2.2.1,hq.2.2.2] + +omit [NeZero M] in +theorem selectedSource_tuple (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(W:ℝ→ℂ)(σ t bW:ℝ)(u:O) : + selectedSource F selected W σ t bW u= + ∑q:Tuple (fiberLists F selected),(∏s:selected,fiberCoefficient F s (q s).val)* + originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*bW⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,(q s).val) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (orientedProfile F.reverse W) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u := by + rw [sum_tuple_original (fiberLists F selected) (fun q=> + (∏s:selected,fiberCoefficient F s (q s))*originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*bW⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,q s) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (orientedProfile F.reverse W) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u)] + unfold selectedSource + apply Finset.sum_congr rfl + intro q hq + rw [tuple_coefficient] + rfl + +omit [NeZero M] in +theorem selectedSource_overlap (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(W:ℝ→ℂ)(σ t bW:ℝ)(hU:0fiberCoefficient F s) + (fixedBase F.rowData.η F.rowData.m F.rowData.f) + (twistedProfile (orientedProfile F.reverse W) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) (∑s∈J,F.widths s) u := by + rw [selectedSource_tuple] + exact original_selected_overlap _ (fiberLists F selected) (fiberLists_prime F selected) + hdis (fun s=>fiberCoefficient F s) _ (fun _=>1) _ U F.r _ + (fun J=>∑s∈J,F.widths s) hU u + +omit [NeZero M] in +theorem fiberAssigned_admissible (F:Fiber M H Label Slot U a ε tstar T allowance i) + (selected:Finset Slot)(lower:Slot→ℝ)(hU:0(x s).val) := by + intro s t he + apply Subtype.ext + by_contra hst + exact Finset.disjoint_left.mp (hdis (Finset.mem_univ s.val) (Finset.mem_univ t.val) hst) + (x s).property (by simpa only [he] using (x t).property) + have hs (s:↥J):CanonicalQuadraticSieve.Supported (x s).val := by + by_contra hn + have hd:=livePrime_data M H (F.profile s.val) (lower s.val) (F.upper s.val) + (U^(F.widths s.val)) (Real.rpow_pos_of_pos hU _) (hV s.val s.val.property) + (x s).val (x s).property + exact base_nonzero_prime F.rowData (x s).val (hp s) + ((hlarge s.val s.val.property).trans_le hd.2.2.1) + (fixedBase_zero_unsupported F.rowData.η F.rowData.m F.rowData.f + F.rowData.lambda_dvd F.rowData.two_dvd (x s).val hn) + have hprod (T:Finset ↥J):CanonicalQuadraticSieve.Supported (∏s∈T,(x s).val) := by + induction T using Finset.induction_on with + | empty => + simp only [Finset.prod_empty] + exact ⟨one_ne_zero,by intro P hP;simp only [UniqueFactorizationMonoid.normalizedFactors_one,Multiset.notMem_zero] at hP⟩ + | @insert s T hsT ih => + rw [Finset.prod_insert hsT] + exact (CanonicalQuadraticSieve.supported_mul_iff _ _).mpr ⟨hs s,ih⟩ + exact ⟨(hprod Finset.univ).1,tuple_product_squarefree _ hp hinj,(hprod Finset.univ).2⟩ + +omit [NeZero M] in +theorem fiberBase_norm (F:Fiber M H Label Slot U a ε tstar T allowance i)(P:Ideal O) : + ‖fixedBase F.rowData.η F.rowData.m F.rowData.f P‖≤1 := by + rw [←baseCharacter_coeff] + exact idealCoeff_norm_le_one _ _ + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceFiberEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceFiberEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..302abc607ad5cdc46f9c69b9ba7273ba791f3949 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceFiberEnergy.lean @@ -0,0 +1,132 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceDeletedEnergy +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedPhysicalRows + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap ContDiff +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeInverseAmplification HeckeDyadic HeckeDetectorRawFiber +open HeckeDetectorCoefficientTransfer InverseMoment InverseInitialProfile +open ConcreteTraceCRT ConcretePrimeRowBridge CanonicalRowCompletion +open DetectorDictionaryInverseRawInitialGates DetectorDictionaryInverseMarkedPhysicalRows +open InverseInitialPhysicalSlots IdealMobiusDivisorSum +local notation "O"=>HeckeFamily.O + +theorem fiber_reference_energy {Δ:ℝ}{D:Parameters.HighData Δ} + (S:ProbeFinalAssembly.SourceData D) + (W:ℝ→ℂ)(ao bo:ℝ)(hao:0deleted_source_energy S (orientedProfile b W) ao bo hao hab + (hsor b) (hWor b) εm hεm K + refine ⟨∑b:Bool,J b,?_⟩ + intro data + choose C U₀ hC hU₀ hb using fun b:Bool=>hj b data + let Tbad:=idealDivisors (∏P∈excluded data,P) + let Ctotal:ℝ:=((Tbad.card:ℝ)+1)^2*(∑b:Bool,C b) + have hCsum:0<∑b:Bool,C b:=Finset.sum_pos (fun b _=>hC b) Finset.univ_nonempty + refine ⟨Ctotal,max (U₀ false) (U₀ true),by dsimp [Ctotal];positivity, + lt_max_of_lt_left (hU₀ false),?_⟩ + intro U hU M neM H Label Slot a ε tstar T allowance i F selected hdata hK hprofile hupper + hell hext hdis hlarge hr hfirst hsecond v + have hUb (b:Bool):U₀ b≤U:=by cases b <;> exact le_trans (by simp) hU + have hUone:1F.profile s)=(fun _=>(S.W:ℝ→ℂ)):=funext hpr + have hups:(fun s:selected=>F.upper s)=(fun _=>2):=funext hup + have hslots:∀s∈selected,∀x,F.profile s x≠0 → x∈Set.Icc (1:ℝ) (F.upper s) := by + intro s hs x hx + rw [hprofile s hs] at hx + rw [hupper s hs] + exact S.complex_support hx + have hlarge':∀s∈selected,((deletedBase F.rowData).modulus.absNorm:ℝ)<1*U^(F.widths s):=by + simpa only [hdata,one_mul] using hlarge + have hphys:=fiber_child_rows_le_deleted_sources F selected W v bo (fun _=>1) hUone + (fun x hx=>(hsW hx).2) hslots hlarge' + rw [hdata] at hphys + let rows:Finset O:=F.rows.image (fun u=>u.val) + have hsum (f:O→ℝ):(∑u∈rows,f u)=∑u∈F.rows,f u.val:= + Finset.sum_image (fun u _ w _ he=>Subtype.ext he) + have hrows:∀u∈rows,‖eisEmbedding u‖^2≤U := by + intro u hu + obtain ⟨w,hw,rfl⟩:=Finset.mem_image.mp hu + rw [ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span] + exact F.row_norm w hw + have hpow (b:Bool):((1+‖orientedFrequency b v‖)^(J b))^2≤ + ((1+‖v‖)^(∑b:Bool,J b))^2 := by + have hn:‖orientedFrequency b v‖=‖v‖:=by cases b <;> simp [orientedFrequency] + rw [hn] + apply pow_le_pow_left₀ (by positivity) + apply pow_le_pow_right₀ (by linarith [norm_nonneg v]) + exact Finset.single_le_sum (fun b _=>Nat.zero_le _) (Finset.mem_univ b) + have hterm (j:Ideal O)(hj:j∈Tbad): + (∑u∈F.rows,‖deletedSelectedSource data M H + (childLogTest (orientedProfile F.reverse W) (orientedFrequency F.reverse v)) + (fun s:selected=>F.profile s) U (shiftedExponent data U F.r j) + 0 0 bo (fun s:selected=>F.upper s) (fun s:selected=>F.widths s) + (fun s:selected=>F.external s) u.val‖^2)≤ + (∑b:Bool,C b)*U^(1+εm)*((1+‖v‖)^(∑b:Bool,J b))^2 := by + rw [hprof,hups] + have hdis':((Finset.univ:Finset selected):Set selected).PairwiseDisjoint + (fun s:selected=>livePrimes M H S.W 2 (U^(F.widths s))) := by + have heL:fiberLists F selected=(fun s:selected=>livePrimes M H S.W 2 (U^(F.widths s))) := by + funext s + dsimp only [fiberLists] + rw [hpr s,hup s] + rwa [heL] at hdis + have hh:=hb F.reverse U (hUb F.reverse) (by simpa using hK) + M H (fun s:selected=>F.widths s) (fun s:selected=>F.external s) + (fun s=>hell s s.property) (fun s=>hext s s.property) hdis' + (fun s=>hlarge s s.property) F.r hr + (by simpa only [Finset.sum_coe_sort] using hfirst) + (by simpa only [Finset.sum_coe_sort] using hsecond) j hj rows hrows (orientedFrequency F.reverse v) + rw [hsum] at hh + refine hh.trans ?_ + apply mul_le_mul _ (hpow F.reverse) (by positivity) (by positivity) + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg (by linarith) _) + exact Finset.single_le_sum (fun b _=>(hC b).le) (Finset.mem_univ F.reverse) + refine hphys.trans ?_ + change (Tbad.card:ℝ)*(∑j∈Tbad,_)≤_ + calc + _≤(Tbad.card:ℝ)*(∑j∈Tbad,(∑b:Bool,C b)*U^(1+εm)* + ((1+‖v‖)^(∑b:Bool,J b))^2):= + mul_le_mul_of_nonneg_left (Finset.sum_le_sum hterm) (by positivity) + _=(Tbad.card:ℝ)^2*(∑b:Bool,C b)*U^(1+εm)*((1+‖v‖)^(∑b:Bool,J b))^2:=by + simp only [Finset.sum_const,nsmul_eq_mul];ring + _≤Ctotal*U^(1+εm)*((1+‖v‖)^(∑b:Bool,J b))^2:=by + dsimp [Ctotal] + gcongr + nlinarith [show 0≤(Tbad.card:ℝ) by positivity] + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceMass.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceMass.lean new file mode 100644 index 0000000000000000000000000000000000000000..5b0dfdb5373973466ce481392e8bca12df239d2e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceMass.lean @@ -0,0 +1,93 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceEnergy +import OAI.NumberTheory.DirichletL.Dictionary.InverseAssignedCount + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily DetectorDictionaryInverseAssignedCount +local notation "O"=>HeckeFamily.O + +private theorem sum_tuple_real {ι:Type*}[Fintype ι](L:ι→Finset (Ideal O)) + (f:(ι→Ideal O)→ℝ) : + (∑q:Tuple L,f (fun i=>(q i).val))=∑q∈assignedTuples L,f q := by + symm + apply Finset.sum_bij (fun q hq i=>⟨q i,(mem_assignedTuples L q).mp hq i⟩) + · intro q hq + exact Finset.mem_univ _ + · intro q hq r hr he + funext i + exact congrArg Subtype.val (congrFun he i) + · intro q hq + refine ⟨fun i=>(q i).val,(mem_assignedTuples L _).mpr (fun i=>(q i).property),?_⟩ + funext i + rfl + · intro q hq + rfl + +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +omit [Fintype ι] in +theorem assignedMass_sum_le (K:ℕ){b U:ℝ}(hb:1≤b)(hU:1≤U) + (L:ι→Finset (Ideal O))(J:Finset ι)(hJ:J.card≤K)(ell:ι→ℝ) + (hL:∀i∈J,∀P∈L i,P≠0 ∧ (P.absNorm:ℝ)≤b*U^(ell i)) + (coeff:ι→Ideal O→ℂ)(hc:∀i∈J,∀P∈L i,‖coeff i P‖≤1) : + (∑x:Assigned L J,assignedMass L J x coeff U (∑i∈J,ell i))≤assignedConstant K b := by + have he:=assigned_sum_normalized_le K hb hU (by simpa using hJ) + (fun i:↥J=>ell i) (fun i:↥J=>L i) + (fun i P hP=>hL i i.property P hP) + (fun i:↥J=>coeff i) (fun i P hP=>hc i i.property P hP) + rw [←sum_tuple_real] at he + simp only [assignedMass,assignedCoefficient,Finset.sum_coe_sort] at he ⊢ + convert he using 1 + congr 1 + ext x + simp + +theorem all_assignedMass_sum_le (K:ℕ){b U:ℝ}(hb:1≤b)(hU:1≤U) + (hK:Fintype.card ι≤K)(L:ι→Finset (Ideal O))(ell:ι→ℝ) + (hL:∀i,∀P∈L i,P≠0 ∧ (P.absNorm:ℝ)≤b*U^(ell i)) + (coeff:ι→Ideal O→ℂ)(hc:∀i,∀P∈L i,‖coeff i P‖≤1) : + (∑J∈Finset.univ.powerset,∑x:Assigned L J,assignedMass L J x coeff U (∑i∈J,ell i))≤ + (2:ℝ)^K*assignedConstant K b := by + calc + _≤∑J∈(Finset.univ:Finset ι).powerset,assignedConstant K b := by + apply Finset.sum_le_sum + intro J hJ + exact assignedMass_sum_le K hb hU L J ((Finset.card_le_univ J).trans hK) ell + (fun i _=>hL i) coeff (fun i _=>hc i) + _=(2:ℝ)^Fintype.card ι*assignedConstant K b := by + simp + _≤_:=mul_le_mul_of_nonneg_right (pow_le_pow_right₀ (by norm_num) hK) + (assignedConstant_pos K hb).le + +theorem original_energy_with_assigned_count (K:ℕ){b U:ℝ}(hb:1≤b)(hU:1≤U) + (hK:Fintype.card ι≤K)(S:Finset (Ideal O))(L:ι→Finset (Ideal O)) + (hp:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L)(ell:ι→ℝ) + (hL:∀i,∀P∈L i,P≠0 ∧ (P.absNorm:ℝ)≤b*U^(ell i)) + (coeff:ι→Ideal O→ℂ)(hc:∀i,∀P∈L i,‖coeff i P‖≤1)(η:Ideal O→*ℂ) + (hj:∀J:Finset ι,∀x:Assigned L J,CanonicalQuadraticSieve.Admissible (assignedIdeal L J x)) + (hη:∀J:Finset ι,∀x:Assigned L J,‖η (assignedIdeal L J x)‖≤1) + (W:ℝ→ℂ)(r z:ℝ)(rows:Finset O)(w:O→ℝ)(hw:∀u,0≤w u)(E:ℝ)(hE:0≤E) + (hres:∀J:Finset ι,∀x:Assigned L J, + (∑u∈rows,w u*‖remainingPolynomial S L J x coeff η W U r z (∑i∈J,ell i) u‖^2)≤E) : + (∑u∈rows,w u*‖∑q:Tuple L,(∏i,coeff i (q i).val)* + InverseInitialConjugateEnergy.originalTotalPolynomial S (∏i,(q i).val) η (fun _=>1) W U r z u‖^2)≤ + ((2:ℝ)^K*assignedConstant K b)^2*E := by + have hU0:0∑i∈J,ell i) hU0 rows w hw E hE hres).trans ?_ + apply mul_le_mul_of_nonneg_right _ hE + apply pow_le_pow_left₀ + (Finset.sum_nonneg (fun J _=>Finset.sum_nonneg + (fun x _=>assignedMass_nonneg L J x coeff U (∑i∈J,ell i) hU0))) + exact all_assignedMass_sum_le K hb hU hK L ell hL coeff hc + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceOverlap.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceOverlap.lean new file mode 100644 index 0000000000000000000000000000000000000000..c422e80435c747478900f4906e211e74f239e042 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceOverlap.lean @@ -0,0 +1,74 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceProducts + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily InverseInitialConjugateEnergy InverseInitialPoissonBridge +open InverseInitialOverlap UniqueFactorizationMonoid ActualEisensteinCubic CanonicalRowCompletion +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +def remainingResidual (S:Finset (Ideal O))(L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ)(a:Ideal O→ℂ) + (W:ℝ→ℂ)(Z r z G:ℝ)(u:O) : ℂ := + ∑y:Remaining L J,star ((∏i:{i:ι // i∉J},coeff i.val (y i).val)* + (moebius (remainingIdeal L J y):ℂ))* + conjugatedResidual S (assignedIdeal L J x*remainingIdeal L J y) + (assignedIdeal L J x) η a W Z r z G u + +theorem assigned_remaining_squarefree (L:ι→Finset (Ideal O)) + (hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(x:Assigned L J)(y:Remaining L J) : + Squarefree (assignedIdeal L J x*remainingIdeal L J y) := by + rw [←joinTuple_product] + exact tuple_product_squarefree _ (fun i=>hprime i _ (joinTuple L J x y i).property) + (tuple_injective L hdis _) + +theorem assigned_source_eq_remainingResidual (S:Finset (Ideal O)) + (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(x:Assigned L J)(coeff:ι→Ideal O→ℂ) + (η:Ideal O→*ℂ)(a:Ideal O→ℂ)(W:ℝ→ℂ)(Z r z G:ℝ)(hZ:0HeckeFamily.O + +theorem padded_source_energy + (W:ℝ → ℂ)(ao bo:ℝ)(hao:01) + (childLogTest W θ) U rr (∑i,ell i) u‖^2)≤ + C*U^(1+εm)*((1+‖θ‖)^degree)^2 := by + obtain ⟨ρ,gap,eta,τ,π,eps,loss,hρ,hρmax,hρε,hgap,hgapρ,heta,hetamax,hetagap, + hτ,hτgap,hπ,heps,hloss,hcost⟩:=InverseInitialMarkedReserve.exists_reserve εm hεm + obtain ⟨degree,henergy⟩:=original_source_energy W ao bo hao hab hsW hW + gap eps π eta τ loss hgap heps hπ heta (by linarith) hetagap hτ hτgap hloss K + have hev:∀ᶠU:ℝ in atTop,(2:ℝ)^K≤U^eta:= + (tendsto_rpow_atTop heta).eventually (eventually_ge_atTop _) + obtain ⟨Uscale,hscale⟩:=eventually_atTop.mp hev + refine ⟨eta,heta,degree,?_⟩ + intro q hq + obtain ⟨C,U₀,hC,hU₀,henergy⟩:=henergy q hq + refine ⟨C,max U₀ Uscale,hC,lt_max_of_lt_left hU₀,?_⟩ + intro U hU ι inst dec hK L ell coeff hell hp hs hdis hratio hc hout primeW hprimeW hlive + χ hχ hperiod hzero r rr hr hrlo hrhi hfirst hsecond rows hrows θ + have hU0:U₀≤U:=(le_max_left _ _).trans hU + have hUone:1hell i) + have hG (J:Finset ι):0≤∑i∈J,ell i:=Finset.sum_nonneg (fun i _=>hell i) + have hGmax (J:Finset ι):(∑i∈J,ell i)≤∑i,ell i:= + Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (fun i _ _=>hell i) + have hcap (J:Finset ι): + 0≤1+ρ ∧ 1+ρ≤2 ∧ -2≤rr+(∑i,ell i)-2*(∑i∈J,ell i) ∧ + rr+2*(∑i,ell i)≤1+ρ-2*gap ∧ + 2*rr+8*(∑i,ell i)≤3*(1+ρ)-2*gap ∧ rr+(∑i,ell i)+7*eta≤2 := + InverseInitialMarkedReserve.shifted_capacity ρ gap eta r rr _ _ hρ hρmax hgapρ + heta hetamax hr hs0 (hG J) (hGmax J) hrlo hrhi hfirst hsecond + have hbase:=hcap ∅ + have hrows':∀u∈rows,‖eisEmbedding u‖^2≤U^(1+ρ) := by + intro u hu + refine (hrows u hu).trans ?_ + calc U=U^(1:ℝ):=(Real.rpow_one U).symm + _≤U^(1+ρ):=Real.rpow_le_rpow_of_exponent_le hUone.le (by linarith) + have hh:=henergy U hU0 (hscale U ((le_max_right _ _).trans hU)) hK L ell coeff hell hp hs + hdis hratio hc hout primeW hprimeW hlive χ hχ hperiod hzero (1+ρ) rr + hbase.1 hbase.2.1 (fun J=>(hcap J).2.2.1) hbase.2.2.2.1 hbase.2.2.2.2.1 + hbase.2.2.2.2.2 rows hrows' θ + refine hh.trans ?_ + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + apply mul_le_mul_of_nonneg_left _ hC.le + apply Real.rpow_le_rpow_of_exponent_le hUone.le + linarith + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferencePrimeGates.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferencePrimeGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..2cdbe29cd0e1fe4484ae2130a0a759cf84b2cc6d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferencePrimeGates.lean @@ -0,0 +1,64 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceDeleted +import OAI.NumberTheory.DirichletL.Detector.DetectorMomentPrimeGeometry + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators Topology +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeInverseAmplification InverseInitialDetectorSource +open InverseInitialRawDictionary InverseInitialPhysicalSlots +open DetectorDictionaryInverseRawInitialGates InverseInitialExcludedPeriod +open InverseInitialExcludedPool InverseInitialExcludedOverlap Filter CanonicalQuadraticSieve CanonicalRowCompletion +local notation "O"=>HeckeFamily.O + +theorem deleted_large_eventually {Label Slot:Type*}[Fintype Label][Fintype Slot] + (data:Label→RowData)(ell:Slot→ℝ)(hell:∀s,0HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +def assignedIdeal (L:ι→Finset (Ideal O))(J:Finset ι)(x:Assigned L J) : Ideal O := + ∏i:↥J,(x i).val + +def remainingIdeal (L:ι→Finset (Ideal O))(J:Finset ι)(y:Remaining L J) : Ideal O := + ∏i:{i:ι // i∉J},(y i).val + +omit [Fintype ι] in +@[simp] theorem joinTuple_assigned (L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(y:Remaining L J)(i:↥J) : joinTuple L J x y i.val=x i := by + simp [joinTuple,Equiv.piEquivPiSubtypeProd_symm_apply,i.property] + +omit [Fintype ι] in +@[simp] theorem joinTuple_remaining (L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(y:Remaining L J)(i:{i:ι // i∉J}) : joinTuple L J x y i.val=y i := by + simp [joinTuple,Equiv.piEquivPiSubtypeProd_symm_apply,i.property] + +omit [Fintype ι] in +theorem joinTuple_assigned_product (L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(y:Remaining L J) : + (∏i∈J,(joinTuple L J x y i).val)=assignedIdeal L J x := by + rw [←Finset.prod_coe_sort J (fun i=>(joinTuple L J x y i).val)] + simp only [joinTuple_assigned,assignedIdeal] + +theorem joinTuple_product (L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(y:Remaining L J) : + (∏i,(joinTuple L J x y i).val)=assignedIdeal L J x*remainingIdeal L J y := by + have he := (Fintype.prod_subtype_mul_prod_subtype (fun i=>i∈J) + (fun i=>(joinTuple L J x y i).val)).symm + simp only [joinTuple_assigned,joinTuple_remaining] at he + convert he using 1 + try simp only [assignedIdeal,remainingIdeal] + congr 2 + ext i + simp + +theorem joinTuple_coefficient_product (L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(y:Remaining L J)(coeff:ι→Ideal O→ℂ) : + (∏i,coeff i (joinTuple L J x y i).val)= + (∏i:↥J,coeff i.val (x i).val)*(∏i:{i:ι // i∉J},coeff i.val (y i).val) := by + have he := (Fintype.prod_subtype_mul_prod_subtype (fun i=>i∈J) + (fun i=>coeff i (joinTuple L J x y i).val)).symm + simp only [joinTuple_assigned,joinTuple_remaining] at he + convert he using 1 + try simp only [assignedIdeal,remainingIdeal] + congr 2 + ext i + simp + +omit [Fintype ι] [DecidableEq ι] in +theorem assignedIdeal_ne_zero (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (J:Finset ι)(x:Assigned L J) : assignedIdeal L J x≠0 := + Finset.prod_ne_zero_iff.mpr (fun i _hi=>(hprime i.val _ (x i).property).ne_zero) + +theorem residual_join (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (J:Finset ι)(x:Assigned L J)(y:Remaining L J) : + residual (∏i,(joinTuple L J x y i).val) (assignedIdeal L J x)=remainingIdeal L J y := by + rw [joinTuple_product,InverseInitialOverlap.residual,quotient_mul_cancel (assignedIdeal_ne_zero L hprime J x)] + +theorem original_selected_grouped_products (S:Finset (Ideal O)) + (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L)(coeff:ι→Ideal O→ℂ) + (η:Ideal O→*ℂ)(a:Ideal O→ℂ)(W:ℝ→ℂ)(Z r z:ℝ)(hZ:0HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +def remainingIndexEquiv (J:Finset ι) : {i:ι // i∉J} ≃ ↥(Finset.univ\J) where + toFun i:=⟨i.val,Finset.mem_sdiff.mpr ⟨Finset.mem_univ _,i.property⟩⟩ + invFun i:=⟨i.val,(Finset.mem_sdiff.mp i.property).2⟩ + left_inv _:=rfl + right_inv _:=rfl + +theorem remaining_product_attach {A:Type*}[CommMonoid A] + (J:Finset ι)(f:{i:ι // i∉J}→A) : + (∏i,f i)=∏i∈(Finset.univ\J).attach,f ⟨i.val,(Finset.mem_sdiff.mp i.property).2⟩ := by + exact ((remainingIndexEquiv J).symm.prod_comp f).symm + +def remainingPi (L:ι→Finset (Ideal O))(J:Finset ι)(q:Remaining L J) : + ∀i∈Finset.univ\J,Ideal O := fun i hi=>(q ⟨i,(Finset.mem_sdiff.mp hi).2⟩).val + +theorem sum_remaining_original (L:ι→Finset (Ideal O))(J:Finset ι) + (f:(∀i∈Finset.univ\J,Ideal O)→ℂ) : + (∑q:Remaining L J,f (remainingPi L J q))=∑q∈(Finset.univ\J).pi L,f q := by + symm + apply Finset.sum_bij (fun q hq i=>⟨q i.val (Finset.mem_sdiff.mpr ⟨Finset.mem_univ _,i.property⟩), + Finset.mem_pi.mp hq i.val (Finset.mem_sdiff.mpr ⟨Finset.mem_univ _,i.property⟩)⟩) + · intro q hq + exact Finset.mem_univ _ + · intro q hq r hr he + funext i hi + exact congrArg Subtype.val (congrFun he ⟨i,(Finset.mem_sdiff.mp hi).2⟩) + · intro q hq + refine ⟨remainingPi L J q,Finset.mem_pi.mpr (fun i hi=>(q ⟨i,(Finset.mem_sdiff.mp hi).2⟩).property),?_⟩ + funext i + rfl + · intro q hq + rfl + +theorem remainingPolynomial_original_pi (S:Finset (Ideal O))(L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ) + (W:ℝ→ℂ)(Z r z G:ℝ)(u:O) : + remainingPolynomial S L J x coeff η W Z r z G u= + ∑q∈(Finset.univ\J).pi L,(∏i∈(Finset.univ\J).attach,star (coeff i.val (q i.val i.property)))* + residualNormalizedPolynomial S (assignedIdeal L J x*survivingProduct (Finset.univ\J) q) + (assignedIdeal L J x) (conjugateIdealCharacter η) (fun _=>1) + (fun v=>star (W v)) Z r z G u := by + rw [←sum_remaining_original] + unfold remainingPolynomial + apply Finset.sum_congr rfl + intro q hq + unfold remainingIdeal survivingProduct remainingPi + rw [remaining_product_attach J (fun i=>star (coeff i.val (q i).val)), + remaining_product_attach J (fun i=>(q i).val)] + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceRemaining.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceRemaining.lean new file mode 100644 index 0000000000000000000000000000000000000000..b0b2c4303fa6c475dcbb970419ef3927612515a8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceRemaining.lean @@ -0,0 +1,102 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceOverlap +import OAI.NumberTheory.DirichletL.Inversion.InitialExcludedFourier + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily InverseInitialConjugateEnergy InverseInitialPoissonBridge +open InverseInitialOverlap UniqueFactorizationMonoid ActualEisensteinCubic +open InverseInitialCommonRatios +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +theorem remaining_injective (L:ι→Finset (Ideal O)) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(y:Remaining L J) : Function.Injective (fun i=>(y i).val) := by + intro i j he + apply Subtype.ext + by_contra hij + exact Finset.disjoint_left.mp (hdis (Finset.mem_univ i.val) (Finset.mem_univ j.val) hij) + (y i).property (by simpa only [he] using (y j).property) + +theorem remaining_moebius (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(y:Remaining L J) : + (moebius (remainingIdeal L J y):ℂ)=(-1:ℂ)^Fintype.card {i:ι // i∉J} := by + let:∀i:{i:ι // i∉J},((y i).val).IsMaximal:=fun i=> + (Ideal.isPrime_of_prime (hprime i.val _ (y i).property)).isMaximal + (hprime i.val _ (y i).property).ne_zero + simpa only [remainingIdeal,Finset.card_univ] using prime_product_moebius + (fun i=>(y i).val) (fun i=>hprime i.val _ (y i).property) + (remaining_injective L hdis J y) Finset.univ + +def remainingPolynomial (S:Finset (Ideal O))(L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ) + (W:ℝ→ℂ)(Z r z G:ℝ)(u:O) : ℂ := + ∑y:Remaining L J,(∏i:{i:ι // i∉J},star (coeff i.val (y i).val))* + residualNormalizedPolynomial S (assignedIdeal L J x*remainingIdeal L J y) + (assignedIdeal L J x) (conjugateIdealCharacter η) (fun _=>1) + (fun v=>star (W v)) Z r z G u + +theorem remainingResidual_eq_polynomial (S:Finset (Ideal O)) + (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(x:Assigned L J)(coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ) + (W:ℝ→ℂ)(Z r z G:ℝ)(u:O) : + remainingResidual S L J x coeff η (fun _=>1) W Z r z G u= + (-1:ℂ)^Fintype.card {i:ι // i∉J}* + remainingPolynomial S L J x coeff η W Z r z G u := by + unfold remainingResidual remainingPolynomial + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro y hy + rw [remaining_moebius L hprime hdis] + simp only [star_mul,star_prod,star_pow,star_neg,star_one,conjugatedResidual] + ring + +theorem sum_tuple_pi (L:ι→Finset (Ideal O)) + (f:(∀i∈(Finset.univ:Finset ι),Ideal O)→ℂ) : + (∑q:Tuple L,f (fun i _=>(q i).val))= + ∑q∈(Finset.univ:Finset ι).pi L,f q := by + symm + apply Finset.sum_bij (fun q hq i=>⟨q i (Finset.mem_univ i), + Finset.mem_pi.mp hq i (Finset.mem_univ i)⟩) + · intro q hq + exact Finset.mem_univ _ + · intro q hq r hr he + funext i hi + exact congrArg Subtype.val (congrFun he i) + · intro q hq + refine ⟨fun i _=>(q i).val,Finset.mem_pi.mpr (fun i hi=>(q i).property),?_⟩ + funext i + rfl + · intro q hq + rfl + +theorem remainingPolynomial_pi (S:Finset (Ideal O))(L:ι→Finset (Ideal O))(J:Finset ι) + (x:Assigned L J)(coeff:ι→Ideal O→ℂ)(η:Ideal O→*ℂ) + (W:ℝ→ℂ)(Z r z G:ℝ)(u:O) : + remainingPolynomial S L J x coeff η W Z r z G u= + ∑q∈(Finset.univ:Finset {i:ι // i∉J}).pi (fun i=>L i.val), + (∏i∈(Finset.univ:Finset {i:ι // i∉J}).attach, + star (coeff i.val.val (q i.val i.property)))* + residualNormalizedPolynomial S + (assignedIdeal L J x*survivingProduct Finset.univ q) + (assignedIdeal L J x) (conjugateIdealCharacter η) (fun _=>1) + (fun v=>star (W v)) Z r z G u := by + rw [←sum_tuple_pi] + unfold remainingPolynomial + apply Finset.sum_congr rfl + intro q hq + simp only [survivingProduct,remainingIdeal] + rw [Finset.prod_attach _ (fun i=>star (coeff i.val (q i).val)), + Finset.prod_attach _ (fun i=>(q i).val)] + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceShift.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceShift.lean new file mode 100644 index 0000000000000000000000000000000000000000..8940e0f2bf53566301bee4928b742c5ea9699464 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceShift.lean @@ -0,0 +1,59 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawInitialGates +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedPadding + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators Topology +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily HeckeInverseAmplification Filter IdealMobiusDivisorSum +open DetectorDictionaryInverseRawInitialGates +local notation "O"=>HeckeFamily.O + +def shiftedExponent (_data:RowData)(U r:ℝ)(j:Ideal O) : ℝ := + r-Real.logb U (j.absNorm:ℝ) + +theorem marked_shift_eventually (data:RowData)(eta:ℝ)(heta:0 linarith + +theorem shifted_source_box (r r' ell G eta:ℝ)(hr:0≤r)(hell:0≤ell) + (_hG:0≤G)(hGell:G≤ell)(hshift:r-eta≤r')(hshiftup:r'≤r) + (hfirst:r+2*ell<1)(_heta:0≤eta)(hetaSmall:eta≤1/7) : + -2≤r'+ell-2*G ∧ r'+ell+7*eta≤2 := by + constructor <;> linarith + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceSourceEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceSourceEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..d17023bebdd521b84126c6656d7f0d0e9fe85ea6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceSourceEnergy.lean @@ -0,0 +1,139 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceMass +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceArithmetic +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawConjugateGates +import OAI.NumberTheory.DirichletL.Inversion.InitialResidualUniformEnergy +import OAI.NumberTheory.DirichletL.Inversion.InitialMarkedAssignedGeometry +import OAI.NumberTheory.DirichletL.Inversion.InitialMarkedReserve +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedPadding + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap ContDiff +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily CanonicalQuadraticSieve CanonicalRowCompletion ConcretePrimeRowBridge +open CanonicalCoefficientClass ConcreteTraceCRT InverseInitialRayAttachment InverseMoment InverseInitialProfile +open InverseInitialOverlapFourier InverseInitialConjugateEnergy InverseInitialQuotientGeometry +open InverseInitialEnergyCallerWindow InverseInitialPoissonBridge InverseInitialPhysicalMeasure +open InverseInitialMarkedAssignedGeometry DetectorDictionaryInverseRawConjugateGates +local notation "O"=>HeckeFamily.O + +private theorem assigned_admissible {ι:Type}[Fintype ι][DecidableEq ι] + (L:ι→Finset (Ideal O))(hp:∀i,∀P∈L i,Prime P) + (hs:∀i,∀P∈L i,Supported P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L) + (J:Finset ι)(x:Assigned L J):Admissible (assignedIdeal L J x) := by + apply tuple_admissible (fun i:↥J=>L i.val) + (fun i=>hp i.val) (fun i=>hs i.val) _ x + intro i hi j hj hij + exact hdis (Finset.mem_univ _) (Finset.mem_univ _) + (fun he=>hij (Subtype.ext he)) + +theorem original_source_energy + (W:ℝ→ℂ)(ao bo:ℝ)(hao:01) + (childLogTest W θ) U r (∑i,ell i) u‖^2)≤ + C*U^(m+15*eta+π+eps+loss)*((1+‖θ‖)^degree)^2 := by + have hsstar:Function.support (fun x=>star (W x))⊆Set.Icc ao bo := by + intro x hx + exact hsW (by simpa using hx) + obtain ⟨degree,henergy⟩:=InverseInitialResidualUniformEnergy.original_residual_uniform_energy + (fun x=>star (W x)) ao bo hao hab hsstar (Complex.conjCLE.contDiff.comp hW) + DetectorDictionaryInverseMarkedPadding.radialMajorant + DetectorDictionaryInverseMarkedPadding.radialMajorant_nonneg + DetectorDictionaryInverseMarkedPadding.radialMajorant_one + 2 gap eps π eta τ loss (by norm_num) hgap heps hπ heta hetaone hetagap hτ hτgap hloss K + refine ⟨degree,?_⟩ + intro q hq + obtain ⟨C,U₀,hC,hU₀,henergy⟩:=henergy q hq + let A:ℝ:=((2:ℝ)^K*DetectorDictionaryInverseAssignedCount.assignedConstant K 2)^2 + have hA:02*U^(ell i)) (fun i P=>star (coeff i P)) hdis + (fun i _=>hH i) (fun i _=>hnorm i) + (fun i _ P hP=>by simpa using hc i P hP) + (assignedGenerator L J x) ell (fun _=>1) (fun _=>2) primeW + (fun i _=>hell i) + (assignedGenerator_ne_zero L J x (fun i _ P hP=>(hp i P hP).ne_zero)) + (fun i _=>hprimeW i) (assignedGenerator_window_live L J x U ell primeW (fun i _=>hlive i)) + (conjugateIdealCharacter χ) + (fun u=>by simpa [elementCharacter,conjugateIdealCharacter] using hχ (Ideal.span {u})) + hperiod hzero (r+(∑i,ell i)-2*(∑i∈J,ell i)) m r hm hmcap (hD J) + (by simpa using (pow_le_pow_right₀ (by norm_num : (1:ℝ)≤2) hJ).trans hpow) + (by simpa [assignedCenter] using hprod (Finset.univ\J)) + rfl (by simpa [assignedCenter] using hfirst) (by simpa [assignedCenter] using hsecond) + (by simpa [assignedCenter] using hparent) rows hrows (assignedIdeal L J x) hje + (assignedElement_span L J x) + (assigned_ratio_interval L J x U hUpos ell K hJ (fun i _=>hratio i)) + (fun i _=>hp i) (fun i _ P hP _=>hratio i P hP) + (remaining_tuple_admissible L hp hs hdis J x) + (remaining_tuple_coprime L hp hdis J) + (remaining_tuple_outside L (reflectionExcludedPrimes q) (reflectionExcludedPrimes_prime q) + hout J x) (-θ) + simpa only [one_mul,remainingPolynomial_original_pi,childLogTest_conjugate, + assignedCenter,norm_neg,E] using hh + have hb:=original_energy_with_assigned_count K (by norm_num : (1:ℝ)≤2) hUone.le hK + (originalSource U r bo) L hp hdis ell (fun i P hP=>⟨(hp i P hP).ne_zero,hnorm i P hP⟩) + coeff hc χ (assigned_admissible L hp hs hdis) (fun J x=>hχ _) + (childLogTest W θ) r (∑i,ell i) rows (fun _=>1) (fun _=>zero_le_one) E hE hres + simpa only [one_mul,E,A,mul_assoc] using hb + +end SevenEighths.DetectorDictionaryInverseMarkedReference + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceTuples.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceTuples.lean new file mode 100644 index 0000000000000000000000000000000000000000..911b183111a80cd2336029875ba49e75ed80621c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseMarkedReferenceTuples.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseMarkedReferenceDivisors + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators +namespace SevenEighths.DetectorDictionaryInverseMarkedReference +open HeckeFamily InverseInitialConjugateEnergy InverseInitialPoissonBridge +local notation "O"=>HeckeFamily.O +variable {ι:Type*}[Fintype ι][DecidableEq ι] + +abbrev Tuple (L:ι→Finset (Ideal O)) := ∀i,↥(L i) +abbrev Assigned (L:ι→Finset (Ideal O))(J:Finset ι) := ∀i:↥J,↥(L i.val) +abbrev Remaining (L:ι→Finset (Ideal O))(J:Finset ι) := ∀i:{i:ι // i∉J},↥(L i.val) + +def joinTuple (L:ι→Finset (Ideal O))(J:Finset ι)(x:Assigned L J)(y:Remaining L J) : Tuple L := + (Equiv.piEquivPiSubtypeProd (fun i=>i∈J) (fun i=>↥(L i))).symm (x,y) + +theorem sum_tuple_split (L:ι→Finset (Ideal O))(J:Finset ι)(f:Tuple L→ℂ) : + (∑q:Tuple L,f q)=∑x:Assigned L J,∑y:Remaining L J,f (joinTuple L J x y) := by + rw [←(Equiv.piEquivPiSubtypeProd (fun i=>i∈J) (fun i=>↥(L i))).symm.sum_comp] + exact Fintype.sum_prod_type _ + +theorem sum_tuple_original (L:ι→Finset (Ideal O))(f:(ι→Ideal O)→ℂ) : + (∑q:Tuple L,f (fun i=>(q i).val))=∑q∈Fintype.piFinset L,f q := by + symm + apply Finset.sum_bij (fun q hq i=>⟨q i,Fintype.mem_piFinset.mp hq i⟩) + · intro q hq + exact Finset.mem_univ _ + · intro q hq r hr he + funext i + exact congrArg Subtype.val (congrFun he i) + · intro q hq + refine ⟨fun i=>(q i).val,Fintype.mem_piFinset.mpr (fun i=>(q i).property),?_⟩ + funext i + rfl + · intro q hq + rfl + +theorem tuple_injective (L:ι→Finset (Ideal O)) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L)(q:Tuple L) : + Function.Injective (fun i=>(q i).val) := by + intro i j he + by_contra hij + exact Finset.disjoint_left.mp (hdis (Finset.mem_univ i) (Finset.mem_univ j) hij) + (q i).property (by simpa only [he] using (q j).property) + +theorem original_selected_subset_sum (S:Finset (Ideal O)) + (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L)(coeff:ι→Ideal O→ℂ) + (η:Ideal O→*ℂ)(a:Ideal O→ℂ)(W:ℝ→ℂ)(Z r z:ℝ)(hZ:0hprime i _ (q i).property) + (tuple_injective L hdis q) η a W Z r z hZ u,Finset.mul_sum] + _ = _ := Finset.sum_comm + +theorem original_selected_grouped (S:Finset (Ideal O)) + (L:ι→Finset (Ideal O))(hprime:∀i,∀P∈L i,Prime P) + (hdis:((Finset.univ:Finset ι):Set ι).PairwiseDisjoint L)(coeff:ι→Ideal O→ℂ) + (η:Ideal O→*ℂ)(a:Ideal O→ℂ)(W:ℝ→ℂ)(Z r z:ℝ)(hZ:0familyDensity scaled reverse n U tstar r σ t 1 v* + (polynomial χ true (childLogTest referenceWindow v) D 0 0*A)) := by + simpa only [familyDensity,zero_add,mul_assoc] using + (polynomial_mode_integrable χ true (logSource scaled reverse n U tstar r σ t) + referenceWindow (13/4) 1 0 D hD + (fun x hx=>(referenceWindow_support (subset_tsupport _ hx)).2)).mul_const A + +theorem family_polynomial_fourier (χ : Character) (A : ℂ) + (scaled reverse : Bool) (n : ℕ) (U tstar r σ t D : ℝ) (hD : 0(referenceWindow_support (subset_tsupport _ hx)).2) + (fun y hy=>referenceWindow_agrees scaled reverse n U tstar r σ t 1 y + (by norm_num) (by norm_num) hy) + rw [clipped_one_zero] at h + rw [h,←integral_mul_const] + apply integral_congr_ae + filter_upwards with v + simp only [familyDensity,logSource_eq_logSchwartz,zero_add,mul_assoc] + +theorem moving_finite_energy (J : ℕ) : + ∃K : ℕ,∃C : ℝ,0(referenceWindow_support (subset_tsupport _ hx)).2) + (fun y hy=>referenceWindow_agrees scaled reverse n U tstar r σ t 1 y + (by norm_num) (by norm_num) hy) href + rw [clipped_one_zero] at hb + simp only [norm_zero,add_zero,one_pow,mul_one] at hb + have hm:=hmass scaled reverse n hn U hU tstar r σ hσ t 1 + simp only [familyDensity_norm,logSource_eq_logSchwartz] at hm + apply hb.trans + calc + _≤E*(B*(1+‖t‖)^K)^2:=mul_le_mul_of_nonneg_left + (pow_le_pow_left₀ (integral_nonneg (fun _=>by positivity)) hm 2) hE + _= _:=by rw [mul_pow,←pow_mul];ring_nf + +theorem logTest_eq_iterate (W : ℝ→ℂ) (n : ℕ) : + logTest W n=(HeckeDetectorRowwisePolynomial.logProfile^[n]) W := by + induction n with + | zero=>rfl + | succ n ih=>rw [logTest,Function.iterate_succ_apply',←ih] + +section Fiber +variable {M : Ideal O} {H : Subgroup (O⧸M)ˣ} {Label Slot : Type*} + {U a ε tstar T allowance : ℝ} {i : ℕ} + +theorem fiber_inverse_source + (F : Fiber M H Label Slot U a ε tstar T allowance i) (n : ℕ) (σ t : ℝ) : + (inverseSourceSchwartz false false n U tstar F.r σ t : ℝ→ℂ)= + twistProfile ((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile) σ t := by + funext x + simpa only [Bool.false_eq_true,ite_false,HeckeDetectorCoefficientTransfer.orientedProfile, + logTest_eq_iterate,Fiber.inverseProfile] using + inverseSourceSchwartz_apply false false n U tstar F.r σ t x + +theorem fiber_inverse_polynomial + (F : Fiber M H Label Slot U a ε tstar T allowance i) (selected : Finset Slot) + (n : ℕ) (σ t : ℝ) (u : FreeRow) : + polynomial (F.family u F.label) true + (inverseSourceSchwartz false false n U tstar F.r σ t) (U^F.r) 0 0* + F.physicalProduct selected u= + polynomial (F.family u F.label) true ((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile) + (U^F.r) σ t*F.physicalProduct selected u := by + rw [fiber_inverse_source,polynomial_twistProfile] + +theorem fiber_inverse_fourier + (F : Fiber M H Label Slot U a ε tstar T allowance i) (selected : Finset Slot) + (n : ℕ) (σ t : ℝ) (hU : 0F.family u F.label) (F.physicalProduct selected) + (U^F.r) E (Real.rpow_pos_of_pos hU _) hE href false false n hn U hU tstar F.r σ hσ t + simpa only [fiber_inverse_polynomial] using hh + +theorem fiber_inverse_height_uniform (J : ℕ) : + ∃K : ℕ,∃C : ℝ,0 HeckeFamily.O + +lemma inverse_polynomial_all_ideals (χ : Character) (W : ℝ→ℂ) (D freq : ℝ) : + polynomial χ true W D 0 freq = + (D:ℂ)^(-(1/2:ℂ))*∑'I:Ideal O,coefficient χ true I*annularWeight W D 0 freq I := by + unfold polynomial + congr 1 + have he : (∑'I:HeckeDyadic.NonzeroIdeal,coefficient χ true I.val*annularWeight W D 0 freq I.val)= + ∑'I:Ideal O,coefficient χ true I*annularWeight W D 0 freq I := by + apply tsum_subtype_eq_of_support_subset (s:={I:Ideal O|I≠0}) + (f:=fun I:Ideal O=>coefficient χ true I*annularWeight W D 0 freq I) + intro I hI hz + subst I + exact hI (by simp only [coefficient_zero,zero_mul]) + simpa only [summand,HeckeDyadic.norm,annularWeight,mul_assoc] using he + +theorem inverse_polynomial_bound (χ : Character) (W : ℝ→ℂ) (b B D freq : ℝ) + (hB : 0≤B) (hD : 0coefficient χ true I*annularWeight W D 0 freq I) + (max 1 b*D) B (by positivity) hB (by + change coefficient χ true (0:Ideal O)*_ = 0 + rw [coefficient_zero,zero_mul]) + (by + intro I + by_cases hI:I=0 + · subst I + simpa only [coefficient_zero,zero_mul,norm_zero] using hB + rw [norm_mul,annularWeight_zero_norm W D freq hD I hI] + exact (mul_le_mul (coefficient_norm_le χ true I) (hW _) (norm_nonneg _) zero_le_one).trans_eq + (one_mul B)) + (by + intro I hne + have hw : W ((I.absNorm:ℝ)/D)≠0 := by + intro hz + exact hne (by simp only [annularWeight,hz,zero_mul,mul_zero]) + exact ((div_le_iff₀ hD).mp (hs hw)).trans + (mul_le_mul_of_nonneg_right (le_max_right 1 b) hD.le)) + convert hh using 1; ring + +lemma childLogTest_norm (W : ℝ→ℂ) (s x : ℝ) : + ‖childLogTest W s x‖=‖W x‖ := by + simp only [childLogTest,norm_mul,logPhase_norm,mul_one] + +theorem inverse_reference_bound (W : SchwartzMap ℝ ℂ) (a b : ℝ) (ha : 0HeckeFamily.O + +theorem conjugate_element_apply (η:Ideal O→*ℂ)(x:O): + elementCharacter (conjugateIdealCharacter η) x=star (elementCharacter η x):=rfl + +theorem conjugate_element_factors (η:Ideal O→*ℂ)(Q:Ideal O) + (h:FactorsModulo Q (elementCharacter η)): + FactorsModulo Q (elementCharacter (conjugateIdealCharacter η)):=by + intro x y hxy + exact congrArg star (h x y hxy) + +theorem conjugate_element_norm (η:Ideal O→*ℂ)(x:O): + ‖elementCharacter (conjugateIdealCharacter η) x‖=‖elementCharacter η x‖:=by + rw [conjugate_element_apply,norm_star] + +theorem raw_conjugate_base_gates (data:RowData): + deletedPeriod (basePeriod data)≠0 ∧ + reflectionExcludedPrimes (deletedPeriod (basePeriod data))=excluded data ∧ + (∀x,‖elementCharacter (conjugateIdealCharacter + (idealCoeff (deletedBase data)).toMonoidHom) x‖≤1) ∧ + FactorsModulo (fixedBaseConductor (deletedPeriod (basePeriod data))) + (elementCharacter (conjugateIdealCharacter (idealCoeff (deletedBase data)).toMonoidHom)):=by + obtain ⟨hq,he,hn,hp⟩:=raw_base_gates data + refine ⟨hq,he,?_,conjugate_element_factors _ _ hp⟩ + intro x + rw [conjugate_element_norm] + exact hn x + +theorem raw_conjugate_zero_outside (data:RowData)(I:Ideal O) + (hI:¬outside (excluded data) I): + conjugateIdealCharacter (idealCoeff (deletedBase data)).toMonoidHom I=0:=by + change star (idealCoeff (deletedBase data) I)=0 + rw [show idealCoeff (deletedBase data) I=0 from + deleted_zero_outside (InverseInitialDetectorSource.baseCharacter data) + (excluded data) (reflectionExcludedPrimes_prime (basePeriod data)) I hI,star_zero] + +theorem childLogTest_conjugate (W:ℝ→ℂ)(θ:ℝ): + (fun x=>star (childLogTest W θ x))=childLogTest (fun x=>star (W x)) (-θ):=by + funext x + simp only [childLogTest,star_mul,SecondPassIntegration.logPhase_conjugate] + ring + +theorem childLogTest_conjugate_norm (W:ℝ→ℂ)(θ x:ℝ): + ‖childLogTest (fun x=>star (W x)) (-θ) x‖=‖W x‖:=by + rw [InverseInitialProfileBounds.childLogTest_norm,norm_star] + +theorem childLogTest_physical_profiles (W:ℝ→ℂ)(θ:ℝ): + (fun x=>star (childLogTest W θ x))=clippedSource (fun x=>star (W x)) 1 (-θ) ∧ + childLogTest W θ=clippedSource W 1 θ:=by + rw [childLogTest_conjugate] + exact ⟨InverseInitialProfileBounds.childLogTest_eq_clipped _ _, + InverseInitialProfileBounds.childLogTest_eq_clipped _ _⟩ + +end SevenEighths.DetectorDictionaryInverseRawConjugateGates + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..d45f58285ec5104514800e8bb4c03a1319db4991 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawEnergy.lean @@ -0,0 +1,86 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawFourier +import OAI.NumberTheory.DirichletL.Hecke.InverseAmplificationRaw + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap FourierTransform ContDiff +open MeasureTheory +namespace SevenEighths.DetectorDictionaryInverseRawFourier +open HeckeFamily HeckeDyadic InverseMoment InverseInitialClippedColumns +open InverseInitialOverlapFourier FourierBridge HeckeInverseAmplification + +theorem polynomial_clipped_energy {ι : Type*} (rows : Finset ι) + (χ : ι→Character) (inv : Bool) (A : ι→ℂ) + (W : ℝ→ℂ) (lo hi : ℝ) (hlo : 0polynomial (χ i) inv (childLogTest Wref (θ+v)) D 0 0*A i + have hint (i : rows) : Integrable (fun v:ℝ=>B v*φ i v) := by + simpa only [B,φ,mul_assoc] using + (polynomial_mode_integrable (χ i) inv g Wref b c θ D hD hWref).mul_const (A i) + have hbound (v : ℝ) : (∑i:rows,‖φ i v‖^2)≤ + (E*(1+‖θ‖)^(2*J))*((1+‖v‖)^J)^2 := by + dsimp only [φ] + rw [Finset.sum_coe_sort rows (fun i=>‖polynomial (χ i) inv (childLogTest Wref (θ+v)) D 0 0*A i‖^2)] + apply (he (θ+v)).trans + have hh : 1+‖θ+v‖≤(1+‖θ‖)*(1+‖v‖) := by + have hn:=norm_add_le θ v + nlinarith [mul_nonneg (norm_nonneg θ) (norm_nonneg v)] + calc + _≤E*((1+‖θ‖)*(1+‖v‖))^(2*J):= + mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (by positivity) hh _) hE + _= _:=by rw [mul_pow,pow_mul];ring + have hden : Integrable (fun v:ℝ=>(1+‖v‖)^J*‖B v‖) := by + simpa only [B,density_norm] using AnalyticBridge.schwartz_fourier_one_plus_integrable g J + have hh:=CenteredMomentHeckeWindowEnergy.finite_weighted_integral_energy B φ + (fun v:ℝ=>(1+‖v‖)^J) (by intro v;positivity) + (E*(1+‖θ‖)^(2*J)) (by positivity) hden hint hbound + have heq (i : rows) : (∫v:ℝ,B v*φ i v)= + polynomial (χ i) inv (clippedTest W c θ) D 0 0*A i := by + rw [polynomial_clipped_fourier (χ i) inv W lo hi hlo hs hW Wref b c θ D hc hD hWref hagree, + ←integral_mul_const] + apply integral_congr_ae + filter_upwards with v + dsimp [B,φ,g] + ring + simp_rw [heq] at hh + rw [Finset.sum_coe_sort rows (fun i=>‖polynomial (χ i) inv (clippedTest W c θ) D 0 0*A i‖^2)] at hh + simpa only [B,density_norm,g] using hh + +theorem rawMoment_reference (data : RowData) + (W : ℝ→ℂ) (lo hi : ℝ) (hlo : 01) + W lo hi hlo hs hW Wref b 1 0 D (C*H*(H*max 1 D)^κ) J (by norm_num) hD + (by positivity) hWref (by simpa only [one_mul] using hagree) (by + intro s + have hb:=he s H D hH hD hHD rows hrows + simpa only [mul_one,one_mul,mul_assoc,mul_left_comm,mul_comm] using hb) + have heq : clippedTest W 1 0=W := by + funext x + simp [clippedTest,childLogTest,logPhase] + rw [heq] at hh + simpa only [mul_one,one_mul,norm_zero,add_zero,one_pow,mul_assoc,mul_left_comm,mul_comm] using hh + +end SevenEighths.DetectorDictionaryInverseRawFourier + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawFiberSource.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawFiberSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..b67171afd2d125b35154972289ebd71cd81f0dc9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawFiberSource.lean @@ -0,0 +1,115 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialPhysicalSlots +import OAI.NumberTheory.DirichletL.Hecke.DetectorRawFiber + +namespace OAI + +noncomputable section +open scoped Classical BigOperators ComplexConjugate +namespace SevenEighths.DetectorDictionaryInverseRawFiberSource +open HeckeFamily HeckeDyadic HeckeInverseAmplification HeckeDetectorRawFiber +open HeckeDetectorCoefficientTransfer InverseInitialPhysicalSlots +open InverseInitialDetectorSource InverseInitialRawDictionary InverseInitialConjugateEnergy +open HeckeDetectorPhysicalSelection +local notation "O"=>HeckeFamily.O + +variable {M : Ideal O} {H : Subgroup (O ⧸ M)ˣ} {Label Slot : Type*} + {U a ε tstar T allowance : ℝ} {i : ℕ} + +theorem fiber_physical_norm_initial + (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (W : ℝ→ℂ) (σ t bW : ℝ) (lower : Slot→ℝ) + (hU : 0 + livePrimes M H (F.profile s) (F.upper s) (U^(F.widths s))), + (star (∏s:selected,primeProfile (F.profile s) (U^(F.widths s)) (F.external s) (p s))/ + fixedBase F.rowData.η F.rowData.m F.rowData.f (∏s:selected,p s))* + originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*bW⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,p s) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (orientedProfile F.reverse W) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u.val‖ := by + have hn:=norm_of_oriented_coefficients (F.family u F.label) + (F.rowData.character ⟨u.val,u.property.1⟩) F.reverse (F.row_coeff u hu) + true W (U^F.r) σ t (Real.rpow_pos_of_pos hU _) + have hp : F.physicalProduct selected u= + ∏s:selected,HeckePrimeRow.canonicalPrimeAmplitude M H u.val + (F.profile s) (F.upper s) (U^(F.widths s)) (F.external s) := by + simp only [Fiber.physicalProduct,physical] + exact (Finset.prod_coe_sort selected _).symm + rw [norm_mul,hn,←norm_mul,hp] + have hh:=physical_slots_norm_initial M H F.rowData ⟨u.val,u.property.1⟩ + (orientedProfile F.reverse W) (fun s:selected=>F.profile s) + U F.r σ (orientedFrequency F.reverse t) bW + (fun s:selected=>lower s) (fun s:selected=>F.upper s) (fun s:selected=>F.widths s) + (fun s:selected=>F.external s) hU + (by intro x hx;apply hW x;intro hz;exact hx (by cases F.reverse <;> simp [orientedProfile,hz])) + (fun s=>hV s s.property) (fun s=>hlarge s s.property) + convert hh using 1 ; congr 2 + ext p + simp only [Fintype.mem_piFinset] + +theorem fiber_physical_energy_initial + (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (W : ℝ→ℂ) (σ t bW : ℝ) (lower : Slot→ℝ) + (hU : 0 + livePrimes M H (F.profile s) (F.upper s) (U^(F.widths s))), + (star (∏s:selected,primeProfile (F.profile s) (U^(F.widths s)) (F.external s) (p s))/ + fixedBase F.rowData.η F.rowData.m F.rowData.f (∏s:selected,p s))* + originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*bW⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,p s) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (orientedProfile F.reverse W) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u.val‖^2 := by + apply Finset.sum_congr rfl + intro u hu + rw [fiber_physical_norm_initial F selected W σ t bW lower hU hW hV hlarge u hu] + +theorem fiber_inverse_log_upper + (F : Fiber M H Label Slot U a ε tstar T allowance i) (n : ℕ) : + ∀x,((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile) x≠0 → x≤9/4 := by + induction n with + | zero => + intro x hx + have hv : HeckeDetectorDyadicProfiles.positiveAnnular x≠0 := by + intro hz + exact hx (by simp [Fiber.inverseProfile,HeckeDetectorInverseFiberCount.inverseTest, + HeckeDetectorDyadicBridge.inverseProfile,hz]) + exact (HeckeDetectorDyadicProfiles.positiveAnnular_support hv).2 + | succ n ih => + intro x hx + rw [Function.iterate_succ_apply'] at hx + exact ih x (HeckeDetectorRowwisePolynomial.logProfile_support _ hx) + +theorem fiber_inverse_energy_initial + (F : Fiber M H Label Slot U a ε tstar T allowance i) + (selected : Finset Slot) (n : ℕ) (σ t : ℝ) (lower : Slot→ℝ) + (hU : 0 + livePrimes M H (F.profile s) (F.upper s) (U^(F.widths s))), + (star (∏s:selected,primeProfile (F.profile s) (U^(F.widths s)) (F.external s) (p s))/ + fixedBase F.rowData.η F.rowData.m F.rowData.f (∏s:selected,p s))* + originalTotalPolynomial + ((ConcretePrimeRowBridge.idealsUpTo ⌈U^F.r*(9/4)⌉₊).filter CanonicalQuadraticSieve.Supported) + (∏s:selected,p s) (fixedBase F.rowData.η F.rowData.m F.rowData.f) (fun _=>1) + (twistedProfile (orientedProfile F.reverse ((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile)) σ (orientedFrequency F.reverse t)) + U F.r (∑s:selected,F.widths s) u.val‖^2 := by + exact fiber_physical_energy_initial F selected + ((HeckeDetectorRowwisePolynomial.logProfile^[n]) F.inverseProfile) σ t (9/4) lower + hU (fiber_inverse_log_upper F n) hV hlarge + +end SevenEighths.DetectorDictionaryInverseRawFiberSource + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawFourier.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..7e1d3634291fe4e8df923ede5ab9f0e251c7bc2c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawFourier.lean @@ -0,0 +1,91 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialDetectorSource +import OAI.NumberTheory.DirichletL.Descent.ClippedEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap FourierTransform ContDiff +open MeasureTheory +namespace SevenEighths.DetectorDictionaryInverseRawFourier +open HeckeFamily HeckeDyadic HeckeDetectorDyadicBridge InverseInitialRawDictionary +open InverseMoment InverseInitialClippedColumns InverseInitialOverlapFourier FourierBridge JointLogSeparation + +private theorem child_cover (Wref : ℝ→ℂ) (b D : ℝ) (hD : 0density g (Real.log c) v* + polynomial χ inv (childLogTest Wref (θ+v)) D 0 0) := by + simp_rw [polynomial_eq_finite χ inv (childLogTest Wref (θ+_)) D 0 0 + (ConcretePrimeRowBridge.idealsUpTo ⌈D*b⌉₊) (child_cover Wref b D hD hWref _)] + simp only [HeckeDyadic.shift,Complex.ofReal_zero,zero_mul,sub_zero, + neg_zero,Complex.cpow_zero,mul_one,Finset.mul_sum] + apply integrable_finsetSum + intro I hI + convert fourier_phase_integrable g + (Real.log c+Real.log ((I.absNorm:ℝ)/D)) + ((D:ℂ)^(-(1/2:ℂ))*coefficient χ inv I*Wref ((I.absNorm:ℝ)/D)* + logPhase θ (Real.log ((I.absNorm:ℝ)/D))) using 1 + funext v + simp only [density,childLogTest,logPhase_add_frequency,logPhase_add] + ring + +theorem polynomial_clipped_fourier (χ : Character) (inv : Bool) + (W : ℝ→ℂ) (lo hi : ℝ) (hlo : 0 + density (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) (Real.log c) v* + ((D:ℂ)^(-(1/2:ℂ))*(coefficient χ inv I*childLogTest Wref (θ+v) ((I.absNorm:ℝ)/D)))) := by + convert fourier_phase_integrable (CubicReflectionKernel.logSchwartz W lo hi hlo hs hW) + (Real.log c+Real.log ((I.absNorm:ℝ)/D)) + ((D:ℂ)^(-(1/2:ℂ))*coefficient χ inv I*Wref ((I.absNorm:ℝ)/D)* + logPhase θ (Real.log ((I.absNorm:ℝ)/D))) using 1 + funext v + simp only [density,childLogTest,logPhase_add_frequency,logPhase_add] + ring + rw [integral_finsetSum _ (fun I _=>hint I)] + apply Finset.sum_congr rfl + intro I hI + by_cases hz : I=0 + · subst I + simp only [coefficient_zero,zero_mul,mul_zero,integral_zero] + have hIp : 0<(I.absNorm:ℝ)/D:=div_pos (by exact_mod_cast (Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr hz))) hD + rw [clipped_test_fourier W lo hi hlo hs hW Wref c θ _ hc hIp (hagree _ hIp), + ←integral_const_mul,←integral_const_mul] + apply integral_congr_ae + filter_upwards with v + ring + +end SevenEighths.DetectorDictionaryInverseRawFourier + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawGeometry.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawGeometry.lean new file mode 100644 index 0000000000000000000000000000000000000000..48ebd368e52c788436778eb91a9463e05b7b353a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawGeometry.lean @@ -0,0 +1,85 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialCanonicalState +import OAI.NumberTheory.DirichletL.Hecke.InverseAmplificationRaw + +namespace OAI + +noncomputable section +namespace SevenEighths.DetectorDictionaryInverseRawGeometry +open InverseMoment InverseInitialCanonicalState + +def capacityGap (c : ℝ) : ℝ:=c/(1+c) + +theorem capacityGap_pos (c : ℝ) (hc : 0HeckeFamily.O + +private theorem admissible_one : Admissible (1:Ideal O) := by + refine ⟨one_ne_zero,squarefree_one,?_⟩ + simp only [UniqueFactorizationMonoid.normalizedFactors_one,Multiset.notMem_zero,false_implies,forall_const] + +def initialFunction (data:RowData)(W:ℝ→ℂ)(H b Btree cap D sigma freq:ℝ)(j:Ideal O):O→ℂ:= + originalTotalPolynomial + (InitialMeanSquare.outsideSquarefreeIdeals (excluded data) (completeCutoff H b Btree cap)) + 1 (idealCoeff (deletedBase data)).toMonoidHom (fun _=>1) + (twistedProfile W sigma freq) H (Real.logb H (D/(j.absNorm:ℝ))) 0 + +theorem deleted_rows_le_initial + (Φ:𝓢(ℝ,ℂ))(hΦ:∀x,0≤(Φ x).re)(hone:∀x∈Set.Icc (0:ℝ) 1,Φ x=1) + (data:RowData)(W:ℝ→ℂ)(H D c b Btree cap sigma freq:ℝ) + (hH:1radialWeight Φ H u*‖f u‖^2):= + (original_smoothed_overlap_triangle F admissible_one + (fun I hI _=>admissible_supported (hFa I hI)) + (idealCoeff (deletedBase data)).toMonoidHom (fun _=>1) (twistedProfile W sigma freq) + (zero_lt_one.trans hH) (Real.logb H (D/(j.absNorm:ℝ))) 0 (fun _=>0) + Φ (fun x _=>hΦ x) (zero_lt_one.trans hH)).1 + have he (u:NonzeroElement)(hu:u∈rows): + ‖polynomial ((data.character u).excludePrimes (excluded data) + (reflectionExcludedPrimes_prime (basePeriod data))) true W (D/(j.absNorm:ℝ)) sigma freq‖^2= + radialWeight Φ H u.val*‖f u.val‖^2:=by + have hn:‖eisEmbedding u.val‖^2/H∈Set.Icc (0:ℝ) 1:=by + refine ⟨div_nonneg (sq_nonneg _) (zero_lt_one.trans hH).le,?_⟩ + apply (div_le_one (zero_lt_one.trans hH)).mpr + rw [eisEmbedding_norm_sq_eq_absNorm_span] + exact hrows u hu + rw [(raw_complete_pool data H D c b Btree cap hH hD hc hcapacity hb W hW).2 j hj u sigma freq] + change ‖f u.val‖^2=(Φ (‖eisEmbedding u.val‖^2/H)).re*‖f u.val‖^2 + rw [hone _ hn,Complex.one_re,one_mul] + calc + _=∑u∈rows,radialWeight Φ H u.val*‖f u.val‖^2:=Finset.sum_congr rfl he + _=∑u∈rows.image Subtype.val,radialWeight Φ H u*‖f u‖^2:=by + rw [Finset.sum_image (fun a _ b _ hab=>Subtype.val_injective hab)] + _≤∑'u:O,radialWeight Φ H u*‖f u‖^2:=hs.sum_le_tsum _ + (fun u _=>mul_nonneg (hΦ _) (sq_nonneg _)) + _=_:=rfl + +theorem raw_rows_le_initial + (Φ:𝓢(ℝ,ℂ))(hΦ:∀x,0≤(Φ x).re)(hone:∀x∈Set.Icc (0:ℝ) 1,Φ x=1) + (data:RowData)(W:ℝ→ℂ)(H D c b Btree cap sigma freq:ℝ) + (hH:11) (fun _=>1) (by intros;norm_num) + simp only [mul_one,one_mul] at hd + apply hd.trans + apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _) + apply Finset.sum_le_sum + intro j hj + exact deleted_rows_le_initial Φ hΦ hone data W H D c b Btree cap sigma freq + hH hD hc hcapacity hb hW j hj rows hrows + +end SevenEighths.DetectorDictionaryInverseRawInitialEnergy + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawInitialGates.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawInitialGates.lean new file mode 100644 index 0000000000000000000000000000000000000000..8a06db8536be28d78483749d40359061b1919370 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawInitialGates.lean @@ -0,0 +1,198 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawGeometry +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawRadial +import OAI.NumberTheory.DirichletL.Inversion.InitialExcludedElement +import OAI.NumberTheory.DirichletL.Inversion.InitialExcludedOverlap + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap Topology +open Filter +namespace SevenEighths.DetectorDictionaryInverseRawInitialGates +open HeckeFamily HeckeDyadic HeckeInverseAmplification InverseInitialDetectorSource +open InverseInitialRawDictionary InverseInitialRayAttachment InverseInitialExcludedPeriod +open InverseInitialExcludedPool InverseInitialExcludedOverlap InverseInitialExcludedPolynomial +open CanonicalRowCompletion CanonicalCoefficientClass CanonicalQuadraticSieve ConcreteTraceCRT +open ConcretePrimeRowBridge UniqueFactorizationMonoid IdealMobiusDivisorSum +open DetectorDictionaryInverseRawGeometry +local notation "O"=>HeckeFamily.O + +def basePeriod (data:RowData):ℕ:=(baseCharacter data).period + +def excluded (data:RowData):Finset (Ideal O):=reflectionExcludedPrimes (basePeriod data) + +def deletedBase (data:RowData):Character:= + (baseCharacter data).excludePrimes (excluded data) (reflectionExcludedPrimes_prime (basePeriod data)) + +theorem basePeriod_ne_zero (data:RowData):basePeriod data≠0:=Nat.ne_of_gt (Character.period_pos _) + +theorem basePeriod_le (data:RowData):Ideal.span {(basePeriod data:O)}≤(baseCharacter data).modulus:= + Ideal.span_le.mpr (Set.singleton_subset_iff.mpr (Character.period_mem _)) + +theorem raw_base_gates (data:RowData): + deletedPeriod (basePeriod data)≠0 ∧ + reflectionExcludedPrimes (deletedPeriod (basePeriod data))=excluded data ∧ + (∀x,‖elementCharacter (idealCoeff (deletedBase data)).toMonoidHom x‖≤1) ∧ + FactorsModulo (fixedBaseConductor (deletedPeriod (basePeriod data))) + (elementCharacter (idealCoeff (deletedBase data)).toMonoidHom):= + deleted_physical_base_gates (baseCharacter data) (basePeriod data) + (basePeriod_ne_zero data) (basePeriod_le data) + +theorem actual_row_fixed_base (data:RowData)(u:NonzeroElement)(I:Ideal O): + idealCoeff (data.character u) I=idealCoeff (baseCharacter data) I*idealRowHom u.val I:=by + rw [baseCharacter_coeff] + exact fixedBase_row data.η (data.character u) data.m data.f u.val (data.character_spec u) I + +theorem actual_deleted_row (data:RowData)(u:NonzeroElement)(I:Ideal O): + idealCoeff ((data.character u).excludePrimes (excluded data) + (reflectionExcludedPrimes_prime (basePeriod data))) I= + idealCoeff (deletedBase data) I*idealRowHom u.val I:=by + unfold deletedBase excluded + rw [idealCoeff_excludePrimes,idealCoeff_excludePrimes,actual_row_fixed_base] + split_ifs <;> simp + +def completeCutoff (H b Btree cap:ℝ):ℕ:=⌈max (Btree*H^(cap+1)) (b*H)⌉₊ + +theorem completeCutoff_tree (H b Btree cap:ℝ): + Btree*H^(cap+1)≤(completeCutoff H b Btree cap:ℝ):= + (le_max_left _ _).trans (Nat.le_ceil _) + +theorem completeCutoff_columns (H b Btree cap D n:ℝ)(hb:0≤b)(hD:0≤D) + (hDH:D≤H)(hn:1≤n):b*(D/n)≤(completeCutoff H b Btree cap:ℝ):=by + have hn0:01) + (twistedProfile W sigma freq) H r 0 u.val:=by + let χ:=(data.character u).excludePrimes (excluded data) + (reflectionExcludedPrimes_prime (basePeriod data)) + let F:=InitialMeanSquare.outsideSquarefreeIdeals (excluded data) Dpool + have hs:(∑'I:Ideal O,(moebius I:ℂ)*idealCoeff χ I* + (W ((I.absNorm:ℝ)/H^r)*(((I.absNorm:ℝ)/H^r:ℝ):ℂ)^(-HeckeDyadic.shift sigma freq)))= + ∑I∈F,(moebius I:ℂ)*idealCoeff χ I* + (W ((I.absNorm:ℝ)/H^r)*(((I.absNorm:ℝ)/H^r:ℝ):ℂ)^(-HeckeDyadic.shift sigma freq)):=by + apply tsum_eq_sum + intro I hn + by_cases hsq:Squarefree I + · by_cases hout:outside (excluded data) I + · by_cases hw:W ((I.absNorm:ℝ)/H^r)=0 + · simp only [hw,zero_mul,mul_zero] + · have hN:(I.absNorm:ℝ)≤(Dpool:ℝ):= + ((div_le_iff₀ (Real.rpow_pos_of_pos hH r)).mp (hW _ hw)).trans hbudget + have hmem:I∈F:=by + apply Finset.mem_filter.mpr + refine ⟨mem_outsideIdealsUpTo.mpr ⟨?_,?_,hout⟩,hsq⟩ + · exact Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hsq.ne_zero) + · exact_mod_cast hN + exact False.elim (hn hmem) + · have hz:=deleted_zero_outside (data.character u) (excluded data) + (reflectionExcludedPrimes_prime (basePeriod data)) I hout + simp only [χ,hz,mul_zero,zero_mul] + · simp only [moebius_of_not_squarefree hsq,Int.cast_zero,zero_mul] + rw [polynomial_all_ideals,hs,normalization_eq H r hH] + unfold InverseInitialConjugateEnergy.originalTotalPolynomial + simp only [add_zero,map_one,mul_one] + congr 1 + apply Finset.sum_congr rfl + intro I hI + rw [actual_deleted_row] + simp only [twistedProfile,InverseInitialPoissonBridge.heckeIdealCharacter_apply] + change (moebius I:ℂ) * (idealCoeff (deletedBase data) I * idealRowHom u.val I) * + (W ((I.absNorm:ℝ)/H^r)*(((I.absNorm:ℝ)/H^r:ℝ):ℂ)^(-shift sigma freq)) = + (moebius I:ℂ) * (idealCoeff (deletedBase data) I * idealRowHom u.val I) * + (W ((I.absNorm:ℝ)/H^r)*(((I.absNorm:ℝ)/H^r:ℝ):ℂ)^(-shift sigma freq)) + ring + +theorem raw_complete_pool (data:RowData)(H D c b Btree cap:ℝ) + (hH:11) + (twistedProfile W sigma freq) H (Real.logb H (D/(j.absNorm:ℝ))) 0 u.val:=by + refine ⟨completeCutoff_tree _ _ _ _,?_⟩ + intro j hj u sigma freq + have hn:= (excluded_divisor_norm data j hj).1 + have hH0:0HeckeFamily.O + +private theorem admissible_one : Admissible (1:Ideal O):=by + refine ⟨one_ne_zero,squarefree_one,?_⟩ + simp only [normalizedFactors_one,Multiset.notMem_zero,false_implies,forall_const] + +theorem input_generator_one (F:Finset (Ideal O))(hF:∀I∈F,Admissible I) + (η:O→*ℂ)(H:Finset (primePool F)→ℂ)(u:O): + letI:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance; + inputConjugateRow (poolPrimary F) (poolPrimary_good F hF) Finset.univ η + (primaryGenerator (1:Ideal O)) 1 1 H u= + inputConjugateRow (poolPrimary F) (poolPrimary_good F hF) Finset.univ η 1 1 1 H u:=by + let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + rw [initial_input_row (poolPrimary F) (poolPrimary_good F hF), + initial_input_row (poolPrimary F) (poolPrimary_good F hF)] + unfold supportConjugateSum + apply Finset.sum_congr rfl + intro A hA + have he:(fun i:primePool F=>Ideal.span {poolPrimary F i})=(fun i=>i.val):= + funext (poolPrimary_span F hF) + have hm:rowCoprimeMask (fun i:primePool F=>Ideal.span {poolPrimary F i}) A + (primaryGenerator (1:Ideal O))=1:=by + rw [he] + exact selected_mask F 1 admissible_one A isCoprime_one_right + have ho:rowCoprimeMask (fun i:primePool F=>Ideal.span {poolPrimary F i}) A 1=1:=by + simp [rowCoprimeMask,Ideal.IsPrime.one_notMem] + simp only [hm,ho] + +theorem complete_pool_selector (E:Finset (Ideal O))(hE:∀P∈E,Prime P) + (Dpool:ℕ)(hbad:fixedBadPrimes⊆E)(W:ℝ→ℂ)(b Z r:ℝ) + (hZ:0(mem_outsideIdealsUpTo.mp (Finset.mem_filter.mp hI).1).2.2) A + have hN:((∏i∈A,i.val).absNorm:ℝ)≤(Dpool:ℝ):= + ((div_le_iff₀ (Real.rpow_pos_of_pos hZ r)).mp (hW _ hw)).trans hbudget + have hmem:(∏i∈A,i.val)∈F:=by + apply Finset.mem_filter.mpr + refine ⟨mem_outsideIdealsUpTo.mpr ⟨?_,?_,hout⟩,hprod.2.1⟩ + · exact Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hprod.1) + · exact_mod_cast hN + exact ite_eq_left hmem + +theorem original_complete_star_input + (E:Finset (Ideal O))(hE:∀P∈E,Prime P)(Dpool:ℕ)(hbad:fixedBadPrimes⊆E) + (η:Ideal O→*ℂ)(W:ℝ→ℂ)(b Z r:ℝ)(hZ:0by rw [poolPrimary_span F hF i];infer_instance; + star (originalTotalPolynomial F 1 η (fun _=>1) W Z r 0 u)= + ((Z^(-r/2):ℝ):ℂ)*inputConjugateRow (poolPrimary F) (poolPrimary_good F hF) + Finset.univ (elementCharacter (conjugateIdealCharacter η)) 1 1 1 + (initialTest (poolPrimary F) (fun _=>1) (fun x=>star (W x)) Z r) u:=by + intro F hF + let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + have he:=selected_conjugate_row F hF 1 admissible_one (fun _ _=>isCoprime_one_right) + (conjugateIdealCharacter η) (fun I=>star (W ((I.absNorm:ℝ)/Z^r))) u + dsimp only at he + rw [input_generator_one F hF] at he + have hselector:(fun A:Finset (primePool F)=> + if (∏i∈A,i.val)∈F then star (W (((∏i∈A,i.val).absNorm:ℝ)/Z^r)) else 0)= + initialTest (poolPrimary F) (fun _=>1) (fun x=>star (W x)) Z r:=by + funext A + rw [complete_pool_selector E hE Dpool hbad (fun x=>star (W x)) b Z r hZ + (fun x hx=>hW x (by simpa only [star_ne_zero] using hx)) hbudget] + simp only [initialTest,one_mul,InitialMeanSquare.poolPrimary_norm F hF] + rfl + rw [hselector] at he + rw [←he] + unfold originalTotalPolynomial + have hscalar:star ((Z^(-r/2):ℝ):ℂ)=((Z^(-r/2):ℝ):ℂ):=by simp + simp only [add_zero,map_one,mul_one,star_mul,star_sum,hscalar, + conjugateIdealCharacter_apply,heckeIdealCharacter_apply] + rw [mul_comm] + congr 1 + apply Finset.sum_congr rfl + intro I hI + simp only [star_intCast] + ring + +theorem original_complete_child_norm + (E:Finset (Ideal O))(hE:∀P∈E,Prime P)(Dpool:ℕ)(hbad:fixedBadPrimes⊆E) + (η:Ideal O→*ℂ)(W:ℝ→ℂ)(b Z r t:ℝ)(hZ:0by rw [poolPrimary_span F hF i];infer_instance; + ‖originalTotalPolynomial F 1 η (fun _=>1) (InverseMoment.childLogTest W t) Z r 0 u‖^2= + ‖((Z^(-r/2):ℝ):ℂ)*inputConjugateRow (poolPrimary F) (poolPrimary_good F hF) + Finset.univ (elementCharacter (conjugateIdealCharacter η)) 1 1 1 + (initialTest (poolPrimary F) (fun _=>1) + (InverseMoment.childLogTest (fun x=>star (W x)) (-t)) Z r) u‖^2:=by + intro F hF + let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:= + fun i=>by rw [poolPrimary_span F hF i];infer_instance + have hw:∀x,InverseMoment.childLogTest W t x≠0→x≤b:=by + intro x hx + exact hW x ((mul_ne_zero_iff.mp hx).1) + have he:=original_complete_star_input E hE Dpool hbad η + (InverseMoment.childLogTest W t) b Z r hZ hw hbudget u + dsimp only at he + rw [DetectorDictionaryInverseRawConjugateGates.childLogTest_conjugate] at he + have hn:=congrArg (fun z:ℂ=>‖z‖^2) he + simpa only [norm_star] using hn + +end SevenEighths.DetectorDictionaryInverseRawInput + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawInputBound.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawInputBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..03a4dc6efebd835ac563c62d2ee4feedc6cb3e86 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawInputBound.lean @@ -0,0 +1,69 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialTotalEnergy + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap ContDiff +namespace SevenEighths.DetectorDictionaryInverseRawInputBound +open ConcretePrimeRowBridge ActualEisensteinCubic ConcreteTraceCRT CompletedGauss SecondPassArithmetic CanonicalQuadraticSieve CanonicalRowCompletion +open CanonicalCoefficientClass InverseMoment InverseInitialProfile InverseInitialRayAttachment +open InverseInitialQuotientGeometry InverseInitialProfileBounds +local notation "O"=>ActualEisensteinCubic.O + +theorem raw_input_bound + (W:𝓢(ℝ,ℂ))(a b:ℝ)(ha:0by rw [poolPrimary_span F hF i];infer_instance; + let p:=poolPrimary F; + let hg:=poolPrimary_good F hF; + ∀Ψ:O→*ℂ,(∀u,‖Ψ u‖≤1)→FactorsModulo (fixedBaseConductor q) Ψ→ + ∀ (r t : ℝ), (-2 : ℝ) ≤ r → r ≤ 1 - 2 * gap → 2 * r ≤ 3 - 2 * gap → r + 7 * η ≤ 2 → + ‖∑'u:O,Φ (‖eisEmbedding u‖^2/Z)* + (‖((Z^(-r/2):ℝ):ℂ)*inputConjugateRow p hg Finset.univ Ψ 1 1 1 + (initialTest p (fun _=>1) (childLogTest W t) Z r) u‖^2:ℝ)‖≤ + C*Z^(1+15*η+π+eps+loss)*(1+‖t‖)^(2*J) := by + have hB:0≤SchwartzMap.seminorm ℝ 0 0 W:=apply_nonneg _ _ + have hb:∀x,‖W x‖≤SchwartzMap.seminorm ℝ 0 0 W:=fun x=>by + simpa only [pow_zero,one_mul,norm_iteratedFDeriv_zero] using W.le_seminorm ℝ 0 0 x + obtain ⟨degree,Btree,hBtree,hbound⟩:=InverseInitialTotalEnergy.original_input_bound + W a b 1 ha le_rfl hs (W.smooth ⊤) Φ _ hB hb 2 gap eps π η τ loss + (by norm_num) hgap heps hπ hη hηone hηsmall hτ hτsmall hloss 0 + refine ⟨InverseClippingProfiles.momentOrder (4*degree),Btree,hBtree,?_⟩ + intro q hq + obtain ⟨C,Z₀,hC,hZ₀,hbound⟩:=hbound q hq + refine ⟨C,Z₀,hC,hZ₀,?_⟩ + intro Z hZ Dpool hpool F hF + let:∀i:primePool F,(Ideal.span {poolPrimary F i}).IsMaximal:=fun i=>by rw [poolPrimary_span F hF i];infer_instance + intro p hg Ψ hΨ hperiod r t hrlo hr₁ hr₂ hrcap + have hZp:1∅) (fun _=>1) (fun _ _=>0) (by simp) (by simp) (by simp) (by simp) + (fun _=>1) (fun _=>0) (fun _=>1) (fun _=>1) (fun _ _=>0) + (by simp) (by simp) (by simp) (by simp) Ψ hΨ hperiod r 1 r + (by norm_num) (by norm_num) hrlo (by simpa using hp) (by simpa [assignedCenter] using hp) + (by simp [assignedCenter]) (by simpa [assignedCenter] using hr₁) + (by simpa [assignedCenter] using hr₂) (by simpa [assignedCenter] using hrcap) + 1 t le_rfl le_rfl + simp only [Finset.sdiff_self,assignedElement,Finset.prod_empty] at h + have hemark : primeMark (∅:Finset (Fin 0)) (fun _=> (∅:Finset (primePool F))) + (fun _ _=> (0:ℂ))=(fun _=>1) := by + funext A + exact primeMark_empty _ _ A + rw [hemark] at h + simpa only [ + Real.rpow_one,←childLogTest_eq_clipped] using h + +end SevenEighths.DetectorDictionaryInverseRawInputBound + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawRadial.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawRadial.lean new file mode 100644 index 0000000000000000000000000000000000000000..821b365c5b665205028804d88163c33af3d56862 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawRadial.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Inversion.InitialDetectorSource +import OAI.NumberTheory.DirichletL.Inversion.SecondChildWindows + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff +namespace SevenEighths.DetectorDictionaryInverseRawRadial +open HeckeFamily HeckeDyadic HeckeInverseAmplification InverseInitialDetectorSource +open InverseInitialRawDictionary InverseInitialConjugateEnergy CanonicalQuadraticSieve +open ConcreteTraceCRT ActualEisensteinCubic +local notation "O"=>HeckeFamily.O + +theorem exists_raw_radial_majorant : + ∃Φ : 𝓢(ℝ,ℂ),HasCompactSupport (Φ:ℝ→ℂ) ∧ + (∀x,0≤(Φ x).re) ∧ (∀x∈Set.Icc (0:ℝ) 1,Φ x=1) := by + have hsub : Set.Icc (0:ℝ) 1⊆Set.Ioo (-1) 2 := by + intro x hx + constructor <;> linarith [hx.1,hx.2] + obtain ⟨f,hf,_,hs,hone⟩:=exists_contDiff_support_eq_eq_one_iff + (n:=⊤) isOpen_Ioo isClosed_Icc hsub + let v : ℝ→ℂ:=fun x=>((f x)^2:ℝ) + have hv : ContDiff ℝ ∞ v:=Complex.ofRealCLM.contDiff.comp + ((by simpa using hf : ContDiff ℝ ∞ f).pow 2) + have hsupp : Function.support v⊆Set.Icc (-1) 2 := by + intro x hx + have hn : x∈Function.support f := by + intro hz + exact hx (by simp [v,hz]) + rw [hs] at hn + exact ⟨hn.1.le,hn.2.le⟩ + have hvc:=HasCompactSupport.of_support_subset_isCompact isCompact_Icc hsupp + refine ⟨hvc.toSchwartzMap hv,hvc,?_,?_⟩ + · intro x + change 0≤(f x)^2 + positivity + · intro x hx + change (((f x)^2:ℝ):ℂ)=1 + rw [(hone x).mp hx] + norm_num + +private theorem admissible_one : Admissible (1:Ideal O) := by + refine ⟨one_ne_zero,squarefree_one,?_⟩ + simp only [UniqueFactorizationMonoid.normalizedFactors_one,Multiset.notMem_zero,false_implies,forall_const] + +theorem finite_raw_le_initial_smoothed (Φ : 𝓢(ℝ,ℂ)) + (hΦ : ∀x,0≤(Φ x).re) (hone : ∀x∈Set.Icc (0:ℝ) 1,Φ x=1) + (data : RowData) (W : ℝ→ℂ) (b Z r σ t H : ℝ) + (hZ : 01) + (twistedProfile W σ t) Z r 0) := by + let S:=(ConcretePrimeRowBridge.idealsUpTo ⌈Z^r*b⌉₊).filter Supported + let f:=originalTotalPolynomial S 1 (fixedBase data.η data.m data.f) (fun _=>1) + (twistedProfile W σ t) Z r 0 + have hsum : Summable (fun u:O=>radialWeight Φ H u*‖f u‖^2) := + (original_smoothed_overlap_triangle S admissible_one + (fun n hn _=>(Finset.mem_filter.mp hn).2) (fixedBase data.η data.m data.f) + (fun _=>1) (twistedProfile W σ t) hZ r 0 (fun _=>0) Φ (fun x _=>hΦ x) hH).1 + have he (u : NonzeroElement) (hu : u∈rows) : + ‖polynomial (data.character u) true W (Z^r) σ t‖^2= + radialWeight Φ H u.val*‖f u.val‖^2 := by + have hn : ‖eisEmbedding u.val‖^2/H∈Set.Icc (0:ℝ) 1 := by + refine ⟨div_nonneg (sq_nonneg _) hH.le,?_⟩ + apply (div_le_one hH).mpr + rw [eisEmbedding_norm_sq_eq_absNorm_span] + exact hrows u hu + rw [character_eq_initial data u W Z r σ t b hZ hW] + change ‖f u.val‖^2=(Φ (‖eisEmbedding u.val‖^2/H)).re*‖f u.val‖^2 + rw [hone _ hn,Complex.one_re,one_mul] + calc + _=∑u∈rows,radialWeight Φ H u.val*‖f u.val‖^2:=Finset.sum_congr rfl he + _=∑u∈rows.image Subtype.val,radialWeight Φ H u*‖f u‖^2:=by + rw [Finset.sum_image (fun a _ b _ hab=>Subtype.val_injective hab)] + _≤∑'u:O,radialWeight Φ H u*‖f u‖^2:=hsum.sum_le_tsum _ + (fun u _=>mul_nonneg (hΦ _) (sq_nonneg _)) + _= _:=rfl + +end SevenEighths.DetectorDictionaryInverseRawRadial + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawRealRadial.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawRealRadial.lean new file mode 100644 index 0000000000000000000000000000000000000000..624bdf545a5745327ba295cd7005bd10241624ea --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawRealRadial.lean @@ -0,0 +1,56 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawRadial + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap ContDiff +namespace SevenEighths.DetectorDictionaryInverseRawRealRadial +open InverseInitialConjugateEnergy ConcreteTraceCRT +local notation "O"=>HeckeFamily.O + +theorem exists_real_raw_radial_majorant: + ∃Φ:𝓢(ℝ,ℂ),HasCompactSupport (Φ:ℝ→ℂ) ∧ + (∀x,0≤(Φ x).re) ∧ (∀x,(Φ x).im=0) ∧ + (∀x∈Set.Icc (0:ℝ) 1,Φ x=1):=by + have hsub:Set.Icc (0:ℝ) 1⊆Set.Ioo (-1) 2:=by + intro x hx + constructor <;> linarith [hx.1,hx.2] + obtain ⟨f,hf,_,hs,hone⟩:=exists_contDiff_support_eq_eq_one_iff + (n:=⊤) isOpen_Ioo isClosed_Icc hsub + let v:ℝ→ℂ:=fun x=>((f x)^2:ℝ) + have hv:ContDiff ℝ ∞ v:=Complex.ofRealCLM.contDiff.comp + ((by simpa using hf:ContDiff ℝ ∞ f).pow 2) + have hsupp:Function.support v⊆Set.Icc (-1) 2:=by + intro x hx + have hn:x∈Function.support f:=by + intro hz + exact hx (by simp [v,hz]) + rw [hs] at hn + exact ⟨hn.1.le,hn.2.le⟩ + have hvc:=HasCompactSupport.of_support_subset_isCompact isCompact_Icc hsupp + refine ⟨hvc.toSchwartzMap hv,hvc,?_,?_,?_⟩ + · intro x + change 0≤(f x)^2 + positivity + · intro x + exact Complex.ofReal_im _ + · intro x hx + change (((f x)^2:ℝ):ℂ)=1 + rw [(hone x).mp hx] + norm_num + +theorem smoothedEnergy_eq_complex_norm (Φ:𝓢(ℝ,ℂ)) + (hΦ:∀x,0≤(Φ x).re)(hreal:∀x,(Φ x).im=0) + (H:ℝ)(hH:0hreal x) hH, + Complex.norm_real,Real.norm_eq_abs, + abs_of_nonneg (smoothedEnergy_nonneg Φ (fun x _=>hΦ x) hH f)] + +end SevenEighths.DetectorDictionaryInverseRawRealRadial + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawReference.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawReference.lean new file mode 100644 index 0000000000000000000000000000000000000000..ac064b464c5f226ef6acd1fb0e16df59bef33225 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseRawReference.lean @@ -0,0 +1,149 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawInputBound +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawInitialEnergy +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawInput +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawRealRadial +import OAI.NumberTheory.DirichletL.Dictionary.InverseRawCompact + +namespace OAI + +noncomputable section + +open scoped Classical BigOperators SchwartzMap Topology +open Filter +namespace SevenEighths.DetectorDictionaryInverseRawReference +open HeckeFamily HeckeDyadic HeckeInverseAmplification InverseMoment +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge +open CanonicalRowCompletion CanonicalCoefficientClass CanonicalQuadraticSieve +open InverseInitialRawDictionary InverseInitialConjugateEnergy InverseInitialExcludedPeriod +open InverseInitialRayAttachment InverseInitialProfileBounds +open DetectorDictionaryInverseRawInitialGates DetectorDictionaryInverseRawInitialEnergy +open DetectorDictionaryInverseRawInput DetectorDictionaryInverseRawInputBound +open DetectorDictionaryInverseRawConjugateGates DetectorDictionaryInverseRawRealRadial +open DetectorDictionaryInverseRawGeometry IdealMobiusDivisorSum +local notation "O"=>HeckeFamily.O + +theorem raw_reference_large (W:𝓢(ℝ,ℂ))(a b c κ:ℝ)(ha:0by + rw [poolPrimary_span F hF i];infer_instance + have hf:initialFunction data (childLogTest W t) H b Btree 2 D 0 0 j= + originalTotalPolynomial F 1 (idealCoeff (deletedBase data)).toMonoidHom + (fun _=>1) (childLogTest W t) H r 0:=by + unfold initialFunction + dsimp only [F] + rw [hqset] + congr 1 + funext x + simp [twistedProfile,HeckeDyadic.shift] + rw [hf,smoothedEnergy_eq_complex_norm Φ hΦ hreal H hHpos] + have he: (∑'u:O,Φ (‖eisEmbedding u‖^2/H)* + (‖originalTotalPolynomial F 1 (idealCoeff (deletedBase data)).toMonoidHom + (fun _=>1) (childLogTest W t) H r 0 u‖^2:ℝ))= + (∑'u:O,Φ (‖eisEmbedding u‖^2/H)* + (‖((H^(-r/2):ℝ):ℂ)*SecondPassArithmetic.inputConjugateRow + (poolPrimary F) (poolPrimary_good F (InitialMeanSquare.outsideSquarefree_admissible + (reflectionExcludedPrimes (deletedPeriod (basePeriod data))) Dpool + (reflectionExcludedPrimes_bad (deletedPeriod (basePeriod data))))) + Finset.univ (elementCharacter (conjugateIdealCharacter + (idealCoeff (deletedBase data)).toMonoidHom)) 1 1 1 + (initialTest (poolPrimary F) (fun _=>1) (childLogTest Wbar (-t)) H r) u‖^2:ℝ)):=by + apply tsum_congr + intro u + congr 2 + exact original_complete_child_norm (reflectionExcludedPrimes (deletedPeriod (basePeriod data))) + (reflectionExcludedPrimes_prime (deletedPeriod (basePeriod data))) Dpool + (reflectionExcludedPrimes_bad (deletedPeriod (basePeriod data))) _ W b H r t hHpos + (fun x hx=>(hs hx).2) hbcover u + rw [he] + simpa only [norm_neg] using hbound + apply hraw.trans + calc + _≤(T.card:ℝ)*∑j∈T,C*H^(1+15*η+π+eps+κ/4)*(1+‖t‖)^(2*J):= + mul_le_mul_of_nonneg_left (Finset.sum_le_sum hterm) (Nat.cast_nonneg _) + _=(T.card:ℝ)^2*C*H^(1+15*η+π+eps+κ/4)*(1+‖t‖)^(2*J):=by + simp only [Finset.sum_const,nsmul_eq_mul];ring + _≤Ctotal*H^(1+15*η+π+eps+κ/4)*(1+‖t‖)^(2*J):=by + dsimp [Ctotal] + gcongr + nlinarith [Nat.cast_nonneg (α:=ℝ) T.card] + _≤(Ctotal*(1+‖t‖)^(2*J))*H*(H*max 1 D)^κ:=by + have he:15*η+π+eps+κ/4≤κ:=by linarith + have hh:=raw_output_budget H D κ (15*η+π+eps+κ/4) hHp.le hκ.le he + rw [show (1+15*η+π+eps+κ/4:ℝ)=1+(15*η+π+eps+κ/4) by ring] + nlinarith [mul_le_mul_of_nonneg_left hh + (show 0≤Ctotal*(1+‖t‖)^(2*J) by dsimp [Ctotal];positivity)] + +theorem raw_reference_moment (W:𝓢(ℝ,ℂ))(a b c κ:ℝ)(ha:0by positivity)) hm 2) hA + _= _:=by simp only [mul_pow,←pow_mul,Nat.mul_comm];ring + +theorem raw_pair_uniform (J : ℕ) : + ∃K : ℕ,∃C : ℝ,0 simp [logTest] + | succ n ih => simp only [logTest,logProfile,ih,pow_succ];ring + +def baseProfile (reverse : Bool) (n : ℕ) (V W : ℝ→ℂ) (R : ℝ) : ℝ→ℂ := + logTest (orientedProfile reverse (ratioProfile V W R)) n + +lemma baseProfile_support (reverse : Bool) (n : ℕ) (V W : ℝ→ℂ) (R : ℝ) : + Function.support (baseProfile reverse n V W R)⊆Function.support W := by + apply (logTest_support _ _).trans + cases reverse + · exact ratioProfile_support V W R + · rw [orientedProfile,ite_eq_left rfl,conjugate_profile_support] + exact ratioProfile_support V W R + +lemma baseProfile_smooth (reverse : Bool) (n : ℕ) (V W : ℝ→ℂ) (R a b : ℝ) + (ha : 0Real.exp (-p.1.1*p.2))).smul + (((Complex.ofRealCLM.contDiff.comp (contDiff_snd : ContDiff ℝ ∞ (fun p : (ℝ×ℝ)×ℝ=>p.2))).pow n).mul + ((hv.comp (by fun_prop)).mul (hw.comp (by fun_prop)))) + +lemma inverseLogFamily_eq (reverse : Bool) (n : ℕ) (V W : ℝ→ℂ) (p : ℝ×ℝ) (x : ℝ) : + inverseLogFamily reverse n V W p x=realInterpolatedLog (baseProfile reverse n V W p.2) p x := by + unfold inverseLogFamily realInterpolatedLog baseProfile + rw [logTest_apply,Real.log_exp] + cases reverse <;> simp [orientedProfile,ratioProfile,map_mul] + +lemma inverseLogFamily_support (reverse : Bool) (n : ℕ) (V W : ℝ→ℂ) (a b : ℝ) + (ha : 0x)).comp (SchwartzMap.derivCLM ℝ ℂ) + +lemma scaleCLM_apply (W : 𝓢(ℝ,ℂ)) (x : ℝ) : scaleCLM W x=scaleProfile W x := by + simp only [scaleCLM,sub_apply,smul_apply, + ContinuousLinearMap.id_apply,ContinuousLinearMap.comp_apply, + SchwartzMap.smulLeftCLM_apply_apply Function.HasTemperateGrowth.id', + SchwartzMap.derivCLM_apply,Complex.real_smul,scaleProfile] + push_cast + ring + +end SevenEighths.DetectorDictionaryInverseUniform + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseUniformSource.lean b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseUniformSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..824e2418071cd1baf41af0856b764ce6e33cf5fc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Dictionary/InverseUniformSource.lean @@ -0,0 +1,76 @@ +import OAI.NumberTheory.DirichletL.Dictionary.InverseUniformTests +import OAI.NumberTheory.DirichletL.Hecke.DetectorInverseFiberCount + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff Topology +open Set + +namespace SevenEighths.DetectorDictionaryInverseUniform +open HeckeInverseAmplification HeckeDyadic HeckeDetectorProfiles HeckeDetectorDyadicProfiles +open HeckeDetectorCoefficientTransfer HeckeDetectorRowwisePolynomial + +lemma positiveAnnular_support_sharp : Function.support positiveAnnular⊆Ioo (1/2) 2 := by + intro x hx + have hx0 : 0≤x := by have := (positiveAnnular_support hx).1; linarith + have he : DyadicTransfer.annularCutoff cutoff x≠0 := by + rwa [←positiveAnnular_eq x hx0] + simpa using HeckeDetectorPartition.annular_support cutoff cutoff_one cutoff_zero x hx0 0 (by simpa using he) + +lemma ratioProfile_zero_of_four_le (R : ℝ) (hR : 4≤R) : + ratioProfile cutoff positiveAnnular R=0 := by + funext x + by_cases hx : positiveAnnular x=0 + · simp [ratioProfile,hx] + · have hs := positiveAnnular_support_sharp hx + have hrx : 2≤R*x := by nlinarith [hs.1] + simp [ratioProfile,cutoff_zero _ hrx] + +lemma inverseDetectorTest_zero_of_four_le (scaled reverse : Bool) (n : ℕ) (R σ t : ℝ) + (hR : 4≤R) : inverseDetectorTest scaled reverse n R σ t=0 := by + have hz : inverseDetectorSchwartz reverse n R σ t=0 := by + ext x + rw [inverseDetectorSchwartz_apply] + simp only [baseProfile,ratioProfile_zero_of_four_le R hR] + cases reverse <;> simp [orientedProfile,twistProfile,HeckeDyadic.shift,logTest_apply] + rw [inverseDetectorTest,hz,map_zero] + +theorem inverseDetectorTest_uniform_all_ratios (S : Finset (ℕ×ℕ)) : + ∃J : ℕ,∃C : ℝ,0inverseSchwartz_operator_uniform + q.2.1 q.2.2.val cutoff positiveAnnular (1/4) (9/4) (by norm_num) + (cutoff.smooth ⊤) positiveAnnular_smooth positiveAnnular_support 4 (sourceOperator q.1) S + let J := (Finset.univ : Finset (Bool×Bool×Fin 3)).sup degree + have hsum : 0≤∑q : Bool×Bool×Fin 3,C q := Finset.sum_nonneg (fun q _=>(hC q).le) + refine ⟨J,1+∑q : Bool×Bool×Fin 3,C q,by linarith,?_⟩ + intro scaled reverse n hn R hR σ hσ t + let q : Bool×Bool×Fin 3 := (scaled,reverse,⟨n,by omega⟩) + have hCq : C q≤1+∑q : Bool×Bool×Fin 3,C q := by + have hh := Finset.single_le_sum (fun q (_ : q∈(Finset.univ : Finset (Bool×Bool×Fin 3)))=>(hC q).le) (Finset.mem_univ q) + linarith + have hdegree : degree q≤J := Finset.le_sup (Finset.mem_univ q) + have he := hb q R hR σ hσ t + change S.sup (schwartzSeminormFamily ℝ ℝ ℂ) (inverseDetectorTest scaled reverse n R σ t)≤_ at he + exact he.trans (mul_le_mul hCq (pow_le_pow_right₀ (by linarith [norm_nonneg t]) hdegree) + (by positivity) (by linarith)) + +end SevenEighths.DetectorDictionaryInverseUniform + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/AffineCuspFourier.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/AffineCuspFourier.lean new file mode 100644 index 0000000000000000000000000000000000000000..24d2a977b5e0c219f6db7ec06dbdf5f2dde0c008 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/AffineCuspFourier.lean @@ -0,0 +1,658 @@ +import OAI.NumberTheory.DirichletL.Reciprocity.RamifiedCuspPhases + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma affineLowerTerm_eq_shifted (q r:Eis) (z:ℂ) (v:ℝ) (hv:0affineLowerTerm q r z v s a d) := by + simp_rw [affineLowerTerm_eq_shifted q r _ v hv s a d ha hq] + exact (shiftedHeightKernel_integrable v hv s _ hs).const_mul _ + +lemma affineLowerTerm_fourier_integral (q r:Eis) (v:ℝ) (hv:0affineLowerTerm q r z v s a (a+3*x)) + (affineLowerTerm_integrable q r v hv s hs a (a+3*x) ha hq) (ninthCuspFrequency h) + rw [←finite_index_period_unfold q hq _ hint] + apply tsum_congr + intro m + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun z=>affineLowerTerm_weighted_translate + h h1 q r a k x m j n ha hprimary hq hr hh hk z v s) + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma affineDenominator_integral_formula (h h1 q r k:Eis) (j n:ℕ) (a:PrimaryLower) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hh:h=q*h1) (hk:3*k=h1+ramifiedAffineParameter j n*a.val) + (v:ℝ) (hv:0∫z in periodDomain, + affineLowerTerm q r z v s a.val d.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))) : + (∑'d:PrimaryCoprimeDenominator a,∫z in periodDomain, + affineLowerTerm q r z v s a.val d.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + (Ideal.absNorm (Ideal.span {q}):ℂ)* + ((v:ℂ)^(2-s)*sourceFourierKernel s (ninthCuspFrequency h*v))* + ((‖eisEmbedding (q*a.val)‖^2:ℝ):ℂ)^(-s)*ramifiedAffineGauss h q r a.val := by + let e:=(cubicResidueElementEquiv a.val (primaryLower_ne_zero a)).trans (primaryDenominatorEquiv a) + have hpair:=e.summable_iff.mpr hsum + change Summable (fun p:CubicUnitResidue a.val×Eis=>∫z in periodDomain, + affineLowerTerm q r z v s a.val (a.val+3*(GaussianShiftedPartition.representative a.val p.1.val+a.val*p.2))* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z)) at hpair + rw [←e.tsum_eq] + change (∑'p:CubicUnitResidue a.val×Eis,∫z in periodDomain, + affineLowerTerm q r z v s a.val (a.val+3*(GaussianShiftedPartition.representative a.val p.1.val+a.val*p.2))* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z))=_ + rw [hpair.tsum_prod] + have hinner (x:CubicUnitResidue a.val) : + (∑'m:Eis,∫z in periodDomain, + affineLowerTerm q r z v s a.val (a.val+3*(GaussianShiftedPartition.representative a.val x.val+a.val*m))* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + (Ideal.absNorm (Ideal.span {q}):ℂ)* + (((v:ℂ)^(2-s)*sourceFourierKernel s (ninthCuspFrequency h*v))* + ((‖eisEmbedding (q*a.val)‖^2:ℝ):ℂ)^(-s)* + ((eisEmbedding (symbol r (a.val+3*GaussianShiftedPartition.representative a.val x.val))* + eisEmbedding (symbol (a.val+3*GaussianShiftedPartition.representative a.val x.val) a.val))* + ShortDraftTrace.breveE (ninthCuspFrequency h* + eisEmbedding (a.val+3*GaussianShiftedPartition.representative a.val x.val)/eisEmbedding (q*a.val)))) := by + rw [affineLowerIntegral_sum_translate h h1 q r a.val k _ j n (primaryLower_ne_zero a) + (primaryLower_primary a) hq hr hh hk v hv s hs, + affineLowerTerm_fourier_integral q r v hv s _ a.val _ (primaryLower_ne_zero a) hq] + simp_rw [hinner] + unfold ramifiedAffineGauss + simp_rw [mul_assoc] + rw [tsum_mul_left,tsum_mul_left,tsum_mul_left,tsum_mul_left] + +lemma affineCuspFrequency_lift (h1:Eis) (j n:ℕ) (a:PrimaryLower) + (hfreq:(3:Eis)∣h1+ramifiedAffineParameter j n) : + ∃k:Eis,3*k=h1+ramifiedAffineParameter j n*a.val := by + have hh:=dvd_add hfreq (a.2.mul_left (ramifiedAffineParameter j n)) + have hd:(3:Eis)∣h1+ramifiedAffineParameter j n*a.val:=by + convert hh using 1 ;ring + obtain ⟨k,hk⟩:=hd + exact ⟨k,hk.symm⟩ + +lemma affineCusp_norm_factor (q:Eis) (s:ℂ) (a:PrimaryLower) : + ((‖eisEmbedding (q*a.val)‖^2:ℝ):ℂ)^(-s)= + ((‖eisEmbedding q‖^2:ℝ):ℂ)^(-s)*((‖eisEmbedding a.val‖^2:ℝ):ℂ)^(-s) := by + rw [map_mul,norm_mul,mul_pow,Complex.ofReal_mul, + Complex.mul_cpow_ofReal_nonneg (sq_nonneg _) (sq_nonneg _)] + +theorem affineCusp_branch_fourier (h h1 q r:Eis) (j n:ℕ) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hh:h=q*h1) (hfreq:(3:Eis)∣h1+ramifiedAffineParameter j n) + (v:ℝ) (hv:0∫z in periodDomain, + affineLowerTerm q r z v s p.1.val p.2.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))) : + (∑'p:UnitLowerData,∫z in periodDomain, + affineLowerTerm q r z v s p.1.val p.2.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + (Ideal.absNorm (Ideal.span {q}):ℂ)*((‖eisEmbedding q‖^2:ℝ):ℂ)^(-s)* + ((v:ℂ)^(2-s)*sourceFourierKernel s (ninthCuspFrequency h*v))* + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding q)* + unramifiedCubicGaussSeries s (3*r^2*h1) := by + rw [hsum.tsum_sigma] + have ha (a:PrimaryLower): + (∑'d:PrimaryCoprimeDenominator a,∫z in periodDomain, + affineLowerTerm q r z v s a.val d.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + ((Ideal.absNorm (Ideal.span {q}):ℂ)*((‖eisEmbedding q‖^2:ℝ):ℂ)^(-s)* + ((v:ℂ)^(2-s)*sourceFourierKernel s (ninthCuspFrequency h*v))* + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding q))* + (((‖eisEmbedding a.val‖^2:ℝ):ℂ)^(-s)*cubicUnitGaussSum (3*r^2*h1) a.val) := by + obtain ⟨k,hk⟩:=affineCuspFrequency_lift h1 j n a hfreq + rw [affineDenominator_integral_formula h h1 q r k j n a hq hr hh hk v hv s hs + (hsum.sigma_factor a),ramifiedAffineGauss_eq_unramified h h1 q r a.val k j n + (primaryLower_ne_zero a) (primaryLower_primary a) hq hr hh hk, + affineCusp_norm_factor] + ring + simp_rw [ha] + rw [tsum_mul_left] + congr 1 + rw [←primaryLowerIdealEquiv.symm.tsum_eq,unramifiedCubicGaussSeries] + apply tsum_congr + intro I + change ((‖eisEmbedding (CompletedGauss.primaryGenerator I.val)‖^2:ℝ):ℂ)^(-s)* + cubicUnitGaussSum (3*r^2*h1) (CompletedGauss.primaryGenerator I.val)=_ + rw [eisEmbedding_norm_sq_eq_absNorm_span,(CompletedGauss.primaryGenerator_spec I.val I.2).1, + Complex.ofReal_natCast] + +end + +section +open MeasureTheory Filter +open scoped BigOperators Classical MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma hasSum_diagonal_unit_integrals (u t:Eisˣ) (v:ℝ) (hv:0∫z in periodDomain, + affineLowerTerm (t:Eis) ((↑u⁻¹:Eis)^2*(t:Eis)) z v s p.1.val p.2.val.val* + ShortDraftTrace.breveE (-freq*z)) + (∫z in periodDomain,eisenstein (integralComplexMatrix (unitCuspDiagonal u)* + integralComplexMatrix (lowerCuspMatrix (t:Eis))*upperSection z v hv) s* + ShortDraftTrace.breveE (-freq*z)) := by + have hh:=(diagonalUnitCuspIndex u t).hasSum_iff.mpr + (hasSum_integral_fixed_left_Eisenstein + (integralComplexMatrix (unitCuspDiagonal u)*integralComplexMatrix (lowerCuspMatrix (t:Eis))) + v hv s freq hs) + apply hh.congr_fun + intro p + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun z=>by dsimp only; rw [diagonal_unit_summand]) + +theorem diagonal_unit_eisenstein_fourier (u t:Eisˣ) (j:ℕ) (h h1:Eis) + (hr:(↑u⁻¹:Eis)^2*(t:Eis)=omega^j ∨ (↑u⁻¹:Eis)^2*(t:Eis)=-(omega^j)) + (hh:h=(t:Eis)*h1) (hfreq:(3:Eis)∣h1+ramifiedAffineParameter j 0) + (v:ℝ) (hv:0 ActualEisensteinCubic.O + +theorem quotient_weighted_period_unfold (q:Eis) (hq:q≠0) + (ψ:(Eis⧸Ideal.span {q})→ℂ) (f:ℂ→ℂ) (hf:Integrable f) : + (∑'n:Eis,ψ (Ideal.Quotient.mk (Ideal.span {q}) n)* + ∫z in periodDomain,f (z+3*eisEmbedding n/eisEmbedding q))= + (∑'r:Eis⧸Ideal.span {q},ψ r)*(∫z:ℂ,f z) := by + let : Finite (Eis⧸Ideal.span {q}):=finite_quotient_span hq + let : Fintype (Eis⧸Ideal.span {q}):=Fintype.ofFinite _ + let I:Eis→ℂ:=fun n=>∫z in periodDomain,f (z+3*eisEmbedding n/eisEmbedding q) + have hs:Summable (fun n:Eis=>ψ (Ideal.Quotient.mk (Ideal.span {q}) n)*I n):=by + apply (((finite_index_period_integrals_summable q hq f hf).norm).mul_left ‖ψ‖).of_norm_bounded + intro n + rw [norm_mul] + exact mul_le_mul_of_nonneg_right (norm_le_pi_norm ψ _) (norm_nonneg _) + have hinner (r:Eis⧸Ideal.span {q}): + (∑'n:((Ideal.Quotient.mk (Ideal.span {q})) ⁻¹' {r}), + ψ (Ideal.Quotient.mk (Ideal.span {q}) n.val)*I n.val)=ψ r*(∫z:ℂ,f z) := by + have heval (n:((Ideal.Quotient.mk (Ideal.span {q})) ⁻¹' {r})): + Ideal.Quotient.mk (Ideal.span {q}) n.val=r:=n.2 + simp_rw [heval] + rw [tsum_mul_left,GaussianFiberEquiv.fiber_tsum q hq r (GaussianShiftedPartition.representative q r) + (GaussianShiftedPartition.representative_spec q r)] + congr 1 + let b:=3*eisEmbedding (GaussianShiftedPartition.representative q r)/eisEmbedding q + have he (n:Eis) (z:ℂ): + z+3*eisEmbedding (GaussianShiftedPartition.representative q r+q*n)/eisEmbedding q= + (z+3*eisEmbedding n)+b:=by + dsimp [b] + simp only [map_add,map_mul] + field_simp [eisEmbedding_ne_zero hq] + ;ring + change (∑'n:Eis,∫z in periodDomain,f (z+3*eisEmbedding + (GaussianShiftedPartition.representative q r+q*n)/eisEmbedding q))=_ + simp_rw [he] + rw [←integral_eq_period_integrals (fun z=>f (z+b)) (hf.comp_add_right b)] + exact integral_add_right_eq_self f b + rw [←(hs.hasSum.tsum_fiberwise (Ideal.Quotient.mk (Ideal.span {q})) ).tsum_eq] + change (∑'r:Eis⧸Ideal.span {q},∑'n:((Ideal.Quotient.mk (Ideal.span {q})) ⁻¹' {r}), + ψ (Ideal.Quotient.mk (Ideal.span {q}) n.val)*I n.val)=_ + simp_rw [hinner] + exact tsum_mul_right + +theorem character_weighted_period_unfold (q:Eis) (hq:q≠0) + (ψ:AddChar (Eis⧸Ideal.span {q}) ℂ) (f:ℂ→ℂ) (hf:Integrable f) : + (∑'n:Eis,ψ (Ideal.Quotient.mk (Ideal.span {q}) n)* + ∫z in periodDomain,f (z+3*eisEmbedding n/eisEmbedding q))= + if ψ=1 then (Ideal.absNorm (Ideal.span {q}):ℂ)*(∫z:ℂ,f z) else 0 := by + let : Finite (Eis⧸Ideal.span {q}):=finite_quotient_span hq + let : Fintype (Eis⧸Ideal.span {q}):=Fintype.ofFinite _ + rw [quotient_weighted_period_unfold q hq ψ f hf,tsum_fintype] + split_ifs with hψ + · rw [AddChar.sum_eq_card_of_eq_one hψ] + congr 1 + change (Fintype.card (Eis⧸Ideal.span {q}):ℂ)=(Nat.card (Eis⧸Ideal.span {q}):ℂ) + rw [Nat.card_eq_fintype_card] + · rw [AddChar.sum_eq_zero_of_ne_one hψ,zero_mul] + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +def affinePeriodChar (q:Eis) (hq:q≠0) (ell:Eis) : AddChar (Eis⧸Ideal.span {q}) ℂ := + (eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates q hq).mulShift + (Ideal.Quotient.mk (Ideal.span {q}) ell) + +lemma affinePeriodChar_mk (q:Eis) (hq:q≠0) (ell x:Eis) : + affinePeriodChar q hq ell (Ideal.Quotient.mk (Ideal.span {q}) x)= + ShortDraftTrace.breveE (eisEmbedding (ell*x)/(eisEmbedding q*eisLam)) := by + simp only [affinePeriodChar,AddChar.mulShift_apply,←map_mul,eisTraceModChar, + IdealGaussCRT.traceModChar_mk] + +lemma affinePeriodChar_eq_one (q:Eis) (hq:q≠0) (ell:Eis) : + affinePeriodChar q hq ell=1 ↔ q∣ell := by + constructor + · intro h + by_contra hd + have hz:Ideal.Quotient.mk (Ideal.span {q}) ell≠0:=by + intro he + exact hd (Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp he)) + exact GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive q hq hz h + · intro hd + have hz:Ideal.Quotient.mk (Ideal.span {q}) ell=0:= + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr hd) + simp [affinePeriodChar,hz] + +lemma affineCusp_general_weighted_translate (h q r a ell x m:Eis) (j n:ℕ) + (hprimary:lambda^2∣a-1) (hq:q≠0) + (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hell:3*ell=h+ramifiedAffineParameter j n*q*a) + (z:ℂ) (v:ℝ) (s:ℂ) : + affineLowerTerm q r z v s a (a+3*(x+a*m))*ShortDraftTrace.breveE (-ninthCuspFrequency h*z)= + affinePeriodChar q hq ell (Ideal.Quotient.mk (Ideal.span {q}) m)* + (affineLowerTerm q r (z+3*eisEmbedding m/eisEmbedding q) v s a (a+3*x)* + ShortDraftTrace.breveE (-ninthCuspFrequency h*(z+3*eisEmbedding m/eisEmbedding q))) := by + let A:=eisEmbedding (ramifiedAffineParameter j n*(a*m))/eisLam/3 + let delta:=3*eisEmbedding m/eisEmbedding q + have hchar:eisEmbedding (symbol r (a+3*(x+a*m)))= + eisEmbedding (symbol r (a+3*x))*ShortDraftTrace.breveE A:=by + have hd:lambda^2∣a+3*x-1:=primary_add_three a x hprimary + have h:=ramified_symbol_primary_shift_signed j n r (a+3*x) (a*m) hr hd + convert h using 1 ; congr 2 ;ring + have hden:symbol (a+3*(x+a*m)) a=symbol (a+3*x) a:= + symbol_congr ⟨3*m,by ring⟩ + have hrow:eisEmbedding (q*a)*z+eisEmbedding (a+3*(x+a*m))= + eisEmbedding (q*a)*(z+delta)+eisEmbedding (a+3*x):=by + dsimp [delta] + simp only [map_add,map_mul,map_ofNat] + field_simp [eisEmbedding_ne_zero hq] + ;ring + have hell':eisEmbedding ell=(eisEmbedding h+eisEmbedding (ramifiedAffineParameter j n)*eisEmbedding q*eisEmbedding a)/3:=by + apply (eq_div_iff (by norm_num : (3:ℂ)≠0)).mpr + have he:=congrArg eisEmbedding hell + simp only [map_mul,map_add,map_ofNat] at he + linear_combination he + have harg:A+ninthCuspFrequency h*delta=eisEmbedding (ell*m)/(eisEmbedding q*eisLam):=by + dsimp [A,delta,ninthCuspFrequency,cuspFrequency] + simp only [map_mul] + rw [hell'] + field_simp [eisEmbedding_ne_zero hq,eisLam_ne_zero] + ;ring + have hphase:ShortDraftTrace.breveE A*ShortDraftTrace.breveE (-ninthCuspFrequency h*z)= + affinePeriodChar q hq ell (Ideal.Quotient.mk (Ideal.span {q}) m)* + ShortDraftTrace.breveE (-ninthCuspFrequency h*(z+delta)):=by + rw [affinePeriodChar_mk,←harg,←AddChar.map_add_eq_mul,←AddChar.map_add_eq_mul] + congr 1 + ring + unfold affineLowerTerm + rw [hchar,hden,hrow] + change _=affinePeriodChar q hq ell (Ideal.Quotient.mk (Ideal.span {q}) m)* + ((eisEmbedding (symbol r (a+3*x))*eisEmbedding (symbol (a+3*x) a))* + ((v/(‖eisEmbedding (q*a)*(z+delta)+eisEmbedding (a+3*x)‖^2+ + ‖eisEmbedding (q*a)‖^2*v^2):ℝ):ℂ)^s* + ShortDraftTrace.breveE (-ninthCuspFrequency h*(z+delta))) + calc + _ = ((eisEmbedding (symbol r (a+3*x))*eisEmbedding (symbol (a+3*x) a))* + ((v/(‖eisEmbedding (q*a)*(z+delta)+eisEmbedding (a+3*x)‖^2+ + ‖eisEmbedding (q*a)‖^2*v^2):ℝ):ℂ)^s)* + (ShortDraftTrace.breveE A*ShortDraftTrace.breveE (-ninthCuspFrequency h*z)) := by ring + _ = _ := by rw [hphase];ring + +lemma affineCusp_masked_inner (h q r a ell x:Eis) (j n:ℕ) + (ha:a≠0) (hprimary:lambda^2∣a-1) (hq:q≠0) + (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hell:3*ell=h+ramifiedAffineParameter j n*q*a) + (v:ℝ) (hv:0affineLowerTerm q r z v s a (a+3*x)) + (affineLowerTerm_integrable q r v hv s hs a (a+3*x) ha hq) (ninthCuspFrequency h) + simp_rw [affineCusp_general_weighted_translate h q r a ell x _ j n hprimary hq hr hell, + integral_const_mul] + rw [character_weighted_period_unfold q hq (affinePeriodChar q hq ell) _ hint] + simp only [affinePeriodChar_eq_one] + +end + +open Filter MeasureTheory +open scoped BigOperators Classical MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma affineDenominator_zero (h h1 q r:Eis) (j n:ℕ) (a:PrimaryLower) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hh:h=q*h1) (hbase:(3:Eis)∣h+ramifiedAffineParameter j n*q) + (hfreq:¬(3:Eis)∣h1+ramifiedAffineParameter j n) + (v:ℝ) (hv:0∫z in periodDomain, + affineLowerTerm q r z v s a.val d.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))) : + (∑'d:PrimaryCoprimeDenominator a,∫z in periodDomain, + affineLowerTerm q r z v s a.val d.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))=0 := by + have hdiv:(3:Eis)∣h+ramifiedAffineParameter j n*q*a.val:=by + have ht:=dvd_add hbase (a.2.mul_left (ramifiedAffineParameter j n*q)) + convert ht using 1 ;ring + obtain ⟨ell,hell⟩:=hdiv + have hell':3*ell=h+ramifiedAffineParameter j n*q*a.val:=hell.symm + have hne:¬q∣ell:=by + rintro ⟨b,hb⟩ + have he:q*(3*b)=q*(h1+ramifiedAffineParameter j n*a.val):=by + rw [hb,hh] at hell' + linear_combination hell' + have hc:=mul_left_cancel₀ hq he + have ht:(3:Eis)∣h1+ramifiedAffineParameter j n*a.val:=⟨b,hc.symm⟩ + apply hfreq + have hh:=dvd_sub ht (a.2.mul_left (ramifiedAffineParameter j n)) + convert hh using 1 ;ring + let e:=(cubicResidueElementEquiv a.val (primaryLower_ne_zero a)).trans (primaryDenominatorEquiv a) + have hpair:=e.summable_iff.mpr hsum + change Summable (fun p:CubicUnitResidue a.val×Eis=>∫z in periodDomain, + affineLowerTerm q r z v s a.val (a.val+3*(GaussianShiftedPartition.representative a.val p.1.val+a.val*p.2))* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z)) at hpair + rw [←e.tsum_eq] + change (∑'p:CubicUnitResidue a.val×Eis,∫z in periodDomain, + affineLowerTerm q r z v s a.val (a.val+3*(GaussianShiftedPartition.representative a.val p.1.val+a.val*p.2))* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z))=_ + rw [hpair.tsum_prod] + have hinner (x:CubicUnitResidue a.val): + (∑'m:Eis,∫z in periodDomain, + affineLowerTerm q r z v s a.val (a.val+3*(GaussianShiftedPartition.representative a.val x.val+a.val*m))* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z))=0:=by + rw [affineCusp_masked_inner h q r a.val ell _ j n (primaryLower_ne_zero a) + (primaryLower_primary a) hq hr hell' v hv s hs,ite_eq_right hne] + simp only [hinner,tsum_zero] + +theorem affineCusp_branch_fourier_masked (h h1 q r:Eis) (j n:ℕ) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hh:h=q*h1) (hbase:(3:Eis)∣h+ramifiedAffineParameter j n*q) + (v:ℝ) (hv:0∫z in periodDomain, + affineLowerTerm q r z v s p.1.val p.2.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))) : + (∑'p:UnitLowerData,∫z in periodDomain, + affineLowerTerm q r z v s p.1.val p.2.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + if (3:Eis)∣h1+ramifiedAffineParameter j n then + (Ideal.absNorm (Ideal.span {q}):ℂ)*((‖eisEmbedding q‖^2:ℝ):ℂ)^(-s)* + ((v:ℂ)^(2-s)*sourceFourierKernel s (ninthCuspFrequency h*v))* + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding q)* + unramifiedCubicGaussSeries s (3*r^2*h1) else 0 := by + split_ifs with hfreq + · exact affineCusp_branch_fourier h h1 q r j n hq hr hh hfreq v hv s hs hsum + · rw [hsum.tsum_sigma] + simp only [affineDenominator_zero h h1 q r j n _ hq hr hh hbase hfreq v hv s hs + (hsum.sigma_factor _),tsum_zero] + +theorem diagonal_once_eisenstein_fourier (u t:Eisˣ) (j:Fin 3→ℕ) (h:Eis) (h1:Fin 3→Eis) + (hr:∀l,(↑u⁻¹:Eis)^2*(onceCuspScale t*omega^l.val)=omega^(j l)*ramifiedTraceLambda ∨ + (↑u⁻¹:Eis)^2*(onceCuspScale t*omega^l.val)=-(omega^(j l)*ramifiedTraceLambda)) + (hh:∀l,h=(onceCuspScale t*omega^l.val)*h1 l) + (hbase:∀l,(3:Eis)∣h+ramifiedAffineParameter (j l) 1*(onceCuspScale t*omega^l.val)) + (v:ℝ) (hv:0 ActualEisensteinCubic.O + +lemma ramified_omega_relation : omega^2+omega+1=(0:Eis) := by + apply eisEmbedding_injective + simp only [map_add,map_pow,map_one,map_zero,eisEmbedding_omega_actual] + exact EisensteinEmbedding.omega3_sq + +def lowerCuspMatrix (t : Eis) : SL(2,Eis) := + ⟨!![1,0;t,1],by simp [Matrix.det_fin_two]⟩ + +def ramifiedParabolic (t x : Eis) : levelThree := by + let M : SL(2,Eis) := ⟨!![1-3*t*x,3*x;-3*t^2*x,1+3*t*x],by + rw [Matrix.det_fin_two] + change (1-3*t*x)*(1+3*t*x)-(3*x)*(-3*t^2*x)=1 + ring⟩ + refine ⟨M,levelThree_of_entries M ?_⟩ + intro i j + fin_cases i <;> fin_cases j + · exact ⟨-t*x,by change 1-3*t*x-1=3*(-t*x);ring⟩ + · exact ⟨x,by change 3*x-0=3*x;ring⟩ + · exact ⟨-t^2*x,by change -3*t^2*x-0=3*(-t^2*x);ring⟩ + · exact ⟨t*x,by change 1+3*t*x-1=3*(t*x);ring⟩ + +lemma ramifiedParabolic_mul_lower (t x : Eis) : + (ramifiedParabolic t x : SL(2,Eis))*lowerCuspMatrix t= + lowerCuspMatrix t*(upperTranslation x : SL(2,Eis)) := by + apply Subtype.ext + change (ramifiedParabolic t x : Matrix (Fin 2) (Fin 2) Eis) * + (lowerCuspMatrix t : Matrix (Fin 2) (Fin 2) Eis) = + (lowerCuspMatrix t : Matrix (Fin 2) (Fin 2) Eis) * + (upperTranslation x : Matrix (Fin 2) (Fin 2) Eis) + funext i j + fin_cases i <;> fin_cases j <;> + simp [ramifiedParabolic,lowerCuspMatrix,upperTranslation,Matrix.mul_apply,Fin.sum_univ_two] <;> ring + +lemma ramifiedParabolic_character (t x : Eis) : + complexCharacter (ramifiedParabolic t x)= + eisEmbedding (symbol (-t) (1-3*t*x)) := by + simp only [complexCharacter,MonoidHom.comp_apply,character,ramifiedParabolic] + apply congrArg eisEmbedding + apply symbol_congr + refine ⟨t,?_⟩ + change (-3*t^2*x)-(-t)=(1-3*t*x)*t + ring + +lemma ramifiedParabolic_omega_value (A B : ℤ) : + complexCharacter (ramifiedParabolic omega (ActualEisensteinCoordinates.eval A B))= + eisEmbedding (cubicExp (A+B)) := by + rw [ramifiedParabolic_character] + have hd : 1-3*omega*ActualEisensteinCoordinates.eval A B=primaryCoord B (B-A) := by + rw [primaryCoord_eq] + change 1-3*omega*((A:Eis)+(B:Eis)*omega)=_ + push_cast + linear_combination -3*(B:Eis)*ramified_omega_relation + rw [hd,symbol_neg_numerator _ _ (primaryCoord_primary _ _), + symbol_omega_eq_linearRay _ (primaryCoord_primary _ _),linearRay_primaryCoord] + congr 2 + ring + +lemma ramifiedParabolic_omega_sq_value (A B : ℤ) : + complexCharacter (ramifiedParabolic (omega^2) (ActualEisensteinCoordinates.eval A B))= + eisEmbedding (cubicExp (-(A+B))) := by + rw [ramifiedParabolic_character] + have hd : 1-3*omega^2*ActualEisensteinCoordinates.eval A B=primaryCoord (A-B) A := by + rw [primaryCoord_eq] + change 1-3*omega^2*((A:Eis)+(B:Eis)*omega)=_ + push_cast + linear_combination -3*((A:Eis)+(B:Eis)*omega-(B:Eis))*ramified_omega_relation + rw [hd,symbol_neg_numerator _ _ (primaryCoord_primary _ _), + symbol_pow_numerator _ _ (primaryCoord_primary _ _) 2, + symbol_omega_eq_linearRay _ (primaryCoord_primary _ _),linearRay_primaryCoord] + have he : cubicExp (2*((A-B)*2+(-1)*A))=cubicExp (-(A+B)) := by + apply cubicExp_eq_of_dvd_sub + exact ⟨A-B,by ring⟩ + have hs : cubicExp ((A-B)*2+(-1)*A)^2=cubicExp (2*((A-B)*2+(-1)*A)) := by + rw [pow_two,←cubicExp_add] + congr 1 + ring + convert congrArg eisEmbedding (hs.trans he) using 1 ; congr 2 ; ring_nf + +def ramifiedSourceFunction (t : Eis) (w : HyperbolicSpace) : ℂ := + cubicSourceResidualFunction (integralComplexMatrix (lowerCuspMatrix t) • w) + +lemma ramifiedSourceFunction_continuous (t : Eis) : Continuous (ramifiedSourceFunction t) := + cubicSourceResidualFunction_continuous.comp (continuous_const_smul _) + +lemma ramifiedSourceFunction_translate (t x : Eis) (w : HyperbolicSpace) : + ramifiedSourceFunction t (complexMatrix (upperTranslation x) • w)= + eisEmbedding (symbol (-t) (1-3*t*x))*ramifiedSourceFunction t w := by + have he := cubicSourceResidualFunction_automorphy + (sourceLevelInclusion (ramifiedParabolic t x)) + (integralComplexMatrix (lowerCuspMatrix t) • w) + rw [sourceLevelInclusion_character,ramifiedParabolic_character] at he + change cubicSourceResidualFunction + (integralComplexMatrix (ramifiedParabolic t x : SL(2,Eis)) • + (integralComplexMatrix (lowerCuspMatrix t) • w))=_ at he + rw [←mul_smul,←map_mul,ramifiedParabolic_mul_lower,map_mul,mul_smul] at he + exact he + +lemma ramifiedSourceFunction_omega_translate (A B : ℤ) (w : HyperbolicSpace) : + ramifiedSourceFunction omega + (complexMatrix (upperTranslation (ActualEisensteinCoordinates.eval A B)) • w)= + eisEmbedding (cubicExp (A+B))*ramifiedSourceFunction omega w := by + rw [ramifiedSourceFunction_translate] + rw [←ramifiedParabolic_character,ramifiedParabolic_omega_value] + +lemma ramifiedSourceFunction_omega_sq_translate (A B : ℤ) (w : HyperbolicSpace) : + ramifiedSourceFunction (omega^2) + (complexMatrix (upperTranslation (ActualEisensteinCoordinates.eval A B)) • w)= + eisEmbedding (cubicExp (-(A+B)))*ramifiedSourceFunction (omega^2) w := by + rw [ramifiedSourceFunction_translate] + rw [←ramifiedParabolic_character,ramifiedParabolic_omega_sq_value] + +end + +section +open MeasureTheory Filter +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT CubicRamified +open EisensteinEmbedding (omega3) +local notation "Eis" => ActualEisensteinCubic.O + +lemma embedding_cubicExp (n : ℤ) : + eisEmbedding (cubicExp n)=Complex.exp (2*Real.pi*Complex.I*(n:ℂ)/3) := by + have hw : omega3=Complex.exp (2*Real.pi*Complex.I/3) := by + rw [←TraceLambdaPhase.exp_minus_four_pi_div_three] + apply Complex.exp_eq_exp_iff_exists_int.mpr + exact ⟨-1,by push_cast;ring⟩ + rw [cubicExp,map_pow,eisEmbedding_omega_actual,hw,←Complex.exp_nat_mul] + apply Complex.exp_eq_exp_iff_exists_int.mpr + refine ⟨-(n/3),?_⟩ + have hn : (n%3).toNat=(n%3) := Int.toNat_of_nonneg (Int.emod_nonneg _ (by norm_num)) + have hnc : ((n%3).toNat:ℂ)=((n%3:ℤ):ℂ) := by exact_mod_cast hn + have he : ((n%3:ℤ):ℂ)=(n:ℂ)-3*((n/3:ℤ):ℂ) := by + have he0 : n%3=n-3*(n/3) := by omega + exact_mod_cast he0 + rw [hnc,he] + push_cast + ring + +def ramifiedShift10 : ℂ := eisEmbedding (omega-1)/(9*eisLam) + +def ramifiedShift19 : ℂ := eisEmbedding (-2-omega)/(9*eisLam) + +lemma ramifiedShift10_explicit : ramifiedShift10=-(omega3^2)/9 := by + unfold ramifiedShift10 + apply (div_eq_iff (mul_ne_zero (by norm_num : (9:ℂ)≠0) eisLam_ne_zero)).mpr + rw [map_sub,eisEmbedding_omega_actual,map_one] + change omega3-1=-(omega3^2)/9*(9*(1+2*omega3)) + linear_combination (2*omega3-1)*EisensteinEmbedding.omega3_sq + +lemma ramifiedShift19_explicit : ramifiedShift19=omega3/9 := by + unfold ramifiedShift19 + apply (div_eq_iff (mul_ne_zero (by norm_num : (9:ℂ)≠0) eisLam_ne_zero)).mpr + rw [map_sub,map_neg,map_ofNat,eisEmbedding_omega_actual] + change -2-omega3=omega3/9*(9*(1+2*omega3)) + linear_combination -2*EisensteinEmbedding.omega3_sq + +lemma ramifiedShift10_period (A B : ℤ) : + ShortDraftTrace.breveE (ramifiedShift10*(3*eisEmbedding (ActualEisensteinCoordinates.eval A B)))= + eisEmbedding (cubicExp (A+B)) := by + have he : ramifiedShift10*(3*eisEmbedding (ActualEisensteinCoordinates.eval A B))= + eisEmbedding ((omega-1)*ActualEisensteinCoordinates.eval A B)/eisLam/3 := by + rw [ramifiedShift10,map_mul] + ring + have ht := breveE_real_trace_of_O (3:ℝ) ((omega-1)*ActualEisensteinCoordinates.eval A B) + norm_num only [Complex.ofReal_ofNat] at ht + rw [he,ht] + have hcoords : (ActualEisensteinCoordinates.coords + ((omega-1)*ActualEisensteinCoordinates.eval A B)).2=A-2*B := by + have hw : omega-1=ActualEisensteinCoordinates.eval (-1) 1 := by + simp only [ActualEisensteinCoordinates.eval,Int.cast_neg,Int.cast_one,one_mul] + change omega-1=-1+omega + ring + rw [hw,ActualEisensteinCoordinates.eval_mul,ShortDraftLatticeCount.coords_eval] + ring + rw [hcoords,←embedding_cubicExp] + exact congrArg eisEmbedding (cubicExp_eq_of_dvd_sub ⟨-B,by ring⟩) + +lemma ramifiedShift19_period (A B : ℤ) : + ShortDraftTrace.breveE (ramifiedShift19*(3*eisEmbedding (ActualEisensteinCoordinates.eval A B)))= + eisEmbedding (cubicExp (-(A+B))) := by + have he : ramifiedShift19*(3*eisEmbedding (ActualEisensteinCoordinates.eval A B))= + eisEmbedding ((-2-omega)*ActualEisensteinCoordinates.eval A B)/eisLam/3 := by + rw [ramifiedShift19,map_mul] + ring + have ht := breveE_real_trace_of_O (3:ℝ) ((-2-omega)*ActualEisensteinCoordinates.eval A B) + norm_num only [Complex.ofReal_ofNat] at ht + rw [he,ht] + have hcoords : (ActualEisensteinCoordinates.coords + ((-2-omega)*ActualEisensteinCoordinates.eval A B)).2=-(A+B) := by + have hw : -2-omega=ActualEisensteinCoordinates.eval (-2) (-1) := by + simp only [ActualEisensteinCoordinates.eval,Int.cast_neg,Int.cast_one,Int.cast_ofNat,neg_mul,one_mul] + change -2-omega=-2+-omega + ring + rw [hw,ActualEisensteinCoordinates.eval_mul,ShortDraftLatticeCount.coords_eval] + ring + rw [hcoords,embedding_cubicExp] + +lemma ramifiedSourceFunction_upper_shift10 (x : Eis) (z : ℂ) (v : ℝ) (hv : 0(g:HyperbolicSpace)) + (upperTranslation_section (ActualEisensteinCoordinates.eval A B) z v hv).symm + rw [he,ramifiedSourceFunction_omega_translate] + +lemma ramifiedSourceFunction_upper_shift19 (x : Eis) (z : ℂ) (v : ℝ) (hv : 0(g:HyperbolicSpace)) + (upperTranslation_section (ActualEisensteinCoordinates.eval A B) z v hv).symm + rw [he,ramifiedSourceFunction_omega_sq_translate] + +lemma trace_dephase_periodic (f : ℂ→ℂ) (shift : ℂ) + (hf : ∀ x : Eis,∀z, f (z+3*eisEmbedding x)= + ShortDraftTrace.breveE (shift*(3*eisEmbedding x))*f z) : + ∀x:Eis,∀z,(f (z+3*eisEmbedding x)*ShortDraftTrace.breveE (-shift*(z+3*eisEmbedding x)))= + f z*ShortDraftTrace.breveE (-shift*z) := by + intro x z + rw [hf,mul_add,AddChar.map_add_eq_mul] + have hn : -shift*(3*eisEmbedding x)=-(shift*(3*eisEmbedding x)) := by ring + rw [hn,AddChar.map_neg_eq_inv] + have hne : ShortDraftTrace.breveE (shift*(3*eisEmbedding x))≠0 := + Complex.exp_ne_zero _ + calc + _ = (ShortDraftTrace.breveE (shift*(3*eisEmbedding x))* + (ShortDraftTrace.breveE (shift*(3*eisEmbedding x)))⁻¹)* + (f z*ShortDraftTrace.breveE (-shift*z)) := by ring + _ = _ := by rw [mul_inv_cancel₀ hne,one_mul] + +lemma ramifiedSourceFunction_dephase10_periodic (v : ℝ) (hv : 0 ramifiedSourceFunction omega (upperPoint z v hv)) + ramifiedShift10 (fun x z=>ramifiedSourceFunction_upper_shift10 x z v hv) + +lemma ramifiedSourceFunction_dephase19_periodic (v : ℝ) (hv : 0 ramifiedSourceFunction (omega^2) (upperPoint z v hv)) + ramifiedShift19 (fun x z=>ramifiedSourceFunction_upper_shift19 x z v hv) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups ENNReal + +def arbitraryCuspCompact (M : SL(2,ℂ)) (a b : ℝ) : Set HyperbolicSpace := + (M • ·) '' cuspHeightCompact a b + +lemma arbitraryCuspCompact_isCompact (M : SL(2,ℂ)) (a b : ℝ) (ha : 0 F (integralOrbitProjection globalKubotaKernel (M • w)) := by + have h1 := dominatedComplexL2_ae (by simp : (1:ℝ≥0∞)≠⊤) + (arbitraryCusp_image_restrict_le M a b ha) + (kernelCompactPullbackCLM (arbitraryCuspCompact M a b) + (arbitraryCuspCompact_isCompact M a b ha) F) + have h2 := (Measure.absolutelyContinuous_of_le_smul + (arbitraryCusp_image_restrict_le M a b ha)).ae_eq + (kernelCompactPullbackCLM_ae (arbitraryCuspCompact M a b) + (arbitraryCuspCompact_isCompact M a b ha) F) + exact (Lp.coeFn_compMeasurePreserving _ (arbitraryCusp_smul_measurePreserving M a b)).trans + ((arbitraryCusp_smul_measurePreserving M a b).quasiMeasurePreserving.ae_eq_comp (h1.trans h2)) + +lemma arbitraryCusp_quasiMeasurePreserving (M : SL(2,ℂ)) (a b : ℝ) (ha : 0 integralOrbitProjection globalKubotaKernel (M • w)) + (hyperbolicVolume.restrict (cuspPeriodStrip a b)) + (integralQuotientVolume globalKubotaKernel) := by + have hcompact : Measure.QuasiMeasurePreserving (integralOrbitProjection globalKubotaKernel) + (hyperbolicVolume.restrict (arbitraryCuspCompact M a b)) + (integralQuotientVolume globalKubotaKernel) := + ⟨measurable_integralOrbitProjection _,Measure.absolutelyContinuous_of_le_smul + (kernelCompactMultiplicity_spec _ (arbitraryCuspCompact_isCompact M a b ha))⟩ + have himage : Measure.QuasiMeasurePreserving (integralOrbitProjection globalKubotaKernel) + (hyperbolicVolume.restrict ((M • ·) '' cuspPeriodStrip a b)) + (integralQuotientVolume globalKubotaKernel) := + ⟨hcompact.measurable,((Measure.absolutelyContinuous_of_le_smul + (arbitraryCusp_image_restrict_le M a b ha)).map + (measurable_integralOrbitProjection _)).trans hcompact.absolutelyContinuous⟩ + exact himage.comp (arbitraryCusp_smul_measurePreserving M a b).quasiMeasurePreserving + +def arbitraryCuspQuotientCompact (M : SL(2,ℂ)) (a b : ℝ) : Set KernelQuotient := + integralOrbitProjection globalKubotaKernel '' arbitraryCuspCompact M a b + +lemma arbitraryCuspQuotientCompact_isCompact (M : SL(2,ℂ)) (a b : ℝ) (ha : 0 + Complex.exp (2*Real.pi*Complex.I*((-freq*hyperbolicHorizontal w)+ + starRingEnd ℂ (-freq*hyperbolicHorizontal w)))) + have hh := hyperbolicHorizontal_continuous + fun_prop + +lemma arbitraryCuspWeightedPhase_bound (ρ : BoundedContinuousFunction ℝ ℂ) (freq : ℂ) + (w : HyperbolicSpace) : ‖arbitraryCuspWeightedPhase ρ freq w‖≤‖ρ‖ := by + rw [arbitraryCuspWeightedPhase,norm_mul,breveE_norm,mul_one] + exact ρ.norm_coe_le_norm _ + +lemma arbitraryCuspFourierTest_memLp (a b : ℝ) (ha : 0 star (arbitraryCuspWeightedPhase ρ freq w)) 2 + (hyperbolicVolume.restrict (cuspPeriodStrip a b)) := by + let := cuspPeriodStripFiniteVolume a b ha + apply MemLp.of_bound (arbitraryCuspWeightedPhase_continuous ρ freq).star.aestronglyMeasurable ‖ρ‖ + exact Eventually.of_forall (fun w => by rw [norm_star];exact arbitraryCuspWeightedPhase_bound ρ freq w) + +def arbitraryCuspFourierTestL2 (a b : ℝ) (ha : 0 star (arbitraryCuspWeightedPhase ρ freq w)) + +def arbitraryCuspHeightFourier (M : SL(2,ℂ)) (a b : ℝ) (ha : 0 z*arbitraryCuspWeightedPhase ρ freq w) + (hw.trans (Set.indicator_of_mem (arbitraryCusp_mem_compact M a b ha w hwm) _)) + +def arbitraryCuspHeightFamily (M : SL(2,ℂ)) (a b : ℝ) (ha : 0 (s-4/3)*arbitraryCuspHeightFamily M a b ha ρ freq s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (arbitraryCuspHeightFourier M a b ha ρ freq cubicEisensteinResidue)) := by + have hh := (arbitraryCuspHeightFourier M a b ha ρ freq).continuous.continuousAt.tendsto.comp + (cubicEisensteinResidue_local_limit _ (arbitraryCuspQuotientCompact_isCompact M a b ha)) + simpa only [Function.comp_def,map_smul,smul_eq_mul,arbitraryCuspHeightFourier_restrict, + arbitraryCuspHeightFamily] using hh + +lemma arbitraryCuspHeightFamily_initial (M : SL(2,ℂ)) (a b : ℝ) (ha : 0 + ((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I-4/3) • + kernelLocalCorrectedSeed S hS a b (by linarith) hab + ((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I)) + =ᶠ[𝓝[>] (0:ℝ)] (fun t : ℝ => + ((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I-4/3) • + kernelLocalCorrectedSeed S hS c d (by linarith) hcd + ((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I)) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 simp [] <;> linarith)] + exact tendsto_nhds_unique h1 (h2.congr' he.symm) + +lemma kernelL2_eq_of_compact_restrictions (F G : KernelQuotientL2) + (h : ∀S : Set KernelQuotient, ∀hS : IsCompact S, + kernelMassRestrictionCLM S hS.measurableSet F= + kernelMassRestrictionCLM S hS.measurableSet G) : F=G := by + let S : ℕ→Set KernelQuotient := fun n => {q | kernelQuotientBarrier 2 3 q≤n} + have hS (n : ℕ) : IsCompact (S n) := kernelBarrier_sublevel_isCompact n + have he (n : ℕ) : ∀ᵐq∂integralQuotientVolume globalKubotaKernel, q∈S n → F q=G q := by + have hi := h (S n) (hS n) + have hf := kernelMassRestriction_coe (S n) (hS n).measurableSet F + have hg := kernelMassRestriction_coe (S n) (hS n).measurableSet G + filter_upwards [hf,hg] with q hf hg hq + rw [Set.indicator_of_mem hq] at hf hg + change kernelMassRestrictionCLM (S n) (hS n).measurableSet F q=F q at hf + change kernelMassRestrictionCLM (S n) (hS n).measurableSet G q=G q at hg + rw [hi] at hf + exact hf.symm.trans hg + apply Lp.ext + filter_upwards [ae_all_iff.mpr he] with q hq + obtain ⟨n,hn⟩ := exists_nat_ge (kernelQuotientBarrier 2 3 q) + exact hq n hn + +theorem kernelEisensteinResidueVector_cutoff_independent + (a b c d : ℝ) (ha : 1 c+f q) p=axisLaplacian f p := by + unfold axisLaplacian axisSlice + simp only [deriv_const_add,deriv_const_add'] + +lemma fullCuspProfileField_summable (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) + (p : SpatialCoordinates) (hp : 0

F (rowHeight (fullCuspRow x) p)) := by + simpa only [fullCuspRow_height _ p hp] using + fullCuspProfileSum_summable F hF (upperPoint (spatialHorizontal p) (p 2) hp) + +lemma fullCuspProfileField_add (F G : ℝ→ℝ) (hF : ∀v≤1,F v=0) (hG : ∀v≤1,G v=0) + (p : SpatialCoordinates) (hp : 0

F v+G v) p=fullCuspProfileField F p+fullCuspProfileField G p := + (fullCuspProfileField_summable F hF p hp).tsum_add + (fullCuspProfileField_summable G hG p hp) + +lemma cuspBarrierProfile_laplacian_zero (a b v : ℝ) (ha : 1 (cuspBarrierField a b q:ℂ)) p-(cuspBarrierField a b p:ℂ)= + (cuspBarrierDefectField a b p:ℂ) := by + have hF : ∀v≤1,cuspBarrierProfile a b v=0 := + fun v hv => cuspBarrierProfile_zero a b hab v (hv.trans ha.le) + have hD : ∀v≤1,cuspBarrierDefectProfile a b v=0 := + fun v hv => cuspBarrierDefectProfile_zero a b v hab (hv.trans_lt ha) + have hid : positiveHeightLaplacian (cuspBarrierProfile a b)= + fun v => cuspBarrierDefectProfile a b v+cuspBarrierProfile a b v := by + funext v + rw [cuspBarrierDefectProfile,sub_add_cancel] + have hh := fullCuspProfileField_laplacian _ (cuspBarrierProfile_smooth a b) hF + (fun v hv => cuspBarrierProfile_laplacian_zero a b v ha hab hv) p hp + simp only [cuspBarrierField,Complex.ofReal_add,Complex.ofReal_one,axisLaplacian_const_add] + rw [hh,hid,fullCuspProfileField_add _ _ hD hF p hp] + simp only [cuspBarrierDefectField,Complex.ofReal_add,Complex.ofReal_neg,Complex.ofReal_one] + ring + +def kernelBarrierPotential (a b : ℝ) (q : KernelQuotient) : ℝ := + 1+kernelQuotientBarrierDefect a b q/kernelQuotientBarrier a b q + +lemma kernelBarrierPotential_lower (a b : ℝ) (ha : 1 (1:ℝ))) q≤kernelBarrierPotential a b q := by + let D := kernelQuotientBarrierDefect a b + let K := tsupport D + have hK : IsCompact K := kernelQuotientBarrierDefect_hasCompactSupport a b ha hab + obtain ⟨C,hC⟩ := (kernelQuotientBarrierDefect_hasCompactSupport a b ha hab).exists_bound_of_continuous + (kernelQuotientBarrierDefect_continuous a b ha hab) + refine ⟨K,hK,max C 0,le_max_right _ _,fun q => ?_⟩ + have hphi := kernelQuotientBarrier_one_le a b ha.le hab q + have hpos : 0 (kernelQuotientBarrier a b (kernelEuclideanProjection q):ℂ)) p= + ((kernelQuotientBarrier a b (kernelEuclideanProjection p)+ + kernelQuotientBarrierDefect a b (kernelEuclideanProjection p):ℝ):ℂ) := by + have hf : ∀q,0 (kernelQuotientBarrier a b (kernelEuclideanProjection q):ℂ)) q := + fun q hq => Complex.ofRealCLM.contDiff.contDiffAt.comp q + (cuspBarrier_euclidean_contDiffAt a b ha.le hab q hq) + rw [positiveEuclideanLaplacian_eq_axis _ hf p hp] + have he : ∀q : SpatialCoordinates,0.trans (add_comm _ _) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold + +lemma kernelBarrierPotential_continuous (a b : ℝ) (ha : 1 by + have hq := kernelQuotientBarrier_one_le a b ha.le hab q + linarith) + +lemma kernelBarrierPotential_equation (a b : ℝ) (ha : 1 (kernelQuotientBarrier a b (kernelEuclideanProjection q):ℂ)) p= + ((kernelBarrierPotential a b (kernelEuclideanProjection p)* + kernelQuotientBarrier a b (kernelEuclideanProjection p):ℝ):ℂ) := by + rw [kernelQuotientBarrier_laplace_defect a b ha hab p hp] + apply congrArg Complex.ofReal + have hn : kernelQuotientBarrier a b (kernelEuclideanProjection p)≠0 := by + have hq := kernelQuotientBarrier_one_le a b ha.le hab (kernelEuclideanProjection p) + linarith + rw [kernelBarrierPotential,add_mul,one_mul,div_mul_cancel₀ _ hn] + +lemma kernelSmoothTest_weighted_mass_integrable (V : KernelQuotient→ℝ) (hV : Continuous V) + (f : kernelSmoothTests) : + Integrable (fun q => V q*‖f.1 q‖^2) (integralQuotientVolume globalKubotaKernel) := by + apply (hV.mul (f.2.1.continuous.norm.pow 2)).integrable_of_hasCompactSupport + apply HasCompactSupport.of_support_subset_isCompact f.2.2 + intro q hq + by_contra hn + have hz : f.1 q=0 := image_eq_zero_of_notMem_tsupport hn + apply hq + change V q*‖f.1 q‖^2=0 + rw [hz,norm_zero,zero_pow (by decide : 2≠0),mul_zero] + +lemma kernelBarrierPotential_weighted_integrable (a b : ℝ) (ha : 1 kernelBarrierPotential a b q*‖f.1 q‖^2) + (integralQuotientVolume globalKubotaKernel) := + kernelSmoothTest_weighted_mass_integrable _ (kernelBarrierPotential_continuous a b ha hab) f + +end + +open scoped ComplexConjugate + +theorem ground_state_square_completion (a b : ℝ) (ha : a ≠ 0) (z d : ℂ) : + ‖d‖^2 - b*((2*(conj z*d).re*a - ‖z‖^2*b)/a^2) = + ‖d - (b/a : ℝ)*z‖^2 := by + simp only [Complex.sq_norm, Complex.normSq_apply, Complex.sub_re, Complex.sub_im, + Complex.mul_re, Complex.mul_im, Complex.ofReal_re, Complex.ofReal_im, + Complex.conj_re, Complex.conj_im] + field_simp + ; ring + +theorem ground_state_directional_inequality (a b : ℝ) (ha : a ≠ 0) (z d : ℂ) : + b*((2*(conj z*d).re*a - ‖z‖^2*b)/a^2) ≤ ‖d‖^2 := by + have hh := ground_state_square_completion a b ha z d + nlinarith [sq_nonneg ‖d - (b/a : ℝ)*z‖] + +end CubicEisenstein + +namespace SecondPassArithmetic + +section + +open scoped BigOperators Classical +open MeasureTheory +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProduct firstLogDensity) +open ConcreteTraceCRT (eisEmbedding) +open RayFourExpansion (RayCharacter) + +theorem globalFirstQuantitativeBudget_below_rank (deltaLoss : ℝ) (hδ : 0Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) (_hc : ∀i,ringChar (ActualEisensteinCubic.O⧸Ideal.span {p i})≠2) + (_hinj : Function.Injective (fun i=>Ideal.span {p i})) + (base : ActualEisensteinCubic.O→*ℂ) (bad : Ideal ActualEisensteinCubic.O) (Z η : ℝ) (Ψ : ActualEisensteinCubic.O→*ℂ) (m : ActualEisensteinCubic.O) + (labels : Finset (Ideal ActualEisensteinCubic.O)) (X F Ksrc : ℝ) + (_hstate : CanonicalStateCondition base bad Z η Ψ m labels X F Ksrc) + (pool : Finset ι) (blocks : Finset (GlobalCubeBlock ι)) (side : Bool) + (windows : Fin 7→ℝ→ℂ) (C Cd Ct Γ E oldHeight B M H U A₀ Vmax : ℝ) (N J Ntail : ℕ), + (∀u,‖base u‖≤1) → (∀i,IsCoprime (Ideal.span {p i}) bad) → + 1hstate.coefficient.norm_le hbase u) hb₁ hb₂ + dsimp only + intro a r j hj ray q hq s + let source := globalQuantitativeSource p pool blocks (Ksrc/Z^η) (X/B^3) (Real.exp 1*B) F M H U side + have hk : ∀x∈source,x.source.frequency≠0 := + globalQuantitativeSource_frequency_ne_zero p pool blocks (Ksrc/Z^η) (X/B^3) (Real.exp 1*B) F M H U side + have hb₁' : ∀x∈source,‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2≤Real.exp 1*B := + fun x hx=>hb₁ x.first.block (globalQuantitativeSource_block_mem p pool blocks + (Ksrc/Z^η) (X/B^3) (Real.exp 1*B) F M H U side x hx) + have hb₂' : ∀x∈source,‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2≤Real.exp 1*B := + fun x hx=>hb₂ x.first.block (globalQuantitativeSource_block_mem p pool blocks + (Ksrc/Z^η) (X/B^3) (Real.exp 1*B) F M H U side x hx) + have hs := canonicalStateCondition_cutoff_retained p hp base bad Z η Ψ m labels X F Ksrc hstate + hpbad source side q j hq (if side then a.1 else a.2) r ray B + hZ hZbig hη hηsmall hB0 hprogress hk hb₁' hb₂' (Finset.mem_filter.mp hj).2.le + have hr : fixedDepthRank Z (globalLogRep j 8*Real.exp 1)Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) (_hinj : Function.Injective (fun i=>Ideal.span {p i})) + (_hc : ∀i,ringChar (ActualEisensteinCubic.O⧸Ideal.span {p i})≠2) + (pool : Finset ι) (Q : Finset (ι→₀ℕ)) (labels : Finset (Ideal ActualEisensteinCubic.O)) + (β : Ideal ActualEisensteinCubic.O→(ι→₀ℕ)→ℂ) (Ψ : ActualEisensteinCubic.O→*ℂ) (m : ActualEisensteinCubic.O) (Γ t Ksrc Kcut ell B F lengthScale : ℝ), + 0≤Γ → 0SchwartzMap.norm_le_seminorm ℝ g x + have hgupper : ∀x,g x≠0→x≤M := fun x hx=>(le_abs_self x).trans (hgM x hx) + refine ⟨Cz*Real.exp M*G^2*‖paperRadialFourier rowMajorant 0‖, + Ct*G^2*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) rowMajorant,by positivity,by positivity,?_⟩ + intro ι _ p hp _ hcop hg hinj hc pool Q labels β Ψ m Γ t Ksrc Kcut ell B F lengthScale + hΓ hKsrc hKcut hell hB hF hL hML hΨ hβ hQB hI0 hIF + dsimp only + have hΨt : ∀u,‖normHeightTwist Ψ t u‖≤1 := + fun u=>(normHeightTwist_norm_le Ψ t u).trans (hΨ u) + have hb₁ := fun b hb=>(reopenedCubeFamily_cube_norms p Q B hQB b hb).1 + have hb₂ := fun b hb=>(reopenedCubeFamily_cube_norms p Q B hQB b hb).2 + have ha : ∀b∈reopenedCubeFamily Q,∀D∈(pool\b.support).powerset,∀I∈labels, + ‖reopenedPairCoefficient β b D I‖≤Γ^2 := + fun b hb D hD I hI=>reopenedPairCoefficient_bound Q labels β Γ hΓ hβ b hb D I hI + constructor + · have hz := hzero p hp hcop hg hinj hc pool (reopenedCubeFamily Q) labels + (reopenedPairCoefficient β) (normHeightTwist Ψ t) (normHeightTwist Ψ t) m m + g g rowMajorant (Γ^2) G G ell Ksrc M B F (sq_nonneg Γ) hG hG hell hB hF + hΨt hΨt (reopenedCubeFamily_admissible Q) hb₁ hb₂ hI0 hIF ha hgG hgG hgupper + change ‖canonicalSourceZero p hp hcop hg pool (reopenedCubeFamily Q) labels + (reopenedPairCoefficient β) (normHeightTwist Ψ t) (normHeightTwist Ψ t) m m + g g rowMajorant Ksrc ell‖≤_ at hz + rw [abs_of_pos hKsrc] at hz + exact hz.trans_eq (by ring) + · have ht := htail p hp hinj hcop hg hc pool (reopenedCubeFamily Q) labels + (reopenedPairCoefficient β) (normHeightTwist Ψ t) (normHeightTwist Ψ t) m m + g g rowMajorant (Γ^2) G G M M Ksrc Kcut ell B F lengthScale + (sq_nonneg Γ) hG hG hKsrc hKcut hell hB hF hL hML hML hΨt hΨt + (reopenedCubeFamily_admissible Q) hb₁ hb₂ hI0 hIF ha hgG hgG hgupper hgupper + exact ht.trans_eq (by rw [show M+M=2*M by ring]; ring) + +end +section + +open ActualEisensteinCubic +open FirstPassCubeLabels (columnLog) +open JointLogSeparation (frequencyTwist) + +variable {ι : Type*} [DecidableEq ι] (p : ι→ActualEisensteinCubic.O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + +theorem reopenedCanonicalRow_two_heights (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (β : (ι→₀ℕ)→ℂ) (Ψ : ActualEisensteinCubic.O→*ℂ) (m f z : ActualEisensteinCubic.O) (g : 𝓢(ℝ,ℂ)) + (X oldHeight newHeight : ℝ) (hX : 0frequencyTwist g newHeight (columnLog p X S)) z‖= + ‖reopenedCanonicalRow p hp hcop hg pool Q β Ψ m f + (fun S=>frequencyTwist g (oldHeight+newHeight) (columnLog p X S)) z‖ := by + rw [reopenedCanonicalRow_frequencyTwist_norm p hp hcop hg pool Q β + (normHeightTwist Ψ oldHeight) m f z g X newHeight hX, + normHeightTwist_twice, + reopenedCanonicalRow_frequencyTwist_norm p hp hcop hg pool Q β Ψ m f z g X + (oldHeight+newHeight) hX] + +theorem reopenedCanonicalEnergy_two_heights (pool : Finset ι) (Q : Finset (ι→₀ℕ)) + (labels : Finset (Ideal ActualEisensteinCubic.O)) (β : Ideal ActualEisensteinCubic.O→(ι→₀ℕ)→ℂ) (Ψ : ActualEisensteinCubic.O→*ℂ) (m : ActualEisensteinCubic.O) + (g : 𝓢(ℝ,ℂ)) (X Ksrc oldHeight newHeight : ℝ) (hX : 0frequencyTwist g newHeight (columnLog p X S))) Ksrc).re= + (∑I∈labels,nonzeroRowMajorantSum + (reopenedCanonicalRow p hp hcop hg pool Q (β I) Ψ m + (ConcretePrimeRowBridge.idealGenerator I) + (fun S=>frequencyTwist g (oldHeight+newHeight) (columnLog p X S))) Ksrc).re := by + apply congrArg Complex.re + apply Finset.sum_congr rfl + intro I hI + unfold nonzeroRowMajorantSum + apply tsum_congr + intro z + rw [reopenedCanonicalRow_two_heights p hp hcop hg pool Q (β I) Ψ m _ z g X oldHeight newHeight hX] + +end + +section +open ActualEisensteinCubic +open ConcreteTraceCRT (eisEmbedding) + +theorem CanonicalStateCondition.row_bound + {base : ActualEisensteinCubic.O→*ℂ} {bad : Ideal ActualEisensteinCubic.O} {Z η : ℝ} {Ψ : ActualEisensteinCubic.O→*ℂ} {m : ActualEisensteinCubic.O} + {labels : Finset (Ideal ActualEisensteinCubic.O)} {X F K : ℝ} + (h : CanonicalStateCondition base bad Z η Ψ m labels X F K) + (hZ : 1≤Z) (hη : 0≤η) (hbudget : 3000*η≤(1:ℝ)/40) : + K≤(X*F)*Z^(-((1:ℝ)/40)) := by + have hn := element_norm_ge_one m h.mask_ne_zero + calc + K = K*1 := (mul_one _).symm + _ ≤ K*‖eisEmbedding m‖^2 := + mul_le_mul_of_nonneg_left hn (zero_le_one.trans h.row_ge_one) + _ ≤ _ := h.invariant_reserved hZ hη hbudget + +theorem canonicalFirstZero_normalization (C Γ X F K B Z ε : ℝ) + (hC : 0≤C) (hX : 0Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + +theorem CanonicalStateCondition.terminal_energy + (hc : ∀i,ringChar (ActualEisensteinCubic.O⧸Ideal.span {p i})≠2) + (hinj : Function.Injective (fun i=>Ideal.span {p i})) + (pool : Finset ι) (base : ActualEisensteinCubic.O→*ℂ) (bad : Ideal ActualEisensteinCubic.O) (Z η : ℝ) (Ψ : ActualEisensteinCubic.O→*ℂ) + (m : ActualEisensteinCubic.O) (labels : Finset (Ideal ActualEisensteinCubic.O)) (X F K : ℝ) + (hstate : CanonicalStateCondition base bad Z η Ψ m labels X F K) + (hbase : ∀u,‖base u‖≤1) (hZ : 1(normHeightTwist_norm_le Ψ t u).trans (hstate.coefficient.norm_le hbase u)) m labels V X F K A M + hstate.column_pos hstate.label_ge_one hstate.row_ge_one hKF hM hV hVs + · exact fun I hI=>(hstate.label_bounds I hI).1 + · exact fun I hI=>(hstate.label_bounds I hI).2.2.2 + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/BesselDerivatives.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/BesselDerivatives.lean new file mode 100644 index 0000000000000000000000000000000000000000..af50c22e9e64a030cb9d34de2df6e398cbd81c06 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/BesselDerivatives.lean @@ -0,0 +1,643 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.PrimePowerGaussSums + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +def cubicBesselDensityDeriv (x t : ℝ) : ℝ := -(x/(2*t))*cubicBesselDensity x t + +lemma cubicBesselDensity_hasDerivAt (x t : ℝ) : + HasDerivAt (fun y : ℝ => cubicBesselDensity y t) (cubicBesselDensityDeriv x t) x := by + have he := ((((hasDerivAt_id x).pow 2).div_const (4*t)).const_sub (-t)).exp.const_mul (t^(-(2:ℝ)/3)) + simp only [Pi.pow_apply,id_eq,Nat.cast_ofNat,mul_one] at he + convert he using 1 + · funext y + rfl + · unfold cubicBesselDensityDeriv cubicBesselDensity + ring + +lemma cubic_exp_damping (y : ℝ) : y*Real.exp (-y)≤1 := by + have hy : y≤Real.exp y := by linarith [Real.add_one_le_exp y] + calc + _ ≤ Real.exp y*Real.exp (-y) := mul_le_mul_of_nonneg_right hy (Real.exp_pos _).le + _ = 1 := by rw [←Real.exp_add,add_neg_cancel,Real.exp_zero] + +lemma cubicBesselDensityDeriv_bound (delta x t : ℝ) + (hdelta : 0 t^(-(2:ℝ)/3)*Real.exp (-t/2)) (Set.Ioi 0) volume := by + have hh := integrableOn_rpow_mul_exp_neg_mul_rpow (s:=-(2:ℝ)/3) (p:=1) (b:=1/2) + (by norm_num) (by norm_num) (by norm_num) + apply hh.congr + filter_upwards with t + rw [Real.rpow_one] + congr 1 + congr 1 + ring + +lemma cubicBesselDensityDeriv_integrable (x : ℝ) (hx : 0 ∫t in Set.Ioi (0:ℝ),cubicBesselDensity y t) + (∫t in Set.Ioi (0:ℝ),cubicBesselDensityDeriv x t) x := by + let delta := x/2 + have hdelta : 0 (4/delta)*(t^(-(2:ℝ)/3)*Real.exp (-t/2))) hU + (Eventually.of_forall (fun y => by unfold cubicBesselDensity;fun_prop)) + (cubicBesselDensity_integrable x) + (by unfold cubicBesselDensityDeriv cubicBesselDensity;fun_prop) + hbound (cubicBesselDerivativeMajorant_integrable.const_mul (4/delta)) + (Eventually.of_forall (fun t y _ => cubicBesselDensity_hasDerivAt y t)) + exact h.2 + +def cubicBesselRealDeriv (x : ℝ) : ℝ := + (-(1:ℝ)/12)*(x/2)^(-(4:ℝ)/3)*(∫t in Set.Ioi (0:ℝ),cubicBesselDensity x t)+ + (1/2:ℝ)*(x/2)^(-(1:ℝ)/3)*(∫t in Set.Ioi (0:ℝ),cubicBesselDensityDeriv x t) + +def schlafliBesselK_cubic_derivative (x : ℝ) : ℂ := (cubicBesselRealDeriv x:ℂ) + +lemma schlafliBesselK_cubic_hasDerivAt (x : ℝ) (hx : 0 schlafliBesselK (1/3) y) + (schlafliBesselK_cubic_derivative x) x := by + have hp : HasDerivAt (fun y : ℝ => (1/2:ℝ)*(y/2)^(-(1:ℝ)/3)) + ((-(1:ℝ)/12)*(x/2)^(-(4:ℝ)/3)) x := by + have hh := (((hasDerivAt_id x).div_const 2).rpow_const + (p:=-(1:ℝ)/3) (Or.inl (by positivity : x/2≠0))).const_mul (1/2:ℝ) + convert hh using 1 <;> norm_num ; ring + have hr := hp.mul (cubicBesselIntegral_hasDerivAt x hx) + have hreal : HasDerivAt (fun y : ℝ => (1/2:ℝ)*(y/2)^(-(1:ℝ)/3)* + (∫t in Set.Ioi (0:ℝ),cubicBesselDensity y t)) (cubicBesselRealDeriv x) x := by + exact hr + apply hreal.ofReal_comp.congr_of_eventuallyEq + filter_upwards [Ioi_mem_nhds hx] with y hy + exact schlafliBesselK_cubic_real y hy + +lemma cubicBesselDerivativeMajorant_integral : + (∫t in Set.Ioi (0:ℝ),t^(-(2:ℝ)/3)*Real.exp (-t/2))= + (2:ℝ)^(1/3:ℝ)*Real.Gamma (1/3) := by + have hh := Real.integral_rpow_mul_exp_neg_mul_Ioi + (a := (1/3:ℝ)) (r := (1/2:ℝ)) (by norm_num) (by norm_num) + convert hh using 1 <;> norm_num ; congr 2 ; funext t ; ring_nf + +lemma cubicBesselIntegral_norm_bound (x : ℝ) : + ‖∫t in Set.Ioi (0:ℝ),cubicBesselDensity x t‖≤ + Real.exp (-x/2)*((2:ℝ)^(1/3:ℝ)*Real.Gamma (1/3)) := by + have hpos : 0≤∫t in Set.Ioi (0:ℝ),cubicBesselDensity x t := by + apply integral_nonneg_of_ae + filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + exact cubicBesselDensity_nonneg x t ht.le + rw [Real.norm_of_nonneg hpos] + exact cubicBesselIntegral_upper x + +lemma cubicBesselIntegralDeriv_norm_bound (delta x : ℝ) (hdelta : 0 ActualEisensteinCubic.O + +lemma primeCubicGauss_add_three (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (e:ℕ) (h:Eis):primeCubicGauss p hp hprimary (e+3) h=primeCubicGauss p hp hprimary e h:=by + unfold primeCubicGauss + rw [pow_add,primeCubicMulChar_cube,mul_one] + +lemma cubicUnitGaussSum_prime_cube_shift_pos (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (n:ℕ) (h:Eis): + cubicUnitGaussSum (h*p^3) (p^(n+4))= + (Ideal.absNorm (Ideal.span {p}):ℂ)^3*cubicUnitGaussSum h (p^(n+1)):=by + by_cases hd:p^n∣h + · obtain ⟨r,rfl⟩:=hd + have harg:p^n*r*p^3=p^(n+3)*r:=by rw [pow_add];ring + rw [harg,show n+4=(n+3)+1 by omega, + cubicUnitGaussSum_prime_power_lift p hp hprimary (n+3) r, + cubicUnitGaussSum_prime_power_lift p hp hprimary n r] + rw [show n+3+1=(n+1)+3 by omega,primeCubicGauss_add_three,pow_add] + ring + · have hlow:cubicUnitGaussSum h (p^(n+1))=0:=by + by_contra hh + exact hd (cubicUnitGaussSum_prime_power_support p hp hprimary n h hh) + have hhigh:cubicUnitGaussSum (h*p^3) (p^(n+4))=0:=by + by_contra hh + have hh':cubicUnitGaussSum (h*p^3) (p^((n+3)+1))≠0:=by convert hh using 1 + have hd':p^(n+3)∣h*p^3:=cubicUnitGaussSum_prime_power_support p hp hprimary (n+3) (h*p^3) hh' + have hd'':p^3*p^n∣p^3*h:=by simpa only [pow_add,mul_comm,mul_left_comm,mul_assoc] using hd' + exact hd ((mul_dvd_mul_iff_left (pow_ne_zero 3 hp.ne_zero)).mp hd'') + rw [hhigh,hlow,mul_zero] + +lemma cubicUnitGaussSum_prime_cube_shift (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (k:ℕ) (h:Eis): + cubicUnitGaussSum (h*p^3) (p^(k+3))= + (Ideal.absNorm (Ideal.span {p}):ℂ)^3*cubicUnitGaussSum h (p^k)- + if k=0 then (Ideal.absNorm (Ideal.span {p}):ℂ)^2 else 0:=by + cases k with + | zero=> + rw [Nat.zero_add,cubicUnitGaussSum_frequency_dvd _ _ (pow_ne_zero _ hp.ne_zero) + (dvd_mul_left (p^3) h)] + have he:=cubicUnitGaussSum_prime_power_zero p hp hprimary 2 + norm_num at he ⊢ + rw [he] + ring + | succ n=> + simpa only [show n+1+3=n+4 by omega,Nat.succ_ne_zero,ite_false,sub_zero] using + cubicUnitGaussSum_prime_cube_shift_pos p hp hprimary n h + +private def primeExpansionTerm (p:Eis) (s:ℂ) (h:Eis) (k:ℕ):ℂ:= + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^k*cubicUnitGaussSum h (p^k)* + unramifiedPrimeDeletedSeries p s (h*p^k) + +private lemma primeExpansionTerm_cube_shift (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (s:ℂ) (h:Eis) (k:ℕ): + primeExpansionTerm p s (h*p^3) (k+3)= + (Ideal.absNorm (Ideal.span {p}):ℂ)^3*((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^3* + primeExpansionTerm p s h k- + if k=0 then (Ideal.absNorm (Ideal.span {p}):ℂ)^2* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^3*unramifiedPrimeDeletedSeries p s h else 0:=by + have hv:unramifiedPrimeDeletedSeries p s (h*p^3*p^(k+3))= + unramifiedPrimeDeletedSeries p s (h*p^k):=by + have he:h*p^3*p^(k+3)=(h*p^k*p^3)*p^3:=by rw [pow_add];ring + rw [he,unramifiedPrimeDeletedSeries_cube_shift p hp, + unramifiedPrimeDeletedSeries_cube_shift p hp] + unfold primeExpansionTerm + rw [cubicUnitGaussSum_prime_cube_shift p hp hprimary k h,hv,pow_add] + split_ifs with hk + · subst k + simp only [pow_zero,mul_one,cubicUnitGaussSum_one] + ring + · ring + +theorem unramifiedCubicGaussSeries_cube_step (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (s:ℂ) (hs:2 ActualEisensteinCubic.O + +theorem unramifiedGaussResidue_of_initial_relation (h0 h1 h2:Eis) (A B:ℂ→ℂ) + (hA:AnalyticOnNhd ℂ A {s:ℂ|1cuspWhittakerHeightFactor s (3*h) + let D:Set ℂ:={s|1T h0 s*H h1 s*H h2 s + let g:ℂ→ℂ:=fun s=>A s*T h1 s*H h0 s*H h2 s+B s*T h2 s*H h0 s*H h1 s + have hT (h:Eis):AnalyticOnNhd ℂ (T h) D:=fun s hs=> + translatedCuspFamily_analyticAt_nonreal (3*h) oppositeSource 2 3 + (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne' + have hH (h:Eis):AnalyticOnNhd ℂ (H h) D:=fun s hs=> + cuspWhittakerHeightFactor_analyticAt (3*h) s hs.1 + have hf:AnalyticOnNhd ℂ f D:=fun s hs=>((hT h0 s hs).mul (hH h1 s hs)).mul (hH h2 s hs) + have hg:AnalyticOnNhd ℂ g D:=fun s hs=> + (((hA s hs).mul (hT h1 s hs)).mul (hH h0 s hs)).mul (hH h2 s hs) |>.add + ((((hB s hs).mul (hT h2 s hs)).mul (hH h0 s hs)).mul (hH h1 s hs)) + have hconvex:Convex ℝ D:= + ((convex_Ioi (1:ℝ)).linear_preimage Complex.reCLM.toLinearMap).inter + ((convex_Ioi (0:ℝ)).linear_preimage Complex.imCLM.toLinearMap) + have hstart:(5+Complex.I:ℂ)∈D:=by norm_num [D] + have hopen:IsOpen {s:ℂ|4(s-4/3)*T h s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (R h)):= + translatedCuspFamily_residue_limit (3*h) oppositeSource 2 3 (by norm_num) (by norm_num) + have hl:=(((hlimT h0).mul (hlimH h1)).mul (hlimH h2)).comp upperVertical_tendsto_cubic_punctured + have hr:=((((hAc.tendsto.mono_left nhdsWithin_le_nhds).mul (hlimT h1)).mul (hlimH h0)).mul + (hlimH h2) |>.add ((((hBc.tendsto.mono_left nhdsWithin_le_nhds).mul (hlimT h2)).mul + (hlimH h0)).mul (hlimH h1))).comp upperVertical_tendsto_cubic_punctured + have hcross:R h0*H h1 (4/3)*H h2 (4/3)= + A (4/3)*R h1*H h0 (4/3)*H h2 (4/3)+B (4/3)*R h2*H h0 (4/3)*H h1 (4/3):=by + apply tendsto_nhds_unique_of_eventuallyEq hl hr + filter_upwards [self_mem_nhdsWithin] with t ht + change 0(Ideal.absNorm (Ideal.span {p}):ℂ)^(-z)) s:=by + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + exact Eventually.of_forall fun z=>(differentiableAt_id.neg).const_cpow (Or.inl + (Nat.cast_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr + (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)))) + +lemma gaussPrimeWeight_center (p:Eis) (hp:Prime p): + (Ideal.absNorm (Ideal.span {p}):ℂ)^3* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-(4/3:ℂ)))^3= + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹:=by + have hQ:(Ideal.absNorm (Ideal.span {p}):ℂ)≠0:=Nat.cast_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + rw [←Complex.cpow_nat_mul,←Complex.cpow_natCast _ 3,←Complex.cpow_add _ _ hQ] + convert Complex.cpow_neg_one (Ideal.absNorm (Ideal.span {p}):ℂ) using 1 ;congr 1 ;norm_num + +theorem unramifiedGaussResidue_prime_recurrence (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h): + unramifiedGaussResidue (h*p^3)= + (1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*unramifiedGaussResidue h- + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(4/3:ℂ))*primeCubicGauss p hp hprimary 1 h* + unramifiedGaussResidue (h*p):=by + let A:ℂ→ℂ:=fun s=>1+(Ideal.absNorm (Ideal.span {p}):ℂ)^3* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^3 + let B:ℂ→ℂ:=fun s=>-((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s)*primeCubicGauss p hp hprimary 1 h) + have hA (s:ℂ):AnalyticAt ℂ A s:=analyticAt_const.add + (analyticAt_const.mul ((gaussPrimeWeight_analytic p hp s).pow 3)) + have hB (s:ℂ):AnalyticAt ℂ B s:=((gaussPrimeWeight_analytic p hp s).mul analyticAt_const).neg + have he:=unramifiedGaussResidue_of_initial_relation (h*p^3) h (h*p) A B + (fun s _=>hA s) (fun s _=>hB s) (hA _).continuousAt (hB _).continuousAt + (fun s hs _=>by + have hh:=unramifiedCubicGaussSeries_prime_recurrence p hp hprimary s (by linarith) h hph + simpa only [A,B,neg_mul,sub_eq_add_neg] using hh) + dsimp only [A,B] at he + rw [gaussPrimeWeight_center p hp] at he + simpa only [neg_mul,sub_eq_add_neg] using he + +end + +section + +open scoped BigOperators Classical Topology +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +theorem unramifiedGaussResidue_cube_recurrence (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (a:ℕ): + unramifiedGaussResidue (h*p^(a+6))= + (1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*unramifiedGaussResidue (h*p^(a+3))- + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*unramifiedGaussResidue (h*p^a):=by + let q:ℂ→ℂ:=fun s=>(Ideal.absNorm (Ideal.span {p}):ℂ)^3* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^3 + have hq (s:ℂ):AnalyticAt ℂ q s:=analyticAt_const.mul ((gaussPrimeWeight_analytic p hp s).pow 3) + have he:=unramifiedGaussResidue_of_initial_relation (h*p^(a+6)) (h*p^(a+3)) (h*p^a) + (fun s=>1+q s) (fun s=>-q s) + (fun s _=>analyticAt_const.add (hq s)) (fun s _=>(hq s).neg) + (continuousAt_const.add (hq _).continuousAt) (hq _).continuousAt.neg + (fun s hs _=>by + have hh:=unramifiedCubicGaussSeries_cube_recurrence p hp hprimary s (by linarith) h hph a + simpa only [q,neg_mul,sub_eq_add_neg] using hh) + dsimp only [q] at he + rw [gaussPrimeWeight_center p hp] at he + simpa only [neg_mul,sub_eq_add_neg] using he + +private lemma recurrence_roots_closed (r:ℕ→ℂ) (q:ℂ) + (hr:∀k,r (k+2)=(1+q)*r (k+1)-q*r k) (k:ℕ): + (1-q)*r k=(r 1-q*r 0)+(r 0-r 1)*q^k:=by + have hpair:∀k:ℕ, + ((1-q)*r k=(r 1-q*r 0)+(r 0-r 1)*q^k) ∧ + ((1-q)*r (k+1)=(r 1-q*r 0)+(r 0-r 1)*q^(k+1)):=by + intro k + induction k with + | zero=>constructor <;>norm_num <;>ring + | succ k ih=> + refine ⟨ih.2,?_⟩ + have hk:=hr k + rw [show k+1+1=k+2 by omega] + simp only [pow_succ] at * + linear_combination (1-q)*hk+(1+q)*ih.2-q*ih.1 + exact (hpair k).1 + +theorem unramifiedGaussResidue_cube_closed (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (k:ℕ): + (1-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*unramifiedGaussResidue (h*p^(3*k))= + (unramifiedGaussResidue (h*p^3)-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*unramifiedGaussResidue h)+ + (unramifiedGaussResidue h-unramifiedGaussResidue (h*p^3))* + ((Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)^k:=by + let r:ℕ→ℂ:=fun j=>unramifiedGaussResidue (h*p^(3*j)) + have hr:∀j,r (j+2)=(1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*r (j+1)- + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*r j:=by + intro j + have he:=unramifiedGaussResidue_cube_recurrence p hp hprimary h hph (3*j) + rw [show 3*j+6=3*(j+2) by omega,show 3*j+3=3*(j+1) by omega] at he + exact he + have he:=recurrence_roots_closed r (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹ hr k + simpa only [r,Nat.mul_zero,Nat.mul_one,pow_zero,mul_one] using he + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ComplexConjugate + +def inverseCuspPath (c d : ℂ) (v : ℝ) (direction : ℂ) (t : ℝ) : ℂ×ℝ := + (-d/c-(t:ℂ)*star direction/(c^2*((v^2+t^2*‖direction‖^2:ℝ):ℂ)), + v/(‖c‖^2*(v^2+t^2*‖direction‖^2))) + +lemma inverseCuspPath_zero (c d : ℂ) (v : ℝ) (direction : ℂ) + (hc : c≠0) (hv : 0v^2+t^2*‖direction‖^2) 0 0 := by + convert (((hasDerivAt_id (0:ℝ)).pow 2).mul_const (‖direction‖^2)).const_add (v^2) using 1 <;> norm_num + have hnum : HasDerivAt (fun t : ℝ=>(t:ℂ)*star direction) (star direction) 0 := by + simpa using ((hasDerivAt_id (0:ℝ)).ofReal_comp.mul_const (star direction)) + have hdenC := hden.ofReal_comp.const_mul (c^2) + have hdenR := hden.const_mul (‖c‖^2) + have hcz : c^2*((v^2+(0:ℝ)^2*‖direction‖^2:ℝ):ℂ)≠0 := by + simpa using mul_ne_zero (pow_ne_zero 2 hc) (pow_ne_zero 2 hvc) + have hrz : ‖c‖^2*(v^2+(0:ℝ)^2*‖direction‖^2)≠0 := by positivity + have hz : HasDerivAt + (fun t : ℝ=>-d/c-(t:ℂ)*star direction/(c^2*((v^2+t^2*‖direction‖^2:ℝ):ℂ))) + (-(star direction)/(c^2*(v:ℂ)^2)) 0 := by + convert (hnum.div hdenC hcz).const_sub (-d/c) using 1 ; + simp only [zero_pow (by decide : 2≠0),zero_mul,add_zero,Complex.ofReal_pow, + Complex.ofReal_zero,mul_zero,sub_zero] + field_simp + + have hvd : HasDerivAt (fun t : ℝ=>v/(‖c‖^2*(v^2+t^2*‖direction‖^2))) 0 0 := by + convert (hasDerivAt_const (0:ℝ) v).div hdenR hrz using 1 ; simp + exact hz.prodMk hvd + +theorem inverseCuspPath_comp_hasDerivAt (c d : ℂ) (v : ℝ) (direction : ℂ) + (hc : c≠0) (hv : 0F (inverseCuspPath c d v direction t)) + (A (-(star direction)/(c^2*(v:ℂ)^2),0)) 0 := by + have hf : HasFDerivAt F A (inverseCuspPath c d v direction 0) := by + rwa [inverseCuspPath_zero c d v direction hc hv] + exact hf.comp_hasDerivAt 0 (inverseCuspPath_hasDerivAt c d v direction hc hv) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/BesselMellinTransform.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/BesselMellinTransform.lean new file mode 100644 index 0000000000000000000000000000000000000000..a3d45c4b24deb242e5fb6d7223468e2b105e641f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/BesselMellinTransform.lean @@ -0,0 +1,607 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CuspAverage + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +lemma schlafliBesselK_cubic_scaled_mellin_integrable (s : ℂ) (c : ℝ) + (hs : 1/3 (v:ℂ)^(s-1)*schlafliBesselK (1/3) (c*v)) + (Set.Ioi 0) volume := by + have hb : MellinConvergent (fun v => schlafliBesselK (1/3) v) s := by + simpa only [MellinConvergent,smul_eq_mul] using schlafliBesselK_cubic_mellin_integrable s hs + have hh := (MellinConvergent.comp_mul_left + (f := fun v => schlafliBesselK (1/3) v) (s := s) hc).mpr hb + simpa only [MellinConvergent,smul_eq_mul] using hh + +lemma schlafliBesselK_cubic_scaled_mellin (s : ℂ) (c : ℝ) + (hs : 1/3 schlafliBesselK (1/3) v) s hc + simp only [mellin,smul_eq_mul] at hh + rw [schlafliBesselK_cubic_mellin s hs] at hh + exact hh + +lemma source_cubic_bessel_mellin_integrable (s freq : ℂ) + (hs : -(1/3) (v:ℂ)^(2*s)* + schlafliBesselK (1/3) (4*Real.pi*‖freq‖*v)) (Set.Ioi 0) volume := by + have hc : 0<4*Real.pi*‖freq‖ := by positivity + have ht : 1/3<(2*s+1).re := by norm_num; linarith + simpa only [show (2*s+1:ℂ)-1=2*s by ring] using + schlafliBesselK_cubic_scaled_mellin_integrable (2*s+1) (4*Real.pi*‖freq‖) ht hc + +theorem source_cubic_bessel_mellin (s freq : ℂ) + (hs : -(1/3) fin_cases j <;> + simp only [Matrix.map_apply,] <;> + assumption + +theorem exists_fixed_matrix_completion (M c a0 r0 d0 b0 : R) + (hc : c≠0) (hdet0 : a0*d0-b0*(c*r0)=1) : + ∀a r : R, M*c∣a-a0 → M∣r-r0 → IsCoprime r (M*c) → IsCoprime a r → + ∃b d : R, a*d-b*(c*r)=1 ∧ M*c∣d-d0 ∧ + (!![a,b;c*r,d] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M})) = + (!![a0,b0;c*r0,d0] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M})) := by + intro a r ha hrr hr har + have hbase : c ∣ a0*d0-1 := by + refine ⟨b0*r0,?_⟩ + linear_combination hdet0 + have hfixed : c ∣ a*d0-1 := by + have hdiff := dvd_mul_of_dvd_left ((dvd_mul_left c M).trans ha) d0 + convert dvd_add hdiff hbase using 1 ; ring + obtain ⟨b,d,hdet,hd⟩ := exists_fixed_completion M c r a d0 hfixed hr har + exact ⟨b,d,hdet,hd,fixed_completion_matrix_congr M c r r0 a a0 b b0 d d0 hc + hr.of_mul_right_left.symm hdet hdet0 ha hd hrr⟩ + +end ShortDraftCRT + +open scoped BigOperators Classical +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +def conductorReduction (a b:Eis): + (Eis⧸Ideal.span {a*b})→+*(Eis⧸Ideal.span {a}):= + Ideal.Quotient.factor (Ideal.span_singleton_le_span_singleton.mpr (dvd_mul_right a b)) + +lemma conductorReduction_surjective (a b:Eis):Function.Surjective (conductorReduction a b):= + Ideal.Quotient.factor_surjective _ + +def quotientTrace (c:Eis) (hc:c≠0):AddChar (Eis⧸Ideal.span {c}) ℂ:= + eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates c hc + +lemma quotientTrace_mk (c:Eis) (hc:c≠0) (x:Eis): + quotientTrace c hc (Ideal.Quotient.mk _ x)=residueAdditive (3*x) c 1:=by + simp only [quotientTrace,eisTraceModChar,IdealGaussCRT.traceModChar_mk] + unfold residueAdditive cuspFrequency + simp only [map_mul,map_one,map_ofNat] + congr 1 + ring + +def conductorFourier (a b:Eis) (ha:a≠0) (hb:b≠0) + (F:(Eis⧸Ideal.span {a})→ℂ) (h:Eis):ℂ:= + ∑'x:Eis⧸Ideal.span {a*b},F (conductorReduction a b x)* + quotientTrace (a*b) (mul_ne_zero ha hb) (Ideal.Quotient.mk _ h*x) + +lemma conductorFourier_shift (a b:Eis) (ha:a≠0) (hb:b≠0) + (F:(Eis⧸Ideal.span {a})→ℂ) (h t:Eis): + conductorFourier a b ha hb F h= + quotientTrace (a*b) (mul_ne_zero ha hb) (Ideal.Quotient.mk _ (h*a*t))* + conductorFourier a b ha hb F h:=by + let q:Eis⧸Ideal.span {a*b}:=Ideal.Quotient.mk _ (a*t) + have hq:conductorReduction a b q=0:=by + change Ideal.Quotient.mk (Ideal.span {a}) (a*t)=0 + exact Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr ⟨t,rfl⟩) + unfold conductorFourier + conv_lhs => rw [←(Equiv.addRight q).tsum_eq] + rw [←tsum_mul_left] + apply tsum_congr + intro x + change F (conductorReduction a b (x+q))* + quotientTrace (a*b) (mul_ne_zero ha hb) (Ideal.Quotient.mk _ h*(x+q))=_ + simp only [map_add,hq,add_zero,mul_add,AddChar.map_add_eq_mul] + have he:Ideal.Quotient.mk (Ideal.span {a*b}) h*q=Ideal.Quotient.mk _ (h*a*t):=by + dsimp [q] + rw [←map_mul] + congr 1 + ring + rw [he] + ring + +theorem conductorFourier_support (a b:Eis) (ha:a≠0) (hb:b≠0) + (F:(Eis⧸Ideal.span {a})→ℂ) (h:Eis) + (hF:conductorFourier a b ha hb F h≠0):b∣h:=by + have hphase (t:Eis): + quotientTrace (a*b) (mul_ne_zero ha hb) (Ideal.Quotient.mk _ (h*a*t))=1:=by + apply mul_right_cancel₀ hF + rw [one_mul,←conductorFourier_shift] + have hz:Ideal.Quotient.mk (Ideal.span {a*b}) (h*a)=0:=by + by_contra hn + apply GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive (a*b) (mul_ne_zero ha hb) hn + ext x + obtain ⟨t,rfl⟩:=Ideal.Quotient.mk_surjective x + simpa only [AddChar.mulShift_apply,←map_mul,AddChar.one_apply,quotientTrace] using hphase t + have hd:a*b∣h*a:=Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp hz) + have hd':a*b∣a*h:=by simpa only [mul_comm h a] using hd + exact (mul_dvd_mul_iff_left ha).mp hd' + +lemma conductorReduction_kernel_card (a b:Eis) (ha:a≠0) (_hb:b≠0): + Nat.card (conductorReduction a b).toAddMonoidHom.ker=Ideal.absNorm (Ideal.span {b}):=by + have hc:=card_ring_eq_card_mul_kernel (conductorReduction a b) + (conductorReduction_surjective a b) + change Ideal.absNorm (Ideal.span {a*b})= + Ideal.absNorm (Ideal.span {a})*Nat.card (conductorReduction a b).toAddMonoidHom.ker at hc + conv_lhs at hc => rw [←Ideal.span_singleton_mul_span_singleton,map_mul] + have hpos:0F y*quotientTrace a ha (Ideal.Quotient.mk _ k*y)) + rw [conductorReduction_kernel_card a b ha hb] at he + exact he + +end +section + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubicSymbol_pow_denominator (x p:Eis) (n:ℕ): + symbol x (p^n)=(symbol x p)^n:=by + induction n with + | zero=>simp + | succ n ih=>rw [pow_succ,symbol_mul_denominator,ih,pow_succ] + +def primeCubicMulChar (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1): + MulChar (Eis⧸Ideal.span {p}) ℂ:=by + letI:(Ideal.span {p}:Ideal Eis).IsMaximal:= + PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + have hg:lambda∉(Ideal.span {p}:Ideal Eis):= + primary_maximal_divisor_good p hprimary _ (Ideal.subset_span (by simp)) + refine {toFun:=fun x=>eisEmbedding (symbol (GaussianShiftedPartition.representative p x) p) + map_one':=?_,map_mul':=?_,map_nonunit':=?_} + · have hd:p∣GaussianShiftedPartition.representative p 1-1:=by + simpa only [map_one] using gaussRep_mk_congr p 1 + rw [symbol_congr hd,symbol_one_numerator p hprimary,map_one] + · intro x y + have hd:p∣GaussianShiftedPartition.representative p (x*y)- + GaussianShiftedPartition.representative p x*GaussianShiftedPartition.representative p y:=by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + simp only [map_mul,GaussianShiftedPartition.representative_spec] + rw [symbol_congr hd,symbol_mul_numerator _ _ p hprimary,map_mul] + · intro x hx + rw [symbol_prime p hp hprimary,primeValue_eq _ hg, + GaussianShiftedPartition.representative_spec,MulChar.map_nonunit _ hx,map_zero] + +lemma primeCubicMulChar_mk (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (x:Eis): + primeCubicMulChar p hp hprimary (Ideal.Quotient.mk _ x)=eisEmbedding (symbol x p):=by + change eisEmbedding (symbol (GaussianShiftedPartition.representative p + (Ideal.Quotient.mk _ x)) p)=_ + rw [symbol_congr (gaussRep_mk_congr p x)] + +lemma quotientTrace_mk_product (c:Eis) (hc:c≠0) (h d:Eis): + quotientTrace c hc (Ideal.Quotient.mk _ h*Ideal.Quotient.mk _ d)= + residueAdditive (3*h) c d:=by + rw [←map_mul,quotientTrace_mk] + unfold residueAdditive cuspFrequency + simp only [map_mul,map_one,map_ofNat] + congr 1 + ring + +lemma conductorReduction_prime_power_unit (p:Eis) (n:ℕ) + (x:Eis⧸Ideal.span {p*p^n}): + IsUnit (conductorReduction p (p^n) x)↔IsUnit x:=by + obtain ⟨d,rfl⟩:=Ideal.Quotient.mk_surjective x + change IsUnit (Ideal.Quotient.mk (Ideal.span {p}) d)↔ + IsUnit (Ideal.Quotient.mk (Ideal.span {p*p^n}) d) + rw [isUnit_quotient_span_iff,isUnit_quotient_span_iff,←pow_succ', + IsCoprime.pow_left_iff (Nat.succ_pos n)] + +theorem cubicUnitGaussSum_prime_power_fourier (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (n:ℕ) (h:Eis): + cubicUnitGaussSum h (p^(n+1))= + conductorFourier p (p^n) hp.ne_zero (pow_ne_zero _ hp.ne_zero) + (fun x=>(primeCubicMulChar p hp hprimary^(n+1)) x) h:=by + let χ:=primeCubicMulChar p hp hprimary + let f:(Eis⧸Ideal.span {p*p^n})→ℂ:=fun x=> + (χ^(n+1)) (conductorReduction p (p^n) x)* + quotientTrace (p*p^n) (mul_ne_zero hp.ne_zero (pow_ne_zero _ hp.ne_zero)) + (Ideal.Quotient.mk _ h*x) + have hsup:Function.support f⊆{x|IsUnit x}:=by + intro x hx + by_contra hn + have hn':¬IsUnit (conductorReduction p (p^n) x):= + fun hh=>hn ((conductorReduction_prime_power_unit p n x).mp hh) + exact hx (by dsimp [f];rw [MulChar.map_nonunit _ hn',zero_mul]) + rw [pow_succ'] + change cubicUnitGaussSum h (p*p^n)=∑'x,f x + rw [←tsum_subtype_eq_of_support_subset hsup] + unfold cubicUnitGaussSum + apply tsum_congr + intro x + let d:=GaussianShiftedPartition.representative (p*p^n) x.val + have hd:Ideal.Quotient.mk (Ideal.span {p*p^n}) d=x.val:= + GaussianShiftedPartition.representative_spec _ _ + change eisEmbedding (symbol d (p*p^n))*residueAdditive (3*h) (p*p^n) d=f x.val + rw [←hd] + dsimp [f] + change _=(χ^(n+1)) (Ideal.Quotient.mk _ d)*_ + rw [MulChar.pow_apply' _ (Nat.succ_ne_zero n),primeCubicMulChar_mk, + quotientTrace_mk_product,←pow_succ',cubicSymbol_pow_denominator,map_pow] + +theorem cubicUnitGaussSum_prime_power_support (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (n:ℕ) (h:Eis) + (hne:cubicUnitGaussSum h (p^(n+1))≠0):p^n∣h:=by + rw [cubicUnitGaussSum_prime_power_fourier p hp hprimary n h] at hne + exact conductorFourier_support p (p^n) hp.ne_zero (pow_ne_zero _ hp.ne_zero) _ h hne + +def primeCubicGauss (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (e:ℕ) (h:Eis):ℂ:= + ∑'x:Eis⧸Ideal.span {p},(primeCubicMulChar p hp hprimary^e) x* + quotientTrace p hp.ne_zero (Ideal.Quotient.mk _ h*x) + +theorem cubicUnitGaussSum_prime_power_lift (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (n:ℕ) (h:Eis): + cubicUnitGaussSum (p^n*h) (p^(n+1))= + (Ideal.absNorm (Ideal.span {p}):ℂ)^n*primeCubicGauss p hp hprimary (n+1) h:=by + rw [cubicUnitGaussSum_prime_power_fourier p hp hprimary n, + conductorFourier_lift p (p^n) hp.ne_zero (pow_ne_zero _ hp.ne_zero)] + have hn:Ideal.absNorm (Ideal.span {p^n})=Ideal.absNorm (Ideal.span {p})^n:=by + rw [←Ideal.span_singleton_pow,map_pow] + rw [hn,Nat.cast_pow] + rfl + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma primeCubicMulChar_cube (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1): + primeCubicMulChar p hp hprimary^3=1:=by + apply DFunLike.ext + intro x + by_cases hx:IsUnit x + · obtain ⟨d,rfl⟩:=Ideal.Quotient.mk_surjective x + rw [MulChar.pow_apply' _ (by decide),primeCubicMulChar_mk,←map_pow, + symbol_cube_of_isCoprime d p hprimary ((isUnit_quotient_span_iff p d).mp hx).symm,map_one] + exact (MulChar.one_apply_coe hx.unit).symm + · rw [MulChar.map_nonunit _ hx,MulChar.map_nonunit _ hx] + +lemma primeCubicMulChar_ne_one (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1): + primeCubicMulChar p hp hprimary≠1:=by + let:(Ideal.span {p}:Ideal Eis).IsMaximal:= + PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + have hg:lambda∉(Ideal.span {p}:Ideal Eis):= + primary_maximal_divisor_good p hprimary _ (Ideal.subset_span (by simp)) + intro hchar + apply cubicChar_ne_one (Ideal.span {p}) hg + apply DFunLike.ext + intro x + by_cases hx:IsUnit x + · obtain ⟨d,rfl⟩:=Ideal.Quotient.mk_surjective x + have he:=congrArg (fun χ:MulChar (Eis⧸Ideal.span {p}) ℂ=>χ (Ideal.Quotient.mk _ d)) hchar + rw [primeCubicMulChar_mk,symbol_prime p hp hprimary,primeValue_eq _ hg] at he + have hoc:(1:MulChar (Eis⧸Ideal.span {p}) ℂ) (Ideal.Quotient.mk _ d)=1:= + MulChar.one_apply_coe hx.unit + have hoo:(1:MulChar (Eis⧸Ideal.span {p}) Eis) (Ideal.Quotient.mk _ d)=1:= + MulChar.one_apply_coe hx.unit + rw [hoo] + apply eisEmbedding_injective + simpa only [hoc,map_one] using he + · rw [MulChar.map_nonunit _ hx,MulChar.map_nonunit _ hx] + +lemma primeCubicMulChar_order (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1): + orderOf (primeCubicMulChar p hp hprimary)=3:=by + have hd:=orderOf_dvd_of_pow_eq_one (primeCubicMulChar_cube p hp hprimary) + rcases (Nat.dvd_prime Nat.prime_three).mp hd with h1|h3 + · exact False.elim (primeCubicMulChar_ne_one p hp hprimary (orderOf_eq_one_iff.mp h1)) + · exact h3 + +lemma primeCubicMulChar_pow_eq_one (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (e:ℕ): + primeCubicMulChar p hp hprimary^e=1↔3∣e:=by + rw [←orderOf_dvd_iff_pow_eq_one,primeCubicMulChar_order] + +lemma primeCubicGauss_mod_three (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (e:ℕ) (h:Eis): + primeCubicGauss p hp hprimary e h=primeCubicGauss p hp hprimary (e%3) h:=by + unfold primeCubicGauss + have he:=pow_mod_orderOf (primeCubicMulChar p hp hprimary) e + rw [primeCubicMulChar_order] at he + rw [he] + +lemma primeCubicGauss_eq_gaussSum (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (e:ℕ) (h:Eis) [Fintype (Eis⧸Ideal.span {p})]: + primeCubicGauss p hp hprimary e h= + gaussSum (primeCubicMulChar p hp hprimary^e) + ((quotientTrace p hp.ne_zero).mulShift (Ideal.Quotient.mk _ h)):=by + simp only [primeCubicGauss,tsum_fintype,gaussSum,AddChar.mulShift_apply] + +theorem primeCubicGauss_of_dvd (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (e:ℕ) (h:Eis) (hph:p∣h): + primeCubicGauss p hp hprimary e h= + if 3∣e then (Ideal.absNorm (Ideal.span {p}):ℂ)-1 else 0:=by + let:(Ideal.span {p}:Ideal Eis).IsMaximal:= + PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + let:Field (Eis⧸Ideal.span {p}):=Ideal.Quotient.field _ + let:Fintype (Eis⧸Ideal.span {p}):=Fintype.ofFinite _ + have hh:Ideal.Quotient.mk (Ideal.span {p}) h=0:= + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr hph) + rw [primeCubicGauss_eq_gaussSum,hh,AddChar.mulShift_zero] + split_ifs with he + · rw [(primeCubicMulChar_pow_eq_one p hp hprimary e).mpr he,gaussSum_one_one, + Nat.card_units,Nat.cast_sub (Nat.succ_le_of_lt Nat.card_pos),Nat.cast_one] + rfl + · exact gaussSum_one_right (fun hχ=>he ((primeCubicMulChar_pow_eq_one p hp hprimary e).mp hχ)) + +theorem primeCubicGauss_trivial_nonzero (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (e:ℕ) (he:3∣e) (h:Eis) (hph:¬p∣h): + primeCubicGauss p hp hprimary e h=-1:=by + let:(Ideal.span {p}:Ideal Eis).IsMaximal:= + PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + let:Field (Eis⧸Ideal.span {p}):=Ideal.Quotient.field _ + let:Fintype (Eis⧸Ideal.span {p}):=Fintype.ofFinite _ + have hh:Ideal.Quotient.mk (Ideal.span {p}) h≠0:=by + intro hh + exact hph (Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp hh)) + rw [primeCubicGauss_eq_gaussSum,(primeCubicMulChar_pow_eq_one p hp hprimary e).mpr he] + exact gaussSum_one_left (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive p hp.ne_zero hh) + +theorem primeCubicGauss_one_mul_two (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (h:Eis) (hph:¬p∣h): + primeCubicGauss p hp hprimary 1 h*primeCubicGauss p hp hprimary 2 h= + (Ideal.absNorm (Ideal.span {p}):ℂ):=by + let:(Ideal.span {p}:Ideal Eis).IsMaximal:= + PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + let:Field (Eis⧸Ideal.span {p}):=Ideal.Quotient.field _ + let:Fintype (Eis⧸Ideal.span {p}):=Fintype.ofFinite _ + have hh:Ideal.Quotient.mk (Ideal.span {p}) h≠0:=by + intro hh + exact hph (Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp hh)) + have hψ:((quotientTrace p hp.ne_zero).mulShift (Ideal.Quotient.mk _ h)).IsPrimitive:= + AddChar.IsPrimitive.of_ne_one (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive p hp.ne_zero hh) + have he:=gaussSum_mul_gaussSum_pow_orderOf_sub_one + (primeCubicMulChar_ne_one p hp hprimary) hψ + rw [primeCubicMulChar_order] at he + have hm:=MulChar.val_neg_one_eq_one_of_odd_order (by decide:Odd 3) + (primeCubicMulChar_cube p hp hprimary) + rw [hm,one_mul] at he + change _=(Nat.card (Eis⧸Ideal.span {p}):ℂ) + simpa only [primeCubicGauss_eq_gaussSum,pow_one,Nat.reduceSub, + Nat.card_eq_fintype_card] using he + +lemma primeCubicGauss_one_eq (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (h:Eis): + primeCubicGauss p hp hprimary 1 h=cubicUnitGaussSum h p:=by + have he:=cubicUnitGaussSum_prime_power_lift p hp hprimary 0 h + simpa only [pow_zero,one_mul,pow_one,Nat.zero_add] using he.symm + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CompactEnergyFamilies.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CompactEnergyFamilies.lean new file mode 100644 index 0000000000000000000000000000000000000000..559d3a8e1e44cefe3b6f31ea120866470e5db6cd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CompactEnergyFamilies.lean @@ -0,0 +1,603 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.VariationalLaplacian +import OAI.NumberTheory.DirichletL.CubicSieve.ReopenedFibers + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +namespace CubicEisenstein + +section + +lemma compact_of_norm_le_compact {E F G : Type*} + [NormedAddCommGroup E] [NormedSpace ℂ E] + [NormedAddCommGroup F] [NormedSpace ℂ F] [CompleteSpace F] + [NormedAddCommGroup G] [NormedSpace ℂ G] + (f : E→L[ℂ]F) (g : E→L[ℂ]G) (hg : IsCompactOperator g) + (hbound : ∃C : ℝ,∀x,‖f x‖≤C*‖g x‖) : IsCompactOperator f := by + let S := (LinearMap.range g.toLinearMap).topologicalClosure + have hS : IsClosed (S : Set G) := (LinearMap.range g.toLinearMap).isClosed_topologicalClosure + have hmem : ∀x,g x∈S := fun x => (LinearMap.range g.toLinearMap).le_topologicalClosure ⟨x,rfl⟩ + let e : E→L[ℂ]S := g.codRestrict S hmem + have he : DenseRange e := by + rw [DenseRange,Subtype.dense_iff,←Set.range_comp] + change closure (Set.range g)⊆closure (Set.range g) + exact Set.Subset.rfl + have hec : IsCompactOperator e := hg.codRestrict hmem hS + let q : S→L[ℂ]F := f.toLinearMap.extendOfNorm e.toLinearMap + have hfq : f=q.comp e := by + ext x + exact (LinearMap.extendOfNorm_eq he hbound x).symm + rw [hfq] + exact hec.clm_comp q + +lemma compact_finite_pi {E G ι : Type*} [Fintype ι] + [NormedAddCommGroup E] [NormedSpace ℂ E] + [NormedAddCommGroup G] [NormedSpace ℂ G] + (T : ι→E→L[ℂ]G) (hT : ∀i,IsCompactOperator (T i)) : + IsCompactOperator (ContinuousLinearMap.pi T) := by + let K : ι→Set G := fun i => closure ((T i) '' Metric.ball (0 : E) 1) + have hK : ∀i,IsCompact (K i) := fun i => (hT i).isCompact_closure_image_ball 1 + refine ⟨Set.pi Set.univ K,isCompact_univ_pi hK,?_⟩ + apply Filter.mem_of_superset (Metric.ball_mem_nhds (0 : E) (by norm_num : (0 : ℝ)<1)) + intro x hx + exact fun i hi => subset_closure ⟨x,hx,rfl⟩ + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff SchwartzMap + +def kernelChartCore (χ : PositiveChartCutoff) : Set EuclideanSpatial := + {p | (1/2 : ℝ)<χ.func p} + +def kernelChartCoreImage (χ : PositiveChartCutoff) : Set KernelQuotient := + kernelEuclideanProjection '' kernelChartCore χ + +lemma kernelChartCore_open (χ : PositiveChartCutoff) : IsOpen (kernelChartCore χ) := + isOpen_lt continuous_const χ.smooth.continuous + +lemma kernelChartCore_subset (χ : PositiveChartCutoff) : kernelChartCore χ⊆tsupport χ.func := by + intro p hp + apply subset_tsupport + change χ.func p≠0 + have hh : (1/2 : ℝ)<χ.func p := hp + linarith + +lemma kernelChartCoreImage_open (χ : PositiveChartCutoff) : IsOpen (kernelChartCoreImage χ) := by + have hp : kernelChartCore χ⊆euclideanUpperHalf := (kernelChartCore_subset χ).trans χ.positive + have he : kernelChartCoreImage χ=integralOrbitProjection globalKubotaKernel '' + (hyperbolicEuclideanCoordinates ⁻¹' kernelChartCore χ) := by + rw [←euclideanToHyperbolic_image_positive _ hp,Set.image_image] + rfl + rw [he] + exact (integralOrbitProjection_openQuotient globalKubotaKernel + globalKubotaKernel_le_levelThree).isOpenMap _ + ((kernelChartCore_open χ).preimage hyperbolicEuclideanCoordinates_continuous) + +abbrev KernelGoodCutoff := {χ : PositiveChartCutoff // + Set.InjOn kernelEuclideanProjection (tsupport χ.func)} + +lemma kernelChartCoreImage_cover : (Set.univ : Set KernelQuotient)⊆ + ⋃χ : KernelGoodCutoff,kernelChartCoreImage χ.1 := by + intro q hq + obtain ⟨w,rfl⟩ := Quotient.mk_surjective q + obtain ⟨χ,hχ,hrange,hinj⟩ := kernelChartCutoff_exists + (hyperbolicEuclideanCoordinates w) (hyperbolicHeight_pos w) + refine Set.mem_iUnion.mpr ⟨⟨χ,hinj⟩,hyperbolicEuclideanCoordinates w,?_,?_⟩ + · change (1/2 : ℝ)<χ.func (hyperbolicEuclideanCoordinates w) + rw [hχ] + norm_num + · simp only [kernelEuclideanProjection,Function.comp_apply,euclideanToHyperbolic_coordinates] + rfl + +lemma kernelCompact_finite_chart_cover (K : Set KernelQuotient) (hK : IsCompact K) : + ∃t : Finset KernelGoodCutoff,K⊆⋃χ∈t,kernelChartCoreImage χ.1 := by + exact hK.elim_finite_subcover (fun χ : KernelGoodCutoff => kernelChartCoreImage χ.1) + (fun χ => kernelChartCoreImage_open χ.1) + (Set.subset_univ K |>.trans kernelChartCoreImage_cover) + +lemma kernelChartCore_mass_estimate (χ : PositiveChartCutoff) + (hinj : Set.InjOn kernelEuclideanProjection (tsupport χ.func)) + (H : ℝ) (hH : 0≤H) (hdensity : ∀p∈tsupport χ.func,((p 2)^3)⁻¹≤H) + (f : kernelSmoothTests) : + (∫q in kernelChartCoreImage χ,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel)≤ + 4*H*‖kernelL2Localize χ (kernelSmoothTestsToL2 f)‖^2 := by + let S := kernelChartCore χ + have hS : MeasurableSet S := (kernelChartCore_open χ).measurableSet + have hpos : S⊆euclideanUpperHalf := (kernelChartCore_subset χ).trans χ.positive + have hi : Set.InjOn kernelEuclideanProjection S := hinj.mono (kernelChartCore_subset χ) + have hm := hyperbolicVolume_le_densityBound S hS hpos H + (fun p hp => hdensity p (kernelChartCore_subset χ hp)) + have hloc : Integrable (fun p => ‖kernelLocalizedField χ f p‖^2) volume := by + exact ((kernelLocalizedSchwartz χ f).memLp 2 volume).norm.integrable_sq + have hlocHyp : IntegrableOn (fun p => ‖kernelLocalizedField χ f p‖^2) S hyperbolicEuclideanVolume := + (hloc.integrableOn.smul_measure (c := ENNReal.ofReal H) ENNReal.ofReal_ne_top).mono_measure hm + have hmass : IntegrableOn (fun p => ‖kernelTestField f p‖^2) S hyperbolicEuclideanVolume := + (kernelEuclideanProjection_measurePreserving_on S hS hpos hi).integrable_comp_of_integrable + (kernelSmoothTests_memLp f).norm.integrable_sq.integrableOn + rw [kernelL2Localize_core χ hinj,schwartz_toL2_norm_sq] + have hEq := kernelEuclideanProjection_integral S hS hpos hi + (fun q => ‖f.1 q‖^2) (kernelSmoothTests_memLp f).norm.integrable_sq.aestronglyMeasurable + change (∫p in S,‖kernelTestField f p‖^2∂hyperbolicEuclideanVolume)=_ at hEq + change (∫q in kernelEuclideanProjection '' S,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel)≤ + 4*H*(∫p,‖kernelLocalizedField χ f p‖^2) + rw [←hEq] + calc + _ ≤ ∫p in S,4*‖kernelLocalizedField χ f p‖^2∂hyperbolicEuclideanVolume := by + apply setIntegral_mono_on hmass (hlocHyp.const_mul 4) hS + intro p hp + have hc : (1/2 : ℝ)<χ.func p := hp + rw [kernelLocalizedField,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs] + have hn := sq_nonneg ‖kernelTestField f p‖ + have hx : 1≤4*(χ.func p)^2 := by nlinarith + nlinarith [mul_le_mul_of_nonneg_right hx hn] + _ = 4*(∫p in S,‖kernelLocalizedField χ f p‖^2∂hyperbolicEuclideanVolume) := integral_const_mul _ _ + _ ≤ 4*(H*(∫p in S,‖kernelLocalizedField χ f p‖^2)) := by + apply mul_le_mul_of_nonneg_left _ (by norm_num) + have hh := integral_mono_measure hm + (Eventually.of_forall (fun p => sq_nonneg ‖kernelLocalizedField χ f p‖)) + (hloc.integrableOn.smul_measure (c := ENNReal.ofReal H) ENNReal.ofReal_ne_top) + simpa only [integral_smul_measure,ENNReal.toReal_ofReal hH,smul_eq_mul] using hh + _ ≤ _ := by + rw [←mul_assoc] + apply mul_le_mul_of_nonneg_left _ (by positivity) + exact setIntegral_le_integral hloc (Eventually.of_forall (fun p => sq_nonneg ‖kernelLocalizedField χ f p‖)) + +lemma kernelChartCore_mass_bound (χ : KernelGoodCutoff) : ∃C : ℝ,0≤C ∧ + ∀f : kernelSmoothTests, + (∫q in kernelChartCoreImage χ.1,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel)≤ + C*‖kernelL2Localize χ.1 (kernelSmoothTestsToL2 f)‖^2 := by + have hrho : ContinuousOn (fun p : EuclideanSpatial => ((p 2)^3)⁻¹) (tsupport χ.1.func) := + (by fun_prop : Continuous (fun p : EuclideanSpatial => (p 2)^3)).continuousOn.inv₀ + (fun p hp => pow_ne_zero _ (ne_of_gt (χ.1.positive hp))) + obtain ⟨r,hr⟩ := χ.1.compact.bddAbove_image hrho + refine ⟨4*max 0 r,by positivity,fun f => ?_⟩ + exact kernelChartCore_mass_estimate χ.1 χ.2 (max 0 r) (le_max_left _ _) + (fun p hp => (hr ⟨p,hp,rfl⟩).trans (le_max_right _ _)) f + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +def kernelMassRestriction (K : Set KernelQuotient) (hK : MeasurableSet K) + (f : KernelQuotientL2) : KernelQuotientL2 := + ((Lp.memLp f).indicator hK).toLp (K.indicator f) + +lemma kernelMassRestriction_coe (K : Set KernelQuotient) (hK : MeasurableSet K) + (f : KernelQuotientL2) : + (kernelMassRestriction K hK f : KernelQuotient→ℂ)=ᵐ[integralQuotientVolume globalKubotaKernel] + K.indicator f := ((Lp.memLp f).indicator hK).coeFn_toLp + +def kernelMassRestrictionLinear (K : Set KernelQuotient) (hK : MeasurableSet K) : + KernelQuotientL2→ₗ[ℂ]KernelQuotientL2 where + toFun := kernelMassRestriction K hK + map_add' f g := by + apply Lp.ext + filter_upwards [kernelMassRestriction_coe K hK (f+g),kernelMassRestriction_coe K hK f, + kernelMassRestriction_coe K hK g,Lp.coeFn_add f g, + Lp.coeFn_add (kernelMassRestriction K hK f) (kernelMassRestriction K hK g)] with q hfg hf hg ha hb + rw [hfg,hb,Pi.add_apply,hf,hg] + by_cases hq : q∈K + · simp only [Set.indicator_of_mem hq,ha,Pi.add_apply] + · simp only [Set.indicator_of_notMem hq,add_zero] + map_smul' c f := by + change kernelMassRestriction K hK (c•f)=c•kernelMassRestriction K hK f + apply Lp.ext + filter_upwards [kernelMassRestriction_coe K hK (c•f),kernelMassRestriction_coe K hK f, + Lp.coeFn_smul c f,Lp.coeFn_smul c (kernelMassRestriction K hK f)] with q hcf hf ha hb + rw [hcf,hb,Pi.smul_apply,hf] + by_cases hq : q∈K + · simp only [Set.indicator_of_mem hq,ha,Pi.smul_apply] + · simp only [Set.indicator_of_notMem hq,smul_zero] + +lemma kernelMassRestriction_norm_le (K : Set KernelQuotient) (hK : MeasurableSet K) + (f : KernelQuotientL2) : ‖kernelMassRestriction K hK f‖≤‖f‖ := by + apply Lp.norm_le_norm_of_ae_le + filter_upwards [kernelMassRestriction_coe K hK f] with q hq + rw [hq] + by_cases hm : q∈K + · simp only [Set.indicator_of_mem hm,le_refl] + · simp only [Set.indicator_of_notMem hm,norm_zero,norm_nonneg] + +def kernelMassRestrictionCLM (K : Set KernelQuotient) (hK : MeasurableSet K) : + KernelQuotientL2→L[ℂ]KernelQuotientL2 := + (kernelMassRestrictionLinear K hK).mkContinuous 1 (by + intro f + change ‖kernelMassRestriction K hK f‖≤1*‖f‖ + simpa only [one_mul] using kernelMassRestriction_norm_le K hK f) + +lemma kernelMassRestriction_norm_sq (K : Set KernelQuotient) (hK : MeasurableSet K) + (f : KernelQuotientL2) : + ‖kernelMassRestrictionCLM K hK f‖^2= + ∫q in K,‖f q‖^2∂integralQuotientVolume globalKubotaKernel := by + rw [←integral_indicator hK] + calc + _ = inner ℝ (kernelMassRestriction K hK f) (kernelMassRestriction K hK f) := + (real_inner_self_eq_norm_sq _).symm + _ = ∫q,inner ℝ (kernelMassRestriction K hK f q) (kernelMassRestriction K hK f q) + ∂integralQuotientVolume globalKubotaKernel := rfl + _ = _ := by + apply integral_congr_ae + filter_upwards [kernelMassRestriction_coe K hK f] with q hq + rw [hq,real_inner_self_eq_norm_sq] + by_cases hqK : q∈K + · simp only [Set.indicator_of_mem hqK] + · simp only [Set.indicator_of_notMem hqK,norm_zero,zero_pow (by decide : 2≠0)] + +lemma kernelMassRestriction_smooth_norm_sq (K : Set KernelQuotient) (hK : MeasurableSet K) + (f : kernelSmoothTests) : + ‖kernelMassRestrictionCLM K hK (kernelSmoothTestsToL2 f)‖^2= + ∫q in K,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel := by + rw [kernelMassRestriction_norm_sq] + apply integral_congr_ae + filter_upwards [ae_restrict_of_ae (kernelSmoothTests_memLp f).coeFn_toLp] with q hq + change ‖((kernelSmoothTests_memLp f).toLp f.1) q‖^2=‖f.1 q‖^2 + rw [hq] + +def kernelEnergyMassRestriction (K : Set KernelQuotient) (hK : MeasurableSet K) : + KernelEnergyGraph→L[ℂ]KernelQuotientL2 := + (kernelMassRestrictionCLM K hK).comp kernelEnergyMass + +lemma integral_le_finite_cover {X ι : Type*} [MeasurableSpace X] [Fintype ι] + (ν : Measure X) (K : Set X) (hK : MeasurableSet K) (U : ι→Set X) + (hU : ∀i,MeasurableSet (U i)) (hcover : K⊆⋃i,U i) + (g : X→ℝ) (hg : Integrable g ν) (hn : ∀x,0≤g x) : + (∫x in K,g x∂ν)≤∑i,∫x in U i,g x∂ν := by + have hi : ∀i,Integrable ((U i).indicator g) ν := fun i => hg.indicator (hU i) + calc + _ = ∫x,K.indicator g x∂ν := (integral_indicator hK).symm + _ ≤ ∫x,∑i,(U i).indicator g x∂ν := by + apply integral_mono (hg.indicator hK) (integrable_finsetSum _ (fun i himem => hi i)) + intro x + have hnon : ∀i,0≤(U i).indicator g x := fun i => Set.indicator_nonneg (fun y hy => hn y) x + by_cases hx : x∈K + · rw [Set.indicator_of_mem hx] + obtain ⟨i,hi⟩ := Set.mem_iUnion.mp (hcover hx) + calc + g x=(U i).indicator g x := (Set.indicator_of_mem hi g).symm + _ ≤ ∑j,(U j).indicator g x := Finset.single_le_sum (fun j hj => hnon j) (Finset.mem_univ i) + · rw [Set.indicator_of_notMem hx] + exact Finset.sum_nonneg (fun i hi => hnon i) + _ = _ := by + rw [integral_finsetSum _ (fun i himem => hi i)] + apply Finset.sum_congr rfl + intro i hi + exact integral_indicator (hU i) + +def kernelEnergyChartFamily (t : Finset KernelGoodCutoff) : + KernelEnergyGraph→L[ℂ](t→EuclideanL2) := + ContinuousLinearMap.pi (fun χ : t => kernelEnergyLocalizeL2 χ.1.1) + +lemma kernelEnergyChartFamily_isCompact (t : Finset KernelGoodCutoff) : + IsCompactOperator (kernelEnergyChartFamily t) := + compact_finite_pi _ (fun χ => kernelEnergyLocalizeL2_isCompact χ.1.1 χ.1.2) + +lemma finite_sum_weighted_norm_sq_le {G ι : Type*} [Fintype ι] + [NormedAddCommGroup G] (C : ι→ℝ) (hC : ∀i,0≤C i) (x : ι→G) : + (∑i,C i*‖x i‖^2)≤(∑i,C i)*‖x‖^2 := by + rw [Finset.sum_mul] + apply Finset.sum_le_sum + intro i hi + exact mul_le_mul_of_nonneg_left + (pow_le_pow_left₀ (norm_nonneg _) (norm_le_pi_norm x i) 2) (hC i) + +lemma kernelEnergyChartFamily_core_apply (t : Finset KernelGoodCutoff) + (f : kernelSmoothTests) (χ : t) : + kernelEnergyChartFamily t (kernelEnergyGraphCore f) χ= + kernelL2Localize χ.1.1 (kernelSmoothTestsToL2 f) := by + change kernelL2Localize χ.1.1 (kernelEnergyMass (kernelEnergyGraphCore f))=_ + rw [kernelEnergyMass_core] + +lemma kernelCompact_mass_bound (K : Set KernelQuotient) (hK : IsCompact K) : + ∃t : Finset KernelGoodCutoff,∃C : ℝ,0≤C ∧ ∀f : kernelSmoothTests, + (∫q in K,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel)≤ + C*‖kernelEnergyChartFamily t (kernelEnergyGraphCore f)‖^2 := by + obtain ⟨t,ht⟩ := kernelCompact_finite_chart_cover K hK + have hcov : K⊆⋃χ : t,kernelChartCoreImage χ.1.1 := by + intro q hq + obtain ⟨χ,hχ,hqχ⟩ := Set.mem_iUnion₂.mp (ht hq) + exact Set.mem_iUnion.mpr ⟨⟨χ,hχ⟩,hqχ⟩ + choose C hC hbound using fun χ : t => kernelChartCore_mass_bound χ.1 + refine ⟨t,∑χ,C χ,Finset.sum_nonneg (fun χ hχ => hC χ),fun f => ?_⟩ + calc + _ ≤ ∑χ : t,∫q in kernelChartCoreImage χ.1.1,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel := + integral_le_finite_cover _ K hK.measurableSet _ + (fun χ : t => (kernelChartCoreImage_open χ.1.1).measurableSet) hcov _ + (kernelSmoothTests_memLp f).norm.integrable_sq (fun _ => sq_nonneg _) + _ ≤ ∑χ : t,C χ*‖kernelL2Localize χ.1.1 (kernelSmoothTestsToL2 f)‖^2 := + Finset.sum_le_sum (fun χ hχ => hbound χ f) + _ = ∑χ : t,C χ*‖kernelEnergyChartFamily t (kernelEnergyGraphCore f) χ‖^2 := by + simp only [kernelEnergyChartFamily_core_apply] + _ ≤ _ := finite_sum_weighted_norm_sq_le C hC _ + +theorem kernelEnergyMassRestriction_isCompact (K : Set KernelQuotient) (hK : IsCompact K) : + IsCompactOperator (kernelEnergyMassRestriction K hK.measurableSet) := by + obtain ⟨t,C,hC,hbound⟩ := kernelCompact_mass_bound K hK + have hsq : ∀u : KernelEnergyGraph, + ‖kernelEnergyMassRestriction K hK.measurableSet u‖^2≤ + C*‖kernelEnergyChartFamily t u‖^2 := by + intro u + exact kernelEnergyGraphCore_dense.induction_on u + (isClosed_le (by fun_prop : Continuous (fun v => ‖kernelEnergyMassRestriction K hK.measurableSet v‖^2)) + (by fun_prop : Continuous (fun v => C*‖kernelEnergyChartFamily t v‖^2))) + (fun f => by + change ‖kernelMassRestrictionCLM K hK.measurableSet + (kernelEnergyMass (kernelEnergyGraphCore f))‖^2≤_ + rw [kernelEnergyMass_core,kernelMassRestriction_smooth_norm_sq] + exact hbound f) + apply compact_of_norm_le_compact _ (kernelEnergyChartFamily t) + (kernelEnergyChartFamily_isCompact t) + refine ⟨Real.sqrt C,fun u => ?_⟩ + have hs := hsq u + have hc := Real.sq_sqrt hC + have hn := mul_nonneg (Real.sqrt_nonneg C) (norm_nonneg (kernelEnergyChartFamily t u)) + have he : (Real.sqrt C*‖kernelEnergyChartFamily t u‖)^2=C*‖kernelEnergyChartFamily t u‖^2 := by + rw [mul_pow,Real.sq_sqrt hC] + nlinarith [norm_nonneg (kernelEnergyMassRestriction K hK.measurableSet u)] + +lemma kernelVariationalResolvent_compact_restriction (K : Set KernelQuotient) + (hK : IsCompact K) : + IsCompactOperator ((kernelMassRestrictionCLM K hK.measurableSet).comp kernelVariationalResolvent) := by + exact (kernelEnergyMassRestriction_isCompact K hK).comp_clm kernelVariationalSolution + +end CubicEisenstein + +open scoped BigOperators Classical +namespace CanonicalRowCompletion + +section +open ActualEisensteinCubic +open CompletedGauss (actualSextic) + +def primeValueHom (w : Ideal ActualEisensteinCubic.O → ℂ) : Ideal ActualEisensteinCubic.O →*₀ ℂ where + toFun I := if I=0 then 0 else ((UniqueFactorizationMonoid.normalizedFactors I).map w).prod + map_zero' := by simp + map_one' := by + rw [ite_eq_right one_ne_zero,UniqueFactorizationMonoid.normalizedFactors_one] + rfl + map_mul' I J := by + by_cases hI : I=0 + · simp [hI] + by_cases hJ : J=0 + · simp [hJ] + simp only [ite_eq_right hI,ite_eq_right hJ,ite_eq_right (mul_ne_zero hI hJ), + UniqueFactorizationMonoid.normalizedFactors_mul hI hJ,Multiset.map_add,Multiset.prod_add] + +theorem primeValueHom_prime (w : Ideal ActualEisensteinCubic.O → ℂ) (P : Ideal ActualEisensteinCubic.O) (hP : Prime P) : + primeValueHom w P = w P := by + change (if P=0 then 0 else _) = w P + rw [ite_eq_right hP.ne_zero, + UniqueFactorizationMonoid.normalizedFactors_irreducible hP.irreducible] + simp only [normalize_eq,Multiset.map_singleton,Multiset.prod_singleton] + +theorem primeValueHom_norm_le_one (w : Ideal ActualEisensteinCubic.O → ℂ) (hw : ∀ P,‖w P‖≤1) + (I : Ideal ActualEisensteinCubic.O) : ‖primeValueHom w I‖≤1 := by + by_cases hI : I=0 + · rw [hI,map_zero,norm_zero] + exact zero_le_one + change ‖if I=0 then 0 else _‖≤1 + rw [ite_eq_right hI] + have hprod (s : Multiset (Ideal ActualEisensteinCubic.O)) : ‖(s.map w).prod‖≤1 := by + induction s using Multiset.induction_on with + | empty => simp + | @cons P s ih => + simp only [Multiset.map_cons,Multiset.prod_cons,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (hw P)).trans ih + exact hprod _ + +def principalIdealHom : ActualEisensteinCubic.O →*₀ Ideal ActualEisensteinCubic.O where + toFun n := Ideal.span {n} + map_zero' := by simp + map_one' := by simp + map_mul' a b := (Ideal.span_singleton_mul_span_singleton a b).symm + +def localRowValue (x : ActualEisensteinCubic.O) (P : Ideal ActualEisensteinCubic.O) : ℂ := + if h : P.IsMaximal ∧ lambda∉P then + letI : P.IsMaximal := h.1 + actualSextic P h.2 (Ideal.Quotient.mk P x) + else 0 + +theorem localRowValue_good (x : ActualEisensteinCubic.O) (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] (hg : lambda∉P) : + localRowValue x P = actualSextic P hg (Ideal.Quotient.mk P x) := by + simp only [localRowValue,dite_eq_left (show P.IsMaximal ∧ lambda∉P from ⟨inferInstance,hg⟩)] + +theorem localRowValue_norm (x : ActualEisensteinCubic.O) (P : Ideal ActualEisensteinCubic.O) : ‖localRowValue x P‖≤1 := by + unfold localRowValue + split_ifs with h + · let : P.IsMaximal := h.1 + let : Fintype (ActualEisensteinCubic.O⧸P) := Fintype.ofFinite _ + exact FiniteRayExpansion.norm_char_le_one _ _ + · simp + +def idealRowHom (x : ActualEisensteinCubic.O) : Ideal ActualEisensteinCubic.O →*₀ ℂ := primeValueHom (localRowValue x) + +def rowTwist (Ψ : ActualEisensteinCubic.O →* ℂ) (m f z : ActualEisensteinCubic.O) : ActualEisensteinCubic.O →* ℂ := + Ψ * (idealRowHom (m^6*f^4*z)).toMonoidHom.comp principalIdealHom.toMonoidHom + +theorem idealRowHom_prime (x : ActualEisensteinCubic.O) (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] (hg : lambda∉P) : + idealRowHom x P = actualSextic P hg (Ideal.Quotient.mk P x) := by + rw [idealRowHom,primeValueHom_prime _ P + (Ideal.prime_of_isPrime (NeZero.ne P) inferInstance),localRowValue_good] + +theorem idealRowHom_norm (x : ActualEisensteinCubic.O) (I : Ideal ActualEisensteinCubic.O) : ‖idealRowHom x I‖≤1 := + primeValueHom_norm_le_one _ (localRowValue_norm x) I + +theorem rowTwist_norm (Ψ : ActualEisensteinCubic.O →* ℂ) (hΨ : ∀n,‖Ψ n‖≤1) (m f z n : ActualEisensteinCubic.O) : + ‖rowTwist Ψ m f z n‖≤1 := by + change ‖Ψ n * idealRowHom (m^6*f^4*z) (Ideal.span {n})‖≤1 + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (hΨ n)).trans (idealRowHom_norm _ _) + +theorem idealRowHom_product {ι : Type*} (p : ι → ActualEisensteinCubic.O) + [∀i,(Ideal.span {p i}).IsMaximal] (hg : ∀i,lambda∉Ideal.span {p i}) + (S : Finset ι) (x : ActualEisensteinCubic.O) : + idealRowHom x (Ideal.span {∏i∈S,p i}) = + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S x := by + rw [FiniteGaussPhase.span_finset_prod,map_prod] + simp only [finiteSquarefreeRow] + apply Finset.prod_congr rfl + intro i hi + exact idealRowHom_prime x _ (hg i) + +theorem rowTwist_product {ι : Type*} (p : ι → ActualEisensteinCubic.O) + [∀i,(Ideal.span {p i}).IsMaximal] (hg : ∀i,lambda∉Ideal.span {p i}) + (S : Finset ι) (Ψ : ActualEisensteinCubic.O →* ℂ) (m f z : ActualEisensteinCubic.O) : + rowTwist Ψ m f z (∏i∈S,p i) = + Ψ (∏i∈S,p i)*rowCoprimeMask (fun i=>Ideal.span {p i}) S m* + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S f^4* + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z := by + change Ψ _ * idealRowHom _ (Ideal.span {∏i∈S,p i}) = _ + rw [idealRowHom_product p hg S,finiteSquarefreeRow_mul,finiteSquarefreeRow_mul, + FirstPassCubeLabels.row_pow,FirstPassCubeLabels.row_pow,FirstPassCubeLabels.row_sixth] + ring + +end + +open ActualEisensteinCubic +open CompletedGauss hiding O +open SecondPassArithmetic hiding O + +section +variable {ι : Type*} [DecidableEq ι] + (p : ι → ActualEisensteinCubic.O) (hp : ∀i,p i≠0) [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + +theorem squarefreeGaussCoefficient_finset (hpr : ∀i,lambda^2∣p i-1) (S : Finset ι) : + squarefreeGaussCoefficient (Ideal.span {∏i∈S,p i}) = + MixedCrossSeparation.columnCoefficient p hp hcop hg S := by + have h := squarefreeGaussCoefficient_eq_canonicalProductCoefficient + (fun i:S=>p i.val) (fun i=>hp i.val) + (MixedCrossSeparation.columnPrimeCoprime p hcop S) (fun i=>hg i.val) + (fun i=>hpr i.val) + simpa only [Finset.prod_coe_sort,MixedCrossSeparation.columnCoefficient] using h + +theorem columnWeight_finset (hpr : ∀i,lambda^2∣p i-1) + (S : Finset ι) (Ψ : ActualEisensteinCubic.O →* ℂ) (m f z : ActualEisensteinCubic.O) (H : Finset ι → ℂ) : + columnWeight (rowTwist Ψ m f z) (Ideal.span {∏i∈S,p i}) * H S = + canonicalSourceCoefficient p hp hcop hg Ψ m f H S * + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z := by + have hn : (∏i∈S,p i)≠0 := Finset.prod_ne_zero_iff.mpr (fun i _=>hp i) + have hprimary : lambda^2∣(∏i∈S,p i)-1 := by + have h := product_primary (fun i:S=>p i.val) (fun i=>hpr i.val) + simpa only [Finset.prod_coe_sort] using h + rw [columnWeight,squarefreeGaussCoefficient_finset p hp hcop hg hpr S, + primaryGenerator_span _ hn hprimary,rowTwist_product p hg S] + simp only [canonicalSourceCoefficient] + ring + +end + +theorem selected_column_sum (F : Finset (Ideal ActualEisensteinCubic.O)) + (hF : ∀I∈F,CanonicalQuadraticSieve.Admissible I) + (Ψ : ActualEisensteinCubic.O →* ℂ) (m f z : ActualEisensteinCubic.O) (W : ℕ → ℂ) : + let p := CanonicalQuadraticSieve.poolPrimary F + let hp := CanonicalQuadraticSieve.poolPrimary_ne_zero F hF + letI : ∀i:ConcretePrimeRowBridge.primePool F,(Ideal.span {p i}).IsMaximal := + fun i=>by rw [CanonicalQuadraticSieve.poolPrimary_span F hF i]; infer_instance + let hcop := CanonicalQuadraticSieve.poolPrimary_coprime F hF + let hg := CanonicalQuadraticSieve.poolPrimary_good F hF + (∑I∈F,columnWeight (rowTwist Ψ m f z) I * W (Ideal.absNorm I)) = + ∑S∈(Finset.univ:Finset (ConcretePrimeRowBridge.primePool F)).powerset, + canonicalSourceCoefficient p hp hcop hg Ψ m f (InitialMeanSquare.selectedIdealTest F W) S * + finiteSquarefreeRow (fun i=>Ideal.span {p i}) hg S z := by + dsimp only + let : ∀i:ConcretePrimeRowBridge.primePool F, + (Ideal.span {CanonicalQuadraticSieve.poolPrimary F i}).IsMaximal := + fun i=>by rw [CanonicalQuadraticSieve.poolPrimary_span F hF i]; infer_instance + rw [InitialMeanSquare.sum_selected_ideals F (fun I hI=>(hF I hI).2.1)] + apply Finset.sum_congr rfl + intro S hS + have hspan : (Ideal.span {∏i∈S,CanonicalQuadraticSieve.poolPrimary F i}) = ∏i∈S,i.val := by + rw [FiniteGaussPhase.span_finset_prod] + exact Finset.prod_congr rfl (fun i _=>CanonicalQuadraticSieve.poolPrimary_span F hF i) + have hpr (i:ConcretePrimeRowBridge.primePool F) : + lambda^2∣CanonicalQuadraticSieve.poolPrimary F i-1 := + (primaryPrime_spec i.val (CanonicalQuadraticSieve.poolPrimary_ne_zero F hF i)).2.2.2 + have h := columnWeight_finset (CanonicalQuadraticSieve.poolPrimary F) + (CanonicalQuadraticSieve.poolPrimary_ne_zero F hF) + (CanonicalQuadraticSieve.poolPrimary_coprime F hF) + (CanonicalQuadraticSieve.poolPrimary_good F hF) hpr S Ψ m f z + (InitialMeanSquare.selectedIdealTest F W) + rw [hspan] at h + rw [←h] + unfold InitialMeanSquare.selectedIdealTest + split_ifs <;> simp + +end CanonicalRowCompletion + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CompactProfiles.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CompactProfiles.lean new file mode 100644 index 0000000000000000000000000000000000000000..7e0ea2cf6e677e289082f1f863c529b498695dc1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CompactProfiles.lean @@ -0,0 +1,693 @@ +import OAI.NumberTheory.DirichletL.QuadraticSieve.SelectedExponents + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Matrix Pointwise ENNReal + +lemma cosetHeight_continuous (r : CuspCosets) : Continuous (cosetHeight r) := by + induction r using Quotient.inductionOn with + | _ M => + have heq : cosetHeight (cosetOf M)=(fun w => hyperbolicHeight (complexMatrix M • w)) := + funext (cosetHeight_cosetOf M) + change Continuous (cosetHeight (cosetOf M)) + rw [heq] + exact hyperbolicHeight_continuous.comp (continuous_hyperbolic_action _) + +lemma cuspCutoffCorrection_measurable (Y : ℝ) (F : ℝ → ℂ) (hF : Measurable F) : + Measurable (cuspCutoffCorrection Y F) := by + unfold cuspCutoffCorrection + apply Measurable.tsum + intro r + apply Measurable.ite + · exact (isOpen_lt continuous_const (cosetHeight_continuous r)).measurableSet + · exact measurable_const.mul (hF.comp (cosetHeight_continuous r).measurable) + · exact measurable_const + +lemma cuspCutoffCorrection_norm_le (F : ℝ → ℂ) (C : ℝ) (hC : 0≤C) + (hF : ∀v,‖F v‖≤C) (w : HyperbolicSpace) : ‖cuspCutoffCorrection 1 F w‖≤C := by + by_cases hh : ∃r : CuspCosets,1 cuspCutoffTerm 1 F r w)=(fun _ : CuspCosets => (0:ℂ)) := by + funext r + simp [cuspCutoffTerm,show ¬1 hh ⟨r,h⟩] + rw [hz,tsum_zero] + rw [hz,norm_zero] + exact hC + +lemma smoothCuspSeedDefect_measurable (a b : ℝ) (s : ℂ) (ha : 0 ?_⟩ + exact cuspCutoffCorrection_norm_le _ _ (le_max_right _ _) (fun v => (hC v).trans (le_max_left _ _)) w + +lemma kernelQuotientDefect_measurable (a b : ℝ) (s : ℂ) (ha : 0 exact hbound w + +def kernelL2Defect (a b : ℝ) (ha : 0 simp [mul_add] + +lemma cuspCutoffCorrection_smul (c : ℂ) (F : ℝ → ℂ) (w : HyperbolicSpace) : + cuspCutoffCorrection 1 (c • F) w=c • cuspCutoffCorrection 1 F w := by + unfold cuspCutoffCorrection + rw [smul_eq_mul,←tsum_mul_left] + apply tsum_congr + intro r + simp only [cuspCutoffTerm,Pi.smul_apply,smul_eq_mul] + split_ifs <;> ring + +def compactHeightProfile (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : ℝ → ℂ := + (Set.Icc a b).indicator (fun v => F (Set.projIcc a b hab v)) + +lemma compactHeightProfile_measurable (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : + Measurable (compactHeightProfile a b hab F) := + (F.continuous.comp continuous_projIcc).measurable.indicator measurableSet_Icc + +lemma compactHeightProfile_norm_le (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) (v : ℝ) : + ‖compactHeightProfile a b hab F v‖≤‖F‖ := by + unfold compactHeightProfile + by_cases hv : v∈Set.Icc a b + · rw [Set.indicator_of_mem hv] + exact F.norm_coe_le_norm _ + · rw [Set.indicator_of_notMem hv,norm_zero] + exact norm_nonneg _ + +lemma compactHeightProfile_add (a b : ℝ) (hab : a≤b) (F G : C(Set.Icc a b,ℂ)) : + compactHeightProfile a b hab (F+G)=compactHeightProfile a b hab F+compactHeightProfile a b hab G := by + funext v + simp [compactHeightProfile,Set.indicator_add] + +lemma compactHeightProfile_smul (a b : ℝ) (hab : a≤b) (c : ℂ) (F : C(Set.Icc a b,ℂ)) : + compactHeightProfile a b hab (c • F)=c • compactHeightProfile a b hab F := by + funext v + by_cases hv : v∈Set.Icc a b <;> simp [compactHeightProfile,hv] + +def kernelCompactProfile (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : + IntegralOrbitQuotient globalKubotaKernel → ℂ := + Quotient.lift (cuspCutoffCorrection 1 (compactHeightProfile a b hab F)) (by + rintro w u ⟨M,hM⟩ + rw [←hM] + obtain ⟨hM,hchar⟩ := (globalKubotaKernel_mem (M:SL(2,ActualEisensteinCubic.O))).mp M.property + have he := cuspCutoffCorrection_automorphy 1 le_rfl (compactHeightProfile a b hab F) + (⟨(M:SL(2,ActualEisensteinCubic.O)),hM⟩ : CubicKubota.levelThree) w + rw [hchar,one_mul] at he + exact he.symm) + +lemma kernelCompactProfile_measurable (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : + Measurable (kernelCompactProfile a b hab F) := + measurable_from_quotient.mpr (cuspCutoffCorrection_measurable 1 _ + (compactHeightProfile_measurable a b hab F)) + +lemma kernelCompactProfile_norm_le (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) + (q : IntegralOrbitQuotient globalKubotaKernel) : ‖kernelCompactProfile a b hab F q‖≤‖F‖ := by + induction q using Quotient.inductionOn with + | _ w => + exact cuspCutoffCorrection_norm_le _ _ (norm_nonneg F) + (compactHeightProfile_norm_le a b hab F) w + +lemma kernelCompactProfile_memLp (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : + MemLp (kernelCompactProfile a b hab F) 2 (integralQuotientVolume globalKubotaKernel) := + MemLp.of_bound (kernelCompactProfile_measurable a b hab F).aestronglyMeasurable ‖F‖ + (Filter.Eventually.of_forall (kernelCompactProfile_norm_le a b hab F)) + +lemma kernelCompactProfile_add (a b : ℝ) (hab : a≤b) (F G : C(Set.Icc a b,ℂ)) : + kernelCompactProfile a b hab (F+G)=kernelCompactProfile a b hab F+kernelCompactProfile a b hab G := by + funext q + induction q using Quotient.inductionOn with + | _ w => + change cuspCutoffCorrection 1 _ w=_ + rw [compactHeightProfile_add,cuspCutoffCorrection_add] + rfl + +lemma kernelCompactProfile_smul (a b : ℝ) (hab : a≤b) (c : ℂ) (F : C(Set.Icc a b,ℂ)) : + kernelCompactProfile a b hab (c • F)=c • kernelCompactProfile a b hab F := by + funext q + induction q using Quotient.inductionOn with + | _ w => + change cuspCutoffCorrection 1 _ w=_ + rw [compactHeightProfile_smul,cuspCutoffCorrection_smul] + rfl + +def compactProfileL2Linear (a b : ℝ) (hab : a≤b) : C(Set.Icc a b,ℂ) →ₗ[ℂ] KernelQuotientL2 where + toFun F := (kernelCompactProfile_memLp a b hab F).toLp (kernelCompactProfile a b hab F) + map_add' F G := by + apply Lp.ext + grw [MemLp.coeFn_toLp,Lp.coeFn_add,MemLp.coeFn_toLp,MemLp.coeFn_toLp] + rw [kernelCompactProfile_add] + map_smul' c F := by + apply Lp.ext + grw [MemLp.coeFn_toLp,Lp.coeFn_smul,MemLp.coeFn_toLp] + rw [kernelCompactProfile_smul] + exact Filter.Eventually.of_forall (fun _ => rfl) + +lemma compactProfileL2Linear_bound (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : + ‖compactProfileL2Linear a b hab F‖≤ + (measureUnivNNReal (integralQuotientVolume globalKubotaKernel) : ℝ)^((2:ℝ)⁻¹)*‖F‖ := by + apply Lp.norm_le_of_ae_bound (norm_nonneg F) + filter_upwards [MemLp.coeFn_toLp (kernelCompactProfile_memLp a b hab F)] with q hq + change ‖((kernelCompactProfile_memLp a b hab F).toLp (kernelCompactProfile a b hab F)) q‖≤‖F‖ + rw [hq] + exact kernelCompactProfile_norm_le a b hab F q + +def compactProfileL2 (a b : ℝ) (hab : a≤b) : C(Set.Icc a b,ℂ) →L[ℂ] KernelQuotientL2 := + (compactProfileL2Linear a b hab).mkContinuous + ((measureUnivNNReal (integralQuotientVolume globalKubotaKernel) : ℝ)^((2:ℝ)⁻¹)) + (compactProfileL2Linear_bound a b hab) + +lemma compactProfileL2_ae_eq (a b : ℝ) (hab : a≤b) (F : C(Set.Icc a b,ℂ)) : + compactProfileL2 a b hab F =ᵐ[integralQuotientVolume globalKubotaKernel] + kernelCompactProfile a b hab F := + MemLp.coeFn_toLp (kernelCompactProfile_memLp a b hab F) + +def compactLogProfile (a b : ℝ) (ha : 0 (Real.log (v:ℝ):ℂ),Complex.continuous_ofReal.comp + (continuous_subtype_val.log (fun v => (ha.trans_le v.2.1).ne'))⟩ + +def compactDefectSecond (a b : ℝ) : C(Set.Icc a b,ℂ) where + toFun v := (v:ℂ)^2*((deriv (deriv (cuspTransition a b)) (v:ℝ):ℝ):ℂ) + continuous_toFun := by + have hd := (contDiff_infty_iff_deriv.mp (cuspTransition_contDiff a b)).2 + have hdd := (contDiff_infty_iff_deriv.mp hd).2 + exact (Complex.continuous_ofReal.comp continuous_subtype_val).pow 2 |>.mul + (Complex.continuous_ofReal.comp (hdd.continuous.comp continuous_subtype_val)) + +def compactDefectFirst (a b : ℝ) : C(Set.Icc a b,ℂ) where + toFun v := (v:ℂ)*((deriv (cuspTransition a b) (v:ℝ):ℝ):ℂ) + continuous_toFun := by + have hd := (contDiff_infty_iff_deriv.mp (cuspTransition_contDiff a b)).2 + exact (Complex.continuous_ofReal.comp continuous_subtype_val).mul + (Complex.continuous_ofReal.comp (hd.continuous.comp continuous_subtype_val)) + +def compactDefectProfile (a b : ℝ) (ha : 0.sub (differentiable_const 1)).smul + (differentiable_const (compactDefectFirst a b)))) + +lemma compactHeightProfile_actual_defect (a b : ℝ) (ha : 0 + change cuspCutoffCorrection 1 (compactHeightProfile a b hab.le (compactDefectProfile a b ha s)) w= + cuspCutoffCorrection 1 (cuspSeedDefectProfile a b s) w + rw [compactHeightProfile_actual_defect a b ha hab s] + +theorem kernelL2Defect_entire (a b : ℝ) (ha : 0 compactProfileL2 a b hab.le (compactDefectProfile a b ha s) := + funext (fun s => (compactProfileL2_actual_defect a b ha hab s).symm) + rw [heq] + exact (compactProfileL2 a b hab.le).differentiable.comp (compactDefectProfile_entire a b ha) + +end CubicEisenstein + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace SecondPassIntegration +open ActualEisensteinCubic JointLogSeparation FirstPassCubeLabels SecondPassArithmetic + +theorem full_uniform_normalized_child_tests + (g₁ g₂ W : 𝓢(ℝ, ℂ)) (A B : ℝ) (hA : 0 ≤ A) (hB : 0 ≤ B) + (hg₁ : ∀ s, g₁ s ≠ 0 → |s| ≤ A) (hg₂ : ∀ s, g₂ s ≠ 0 → |s| ≤ A) : + ∃ (A₁ A₂ : 𝓢(ℝ, ℂ)) (windows : Fin 7 → ℝ → ℂ), + (∀ j, HasCompactSupport (windows j)) ∧ + (∀ j, ContDiff ℝ ∞ (windows j)) ∧ + (∀ j s, windows j s ≠ 0 → |s| ≤ A+B+1) ∧ + ∀ {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, lambda ∉ Ideal.span {p i}), ∀ (D E V₀ X X₀ K Y : ℝ), 0 < D → 0 < E → 0 < V₀ → 0 < X → 0 < X₀ → 0 < K → + ∀ (F V : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m r c d e k : O), + d ≠ 0 → e ≠ 0 → k ≠ 0 → + |Real.log (primeProductNorm p V * X₀ / X)| ≤ B → + |Real.log (elementNorm d / D)| ≤ B → + |Real.log (elementNorm e / E)| ≤ B → + |Real.log (primeProductNorm p V / V₀)| ≤ B → + |Real.log (elementNorm (d*e*k) / K)| ≤ B → + secondChildKernelPair p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k (-k) + (radialPairKernel p e k W g₁ g₂ X X Y) = + (X : ℂ)⁻¹ * postCommonSmoothPair p hp hcop hg F Ψ₁ Ψ₂ (m*r) + (c*e*∏ i ∈ V, p i) (d*e*k) (d*e*(-k)) A₁ A₂ W windows + (Real.log (primeProductNorm p V * X₀ / X)) (Real.log (elementNorm d / D)) + (Real.log (elementNorm e / E)) (Real.log (primeProductNorm p V / V₀)) + (Real.log (elementNorm (d*e*k) / K)) X₀ X₀ (Y*K/(D*E^2*V₀^2*X₀^2)) := by + obtain ⟨U, hUc, hUs, hUone, hUsupp, hUzero⟩ := + FourierBridge.exists_complex_smooth_cutoff A hA + have hU₁ : ∀ s, g₁ s ≠ 0 → U s = 1 := fun s hs => hUone s (hg₁ s hs) + have hU₂ : ∀ s, g₂ s ≠ 0 → U s = 1 := fun s hs => hUone s (hg₂ s hs) + let A₁ := conjugateProfile (halfNormalizationCLM U g₁) + let A₂ := halfNormalizationCLM U g₂ + have hA₁ : ∀ s, A₁ s ≠ 0 → |s| ≤ A := by + intro s hs + apply halfNormalization_support_bound U hUc hUs g₁ A hg₁ s + intro hz + exact hs (by simp [A₁, hz]) + have hA₂ : ∀ s, A₂ s ≠ 0 → |s| ≤ A := + halfNormalization_support_bound U hUc hUs g₂ A hg₂ + obtain ⟨windows, hwc, hws, hwb, hwo, hwt⟩ := exists_fixed_sector_windows A B hA hB + refine ⟨A₁, A₂, windows, hwc, hws, hwb, ?_⟩ + intro ι _ p hp _ hcop hg + D E V₀ X X₀ K Y hD hE hV₀ hX hX₀ hK F V Ψ₁ Ψ₂ m r c d e k hd he hk hz hud hue huv hkap + apply secondChildKernelPair_eq_postCommon p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k hd he hk + D E V₀ X X₀ K Y hD hE hV₀ hX hX₀ hK U hUc hUs g₁ g₂ W hU₁ hU₂ windows + · exact hwo _ _ _ _ _ hz hud hue huv hkap + · exact fun a ha => hwt A₁ _ hA₁ hz 5 a ha + · exact fun a ha => hwt A₂ _ hA₂ hz 6 a ha + +theorem full_uniform_twisted_normalized_child_tests + (g₁ g₂ W : 𝓢(ℝ, ℂ)) (A B : ℝ) (hA : 0 ≤ A) (hB : 0 ≤ B) + (hg₁ : ∀ s, g₁ s ≠ 0 → |s| ≤ A) (hg₂ : ∀ s, g₂ s ≠ 0 → |s| ≤ A) : + ∃ (A₁ A₂ : 𝓢(ℝ, ℂ)) (windows : Fin 7 → ℝ → ℂ), + (∀ j, HasCompactSupport (windows j)) ∧ + (∀ j, ContDiff ℝ ∞ (windows j)) ∧ + (∀ j s, windows j s ≠ 0 → |s| ≤ A+B+1) ∧ + ∀ {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, lambda ∉ Ideal.span {p i}), ∀ (θ₁ θ₂ D E V₀ X X₀ K Y : ℝ), 0 < D → 0 < E → 0 < V₀ → 0 < X → 0 < X₀ → 0 < K → + ∀ (F V : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m r c d e k : O), + d ≠ 0 → e ≠ 0 → k ≠ 0 → + |Real.log (primeProductNorm p V * X₀ / X)| ≤ B → + |Real.log (elementNorm d / D)| ≤ B → + |Real.log (elementNorm e / E)| ≤ B → + |Real.log (primeProductNorm p V / V₀)| ≤ B → + |Real.log (elementNorm (d*e*k) / K)| ≤ B → + secondChildKernelPair p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k (-k) + (radialPairKernel p e k W (frequencyTwist g₁ θ₁) (frequencyTwist g₂ θ₂) X X Y) = + (X : ℂ)⁻¹ * postCommonSmoothPair p hp hcop hg F Ψ₁ Ψ₂ (m*r) + (c*e*∏ i ∈ V, p i) (d*e*k) (d*e*(-k)) (frequencyTwist A₁ (-θ₁)) (frequencyTwist A₂ θ₂) W windows + (Real.log (primeProductNorm p V * X₀ / X)) (Real.log (elementNorm d / D)) + (Real.log (elementNorm e / E)) (Real.log (primeProductNorm p V / V₀)) + (Real.log (elementNorm (d*e*k) / K)) X₀ X₀ (Y*K/(D*E^2*V₀^2*X₀^2)) := by + obtain ⟨U, hUc, hUs, hUone, hUsupp, hUzero⟩ := + FourierBridge.exists_complex_smooth_cutoff A hA + have hU₁ : ∀ s, g₁ s ≠ 0 → U s = 1 := fun s hs => hUone s (hg₁ s hs) + have hU₂ : ∀ s, g₂ s ≠ 0 → U s = 1 := fun s hs => hUone s (hg₂ s hs) + let A₁ := conjugateProfile (halfNormalizationCLM U g₁) + let A₂ := halfNormalizationCLM U g₂ + have hA₁ : ∀ s, A₁ s ≠ 0 → |s| ≤ A := by + intro s hs + apply halfNormalization_support_bound U hUc hUs g₁ A hg₁ s + intro hz + exact hs (by simp [A₁, hz]) + have hA₂ : ∀ s, A₂ s ≠ 0 → |s| ≤ A := + halfNormalization_support_bound U hUc hUs g₂ A hg₂ + obtain ⟨windows, hwc, hws, hwb, hwo, hwt⟩ := exists_fixed_sector_windows A B hA hB + refine ⟨A₁, A₂, windows, hwc, hws, hwb, ?_⟩ + intro ι _ p hp _ hcop hg + θ₁ θ₂ D E V₀ X X₀ K Y hD hE hV₀ hX hX₀ hK F V Ψ₁ Ψ₂ m r c d e k hd he hk hz hud hue huv hkap + have htw₁ : ∀ s, frequencyTwist g₁ θ₁ s ≠ 0 → U s = 1 := by + intro s hs + apply hU₁ s + intro hz + exact hs (by simp [frequencyTwist_apply, hz]) + have htw₂ : ∀ s, frequencyTwist g₂ θ₂ s ≠ 0 → U s = 1 := by + intro s hs + apply hU₂ s + intro hz + exact hs (by simp [frequencyTwist_apply, hz]) + have hsupp₁ : ∀ s, frequencyTwist A₁ (-θ₁) s ≠ 0 → |s| ≤ A := by + intro s hs + apply hA₁ s + intro hz + exact hs (by simp [frequencyTwist_apply, hz]) + have hsupp₂ : ∀ s, frequencyTwist A₂ θ₂ s ≠ 0 → |s| ≤ A := by + intro s hs + apply hA₂ s + intro hz + exact hs (by simp [frequencyTwist_apply, hz]) + have hh := secondChildKernelPair_eq_postCommon p hp hcop hg F V Ψ₁ Ψ₂ m r c d e k hd he hk + D E V₀ X X₀ K Y hD hE hV₀ hX hX₀ hK U hUc hUs + (frequencyTwist g₁ θ₁) (frequencyTwist g₂ θ₂) W htw₁ htw₂ windows + dsimp only at hh + rw [normalized_conjugate_frequencyTwist U hUc hUs, + halfNormalization_twist U hUc hUs] at hh + exact hh (hwo _ _ _ _ _ hz hud hue huv hkap) + (fun a ha => hwt (frequencyTwist A₁ (-θ₁)) _ hsupp₁ hz 5 a ha) + (fun a ha => hwt (frequencyTwist A₂ θ₂) _ hsupp₂ hz 6 a ha) + +end SecondPassIntegration + +namespace SecondPassArithmetic + +section +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm normalizedColumn columnLog b0Label) +open JointLogSeparation (halfNormalizationCLM) +open SecondPassFiber (newRow) + +section +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,lambda ∉ Ideal.span {p i}) + +def globalSecondLiteralTerm (F : Finset ι) (Ψ : O →* ℂ) (m : O) (ray : SecondRayIndex) + (g₁ g₂ W : 𝓢(ℝ,ℂ)) (ell Y : ℝ) (side : Bool) (x : GlobalSecondData ι) : ℂ := + let X := globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon + let m' := m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + let c := secondBaseLabel p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent x.cube.leftBit x.cube.rightBit + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor + (primeProductNorm p x.firstCommon : ℂ)⁻¹ * + secondExpansionSource p hp hcop hg (globalSecondRawPool F x) Ψ m' c d ray {x.source} + (fun A => normalizedColumn p (fun S => g₁ (columnLog p X S)) A) + (fun A => normalizedColumn p (fun S => g₂ (columnLog p X S)) A) W Y + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] hp in +theorem globalResidualScale_eq (ell : ℝ) (side : Bool) (x : GlobalSecondData ι) : + secondExpansionScale p (globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon) + (primeSubsetGenerator (fun i => Ideal.span {p i}) (x.source.sourceCommon\x.source.divisor)) + (expansionSupportData x.common x.firstDivisor x.source) = globalActualResidualScale p ell side x := by + simp only [secondExpansionScale,expansionSupportData,primeSubsetGenerator_norm_eq_productNorm,globalActualResidualScale] + ring + +end + +theorem globalSecondLiteralTerm_fixed_profiles + (U : ℝ → ℂ) (hUc : HasCompactSupport U) (hUs : ContDiff ℝ ∞ U) + (g₁ g₂ W : 𝓢(ℝ,ℂ)) (A : ℝ) (hA : 0 ≤ A) + (hU₁ : ∀ t,g₁ t ≠ 0 → U t=1) (hU₂ : ∀ t,g₂ t ≠ 0 → U t=1) + (hg₁ : ∀ t,g₁ t ≠ 0 → |t| ≤ A) (hg₂ : ∀ t,g₂ t ≠ 0 → |t| ≤ A) : + ∃ (A₁ A₂ : 𝓢(ℝ,ℂ)) (windows : Fin 7 → ℝ → ℂ), + (∀ i,HasCompactSupport (windows i)) ∧ (∀ i,ContDiff ℝ ∞ (windows i)) ∧ + (∀ i t,windows i t ≠ 0 → |t| ≤ A+6+1) ∧ + ∀ {ι : Type*} [DecidableEq ι] (p : ι → O) (hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,lambda ∉ Ideal.span {p i}) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hpr : ∀ i,lambda^2 ∣ p i-1) + (F : Finset ι) (Ψ : O →* ℂ) (m : O) (ray : SecondRayIndex) + (ell Y : ℝ) (side : Bool) (x : GlobalSecondData ι), + 0 < ell → x.source.divisor ⊆ x.source.sourceCommon → x.source.frequency ≠ 0 → + let j := globalScaleIndex p side x + globalSecondLiteralTerm p hp hcop hg F Ψ m ray g₁ g₂ W ell Y side x = + globalSecondOuterWeight p hp hcop hg Ψ m ray ell Y side x * + postCommonSmoothPair p hp hcop hg (globalSecondRawPool F x) + (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) (globalSecondRawMask p m x) + (globalSecondLabel p x) (newRow (globalSecondTuple p x)) (-newRow (globalSecondTuple p x)) + A₁ A₂ W windows (globalBinZ p ell side j x) (globalBinUd p j x) + (globalBinUe p j x) (globalBinUv p j x) (globalBinKap p j x) + (globalPooledColumnScale ell j) (globalPooledColumnScale ell j) (globalBinRadial ell Y j) := by + have h1 := SecondPassIntegration.halfNormalization_support_bound U hUc hUs g₁ A hg₁ + have h2 := SecondPassIntegration.halfNormalization_support_bound U hUc hUs g₂ A hg₂ + obtain ⟨A₁,A₂,windows,hwc,hws,hwb,hid⟩ := SecondPassIntegration.full_uniform_normalized_child_tests + (halfNormalizationCLM U g₁) (halfNormalizationCLM U g₂) W A 6 hA (by norm_num) h1 h2 + refine ⟨A₁,A₂,windows,hwc,hws,hwb,?_⟩ + intro ι _ p hp _ hcop hg hinj hpr F Ψ m ray ell Y side x hell hE hk + dsimp only + let j := globalScaleIndex p side x + let X := globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon + let r := primeSubsetGenerator (fun i => Ideal.span {p i}) (x.source.sourceCommon\x.source.divisor) + let c := secondBaseLabel p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent x.cube.leftBit x.cube.rightBit + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) x.source.divisor + let m' := m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + have hX : 0 < X := div_pos (globalFirstColumnScale_pos p hp ell hell x side) + (FirstPassCubeLabels.primeProductNorm_pos p hp _) + have hr : Ideal.span {secondMaskQuotient p x.source.divisor x.source.sourceCommon hE}=Ideal.span {r} := by + rw [secondMaskQuotient_span] + exact (ConcretePrimeRowBridge.span_idealGenerator _).symm + have hnorm := weighted_secondRayChild_normalized p hp hcop hg hinj hpr + x.source.sourceCommon x.source.divisor hE (globalSecondRawPool F x) x.source.overlap Ψ Ψ + m' c d x.source.frequency r ray hr X Y hX U hUc hUs g₁ g₂ W hU₁ hU₂ + have hscale : X/(‖ConcreteTraceCRT.eisEmbedding e‖^2*‖ConcreteTraceCRT.eisEmbedding r‖^2)= + globalActualResidualScale p ell side x := globalResidualScale_eq p ell side x + dsimp only at hnorm + rw [hscale] at hnorm + have hcoords := globalPooled_log_coordinates p hp ell hell side x hk + have hid' := hid p hp hcop hg (globalLogRep j 5) (globalLogRep j 6) (globalLogRep j 7) + (globalActualResidualScale p ell side x) (globalPooledColumnScale ell j) (globalLogRep j 8) Y + (globalLogRep_pos j 5) (globalLogRep_pos j 6) (globalLogRep_pos j 7) + (globalActualResidualScale_pos p hp ell hell side x) (globalPooledColumnScale_pos ell hell j) (globalLogRep_pos j 8) + (globalSecondRawPool F x) x.source.overlap (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) + m' r c d e x.source.frequency (primeSubsetGenerator_ne_zero _ _) (primeSubsetGenerator_ne_zero _ _) hk + hcoords.1 hcoords.2.1 hcoords.2.2.1 hcoords.2.2.2.1 hcoords.2.2.2.2 + rw [hid'] at hnorm + have hgoal := congrArg (fun z : ℂ => (primeProductNorm p x.firstCommon : ℂ)⁻¹ * + ((Y : ℂ)*secondSourceCommonCoefficient p hg Ψ m' c d x.source.sourceCommon x.source.divisor) * z) hnorm + have hrow : newRow (globalSecondTuple p x) = d*e*x.source.frequency := rfl + have hlabel : globalSecondLabel p x = c*e*∏ i ∈ x.source.overlap,p i := rfl + have hmask : globalSecondRawMask p m x = m'*r := rfl + have hz : globalBinZ p ell side j x = + Real.log (primeProductNorm p x.source.overlap*globalPooledColumnScale ell j / + globalActualResidualScale p ell side x) := rfl + have hud : globalBinUd p j x = Real.log (SecondPassIntegration.elementNorm d/globalLogRep j 5) := rfl + have hue : globalBinUe p j x = Real.log (SecondPassIntegration.elementNorm e/globalLogRep j 6) := rfl + have huv : globalBinUv p j x = Real.log (primeProductNorm p x.source.overlap/globalLogRep j 7) := rfl + have hkap : globalBinKap p j x = Real.log (SecondPassIntegration.elementNorm (d*e*x.source.frequency)/globalLogRep j 8) := rfl + change globalSecondLiteralTerm p hp hcop hg F Ψ m ray g₁ g₂ W ell Y side x = _ + rw [hrow,hlabel,hmask,hz,hud,hue,huv,hkap] + have hq := secondExpansionQuotient_of_subset p x.source hE + simp only [globalSecondLiteralTerm,secondExpansionSource,Finset.sum_singleton,hq, + globalSecondOuterWeight,secondNormalizedExpansionWeight, + globalResidualScale_eq p ell side x,globalBinRadial,m',c,d,e,r,X,j,mul_neg,mul_assoc] at hgoal ⊢ + exact hgoal + +end + +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm normalizedColumn columnLog b0Label) +open JointLogSeparation (halfNormalizationCLM frequencyTwist frequencyTwist_apply halfNormalization_twist) +open SecondPassFiber (newRow) + +theorem globalSecondLiteralTerm_twisted_profiles + (U : ℝ → ℂ) (hUc : HasCompactSupport U) (hUs : ContDiff ℝ ∞ U) + (g₁ g₂ W : 𝓢(ℝ,ℂ)) (A : ℝ) (hA : 0 ≤ A) + (hU₁ : ∀ t,g₁ t ≠ 0 → U t=1) (hU₂ : ∀ t,g₂ t ≠ 0 → U t=1) + (hg₁ : ∀ t,g₁ t ≠ 0 → |t| ≤ A) (hg₂ : ∀ t,g₂ t ≠ 0 → |t| ≤ A) : + ∃ (A₁ A₂ : 𝓢(ℝ,ℂ)) (windows : Fin 7 → ℝ → ℂ), + (∀ i,HasCompactSupport (windows i)) ∧ (∀ i,ContDiff ℝ ∞ (windows i)) ∧ + (∀ i t,windows i t ≠ 0 → |t| ≤ A+6+1) ∧ + ∀ {ι : Type*} [DecidableEq ι] (p : ι → O) (hp : ∀ i,p i ≠ 0) + [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,lambda ∉ Ideal.span {p i}) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hpr : ∀ i,lambda^2 ∣ p i-1) + (F : Finset ι) (Ψ : O →* ℂ) (m : O) (ray : SecondRayIndex) + (θ₁ θ₂ ell Y : ℝ) (side : Bool) (x : GlobalSecondData ι), + 0 < ell → x.source.divisor ⊆ x.source.sourceCommon → x.source.frequency ≠ 0 → + let j := globalScaleIndex p side x + globalSecondLiteralTerm p hp hcop hg F Ψ m ray (frequencyTwist g₁ θ₁) (frequencyTwist g₂ θ₂) W ell Y side x = + globalSecondOuterWeight p hp hcop hg Ψ m ray ell Y side x * + postCommonSmoothPair p hp hcop hg (globalSecondRawPool F x) + (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) (globalSecondRawMask p m x) + (globalSecondLabel p x) (newRow (globalSecondTuple p x)) (-newRow (globalSecondTuple p x)) + (frequencyTwist A₁ (-θ₁)) (frequencyTwist A₂ θ₂) W windows (globalBinZ p ell side j x) (globalBinUd p j x) + (globalBinUe p j x) (globalBinUv p j x) (globalBinKap p j x) + (globalPooledColumnScale ell j) (globalPooledColumnScale ell j) (globalBinRadial ell Y j) := by + have h1 := SecondPassIntegration.halfNormalization_support_bound U hUc hUs g₁ A hg₁ + have h2 := SecondPassIntegration.halfNormalization_support_bound U hUc hUs g₂ A hg₂ + obtain ⟨A₁,A₂,windows,hwc,hws,hwb,hid⟩ := SecondPassIntegration.full_uniform_twisted_normalized_child_tests + (halfNormalizationCLM U g₁) (halfNormalizationCLM U g₂) W A 6 hA (by norm_num) h1 h2 + refine ⟨A₁,A₂,windows,hwc,hws,hwb,?_⟩ + intro ι _ p hp _ hcop hg hinj hpr F Ψ m ray θ₁ θ₂ ell Y side x hell hE hk + dsimp only + let j := globalScaleIndex p side x + let X := globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon + let r := primeSubsetGenerator (fun i => Ideal.span {p i}) (x.source.sourceCommon\x.source.divisor) + let c := secondBaseLabel p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent x.cube.leftBit x.cube.rightBit + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) x.firstDivisor + let e := primeSubsetGenerator (fun i => Ideal.span {p i}) x.source.divisor + let m' := m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit + have hX : 0 < X := div_pos (globalFirstColumnScale_pos p hp ell hell x side) + (FirstPassCubeLabels.primeProductNorm_pos p hp _) + have hr : Ideal.span {secondMaskQuotient p x.source.divisor x.source.sourceCommon hE}=Ideal.span {r} := by + rw [secondMaskQuotient_span] + exact (ConcretePrimeRowBridge.span_idealGenerator _).symm + have htw₁ : ∀ t, frequencyTwist g₁ θ₁ t ≠ 0 → U t = 1 := by + intro t ht + apply hU₁ t + intro hz + exact ht (by simp [frequencyTwist_apply,hz]) + have htw₂ : ∀ t, frequencyTwist g₂ θ₂ t ≠ 0 → U t = 1 := by + intro t ht + apply hU₂ t + intro hz + exact ht (by simp [frequencyTwist_apply,hz]) + have hnorm := weighted_secondRayChild_normalized p hp hcop hg hinj hpr + x.source.sourceCommon x.source.divisor hE (globalSecondRawPool F x) x.source.overlap Ψ Ψ + m' c d x.source.frequency r ray hr X Y hX U hUc hUs (frequencyTwist g₁ θ₁) (frequencyTwist g₂ θ₂) W htw₁ htw₂ + have hscale : X/(‖ConcreteTraceCRT.eisEmbedding e‖^2*‖ConcreteTraceCRT.eisEmbedding r‖^2)= + globalActualResidualScale p ell side x := globalResidualScale_eq p ell side x + dsimp only at hnorm + rw [hscale,halfNormalization_twist U hUc hUs,halfNormalization_twist U hUc hUs] at hnorm + have hcoords := globalPooled_log_coordinates p hp ell hell side x hk + have hid' := hid p hp hcop hg θ₁ θ₂ (globalLogRep j 5) (globalLogRep j 6) (globalLogRep j 7) + (globalActualResidualScale p ell side x) (globalPooledColumnScale ell j) (globalLogRep j 8) Y + (globalLogRep_pos j 5) (globalLogRep_pos j 6) (globalLogRep_pos j 7) + (globalActualResidualScale_pos p hp ell hell side x) (globalPooledColumnScale_pos ell hell j) (globalLogRep_pos j 8) + (globalSecondRawPool F x) x.source.overlap (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) + m' r c d e x.source.frequency (primeSubsetGenerator_ne_zero _ _) (primeSubsetGenerator_ne_zero _ _) hk + hcoords.1 hcoords.2.1 hcoords.2.2.1 hcoords.2.2.2.1 hcoords.2.2.2.2 + rw [hid'] at hnorm + have hgoal := congrArg (fun z : ℂ => (primeProductNorm p x.firstCommon : ℂ)⁻¹ * + ((Y : ℂ)*secondSourceCommonCoefficient p hg Ψ m' c d x.source.sourceCommon x.source.divisor) * z) hnorm + have hrow : newRow (globalSecondTuple p x) = d*e*x.source.frequency := rfl + have hlabel : globalSecondLabel p x = c*e*∏ i ∈ x.source.overlap,p i := rfl + have hmask : globalSecondRawMask p m x = m'*r := rfl + have hz : globalBinZ p ell side j x = + Real.log (primeProductNorm p x.source.overlap*globalPooledColumnScale ell j / + globalActualResidualScale p ell side x) := rfl + have hud : globalBinUd p j x = Real.log (SecondPassIntegration.elementNorm d/globalLogRep j 5) := rfl + have hue : globalBinUe p j x = Real.log (SecondPassIntegration.elementNorm e/globalLogRep j 6) := rfl + have huv : globalBinUv p j x = Real.log (primeProductNorm p x.source.overlap/globalLogRep j 7) := rfl + have hkap : globalBinKap p j x = Real.log (SecondPassIntegration.elementNorm (d*e*x.source.frequency)/globalLogRep j 8) := rfl + change globalSecondLiteralTerm p hp hcop hg F Ψ m ray (frequencyTwist g₁ θ₁) (frequencyTwist g₂ θ₂) W ell Y side x = _ + rw [hrow,hlabel,hmask,hz,hud,hue,huv,hkap] + have hq := secondExpansionQuotient_of_subset p x.source hE + simp only [globalSecondLiteralTerm,secondExpansionSource,Finset.sum_singleton,hq, + globalSecondOuterWeight,secondNormalizedExpansionWeight, + globalResidualScale_eq p ell side x,globalBinRadial,m',c,d,e,r,X,j,mul_neg,mul_assoc] at hgoal ⊢ + exact hgoal + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConjugateCuspProfiles.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConjugateCuspProfiles.lean new file mode 100644 index 0000000000000000000000000000000000000000..93f2f164581b36ac6dcd27e0fb54685a26ea5381 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConjugateCuspProfiles.lean @@ -0,0 +1,613 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.ArbitraryCuspPullback +import OAI.NumberTheory.DirichletL.Reciprocity.CubeCorrespondence + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory Asymptotics +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +theorem cuspBarProfile_conjugate_reflection (G : CubicKubota.levelThree) + (g H : SL(2,ℂ)) (hfactor : g=complexMatrix G*H) (hc : g 1 0≠0) + (v : ℝ) (hv : 0cubicSourceConjugateFunction (H•w)) (-g 1 1/g 1 0)) v := by + have hdual : 0<(‖g 1 0‖^2*v)⁻¹ := by positivity + rw [cuspBarProfile_positive _ _ _ hv,reflectedCuspProfile,cuspZProfile_positive _ _ _ hdual] + have he := cubicSourceConjugateFunction_cuspDerivative G g H hfactor hc v hv + have hpow : (v:ℂ)^(-2:ℂ)=((v:ℂ)^2)⁻¹ := by + rw [Complex.cpow_neg,Complex.cpow_ofNat] + rw [hpow] + simp only [one_div] at he + rw [he] + ring + +theorem conjugateSource_principal_cusp_mellin_entire (G : CubicKubota.levelThree) + (hc : complexMatrix G 1 0≠0) : + (∀s : ℂ,MellinConvergent + (cuspBarProfile cubicSourceConjugateFunction (complexMatrix G 0 0/complexMatrix G 1 0)) s) ∧ + Differentiable ℂ + (mellin (cuspBarProfile cubicSourceConjugateFunction (complexMatrix G 0 0/complexMatrix G 1 0))) := by + let g := complexMatrix G + apply cusp_mellin_entire + (cuspBarProfile cubicSourceConjugateFunction (g 0 0/g 1 0)) + (cuspZProfile cubicSourceConjugateFunction (-g 1 1/g 1 0)) + (-star (CubicKubota.complexCharacter G)/(g 1 0)^2) (‖g 1 0‖^2) + residualCuspDecayRate residualCuspDecayRate + · change 0<‖complexMatrix G 1 0‖^2 + positivity + · exact residualCuspDecayRate_pos + · exact residualCuspDecayRate_pos + · exact cuspBarProfile_conjugate_continuousOn _ + · exact cuspZProfile_conjugate_continuousOn _ + · exact cuspBarProfile_conjugate_isBigO _ + · exact cuspZProfile_conjugate_isBigO _ + · intro v hv + simpa only [one_smul] using cuspBarProfile_conjugate_reflection G g 1 (by simp [g]) hc v hv + +theorem conjugateSource_cusp_mellin_reflection (G : CubicKubota.levelThree) + (g H : SL(2,ℂ)) (hfactor : g=complexMatrix G*H) (hc : g 1 0≠0) (s : ℂ) : + mellin (cuspBarProfile cubicSourceConjugateFunction (g 0 0/g 1 0)) (2*s)= + (-star (CubicKubota.complexCharacter G)/(g 1 0)^2)*(‖g 1 0‖^2:ℝ)^(2-2*s:ℂ)* + mellin (cuspZProfile (fun w=>cubicSourceConjugateFunction (H•w)) (-g 1 1/g 1 0)) (2-2*s) := by + apply cusp_mellin_reflection_of_identity _ _ _ _ _ (by positivity) + intro v hv + exact cuspBarProfile_conjugate_reflection G g H hfactor hc v hv + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma cubicBesselIntegralDeriv_continuousAt (x : ℝ) (hx : 0∫t in Set.Ioi (0:ℝ),cubicBesselDensityDeriv y t) x := by + let delta := x/2 + have hdelta : 0(4/delta)*(t^(-(2:ℝ)/3)*Real.exp (-t/2))) + · exact Eventually.of_forall (fun y=>by unfold cubicBesselDensityDeriv cubicBesselDensity;fun_prop) + · filter_upwards [Ioi_mem_nhds (show deltaby unfold cubicBesselDensityDeriv cubicBesselDensity;fun_prop) + +lemma schlafliBesselK_cubic_derivative_continuousAt (x : ℝ) (hx : 0(y/2)^(-(4:ℝ)/3)) x := + (continuousAt_id.div_const 2).rpow_const (Or.inl (by positivity)) + have hp1 : ContinuousAt (fun y : ℝ=>(y/2)^(-(1:ℝ)/3)) x := + (continuousAt_id.div_const 2).rpow_const (Or.inl (by positivity)) + have hI := (cubicBesselIntegral_hasDerivAt x hx).continuousAt + have hD := cubicBesselIntegralDeriv_continuousAt x hx + apply Complex.continuous_ofReal.continuousAt.comp + exact ((continuousAt_const.mul hp4).mul hI).add ((continuousAt_const.mul hp1).mul hD) + +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma amplitudeDeriv_continuousAt (v : ℝ) (hv : 0coeff.amplitudeDeriv y h) v := by + by_cases hh : h=0 + · simpa only [amplitudeDeriv,ite_eq_left hh] using (continuousAt_const (y:=(0:ℂ)) (x:=v)) + have hr : 0<‖cuspFrequency h‖ := norm_pos_iff.mpr (cuspFrequency_ne_zero h hh) + have hK : ContinuousAt (fun y : ℝ=>schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*y)) v := + (schlafliBesselK_cubic_hasDerivAt _ (by positivity)).continuousAt.comp (by fun_prop) + have hD : ContinuousAt (fun y : ℝ=>schlafliBesselK_cubic_derivative (4*Real.pi*‖cuspFrequency h‖*y)) v := + (schlafliBesselK_cubic_derivative_continuousAt _ (by positivity)).comp (by fun_prop) + simp only [amplitudeDeriv,ite_eq_right hh] + exact continuousAt_const.mul (hK.add ((Complex.continuous_ofReal.continuousAt.mul continuousAt_const).mul hD)) + +lemma termFDeriv_continuousAt (h : ActualEisensteinCubic.O) (p : ℝ × ℂ) (hp : 0(0:(ℝ × ℂ)→L[ℝ]ℂ) := by + funext q + simp only [termFDeriv,ite_eq_left hh] + rw [he] + exact continuousAt_const + have hA := (coeff.amplitudeDeriv_continuousAt p.1 hp h).comp continuousAt_fst + have hphase : ContinuousAt (fun q : ℝ × ℂ=>ShortDraftTrace.breveE (cuspFrequency h*q.2)) p := by + change ContinuousAt (fun q : ℝ × ℂ=>Complex.exp (2*Real.pi*Complex.I* + ((cuspFrequency h*q.2)+starRingEnd ℂ (cuspFrequency h*q.2)))) p + fun_prop + have hfirst := (ContinuousLinearMap.smulRightL ℝ (ℝ × ℂ) ℂ + (ContinuousLinearMap.fst ℝ ℝ ℂ)).continuous.continuousAt.comp (hA.mul hphase) + have hterm := (coeff.term_continuousOn h).continuousAt + ((isOpen_lt continuous_const continuous_fst).mem_nhds hp) + have hsecond := hterm.smul (continuousAt_const + (y:=(horizontalPhaseCLM (cuspFrequency h)).comp (ContinuousLinearMap.snd ℝ ℝ ℂ))) + have he : coeff.termFDeriv h=(fun q : ℝ × ℂ=> + (ContinuousLinearMap.fst ℝ ℝ ℂ).smulRight + (coeff.amplitudeDeriv q.1 h*ShortDraftTrace.breveE (cuspFrequency h*q.2))+ + coeff.term h q • (horizontalPhaseCLM (cuspFrequency h)).comp (ContinuousLinearMap.snd ℝ ℝ ℂ)) := by + funext q + simp only [termFDeriv,ite_eq_right hh] + rw [he] + exact hfirst.add hsecond + +lemma seriesFDeriv_continuousOn_slab (a b : ℝ) (ha : 0∑'h : ActualEisensteinCubic.O,coeff.termFDeriv h p) + {p : ℝ × ℂ|p.1∈Set.Icc a b} := by + obtain ⟨C,hC,hbound⟩ := coeff.termFDeriv_slab_bound a b ha hab + apply continuousOn_tsum (u:=fun h : ActualEisensteinCubic.O=>C*((1+‖cuspFrequency h‖)*Real.exp (-(Real.pi*a)*‖cuspFrequency h‖))) + · intro h p hp + exact (coeff.termFDeriv_continuousAt h p (ha.trans_le hp.1)).continuousWithinAt + · exact (summable_one_add_norm_exp_neg_cuspFrequency (Real.pi*a) (mul_pos Real.pi_pos ha)).mul_left C + · exact hbound + +lemma series_contDiffAt_one (p : ℝ × ℂ) (hp : 0∑'h : ActualEisensteinCubic.O,coeff.termFDeriv h q), + {q : ℝ × ℂ|q.1∈Set.Icc (p.1/2) (2*p.1)},?_,?_,?_⟩ + · exact continuousAt_fst.tendsto.eventually (Icc_mem_nhds (by linarith) (by linarith)) + · exact coeff.seriesFDeriv_continuousOn_slab _ _ (by linarith) (by linarith) + · intro q hq + exact coeff.series_hasFDerivAt q (by change p.1/2≤q.1 ∧ q.1≤2*p.1 at hq;linarith [hq.1]) + +end SubexponentialBesselCoefficients +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +def cuspSpatialInput (q : ℝ × ℂ) : SpatialCoordinates := ![q.2.re,q.2.im,q.1] +def cuspSpatialOutput (p : SpatialCoordinates) : ℝ × ℂ := (p 2,spatialHorizontal p) + +lemma cuspSpatialInput_contDiff : ContDiff ℝ 1 cuspSpatialInput := by + apply contDiff_pi.mpr + intro j + fin_cases j + · change ContDiff ℝ 1 (fun q : ℝ × ℂ=>q.2.re) + exact Complex.reCLM.contDiff.comp contDiff_snd + · change ContDiff ℝ 1 (fun q : ℝ × ℂ=>q.2.im) + exact Complex.imCLM.contDiff.comp contDiff_snd + · change ContDiff ℝ 1 (fun q : ℝ × ℂ=>q.1) + fun_prop + +lemma cuspSpatialOutput_contDiff : ContDiff ℝ 1 cuspSpatialOutput := + (contDiff_apply ℝ ℝ 2).prodMk (spatialHorizontal_contDiff.of_le (by simp)) + +lemma cuspSpatialInput_horizontal (q : ℝ × ℂ) : spatialHorizontal (cuspSpatialInput q)=q.2 := + Complex.re_add_im q.2 + +lemma cuspSpatialAction_lift (g : SL(2,ℂ)) (q : ℝ × ℂ) (hq : 0coeff.fullFunction constant (cuspCoordinateLift q)) p := by + have hreal : ContDiffAt ℝ 1 (fun q : ℝ × ℂ=>q.1^(2/3:ℝ)) p := + contDiff_fst.contDiffAt.rpow_const_of_ne hp.ne' + have hcast := Complex.ofRealCLM.contDiff.contDiffAt.comp p hreal + have hpow : ContDiffAt ℝ 1 (fun q : ℝ × ℂ=>(q.1:ℂ)^(2/3:ℂ)) p := by + apply hcast.congr_of_eventuallyEq + filter_upwards [continuousAt_fst.tendsto.eventually (Ioi_mem_nhds hp)] with q hq + have he := Complex.ofReal_cpow (le_of_lt hq) (2/3:ℝ) + norm_num only [Complex.ofReal_div,Complex.ofReal_ofNat] at he + exact he.symm + have hfull : ContDiffAt ℝ 1 (fun q : ℝ × ℂ=>constant*(q.1:ℂ)^(2/3:ℂ)+coeff.series q) p := + (contDiffAt_const.mul hpow).add (coeff.series_contDiffAt_one p hp) + apply hfull.congr_of_eventuallyEq + filter_upwards [continuousAt_fst.tendsto.eventually (Ioi_mem_nhds hp)] with q hq + exact coeff.fullFunction_cusp_eq constant q hq + +lemma fullFunction_translate_cusp_contDiffAt_one (constant : ℂ) (g : SL(2,ℂ)) + (p : ℝ × ℂ) (hp : 0coeff.fullFunction constant (g•cuspCoordinateLift q)) p := by + have hmid : ContDiffAt ℝ 1 (fun q=>mobiusSpatial g (cuspSpatialInput q)) p := + ((mobiusSpatial_contDiffAt g (cuspSpatialInput p) hp).of_le (by simp)).comp p + cuspSpatialInput_contDiff.contDiffAt + have hact := cuspSpatialOutput_contDiff.contDiffAt.comp p hmid + have hpos : 0<(cuspSpatialOutput (mobiusSpatial g (cuspSpatialInput p))).1 := + mobiusSpatial_positive g _ hp + have hfull := (coeff.fullFunction_cusp_contDiffAt_one constant _ hpos).comp p hact + apply hfull.congr_of_eventuallyEq + filter_upwards [continuousAt_fst.tendsto.eventually (Ioi_mem_nhds hp)] with q hq + exact congrArg (coeff.fullFunction constant) (cuspSpatialAction_lift g q hq).symm + +lemma fullFunction_translate_split_contDiffAt_one (constant : ℂ) (g : SL(2,ℂ)) + (p : ℂ × ℝ) (hp : 0coeff.fullFunction constant (g•cuspCoordinateLift (q.2,q.1))) p := by + have hswap : ContDiffAt ℝ 1 (fun q : ℂ × ℝ=>(q.2,q.1)) p := by fun_prop + exact (coeff.fullFunction_translate_cusp_contDiffAt_one constant g (p.2,p.1) hp).comp p hswap + +end SubexponentialBesselCoefficients + +lemma cubicSourceResidualFunction_translate_split_contDiffAt_one (g : SL(2,ℂ)) + (p : ℂ × ℝ) (hp : 0cubicSourceResidualFunction (g•cuspCoordinateLift (q.2,q.1))) p := by + rw [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselCoefficients.fullFunction_translate_split_contDiffAt_one _ g p hp + +lemma cubicSourceConjugateFunction_translate_split_contDiffAt_one (g : SL(2,ℂ)) + (p : ℂ × ℝ) (hp : 0cubicSourceConjugateFunction (g•cuspCoordinateLift (q.2,q.1))) p := by + exact Complex.conjCLE.contDiff.contDiffAt.comp p + (cubicSourceResidualFunction_translate_split_contDiffAt_one g p hp) + +lemma horizontalWirtingerBar_eq_fderiv (F : ℂ × ℝ→ℂ) (A : (ℂ × ℝ)→L[ℝ]ℂ) + (z : ℂ) (v : ℝ) (hF : HasFDerivAt F A (z,v)) : + horizontalWirtingerBar (fun w=>F (w,v)) z= + (1/2:ℂ)*(A (1,0)+Complex.I*A (Complex.I,0)) := by + have hline (direction : ℂ) : + HasDerivAt (fun t : ℝ=>F (z+(t:ℂ)*direction,v)) (A (direction,0)) 0 := by + have hz : HasDerivAt (fun t : ℝ=>z+(t:ℂ)*direction) direction 0 := by + simpa using (((hasDerivAt_id (0:ℝ)).ofReal_comp.mul_const direction).const_add z) + have hp := hz.prodMk (hasDerivAt_const (0:ℝ) v) + have hf : HasFDerivAt F A (z+(0:ℂ)*direction,v) := by simpa using hF + exact hf.comp_hasDerivAt 0 hp + have h1 := (hline 1).deriv + have hI := (hline Complex.I).deriv + simp only [mul_one] at h1 + rw [horizontalWirtingerBar,h1,hI] + +lemma cuspBarProfile_continuousOn_of_contDiff (f : HyperbolicSpace→ℂ) + (hreg : ∀p : ℂ × ℝ,0f (cuspCoordinateLift (q.2,q.1))) p) (z : ℂ) : + ContinuousOn (cuspBarProfile f z) (Set.Ioi 0) := by + let F : ℂ × ℝ→ℂ := fun q=>f (cuspCoordinateLift (q.2,q.1)) + intro v hv + have hd : ContinuousAt (fderiv ℝ F) (z,v) := + (hreg (z,v) hv).continuousAt_fderiv (by norm_num) + have hc : ContinuousAt (fun y : ℝ=>(z,y)) v := continuousAt_const.prodMk continuousAt_id + have h1 := (hd.comp hc).clm_apply (continuousAt_const (y:=((1,0):ℂ × ℝ))) + have hI := (hd.comp hc).clm_apply (continuousAt_const (y:=((Complex.I,0):ℂ × ℝ))) + have hformula : ContinuousAt (fun y : ℝ=>(1/2:ℂ)* + ((fderiv ℝ F (z,y)) (1,0)+Complex.I*(fderiv ℝ F (z,y)) (Complex.I,0))) v := + continuousAt_const.mul (h1.add (continuousAt_const.mul hI)) + apply ContinuousAt.continuousWithinAt + apply hformula.congr_of_eventuallyEq + filter_upwards [Ioi_mem_nhds (show 0f (cuspCoordinateLift (q.2,q.1))) p) (z : ℂ) : + ContinuousOn (cuspZProfile f z) (Set.Ioi 0) := by + let F : ℂ × ℝ→ℂ := fun q=>f (cuspCoordinateLift (q.2,q.1)) + intro v hv + have hd : ContinuousAt (fderiv ℝ F) (z,v) := + (hreg (z,v) hv).continuousAt_fderiv (by norm_num) + have hc : ContinuousAt (fun y : ℝ=>(z,y)) v := continuousAt_const.prodMk continuousAt_id + have h1 := (hd.comp hc).clm_apply (continuousAt_const (y:=((1,0):ℂ × ℝ))) + have hI := (hd.comp hc).clm_apply (continuousAt_const (y:=((Complex.I,0):ℂ × ℝ))) + have hformula : ContinuousAt (fun y : ℝ=>(1/2:ℂ)* + ((fderiv ℝ F (z,y)) (1,0)-Complex.I*(fderiv ℝ F (z,y)) (Complex.I,0))) v := + continuousAt_const.mul (h1.sub (continuousAt_const.mul hI)) + apply ContinuousAt.continuousWithinAt + apply hformula.congr_of_eventuallyEq + filter_upwards [Ioi_mem_nhds (show 0cubicSourceResidualFunction (H•w)) z) (Set.Ioi 0) := + cuspBarProfile_continuousOn_of_contDiff _ + (cubicSourceResidualFunction_translate_split_contDiffAt_one H) z + +lemma cuspZProfile_source_translate_continuousOn (H : SL(2,ℂ)) (z : ℂ) : + ContinuousOn (cuspZProfile (fun w=>cubicSourceResidualFunction (H•w)) z) (Set.Ioi 0) := + cuspZProfile_continuousOn_of_contDiff _ + (cubicSourceResidualFunction_translate_split_contDiffAt_one H) z + +lemma cuspBarProfile_conjugate_translate_continuousOn (H : SL(2,ℂ)) (z : ℂ) : + ContinuousOn (cuspBarProfile (fun w=>cubicSourceConjugateFunction (H•w)) z) (Set.Ioi 0) := + cuspBarProfile_continuousOn_of_contDiff _ + (cubicSourceConjugateFunction_translate_split_contDiffAt_one H) z + +lemma cuspZProfile_conjugate_translate_continuousOn (H : SL(2,ℂ)) (z : ℂ) : + ContinuousOn (cuspZProfile (fun w=>cubicSourceConjugateFunction (H•w)) z) (Set.Ioi 0) := + cuspZProfile_continuousOn_of_contDiff _ + (cubicSourceConjugateFunction_translate_split_contDiffAt_one H) z + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical + +open ActualEisensteinCubic ConcreteTraceCRT CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma ninth_trace_character_period (c x : Eis) : + ShortDraftTrace.breveE ((eisEmbedding c/(9*eisLam))*(9*eisEmbedding x))=1 := by + have he : (eisEmbedding c/(9*eisLam))*(9*eisEmbedding x)=eisEmbedding (c*x)/eisLam := by + rw [map_mul] + ring + rw [he,breveE_embedding_div_traceLambda] + +lemma ramifiedSource_scaled_periodic10 (v : ℝ) (hv : 0 omega_primitive.ne_one (by decide) (eisEmbedding_injective (by simpa using h)) + · intro z + have he : 3*(1+z)=3*z+3*eisEmbedding (ActualEisensteinCoordinates.eval 1 0) := by + norm_num [ActualEisensteinCoordinates.eval] + ring + rw [he,ramifiedSourceFunction_upper_shift10,ramifiedShift10_period] + norm_num [cubicExp] + +theorem ramifiedSource_zero_mode19 (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +abbrev UnitLowerData := Σa:PrimaryLower,{d:PrimaryLower//IsCoprime a.val d.val} + +def unitLowerToPrimitive (u : Eisˣ) (p : UnitLowerData) : PrimitiveRow := by + refine ⟨![(u:Eis)*(p.1.val-p.2.val.val),p.2.val.val],?_,?_,p.2.val.2⟩ + · change IsCoprime ((u:Eis)*(p.1.val-p.2.val.val)) p.2.val.val + apply (isCoprime_mul_unit_left_left u.isUnit _ _).mpr + apply IsCoprime.symm + apply (isCoprime_right_congr_of_dvd p.2.val.val (p.1.val-p.2.val.val) p.1.val + ⟨-1,by ring⟩).mpr + exact p.2.2.symm + · have hd : (3:Eis)∣p.1.val-p.2.val.val := by + simpa only [sub_sub_sub_cancel_right] using dvd_sub p.1.2 p.2.val.2 + exact hd.mul_left (u:Eis) + +lemma unitLowerToPrimitive_bijective (u : Eisˣ) : + Function.Bijective (unitLowerToPrimitive u) := by + constructor + · rintro ⟨a,d,hd⟩ ⟨b,e,he⟩ h + have hrow := congrArg Subtype.val h + have hde : d=e := Subtype.ext (congrFun hrow 1) + subst e + have hab : a=b := by + apply Subtype.ext + have hh := congrFun hrow 0 + change (u:Eis)*(a.val-d.val)=(u:Eis)*(b.val-d.val) at hh + have hcancel := u.isUnit.mul_left_cancel hh + linear_combination hcancel + subst b + rfl + · intro r + let d : PrimaryLower := ⟨r.val 1,r.2.2.2⟩ + let a : PrimaryLower := ⟨(↑u⁻¹:Eis)*r.val 0+r.val 1,by + have hc := r.2.2.1.mul_left (↑u⁻¹:Eis) + have hh := dvd_add hc r.2.2.2 + convert hh using 1 ;ring⟩ + have hcop : IsCoprime a.val d.val := by + apply IsCoprime.symm + apply (isCoprime_right_congr_of_dvd d.val a.val ((↑u⁻¹:Eis)*r.val 0) + ⟨1,by dsimp [a,d];ring⟩).mpr + exact (isCoprime_mul_unit_left_right u⁻¹.isUnit _ _).mpr r.2.1.symm + refine ⟨⟨a,d,hcop⟩,Subtype.ext ?_⟩ + funext i + fin_cases i + · change (u:Eis)*((↑u⁻¹:Eis)*r.val 0+r.val 1-r.val 1)=r.val 0 + rw [add_sub_cancel_right,←mul_assoc] + simp + · rfl + +def unitLowerEquiv (u : Eisˣ) : UnitLowerData≃PrimitiveRow := + Equiv.ofBijective _ (unitLowerToPrimitive_bijective u) + +lemma rowOperator_lowerCusp (t : Eis) (v : Fin 2→ℂ) : + rowOperator (integralComplexMatrix (lowerCuspMatrix t)) v= + ![v 0+eisEmbedding t*v 1,v 1] := by + rw [rowOperator_apply] + funext i + simp only [Matrix.vecMul,dotProduct,Fin.sum_univ_two,integralComplexMatrix_apply] + fin_cases i <;> + simp [lowerCuspMatrix,mul_comm] + +lemma unitLower_row_phase (u : Eisˣ) (p : UnitLowerData) : + (cosetCharacter (primitiveRowEquiv.symm (unitLowerEquiv u p)))⁻¹= + eisEmbedding (symbol (u:Eis) p.2.val.val)* + eisEmbedding (symbol p.2.val.val p.1.val) := by + rw [inverse_cosetCharacter_eq_row_symbol,primitiveRowEquiv_symm_row] + change eisEmbedding (symbol ((u:Eis)*(p.1.val-p.2.val.val)) p.2.val.val)=_ + have hh : symbol ((u:Eis)*(p.1.val-p.2.val.val)) p.2.val.val= + symbol ((u:Eis)*p.1.val) p.2.val.val := by + exact symbol_congr ⟨-(u:Eis),by ring⟩ + rw [hh,symbol_mul_numerator _ _ _ (primaryLower_primary p.2.val), + symbol_reciprocity p.1.val p.2.val.val (primaryLower_ne_zero p.1) + (primaryLower_ne_zero p.2.val) (primaryLower_primary p.1) + (primaryLower_primary p.2.val),map_mul] + +def unitLowerTerm (u : Eisˣ) (z : ℂ) (v : ℝ) (s : ℂ) (a d : Eis) : ℂ := + (eisEmbedding (symbol (u:Eis) d)*eisEmbedding (symbol d a))* + ((v/(‖eisEmbedding ((u:Eis)*a)*z+eisEmbedding d‖^2+ + ‖eisEmbedding ((u:Eis)*a)‖^2*v^2):ℝ):ℂ)^s + +lemma unitLower_summand (u : Eisˣ) (z : ℂ) (v : ℝ) (hv : 0 + simp [unitLowerEquiv, Equiv.ofBijective_apply, unitLowerToPrimitive, r, map_mul, map_sub, mul_sub] + have hr0 : r≠0 := by + intro hh + have he := congrFun hh 1 + exact eisEmbedding_ne_zero (primaryLower_ne_zero p.2.val) he + have hp := heightDenominator_pos z v hv r hr0 + rw [summand,←rowOperator_mul,hr,rowEnergy_upperSection,unitLower_row_phase] + change _=(eisEmbedding (symbol (u:Eis) p.2.val.val)*eisEmbedding (symbol p.2.val.val p.1.val))* + ((v/heightDenominator z v r:ℝ):ℂ)^s + have hi : ((v/heightDenominator z v r:ℝ):ℂ)= + (((heightDenominator z v r/v:ℝ):ℂ))⁻¹ := by + simp only [Complex.ofReal_div,inv_div] + rw [hi,Complex.inv_cpow_ofReal_nonneg (div_nonneg hp.le hv.le),Complex.cpow_neg] + +theorem unitLowerEisenstein_eq_rows (u : Eisˣ) (z : ℂ) (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +lemma globalKubotaKernel_conjugate_mem (M : levelThree) (N : globalKubotaKernel) : + (M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹∈globalKubotaKernel := by + obtain ⟨n,hn,hnval⟩ := N.property + change (n:SL(2,ActualEisensteinCubic.O))=(N:SL(2,ActualEisensteinCubic.O)) at hnval + refine ⟨M*n*M⁻¹,?_,?_⟩ + · change finiteCubicMultiplier (M*n*M⁻¹)=1 + change finiteCubicMultiplier n=1 at hn + simp only [map_mul,map_inv,hn,mul_one,mul_inv_cancel] + · change (M:SL(2,ActualEisensteinCubic.O))*(n:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹=_ + rw [hnval] + +def kernelConjugate (M : levelThree) : globalKubotaKernel ≃* globalKubotaKernel where + toFun N := ⟨(M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹,globalKubotaKernel_conjugate_mem M N⟩ + invFun N := ⟨(M⁻¹:levelThree)*(N:SL(2,ActualEisensteinCubic.O))*(M⁻¹:levelThree)⁻¹,globalKubotaKernel_conjugate_mem M⁻¹ N⟩ + left_inv N := by apply Subtype.ext; simp [mul_assoc] + right_inv N := by apply Subtype.ext; simp [mul_assoc] + map_mul' N P := by apply Subtype.ext; simp [mul_assoc] + +lemma kernelConjugate_coe (M : levelThree) (N : globalKubotaKernel) : + (kernelConjugate M N : SL(2,ActualEisensteinCubic.O))=(M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹ := rfl + +lemma level_action_respects_kernel (M : levelThree) (u v : HyperbolicSpace) + (h : (integralOrbitRel globalKubotaKernel).r u v) : + (integralOrbitRel globalKubotaKernel).r (complexMatrix M • u) (complexMatrix M • v) := by + obtain ⟨N,hN⟩ := h + refine ⟨kernelConjugate M N,?_⟩ + change integralComplexMatrix ((M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹) • + (complexMatrix M • u)=complexMatrix M • v + rw [map_mul,map_mul,map_inv,mul_smul,mul_smul] + change complexMatrix M • (integralComplexMatrix (N:SL(2,ActualEisensteinCubic.O)) • + ((complexMatrix M)⁻¹ • (complexMatrix M • u)))=_ + rw [inv_smul_smul,hN] + +def kernelLevelAction (M : levelThree) : KernelQuotient→KernelQuotient := + Quotient.map' (fun w => complexMatrix M • w) (level_action_respects_kernel M) + +lemma kernelLevelAction_mk (M : levelThree) (w : HyperbolicSpace) : + kernelLevelAction M (integralOrbitProjection globalKubotaKernel w)= + integralOrbitProjection globalKubotaKernel (complexMatrix M • w) := rfl + +lemma kernelLevelAction_one (q : KernelQuotient) : kernelLevelAction 1 q=q := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection globalKubotaKernel (complexMatrix 1 • w)=integralOrbitProjection globalKubotaKernel w + rw [map_one,one_smul] + +lemma kernelLevelAction_mul (M N : levelThree) (q : KernelQuotient) : + kernelLevelAction (M*N) q=kernelLevelAction M (kernelLevelAction N q) := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection globalKubotaKernel (complexMatrix (M*N) • w)= + integralOrbitProjection globalKubotaKernel (complexMatrix M • (complexMatrix N • w)) + rw [map_mul,mul_smul] + +lemma kernelLevelAction_continuous (M : levelThree) : Continuous (kernelLevelAction M) := + (continuous_hyperbolic_action (complexMatrix M)).quotient_map' (level_action_respects_kernel M) + +def kernelLevelHomeomorph (M : levelThree) : KernelQuotient ≃ₜ KernelQuotient where + toFun := kernelLevelAction M + invFun := kernelLevelAction M⁻¹ + left_inv q := by rw [←kernelLevelAction_mul,inv_mul_cancel,kernelLevelAction_one] + right_inv q := by rw [←kernelLevelAction_mul,mul_inv_cancel,kernelLevelAction_one] + continuous_toFun := kernelLevelAction_continuous M + continuous_invFun := kernelLevelAction_continuous M⁻¹ + +lemma kernelLevelAction_eisenstein (M : levelThree) (s : ℂ) (hs : 2 + exact hyperbolicEisenstein_automorphy M s hs w + +lemma kernelLevelAction_seed (M : levelThree) (a b : ℝ) (s : ℂ) (q : KernelQuotient) : + kernelQuotientSeed a b s (kernelLevelAction M q)=complexCharacter M*kernelQuotientSeed a b s q := by + induction q using Quotient.inductionOn with + | _ w => exact smoothCuspSeed_automorphy a b s M w + +lemma kernelLevelAction_defect (M : levelThree) (a b : ℝ) (s : ℂ) (q : KernelQuotient) : + kernelQuotientDefect a b s (kernelLevelAction M q)=complexCharacter M*kernelQuotientDefect a b s q := by + induction q using Quotient.inductionOn with + | _ w => exact smoothCuspSeedDefect_automorphy a b s M w + +lemma kernelLevelAction_fundamentalDomain (M : levelThree) : + IsFundamentalDomain globalKubotaKernel + ((fun w : HyperbolicSpace => complexMatrix M • w) '' hyperbolicFundamentalSet globalKubotaKernel) + hyperbolicVolume := by + apply (hyperbolicFundamentalSet_isFundamentalDomain globalKubotaKernel + globalKubotaKernel_le_levelThree).image_of_equiv (MulAction.toPerm (complexMatrix M)) + (show Measure.QuasiMeasurePreserving (MulAction.toPerm (complexMatrix M)).symm hyperbolicVolume hyperbolicVolume from by + exact (measurePreserving_smul (complexMatrix M)⁻¹ hyperbolicVolume).quasiMeasurePreserving) + (kernelConjugate M⁻¹).toEquiv + intro N w + change complexMatrix M • (integralComplexMatrix + ((M⁻¹:levelThree)*(N:SL(2,ActualEisensteinCubic.O))*(M⁻¹:levelThree)⁻¹) • w)= + integralComplexMatrix (N:SL(2,ActualEisensteinCubic.O)) • (complexMatrix M • w) + simp only [Subgroup.coe_inv,map_mul,map_inv] + change complexMatrix M • (((complexMatrix M)⁻¹*integralComplexMatrix (N:SL(2,ActualEisensteinCubic.O))* + ((complexMatrix M)⁻¹)⁻¹) • w)=_ + simp only [inv_inv,mul_smul,smul_inv_smul] + +lemma kernelLevelAction_measurePreserving (M : levelThree) : + MeasurePreserving (kernelLevelAction M) (integralQuotientVolume globalKubotaKernel) + (integralQuotientVolume globalKubotaKernel) := by + refine ⟨(kernelLevelAction_continuous M).measurable,?_⟩ + let act : HyperbolicSpace→HyperbolicSpace := fun w => complexMatrix M • w + have hmap := (measurePreserving_smul (complexMatrix M) hyperbolicVolume).restrict_image_emb + (measurableEmbedding_const_smul (complexMatrix M)) (hyperbolicFundamentalSet globalKubotaKernel) + have heq : kernelLevelAction M ∘ integralOrbitProjection globalKubotaKernel= + integralOrbitProjection globalKubotaKernel ∘ act := by ext w; rfl + change Measure.map (kernelLevelAction M) + (Measure.map (integralOrbitProjection globalKubotaKernel) + (hyperbolicVolume.restrict (hyperbolicFundamentalSet globalKubotaKernel)))=_ + rw [Measure.map_map (kernelLevelAction_continuous M).measurable + (measurable_integralOrbitProjection _),heq, + ←Measure.map_map (measurable_integralOrbitProjection _) (continuous_hyperbolic_action _).measurable] + change Measure.map (integralOrbitProjection globalKubotaKernel) + (Measure.map act (hyperbolicVolume.restrict (hyperbolicFundamentalSet globalKubotaKernel)))=_ + rw [hmap.map_eq] + exact integralQuotientVolume_independent globalKubotaKernel globalKubotaKernel_le_levelThree _ + (kernelLevelAction_fundamentalDomain M) + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open CubicKubota + +def kernelLevelPullback (M : levelThree) : KernelQuotientL2 →ₗᵢ[ℂ] KernelQuotientL2 := + Lp.compMeasurePreservingₗᵢ ℂ (kernelLevelAction M) (kernelLevelAction_measurePreserving M) + +lemma kernelLevelPullback_ae_eq (M : levelThree) (F : KernelQuotientL2) : + kernelLevelPullback M F=ᵐ[integralQuotientVolume globalKubotaKernel] + fun q => F (kernelLevelAction M q) := + Lp.coeFn_compMeasurePreserving F (kernelLevelAction_measurePreserving M) + +lemma kernelLevelPullback_one (F : KernelQuotientL2) : kernelLevelPullback 1 F=F := by + apply Lp.ext + filter_upwards [kernelLevelPullback_ae_eq 1 F] with q hq + simpa only [kernelLevelAction_one] using hq + +lemma kernelLevelPullback_comp (M N : levelThree) (F : KernelQuotientL2) : + kernelLevelPullback M (kernelLevelPullback N F)=kernelLevelPullback (N*M) F := by + have hcomp := (kernelLevelAction_measurePreserving M).quasiMeasurePreserving.ae_eq_comp + (kernelLevelPullback_ae_eq N F) + apply Lp.ext + filter_upwards [kernelLevelPullback_ae_eq M (kernelLevelPullback N F),hcomp, + kernelLevelPullback_ae_eq (N*M) F] with q hp hn hnm + rw [hp,hnm] + exact hn.trans (congrArg F (kernelLevelAction_mul N M q).symm) + +lemma kernelLevelPullback_surjective (M : levelThree) : Function.Surjective (kernelLevelPullback M) := by + intro F + refine ⟨kernelLevelPullback M⁻¹ F,?_⟩ + rw [kernelLevelPullback_comp,inv_mul_cancel,kernelLevelPullback_one] + +def kernelLevelUnitary (M : levelThree) : KernelQuotientL2 ≃ₗᵢ[ℂ] KernelQuotientL2 := + LinearIsometryEquiv.ofSurjective (kernelLevelPullback M) (kernelLevelPullback_surjective M) + +lemma kernelLevelUnitary_apply (M : levelThree) (F : KernelQuotientL2) : + kernelLevelUnitary M F=kernelLevelPullback M F := rfl + +lemma kernelLevelPullback_defect (M : levelThree) (a b : ℝ) (ha : 0 kernelQuotientEisenstein s hs q-kernelQuotientSeed a b s q) : + kernelLevelPullback M F=complexCharacter M • F := by + have hcomp := (kernelLevelAction_measurePreserving M).quasiMeasurePreserving.ae_eq_comp hF + apply Lp.ext + filter_upwards [kernelLevelPullback_ae_eq M F,hcomp,hF,Lp.coeFn_smul (complexCharacter M) F] + with q hp hc hf hsmul + change _=complexCharacter M*F q at hsmul + rw [hp,hsmul,hf] + dsimp only [Function.comp_def] at hc + rw [hc,kernelLevelAction_eisenstein,kernelLevelAction_seed,mul_sub] + +lemma kernelCorrection_character_of_initial_overlap (M : levelThree) (a b : ℝ) + (ha : 0 kernelQuotientEisenstein s (by linarith) q-kernelQuotientSeed a b s q) : + ∀s∈cuspUpperParameterRegion, + kernelLevelPullback M (kernelEisensteinL2Correction a b ha hab s)= + complexCharacter M • kernelEisensteinL2Correction a b ha hab s := by + have hc : AnalyticOnNhd ℂ (kernelEisensteinL2Correction a b ha hab) cuspUpperParameterRegion := by + intro s hs + exact kernelEisensteinL2Correction_analyticAt_nonreal a b ha hab s (by linarith [hs.1]) hs.2.ne' + have hl : AnalyticOnNhd ℂ (fun s => kernelLevelPullback M (kernelEisensteinL2Correction a b ha hab s)) + cuspUpperParameterRegion := by + intro s hs + exact (ContinuousLinearMap.analyticAt (𝕜 := ℂ) (E := KernelQuotientL2) (F := KernelQuotientL2) + (kernelLevelPullback M).toContinuousLinearMap _).comp_of_eq (hc s hs) rfl + have hr : AnalyticOnNhd ℂ (fun s => complexCharacter M • kernelEisensteinL2Correction a b ha hab s) + cuspUpperParameterRegion := by + intro s hs + exact (hc s hs).const_smul (c := complexCharacter M) + have hV : IsOpen {s : ℂ | 4 kernelLevelPullback M (kernelEisensteinL2Correction a b ha hab s)) + =ᶠ[𝓝 (5+Complex.I:ℂ)] (fun s => complexCharacter M • kernelEisensteinL2Correction a b ha hab s) := by + filter_upwards [hV.mem_nhds (by norm_num)] with s hs + exact kernelLevelPullback_of_remainder_ae M a b s (by linarith [hs.1]) _ (hoverlap s hs.1 hs.2) + exact hl.eqOn_of_preconnected_of_eventuallyEq hr cuspUpperParameterRegion_convex.isPreconnected + (by norm_num [cuspUpperParameterRegion]) hevent + +lemma thetaApproach_tendsto_complex_punctured : + Tendsto (fun t : ℝ => (4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I) + (𝓝[>] (0:ℝ)) (𝓝[≠] (4/3:ℂ)) := by + apply tendsto_nhdsWithin_iff.mpr + constructor + · have hh : Continuous (fun t : ℝ => (4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I) := by fun_prop + have ht := (hh.tendsto 0).mono_left (show 𝓝[>] (0:ℝ)≤𝓝 0 from nhdsWithin_le_nhds) + simpa only [Complex.ofReal_zero,zero_mul,add_zero] using ht + · filter_upwards [self_mem_nhdsWithin] with t ht + change 0 kernelQuotientEisenstein s (by linarith) q-kernelQuotientSeed a b s q) : + kernelLevelPullback M (kernelEisensteinResidueVector a b ha hab)= + complexCharacter M • kernelEisensteinResidueVector a b ha hab := by + have hlim := (kernelEisensteinResidueVector_limit a b ha hab).comp thetaApproach_tendsto_complex_punctured + have hl := (kernelLevelPullback M).continuous.continuousAt.tendsto.comp hlim + have hr := hlim.const_smul (complexCharacter M) + have hevent : + (fun t : ℝ => kernelLevelPullback M + (((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I-4/3) • + kernelEisensteinL2Correction a b ha hab ((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I))) + =ᶠ[𝓝[>] (0:ℝ)] + (fun t : ℝ => complexCharacter M • + (((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I-4/3) • + kernelEisensteinL2Correction a b ha hab ((4/3:ℂ)+(t:ℂ)+(t:ℂ)*Complex.I))) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 kernelQuotientEisenstein s hs q-kernelQuotientSeed a b s q) : + kernelCuspAverageFamily a b ha hab s= + ∫w in cuspPeriodStrip 5 6,hyperbolicEisenstein s w∂hyperbolicVolume := by + have hcorrected : kernelCorrectedSeed a b ha hab s=ᵐ[integralQuotientVolume globalKubotaKernel] + kernelQuotientEisenstein s hs := by + filter_upwards [hoverlap] with q hq + change kernelQuotientSeed a b s q+kernelEisensteinL2Correction a b ha hab s q=_ + rw [hq] + ring + have hm := kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have hrestr := ae_restrict_of_ae hcorrected (s := kernelCuspStripSet) + have hp := hm.quasiMeasurePreserving.ae_eq_comp hrestr + rw [kernelCuspAverageFamily_actual_integral] + apply integral_congr_ae + filter_upwards [hp] with w hw + exact hw.trans (kernelQuotientEisenstein_mk s hs w) + +lemma kernelEisensteinResidueVector_nonzero_character_of_initial_overlap (a b : ℝ) + (ha : 0 kernelQuotientEisenstein s (by linarith) q-kernelQuotientSeed a b s q) : + kernelEisensteinResidueVector a b ha hab≠0 ∧ + ∀M : levelThree,kernelLevelPullback M (kernelEisensteinResidueVector a b ha hab)= + complexCharacter M • kernelEisensteinResidueVector a b ha hab := by + constructor + · apply kernelEisensteinResidueVector_ne_zero_of_overlap a b ha hab + intro s hs hi + exact kernelCuspAverageFamily_eq_of_initial_overlap a b ha hab s (by linarith) (hoverlap s hs hi) + · intro M + exact kernelEisensteinResidueVector_character_of_initial_overlap M a b ha hab hoverlap + +end CubicEisenstein + +open scoped BigOperators +namespace QuadraticAllOddCRT +open ActualEisensteinCubic +open QuadraticGaussRay hiding O +open ActualEisensteinCoordinates hiding O omega +open EisensteinEPrimaryPhase (Coord odd) + +def quadraticRayExponent (r : Coord) : ZMod 4 := + if r∈({(0,1),(0,3),(1,0),(1,1),(3,0),(3,3)} : Finset Coord) then 0 + else if r∈({(1,2),(1,3),(2,3)} : Finset Coord) then 1 else 3 + +def fourthRoot (a : ZMod 4) : ℂ := Complex.I^(a.val:ℤ) + +lemma fourthRoot_add (a b : ZMod 4) : fourthRoot (a+b)=fourthRoot a*fourthRoot b := by + unfold fourthRoot + rw [←zpow_add₀ Complex.I_ne_zero] + apply I_zpow_eq_of_mod_four + push_cast + simp + +lemma quadraticRayValue_eq_fourthRoot (r : Coord) (hr : odd r) : + quadraticRayValue r=fourthRoot (quadraticRayExponent r) := by + have hcmp (a b : ZMod 4) : (a=b) ↔ (a.val=b.val) := + (ZMod.val_injective 4).eq_iff.symm + have hcases : ∀ x : ZMod 4, x = 0 ∨ x = 1 ∨ x = 2 ∨ x = 3 := by decide + rcases r with ⟨a,b⟩ + rcases hcases a with rfl | rfl | rfl | rfl <;> + rcases hcases b with rfl | rfl | rfl | rfl <;> + norm_num [EisensteinEPrimaryPhase.odd,ZMod.val_zero,ZMod.val_one_eq_one_mod,ZMod.val_ofNat] at hr <;> + norm_num [quadraticRayExponent,fourthRoot,EisensteinEPrimaryPhase.odd, + quadraticRayValue,breveGaussianFourTerms_formula,Prod.mk.injEq,hcmp, + ZMod.val_zero,ZMod.val_one_eq_one_mod,ZMod.val_ofNat, + Complex.I_sq,Complex.I_pow_three,Complex.inv_I,zpow_neg] <;> + ring_nf + +def quadraticRaySign (r s : Coord) : ℤ := + if odd r ∧ odd s then + if quadraticRayExponent (EisensteinEPrimaryPhase.mul r s)= + quadraticRayExponent r+quadraticRayExponent s then 1 else -1 + else 0 + +lemma quadraticRaySign_mul_left (r s t : Coord) : + quadraticRaySign (EisensteinEPrimaryPhase.mul r s) t= + quadraticRaySign r t*quadraticRaySign s t := by + have h : ∀r s t : Coord, + quadraticRaySign (EisensteinEPrimaryPhase.mul r s) t= + quadraticRaySign r t*quadraticRaySign s t := by decide + exact h r s t + +lemma quadraticRaySign_mul_right (r s t : Coord) : + quadraticRaySign r (EisensteinEPrimaryPhase.mul s t)= + quadraticRaySign r s*quadraticRaySign r t := by + have h : ∀r s t : Coord, + quadraticRaySign r (EisensteinEPrimaryPhase.mul s t)= + quadraticRaySign r s*quadraticRaySign r t := by decide + exact h r s t + +lemma quadraticRaySign_symm (r s : Coord) : quadraticRaySign r s=quadraticRaySign s r := by + have h : ∀r s : Coord,quadraticRaySign r s=quadraticRaySign s r := by decide + exact h r s + +lemma quadraticRaySign_sq (r s : Coord) (hr : odd r) (hs : odd s) : + quadraticRaySign r s^2=1 := by + unfold quadraticRaySign + rw [ite_eq_left ⟨hr,hs⟩] + split_ifs <;> norm_num + +lemma quadraticRaySign_exponent (r s : Coord) (hr : odd r) (hs : odd s) : + quadraticRayExponent (EisensteinEPrimaryPhase.mul r s)= + (if quadraticRaySign r s=1 then 0 else 2)+quadraticRayExponent r+quadraticRayExponent s := by + have h : ∀r s : Coord,odd r → odd s → + quadraticRayExponent (EisensteinEPrimaryPhase.mul r s)= + (if quadraticRaySign r s=1 then 0 else 2)+quadraticRayExponent r+quadraticRayExponent s := by decide + exact h r s hr hs + +lemma quadraticRaySign_root (r s : Coord) (hr : odd r) (hs : odd s) : + fourthRoot (if quadraticRaySign r s=1 then 0 else 2)=(quadraticRaySign r s:ℂ) := by + by_cases he : quadraticRayExponent (EisensteinEPrimaryPhase.mul r s)= + quadraticRayExponent r+quadraticRayExponent s + · norm_num [quadraticRaySign,hr,hs,he,fourthRoot,ZMod.val_zero,ZMod.val_ofNat,Complex.I_sq] + · norm_num [quadraticRaySign,hr,hs,he,fourthRoot,ZMod.val_zero,ZMod.val_ofNat,Complex.I_sq] + +lemma odd_mul (r s : Coord) (hr : odd r) (hs : odd s) : odd (EisensteinEPrimaryPhase.mul r s) := by + have h : ∀r s : Coord,odd r → odd s → odd (EisensteinEPrimaryPhase.mul r s) := by decide + exact h r s hr hs + +theorem quadraticRayValue_mul (r s : Coord) (hr : odd r) (hs : odd s) : + quadraticRayValue (EisensteinEPrimaryPhase.mul r s)= + (quadraticRaySign r s:ℂ)*quadraticRayValue r*quadraticRayValue s := by + rw [quadraticRayValue_eq_fourthRoot _ (odd_mul r s hr hs),quadraticRaySign_exponent r s hr hs, + fourthRoot_add,fourthRoot_add,quadraticRaySign_root r s hr hs, + quadraticRayValue_eq_fourthRoot r hr,quadraticRayValue_eq_fourthRoot s hs] + +lemma quadraticRayPair_eq_sign (r s : Coord) (hr : odd r) (hs : odd s) : + MixedCrossSeparation.quadraticRayPair r s=(quadraticRaySign r s:ℂ) := by + unfold MixedCrossSeparation.quadraticRayPair + rw [quadraticRayValue_mul r s hr hs] + apply (div_eq_iff (mul_ne_zero (quadraticRayValue_ne_zero_of_odd r hr) + (quadraticRayValue_ne_zero_of_odd s hs))).mpr + ring + +end QuadraticAllOddCRT + +open scoped BigOperators Classical +namespace CanonicalRowCompletion + +section +open ActualEisensteinCubic +open CompletedGauss hiding O +open CanonicalQuadraticSieve hiding O +open CubicJacobiGlobal hiding O +open QuadraticGaussRay hiding O +open QuadraticAllOddCRT +open ActualEisensteinCoordinates hiding O omega +open UniqueFactorizationMonoid + +lemma supported_factors_good (I : Ideal ActualEisensteinCubic.O) (hI : Supported I) : + ∀P∈normalizedFactors I,P.IsMaximal ∧ lambda∉P ∧ ringChar (ActualEisensteinCubic.O⧸P)≠2 := by + intro P hP + have hp := prime_of_normalized_factor P hP + exact ⟨(Ideal.isPrime_of_prime hp).isMaximal hp.ne_zero,hI.2 P hP⟩ + +lemma idealRowHom_one_supported (I : Ideal ActualEisensteinCubic.O) (hI : Supported I) : idealRowHom 1 I=1 := by + have h := CanonicalUnitEuler.idealRowHom_unit_norm (1:ActualEisensteinCubic.Oˣ) I hI.1 (supported_factors_good I hI) + simpa using h + +lemma supported_prime_data (p : ActualEisensteinCubic.O) (hp : Prime p) (hs : Supported (Ideal.span {p})) : + lambda∉(Ideal.span {p}:Ideal ActualEisensteinCubic.O) ∧ ringChar (ActualEisensteinCubic.O⧸Ideal.span {p})≠2 := by + let : (Ideal.span {p}).IsMaximal := PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + exact hs.2 _ ((Ideal.mem_normalizedFactors_iff hs.1).mpr ⟨inferInstance,le_rfl⟩) + +lemma supported_residue_odd (p : ActualEisensteinCubic.O) (hs : Supported (Ideal.span {p})) : EisensteinEPrimaryPhase.odd (residue p) := + (ActualEisensteinCoordinates.odd_residue_iff_not_two_dvd p).mpr ((supported_span_iff p).mp hs).2 + +theorem idealRowHom_prime_reciprocity (p q : ActualEisensteinCubic.O) (hp : Prime p) (hq : Prime q) + (hprimaryP : lambda^2∣p-1) (hprimaryQ : lambda^2∣q-1) + (hsP : Supported (Ideal.span {p})) (hsQ : Supported (Ideal.span {q})) : + idealRowHom q (Ideal.span {p})= + (quadraticRaySign (residue p) (residue q):ℂ)*idealRowHom p (Ideal.span {q}) := by + let : (Ideal.span {p}).IsMaximal := PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + let : (Ideal.span {q}).IsMaximal := PrincipalIdealRing.isMaximal_of_irreducible hq.irreducible + obtain ⟨hgP,hcP⟩ := supported_prime_data p hp hsP + obtain ⟨hgQ,hcQ⟩ := supported_prime_data q hq hsQ + by_cases he : (Ideal.span {p}:Ideal ActualEisensteinCubic.O)=Ideal.span {q} + · have hqp : q∈(Ideal.span {p}:Ideal ActualEisensteinCubic.O) := by rw [he];exact Ideal.subset_span (by simp) + have hpq : p∈(Ideal.span {q}:Ideal ActualEisensteinCubic.O) := by rw [←he];exact Ideal.subset_span (by simp) + rw [idealRowHom_prime q _ hgP,idealRowHom_prime p _ hgQ, + Ideal.Quotient.eq_zero_iff_mem.mpr hqp,Ideal.Quotient.eq_zero_iff_mem.mpr hpq] + simp only [MulChar.map_zero,mul_zero] + · have hcop : IsCoprime (Ideal.span {p}:Ideal ActualEisensteinCubic.O) (Ideal.span {q}) := Ideal.isCoprime_of_isMaximal he + have hqp : q∉(Ideal.span {p}:Ideal ActualEisensteinCubic.O) := by + intro h + apply he + exact ((inferInstance : (Ideal.span {q}:Ideal ActualEisensteinCubic.O).IsMaximal).eq_of_le + (Ideal.IsMaximal.ne_top inferInstance) + (Ideal.span_le.mpr (Set.singleton_subset_iff.mpr h))).symm + have h2 : idealRowHom q (Ideal.span {p})^2=idealRowHom p (Ideal.span {q})^2 := by + rw [idealRowHom_square,idealRowHom_square] + exact congrArg ConcreteTraceCRT.eisEmbedding (symbol_reciprocity q p hq.ne_zero hp.ne_zero hprimaryQ hprimaryP) + have h6 : idealRowHom q (Ideal.span {p})^6=1 := by + rw [idealRowHom_prime q _ hgP] + have h := canonicalSextic_sixth_power_mask (Ideal.span {p}) hgP q + change actualSextic _ hgP (Ideal.Quotient.mk _ (q^6))=_ at h + simpa only [map_pow,ite_eq_right hqp] using h + have hcross := quadratic_ray_cross p q hp.ne_zero hq.ne_zero hcop hcP hcQ + rw [residue_mul,quadraticRayValue_mul _ _ (supported_residue_odd p hsP) (supported_residue_odd q hsQ)] at hcross + have h3 (x y : ActualEisensteinCubic.O) (hg : lambda∉(Ideal.span {x}:Ideal ActualEisensteinCubic.O)) [(Ideal.span {x}).IsMaximal] : + idealRowHom y (Ideal.span {x})^3= + character (Ideal.span {x}) (Ideal.Quotient.mk (Ideal.span {x}) y) := by + rw [idealRowHom_prime y _ hg,←MulChar.pow_apply' _ (by decide : (3:ℕ)≠0),actualSextic_cube_quadratic] + have hc : idealRowHom q (Ideal.span {p})^3*idealRowHom p (Ideal.span {q})^3= + (quadraticRaySign (residue p) (residue q):ℂ) := by + rw [h3 p q hgP,h3 q p hgQ] + apply mul_right_cancel₀ (quadraticRayValue_ne_zero_of_odd _ (supported_residue_odd p hsP)) + apply mul_right_cancel₀ (quadraticRayValue_ne_zero_of_odd _ (supported_residue_odd q hsQ)) + simpa only [mul_assoc,mul_left_comm,mul_comm] using hcross.symm + calc + _ = idealRowHom q (Ideal.span {p})*idealRowHom q (Ideal.span {p})^6 := by rw [h6,mul_one] + _ = idealRowHom q (Ideal.span {p})^3*(idealRowHom q (Ideal.span {p})^2)^2 := by ring + _ = idealRowHom q (Ideal.span {p})^3*(idealRowHom p (Ideal.span {q})^2)^2 := by rw [h2] + _ = (idealRowHom q (Ideal.span {p})^3*idealRowHom p (Ideal.span {q})^3)*idealRowHom p (Ideal.span {q}) := by ring + _ = _ := by rw [hc] + +end + +open ActualEisensteinCubic +open CompletedGauss hiding O +open CanonicalQuadraticSieve hiding O +open CubicJacobiGlobal hiding O +open QuadraticAllOddCRT +open ActualEisensteinCoordinates hiding O omega + +def sexticReciprocityPhase (a b : ActualEisensteinCubic.O) : ℂ := + (quadraticRaySign (residue a) (residue b):ℂ) + +lemma sexticReciprocityPhase_mul_left (a b c : ActualEisensteinCubic.O) : + sexticReciprocityPhase (a*b) c=sexticReciprocityPhase a c*sexticReciprocityPhase b c := by + simp only [sexticReciprocityPhase,residue_mul,quadraticRaySign_mul_left,Int.cast_mul] + +lemma sexticReciprocityPhase_mul_right (a b c : ActualEisensteinCubic.O) : + sexticReciprocityPhase a (b*c)=sexticReciprocityPhase a b*sexticReciprocityPhase a c := by + simp only [sexticReciprocityPhase,residue_mul,quadraticRaySign_mul_right,Int.cast_mul] + +lemma sexticReciprocityPhase_one_right (a : ActualEisensteinCubic.O) (ha : Supported (Ideal.span {a})) : + sexticReciprocityPhase a 1=1 := by + have h1 : residue (1:ActualEisensteinCubic.O)=((1:ZMod 4),0) := by + have h : (1:ActualEisensteinCubic.O)=eval 1 0 := by simp [eval] + rw [h,residue_eval] + norm_num + have ht : ∀r : EisensteinEPrimaryPhase.Coord,EisensteinEPrimaryPhase.odd r → + quadraticRaySign r ((1:ZMod 4),0)=1 := by decide + simp only [sexticReciprocityPhase,h1,ht _ (supported_residue_odd a ha),Int.cast_one] + +lemma sexticReciprocityPhase_one_left (a : ActualEisensteinCubic.O) (ha : Supported (Ideal.span {a})) : + sexticReciprocityPhase 1 a=1 := by + have he : sexticReciprocityPhase 1 a=sexticReciprocityPhase a 1 := by + simp only [sexticReciprocityPhase,quadraticRaySign_symm] + rw [he,sexticReciprocityPhase_one_right a ha] + +lemma idealRowHom_prime_primary_reciprocity (p b : ActualEisensteinCubic.O) (hp : Prime p) + (hprimaryP : lambda^2∣p-1) (hprimaryB : lambda^2∣b-1) + (hsP : Supported (Ideal.span {p})) (hsB : Supported (Ideal.span {b})) : + idealRowHom b (Ideal.span {p})=sexticReciprocityPhase p b*idealRowHom p (Ideal.span {b}) := by + have hb0 : b≠0 := by + intro h + apply hsB.1 + simp [h] + obtain ⟨s,hprod,hfactors⟩ := exists_primary_prime_factorization b hb0 hprimaryB + rw [←hprod] at hsB ⊢ + clear hprod hb0 hprimaryB b + induction s using Multiset.induction_on with + | empty => + simp only [Multiset.prod_zero,Ideal.span_singleton_one,←Ideal.one_eq_top,map_one, + idealRowHom_one_supported _ hsP,sexticReciprocityPhase_one_right p hsP,mul_one] + | @cons q s ih => + have hq := hfactors q (Multiset.mem_cons_self _ _) + have htail : ∀r∈s,Prime r ∧ lambda^2∣r-1 := fun r hr => hfactors r (Multiset.mem_cons_of_mem hr) + have hsplit : Supported (Ideal.span {q}) ∧ Supported (Ideal.span {s.prod}) := by + simpa only [Multiset.prod_cons,←Ideal.span_singleton_mul_span_singleton,supported_mul_iff] using hsB + rw [Multiset.prod_cons,idealRowHom_argument_mul,←Ideal.span_singleton_mul_span_singleton, + map_mul,sexticReciprocityPhase_mul_right, + idealRowHom_prime_reciprocity p q hp hq.1 hprimaryP hq.2 hsP hsplit.1, + ih hsplit.2 htail] + simp only [sexticReciprocityPhase] + ring + +theorem idealRowHom_primary_reciprocity (a b : ActualEisensteinCubic.O) + (hprimaryA : lambda^2∣a-1) (hprimaryB : lambda^2∣b-1) + (hsA : Supported (Ideal.span {a})) (hsB : Supported (Ideal.span {b})) : + idealRowHom b (Ideal.span {a})=sexticReciprocityPhase a b*idealRowHom a (Ideal.span {b}) := by + have ha0 : a≠0 := by + intro h + apply hsA.1 + simp [h] + obtain ⟨s,hprod,hfactors⟩ := exists_primary_prime_factorization a ha0 hprimaryA + rw [←hprod] at hsA ⊢ + clear hprod ha0 hprimaryA a + induction s using Multiset.induction_on with + | empty => + simp only [Multiset.prod_zero,Ideal.span_singleton_one,←Ideal.one_eq_top,map_one, + idealRowHom_one_supported _ hsB,sexticReciprocityPhase_one_left b hsB,one_mul] + | @cons p s ih => + have hp := hfactors p (Multiset.mem_cons_self _ _) + have htail : ∀r∈s,Prime r ∧ lambda^2∣r-1 := fun r hr => hfactors r (Multiset.mem_cons_of_mem hr) + have hsplit : Supported (Ideal.span {p}) ∧ Supported (Ideal.span {s.prod}) := by + simpa only [Multiset.prod_cons,←Ideal.span_singleton_mul_span_singleton,supported_mul_iff] using hsA + rw [Multiset.prod_cons,←Ideal.span_singleton_mul_span_singleton,map_mul, + idealRowHom_argument_mul,sexticReciprocityPhase_mul_left, + idealRowHom_prime_primary_reciprocity p b hp.1 hp.2 hprimaryB hsplit.1 hsB, + ih hsplit.2 htail] + ring + +theorem idealRowHom_primary_reciprocity_ray (a b : ActualEisensteinCubic.O) + (hprimaryA : lambda^2∣a-1) (hprimaryB : lambda^2∣b-1) + (hsA : Supported (Ideal.span {a})) (hsB : Supported (Ideal.span {b})) : + idealRowHom b (Ideal.span {a})= + MixedCrossSeparation.quadraticRayPair (residue a) (residue b)*idealRowHom a (Ideal.span {b}) := by + rw [quadraticRayPair_eq_sign _ _ (supported_residue_odd a hsA) (supported_residue_odd b hsB)] + exact idealRowHom_primary_reciprocity a b hprimaryA hprimaryB hsA hsB + +theorem idealRowHom_ideal_reciprocity (I J : Ideal ActualEisensteinCubic.O) (hI : Supported I) (hJ : Supported J) : + idealRowHom (primaryGenerator J) I= + sexticReciprocityPhase (primaryGenerator I) (primaryGenerator J)*idealRowHom (primaryGenerator I) J := by + have hpI := primaryGenerator_spec I (supported_primaryGenerator_ne_zero I hI) + have hpJ := primaryGenerator_spec J (supported_primaryGenerator_ne_zero J hJ) + have h := idealRowHom_primary_reciprocity (primaryGenerator I) (primaryGenerator J) + hpI.2 hpJ.2 (by rwa [hpI.1]) (by rwa [hpJ.1]) + simpa only [hpI.1,hpJ.1] using h + +end CanonicalRowCompletion + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConstantDirichletSeries.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConstantDirichletSeries.lean new file mode 100644 index 0000000000000000000000000000000000000000..808b6c93ae3df61002dd72b9eaac8155c105ca64 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConstantDirichletSeries.lean @@ -0,0 +1,632 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.FrequencyCutoffs + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +open scoped BigOperators Classical + +namespace CubicEisenstein +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal UniqueFactorizationMonoid CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal) + +lemma constant_dirichlet_support (s : ℂ) : + Function.support (arithmeticDirichletTerm s 0) ⊆ + {c : LevelLower | c.1 ≠ 0 ∧ ∃ a : O,c.1=a^3} := by + intro c hc + change arithmeticDirichletTerm s 0 c ≠ 0 at hc + by_cases hzero : c.1=0 + · simp [arithmeticDirichletTerm,hzero] at hc + · refine ⟨hzero, ?_⟩ + have hA : arithmeticResidueSum 0 c.1 ≠ 0 := by + intro hA + apply hc + simp only [arithmeticDirichletTerm,ite_eq_right hzero,hA,mul_zero] + exact (arithmeticResidueSum_ne_zero_iff_cube c.1 hzero c.2).mp hA + +lemma totient_sum_good (s : ℂ) : + (∑' I : GoodIdeal,(idealTotient I.1:ℂ)*unramifiedNormWeight s I.1)=unramifiedTotientSeries s := by + unfold unramifiedTotientSeries + apply tsum_subtype_eq_of_support_subset (s := {I : Ideal O | primaryGenerator I ≠ 0}) + (f := fun I : Ideal O => (idealTotient I:ℂ)*unramifiedNormWeight s I) + intro I hI + change (idealTotient I:ℂ)*unramifiedNormWeight s I ≠ 0 at hI + change primaryGenerator I ≠ 0 + intro hg + apply hI + rw [unramifiedNormWeight_of_bad _ I hg,mul_zero] + +lemma norm_ramifiedRatio_lt_one (s : ℂ) (hs : 1 ‖arithmeticDirichletTerm s 0 c‖) := by + have hs1 : 1 ‖ramifiedRatio s^(n+1)‖) := by + have hh := (summable_geometric_of_lt_one (norm_nonneg (ramifiedRatio s)) hq).mul_right + ‖ramifiedRatio s‖ + simpa only [pow_succ,norm_mul,norm_pow] using hh + have hi := (unramifiedTotientSeries_summable_norm (3*s-2) hw).subtype + (fun I : Ideal O => primaryGenerator I ≠ 0) + have hni := hqn.mul_norm hi + have hb : Summable (fun _ : Bool => ‖(1:ℂ)‖) := summable_of_hasFiniteSupport (Set.toFinite _) + have hfull := hb.mul_norm hni + have hp : Summable (fun p : Bool × ℕ × GoodIdeal => + ‖arithmeticDirichletTerm s 0 (cubeColumnMap p).1‖) := by + apply hfull.congr + rintro ⟨b,n,I⟩ + simp only [one_mul,cubeColumn_dirichletTerm] + have hsub : Summable (fun c : CubeLower => ‖arithmeticDirichletTerm s 0 c.1‖) := + cubeColumnEquiv.summable_iff.mp hp + have hind := (summable_subtype_iff_indicator + (s := {c : LevelLower | c.1 ≠ 0 ∧ ∃ a : O,c.1=a^3}) + (f := fun c => ‖arithmeticDirichletTerm s 0 c‖)).mp hsub + apply hind.congr + intro c + by_cases hc : c.1 ≠ 0 ∧ ∃ a : O,c.1=a^3 + · simp [Set.indicator,hc] + · have hz : arithmeticDirichletTerm s 0 c=0 := by + by_contra h + exact hc (constant_dirichlet_support s h) + simp [Set.indicator,hc,hz] + +lemma ramified_geometric_sum (s : ℂ) (hs : 1 arithmeticDirichletTerm s 0 c.1) := hc.subtype _ + have hp := cubeColumnEquiv.summable_iff.mpr hsub + change Summable (fun p : Bool × ℕ × GoodIdeal => + arithmeticDirichletTerm s 0 (cubeColumnMap p).1) at hp + calc + _ = ∑' c : CubeLower,arithmeticDirichletTerm s 0 c.1 := + (tsum_subtype_eq_of_support_subset (constant_dirichlet_support s)).symm + _ = ∑' p : Bool × ℕ × GoodIdeal,arithmeticDirichletTerm s 0 (cubeColumnMap p).1 := + (cubeColumnEquiv.tsum_eq _).symm + _ = ∑' b : Bool,∑' n : ℕ,∑' I : GoodIdeal, + arithmeticDirichletTerm s 0 (cubeColumnMap (b,n,I)).1 := by + rw [hp.tsum_prod] + apply tsum_congr + intro b + exact (hp.prod_factor b).tsum_prod + _ = ∑' b : Bool,∑' n : ℕ,∑' I : GoodIdeal, + ramifiedRatio s^(n+1)*((idealTotient I.1:ℂ)*unramifiedNormWeight (3*s-2) I.1) := by + apply tsum_congr; intro b + apply tsum_congr; intro n + exact tsum_congr (fun I => cubeColumn_dirichletTerm s b n I) + _ = ∑' _ : Bool,∑' n : ℕ,ramifiedRatio s^(n+1)*unramifiedTotientSeries (3*s-2) := by + apply tsum_congr; intro b + apply tsum_congr; intro n + rw [tsum_mul_left,totient_sum_good] + _ = ∑' _ : Bool,((3:ℂ)^(3*s-3)-1)⁻¹*unramifiedTotientSeries (3*s-2) := by + apply tsum_congr; intro b + rw [tsum_mul_right,ramified_geometric_sum s (by linarith)] + _ = _ := by + rw [tsum_fintype] + simp only [Finset.sum_const,Finset.card_univ,Fintype.card_bool,nsmul_eq_mul] + ring + +theorem scatteringCoefficient_zero_zeta (s : ℂ) (hs : (4:ℝ)/3 by rw [poolPrimary_span F hF i]; infer_instance + matrix M N = QuadraticInitialBound.quadraticMatrix (poolPrimary F) + (poolPrimary_good F hF) + (fun I : idealRange M => idealSupport F I.val) + (fun J : idealRange N => idealSupport F J.val) := by + ext I J + change quadraticRow J.val (primaryGenerator I.val) = _ + rw [quadraticRow_eq_primaryPool F hF J.val (hN J.property)] + rw [primaryGenerator_eq_poolProduct F hF I.val (hM I.property)] + rfl + +theorem sieveNorm_reverse_le (M N : ℝ) : + sieveNorm M N ≤ 262144 * sieveNorm N M := by + let F := idealRange M ∪ idealRange N + have hF : ∀ I ∈ F, Admissible I := by + intro I hI + rcases Finset.mem_union.mp hI with hI | hI + · exact (mem_idealRange.mp hI).1 + · exact (mem_idealRange.mp hI).1 + have hM : idealRange M ⊆ F := Finset.subset_union_left + have hN : idealRange N ⊆ F := Finset.subset_union_right + let : ∀ i : primePool F, (Ideal.span {poolPrimary F i}).IsMaximal := + fun i => by rw [poolPrimary_span F hF i]; infer_instance + have h := QuadraticInitialBound.quadraticSieveNorm_reverse_le + (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) (poolPrimary_odd F hF) + (fun I : idealRange M => idealSupport F I.val) + (fun J : idealRange N => idealSupport F J.val) + simpa only [QuadraticInitialBound.quadraticSieveNorm, + ← matrix_eq_primePool M N F hF hM hN, + ← matrix_eq_primePool N M F hF hN hM, sieveNorm] using h + +end +section + +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge CompletedGauss +open EisensteinSchwartzPoisson GaussGeneratorTransport UnrestrictedIdealReindex +open TruncatedPrincipalPoisson QuadraticSquarefreeKernel + +def dualPrincipalIdeal (I J : Ideal O) (V : ℝ → ℂ) (X : ℝ) : ℂ := + ∑' A : NonzeroIdeal, + (idealZeroMask I (idealGenerator A.val) * idealZeroMask J (idealGenerator A.val)) * + V ((Ideal.absNorm A.val : ℝ) / X) + +def dualPrincipalLattice (I J : Ideal O) (V : ℝ → ℂ) (X : ℝ) : ℂ := + ∑' z : O, rowCoprimeMask (fun P : primePool {I * J} => P.val) Finset.univ z * + V (‖eisEmbedding z‖ ^ 2 / X) + +theorem idealZeroMask_pair_zero (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hnt : I ≠ 1 ∨ J ≠ 1) : idealZeroMask I 0 * idealZeroMask J 0 = 0 := by + rw [← canonical_quadraticRow_squared I hI, ← canonical_quadraticRow_squared J hJ] + calc + _ = (quadraticRow I 0 * quadraticRow J 0) ^ 2 := by ring + _ = 0 := by rw [quadratic_pair_zero_of_nontrivial I J hI hJ hnt]; ring + +theorem dualPrincipalIdeal_eq_lattice (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hnt : I ≠ 1 ∨ J ≠ 1) (V : 𝓢(ℝ, ℂ)) (X : ℝ) (hX : 0 < X) : + dualPrincipalIdeal I J V X = (6 : ℂ)⁻¹ * dualPrincipalLattice I J V X := by + let P := fun P : primePool {I * J} => P.val + let f : O → ℂ := fun z => rowCoprimeMask P Finset.univ z * V (‖eisEmbedding z‖ ^ 2 / X) + have hV : Summable (fun z : O => ‖V (‖eisEmbedding z‖ ^ 2 / X)‖) := by + simpa only [scaledRadialTest_apply] using actual_eisenstein_summable_norm (scaledRadialTest V X hX) + have hf : Summable f := by + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun z => norm_nonneg _) _ hV + intro z + dsimp only [f] + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) + (QuadraticUnitInvariance.rowCoprimeMask_norm_le_one P Finset.univ z) + have hm (z : O) : rowCoprimeMask P Finset.univ z = idealZeroMask I z * idealZeroMask J z := by + rw [singleton_rowCoprimeMask_eq_idealZeroMask, idealZeroMask_mul I J hI.1 hJ.1] + have h0 : f 0 = 0 := by + dsimp only [f] + rw [hm, idealZeroMask_pair_zero I J hI hJ hnt, zero_mul] + have hu (u : Oˣ) (z : O) : f (u.val * z) = f z := by + dsimp only [f] + rw [QuadraticUnitInvariance.rowCoprimeMask_unit_mul, norm_eisEmbedding_unit_mul] + have he := tsum_unit_invariant_of_zero f hf h0 hu + have hd : (∑' A : NonzeroIdeal, f (idealGenerator A.val)) = dualPrincipalIdeal I J V X := by + apply tsum_congr + intro A + simp only [f, hm, idealGenerator_norm_sq] + change dualPrincipalLattice I J V X = 6 * ∑' A : NonzeroIdeal, f (idealGenerator A.val) at he + rw [hd] at he + rw [he] + ring + +theorem dualPrincipalIdeal_truncated (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hnt : I ≠ 1 ∨ J ≠ 1) (V : 𝓢(ℝ, ℂ)) (X Y Z lengthScale : ℝ) (hX : 0 < X) : + dualPrincipalIdeal I J V X = (6 : ℂ)⁻¹ * + (principalTruncation (fun P : primePool {I * J} => P.val) Finset.univ V X Z + + middleTruncation (fun P : primePool {I * J} => P.val) Finset.univ V X Y Z lengthScale + + truncationError (fun P : primePool {I * J} => P.val) Finset.univ V X Y Z lengthScale) := by + rw [dualPrincipalIdeal_eq_lattice I J hI hJ hnt V X hX] + congr 1 + unfold truncationError + have he : dualPrincipalLattice I J V X = + ∑' z : O, rowCoprimeMask (fun P : primePool {I * J} => P.val) Finset.univ z * + (if z = 0 then 0 else V (‖eisEmbedding z‖ ^ 2 / X)) := by + apply tsum_congr + intro z + by_cases hz : z = 0 + · subst z + rw [singleton_rowCoprimeMask_eq_idealZeroMask, idealZeroMask_mul I J hI.1 hJ.1, + idealZeroMask_pair_zero I J hI hJ hnt, zero_mul, zero_mul] + · simp only [ite_eq_right hz] + rw [he] + ring + +theorem canonical_pair_ideal_fourier_summable (I J : Ideal O) (W : 𝓢(ℝ, ℂ)) + (t : ℝ) (ht : 0 < t) : + Summable (fun lengthScale : NonzeroIdeal => unrestrictedPairCharacter I J lengthScale.val * + paperRadialFourier W (t * (Ideal.absNorm lengthScale.val : ℝ))) := by + have hi : Function.Injective (fun lengthScale : NonzeroIdeal => idealGenerator lengthScale.val) := by + intro A B he + apply Subtype.ext + have hs := congrArg (fun z : O => Ideal.span {z}) he + simpa only [span_idealGenerator] using hs + have h := (canonical_pair_fourier_summable I J W t ht).comp_injective hi + simpa only [Function.comp_def, idealGenerator_norm_sq, unrestrictedPairCharacter] using h + +theorem canonical_nonprincipal_dual_principal + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hray : columnRay I = columnRay J) (hnt : I ≠ 1 ∨ J ≠ 1) + (W : 𝓢(ℝ, ℂ)) (t : ℝ) (ht : 0 < t) : + (∑' h : O, (quadraticRow I h * quadraticRow J h) * + paperRadialFourier W (t * ‖eisEmbedding h‖ ^ 2)) = + (6 : ℂ) * ∑' B : {B : Ideal O // Squarefree B}, + unrestrictedPairCharacter I J B.val * + dualPrincipalIdeal I J (quadraticTransformedSquareProfile W) + (Real.sqrt (1 / (t * (Ideal.absNorm B.val : ℝ)))) := by + rw [canonical_nonprincipal_dual_squarefree I J hI hJ hray hnt W t ht] + congr 1 + let F : (NonzeroIdeal × {B : Ideal O // Squarefree B}) → ℂ := fun p => + (idealZeroMask I (idealGenerator p.1.val) * idealZeroMask J (idealGenerator p.1.val)) * + unrestrictedPairCharacter I J p.2.val * paperRadialFourier W + (t * ((Ideal.absNorm p.1.val : ℝ) ^ 2 * (Ideal.absNorm p.2.val : ℝ))) + have hf : Summable F := by + have hs := decompositionEquiv.symm.summable_iff.mpr + (canonical_pair_ideal_fourier_summable I J W t ht) + apply hs.congr + intro p + change unrestrictedPairCharacter I J (p.1.val ^ 2 * p.2.val) * + paperRadialFourier W (t * (Ideal.absNorm (p.1.val ^ 2 * p.2.val) : ℝ)) = F p + rw [unrestrictedPairCharacter_mul I J hI hJ hray, + unrestrictedPairCharacter_square I J hI hJ hray] + simp only [F, map_mul, map_pow, Nat.cast_mul, Nat.cast_pow] + change (∑' p, F p) = _ + calc + _ = ∑' p : ({B : Ideal O // Squarefree B} × NonzeroIdeal), F (p.2, p.1) := + (Equiv.prodComm _ _).tsum_eq (fun p => F (p.2, p.1)) + _ = ∑' B : {B : Ideal O // Squarefree B}, ∑' A : NonzeroIdeal, F (A, B) := hf.prod_symm.tsum_prod + _ = _ := by + apply tsum_congr + intro B + rw [dualPrincipalIdeal, ← tsum_mul_left] + apply tsum_congr + intro A + have hB : 0 < (Ideal.absNorm B.val : ℝ) := by + exact_mod_cast Nat.pos_iff_ne_zero.mpr (fun h => B.property.ne_zero (Ideal.absNorm_eq_zero_iff.mp h)) + have htb : 0 < t * (Ideal.absNorm B.val : ℝ) := mul_pos ht hB + have harg : ((Ideal.absNorm A.val : ℝ) / Real.sqrt (1 / (t * (Ideal.absNorm B.val : ℝ)))) ^ 2 = + t * ((Ideal.absNorm A.val : ℝ) ^ 2 * (Ideal.absNorm B.val : ℝ)) := by + rw [div_pow, Real.sq_sqrt (one_div_pos.mpr htb).le] + field_simp + + simp only [F, quadraticTransformedSquareProfile_apply, harg] + ring + +end +section + +open ActualEisensteinCubic CompletedGauss IdealMobiusDivisorSum +open QuadraticMainOperatorBound IdealCoprimeSieveOperator DivisorBlockCauchy + +def canonicalMainBoundary (H : Finset (Ideal O)) (G : Ideal O) (K N : ℝ) + (a : idealRange N → ℂ) : ℂ := + ∑ D ∈ idealDivisors G, ∑ E ∈ idealDivisors G, + (UniqueFactorizationMonoid.moebius E : ℂ) * + (∑ B : H, mainWeight K B.val D E * + (∑ J : idealRange N, ∑ lengthScale : idealRange N, if IsCoprime J.val lengthScale.val then + star (quadraticRow J.val (primaryGenerator B.val) * + (a J * quadraticRow J.val (primaryGenerator D * primaryGenerator E))) * + (quadraticRow lengthScale.val (primaryGenerator B.val) * + (a lengthScale * quadraticRow lengthScale.val (primaryGenerator D * primaryGenerator E))) else 0)) + +theorem canonicalMainBoundary_bound + (ε : ℝ) (hε : 0 < ε) (K N : ℝ) (hK : 0 < K) (hN : 0 ≤ N) + (H : Finset (Ideal O)) (hH : H ⊆ idealRange K) (G : Ideal O) (hG : G ≠ 0) + (a : idealRange N → ℂ) : + ‖canonicalMainBoundary H G K N a‖ ≤ + ((idealDivisors G).card : ℝ) ^ 2 * + ((1 / Real.sqrt K) * sieveNorm K N * (supportConstant ε hε * N ^ ε) * + ∑ J, ‖a J‖ ^ 2) := by + let A : Matrix H (idealRange N) ℂ := fun B J => quadraticRow J.val (primaryGenerator B.val) + let r : Ideal O → Ideal O → idealRange N → ℂ := fun D E J => + quadraticRow J.val (primaryGenerator D * primaryGenerator E) + have he := main_difference_operator_bound ε hε K hK G hG + (fun B : H => B.val) (fun J : idealRange N => J.val) + (fun J => (mem_idealRange.mp J.property).1.1) N hN + (fun J => (mem_idealRange.mp J.property).2) A a r + (fun D E J => quadraticRow_norm_le_one J.val _) + have hA : ‖FiniteSieveOperator.operator A‖ ^ 2 ≤ sieveNorm K N := + family_squared_norm_le (fun B : H => B.val) (fun J : idealRange N => J.val) + Subtype.val_injective Subtype.val_injective K N + (fun B => mem_idealRange.mp (hH B.property)) (fun J => mem_idealRange.mp J.property) + change ‖canonicalMainBoundary H G K N a‖ ≤ _ at he + apply he.trans + have hs : 0 ≤ supportConstant ε hε := (supportConstant_pos ε hε).le + gcongr + +theorem canonicalMainBoundary_small_power + (ε : ℝ) (hε : 0 < ε) (K N : ℝ) (hK : 0 < K) (hN : 0 ≤ N) + (H : Finset (Ideal O)) (hH : H ⊆ idealRange K) (G : Ideal O) (hG : G ≠ 0) + (a : idealRange N → ℂ) : + ‖canonicalMainBoundary H G K N a‖ ≤ + (divisorConstant ε hε * (Ideal.absNorm G : ℝ) ^ ε) ^ 2 * + ((1 / Real.sqrt K) * sieveNorm K N * (supportConstant ε hε * N ^ ε) * + ∑ J, ‖a J‖ ^ 2) := by + apply (canonicalMainBoundary_bound ε hε K N hK hN H hH G hG a).trans + have hd : ((idealDivisors G).card : ℝ) ≤ divisorConstant ε hε * (Ideal.absNorm G : ℝ) ^ ε := + (IdealDivisorBound.ideal_divisor_small_power ε hε).choose_spec.2 G hG + have hs : 0 ≤ supportConstant ε hε := (supportConstant_pos ε hε).le + have hB := sieveNorm_nonneg K N + gcongr + +theorem canonicalMainBoundary_reverse + (ε : ℝ) (hε : 0 < ε) (K N : ℝ) (hK : 0 < K) (hN : 0 ≤ N) + (H : Finset (Ideal O)) (hH : H ⊆ idealRange K) (G : Ideal O) (hG : G ≠ 0) + (a : idealRange N → ℂ) : + ‖canonicalMainBoundary H G K N a‖ ≤ + ((idealDivisors G).card : ℝ) ^ 2 * + ((262144 / Real.sqrt K) * sieveNorm N K * (supportConstant ε hε * N ^ ε) * + ∑ J, ‖a J‖ ^ 2) := by + apply (canonicalMainBoundary_bound ε hε K N hK hN H hH G hG a).trans + have hs : 0 ≤ supportConstant ε hε := (supportConstant_pos ε hε).le + calc + _ ≤ ((idealDivisors G).card : ℝ) ^ 2 * + ((1 / Real.sqrt K) * (262144 * sieveNorm N K) * (supportConstant ε hε * N ^ ε) * + ∑ J, ‖a J‖ ^ 2) := by gcongr; exact sieveNorm_reverse_le K N + _ = _ := by ring + +end + +open ActualEisensteinCubic CompletedGauss FiniteSieveRestriction + +def CoefficientOnShell (N X : ℝ) (a : idealRange N → ℂ) : Prop := + ∀ J, a J ≠ 0 → X / 2 < (Ideal.absNorm J.val : ℝ) ∧ (Ideal.absNorm J.val : ℝ) ≤ X + +theorem column_dyadic_exists (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) (J : idealRange N) : + ∃ j ∈ Finset.range (lengthScale + 1), (2 : ℝ) ^ j / 2 < (Ideal.absNorm J.val : ℝ) ∧ + (Ideal.absNorm J.val : ℝ) ≤ (2 : ℝ) ^ j := by + have hn : 1 ≤ Ideal.absNorm J.val := Nat.one_le_iff_ne_zero.mpr + (fun hz => (mem_idealRange.mp J.property).1.1 (Ideal.absNorm_eq_zero_iff.mp hz)) + exact exists_dyadic_shell (Ideal.absNorm J.val) lengthScale hn ((mem_idealRange.mp J.property).2.trans hNL) + +def columnDyadicSector (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) (J : idealRange N) : Fin (lengthScale + 1) := + ⟨(column_dyadic_exists N lengthScale hNL J).choose, + Finset.mem_range.mp (column_dyadic_exists N lengthScale hNL J).choose_spec.1⟩ + +def dyadicColumnCoefficient (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (j : Fin (lengthScale + 1)) (a : idealRange N → ℂ) : idealRange N → ℂ := + sectorCoefficient (columnDyadicSector N lengthScale hNL) j a + +theorem dyadicColumnCoefficient_shell (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (j : Fin (lengthScale + 1)) (a : idealRange N → ℂ) : + CoefficientOnShell N ((2 : ℝ) ^ j.val) (dyadicColumnCoefficient N lengthScale hNL j a) := by + intro J hJ + have he : columnDyadicSector N lengthScale hNL J = j := by + by_contra hn + exact hJ (by simp only [dyadicColumnCoefficient, sectorCoefficient, ite_eq_right hn]) + have hs := (column_dyadic_exists N lengthScale hNL J).choose_spec.2 + have hv : (columnDyadicSector N lengthScale hNL J).val = j.val := congrArg Fin.val he + change (column_dyadic_exists N lengthScale hNL J).choose = j.val at hv + simpa only [hv] using hs + +theorem dyadicColumnCoefficient_energy (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (a : idealRange N → ℂ) : + (∑ j : Fin (lengthScale + 1), ∑ J, ‖dyadicColumnCoefficient N lengthScale hNL j a J‖ ^ 2) = ∑ J, ‖a J‖ ^ 2 := + sectorCoefficient_energy (columnDyadicSector N lengthScale hNL) a + +theorem weighted_energy_column_shells {m : Type*} [Fintype m] + (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (A : Matrix m (idealRange N) ℂ) (v : m → ℝ) (hv : ∀ i, 0 ≤ v i) + (a : idealRange N → ℂ) : + (∑ i, v i * ‖∑ J, A i J * a J‖ ^ 2) ≤ + (lengthScale + 1 : ℝ) * ∑ j : Fin (lengthScale + 1), ∑ i, + v i * ‖∑ J, A i J * dyadicColumnCoefficient N lengthScale hNL j a J‖ ^ 2 := by + simpa only [Fintype.card_fin, Nat.cast_add, Nat.cast_one, dyadicColumnCoefficient] using + sector_weighted_energy_bound A (columnDyadicSector N lengthScale hNL) a v hv + +theorem annularHighEnergy_column_shells (M N K : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (a : idealRange N → ℂ) : + annularHighEnergy M N K a ≤ (lengthScale + 1 : ℝ) * + ∑ j : Fin (lengthScale + 1), annularHighEnergy M N K (dyadicColumnCoefficient N lengthScale hNL j a) := by + exact weighted_energy_column_shells N lengthScale hNL + (fun I : highKernelRange (2 * M) K => fun J => quadraticRow J.val (primaryGenerator I.val)) + (fun I => annularHighWeight M I.val) (fun _ => QuadraticInitialBound.annularSieveBump.nonneg) a + +def coefficientAtScale (N X : ℝ) (a : idealRange N → ℂ) (J : idealRange X) : ℂ := + if h : J.val ∈ idealRange N then a ⟨J.val, h⟩ else 0 + +theorem coefficientAtScale_shell (N X : ℝ) (a : idealRange N → ℂ) + (ha : CoefficientOnShell N X a) : CoefficientOnShell X X (coefficientAtScale N X a) := by + intro J hJ + unfold coefficientAtScale at hJ + split_ifs at hJ with h + · exact ha ⟨J.val, h⟩ hJ + · exact (hJ rfl).elim + +theorem coefficientAtScale_row_sum (N X : ℝ) (a : idealRange N → ℂ) + (ha : ∀ J, a J ≠ 0 → (Ideal.absNorm J.val : ℝ) ≤ X) (z : O) : + (∑ J : idealRange N, quadraticRow J.val z * a J) = + ∑ J : idealRange X, quadraticRow J.val z * coefficientAtScale N X a J := by + let f : Ideal O → ℂ := fun I => if h : I ∈ idealRange N then quadraticRow I z * a ⟨I, h⟩ else 0 + have hleft : (∑ J : idealRange N, quadraticRow J.val z * a J) = ∑ I ∈ idealRange N, f I := by + rw [← Finset.sum_coe_sort (idealRange N) f] + apply Finset.sum_congr rfl + intro J _ + simp only [f, dite_eq_left J.property] + have hright : (∑ J : idealRange X, quadraticRow J.val z * coefficientAtScale N X a J) = + ∑ I ∈ idealRange X, f I := by + rw [← Finset.sum_coe_sort (idealRange X) f] + apply Finset.sum_congr rfl + intro J _ + unfold coefficientAtScale + split_ifs with h <;> simp only [f, h, ↓reduceDIte, mul_zero] + rw [hleft, hright] + rcases le_total N X with hNX | hXN + · apply Finset.sum_subset (idealRange_mono hNX) + intro I hIX hIN + simp only [f, dite_eq_right hIN] + · symm + apply Finset.sum_subset (idealRange_mono hXN) + intro I hIN hIX + have haI : a ⟨I, hIN⟩ = 0 := by + by_contra hn + exact hIX (mem_idealRange.mpr ⟨(mem_idealRange.mp hIN).1, ha ⟨I, hIN⟩ hn⟩) + simp only [f, dite_eq_left hIN, haI, mul_zero] + +theorem coefficientAtScale_energy (N X : ℝ) (a : idealRange N → ℂ) + (ha : ∀ J, a J ≠ 0 → (Ideal.absNorm J.val : ℝ) ≤ X) : + (∑ J : idealRange N, ‖a J‖ ^ 2) = ∑ J : idealRange X, ‖coefficientAtScale N X a J‖ ^ 2 := by + let f : Ideal O → ℝ := fun I => if h : I ∈ idealRange N then ‖a ⟨I, h⟩‖ ^ 2 else 0 + have hleft : (∑ J : idealRange N, ‖a J‖ ^ 2) = ∑ I ∈ idealRange N, f I := by + rw [← Finset.sum_coe_sort (idealRange N) f] + apply Finset.sum_congr rfl + intro J _ + simp only [f, dite_eq_left J.property] + have hright : (∑ J : idealRange X, ‖coefficientAtScale N X a J‖ ^ 2) = + ∑ I ∈ idealRange X, f I := by + rw [← Finset.sum_coe_sort (idealRange X) f] + apply Finset.sum_congr rfl + intro J _ + unfold coefficientAtScale + split_ifs with h <;> simp only [f, h, ↓reduceDIte, norm_zero, zero_pow (by decide : 2 ≠ 0)] + rw [hleft, hright] + rcases le_total N X with hNX | hXN + · apply Finset.sum_subset (idealRange_mono hNX) + intro I hIX hIN + simp only [f, dite_eq_right hIN] + · symm + apply Finset.sum_subset (idealRange_mono hXN) + intro I hIN hIX + have haI : a ⟨I, hIN⟩ = 0 := by + by_contra hn + exact hIX (mem_idealRange.mpr ⟨(mem_idealRange.mp hIN).1, ha ⟨I, hIN⟩ hn⟩) + simp only [f, dite_eq_left hIN, haI, norm_zero, zero_pow (by decide : 2 ≠ 0)] + +theorem annularHighEnergy_coefficientAtScale (M N X K : ℝ) (a : idealRange N → ℂ) + (ha : ∀ J, a J ≠ 0 → (Ideal.absNorm J.val : ℝ) ≤ X) : + annularHighEnergy M N K a = annularHighEnergy M X K (coefficientAtScale N X a) := by + unfold annularHighEnergy + simp_rw [coefficientAtScale_row_sum N X a ha] + +theorem annularHighEnergy_column_shells_at_scale (M N K : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (a : idealRange N → ℂ) : + annularHighEnergy M N K a ≤ (lengthScale + 1 : ℝ) * ∑ j : Fin (lengthScale + 1), + annularHighEnergy M ((2 : ℝ) ^ j.val) K + (coefficientAtScale N ((2 : ℝ) ^ j.val) (dyadicColumnCoefficient N lengthScale hNL j a)) := by + apply (annularHighEnergy_column_shells M N K lengthScale hNL a).trans_eq + apply congrArg (fun x : ℝ => (lengthScale + 1 : ℝ) * x) + apply Finset.sum_congr rfl + intro j _ + exact annularHighEnergy_coefficientAtScale M N _ K _ + (fun J hJ => (dyadicColumnCoefficient_shell N lengthScale hNL j a J hJ).2) + +theorem dyadicColumnCoefficient_at_scale_energy (N : ℝ) (lengthScale : ℕ) (hNL : N ≤ (2 : ℝ) ^ lengthScale) + (a : idealRange N → ℂ) : + (∑ j : Fin (lengthScale + 1), ∑ J : idealRange ((2 : ℝ) ^ j.val), + ‖coefficientAtScale N ((2 : ℝ) ^ j.val) (dyadicColumnCoefficient N lengthScale hNL j a) J‖ ^ 2) = + ∑ J : idealRange N, ‖a J‖ ^ 2 := by + calc + _ = ∑ j : Fin (lengthScale + 1), ∑ J : idealRange N, ‖dyadicColumnCoefficient N lengthScale hNL j a J‖ ^ 2 := by + apply Finset.sum_congr rfl + intro j _ + exact (coefficientAtScale_energy N _ _ + (fun J hJ => (dyadicColumnCoefficient_shell N lengthScale hNL j a J hJ).2)).symm + _ = _ := dyadicColumnCoefficient_energy N lengthScale hNL a + +end CanonicalQuadraticSieve + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConstantTermSupport.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConstantTermSupport.lean new file mode 100644 index 0000000000000000000000000000000000000000..e1355a1df5e695a8ca556882c183a7090ebe6b03 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ConstantTermSupport.lean @@ -0,0 +1,628 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.FixedProfiles + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein +open MeasureTheory Set Filter +open scoped BigOperators Classical + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal UniqueFactorizationMonoid + +lemma multiset_cube_remainder {α : Type*} [DecidableEq α] (s : Multiset α) (p : α) + (hdiv : ∀ q, q ≠ p → 3 ∣ s.count q) : + ∃ t : Multiset α, s=(s.count p % 3) • {p} + 3 • t := by + let t := Finsupp.toMultiset (s.toFinsupp.mapRange (fun n : ℕ => n/3) (by decide)) + refine ⟨t,?_⟩ + apply Multiset.ext.mpr + intro q + simp only [Multiset.count_add,Multiset.count_nsmul,Multiset.count_singleton, + t,Finsupp.count_toMultiset,Finsupp.mapRange_apply,Multiset.toFinsupp_apply] + by_cases hq : q=p + · subst q + simp only [ite_true,mul_one] + omega + · simp only [hq,ite_false,mul_zero,zero_add] + exact (Nat.mul_div_cancel' (hdiv q hq)).symm + +lemma residue_lambda_prime : Prime lambda := by + let : Fact (Nat.Prime 3) := ⟨Nat.prime_three⟩ + exact (IsCyclotomicExtension.zeta_spec 3 ℚ K).zeta_sub_one_prime' + +lemma constant_coefficient_unramified_count [NormalizationMonoid O] + (c : O) (hc : c ≠ 0) (hlevel : (3:O) ∣ c) (hA : arithmeticResidueSum 0 c ≠ 0) + (q : O) (hq : q ≠ normalize lambda) : 3 ∣ (normalizedFactors c).count q := by + by_cases hmem : q ∈ normalizedFactors c + · have hprime := prime_of_normalized_factor q hmem + let P : Ideal O := Ideal.span {q} + let : P.IsMaximal := PrincipalIdealRing.isMaximal_of_irreducible hprime.irreducible + have hg : lambda ∉ P := by + intro hl + have ha : Associated q lambda := + hprime.associated_of_dvd residue_lambda_prime (Ideal.mem_span_singleton.mp hl) + apply hq + exact (normalize_normalized_factor q hmem).symm.trans + (normalize_eq_normalize_iff_associated.mpr ha) + obtain ⟨p,hP,hprimary,-⟩ := cubicJacobi_exists_primary_generator P hg + have hqp : Associated q p := Ideal.span_singleton_eq_span_singleton.mp hP + have hp : Prime p := hqp.prime_iff.mp hprime + obtain ⟨b,hfactor,hpb⟩ := (FiniteMultiplicity.of_prime_left hp hc).exists_eq_pow_mul_and_not_dvd + have hd := constant_coefficient_primary_prime_exponent c p b (multiplicity p c) + hc hlevel hp hprimary hpb hfactor hA + have hcount := multiplicity_eq_count_normalizedFactors hprime.irreducible hc + rw [normalize_normalized_factor q hmem] at hcount + rw [← hcount,← multiplicity_eq_of_associated_left hqp] + exact hd + · rw [Multiset.count_eq_zero.mpr hmem] + exact dvd_zero _ + +theorem constant_coefficient_cube_reduction (c : O) (hc : c ≠ 0) + (hlevel : (3:O) ∣ c) (hA : arithmeticResidueSum 0 c ≠ 0) : + ∃ (u : Oˣ) (r : ℕ) (a : O), r < 3 ∧ c=(u:O)*lambda^r*a^3 := by + let : StrongNormalizationMonoid O := UniqueFactorizationMonoid.strongNormalizationMonoid + let s := normalizedFactors c + obtain ⟨t,ht⟩ := multiset_cube_remainder s (normalize lambda) + (constant_coefficient_unramified_count c hc hlevel hA) + let r := s.count (normalize lambda) % 3 + have hprod : s.prod=(normalize lambda)^r*t.prod^3 := by + rw [ht,Multiset.prod_add,Multiset.prod_nsmul,Multiset.prod_singleton,Multiset.prod_nsmul] + have hassoc : Associated (lambda^r*t.prod^3) c := by + have hnorm : Associated ((normalize lambda)^r*t.prod^3) (lambda^r*t.prod^3) := + (normalize_associated lambda).pow_pow.mul_right _ + apply hnorm.symm.trans + rw [← hprod] + exact prod_normalizedFactors hc + obtain ⟨u,hu⟩ := hassoc + refine ⟨u,r,t.prod,Nat.mod_lt _ (by decide),?_⟩ + rw [← hu] + ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified + +lemma constant_coefficient_ramified_equation (c : O) (hc : c ≠ 0) (hlevel : (3:O) ∣ c) + (hA : arithmeticResidueSum 0 c ≠ 0) (u : Oˣ) (r : ℕ) (a : O) (ha : a ≠ 0) + (hfactor : c=(u:O)*lambda^r*a^3) (A B : ℤ) : + symbol (u:O) (primaryCoord A B)*(cubicExp A)^r=1 := by + let t0 := primaryCoord A B + have ht0 : lambda^2 ∣ t0-1 := primaryCoord_primary A B + obtain ⟨w,hw⟩ := exists_coprime_three_shift t0 3 a ht0 (primary_coprime_three t0 ht0) ha + let t := t0+3*w*3 + have ht : lambda^2 ∣ t-1 := primary_add_multiple_three t0 3 w ht0 + have h9 : (9:O) ∣ t-t0 := ⟨w,by dsimp [t]; ring⟩ + have hat : IsCoprime a t := hw.symm + have hlt : IsCoprime lambda t := + coprime_of_dvd_sub_one lambda t ((show lambda ∣ lambda^2 from ⟨lambda,by ring⟩).trans ht) + have hct : IsCoprime c t := by + rw [hfactor,show (u:O)*lambda^r*a^3=(u:O)*(lambda^r*a^3) by ring] + apply (isCoprime_mul_unit_left_left u.isUnit _ _).mpr + exact hlt.pow_left.mul_left hat.pow_left + have htriv := arithmeticResidueSum_ne_zero_forces_trivial c hc hlevel hA t + ⟨hct,three_dvd_primary_sub_one t ht⟩ + have hacube : symbol (a^3) t=1 := by + rw [symbol_pow_numerator a t ht 3] + exact symbol_cube_of_isCoprime a t ht hat + rw [hfactor,symbol_mul_numerator _ _ t ht,symbol_mul_numerator _ _ t ht, + symbol_pow_numerator lambda t ht r,hacube,mul_one, + symbol_unit_congr_mod_nine (u:O) t t0 u.isUnit ht ht0 h9, + symbol_lambda_congr_mod_nine t t0 ht ht0 h9, + symbol_lambda_eq_linearRay t0 ht0] at htriv + simpa only [t0,linearRay_primaryCoord,one_mul,zero_mul,add_zero] using htriv + +lemma unit_eq_sign_of_symbol_class (u : Oˣ) + (hu : symbol (u:O) (primaryCoord 0 1)=1) : (u:O)=1 ∨ (u:O)=-1 := by + let ζ := IsCyclotomicExtension.zeta_spec 3 ℚ K + let η : Oˣ := (ζ.toInteger_isPrimitiveRoot.isUnit (by decide)).unit + have hη : (η:O)=omega := rfl + have hlist : u ∈ ([1,-1,η,-η,η^2,-η^2] : List Oˣ) := + IsCyclotomicExtension.Rat.Three.Units.mem ζ u + have hω : symbol omega (primaryCoord 0 1)=omega^2 := by + rw [symbol_omega_eq_linearRay _ (primaryCoord_primary 0 1),linearRay_primaryCoord] + norm_num [cubicExp] + have hω2 : symbol (omega^2) (primaryCoord 0 1)=omega^4 := by + rw [symbol_pow_numerator omega _ (primaryCoord_primary 0 1) 2,hω,← pow_mul] + have hn2 : omega^2 ≠ 1 := (omega_primitive.pow_eq_one_iff_dvd 2).not.mpr (by decide) + have hn4 : omega^4 ≠ 1 := (omega_primitive.pow_eq_one_iff_dvd 4).not.mpr (by decide) + simp only [List.mem_cons,List.mem_nil_iff,or_false] at hlist + rcases hlist with h | h | h | h | h | h + · exact Or.inl (by rw [h,Units.val_one]) + · exact Or.inr (by rw [h,Units.val_neg,Units.val_one]) + · exact False.elim (hn2 (by simpa only [h,hη,hω] using hu)) + · exact False.elim (hn2 (by simpa only [h,Units.val_neg,hη, + (symbol_neg_numerator _ _ (primaryCoord_primary 0 1)),hω] using hu)) + · exact False.elim (hn4 (by simpa only [h,Units.val_pow_eq_pow_val,hη,hω2] using hu)) + · exact False.elim (hn4 (by simpa only [h,Units.val_neg,Units.val_pow_eq_pow_val,hη, + (symbol_neg_numerator _ _ (primaryCoord_primary 0 1)),hω2] using hu)) + +theorem arithmeticResidueSum_ne_zero_implies_cube (c : O) (hc : c ≠ 0) + (hlevel : (3:O) ∣ c) (hA : arithmeticResidueSum 0 c ≠ 0) : ∃ a : O,c=a^3 := by + obtain ⟨u,r,a,hr,hfactor⟩ := constant_coefficient_cube_reduction c hc hlevel hA + have ha : a ≠ 0 := by + intro hz + rw [hz,zero_pow (by decide : (3:ℕ) ≠ 0),mul_zero] at hfactor + exact hc hfactor + have h01 := constant_coefficient_ramified_equation c hc hlevel hA u r a ha hfactor 0 1 + have husign := unit_eq_sign_of_symbol_class u (by + simpa only [cubicExp_zero,one_pow,mul_one] using h01) + have h10 := constant_coefficient_ramified_equation c hc hlevel hA u r a ha hfactor 1 0 + have hωr : omega^r=1 := by + rcases husign with hu | hu + · simpa only [hu,symbol_one_numerator _ (primaryCoord_primary 1 0),one_mul, + cubicExp,Int.reduceMod,Int.toNat_one,pow_one] using h10 + · simpa only [hu,symbol_neg_one _ (primaryCoord_primary 1 0),one_mul, + cubicExp,Int.reduceMod,Int.toNat_one,pow_one] using h10 + have hdiv : 3 ∣ r := (omega_primitive.pow_eq_one_iff_dvd r).mp hωr + have hr0 : r=0 := by omega + rw [hr0,pow_zero,mul_one] at hfactor + rcases husign with hu | hu + · refine ⟨a,?_⟩ + simpa only [hu,one_mul] using hfactor + · refine ⟨-a,?_⟩ + rw [hfactor,hu] + ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal + +theorem arithmeticResidueSum_ne_zero_iff_cube (c : O) (hc : c ≠ 0) (hlevel : (3:O) ∣ c) : + arithmeticResidueSum 0 c ≠ 0 ↔ ∃ a : O,c=a^3 := by + constructor + · exact arithmeticResidueSum_ne_zero_implies_cube c hc hlevel + · rintro ⟨a,rfl⟩ + have ha : a ≠ 0 := fun h => hc (by rw [h]; norm_num) + exact arithmeticResidueSum_cube_ne_zero a ha + +theorem arithmeticResidueSum_constant_formula (c : O) (hc : c ≠ 0) (hlevel : (3:O) ∣ c) : + arithmeticResidueSum 0 c= + if ∃ a : O,c=a^3 then (Nat.card (AdmissibleResidue c):ℂ) else 0 := by + split_ifs with hcube + · obtain ⟨a,rfl⟩ := hcube + exact arithmeticResidueSum_cube a (fun h => hc (by rw [h]; norm_num)) + · exact not_ne_iff.mp (fun hA => hcube (arithmeticResidueSum_ne_zero_implies_cube c hc hlevel hA)) + +end CubicEisenstein + +open scoped BigOperators Classical +namespace CanonicalQuadraticSieve + +section +open ActualEisensteinCubic CompletedGauss ConcretePrimeRowBridge + +def idealZeroMask (D : Ideal O) (z : O) : ℂ := + if ∃ P ∈ UniqueFactorizationMonoid.normalizedFactors D, z ∈ P then 0 else 1 + +theorem idealSupport_singleton_univ (D : Ideal O) : + idealSupport {D} D = Finset.univ := by + apply Finset.eq_univ_of_forall + intro P + apply (mem_idealSupport_iff {D} D P).mpr + obtain ⟨I, hI, hP⟩ := mem_primePool_iff.mp P.property + have hID : I = D := Finset.mem_singleton.mp hI + simpa only [hID] using hP + +theorem singleton_rowCoprimeMask_eq_idealZeroMask (D : Ideal O) (z : O) : + rowCoprimeMask (fun P : primePool {D} => P.val) Finset.univ z = idealZeroMask D z := by + have he : (∃ P ∈ (Finset.univ : Finset (primePool {D})), z ∈ P.val) ↔ + ∃ P ∈ UniqueFactorizationMonoid.normalizedFactors D, z ∈ P := by + constructor + · rintro ⟨P, _, hz⟩ + obtain ⟨I, hI, hP⟩ := mem_primePool_iff.mp P.property + have hID : I = D := Finset.mem_singleton.mp hI + exact ⟨P.val, hID ▸ hP, hz⟩ + · rintro ⟨P, hP, hz⟩ + have hp : P ∈ primePool {D} := mem_primePool_iff.mpr ⟨D, Finset.mem_singleton_self D, hP⟩ + exact ⟨⟨P, hp⟩, Finset.mem_univ _, hz⟩ + simp only [rowCoprimeMask, idealZeroMask, he] + +theorem canonical_quadraticRow_star (D : Ideal O) (hD : Admissible D) (z : O) : + star (quadraticRow D z) = quadraticRow D z := by + let F : Finset (Ideal O) := {D} + have hF : ∀ I ∈ F, Admissible I := by + intro I hI + have hID := Finset.mem_singleton.mp hI + simpa only [hID] using hD + rw [quadraticRow_eq_pool F hF D (Finset.mem_singleton_self D)] + exact QuadraticInitialBound.quadraticRow_star _ _ _ _ + +theorem canonical_quadraticRow_squared (D : Ideal O) (hD : Admissible D) (z : O) : + quadraticRow D z * quadraticRow D z = idealZeroMask D z := by + let F : Finset (Ideal O) := {D} + have hF : ∀ I ∈ F, Admissible I := by + intro I hI + have hID := Finset.mem_singleton.mp hI + simpa only [hID] using hD + rw [quadraticRow_eq_pool F hF D (Finset.mem_singleton_self D)] + rw [← QuadraticSquarefreeKernel.quadraticRow_mul _ _ _ z z, ← pow_two, + QuadraticSquarefreeKernel.quadraticRow_square, idealSupport_singleton_univ] + exact singleton_rowCoprimeMask_eq_idealZeroMask D z + +def gcdMaskPrimes (D : Ideal O) : Finset (Ideal O) := + {Ideal.span {lambda}, Ideal.span {(2 : O)}} ∪ + (UniqueFactorizationMonoid.normalizedFactors D).toFinset + +instance gcdMaskPrimes_maximal (D : Ideal O) (P : gcdMaskPrimes D) : P.val.IsMaximal := by + rcases Finset.mem_union.mp P.property with hp | hp + · rcases Finset.mem_insert.mp hp with hp | hp + · rw [hp] + exact lambdaIdeal_maximal + · rw [Finset.mem_singleton.mp hp] + exact twoIdeal_maximal + · have h := UniqueFactorizationMonoid.prime_of_normalized_factor P.val (Multiset.mem_toFinset.mp hp) + exact (Ideal.isPrime_of_prime h).isMaximal h.ne_zero + +theorem gcdMaskPrimes_mask (D : Ideal O) (z : O) : + rowCoprimeMask (fun P : gcdMaskPrimes D => P.val) Finset.univ z = + rowCoprimeMask badPrime Finset.univ z * idealZeroMask D z := by + have he : (∃ P ∈ (Finset.univ : Finset (gcdMaskPrimes D)), z ∈ P.val) ↔ + (lambda ∣ z ∨ (2 : O) ∣ z) ∨ + ∃ P ∈ UniqueFactorizationMonoid.normalizedFactors D, z ∈ P := by + constructor + · rintro ⟨P, _, hz⟩ + rcases Finset.mem_union.mp P.property with hp | hp + · rcases Finset.mem_insert.mp hp with hp | hp + · exact Or.inl (Or.inl (Ideal.mem_span_singleton.mp (hp ▸ hz))) + · exact Or.inl (Or.inr (Ideal.mem_span_singleton.mp ((Finset.mem_singleton.mp hp) ▸ hz))) + · exact Or.inr ⟨P.val, Multiset.mem_toFinset.mp hp, hz⟩ + · rintro ((hz | hz) | ⟨P, hP, hz⟩) + · exact ⟨⟨Ideal.span {lambda}, Finset.mem_union_left _ (Finset.mem_insert_self _ _)⟩, + Finset.mem_univ _, Ideal.mem_span_singleton.mpr hz⟩ + · exact ⟨⟨Ideal.span {(2 : O)}, Finset.mem_union_left _ (Finset.mem_insert_of_mem (Finset.mem_singleton_self _))⟩, + Finset.mem_univ _, Ideal.mem_span_singleton.mpr hz⟩ + · exact ⟨⟨P, Finset.mem_union_right _ (Multiset.mem_toFinset.mpr hP)⟩, Finset.mem_univ _, hz⟩ + change (if ∃ P ∈ (Finset.univ : Finset (gcdMaskPrimes D)), z ∈ P.val then (0 : ℂ) else 1) = _ + simp only [he] + rw [badPrime_mask, supported_span_iff] + unfold idealZeroMask + by_cases hl : lambda ∣ z <;> by_cases ht : (2 : O) ∣ z <;> + by_cases hd : ∃ P ∈ UniqueFactorizationMonoid.normalizedFactors D, z ∈ P <;> simp [hl, ht, hd] + +end +section + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss ConcretePrimeRowBridge ActualEisensteinCoordinates +open EisensteinSchwartzPoisson GaussGeneratorTransport QuadraticUnitInvariance + +theorem canonical_same_ray_pair_poisson + {α : Type*} [DecidableEq α] + (R : α → Ideal O) [∀ i, (R i).IsMaximal] (hinj : Function.Injective R) (S : Finset α) + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hcop : IsCoprime I J) (hray : columnRay I = columnRay J) + (W : 𝓢(ℝ, ℂ)) (M : ℝ) (hM : 0 < M) : + let n := primaryGenerator I * primaryGenerator J + let χ := fun z => quadraticRow I z * quadraticRow J z + (∑' z : O, rowCoprimeMask R S z * χ z * W (‖eisEmbedding z‖ ^ 2 / M)) = + ((M : ℂ) / (‖eisEmbedding n‖ : ℂ)) * + ∑ E ∈ S.powerset, + let d := primeSubsetGenerator R E + ((UniqueFactorizationMonoid.moebius (∏ i ∈ E, R i) : ℂ) * χ d / + (‖eisEmbedding d‖ ^ 2 : ℝ)) * + ∑' h : O, χ h * paperRadialFourier W + (M * ‖eisEmbedding h‖ ^ 2 / (‖eisEmbedding d‖ ^ 2 * ‖eisEmbedding n‖ ^ 2)) := by + let F : Finset (Ideal O) := {I, J} + have hF : ∀ lengthScale ∈ F, Admissible lengthScale := by + intro lengthScale hL + rcases Finset.mem_insert.mp hL with rfl | hL + · exact hI + · have hLJ := Finset.mem_singleton.mp hL + simpa only [hLJ] using hJ + have hIF : I ∈ F := by simp [F] + have hJF : J ∈ F := by simp [F] + let p := poolPrimary F + let A := idealSupport F I + let B := idealSupport F J + let : ∀ i : primePool F, (Ideal.span {p i}).IsMaximal := + fun i => by change (Ideal.span {poolPrimary F i}).IsMaximal; rw [poolPrimary_span F hF i]; infer_instance + have hd : Disjoint A B := idealSupport_disjoint_of_coprime F I J hcop + have hpgI : primaryGenerator I = ∏ i ∈ A, p i := primaryGenerator_eq_poolProduct F hF I hIF + have hpgJ : primaryGenerator J = ∏ i ∈ B, p i := primaryGenerator_eq_poolProduct F hF J hJF + have hr : residue (∏ i ∈ A, p i) = residue (∏ i ∈ B, p i) := by + rw [← hpgI, ← hpgJ] + exact hray + have hn : (∏ i ∈ A ∪ B, p i) = primaryGenerator I * primaryGenerator J := by + rw [Finset.prod_union hd, ← hpgI, ← hpgJ] + have hrowI (z : O) : QuadraticInitialBound.quadraticRow + (fun i => Ideal.span {p i}) (poolPrimary_good F hF) A z = quadraticRow I z := + (quadraticRow_eq_primaryPool F hF I hIF z).symm + have hrowJ (z : O) : QuadraticInitialBound.quadraticRow + (fun i => Ideal.span {p i}) (poolPrimary_good F hF) B z = quadraticRow J z := + (quadraticRow_eq_primaryPool F hF J hJF z).symm + have ht := same_ray_quadratic_pair_poisson R hinj S p (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) (poolPrimary_odd F hF) + A B hd hr W M hM + simpa only [hn, hrowI, hrowJ] using ht + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss ConcretePrimeRowBridge ActualEisensteinCoordinates +open EisensteinSchwartzPoisson GaussGeneratorTransport QuadraticUnitInvariance PrimaryIdealUnitReindex + +theorem canonical_pair_unit_invariant (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hray : columnRay I = columnRay J) (u : Oˣ) (z : O) : + quadraticRow I (u.val * z) * quadraticRow J (u.val * z) = + quadraticRow I z * quadraticRow J z := by + let F : Finset (Ideal O) := {I, J} + have hF : ∀ lengthScale ∈ F, Admissible lengthScale := by + intro lengthScale hL + rcases Finset.mem_insert.mp hL with rfl | hL + · exact hI + · have hLJ := Finset.mem_singleton.mp hL + simpa only [hLJ] using hJ + have hIF : I ∈ F := by simp [F] + have hJF : J ∈ F := by simp [F] + let p := poolPrimary F + let A := idealSupport F I + let B := idealSupport F J + let : ∀ i : primePool F, (Ideal.span {p i}).IsMaximal := + fun i => by change (Ideal.span {poolPrimary F i}).IsMaximal; rw [poolPrimary_span F hF i]; infer_instance + have hcA : Pairwise (Function.onFun IsCoprime (fun i : A => Ideal.span {p i.val})) := + fun i j hij => poolPrimary_coprime F hF (fun h => hij (Subtype.ext h)) + have hcB : Pairwise (Function.onFun IsCoprime (fun i : B => Ideal.span {p i.val})) := + fun i j hij => poolPrimary_coprime F hF (fun h => hij (Subtype.ext h)) + have hr : residue (∏ i : A, p i.val) = residue (∏ i : B, p i.val) := by + rw [Finset.prod_coe_sort, Finset.prod_coe_sort, + ← primaryGenerator_eq_poolProduct F hF I hIF, ← primaryGenerator_eq_poolProduct F hF J hJF] + exact hray + have h := quadratic_pair_unit_invariant + (fun i : A => p i.val) (fun i => poolPrimary_ne_zero F hF i.val) hcA + (fun i => poolPrimary_good F hF i.val) (fun i => poolPrimary_odd F hF i.val) + (fun i : B => p i.val) (fun i => poolPrimary_ne_zero F hF i.val) hcB + (fun i => poolPrimary_good F hF i.val) (fun i => poolPrimary_odd F hF i.val) hr u z + have hrowI (w : O) : finiteSexticRow (fun i : A => Ideal.span {p i.val}) + (fun i => poolPrimary_good F hF i.val) (fun _ => 3) w = quadraticRow I w := + (quadraticRow_eq_primarySubset F hF I hIF w).symm + have hrowJ (w : O) : finiteSexticRow (fun i : B => Ideal.span {p i.val}) + (fun i => poolPrimary_good F hF i.val) (fun _ => 3) w = quadraticRow J w := + (quadraticRow_eq_primarySubset F hF J hJF w).symm + simpa only [hrowI, hrowJ] using h + +theorem canonical_masked_pair_summable {α : Type*} (R : α → Ideal O) (S : Finset α) + (I J : Ideal O) (W : 𝓢(ℝ, ℂ)) (M : ℝ) (hM : 0 < M) : + Summable (fun z : O => rowCoprimeMask R S z * + (quadraticRow I z * quadraticRow J z) * W (‖eisEmbedding z‖ ^ 2 / M)) := by + have hW : Summable (fun z : O => ‖W (‖eisEmbedding z‖ ^ 2 / M)‖) := by + simpa only [scaledRadialTest_apply] using + actual_eisenstein_summable_norm (scaledRadialTest W M hM) + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun z => norm_nonneg _) _ hW + intro z + simp only [norm_mul] + calc + _ ≤ 1 * (1 * 1) * ‖W (‖eisEmbedding z‖ ^ 2 / M)‖ := by + gcongr + · exact rowCoprimeMask_norm_le_one R S z + · exact quadraticRow_norm_le_one I z + · exact quadraticRow_norm_le_one J z + _ = _ := by ring + +theorem canonical_pair_lattice_eq_primary_ideal_sum + {α : Type*} (R : α → Ideal O) (S : Finset α) + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hray : columnRay I = columnRay J) (W : 𝓢(ℝ, ℂ)) (M : ℝ) (hM : 0 < M) : + (∑' z : O, if lambda ∣ z then 0 else rowCoprimeMask R S z * + (quadraticRow I z * quadraticRow J z) * W (‖eisEmbedding z‖ ^ 2 / M)) = + (Nat.card Oˣ : ℂ) * ∑' lengthScale : GoodIdeal, + rowCoprimeMask R S (primaryGenerator lengthScale.val) * + (quadraticRow I (primaryGenerator lengthScale.val) * quadraticRow J (primaryGenerator lengthScale.val)) * + W ((Ideal.absNorm lengthScale.val : ℝ) / M) := by + have hs := canonical_masked_pair_summable R S I J W M hM + have hu (u : Oˣ) (lengthScale : GoodIdeal) : + rowCoprimeMask R S (u.val * primaryGenerator lengthScale.val) * + (quadraticRow I (u.val * primaryGenerator lengthScale.val) * quadraticRow J (u.val * primaryGenerator lengthScale.val)) * + W (‖eisEmbedding (u.val * primaryGenerator lengthScale.val)‖ ^ 2 / M) = + rowCoprimeMask R S (primaryGenerator lengthScale.val) * + (quadraticRow I (primaryGenerator lengthScale.val) * quadraticRow J (primaryGenerator lengthScale.val)) * + W (‖eisEmbedding (primaryGenerator lengthScale.val)‖ ^ 2 / M) := by + rw [rowCoprimeMask_unit_mul, canonical_pair_unit_invariant I J hI hJ hray, + norm_eisEmbedding_unit_mul] + have ht := tsum_ramified_mask_unit_invariant _ hs hu + change (∑' z : O, if lambda ∣ z then (0 : ℂ) else _) = _ at ht + have hn (lengthScale : GoodIdeal) := primaryGenerator_norm_sq lengthScale.val lengthScale.property + simpa only [hn] using ht + +theorem canonical_mask_lattice_eq_six_all_ideals + {α : Type*} (R : α → Ideal O) (S : Finset α) + (hmask : ∀ z : O, lambda ∣ z → rowCoprimeMask R S z = 0) + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hray : columnRay I = columnRay J) (W : 𝓢(ℝ, ℂ)) (M : ℝ) (hM : 0 < M) : + (∑' z : O, rowCoprimeMask R S z * + (quadraticRow I z * quadraticRow J z) * W (‖eisEmbedding z‖ ^ 2 / M)) = + (6 : ℂ) * ∑' lengthScale : Ideal O, + rowCoprimeMask R S (primaryGenerator lengthScale) * + (quadraticRow I (primaryGenerator lengthScale) * quadraticRow J (primaryGenerator lengthScale)) * + W ((Ideal.absNorm lengthScale : ℝ) / M) := by + have ht := canonical_pair_lattice_eq_primary_ideal_sum R S I J hI hJ hray W M hM + rw [card_units_eq_six] at ht + have hl : (∑' z : O, if lambda ∣ z then 0 else rowCoprimeMask R S z * + (quadraticRow I z * quadraticRow J z) * W (‖eisEmbedding z‖ ^ 2 / M)) = + ∑' z : O, rowCoprimeMask R S z * + (quadraticRow I z * quadraticRow J z) * W (‖eisEmbedding z‖ ^ 2 / M) := by + apply tsum_congr + intro z + by_cases hz : lambda ∣ z + · simp [hz, hmask z hz] + · rw [ite_eq_right hz] + rw [hl] at ht + rw [ht] + congr 1 + let f : Ideal O → ℂ := fun lengthScale => rowCoprimeMask R S (primaryGenerator lengthScale) * + (quadraticRow I (primaryGenerator lengthScale) * quadraticRow J (primaryGenerator lengthScale)) * + W ((Ideal.absNorm lengthScale : ℝ) / M) + change (∑' lengthScale : GoodIdeal, f lengthScale.val) = ∑' lengthScale : Ideal O, f lengthScale + have hsub : (∑' lengthScale : GoodIdeal, f lengthScale.val) = + ∑' lengthScale : Ideal O, ({lengthScale : Ideal O | primaryGenerator lengthScale ≠ 0} : Set (Ideal O)).indicator f lengthScale := + tsum_subtype _ f + rw [hsub] + apply tsum_congr + intro lengthScale + by_cases hg : primaryGenerator lengthScale ≠ 0 + · exact Set.indicator_of_mem hg f + · rw [Set.indicator_of_notMem hg] + have hz : primaryGenerator lengthScale = 0 := not_not.mp hg + dsimp only [f] + rw [hz, hmask 0 (dvd_zero _)] + simp only [zero_mul] + +end + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss ConcretePrimeRowBridge +open EisensteinSchwartzPoisson GaussGeneratorTransport PrimaryIdealUnitReindex + +theorem badPrime_injective : Function.Injective badPrime := by + have hgood : lambda ∉ (Ideal.span {(2 : O)} : Ideal O) := by + have hg := cubicTwoIdeal_good + change lambda ∉ cubicTwoIdeal at hg + simpa only [cubicTwoIdeal, Ideal.span_singleton_neg] using hg + intro i j hij + cases i <;> cases j + · rfl + · exfalso + apply hgood + have he : (Ideal.span {lambda} : Ideal O) = Ideal.span {(2 : O)} := hij + rw [← he] + exact Ideal.subset_span (by simp) + · exfalso + apply hgood + have he : (Ideal.span {(2 : O)} : Ideal O) = Ideal.span {lambda} := hij + rw [he] + exact Ideal.subset_span (by simp) + · rfl + +theorem supported_primaryGenerator_ne_zero (lengthScale : Ideal O) (hL : Supported lengthScale) : + primaryGenerator lengthScale ≠ 0 := + primaryGenerator_ne_zero_of_good_factors lengthScale hL.1 (fun P hP => (hL.2 P hP).1) + +theorem supported_span_primaryGenerator_iff (lengthScale : Ideal O) : + Supported (Ideal.span {primaryGenerator lengthScale}) ↔ Supported lengthScale := by + constructor + · intro h + have hn : primaryGenerator lengthScale ≠ 0 := by + intro hz + apply h.1 + simp [hz] + rwa [(primaryGenerator_spec lengthScale hn).1] at h + · intro h + rw [(primaryGenerator_spec lengthScale (supported_primaryGenerator_ne_zero lengthScale h)).1] + exact h + +theorem badPrime_mask_primaryGenerator (lengthScale : Ideal O) : + rowCoprimeMask badPrime Finset.univ (primaryGenerator lengthScale) = if Supported lengthScale then 1 else 0 := by + rw [badPrime_mask, supported_span_primaryGenerator_iff] + +theorem canonical_supported_lattice_eq_six_ideals + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hray : columnRay I = columnRay J) (W : 𝓢(ℝ, ℂ)) (M : ℝ) (hM : 0 < M) : + (∑' z : O, rowCoprimeMask badPrime Finset.univ z * + (quadraticRow I z * quadraticRow J z) * W (‖eisEmbedding z‖ ^ 2 / M)) = + (6 : ℂ) * ∑' lengthScale : Ideal O, if Supported lengthScale then + (quadraticRow I (primaryGenerator lengthScale) * quadraticRow J (primaryGenerator lengthScale)) * + W ((Ideal.absNorm lengthScale : ℝ) / M) else 0 := by + have hm (z : O) (hz : lambda ∣ z) : rowCoprimeMask badPrime Finset.univ z = 0 := by + rw [badPrime_mask] + have hns : ¬Supported (Ideal.span {z}) := fun h => ((supported_span_iff z).mp h).1 hz + exact ite_eq_right hns + rw [canonical_mask_lattice_eq_six_all_ideals badPrime Finset.univ hm I J hI hJ hray W M hM] + congr 1 + apply tsum_congr + intro lengthScale + rw [badPrime_mask_primaryGenerator] + by_cases hL : Supported lengthScale <;> simp [hL] + +theorem canonical_supported_pair_poisson + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (hcop : IsCoprime I J) (hray : columnRay I = columnRay J) + (W : 𝓢(ℝ, ℂ)) (M : ℝ) (hM : 0 < M) : + let n := primaryGenerator I * primaryGenerator J + let χ := fun z => quadraticRow I z * quadraticRow J z + (∑' lengthScale : Ideal O, if Supported lengthScale then χ (primaryGenerator lengthScale) * + W ((Ideal.absNorm lengthScale : ℝ) / M) else 0) = + ((M : ℂ) / (6 * ‖eisEmbedding n‖ : ℂ)) * + ∑ E ∈ (Finset.univ : Finset Bool).powerset, + let d := primeSubsetGenerator badPrime E + ((UniqueFactorizationMonoid.moebius (∏ i ∈ E, badPrime i) : ℂ) * χ d / + (‖eisEmbedding d‖ ^ 2 : ℝ)) * + ∑' h : O, χ h * paperRadialFourier W + (M * ‖eisEmbedding h‖ ^ 2 / (‖eisEmbedding d‖ ^ 2 * ‖eisEmbedding n‖ ^ 2)) := by + have hlat := canonical_same_ray_pair_poisson badPrime badPrime_injective Finset.univ I J hI hJ hcop hray W M hM + have hid := canonical_supported_lattice_eq_six_ideals I J hI hJ hray W M hM + dsimp only at hlat ⊢ + rw [hid] at hlat + calc + _ = (6 : ℂ)⁻¹ * ((M : ℂ) / ‖eisEmbedding (primaryGenerator I * primaryGenerator J)‖ * _) := by + rw [← hlat] + ring + _ = _ := by ring + +end CanonicalQuadraticSieve + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CoordinateLaplacian.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CoordinateLaplacian.lean new file mode 100644 index 0000000000000000000000000000000000000000..de71a81d2c9a56ac6b2d2b857dc4619ce8ea0fbd --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CoordinateLaplacian.lean @@ -0,0 +1,642 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.RadialProfiles +import OAI.NumberTheory.DirichletL.CubicSieve.CanonicalLogEnergy + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff SchwartzMap LineDeriv + +def kernelCoordinateLaplacian (f : kernelSmoothTests) (p : EuclideanSpatial) : ℂ := + -(p 2:ℂ)^2*(∑j : Fin 3, + fderiv ℝ (fun q => fderiv ℝ (kernelTestField f) q (euclideanCoordinateVector j)) p + (euclideanCoordinateVector j))+ + (p 2:ℂ)*fderiv ℝ (kernelTestField f) p (euclideanCoordinateVector 2) + +lemma kernelCoreLift_laplacian (χ : PositiveChartCutoff) (f : kernelSmoothTests) + (p : EuclideanSpatial) (hp : p∈kernelChartCore χ) : + upperPositiveLaplacian (kernelCoreLift χ f) p=kernelCoordinateLaplacian f p := by + have he := kernelCoreLift_eventually_eq χ f p hp + have hd (j : Fin 3) : (fun q => fderiv ℝ (kernelCoreLift χ f) q (euclideanCoordinateVector j))=ᶠ[𝓝 p] + (fun q => fderiv ℝ (kernelTestField f) q (euclideanCoordinateVector j)) := + (he.fderiv (𝕜 := ℝ)).mono (fun q hq => congrArg (fun d => d (euclideanCoordinateVector j)) hq) + have hdd (j : Fin 3) : + (∂_{euclideanCoordinateVector j} (∂_{euclideanCoordinateVector j} (kernelCoreLift χ f))) p= + fderiv ℝ (fun q => fderiv ℝ (kernelTestField f) q (euclideanCoordinateVector j)) p + (euclideanCoordinateVector j) := by + change fderiv ℝ (fun q => fderiv ℝ (kernelCoreLift χ f) q (euclideanCoordinateVector j)) p + (euclideanCoordinateVector j)=_ + rw [(hd j).fderiv_eq] + simp only [upperPositiveLaplacian,kernelCoordinateLaplacian,hdd, + SchwartzMap.lineDerivOp_apply_eq_fderiv,he.fderiv_eq] + +lemma kernelDirichletForm_coordinate_equation_chart (χ : PositiveChartCutoff) + (hinj : Set.InjOn kernelEuclideanProjection (tsupport χ.func)) + (f g : kernelSmoothTests) (hg : tsupport g.1⊆kernelChartCoreImage χ) + (A : KernelQuotient→ℂ) (hA : MemLp A 2 (integralQuotientVolume globalKubotaKernel)) + (heq : ∀p,0

star (A q)*g.1 q) (integralQuotientVolume globalKubotaKernel) := + hA.star.integrable_mul (kernelSmoothTests_memLp g) + have himg : kernelChartCoreImage χ⊆kernelEuclideanProjection '' S := + Set.image_mono (kernelChartCore_subset χ) + rw [kernelDirichletForm_eq_chart_laplacian χ hinj f g hg] + calc + _ = ∫p in S,star (upperPositiveLaplacian (kernelCoreLift χ f) p)*kernelCoreLift χ g p/(p 2:ℂ)^3 := by + symm + apply setIntegral_eq_integral_of_forall_compl_eq_zero + intro p hp + have hz : kernelCoreLift χ g p=0 := image_eq_zero_of_notMem_tsupport + (fun h => hp (kernelCoreLift_tsupport_outer χ g h)) + rw [hz,mul_zero,zero_div] + _ = ∫p in S,star (A (kernelEuclideanProjection p))*g.1 (kernelEuclideanProjection p)/(p 2:ℂ)^3 := by + apply setIntegral_congr_fun hS + intro p hp + dsimp only + rw [kernelCoreLift_eq_on_outer χ hinj g hg hp] + by_cases hc : p∈kernelChartCore χ + · rw [kernelCoreLift_laplacian χ f p hc,heq p (χ.positive hp)] + rfl + · have hz : kernelCoreLift χ g p=0 := image_eq_zero_of_notMem_tsupport + (fun h => hc (kernelCoreLift_tsupport χ hinj g hg h)) + rw [kernelCoreLift_eq_on_outer χ hinj g hg hp] at hz + change g.1 (kernelEuclideanProjection p)=0 at hz + change star _*g.1 (kernelEuclideanProjection p)/_=star _*g.1 (kernelEuclideanProjection p)/_ + rw [hz,mul_zero,zero_div,mul_zero,zero_div] + _ = ∫p in S,star (A (kernelEuclideanProjection p))*g.1 (kernelEuclideanProjection p) + ∂hyperbolicEuclideanVolume := + (hyperbolicEuclidean_setIntegral_complex S hS χ.positive _).symm + _ = ∫q in kernelEuclideanProjection '' S,star (A q)*g.1 q∂integralQuotientVolume globalKubotaKernel := + kernelEuclideanProjection_integral_complex S hS χ.positive hinj _ hi.aestronglyMeasurable + _ = _ := by + apply setIntegral_eq_integral_of_forall_compl_eq_zero + intro q hq + have hz : g.1 q=0 := image_eq_zero_of_notMem_tsupport (fun h => hq (himg (hg h))) + rw [hz,mul_zero] + +lemma kernelDirichletForm_sum_right {ι : Type*} (f : kernelSmoothTests) + (t : Finset ι) (g : ι→kernelSmoothTests) : + kernelDirichletForm f (∑i∈t,g i)=∑i∈t,kernelDirichletForm f (g i) := by + induction t using Finset.induction_on with + | empty => + have hz := kernelDirichletForm_smul_right 0 f (0 : kernelSmoothTests) + simpa only [Finset.sum_empty,zero_smul,zero_mul] using hz + | @insert i t hi ih => + simp only [Finset.sum_insert hi,kernelDirichletForm_add_right,ih] + +theorem kernelDirichletForm_coordinate_equation (f : kernelSmoothTests) + (A : KernelQuotient→ℂ) (hA : MemLp A 2 (integralQuotientVolume globalKubotaKernel)) + (heq : ∀p,0

hA.star.integrable_mul (kernelSmoothTests_memLp (G i))) + _ = _ := by + apply integral_congr_ae + exact Eventually.of_forall (fun q => by + have hq := congrArg (fun k : kernelSmoothTests => k.1 q) hG + simp only [Submodule.coe_sum,Finset.sum_apply] at hq + dsimp only + rw [←Finset.mul_sum,hq]) + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff + +lemma kernelL2_inner_toLp_smooth (A : KernelQuotient→ℂ) + (hA : MemLp A 2 (integralQuotientVolume globalKubotaKernel)) (g : kernelSmoothTests) : + inner ℂ (hA.toLp A) (kernelSmoothTestsToL2 g)= + ∫q,star (A q)*g.1 q∂integralQuotientVolume globalKubotaKernel := by + calc + _ = ∫q,inner ℂ ((hA.toLp A) q) (kernelSmoothTestsToL2 g q) + ∂integralQuotientVolume globalKubotaKernel := rfl + _ = _ := by + apply integral_congr_ae + filter_upwards [hA.coeFn_toLp,(kernelSmoothTests_memLp g).coeFn_toLp] with q hq hg + change inner ℂ ((hA.toLp A) q) (((kernelSmoothTests_memLp g).toLp g.1) q)=_ + rw [hq,hg,RCLike.inner_apply] + simp only [RCLike.star_def,mul_comm] + +lemma kernelCoordinateLaplacian_form (f : kernelSmoothTests) + (A : KernelQuotient→ℂ) (hA : MemLp A 2 (integralQuotientVolume globalKubotaKernel)) + (heq : ∀p,0

+ inner ℂ (kernelEnergyGradient (kernelEnergyGraphCore f)) (kernelEnergyGradient u))) + (by fun_prop : Continuous (fun u : KernelEnergyGraph => inner ℂ (hA.toLp A) (kernelEnergyMass u)))) + (fun g => by + rw [kernelEnergyGradient_core,kernelEnergyGradient_core,kernelEnergyMass_core, + kernelGradientToL2_inner,kernelL2_inner_toLp_smooth] + exact kernelDirichletForm_coordinate_equation f A hA heq g) + +theorem kernelEnergyLaplacian_graph_of_coordinate (f : kernelSmoothTests) + (A : KernelQuotient→ℂ) (hA : MemLp A 2 (integralQuotientVolume globalKubotaKernel)) + (heq : ∀p,0

Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + +theorem densityChildEnergy_from_canonical_state + (pool : Finset ι) (Ψ₁ Ψ₂ : ActualEisensteinCubic.O →* ℂ) (m : ActualEisensteinCubic.O) + (T : Finset (Ideal ActualEisensteinCubic.O × ActualEisensteinCubic.O)) (labels : Finset (Ideal ActualEisensteinCubic.O)) (V₁ V₂ : ℝ → ℂ) + (X F K E t₁ t₂ : ℝ) (J : ℕ) (hX : 0hbad i) + have hJ : IsCoprime (Ideal.span {jLabel p B (fun i=>v₁ i+v₂ i) ε₁ ε₂}) bad := by + simp only [jLabel,primeProduct,FiniteGaussPhase.span_finset_prod,←Ideal.span_singleton_pow] + exact IsCoprime.prod_left (fun i _=>(hbad i).pow_left) + exact ((hJ.mul_left (hprod C)).mul_left (hprod E)).mul_left (hprod V) + +theorem globalNewLabel_coprime (bad : Ideal ActualEisensteinCubic.O) + (hbad : ∀i,IsCoprime (Ideal.span {p i}) bad) (x : GlobalSecondData ι) : + IsCoprime (SecondPassFiber.newLabel (globalSecondTuple p x)) bad := by + exact actualSecondLabel_coprime p bad hbad x.cube.support x.common x.source.divisor x.source.overlap + x.cube.leftExponent x.cube.rightExponent x.cube.leftBit x.cube.rightBit + +theorem globalCanonicalLabels_coprime (bad : Ideal ActualEisensteinCubic.O) + (hbad : ∀i,IsCoprime (Ideal.span {p i}) bad) + (source : Finset (GlobalSecondData ι)) (side : Bool) + (q : Ideal ActualEisensteinCubic.O × Ideal ActualEisensteinCubic.O × Ideal ActualEisensteinCubic.O) (j : GlobalLogIndex) : + ∀I∈globalCanonicalLabels p source side q j,IsCoprime I bad := by + intro I hI + obtain ⟨z,hz,rfl⟩ := Finset.mem_image.mp hI + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hz + exact globalNewLabel_coprime p bad hbad x + +end SecondPassArithmetic + +namespace CanonicalRowCompletion + +open MeasureTheory +open scoped BigOperators Classical +open ActualEisensteinCubic +open CompletedGauss hiding O +open ConcretePrimeRowBridge hiding O columnWeight +open CanonicalQuadraticSieve hiding O + +theorem finite_integral_energy_polynomial {κ : Type*} [Fintype κ] + (b : ℝ → ℂ) (φ : κ → ℝ → ℂ) (d : ℕ) (E : ℝ) (hE : 0 ≤ E) + (hb : Integrable (fun t => ‖b t‖*(1+|t|)^d)) + (hφ : ∀ k, Integrable (fun t => b t*φ k t)) + (hbound : ∀ t, (∑ k, ‖φ k t‖^2) ≤ E*(1+|t|)^(2*d)) : + (∑ k, ‖∫ t : ℝ, b t*φ k t‖^2) ≤ + E*(∫ t : ℝ, ‖b t‖*(1+|t|)^d)^2 := by + let e := PiLp.continuousLinearEquiv 2 ℂ (fun _ : κ => ℂ) + let F : ℝ → EuclideanSpace ℂ κ := fun t => e.symm (fun k => b t*φ k t) + have hF (t : ℝ) : ‖F t‖ ≤ (‖b t‖*(1+|t|)^d)*Real.sqrt E := by + apply (sq_le_sq₀ (norm_nonneg _) (by positivity)).mp + rw [EuclideanSpace.norm_sq_eq] + change (∑ k, ‖b t*φ k t‖^2) ≤ _ + simp only [norm_mul,mul_pow,← Finset.mul_sum,Real.sq_sqrt hE] + have hp : (1+|t|)^(2*d) = ((1+|t|)^d)^2 := by + rw [← pow_mul,Nat.mul_comm d 2] + calc + _ ≤ ‖b t‖^2 * (E*(1+|t|)^(2*d)) := + mul_le_mul_of_nonneg_left (hbound t) (sq_nonneg _) + _ = _ := by rw [hp]; ring + have he : (∫ t : ℝ, F t) = e.symm (fun k => ∫ t : ℝ, b t*φ k t) := by + rw [show F = (fun t => e.symm (fun k => b t*φ k t)) from rfl, + e.symm.integral_comp_comm] + congr 1 + funext k + exact eval_integral hφ k + have hn : ‖e.symm (fun k => ∫ t : ℝ, b t*φ k t)‖ ≤ + (∫ t : ℝ, ‖b t‖*(1+|t|)^d)*Real.sqrt E := by + rw [← he,← integral_mul_const] + exact norm_integral_le_of_norm_le (hb.mul_const _) + (Filter.Eventually.of_forall hF) + have hh := pow_le_pow_left₀ (norm_nonneg _) hn 2 + rw [EuclideanSpace.norm_sq_eq,mul_pow,Real.sq_sqrt hE] at hh + change (∑ k, ‖∫ t : ℝ, b t*φ k t‖^2) ≤ + (∫ t : ℝ, ‖b t‖*(1+|t|)^d)^2 * E at hh + simpa only [mul_comm] using hh + +theorem norm_add_sum_sq_le {κ : Type*} (s : Finset κ) (a : ℂ) (b : κ → ℂ) : + ‖a + ∑ k ∈ s, b k‖^2 ≤ 2*(‖a‖^2 + s.card*∑ k ∈ s, ‖b k‖^2) := by + have hs : ‖∑ k ∈ s, b k‖^2 ≤ (s.card : ℝ)*∑ k ∈ s, ‖b k‖^2 := by + calc + _ ≤ (∑ k ∈ s, ‖b k‖)^2 := + pow_le_pow_left₀ (norm_nonneg _) (norm_sum_le _ _) 2 + _ ≤ _ := by + simpa only [one_mul,one_pow,Finset.sum_const,nsmul_eq_mul,mul_one] + using Finset.sum_mul_sq_le_sq_mul_sq s (fun _ => (1:ℝ)) (fun k => ‖b k‖) + have ha := pow_le_pow_left₀ (norm_nonneg _) (norm_add_le a (∑ k ∈ s, b k)) 2 + nlinarith [sq_nonneg (‖a‖ - ‖∑ k ∈ s, b k‖)] + +theorem outsideCanonicalRow_binned_energy + (S : Finset (Ideal ActualEisensteinCubic.O)) (D : ℕ) (hbad : fixedBadPrimes ⊆ S) + (hSp : ∀ P ∈ S, Prime P) (Ψ : ActualEisensteinCubic.O →* ℂ) (m f z : ActualEisensteinCubic.O) + (W : ℝ → ℂ) (hWc : HasCompactSupport W) (b X H₀ : ℝ) + (hb : 0 ≤ b) (hX : 0 < X) (hW : ∀ t, W t ≠ 0 → t ≤ b) (hD : b*X ≤ D) : + ‖outsideCanonicalRow S D hbad Ψ m f z W X‖^2 ≤ + 2*X*(‖shortCompletedSum (rowTwist Ψ (m*excludedGenerator S) f z) W X H₀‖^2 + + (cubeLogRange b X).card * ∑ j ∈ cubeLogRange b X, + ‖outsideCanonicalBin S D hbad (activeCubeLogBin S D b X j) Ψ m f z W X H₀‖^2) := by + have hs := norm_add_sum_sq_le (cubeLogRange b X) + (shortCompletedSum (rowTwist Ψ (m*excludedGenerator S) f z) W X H₀) + (fun j => outsideCanonicalBin S D hbad (activeCubeLogBin S D b X j) Ψ m f z W X H₀) + rw [← outsideCanonicalRow_reopened_binned S D hbad hSp Ψ m f z W hWc b X H₀ hb hX hW hD] at hs + have hn : ‖outsideCanonicalRow S D hbad Ψ m f z W X‖^2 = + X*‖(Real.sqrt X : ℂ)⁻¹ * outsideCanonicalRow S D hbad Ψ m f z W X‖^2 := by + rw [norm_mul,norm_inv,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg X), + mul_pow,inv_pow,Real.sq_sqrt hX.le] + field_simp + rw [hn] + convert mul_le_mul_of_nonneg_left hs hX.le using 1 ; ring + +end CanonicalRowCompletion + +open scoped BigOperators Classical +namespace CanonicalCoefficientClass + +section +open ActualEisensteinCubic +open SecondPassArithmetic (rayMonoid conjugateRayMonoid rayMonoid_apply conjugateRayMonoid_apply + FirstCoreIndex firstCoreTwist sideRayMonoid SecondRayIndex secondRayMinus secondRayPlus) +open RayFourExpansion (RayCharacter) + +def IsBaseRayTwist (base Ψ : ActualEisensteinCubic.O→*ℂ) : Prop := + Ψ=base ∨ ∃χ : RayCharacter, Ψ=rayMonoid χ*base + +def baseRayOrbit (base : ActualEisensteinCubic.O→*ℂ) : Finset (ActualEisensteinCubic.O→*ℂ) := + insert base (Finset.univ.image (fun χ : RayCharacter => rayMonoid χ*base)) + +lemma mem_baseRayOrbit (base Ψ : ActualEisensteinCubic.O→*ℂ) : Ψ∈baseRayOrbit base ↔ IsBaseRayTwist base Ψ := by + simp only [baseRayOrbit,Finset.mem_insert,Finset.mem_image,Finset.mem_univ,true_and,IsBaseRayTwist] + constructor + · rintro (h|⟨χ,h⟩) + · exact Or.inl h + · exact Or.inr ⟨χ,h.symm⟩ + · rintro (h|⟨χ,h⟩) + · exact Or.inl h + · exact Or.inr ⟨χ,h.symm⟩ + +lemma baseRayOrbit_card (base : ActualEisensteinCubic.O→*ℂ) : (baseRayOrbit base).card≤17 := by + have h1 := Finset.card_insert_le base (Finset.univ.image (fun χ : RayCharacter => rayMonoid χ*base)) + have h2 := Finset.card_image_le (s := (Finset.univ : Finset RayCharacter)) + (f := fun χ : RayCharacter => rayMonoid χ*base) + have h3 := RayFourExpansion.rayCharacter_card_le + simp only [Finset.card_univ] at h2 + unfold baseRayOrbit + omega + +lemma rayMonoid_mul (χ η : RayCharacter) : rayMonoid (χ*η)=rayMonoid χ*rayMonoid η := by + ext x + simp only [rayMonoid_apply,RayFourExpansion.rayCharacter,MulChar.mul_apply,MonoidHom.mul_apply] + +lemma conjugateRayMonoid_eq (χ : RayCharacter) : conjugateRayMonoid χ=rayMonoid (star χ) := by + ext x + simp only [conjugateRayMonoid_apply,rayMonoid_apply,RayFourExpansion.rayCharacter,MulChar.star_apply] + +lemma IsBaseRayTwist.mul_ray {base Ψ : ActualEisensteinCubic.O→*ℂ} (hΨ : IsBaseRayTwist base Ψ) (χ : RayCharacter) : + IsBaseRayTwist base (rayMonoid χ*Ψ) := by + rcases hΨ with h|⟨η,h⟩ + · exact Or.inr ⟨χ,by rw [h]⟩ + · exact Or.inr ⟨χ*η,by rw [h,rayMonoid_mul,mul_assoc]⟩ + +lemma firstCoreTwist_single_ray (side : Bool) (χ : RayCharacter) (Ψ : ActualEisensteinCubic.O→*ℂ) + (r : FirstCoreIndex) : + firstCoreTwist side χ Ψ r = + rayMonoid ((if side then star χ else χ)*FirstPassCubeLabels.coreRayCharacter side r.1 r.2.2)*Ψ := by + rw [rayMonoid_mul] + have hcore : FirstPassCubeLabels.coreRayTwist side r.1 r.2.2 = + rayMonoid (FirstPassCubeLabels.coreRayCharacter side r.1 r.2.2) := rfl + unfold firstCoreTwist sideRayMonoid + rw [hcore] + cases side <;> simp only [Bool.false_eq_true,ite_false,ite_true,conjugateRayMonoid_eq] <;> ac_rfl + +lemma IsBaseRayTwist.firstCore {base Ψ : ActualEisensteinCubic.O→*ℂ} (hΨ : IsBaseRayTwist base Ψ) + (side : Bool) (χ : RayCharacter) (r : FirstCoreIndex) : + IsBaseRayTwist base (firstCoreTwist side χ Ψ r) := by + rw [firstCoreTwist_single_ray] + exact hΨ.mul_ray _ + +lemma secondRayMinus_single_ray (Ψ : ActualEisensteinCubic.O→*ℂ) (r : SecondRayIndex) : + secondRayMinus Ψ r=rayMonoid (star r.2.2*star r.1.2)*Ψ := by + rw [rayMonoid_mul] + simp only [secondRayMinus,conjugateRayMonoid_eq,mul_assoc] + +lemma secondRayPlus_single_ray (Ψ : ActualEisensteinCubic.O→*ℂ) (r : SecondRayIndex) : + secondRayPlus Ψ r=rayMonoid (r.2.1*star r.1.1)*Ψ := by + rw [rayMonoid_mul] + simp only [secondRayPlus,conjugateRayMonoid_eq,mul_assoc] + +lemma IsBaseRayTwist.secondMinus {base Ψ : ActualEisensteinCubic.O→*ℂ} (hΨ : IsBaseRayTwist base Ψ) + (r : SecondRayIndex) : IsBaseRayTwist base (secondRayMinus Ψ r) := by + rw [secondRayMinus_single_ray] + exact hΨ.mul_ray _ + +lemma IsBaseRayTwist.secondPlus {base Ψ : ActualEisensteinCubic.O→*ℂ} (hΨ : IsBaseRayTwist base Ψ) + (r : SecondRayIndex) : IsBaseRayTwist base (secondRayPlus Ψ r) := by + rw [secondRayPlus_single_ray] + exact hΨ.mul_ray _ + +lemma IsBaseRayTwist.norm_le {base Ψ : ActualEisensteinCubic.O→*ℂ} (hΨ : IsBaseRayTwist base Ψ) + (hbase : ∀x,‖base x‖≤1) (x : ActualEisensteinCubic.O) : ‖Ψ x‖≤1 := by + rcases hΨ with rfl|⟨χ,rfl⟩ + · exact hbase x + · rw [MonoidHom.mul_apply,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) + (FiniteRayExpansion.norm_char_le_one χ _)).trans (hbase x) + +def FactorsModulo (Q : Ideal ActualEisensteinCubic.O) (Ψ : ActualEisensteinCubic.O→*ℂ) : Prop := + ∀x y : ActualEisensteinCubic.O,x-y∈Q → Ψ x=Ψ y + +lemma IsBaseRayTwist.factorsModulo {base Ψ : ActualEisensteinCubic.O→*ℂ} (hΨ : IsBaseRayTwist base Ψ) + (Q : Ideal ActualEisensteinCubic.O) (hbase : FactorsModulo Q base) : + FactorsModulo (Q*Ideal.span {(4:ActualEisensteinCubic.O)}) Ψ := by + intro x y hxy + have hb := hbase x y (Ideal.mul_le_left hxy) + rcases hΨ with rfl|⟨χ,rfl⟩ + · exact hb + · simp only [MonoidHom.mul_apply] + rw [hb] + congr 1 + exact RayFourExpansion.rayCharacter_eq_of_mod_four χ x y + (Ideal.mem_span_singleton.mp (Ideal.mul_le_right hxy)) + +def initialBase {q : ℕ} (χ : DirichletCharacter ℂ q) : ActualEisensteinCubic.O→*ℂ := + InitialMeanSquare.conjugateMonoid (InitialMeanSquare.normCharacter χ) + +lemma initialBase_norm {q : ℕ} (χ : DirichletCharacter ℂ q) (x : ActualEisensteinCubic.O) : + ‖initialBase χ x‖≤1 := by + change ‖star (InitialMeanSquare.normCharacter χ x)‖≤1 + rw [norm_star] + exact InitialMeanSquare.normCharacter_norm_le_one χ x + +lemma initial_minus_member {q : ℕ} (χ : DirichletCharacter ℂ q) (r : SecondRayIndex) : + IsBaseRayTwist (initialBase χ) (secondRayMinus (initialBase χ) r) := + IsBaseRayTwist.secondMinus (Or.inl rfl : IsBaseRayTwist (initialBase χ) (initialBase χ)) r + +lemma initial_plus_member {q : ℕ} (χ : DirichletCharacter ℂ q) (r : SecondRayIndex) : + IsBaseRayTwist (initialBase χ) (secondRayPlus (initialBase χ) r) := + IsBaseRayTwist.secondPlus (Or.inl rfl : IsBaseRayTwist (initialBase χ) (initialBase χ)) r + +end + +open ActualEisensteinCubic +open ActualEisensteinCoordinates (eval coords eval_coords) +open ShortDraftLatticeCount (qNat qO_nonneg coords_eval) + +lemma norm_eval_mod (m : ℕ) (a b : ℤ) : + (Ideal.absNorm (Ideal.span {eval a b}) : ZMod m)= + (a : ZMod m)^2-(a : ZMod m)*(b : ZMod m)+(b : ZMod m)^2 := by + have hi : (Ideal.absNorm (Ideal.span {eval a b}) : ℤ)=a^2-a*b+b^2 := by + rw [←qNat_eq_absNorm_span] + change ((ShortDraftLatticeCount.q (coords (eval a b))).toNat : ℤ)=_ + rw [Int.toNat_of_nonneg (qO_nonneg _),coords_eval] + rfl + have hz := congrArg (fun k : ℤ => (k : ZMod m)) hi + push_cast at hz + exact hz + +theorem normCharacter_factorsModulo {m : ℕ} (χ : DirichletCharacter ℂ m) : + FactorsModulo (Ideal.span {(m : ActualEisensteinCubic.O)}) (InitialMeanSquare.normCharacter χ) := by + intro x y hxy + obtain ⟨z,hz⟩ := Ideal.mem_span_singleton.mp hxy + let c := (coords y).1 + let d := (coords y).2 + let e := (coords z).1 + let f := (coords z).2 + have hy : y=eval c d := (eval_coords y).symm + have hx : x=eval (c+(m : ℤ)*e) (d+(m : ℤ)*f) := by + calc + x=y+(m : ActualEisensteinCubic.O)*z := by linear_combination hz + _=eval (c+(m : ℤ)*e) (d+(m : ℤ)*f) := by + rw [hy,←eval_coords z] + dsimp [eval,c,d,e,f] + push_cast + ring + change χ (Ideal.absNorm (Ideal.span {x}))=χ (Ideal.absNorm (Ideal.span {y})) + congr 1 + rw [hx,hy,norm_eval_mod,norm_eval_mod] + simp + +theorem initialBase_factorsModulo {m : ℕ} (χ : DirichletCharacter ℂ m) : + FactorsModulo (Ideal.span {(m : ActualEisensteinCubic.O)}) (initialBase χ) := by + intro x y hxy + change star (InitialMeanSquare.normCharacter χ x)=star (InitialMeanSquare.normCharacter χ y) + rw [normCharacter_factorsModulo χ x y hxy] + +def fixedBaseConductor (m : ℕ) : Ideal ActualEisensteinCubic.O := Ideal.span {(m : ActualEisensteinCubic.O)}*Ideal.span {(4 : ActualEisensteinCubic.O)} + +theorem initialOrbit_factorsModulo {m : ℕ} (χ : DirichletCharacter ℂ m) (Ψ : ActualEisensteinCubic.O→*ℂ) + (hΨ : IsBaseRayTwist (initialBase χ) Ψ) : FactorsModulo (fixedBaseConductor m) Ψ := + hΨ.factorsModulo _ (initialBase_factorsModulo χ) + +lemma fixedBaseConductor_principal (m : ℕ) : + fixedBaseConductor m=Ideal.span {((4*m : ℕ) : ActualEisensteinCubic.O)} := by + rw [fixedBaseConductor,Ideal.span_singleton_mul_span_singleton] + congr 1 + push_cast + ring_nf + +lemma fixedBaseConductor_ne_zero (m : ℕ) (hm : m≠0) : fixedBaseConductor m≠0 := by + rw [fixedBaseConductor_principal] + change Ideal.span {((4*m : ℕ) : ActualEisensteinCubic.O)}≠⊥ + rw [ne_eq,Ideal.span_singleton_eq_bot] + exact_mod_cast Nat.mul_ne_zero (by decide : (4:ℕ)≠0) hm + +lemma fixedBaseConductor_norm (m : ℕ) (hm : m≠0) : + Ideal.absNorm (fixedBaseConductor m)=16*m^2 := by + rw [fixedBaseConductor_principal] + have h := rational_modulus_card (4*m) (Nat.mul_ne_zero (by decide) hm) + rw [Ideal.absNorm_apply,Submodule.cardQuot_apply] + rw [h] + ring + +end CanonicalCoefficientClass + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CorrespondenceAdjoint.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CorrespondenceAdjoint.lean new file mode 100644 index 0000000000000000000000000000000000000000..ce1d72a598632ccbbdeb2a0ea9129d1c3a6dbccf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CorrespondenceAdjoint.lean @@ -0,0 +1,665 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.RamifiedSixBranches + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups InnerProductSpace + +local notation "O" => ActualEisensteinCubic.O + +lemma integralConjugatePullback_inverse_left {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (hH : H≤CubicKubota.levelThree) (hJ : J≤CubicKubota.levelThree) + (F : IntegralQuotientL2 H) : + integralConjugatePullback e g he hH hJ + (integralConjugatePullback e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) hJ hH F)=F := by + apply Lp.ext + have hi := integralConjugatePullback_ae e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) hJ hH F + have hc := (integralConjugateMap_measurePreserving e g he hH hJ).quasiMeasurePreserving.ae_eq_comp hi + filter_upwards [integralConjugatePullback_ae e g he hH hJ + (integralConjugatePullback e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) hJ hH F),hc] + with q hq hqi + dsimp only [Function.comp_def] at hqi + rw [hq,hqi,integralConjugateMap_inverse] + +lemma integralConjugatePullback_pairing {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (hH : H≤CubicKubota.levelThree) (hJ : J≤CubicKubota.levelThree) + (F : IntegralQuotientL2 H) (G : IntegralQuotientL2 J) : + ⟪F,integralConjugatePullback e g he hH hJ G⟫_ℂ= + ⟪integralConjugatePullback e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) hJ hH F,G⟫_ℂ := by + calc + _ = ⟪integralConjugatePullback e g he hH hJ + (integralConjugatePullback e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) hJ hH F), + integralConjugatePullback e g he hH hJ G⟫_ℂ := by + rw [integralConjugatePullback_inverse_left] + _ = _ := LinearIsometry.inner_map_map _ _ _ + +theorem kernelCorrespondenceL2_pairing {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (F G : KernelQuotientL2) : + ⟪F,kernelCorrespondenceL2 hHK hJK e g he G⟫_ℂ= + ⟪kernelCorrespondenceL2 hJK hHK e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) F,G⟫_ℂ := by + change ⟪F,integralCoverTrace hHK globalKubotaKernel_le_levelThree + (integralConjugatePullback e g he (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree) + (integralCoverPullback hJK globalKubotaKernel_le_levelThree G))⟫_ℂ=_ + rw [integralCoverTrace_pairing,integralConjugatePullback_pairing] + exact (ContinuousLinearMap.adjoint_inner_left + (integralCoverPullback hJK globalKubotaKernel_le_levelThree) G _).symm + +theorem kernelCorrespondenceL2_adjoint {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + ContinuousLinearMap.adjoint (kernelCorrespondenceL2 hHK hJK e g he)= + kernelCorrespondenceL2 hJK hHK e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) := by + apply ContinuousLinearMap.ext + intro F + apply ext_inner_right ℂ + intro G + rw [ContinuousLinearMap.adjoint_inner_left] + exact kernelCorrespondenceL2_pairing hHK hJK e g he F G + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section + +lemma continuous_period_integral {X:Type*} [TopologicalSpace X] + [FirstCountableTopology X] [LocallyCompactSpace X] + (f:X→ℂ→ℂ) (hf:Continuous f.uncurry) : + Continuous (fun x=>∫z in periodDomain,f x z) := by + rw [continuous_iff_continuousAt] + intro x0 + obtain ⟨U,hUc,hUn⟩:=exists_compact_mem_nhds x0 + let radius:ℝ:=∑i,‖periodBasis i‖ + obtain ⟨C,hC⟩:=(hUc.prod (isCompact_closedBall (0:ℂ) radius)).bddAbove_image hf.norm.continuousOn + apply continuousAt_of_dominated + · filter_upwards with x using (show Continuous (f x) from hf.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable + · filter_upwards [hUn] with x hx + filter_upwards [ae_restrict_mem periodDomain_measurable] with z hz + apply hC + exact ⟨(x,z),⟨hx,by simpa only [Metric.mem_closedBall,dist_zero_right,radius] using norm_mem_periodDomain z hz⟩,rfl⟩ + · let:=periodDomain_finiteMeasure + exact integrable_const C + · filter_upwards with z using (show Continuous (fun x=>f x z) from hf.comp (continuous_id.prodMk continuous_const)).continuousAt + +def continuousCuspSlice (f:HyperbolicSpace→ℂ) (freq:ℂ) (v:ℝ) :ℂ:= + (∫z in periodDomain,f (cuspCoordinateLift (v,z))*ShortDraftTrace.breveE (-freq*z))/(v:ℂ)^3 + +lemma continuousCuspSlice_integrable (f:HyperbolicSpace→ℂ) (hf:Continuous f) + (freq:ℂ) (a b:ℝ) (ha:0f w*arbitraryCuspWeightedPhase 1 freq w + have hg:Continuous g:=hf.mul (arbitraryCuspWeightedPhase_continuous 1 freq) + have hi:=cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg + rw [IntegrableOn,Measure.volume_eq_prod,←Measure.prod_restrict] at hi + apply hi.integral_prod_left.congr + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + have hp:0c/(v:ℂ)^3) + apply integral_congr_ae + exact Eventually.of_forall (fun z=>by + dsimp only [g] + rw [arbitraryCuspWeightedPhase,cuspCoordinateLift_positive v z hp, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + simp) + +lemma continuousCuspSlice_continuousOn (f:HyperbolicSpace→ℂ) (hf:Continuous f) + (freq:ℂ) (a b:ℝ) (ha:0⟨(q.2,max a q.1),ha.trans_le (le_max_left _ _)⟩ + have hc:Continuous coord:=by + apply Continuous.subtype_mk + exact continuous_snd.prodMk (continuous_const.max continuous_fst) + have hup:Continuous (fun q:(ℝ × ℂ)=>f (upperPoint q.2 (max a q.1) (ha.trans_le (le_max_left _ _)))):= + hf.comp (continuous_upperCoordinates.comp hc) + have he:Continuous (fun q:(ℝ × ℂ)=>ShortDraftTrace.breveE (-freq*q.2)):=by + change Continuous (fun q:(ℝ × ℂ)=>Complex.exp (2*Real.pi*Complex.I*((-freq*q.2)+starRingEnd ℂ (-freq*q.2)))) + fun_prop + have hi:=continuous_period_integral (fun v z=>f (upperPoint z (max a v) (ha.trans_le (le_max_left _ _)))* + ShortDraftTrace.breveE (-freq*z)) (hup.mul he) + have hnum:ContinuousOn (fun v:ℝ=>∫z in periodDomain,f (cuspCoordinateLift (v,z))* + ShortDraftTrace.breveE (-freq*z)) (Set.Icc a b):=by + apply hi.continuousOn.congr + intro v hv + have hp:0pow_ne_zero 3 (Complex.ofReal_ne_zero.mpr (ha.trans_le hv.1).ne')) + +lemma continuousCuspSlice_test (f:HyperbolicSpace→ℂ) (hf:Continuous f) (freq:ℂ) + (a b:ℝ) (ha:0f w*arbitraryCuspWeightedPhase ρ freq w):= + hf.mul (arbitraryCuspWeightedPhase_continuous ρ freq) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha _ hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha _ hg)] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hp:0by + dsimp only + rw [arbitraryCuspWeightedPhase,cuspCoordinateLift_positive v z hp, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + ring) + +theorem continuousCuspSlice_eq_of_tests (f:HyperbolicSpace→ℂ) (hf:Continuous f) + (freq:ℂ) (g:ℝ→ℂ) + (hg:∀a b:ℝ,0linarith) + +local notation "Eis" => ActualEisensteinCubic.O + +theorem ramifiedSource_fourier_all_heights (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) + (v:ℝ) (hv:0R*(v:ℂ)^(-(4/3:ℂ)-1)* + sourceFourierKernel (4/3) (ninthCuspFrequency h*v) + have hg:∀a b:ℝ,0by dsimp only [g,R];ring) + have he:=continuousCuspSlice_eq_of_tests + (ramifiedSourceFunction (ramifiedCuspRoot side:Eis)) (ramifiedSourceFunction_continuous _) + (ninthCuspFrequency h) g hg ht v hv + have hvn:(v:ℂ)≠0:=Complex.ofReal_ne_zero.mpr hv.ne' + have hp:(v:ℂ)^(-(4/3:ℂ)-1)=(v:ℂ)^(2/3:ℂ)/(v:ℂ)^3:=by + rw [show -(4/3:ℂ)-1=(2/3:ℂ)-3 by ring,Complex.cpow_sub _ _ hvn] + congr 1 + exact Complex.cpow_natCast _ 3 + dsimp only [continuousCuspSlice,g,R] at he + simp only [cuspCoordinateLift_positive v _ hv,hp] at he + apply (div_left_inj' (pow_ne_zero 3 hvn)).mp + convert he using 1 ;ring + +end + +section +local notation "Eis" => ActualEisensteinCubic.O + +lemma continuous_period_fourier_bound (f:ℂ→ℂ) (hf:Continuous f) : + ∃C:ℝ,0≤C∧∀freq:ℂ,‖∫z in periodDomain,f z*ShortDraftTrace.breveE (-freq*z)‖≤C := by + let radius:ℝ:=∑i,‖periodBasis i‖ + obtain ⟨B,hB⟩:=(isCompact_closedBall (0:ℂ) radius).bddAbove_image hf.norm.continuousOn + refine ⟨max 0 B*(volume.restrict periodDomain).real Set.univ,mul_nonneg (le_max_left _ _) (measureReal_nonneg),?_⟩ + intro freq + let:=periodDomain_finiteMeasure + apply norm_integral_le_of_norm_le_const + filter_upwards [ae_restrict_mem periodDomain_measurable] with z hz + rw [norm_mul,breveE_norm,mul_one] + apply le_trans _ (le_max_right _ _) + apply hB + exact ⟨z,by simpa only [Metric.mem_closedBall,dist_zero_right,radius] using norm_mem_periodDomain z hz,rfl⟩ + +theorem continuous_fourier_bessel_subexponential (f:ℝ→ℂ→ℂ) (c:Eis→ℂ) + (hf:∀v:ℝ,0c.fullFunction 0 (upperPoint z v hv)):=by + apply periodDomain_L2_ext _ _ (periodDomain_memLp_of_continuous f hf) + (periodDomain_memLp_of_continuous _ hc) + intro h + rw [hfour,c.fullFunction_fourier] + by_cases hh:h=0 + · simp [hh,SubexponentialBesselCoefficients.amplitude] + · simp [hh] + have hall:=ae_eq_of_periodDomain_eq f _ hp (fun n z=>c.fullFunction_period 0 v hv z n) he + exact congrFun (Measure.eq_of_ae_eq hall hf hc) + +end + +section +open ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma ninthCuspFrequency_three (h:Eis) : + 3*ninthCuspFrequency h=cuspFrequency h := by + unfold ninthCuspFrequency cuspFrequency + ring + +lemma sourceFourierKernel_cubic_amplitude (h:Eis) (hh:h≠0) (v:ℝ) (hv:0 ActualEisensteinCubic.O + +def ramifiedScaledRow (side:Bool) (v:ℝ) (z:ℂ) :ℂ:= + ramifiedSourceFunction (ramifiedCuspRoot side:Eis) (cuspCoordinateLift (3*v,3*z)) + +def ramifiedBesselValue (side:Bool) (h:Eis) :ℂ:= + if hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side) then + (3:ℂ)^(2/3:ℂ)*cubicBesselNormalizer h*ramifiedArithmeticResidue side h hf/ + ((9*Real.sqrt 3/2:ℝ):ℂ) + else 0 + +lemma ramifiedScaledRow_continuous (side:Bool) (v:ℝ) (hv:0ramifiedSourceFunction (ramifiedCuspRoot side:Eis) + (upperPoint (3*z) (3*v) hp)):=by + funext z + exact congrArg (ramifiedSourceFunction (ramifiedCuspRoot side:Eis)) (cuspCoordinateLift_positive (3*v) (3*z) hp) + rw [he] + exact (ramifiedSource_height_continuous side (3*v) hp).comp (continuous_const.mul continuous_id) + +lemma ramifiedScaledRow_periodic (side:Bool) (v:ℝ) (hv:0 ActualEisensteinCubic.O + +def ramifiedCuspBesselTerm (side:Bool) (h:Eis) (v:ℝ) (z:ℂ) :ℂ:= + (if h=0 then 0 else ramifiedBesselValue side h*((v/3:ℝ):ℂ)* + schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*(v/3)))* + ShortDraftTrace.breveE (ninthCuspFrequency h*z) + +lemma ramifiedCuspBesselTerm_eq (side:Bool) (h:Eis) (v:ℝ) (hv:0ramifiedCuspBesselTerm_eq side h v hv z) + +theorem ramifiedSource_bessel_normal (side:Bool) (a b:ℝ) (ha:0C*Real.exp (-(Real.pi*(a/3))*‖cuspFrequency h‖), + (summable_exp_neg_cuspFrequency_norm (Real.pi*(a/3)) (by positivity)).mul_left C,?_⟩ + intro h v hv z + have hp:0∑i∈s,G i x) p=∑i∈s,coverDirichletPair F (G i) p := by + simp only [coverDirichletPair,coverGradientAt_sum s G p hG,inner_sum] + +lemma coverDirichletPair_norm_le (F G : EuclideanSpatial→ℂ) (p : EuclideanSpatial) + (hF : DifferentiableAt ℝ F p) (hG : DifferentiableAt ℝ G p) : + ‖coverDirichletPair F G p‖≤(coverEnergyDensity F p+coverEnergyDensity G p)/2 := by + have hh := norm_inner_le_norm (𝕜:=ℂ) (coverGradientAt F p) (coverGradientAt G p) + have hs := sq_nonneg (‖coverGradientAt F p‖-‖coverGradientAt G p‖) + rw [←coverGradientAt_norm_sq F p hF,←coverGradientAt_norm_sq G p hG] + exact le_trans hh (by nlinarith) + +lemma kernelDirichletPairDensity_eq_cover (f h : kernelSmoothTests) (w : HyperbolicSpace) : + kernelDirichletPairDensity f h (integralOrbitProjection globalKubotaKernel w)= + coverDirichletPair (kernelTestField f) (kernelTestField h) (hyperbolicEuclideanCoordinates w) := by + rw [kernelDirichletPairDensity_coordinate] + rfl + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CorrespondenceEnergy.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CorrespondenceEnergy.lean new file mode 100644 index 0000000000000000000000000000000000000000..b87b298154f10c96cccd2ff81ab0d2a3aab33766 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CorrespondenceEnergy.lean @@ -0,0 +1,618 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CorrespondenceAdjoint + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise Manifold ContDiff ENNReal InnerProductSpace +open Finset AddChar MulChar EisensteinEmbedding + +section +local notation "O" => ActualEisensteinCubic.O + +lemma kernelTestField_comp_contDiffAt (f : kernelSmoothTests) (g : SL(2,ℂ)) + (p : EuclideanSpatial) (hp : 0

coverGradientAt F (hyperbolicEuclideanCoordinates w)) := by + apply (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin 3=>ℂ)).symm.continuous.comp + apply continuous_pi + intro j + apply (Complex.continuous_ofReal.comp hyperbolicHeight_continuous).mul + rw [continuous_iff_continuousAt] + intro w + exact (((hF _ (hyperbolicHeight_pos w)).continuousAt_fderiv (by simp)).clm_apply + continuousAt_const).comp hyperbolicEuclideanCoordinates_continuous.continuousAt + +def kernelCorrespondencePairLift (g : SL(2,ℂ)) (f h : kernelSmoothTests) + (w : HyperbolicSpace) : ℂ := + coverDirichletPair (kernelTestField f) (kernelTestField h ∘ euclideanAction g) + (hyperbolicEuclideanCoordinates w) + +lemma kernelCorrespondencePairLift_continuous (g : SL(2,ℂ)) (f h : kernelSmoothTests) : + Continuous (kernelCorrespondencePairLift g f h) := + (coverGradientAt_lift_continuous _ (kernelTestField_contDiffAt f)).inner + (coverGradientAt_lift_continuous _ (kernelTestField_comp_contDiffAt h g)) + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +include hHK hJK he in +omit [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondencePairLift_invariant (f h : kernelSmoothTests) + (k : H) (w : HyperbolicSpace) : + kernelCorrespondencePairLift g f h (k•w)=kernelCorrespondencePairLift g f h w := by + let A := integralComplexMatrix (k:SL(2,ActualEisensteinCubic.O)) + let B := integralComplexMatrix (e k:SL(2,ActualEisensteinCubic.O)) + have hfi : kernelTestField f ∘ euclideanAction A=kernelTestField f := + funext (kernelTestField_invariant f ⟨(k:SL(2,ActualEisensteinCubic.O)),hHK k.property⟩) + have hhi : (kernelTestField h ∘ euclideanAction g) ∘ euclideanAction A= + kernelTestField h ∘ euclideanAction g := by + rw [Function.comp_assoc,←euclideanAction_mul,he k,euclideanAction_mul,←Function.comp_assoc] + have hh : kernelTestField h ∘ euclideanAction B=kernelTestField h := + funext (kernelTestField_invariant h ⟨(e k:SL(2,ActualEisensteinCubic.O)),hJK (e k).property⟩) + rw [hh] + have hp := hyperbolicHeight_pos w + have hh := coverDirichletPair_comp A (kernelTestField f) (kernelTestField h ∘ euclideanAction g) + (hyperbolicEuclideanCoordinates w) hp + ((kernelTestField_contDiffAt f _ (euclideanAction_positive A _)).differentiableAt (by simp)) + ((kernelTestField_comp_contDiffAt h g _ (euclideanAction_positive A _)).differentiableAt (by simp)) + rw [hfi,hhi] at hh + change _=coverDirichletPair (kernelTestField f) (kernelTestField h ∘ euclideanAction g) + (hyperbolicEuclideanCoordinates w) + rw [integralSubgroup_smul] + simpa only [kernelCorrespondencePairLift,A,euclideanAction,euclideanToHyperbolic_coordinates] using hh.symm + +def kernelCorrespondencePair (f h : kernelSmoothTests) : IntegralOrbitQuotient H→ℂ := + Quotient.lift (kernelCorrespondencePairLift g f h) (by + rintro w v ⟨k,rfl⟩ + exact (kernelCorrespondencePairLift_invariant hHK hJK e g he f h k w).symm) + +omit [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondencePair_projection (f h : kernelSmoothTests) (w : HyperbolicSpace) : + kernelCorrespondencePair hHK hJK e g he f h (integralOrbitProjection H w)= + kernelCorrespondencePairLift g f h w := rfl + +omit [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondencePair_measurable (f h : kernelSmoothTests) : + Measurable (kernelCorrespondencePair hHK hJK e g he f h) := + measurable_from_quotient.mpr (kernelCorrespondencePairLift_continuous g f h).measurable + +omit [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondencePair_norm_le (f h : kernelSmoothTests) (q : IntegralOrbitQuotient H) : + ‖kernelCorrespondencePair hHK hJK e g he f h q‖≤ + (kernelQuotientEnergyDensity f (integralCoverMap hHK q)+ + kernelQuotientEnergyDensity h (integralCoverMap hJK (integralConjugateMap e g he q)))/2 := by + induction q using Quotient.inductionOn with + | _ w => + have hf := (kernelTestField_contDiffAt f (hyperbolicEuclideanCoordinates w) (hyperbolicHeight_pos w)).differentiableAt (by simp) + have hh := (kernelTestField_comp_contDiffAt h g (hyperbolicEuclideanCoordinates w) (hyperbolicHeight_pos w)).differentiableAt (by simp) + have hb := coverDirichletPair_norm_le (kernelTestField f) (kernelTestField h ∘ euclideanAction g) + (hyperbolicEuclideanCoordinates w) hf hh + rw [coverEnergyDensity_comp g _ _ (hyperbolicHeight_pos w) + ((kernelTestField_contDiffAt h _ (euclideanAction_positive g _)).differentiableAt (by simp))] at hb + change ‖kernelCorrespondencePairLift g f h w‖≤ + (kernelTestEnergyDensity f w+kernelTestEnergyDensity h (g•w))/2 + simpa only [kernelCorrespondencePairLift,kernelTestEnergyDensity_eq_cover,euclideanAction, + euclideanToHyperbolic_coordinates] using hb + +lemma kernelCorrespondencePair_integrable (f h : kernelSmoothTests) : + Integrable (kernelCorrespondencePair hHK hJK e g he f h) (integralQuotientVolume H) := by + have hf := (integralCoverMap_measurePreserving hHK globalKubotaKernel_le_levelThree).integrable_comp_of_integrable + ((kernelQuotientEnergyDensity_integrable f).smul_measure + (c:=(H.relIndex globalKubotaKernel:ℝ≥0∞)) (by simp)) + have hh := (integralCoverMap_measurePreserving hJK globalKubotaKernel_le_levelThree).integrable_comp_of_integrable + ((kernelQuotientEnergyDensity_integrable h).smul_measure + (c:=(J.relIndex globalKubotaKernel:ℝ≥0∞)) (by simp)) + have hhh := (integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) (hJK.trans globalKubotaKernel_le_levelThree)).integrable_comp_of_integrable hh + apply ((hf.add hhh).div_const 2).mono' (kernelCorrespondencePair_measurable hHK hJK e g he f h).aestronglyMeasurable + exact Filter.Eventually.of_forall (kernelCorrespondencePair_norm_le hHK hJK e g he f h) + +end + +local notation "O" => ActualEisensteinCubic.O + +lemma kernelCorrespondencePairLift_kernel (g : SL(2,ℂ)) (f h : kernelSmoothTests) + (r : globalKubotaKernel) (w : HyperbolicSpace) : + kernelCorrespondencePairLift g f h (r•w)= + coverDirichletPair (kernelTestField f) + (kernelTestField h ∘ euclideanAction (g*integralComplexMatrix (r:SL(2,ActualEisensteinCubic.O)))) + (hyperbolicEuclideanCoordinates w) := by + have hf := (kernelTestField_contDiffAt f _ (euclideanAction_positive (integralComplexMatrix r) (hyperbolicEuclideanCoordinates w))).differentiableAt (by simp) + have hh := (kernelTestField_comp_contDiffAt h g _ (euclideanAction_positive (integralComplexMatrix r) (hyperbolicEuclideanCoordinates w))).differentiableAt (by simp) + have hp := coverDirichletPair_comp (integralComplexMatrix r) (kernelTestField f) + (kernelTestField h ∘ euclideanAction g) (hyperbolicEuclideanCoordinates w) + (hyperbolicHeight_pos w) hf hh + have hfi : kernelTestField f ∘ euclideanAction (integralComplexMatrix r)=kernelTestField f := + funext (kernelTestField_invariant f r) + rw [hfi,Function.comp_assoc,←euclideanAction_mul] at hp + simpa only [kernelCorrespondencePairLift,integralSubgroup_smul,euclideanAction, + euclideanToHyperbolic_coordinates] using hp.symm + +lemma kernelTestField_comp_inverse (f : kernelSmoothTests) (g : SL(2,ℂ)) : + (kernelTestField f ∘ euclideanAction g⁻¹) ∘ euclideanAction g=kernelTestField f := by + funext p + simp only [Function.comp_def,kernelTestField,euclideanAction,euclideanToHyperbolic_coordinates, + inv_smul_smul] + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +lemma kernelCorrespondencePair_trace (f h : kernelSmoothTests) (q : KernelQuotient) : + kernelDirichletPairDensity f (kernelCorrespondenceTest hHK hJK e g he h) q= + integralCoverTraceFunction H globalKubotaKernel + (kernelCorrespondencePair hHK hJK e g he f h) q := by + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + induction q using Quotient.inductionOn with + | _ w => + change kernelDirichletPairDensity f (kernelCorrespondenceTest hHK hJK e g he h) + (integralOrbitProjection globalKubotaKernel w)=_ + rw [kernelDirichletPairDensity_eq_cover] + have hfield := funext (kernelCorrespondenceTest_field hHK hJK e g he h) + rw [hfield] + have hd (r : IntegralCoverCosets H globalKubotaKernel) : + DifferentiableAt ℝ (kernelTestField h ∘ euclideanAction (kernelCorrespondenceMatrix g r)) + (hyperbolicEuclideanCoordinates w) := + (kernelTestField_comp_contDiffAt h _ _ (hyperbolicHeight_pos w)).differentiableAt (by simp) + have hsum := coverDirichletPair_sum_right Finset.univ (kernelTestField f) + (fun r=>kernelTestField h ∘ euclideanAction (kernelCorrespondenceMatrix g r)) + (hyperbolicEuclideanCoordinates w) (fun r _=>hd r) + simp only [Function.comp_apply] at hsum + rw [hsum] + change (∑r : IntegralCoverCosets H globalKubotaKernel,_)= + ∑r : IntegralCoverCosets H globalKubotaKernel, + kernelCorrespondencePair hHK hJK e g he f h (integralCoverFiberPoint H globalKubotaKernel r w) + apply Finset.sum_congr rfl + intro r _ + rw [integralCoverFiberPoint_rep,kernelCorrespondencePair_projection, + kernelCorrespondencePairLift_kernel] + rfl + +lemma kernelCorrespondenceForm_integral (f h : kernelSmoothTests) : + kernelDirichletForm f (kernelCorrespondenceTest hHK hJK e g he h)= + ∫q,kernelCorrespondencePair hHK hJK e g he f h q∂integralQuotientVolume H := by + unfold kernelDirichletForm + simp_rw [kernelCorrespondencePair_trace] + exact integralCoverTraceFunction_integral hHK globalKubotaKernel_le_levelThree _ + (kernelCorrespondencePair_measurable hHK hJK e g he f h) + (kernelCorrespondencePair_integrable hHK hJK e g he f h) + +omit [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondencePair_conjugate (f h : kernelSmoothTests) (q : IntegralOrbitQuotient H) : + kernelCorrespondencePair hHK hJK e g he f h q= + star (kernelCorrespondencePair hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) h f (integralConjugateMap e g he q)) := by + induction q using Quotient.inductionOn with + | _ w => + change kernelCorrespondencePairLift g f h w= + star (kernelCorrespondencePairLift g⁻¹ h f (g•w)) + have hf := (kernelTestField_contDiffAt h _ (euclideanAction_positive g (hyperbolicEuclideanCoordinates w))).differentiableAt (by simp) + have hh := (kernelTestField_comp_contDiffAt f g⁻¹ _ (euclideanAction_positive g (hyperbolicEuclideanCoordinates w))).differentiableAt (by simp) + have hc := coverDirichletPair_comp g (kernelTestField h) (kernelTestField f ∘ euclideanAction g⁻¹) + (hyperbolicEuclideanCoordinates w) (hyperbolicHeight_pos w) hf hh + rw [kernelTestField_comp_inverse] at hc + have hs := congrArg star hc + have hswap : star (inner ℂ + (coverGradientAt (kernelTestField h ∘ euclideanAction g) (hyperbolicEuclideanCoordinates w)) + (coverGradientAt (kernelTestField f) (hyperbolicEuclideanCoordinates w)))= + inner ℂ (coverGradientAt (kernelTestField f) (hyperbolicEuclideanCoordinates w)) + (coverGradientAt (kernelTestField h ∘ euclideanAction g) (hyperbolicEuclideanCoordinates w)) := + inner_conj_symm _ _ + rw [coverDirichletPair,hswap] at hs + simpa only [kernelCorrespondencePairLift,coverDirichletPair,euclideanAction, + euclideanToHyperbolic_coordinates] using hs + +theorem kernelCorrespondenceForm_adjoint (f h : kernelSmoothTests) : + kernelDirichletForm f (kernelCorrespondenceTest hHK hJK e g he h)= + kernelDirichletForm (kernelCorrespondenceTest hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) f) h := by + let opposite := kernelCorrespondencePair hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) h f + have hom := kernelCorrespondencePair_measurable hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) h f + have hm := integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) (hJK.trans globalKubotaKernel_le_levelThree) + rw [kernelCorrespondenceForm_integral] + calc + _ = ∫q,star (opposite (integralConjugateMap e g he q))∂integralQuotientVolume H := by + apply integral_congr_ae + exact Filter.Eventually.of_forall (kernelCorrespondencePair_conjugate hHK hJK e g he f h) + _ = ∫q,star (opposite q)∂integralQuotientVolume J := by + have hh := integral_map («μ»:=integralQuotientVolume H) hm.measurable.aemeasurable + (continuous_star.measurable.comp hom).aestronglyMeasurable + rw [hm.map_eq] at hh + exact hh.symm + _ = star (∫q,opposite q∂integralQuotientVolume J) := by + simp only [Complex.star_def] + exact integral_conj + _ = _ := by + rw [←kernelCorrespondenceForm_integral hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he),kernelDirichletForm_conj] + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups InnerProductSpace +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +lemma kernelCorrespondenceEnergy_pairing_core (f h : kernelSmoothTests) : + inner ℂ (kernelEnergyGraphCore f) + (kernelCorrespondenceEnergy hHK hJK e g he (kernelEnergyGraphCore h))= + inner ℂ (kernelCorrespondenceEnergy hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) (kernelEnergyGraphCore f)) (kernelEnergyGraphCore h) := by + rw [kernelCorrespondenceEnergy_core,kernelCorrespondenceEnergy_core, + kernelEnergyGraph_inner,kernelEnergyGraph_inner] + simp only [kernelEnergyMass_core,kernelEnergyGradient_core,kernelGradientToL2_inner] + rw [kernelCorrespondenceTest_mass,kernelCorrespondenceTest_mass, + kernelCorrespondenceL2_pairing,kernelCorrespondenceForm_adjoint] + +theorem kernelCorrespondenceEnergy_pairing (u v : KernelEnergyGraph) : + inner ℂ u (kernelCorrespondenceEnergy hHK hJK e g he v)= + inner ℂ (kernelCorrespondenceEnergy hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) u) v := by + apply congrFun (kernelEnergyGraphCore_dense.equalizer + (continuous_id.inner continuous_const) + ((kernelCorrespondenceEnergy hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he)).continuous.inner continuous_const) ?_) u + funext f + apply congrFun (kernelEnergyGraphCore_dense.equalizer + (continuous_const.inner (kernelCorrespondenceEnergy hHK hJK e g he).continuous) + (continuous_const.inner continuous_id) ?_) v + funext h + exact kernelCorrespondenceEnergy_pairing_core hHK hJK e g he f h + +lemma kernelCorrespondenceEnergy_pairing_left (u v : KernelEnergyGraph) : + inner ℂ (kernelCorrespondenceEnergy hHK hJK e g he u) v= + inner ℂ u (kernelCorrespondenceEnergy hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) v) := by + have hh := congrArg star (kernelCorrespondenceEnergy_pairing hHK hJK e g he v u) + simpa only [←starRingEnd_apply,inner_conj_symm] using hh + +lemma kernelCorrespondenceL2_pairing_left (F G : KernelQuotientL2) : + inner ℂ (kernelCorrespondenceL2 hHK hJK e g he F) G= + inner ℂ F (kernelCorrespondenceL2 hJK hHK e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) G) := by + have hh := congrArg star (kernelCorrespondenceL2_pairing hHK hJK e g he G F) + simpa only [←starRingEnd_apply,inner_conj_symm] using hh + +theorem kernelCorrespondence_variationalSolution (F : KernelQuotientL2) : + kernelCorrespondenceEnergy hHK hJK e g he (kernelVariationalSolution F)= + kernelVariationalSolution (kernelCorrespondenceL2 hHK hJK e g he F) := by + apply kernelVariationalSolution_unique + intro v + rw [←kernelEnergyGraph_inner,kernelCorrespondenceEnergy_pairing_left, + kernelEnergyGraph_inner,kernelVariationalSolution_equation, + kernelCorrespondenceEnergy_mass] + exact (kernelCorrespondenceL2_pairing_left hHK hJK e g he F (kernelEnergyMass v)).symm + +theorem kernelCorrespondence_variationalResolvent (F : KernelQuotientL2) : + kernelVariationalResolvent (kernelCorrespondenceL2 hHK hJK e g he F)= + kernelCorrespondenceL2 hHK hJK e g he (kernelVariationalResolvent F) := by + change kernelEnergyMass (kernelVariationalSolution (kernelCorrespondenceL2 hHK hJK e g he F))=_ + rw [←kernelCorrespondence_variationalSolution,kernelCorrespondenceEnergy_mass] + rfl + +theorem kernelCorrespondence_operatorGraph (F G : KernelQuotientL2) + (hFG : (F,G)∈kernelEnergyLaplacian.graph) : + (kernelCorrespondenceL2 hHK hJK e g he F, + kernelCorrespondenceL2 hHK hJK e g he G)∈kernelEnergyLaplacian.graph := by + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] at hFG ⊢ + rw [←map_add,kernelCorrespondence_variationalResolvent,hFG] + +theorem kernelCorrespondence_eigenvector (F : KernelQuotientL2) (eigenvalue : ℂ) + (hF : (F,eigenvalue • F)∈kernelEnergyLaplacian.graph) : + (kernelCorrespondenceL2 hHK hJK e g he F, + eigenvalue • kernelCorrespondenceL2 hHK hJK e g he F)∈kernelEnergyLaplacian.graph := by + simpa only [map_smul] using kernelCorrespondence_operatorGraph hHK hJK e g he F (eigenvalue • F) hF + +end + +section + +open MeasureTheory +open scoped Classical MatrixGroups BigOperators + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma cuspFrequency_mul_right (h c:Eis) : cuspFrequency (h*c)=cuspFrequency h*eisEmbedding c := by + unfold cuspFrequency + rw [map_mul] + ring + +lemma cusp_character_continuous (h:Eis) : + Continuous (fun z:ℂ=>ShortDraftTrace.breveE (-cuspFrequency h*z)) := by + change Continuous (fun z:ℂ=>Complex.exp (2*Real.pi*Complex.I* + ((-cuspFrequency h*z)+starRingEnd ℂ (-cuspFrequency h*z)))) + fun_prop + +lemma cusp_character_fractional_period (c:Eis) (hc:c≠0) (h q:Eis) (z:ℂ) : + ShortDraftTrace.breveE (-cuspFrequency (h*c)*(z+3*eisEmbedding q/eisEmbedding c))= + ShortDraftTrace.breveE (-cuspFrequency (h*c)*z) := by + rw [mul_add,AddChar.map_add_eq_mul] + have he:-cuspFrequency (h*c)*(3*eisEmbedding q/eisEmbedding c)= + -cuspFrequency h*(3*eisEmbedding q):=by + rw [cuspFrequency_mul_right] + field_simp [eisEmbedding_ne_zero hc] + rw [he] + have hz:ShortDraftTrace.breveE (-cuspFrequency h*(3*eisEmbedding q))=1:=by + simpa only [zero_add,mul_zero,AddChar.map_zero_eq_one] using cuspFrequency_negative_period h q 0 + rw [hz,mul_one] + +lemma period_fourier_fractional_translation (f:ℂ→ℂ) + (hf:∀n:Eis,∀z:ℂ,f (z+3*eisEmbedding n)=f z) + (c:Eis) (hc:c≠0) (h q:Eis) : + (∫z in periodDomain,f (z+3*eisEmbedding q/eisEmbedding c)* + ShortDraftTrace.breveE (-cuspFrequency (h*c)*z))= + ∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency (h*c)*z) := by + let g:ℂ→ℂ:=fun z=>f z*ShortDraftTrace.breveE (-cuspFrequency (h*c)*z) + have hg (n:Eis) (z:ℂ):g (z+3*eisEmbedding n)=g z:=by + dsimp [g] + rw [hf,cuspFrequency_negative_period] + have hi:=period_integral_translation g hg (3*eisEmbedding q/eisEmbedding c) + have hp (z:ℂ):g (3*eisEmbedding q/eisEmbedding c+z)= + f (z+3*eisEmbedding q/eisEmbedding c)*ShortDraftTrace.breveE (-cuspFrequency (h*c)*z):=by + dsimp [g] + rw [add_comm (3*eisEmbedding q/eisEmbedding c) z,cusp_character_fractional_period c hc] + simpa only [hp,g] using hi + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma cube_upperPoint_continuous (v:ℝ) (hv:0upperPoint z v hv) := by + let c:ℂ→UpperCoordinates:=fun z=>⟨(z,v),hv⟩ + have hc:Continuous c:=by + apply Continuous.subtype_mk + exact continuous_id.prodMk continuous_const + simpa only [Function.comp_def,c] using continuous_upperCoordinates.comp hc + +theorem cubeAverage_fourier (p:Eis) (hp:p≠0) (F:HyperbolicSpace→ℂ) (hF:Continuous F) + (hperiod:∀n:Eis,∀w:HyperbolicSpace,F (complexTranslation (3*eisEmbedding n) • w)=F w) + (h:Eis) (v:ℝ) (hv:0F (upperPoint z V hV) + let H:ℂ→ℂ:=fun z=>cubeAverage p hp F (upperPoint z v hv)*ShortDraftTrace.breveE (-cuspFrequency h*z) + have hf:Continuous f:=hF.comp (cube_upperPoint_continuous V hV) + have hfperiod (n:Eis) (z:ℂ):f (z+3*eisEmbedding n)=f z:=by + dsimp [f] + rw [←complexTranslation_action] + exact hperiod n _ + have hH:Continuous H:= + ((cubeAverage_continuous p hp F hF).comp (cube_upperPoint_continuous v hv)).mul (cusp_character_continuous h) + have hHperiod (n:Eis) (z:ℂ):H (z+3*eisEmbedding n)=H z:=by + dsimp [H] + rw [←complexTranslation_action,cubeAverage_period_three p hp F hperiod,cuspFrequency_negative_period] + let term (r:Eis⧸Ideal.span {p^3}) (z:ℂ):= + f (z+3*eisEmbedding (GaussianShiftedPartition.representative (p^3) r)/eisEmbedding (p^3))* + ShortDraftTrace.breveE (-cuspFrequency (h*p^3)*z) + have hpoint (z:ℂ):H (eisEmbedding (p^3)*z)= + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3*(∑' r:Eis⧸Ideal.span {p^3},term r z):=by + have hphase:ShortDraftTrace.breveE (-cuspFrequency h*(eisEmbedding (p^3)*z))= + ShortDraftTrace.breveE (-cuspFrequency (h*p^3)*z):=by + rw [cuspFrequency_mul_right] + congr 1 + ring + dsimp only [H,cubeAverage] + rw [hphase] + rw [mul_assoc,←tsum_mul_right] + congr 1 + apply tsum_congr + intro r + dsimp only [term,f] + rw [cubeAverageMatrix_action] + congr 2 + apply upperPoint_congr + · rw [map_pow] + field_simp [eisEmbedding_ne_zero hp] + · rfl + let:Finite (Eis⧸Ideal.span {p^3}):=finite_quotient_span (pow_ne_zero 3 hp) + let:Fintype (Eis⧸Ideal.span {p^3}):=Fintype.ofFinite _ + have hi (r:Eis⧸Ideal.span {p^3}):IntegrableOn (term r) periodDomain:=by + apply periodDomain_integrable_of_continuous + exact (hf.comp (continuous_id.add continuous_const)).mul (cusp_character_continuous (h*p^3)) + have hint:(∫z in periodDomain,∑' r:Eis⧸Ideal.span {p^3},term r z)= + ∑' r:Eis⧸Ideal.span {p^3},∫z in periodDomain,term r z:=by + simp only [tsum_fintype] + exact integral_finsetSum _ (fun r _=>hi r) + have hterm (r:Eis⧸Ideal.span {p^3}): + (∫z in periodDomain,term r z)=∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency (h*p^3)*z):= + period_fourier_fractional_translation f hfperiod (p^3) (pow_ne_zero 3 hp) h _ + have hcard:(Nat.card (Eis⧸Ideal.span {p^3}):ℂ)=(Ideal.absNorm (Ideal.span {p}):ℂ)^3:=by + change (Ideal.absNorm (Ideal.span {p^3}):ℂ)=_ + rw [←Ideal.span_singleton_pow,map_pow,Nat.cast_pow] + have hqN:Ideal.absNorm (Ideal.span {p})≠0:= + (Ideal.absNorm_ne_zero_iff _).mpr (finite_quotient_span hp) + have hq:(Ideal.absNorm (Ideal.span {p}):ℂ)≠0:=by exact_mod_cast hqN + change (∫z in periodDomain,H z)=∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency (h*p^3)*z) + calc + _=∫z in periodDomain,H (eisEmbedding (p^3)*z):= + (period_integral_eisenstein_mul H hH.measurable hHperiod (p^3) (pow_ne_zero 3 hp)).symm + _=(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3* + (∑' r:Eis⧸Ideal.span {p^3},∫z in periodDomain,term r z):=by + simp_rw [hpoint] + rw [integral_const_mul,hint] + _=(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3* + (∑' (_:Eis⧸Ideal.span {p^3}),∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency (h*p^3)*z)):=by + congr 1 + exact tsum_congr hterm + _=_:=by rw [tsum_const,nsmul_eq_mul,hcard];field_simp + +end + +open MeasureTheory +open scoped Classical MatrixGroups BigOperators +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +theorem cubeSource_fourier (p:Eis) (hp:p≠0) (h:Eis) (v:ℝ) (hv:0 ActualEisensteinCubic.O + +lemma integralCoverMap_quasiMeasurePreserving {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + Measure.QuasiMeasurePreserving (integralCoverMap hHK) + (integralQuotientVolume H) (integralQuotientVolume K) := by + refine ⟨integralCoverMap_measurable hHK,?_⟩ + rw [integralCoverMap_measure hHK hK] + exact Measure.smul_absolutelyContinuous + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +def kernelCorrespondenceL2 : KernelQuotientL2→L[ℂ]KernelQuotientL2 := + (integralCoverTrace hHK globalKubotaKernel_le_levelThree).comp + ((integralConjugatePullback e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree)).toContinuousLinearMap.comp + (integralCoverPullback hJK globalKubotaKernel_le_levelThree)) + +lemma kernelCorrespondenceL2_representative (F : KernelQuotientL2) + (f : KernelQuotient→ℂ) (hf : Measurable f) + (hrep : F=ᵐ[integralQuotientVolume globalKubotaKernel]f) : + kernelCorrespondenceL2 hHK hJK e g he F=ᵐ[integralQuotientVolume globalKubotaKernel] + kernelCorrespondenceFunction hJK e g he f := by + have hcover := (integralCoverPullback_ae hJK globalKubotaKernel_le_levelThree F).trans + ((integralCoverMap_quasiMeasurePreserving hJK + globalKubotaKernel_le_levelThree).ae_eq_comp hrep) + have hconj := (integralConjugatePullback_ae e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree) _).trans + ((integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree)).quasiMeasurePreserving.ae_eq_comp hcover) + exact integralCoverTrace_representative hHK globalKubotaKernel_le_levelThree _ _ + ((hf.comp (integralCoverMap_measurable hJK)).comp (integralConjugateMap_measurable e g he)) hconj + +lemma kernelCorrespondenceTest_mass (f : kernelSmoothTests) : + kernelSmoothTestsToL2 (kernelCorrespondenceTest hHK hJK e g he f)= + kernelCorrespondenceL2 hHK hJK e g he (kernelSmoothTestsToL2 f) := by + apply Lp.ext + exact (kernelSmoothTests_memLp (kernelCorrespondenceTest hHK hJK e g he f)).coeFn_toLp.trans + (kernelCorrespondenceL2_representative hHK hJK e g he _ f.1 + f.2.1.continuous.measurable (kernelSmoothTests_memLp f).coeFn_toLp).symm + +include hHK in +lemma kernelCorrespondenceFunction_integrable (f : KernelQuotient→ℂ) (hf : Measurable f) + (hi : Integrable f (integralQuotientVolume globalKubotaKernel)) : + Integrable (kernelCorrespondenceFunction hJK e g he f) + (integralQuotientVolume globalKubotaKernel) := by + have hcover := (integralCoverMap_measurePreserving hJK + globalKubotaKernel_le_levelThree).integrable_comp_of_integrable + (hi.smul_measure (c:=(J.relIndex globalKubotaKernel:ℝ≥0∞)) (by simp)) + have hconj := (integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree)).integrable_comp_of_integrable hcover + exact integralCoverTraceFunction_integrable hHK globalKubotaKernel_le_levelThree _ + ((hf.comp (integralCoverMap_measurable hJK)).comp (integralConjugateMap_measurable e g he)) hconj + +include hHK in +lemma kernelCorrespondenceFunction_integral (f : KernelQuotient→ℂ) (hf : Measurable f) + (hi : Integrable f (integralQuotientVolume globalKubotaKernel)) : + (∫q,kernelCorrespondenceFunction hJK e g he f q∂integralQuotientVolume globalKubotaKernel)= + (J.relIndex globalKubotaKernel:ℂ)*(∫q,f q∂integralQuotientVolume globalKubotaKernel) := by + have hcover := (integralCoverMap_measurePreserving hJK + globalKubotaKernel_le_levelThree).integrable_comp_of_integrable + (hi.smul_measure (c:=(J.relIndex globalKubotaKernel:ℝ≥0∞)) (by simp)) + have hconj := (integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree)).integrable_comp_of_integrable hcover + have hm := integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree) + change Integrable (fun q=>f (integralCoverMap hJK (integralConjugateMap e g he q))) _ at hconj + calc + _ = ∫q,f (integralCoverMap hJK (integralConjugateMap e g he q))∂integralQuotientVolume H := + integralCoverTraceFunction_integral hHK globalKubotaKernel_le_levelThree _ + ((hf.comp (integralCoverMap_measurable hJK)).comp (integralConjugateMap_measurable e g he)) hconj + _ = ∫q,f (integralCoverMap hJK q)∂integralQuotientVolume J := by + have hh := integral_map («μ»:=integralQuotientVolume H) hm.measurable.aemeasurable + (hf.comp (integralCoverMap_measurable hJK)).aestronglyMeasurable + rw [hm.map_eq] at hh + exact hh.symm + _ = ∫q,f q∂Measure.map (integralCoverMap hJK) (integralQuotientVolume J) := + (integral_map (integralCoverMap_measurable hJK).aemeasurable hf.aestronglyMeasurable).symm + _ = _ := by + rw [integralCoverMap_measure hJK globalKubotaKernel_le_levelThree, + integral_smul_measure] + simp only [ENNReal.toReal_natCast,Complex.real_smul,Complex.ofReal_natCast] + +end + +def coverEnergyDensity (F : EuclideanSpatial→ℂ) (p : EuclideanSpatial) : ℝ := + euclideanScalarDirichletDensity (fun x=>(F x).re) p+ + euclideanScalarDirichletDensity (fun x=>(F x).im) p + +def coverGradientAt (F : EuclideanSpatial→ℂ) (p : EuclideanSpatial) : + EuclideanSpace ℂ (Fin 3) := + WithLp.toLp 2 (fun j=>(p 2:ℂ)*fderiv ℝ F p (EuclideanSpace.basisFun (Fin 3) ℝ j)) + +lemma coverEnergyDensity_nonneg (F : EuclideanSpatial→ℂ) (p : EuclideanSpatial) : + 0≤coverEnergyDensity F p := by + unfold coverEnergyDensity euclideanScalarDirichletDensity + positivity + +lemma coverGradientAt_norm_sq (F : EuclideanSpatial→ℂ) (p : EuclideanSpatial) + (hF : DifferentiableAt ℝ F p) : + ‖coverGradientAt F p‖^2=coverEnergyDensity F p := by + have hr := (Complex.reCLM.hasFDerivAt.comp p hF.hasFDerivAt).fderiv + have hi := (Complex.imCLM.hasFDerivAt.comp p hF.hasFDerivAt).fderiv + change fderiv ℝ (fun x=>(F x).re) p=_ at hr + change fderiv ℝ (fun x=>(F x).im) p=_ at hi + unfold coverEnergyDensity euclideanScalarDirichletDensity + rw [hr,hi,(EuclideanSpace.basisFun (Fin 3) ℝ).norm_dual, + (EuclideanSpace.basisFun (Fin 3) ℝ).norm_dual,←mul_add,←Finset.sum_add_distrib] + rw [PiLp.norm_sq_eq_of_L2] + change (∑j:Fin 3,‖(p 2:ℂ)*fderiv ℝ F p (EuclideanSpace.basisFun (Fin 3) ℝ j)‖^2)=_ + simp only [norm_mul,mul_pow,Complex.norm_real,Real.norm_eq_abs,sq_abs,Finset.mul_sum] + apply Finset.sum_congr rfl + intro j _ + congr 1 + change ‖fderiv ℝ F p (EuclideanSpace.basisFun (Fin 3) ℝ j)‖^2= + (fderiv ℝ F p (EuclideanSpace.basisFun (Fin 3) ℝ j)).re^2+ + (fderiv ℝ F p (EuclideanSpace.basisFun (Fin 3) ℝ j)).im^2 + simpa only [Complex.normSq_apply,pow_two] using + (Complex.normSq_eq_norm_sq (fderiv ℝ F p (EuclideanSpace.basisFun (Fin 3) ℝ j))).symm + +lemma coverEnergyDensity_comp (g : SL(2,ℂ)) (F : EuclideanSpatial→ℂ) + (p : EuclideanSpatial) (hp : 0

(F p).re) p hp + (Complex.reCLM.differentiableAt.comp _ hF) + have hi := hyperbolic_cotangent_energy_comp g (fun p=>(F p).im) p hp + (Complex.imCLM.differentiableAt.comp _ hF) + exact congrArg₂ (fun x y : ℝ=>x+y) hr hi + +lemma coverGradientAt_sum {ι : Type*} (s : Finset ι) (F : ι→EuclideanSpatial→ℂ) + (p : EuclideanSpatial) (hF : ∀i∈s,DifferentiableAt ℝ (F i) p) : + coverGradientAt (fun x=>∑i∈s,F i x) p=∑i∈s,coverGradientAt (F i) p := by + apply (WithLp.equiv 2 (Fin 3→ℂ)).injective + funext j + simp only [coverGradientAt,fderiv_fun_sum hF,_root_.sum_apply, + WithLp.equiv_apply,Finset.mul_sum,WithLp.ofLp_sum,Finset.sum_apply] + +lemma norm_sum_sq_le_card {ι E : Type*} [NormedAddCommGroup E] + (s : Finset ι) (f : ι→E) : + ‖∑i∈s,f i‖^2≤(s.card:ℝ)*∑i∈s,‖f i‖^2 := by + calc + _ ≤ (∑i∈s,‖f i‖)^2 := (sq_le_sq₀ (norm_nonneg _) (Finset.sum_nonneg (fun _ _=>norm_nonneg _))).mpr + (norm_sum_le _ _) + _ ≤ _ := by + simpa only [one_mul,one_pow,Finset.sum_const,nsmul_eq_mul,mul_one] using + (Finset.sum_mul_sq_le_sq_mul_sq s (fun _=> (1:ℝ)) (fun i=>‖f i‖)) + +lemma coverEnergyDensity_sum_le {ι : Type*} (s : Finset ι) (F : ι→EuclideanSpatial→ℂ) + (p : EuclideanSpatial) (hF : ∀i∈s,DifferentiableAt ℝ (F i) p) : + coverEnergyDensity (fun x=>∑i∈s,F i x) p≤(s.card:ℝ)*∑i∈s,coverEnergyDensity (F i) p := by + rw [←coverGradientAt_norm_sq _ _ (DifferentiableAt.fun_sum hF),coverGradientAt_sum s F p hF] + have hh := norm_sum_sq_le_card s (fun i=>coverGradientAt (F i) p) + calc + _ ≤ _ := hh + _ = _ := by + congr 1 + apply Finset.sum_congr rfl + intro i hi + exact coverGradientAt_norm_sq (F i) p (hF i hi) + +lemma kernelTestEnergyDensity_eq_cover (f : kernelSmoothTests) (w : HyperbolicSpace) : + kernelTestEnergyDensity f w=coverEnergyDensity (kernelTestField f) (hyperbolicEuclideanCoordinates w) := rfl + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma rational_unipotent_upper (n:ℕ) : + rationalEmbedding (ModularGroup.T^n)=unitCuspUpper (n:Eis) := by + rw [←rationalUnipotent_nat] + apply Subtype.ext + change ( !![(1 : ℤ), (n : ℤ); 0, 1]).map (Int.castRingHom Eis) = + !![1, (n : Eis); 0, 1] + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> simp + +lemma rational_cusp_lower_section (u:Eisˣ) (n:ℕ) (z:ℂ) (v:ℝ) (hv:0(4:ℂ)⁻¹*(eisenstein + (integralComplexMatrix (lowerCuspMatrix (u:Eis))*upperSection z v hv) s+c)) + apply Finset.sum_congr rfl + intro n hn + rw [←mul_assoc,rational_cusp_lower_section] + +theorem sourceEisenstein_primitive_lower_four (u t:Eisˣ) + (hu:(u:Eis)^2+(u:Eis)+1=0) + (ht:-(u:Eis)*(1+2*(u:Eis))=onceCuspScale t) + (z:ℂ) (v:ℝ) (hv:0eisenstein (g*upperSection (z+b) v hv) s) := by + have hc:Continuous (fun z:ℂ=>(⟨(z+b,v),hv⟩:UpperCoordinates)):=by fun_prop + have he : Continuous (fun z:ℂ=>hyperbolicEisenstein s (g • upperPoint (z+b) v hv)) := by + simpa only [Function.comp_def] using + ((hyperbolicEisenstein_continuous s hs).comp (continuous_translatedUpperCoordinates g)).comp hc + simpa only [hyperbolicEisenstein_fixed_upper] using he + +lemma integrable_fixed_left_Eisenstein_fourier (g:SL(2,ℂ)) (v:ℝ) (hv:0eisenstein (g*upperSection (z+b) v hv) s*ShortDraftTrace.breveE (-freq*z)) periodDomain := by + apply periodDomain_integrable_of_continuous + apply (continuous_fixed_left_Eisenstein g v hv s hs b).mul + change Continuous (fun z:ℂ=>Complex.exp (2*Real.pi*Complex.I*((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +def ramifiedCuspGaussSeries (b:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b)) (s:ℂ) : ℂ := + (4:ℂ)⁻¹*(unitCuspGaussSeries 1 (ramifiedCuspRoot b) h s+ + ShortDraftTrace.breveE (ninthCuspFrequency h*eisEmbedding (↑(ramifiedCuspRoot b)⁻¹:Eis))* + (unitCuspGaussSeries (-(ramifiedCuspRoot b)) (-(ramifiedCuspRoot b)) h s+ + unitCuspGaussSeries (-(ramifiedCuspRoot b)) 1 h s+ + onceCuspGaussSeries (-(ramifiedCuspRoot b)) (ramifiedCuspScaleUnit b) h hf s)) + +theorem ramifiedSourceEisenstein_fourier (b:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b)) + (v:ℝ) (hv:0eisenstein (integralComplexMatrix (lowerCuspMatrix (t:Eis))*upperSection z v hv) s* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z) + let f1:ℂ→ℂ:=fun z=>eisenstein (integralComplexMatrix (unitCuspDiagonal (-t))* + integralComplexMatrix (lowerCuspMatrix (-(t:Eis)))*upperSection (z+shift) v hv) s* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z) + let f2:ℂ→ℂ:=fun z=>eisenstein (integralComplexMatrix (unitCuspDiagonal (-t))* + integralComplexMatrix (lowerCuspMatrix 1)*upperSection (z+shift) v hv) s* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z) + let f3:ℂ→ℂ:=fun z=>eisenstein (integralComplexMatrix (unitCuspDiagonal (-t))* + integralComplexMatrix (lowerCuspMatrix (onceCuspScale (ramifiedCuspScaleUnit b)))*upperSection (z+shift) v hv) s* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z) + have hi0:IntegrableOn f0 periodDomain:=by + simpa only [f0,add_zero] using integrable_fixed_left_Eisenstein_fourier + (integralComplexMatrix (lowerCuspMatrix (t:Eis))) v hv s hs 0 (ninthCuspFrequency h) + have hi1:IntegrableOn f1 periodDomain:=integrable_fixed_left_Eisenstein_fourier _ v hv s hs shift _ + have hi2:IntegrableOn f2 periodDomain:=integrable_fixed_left_Eisenstein_fourier _ v hv s hs shift _ + have hi3:IntegrableOn f3 periodDomain:=integrable_fixed_left_Eisenstein_fourier _ v hv s hs shift _ + have heq:(∫z in periodDomain,sourceEisenstein s + (integralComplexMatrix (lowerCuspMatrix (t:Eis)) • upperPoint z v hv)*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + (4:ℂ)⁻¹*((∫z in periodDomain,f0 z)+(∫z in periodDomain,f1 z)+ + (∫z in periodDomain,f2 z)+(∫z in periodDomain,f3 z)):=by + calc + _ = ∫z in periodDomain,(4:ℂ)⁻¹*(f0 z+f1 z+f2 z+f3 z) := by + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun z=>by + dsimp only + rw [sourceEisenstein_primitive_lower_four t (ramifiedCuspScaleUnit b) + (ramifiedCuspRoot_primitive b) (ramifiedCuspScaleUnit_spec b)] + dsimp only [f0,f1,f2,f3,shift] + ring) + _ = _ := by + rw [integral_const_mul] + rw [integral_add (f:=fun z=>f0 z+f1 z+f2 z) (g:=f3) ((hi0.add hi1).add hi2) hi3, + integral_add (f:=fun z=>f0 z+f1 z) (g:=f2) (hi0.add hi1) hi2, + integral_add (f:=f0) (g:=f1) hi0 hi1] + have hr0:(↑(1:Eisˣ)⁻¹:Eis)^2*(t:Eis)=omega^(ramifiedCuspDirectIndex b):=by + simpa [t] using ramifiedCuspRoot_val b + have hr1:(↑(-t)⁻¹:Eis)^2*((-t:Eisˣ):Eis)=-(omega^(ramifiedCuspOppositeIndex b)):= + ramifiedCusp_opposite_character b + have hr2:(↑(-t)⁻¹:Eis)^2*((1:Eisˣ):Eis)=omega^(ramifiedCuspDirectIndex b):=by + rw [Units.val_one,mul_one,ramifiedCusp_neg_inv_square,ramifiedCuspRoot_val] + have hb2:(3:Eis)∣h+ramifiedAffineParameter (ramifiedCuspDirectIndex b) 0*((1:Eisˣ):Eis):=by + simpa using ramifiedCusp_unit_base b h hf + have h0:(∫z in periodDomain,f0 z)=arch*unitCuspGaussSeries 1 t h s:=by + simpa only [unitCuspDiagonal_one,map_one,one_mul,f0,arch] using + unitCusp_eisenstein_fourier_base 1 t (ramifiedCuspDirectIndex b) h (Or.inl hr0) + (ramifiedCusp_direct_base b h hf) v hv s hs + have h1:(∫z in periodDomain,f1 z)=ShortDraftTrace.breveE (ninthCuspFrequency h*shift)* + (arch*unitCuspGaussSeries (-t) (-t) h s):=by + have he:=diagonal_unit_fourier_shift (-t) (-t) (ramifiedCuspOppositeIndex b) h (Or.inr hr1) + (ramifiedCusp_opposite_base b h hf) v hv s shift + rw [unitCusp_eisenstein_fourier_base (-t) (-t) (ramifiedCuspOppositeIndex b) h (Or.inr hr1) + (ramifiedCusp_opposite_base b h hf) v hv s hs] at he + simpa only [f1,Units.val_neg,arch] using he + have h2:(∫z in periodDomain,f2 z)=ShortDraftTrace.breveE (ninthCuspFrequency h*shift)* + (arch*unitCuspGaussSeries (-t) 1 h s):=by + have he:=diagonal_unit_fourier_shift (-t) 1 (ramifiedCuspDirectIndex b) h (Or.inl hr2) + hb2 v hv s shift + rw [unitCusp_eisenstein_fourier_base (-t) 1 (ramifiedCuspDirectIndex b) h (Or.inl hr2) + hb2 v hv s hs] at he + simpa only [f2,Units.val_one,arch] using he + have h3:(∫z in periodDomain,f3 z)=ShortDraftTrace.breveE (ninthCuspFrequency h*shift)* + (arch*onceCuspGaussSeries (-t) (ramifiedCuspScaleUnit b) h hf s):=by + dsimp only [f3] + rw [diagonal_once_fourier_shift (-t) (ramifiedCuspScaleUnit b) h hf v hv s shift hs, + onceCusp_eisenstein_fourier (-t) (ramifiedCuspScaleUnit b) h hf v hv s hs] + rw [heq,h0,h1,h2,h3] + dsimp only [ramifiedCuspGaussSeries,arch,shift,t] + ring + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +local notation "Eis" => ActualEisensteinCubic.O + +theorem finite_unramified_residue {ι:Type*} [Fintype ι] [DecidableEq ι] + (index:ι→Eis) (coefficient:ι→ℂ→ℂ) + (hc:∀i s,1(s-4/3)*f s) (𝓝[≠] (4/3:ℂ)) (𝓝 R)) + (hinit:∀s:ℂ,4cuspWhittakerHeightFactor s (3*index i) + let G:ι→ℂ→ℂ:=fun i s=>translatedCuspFamily (3*index i) oppositeSource 2 3 + (by norm_num) (by norm_num) s + let D:ℂ→ℂ:=fun s=>∏i,H i s + let E:ι→ℂ→ℂ:=fun i s=>∏j∈Finset.univ.erase i,H j s + have hH:∀i s,1 + cuspWhittakerHeightFactor_analyticAt (3*index i) s hs + have hD:∀s,1 + Finset.analyticAt_fun_prod _ (fun i hi=>hH i s hs) + have hE:∀i s,1 + Finset.analyticAt_fun_prod _ (fun j hj=>hH j s hs) + have hprod (i:ι) (s:ℂ):H i s*E i s=D s:=by + exact Finset.mul_prod_erase Finset.univ (fun j=>H j s) (Finset.mem_univ i) + let domain:Set ℂ:={s|1f s*D s) domain:=fun s hs=>(hf s hs.1 hs.2).mul (hD s hs.1) + have hb:AnalyticOnNhd ℂ (fun s=>∑i,coefficient i s*G i s*E i s) domain:=by + intro s hs + apply Finset.analyticAt_fun_sum + intro i hi + exact ((hc i s hs.1).mul (translatedCuspFamily_analyticAt_nonreal (3*index i) + oppositeSource 2 3 (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne')).mul (hE i s hs.1) + have hopen:IsOpen {s:ℂ|4f s*D s)=ᶠ[𝓝 (5+Complex.I:ℂ)] + (fun s=>∑i,coefficient i s*G i s*E i s):=by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + rw [hinit s hs.1 hs.2,Finset.sum_mul] + apply Finset.sum_congr rfl + intro i hi + dsimp only [G] + rw [translatedCuspFamily_opposite_initial (index i) s hs.1 hs.2] + change coefficient i s*unramifiedCubicGaussSeries s (index i)*D s= + coefficient i s*(unramifiedCubicGaussSeries s (index i)*H i s)*E i s + rw [←hprod i s] + ring + have heq:=ha.eqOn_of_preconnected_of_eventuallyEq hb hconvex.isPreconnected + (show (5+Complex.I:ℂ)∈domain by norm_num [domain]) hev + have hDc:Tendsto D (𝓝[≠] (4/3:ℂ)) (𝓝 (D (4/3))):= + (hD (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds + have hl:=(hlim.mul hDc).comp upperVertical_tendsto_cubic_punctured + have hg:∀i,Tendsto (fun s:ℂ=>coefficient i s*((s-4/3)*G i s)*E i s) + (𝓝[≠] (4/3:ℂ)) + (𝓝 (coefficient i (4/3)*translatedCuspFourier (3*index i) oppositeSource + cubicEisensteinResidue*E i (4/3))):=by + intro i + exact (((hc i (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds).mul + (translatedCuspFamily_residue_limit (3*index i) oppositeSource 2 3 + (by norm_num) (by norm_num))).mul + ((hE i (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds) + have hr:=(tendsto_finsetSum Finset.univ (fun i hi=>hg i)).comp upperVertical_tendsto_cubic_punctured + have hel:(fun t:ℝ=>((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)*f ((4/3:ℂ)+(t:ℂ)*Complex.I))* + D ((4/3:ℂ)+(t:ℂ)*Complex.I))=ᶠ[𝓝[>] (0:ℝ)] + (fun t:ℝ=>∑i,coefficient i ((4/3:ℂ)+(t:ℂ)*Complex.I)* + ((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)*G i ((4/3:ℂ)+(t:ℂ)*Complex.I))* + E i ((4/3:ℂ)+(t:ℂ)*Complex.I)):=by + filter_upwards [self_mem_nhdsWithin] with t ht + have ht0:0 + cuspWhittakerHeightFactor_center_ne_zero (3*index i)) + apply mul_right_cancel₀ hDn + rw [Finset.sum_mul] + refine hres.trans ?_ + apply Finset.sum_congr rfl + intro i hi + change coefficient i (4/3)*translatedCuspFourier (3*index i) oppositeSource + cubicEisensteinResidue*E i (4/3)=coefficient i (4/3)* + (translatedCuspFourier (3*index i) oppositeSource cubicEisensteinResidue/H i (4/3))*D (4/3) + rw [←hprod i (4/3)] + field_simp [show H i (4/3)≠0 from cuspWhittakerHeightFactor_center_ne_zero (3*index i)] + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open CubicKubota + +lemma cuspStrip_integrable_continuous (a b:ℝ) (ha:0(s-4/3)*sourceArbitraryHeightFamily M a b ha ρ freq s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (sourceArbitraryHeightFourier M a b ha ρ freq cubicEisensteinResidue)) := by + have he:=(tendsto_finsetSum Finset.univ (fun i hi=> + arbitraryCuspHeightFamily_residue_limit (rationalComplex (rationalBruhatRep i)*M) a b ha ρ freq)).const_mul ((24:ℂ)⁻¹) + convert he using 1 + · funext s + rw [sourceArbitraryHeightFamily,←Finset.mul_sum] + ring + · simp only [sourceArbitraryHeightFourier,_root_.smul_apply, + _root_.sum_apply,smul_eq_mul] + +lemma sourceProjection_integral (f:HyperbolicSpace→ℂ) (hf:Continuous f) + (M:SL(2,ℂ)) (a b:ℝ) (ha:0f ((rationalComplex (rationalBruhatRep i)*M)•w)*arbitraryCuspWeightedPhase ρ freq w) + (cuspPeriodStrip a b) hyperbolicVolume := + cuspStrip_integrable_continuous a b ha _ ((hf.comp (continuous_hyperbolic_action _)).mul + (arbitraryCuspWeightedPhase_continuous ρ freq)) + calc + _ = ∫w in cuspPeriodStrip a b,(24:ℂ)⁻¹*∑i:RationalBruhatIndex, + f ((rationalComplex (rationalBruhatRep i)*M)•w)*arbitraryCuspWeightedPhase ρ freq w∂hyperbolicVolume := by + apply integral_congr_ae + exact Eventually.of_forall (fun w=>by + dsimp only + rw [sourceProjection_eq_twentyFour] + simp only [rationalComplex,MonoidHom.comp_apply,mul_smul] + rw [←Finset.sum_mul] + ring) + _ = _ := by rw [integral_const_mul,integral_finsetSum _ (fun i hi'=>hi i)] + +lemma sourceArbitraryHeightFamily_initial (M:SL(2,ℂ)) (a b:ℝ) (ha:0c*arbitraryCuspWeightedPhase ρ freq w) hw + +lemma sourceArbitraryHeightFourier_residue_integral (M:SL(2,ℂ)) (a b:ℝ) (ha:0 ActualEisensteinCubic.O + +lemma cubeAverageMatrix_translate_lattice (p:Eis) (hp:p≠0) (q n:Eis) : + cubeAverageMatrix p hp q*complexTranslation (3*eisEmbedding n)=cubeAverageMatrix p hp (q+n) := by + apply Subtype.ext + rw [Matrix.SpecialLinearGroup.coe_mul, cubeAverageMatrix_entries, cubeAverageMatrix_entries] + ext i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, complexTranslation, map_add] + ring + +lemma cubeAverage_period_three (p:Eis) (hp:p≠0) (F:HyperbolicSpace→ℂ) + (hF:∀n:Eis,∀w:HyperbolicSpace,F (complexTranslation (3*eisEmbedding n) • w)=F w) + (n:Eis) (w:HyperbolicSpace) : + cubeAverage p hp F (complexTranslation (3*eisEmbedding n) • w)=cubeAverage p hp F w := by + let a:(Eis⧸Ideal.span {p^3})≃(Eis⧸Ideal.span {p^3}):= + { toFun:=fun r=>r+Ideal.Quotient.mk _ n + invFun:=fun r=>r-Ideal.Quotient.mk _ n + left_inv:=fun r=>add_sub_cancel_right r _ + right_inv:=fun r=>sub_add_cancel r _ } + let f (r:Eis⧸Ideal.span {p^3}):= + F (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) • w) + have hpoint (r:Eis⧸Ideal.span {p^3}): + F (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) • + (complexTranslation (3*eisEmbedding n) • w))=f (a r) := by + rw [←mul_smul,cubeAverageMatrix_translate_lattice] + apply cubeAverage_summand_congr p hp F hF + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + rw [map_add,GaussianShiftedPartition.representative_spec, + GaussianShiftedPartition.representative_spec] + rfl + unfold cubeAverage + congr 1 + calc + _ = ∑' r,f (a r):=tsum_congr hpoint + _ = ∑' r,f r:=a.tsum_eq f + +end + +section + +open MeasureTheory +open scoped Classical MatrixGroups BigOperators + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota EisensteinCuspModThree +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubicSource_period_three (n:Eis) (w:HyperbolicSpace) : + cubicSourceResidualFunction (complexTranslation (3*eisEmbedding n) • w)= + cubicSourceResidualFunction w := by + obtain ⟨z,v,hv,rfl⟩:=upperPoint_surjective w + rw [complexTranslation_action] + simp only [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselFunction_period v hv z n + +lemma cubicSource_period_one (w:HyperbolicSpace) : + cubicSourceResidualFunction (complexTranslation 1 • w)=cubicSourceResidualFunction w := by + have h:=cubicSourceResidualFunction_rational_invariant ModularGroup.T w + change cubicSourceResidualFunction (rationalComplex ModularGroup.T • w)=_ at h + rwa [rationalComplex_T_eq] at h + +lemma cubicSource_period_finTwo (t:Fin 2) (w:HyperbolicSpace) : + cubicSourceResidualFunction (complexTranslation (t.val:ℂ) • w)=cubicSourceResidualFunction w := by + fin_cases t + · have hz:complexTranslation 0=1:=by + apply Matrix.SpecialLinearGroup.ext + intro i j + fin_cases i <;> fin_cases j <;> simp [complexTranslation] + simp only [Nat.cast_zero,hz,one_smul] + · simpa using cubicSource_period_one w + +lemma cubicSource_cube_period_finTwo (p:Eis) (hp:p≠0) (hprimary:lambda^2∣p-1) + (t:Fin 2) (w:HyperbolicSpace) : + cubeAverage p hp cubicSourceResidualFunction (complexTranslation (t.val:ℂ) • w)= + cubeAverage p hp cubicSourceResidualFunction w := by + fin_cases t + · have hz:complexTranslation 0=1:=by + apply Matrix.SpecialLinearGroup.ext + intro i j + fin_cases i <;> fin_cases j <;> simp [complexTranslation] + simp only [Nat.cast_zero,hz,one_smul] + · simpa using cubeAverage_period_one p hp hprimary cubicSourceResidualFunction + cubicSource_period_three cubicSource_period_one w + +theorem cubeSource_summand_average {M:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData M p q) (hp:p≠0) (v:ℝ) (hv:0 ActualEisensteinCubic.O + +theorem cubeSource_levelTwo_upper_average (A:levelTwo) (T:SL(2,Eis)) (hT:T 1 0=0) + (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (v:ℝ) (hv:0⟨(3*(eisEmbedding (p^3)*z),v),hv⟩ + have hc:Continuous c:=by + apply Continuous.subtype_mk + exact (continuous_const.mul (continuous_const.mul continuous_id)).prodMk continuous_const + have hcoord:= (continuous_translatedUpperCoordinates (integralComplexMatrix M)).comp hc + have h0:Continuous (fun z=>cubicSourceResidualFunction + (integralComplexMatrix M • upperPoint (3*(eisEmbedding (p^3)*z)) v hv)):=by + simpa only [Function.comp_def,c] using cubicSourceResidualFunction_continuous.comp hcoord + have h1:Continuous (fun z=>cubeAverage p hp.ne_zero cubicSourceResidualFunction + (integralComplexMatrix M • upperPoint (3*(eisEmbedding (p^3)*z)) v hv)):=by + simpa only [Function.comp_def,c] using + (cubeAverage_continuous p hp.ne_zero cubicSourceResidualFunction cubicSourceResidualFunction_continuous).comp hcoord + have h2:Continuous (fun z:ℂ=>(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*cubicSourceResidualFunction + (integralComplexMatrix M • upperPoint (3*(eisEmbedding (p^3)*z)) v hv)):= + continuous_const.mul h0 + rw [integral_sub (periodDomain_integrable_of_continuous _ h1) + (periodDomain_integrable_of_continuous _ h2),integral_const_mul, + cubeSource_average_all_cusps M p hp hprimary v hv, + sourceCusp_average_enlarged M (p^3) (pow_ne_zero 3 hp.ne_zero) v hv] + ring + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma integralCoverFiberPoint_continuous (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) : Continuous (integralCoverFiberPoint H K q) := by + have he : integralCoverFiberPoint H K q=fun w=> + integralOrbitProjection H ((integralCoverRep H K q)⁻¹•w) := + funext (integralCoverFiberPoint_rep H K q) + rw [he] + exact (continuous_integralOrbitProjection H).comp + (continuous_hyperbolic_action (integralComplexMatrix ((integralCoverRep H K q)⁻¹:SL(2,ActualEisensteinCubic.O)))) + +lemma integralCoverMap_fiber {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) + (w : HyperbolicSpace) : + (integralCoverMap hHK) ⁻¹' {integralOrbitProjection K w}= + Set.range (fun q : IntegralCoverCosets H K=>integralCoverFiberPoint H K q w) := by + ext u + constructor + · intro hu + induction u using Quotient.inductionOn with + | _ z => + have he : integralOrbitProjection K z=integralOrbitProjection K w := hu + obtain ⟨k,hk⟩ := Quotient.exact he + refine ⟨(k : IntegralCoverCosets H K),?_⟩ + change integralCoverFiberPoint H K (k : IntegralCoverCosets H K) w=integralOrbitProjection H z + rw [integralCoverFiberPoint_mk] + congr 1 + rw [←hk] + exact inv_smul_smul k z + · rintro ⟨q,rfl⟩ + exact integralCoverMap_fiberPoint hHK q w + +lemma integralCoverMap_preimage_image {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (S : Set (IntegralOrbitQuotient H)) : + (integralOrbitProjection K) ⁻¹' (integralCoverMap hHK '' S)= + ⋃q : IntegralCoverCosets H K,(integralCoverFiberPoint H K q) ⁻¹' S := by + ext w + constructor + · rintro ⟨u,hu,huw⟩ + have hh : u∈(integralCoverMap hHK) ⁻¹' {integralOrbitProjection K w} := huw + rw [integralCoverMap_fiber hHK w] at hh + obtain ⟨q,rfl⟩ := hh + exact Set.mem_iUnion.mpr ⟨q,hu⟩ + · intro hw + obtain ⟨q,hq⟩ := Set.mem_iUnion.mp hw + exact ⟨integralCoverFiberPoint H K q w,hq,integralCoverMap_fiberPoint hHK q w⟩ + +theorem integralCoverMap_isClosedMap {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) [H.IsFiniteRelIndex K] : IsClosedMap (integralCoverMap hHK) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + intro S hS + have hq : Topology.IsQuotientMap (integralOrbitProjection K) := isQuotientMap_quotient_mk' + apply hq.isCoinducing.isClosed_preimage.mp + rw [integralCoverMap_preimage_image] + exact isClosed_iUnion_of_finite (fun q=>hS.preimage (integralCoverFiberPoint_continuous H K q)) + +theorem integralCoverMap_isProperMap {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) [H.IsFiniteRelIndex K] : IsProperMap (integralCoverMap hHK) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + apply isProperMap_iff_isClosedMap_and_compact_fibers.mpr + refine ⟨integralCoverMap_continuous hHK,integralCoverMap_isClosedMap hHK,?_⟩ + intro q + induction q using Quotient.inductionOn with + | _ w => + change IsCompact ((integralCoverMap hHK) ⁻¹' {integralOrbitProjection K w}) + rw [integralCoverMap_fiber hHK w] + exact (Set.finite_range _).isCompact + +theorem integralCoverMap_compact_preimage {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) [H.IsFiniteRelIndex K] + (S : Set (IntegralOrbitQuotient K)) (hS : IsCompact S) : + IsCompact ((integralCoverMap hHK) ⁻¹' S) := + (integralCoverMap_isProperMap hHK).isCompact_preimage hS + +end + +section + +open MeasureTheory +open scoped Classical MatrixGroups BigOperators + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota EisensteinCuspModThree +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubeCuspTriangular_norm_sq_pos {M:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData M p q) (hp:p≠0) : 0<‖cubeCuspTriangular d hp 1 1‖^2 := by + rw [cubeCuspTriangular_norm_sq] + exact Real.rpow_pos_of_pos (norm_pos_iff.mpr (eisEmbedding_ne_zero hp)) _ + +def cubeReducedRemainder {M:SL(2,Eis)} {p q:Eis} (d:CubeCuspData M p q) (hp:p≠0) + (z:ℂ) (v:ℝ) (hv:0cubeReducedRemainder (d r) hp.ne_zero z v hv):=Summable.of_finite + have hs2:Summable (fun r:Eis⧸Ideal.span {p^3}=>(v:ℂ)^(2/3:ℂ)* + (sourceCuspLeadingCoefficient (d r).matrix*cubeCuspHeightWeight p (d r).exponent)):=Summable.of_finite + rw [tsum_congr hpoint,hs1.tsum_add hs2,tsum_mul_left] + calc + _=(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3 * + (∑' r:Eis⧸Ideal.span {p^3},cubeReducedRemainder (d r) hp.ne_zero z v hv)+ + (v:ℂ)^(2/3:ℂ)*((Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3 * + (∑' r:Eis⧸Ideal.span {p^3},sourceCuspLeadingCoefficient (d r).matrix*cubeCuspHeightWeight p (d r).exponent)):=by ring + _=_:=by rw [cubeSource_leading_sum M p hp hprimary];ring + rw [hu] + unfold sourceCuspRemainder + ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota EisensteinCuspModThree +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubePrime_norm_ge_one (p:Eis) (hp:p≠0) : 1≤‖eisEmbedding p‖ := by + have hn:1≤‖eisEmbedding p‖^2:=by + rw [eisEmbedding_norm_sq_eq_absNorm_span] + have hq:Ideal.absNorm (Ideal.span {p})≠0:= + (Ideal.absNorm_ne_zero_iff _).mpr (finite_quotient_span hp) + exact_mod_cast Nat.one_le_iff_ne_zero.mpr hq + nlinarith [norm_nonneg (eisEmbedding p)] + +lemma cubeReducedRemainder_bound {M:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData M p q) (hp:p≠0) (K:ℝ) (hK:0≤K) + (hrep:∀j:Fin 3,∀z:ℂ,∀v:ℝ,∀hv:0cubeReducedRemainder (d r) hp.ne_zero z v hv) (K*‖eisEmbedding p‖^9/v^3) + (by positivity) (fun r=>cubeReducedRemainder_bound (d r) hp.ne_zero K hK hrep z v hv hv1) + have hrest:‖(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*sourceCuspRemainder M z v hv‖≤ + (Ideal.absNorm (Ideal.span {p}):ℝ)⁻¹*(K/v^3):=by + rw [norm_mul,norm_inv,Complex.norm_natCast] + exact mul_le_mul_of_nonneg_left hbase (inv_nonneg.mpr (Nat.cast_nonneg _)) + rw [cubeSource_difference_eq_remainders M p hp hprimary z v hv] + refine (norm_sub_le _ _).trans ?_ + calc + _≤K*‖eisEmbedding p‖^9/v^3+(Ideal.absNorm (Ideal.span {p}):ℝ)⁻¹*(K/v^3):= + add_le_add hsum hrest + _=_:=by ring + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise Manifold ContDiff ENNReal +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma integralCoverMap_hasCompactSupport {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) [H.IsFiniteRelIndex K] (f : IntegralOrbitQuotient K→ℂ) + (hf : HasCompactSupport f) : + HasCompactSupport (fun q=>f (integralCoverMap hHK q)) := by + apply HasCompactSupport.of_support_subset_isCompact + (integralCoverMap_compact_preimage hHK (tsupport f) hf.isCompact) + intro q hq + exact subset_tsupport f hq + +lemma integralCoverTraceFunction_hasCompactSupport {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) [H.IsFiniteRelIndex K] (f : IntegralOrbitQuotient H→ℂ) + (hf : HasCompactSupport f) : HasCompactSupport (integralCoverTraceFunction H K f) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + apply HasCompactSupport.of_support_subset_isCompact + (hf.isCompact.image (integralCoverMap_continuous hHK)) + intro q hq + induction q using Quotient.inductionOn with + | _ w => + change (∑r : IntegralCoverCosets H K,f (integralCoverFiberPoint H K r w))≠0 at hq + obtain ⟨r,_,hr⟩ := Finset.exists_ne_zero_of_sum_ne_zero hq + exact ⟨integralCoverFiberPoint H K r w,subset_tsupport f hr, + integralCoverMap_fiberPoint hHK r w⟩ + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +def kernelCorrespondenceFunction (f : KernelQuotient→ℂ) : KernelQuotient→ℂ := + integralCoverTraceFunction H globalKubotaKernel + (fun q=>f (integralCoverMap hJK (integralConjugateMap e g he q))) + +omit [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondenceFunction_lift (f : KernelQuotient→ℂ) (w : HyperbolicSpace) : + kernelCorrespondenceFunction hJK e g he f (integralOrbitProjection globalKubotaKernel w)= + letI : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + ∑q : IntegralCoverCosets H globalKubotaKernel, + f (integralOrbitProjection globalKubotaKernel + ((g*integralComplexMatrix (((integralCoverRep H globalKubotaKernel q)⁻¹: + globalKubotaKernel):SL(2,ActualEisensteinCubic.O)))•w)) := by + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + change (∑q : IntegralCoverCosets H globalKubotaKernel, + f (integralCoverMap hJK (integralConjugateMap e g he + (integralCoverFiberPoint H globalKubotaKernel q w))))=_ + apply Finset.sum_congr rfl + intro q _ + rw [integralCoverFiberPoint_rep,integralSubgroup_smul, + integralConjugateMap_projection,integralCoverMap_projection,mul_smul] + +include hHK in +lemma kernelCorrespondenceFunction_hasCompactSupport (f : KernelQuotient→ℂ) + (hf : HasCompactSupport f) : HasCompactSupport (kernelCorrespondenceFunction hJK e g he f) := by + apply integralCoverTraceFunction_hasCompactSupport hHK + exact (integralCoverMap_hasCompactSupport hJK f hf).comp_homeomorph + (integralConjugateHomeomorph e g he) + +omit [J.IsFiniteRelIndex globalKubotaKernel] in +lemma kernelCorrespondenceFunction_contMDiff (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) : + ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ (kernelCorrespondenceFunction hJK e g he f) := by + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + apply kernel_contMDiff_of_lift + simp_rw [kernelCorrespondenceFunction_lift] + apply ContMDiff.sum + intro q _ + exact (hf.comp kernelProjection_contMDiff).comp + (hyperbolicAction_contMDiff (g*integralComplexMatrix + (((integralCoverRep H globalKubotaKernel q)⁻¹:globalKubotaKernel):SL(2,ActualEisensteinCubic.O)))) + +def kernelCorrespondenceTest (f : kernelSmoothTests) : kernelSmoothTests := + ⟨kernelCorrespondenceFunction hJK e g he f.1, + kernelCorrespondenceFunction_contMDiff hJK e g he f.1 f.2.1, + kernelCorrespondenceFunction_hasCompactSupport hHK hJK e g he f.1 f.2.2⟩ + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CoverTrace.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CoverTrace.lean new file mode 100644 index 0000000000000000000000000000000000000000..48643259a1e73fc24f113ab182359a04f21d1720 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CoverTrace.lean @@ -0,0 +1,622 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.IntegralCover + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise ENNReal InnerProductSpace +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma integralCoverSheet_measure (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) (q : IntegralCoverCosets H K) + (S : Set (IntegralOrbitQuotient K)) (hS : MeasurableSet S) : + hyperbolicVolume ((integralOrbitProjection K) ⁻¹' S ∩ integralCoverSheet H K q)= + integralQuotientVolume K S := by + have he : (integralOrbitProjection K) ⁻¹' S ∩ integralCoverSheet H K q= + (fun w=>integralCoverRep H K q • w) ⁻¹' + ((integralOrbitProjection K) ⁻¹' S ∩ hyperbolicFundamentalSet K) := by + ext w + change (integralOrbitProjection K w∈S ∧ integralCoverRep H K q•w∈hyperbolicFundamentalSet K) ↔ + (integralOrbitProjection K (integralCoverRep H K q•w)∈S ∧ + integralCoverRep H K q•w∈hyperbolicFundamentalSet K) + rw [integralSubgroup_smul,integralOrbitProjection_eq] + rw [he,measure_preimage_smul] + rw [integralQuotientVolume,Measure.map_apply (measurable_integralOrbitProjection K) hS, + Measure.restrict_apply ((measurable_integralOrbitProjection K) hS)] + +theorem integralCoverMap_measure {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + Measure.map (integralCoverMap hHK) (integralQuotientVolume H)= + (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + have hH : H≤CubicKubota.levelThree := hHK.trans hK + rw [←integralQuotientVolume_independent H hH (integralCoverDomain H K) + (integralCoverDomain_isFundamentalDomain hHK hK)] + rw [Measure.map_map (integralCoverMap_measurable hHK) (measurable_integralOrbitProjection H)] + change Measure.map (integralOrbitProjection K) (hyperbolicVolume.restrict (integralCoverDomain H K))=_ + apply Measure.ext + intro S hS + rw [Measure.map_apply (measurable_integralOrbitProjection K) hS, + Measure.restrict_apply ((measurable_integralOrbitProjection K) hS),Measure.smul_apply,smul_eq_mul] + rw [integralCoverDomain,Set.inter_iUnion] + rw [measure_iUnion] + · simp_rw [integralCoverSheet_measure H K _ S hS] + rw [tsum_fintype] + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] + congr 1 + rw [Subgroup.relIndex,Subgroup.index,Nat.card_eq_fintype_card] + · intro q r hqr + exact (integralCoverSheet_pairwiseDisjoint H K hK hqr).mono Set.inter_subset_right Set.inter_subset_right + · intro q + exact ((measurable_integralOrbitProjection K) hS).inter (integralCoverSheet_measurable H K q) + +lemma integralCoverMap_measurePreserving {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + MeasurePreserving (integralCoverMap hHK) (integralQuotientVolume H) + ((H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) := + ⟨integralCoverMap_measurable hHK,integralCoverMap_measure hHK hK⟩ + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise ENNReal InnerProductSpace InnerProduct +open Finset AddChar MulChar EisensteinEmbedding + +section +local notation "O" => ActualEisensteinCubic.O + +abbrev IntegralQuotientL2 (H : Subgroup (SL(2,ActualEisensteinCubic.O))) := + Lp ℂ 2 (integralQuotientVolume H) + +def integralCoverPullback {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + IntegralQuotientL2 K→L[ℂ]IntegralQuotientL2 H := + (Lp.compMeasurePreservingₗᵢ ℂ (integralCoverMap hHK) + (integralCoverMap_measurePreserving hHK hK)).toContinuousLinearMap.comp + (dominatedComplexL2 (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) le_rfl) + +theorem integralCoverPullback_ae {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (F : IntegralQuotientL2 K) : + integralCoverPullback hHK hK F=ᵐ[integralQuotientVolume H] + fun q=>F (integralCoverMap hHK q) := by + have hm := integralCoverMap_measurePreserving hHK hK + have he := dominatedComplexL2_ae + (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) + (le_rfl : (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K≤ + (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) F + exact (Lp.coeFn_compMeasurePreserving _ hm).trans + (hm.quasiMeasurePreserving.ae_eq_comp he) + +theorem integralCoverPullback_norm_le {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (F : IntegralQuotientL2 K) : + ‖integralCoverPullback hHK hK F‖≤(H.relIndex K:ℝ)^((1:ℝ)/2)*‖F‖ := by + change ‖Lp.compMeasurePreserving (integralCoverMap hHK) + (integralCoverMap_measurePreserving hHK hK) + (dominatedComplexL2 (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) le_rfl F)‖≤_ + rw [Lp.norm_compMeasurePreserving] + simpa only [ENNReal.toReal_natCast] using dominatedComplexL2_norm_le + (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) + (le_rfl : (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K≤ + (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) F + +theorem integralCoverPullback_inner {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (F G : IntegralQuotientL2 K) : + ⟪integralCoverPullback hHK hK F,integralCoverPullback hHK hK G⟫_ℂ= + (H.relIndex K:ℂ)*⟪F,G⟫_ℂ := by + let changeMeasure : IntegralQuotientL2 K→L[ℂ] + Lp ℂ 2 ((H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) := + dominatedComplexL2 (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) le_rfl + change ⟪(Lp.compMeasurePreservingₗᵢ ℂ (integralCoverMap hHK) + (integralCoverMap_measurePreserving hHK hK)) (changeMeasure F), + (Lp.compMeasurePreservingₗᵢ ℂ (integralCoverMap hHK) + (integralCoverMap_measurePreserving hHK hK)) (changeMeasure G)⟫_ℂ=_ + rw [LinearIsometry.inner_map_map,L2.inner_def,L2.inner_def] + have hF := dominatedComplexL2_ae + (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) + (le_rfl : (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K≤ + (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) F + have hG := dominatedComplexL2_ae + (by simp : (H.relIndex K:ℝ≥0∞)≠⊤) + (le_rfl : (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K≤ + (H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) G + calc + _ = ∫q,⟪F q,G q⟫_ℂ ∂((H.relIndex K:ℝ≥0∞) • integralQuotientVolume K) := by + apply integral_congr_ae + filter_upwards [hF,hG] with q hqF hqG + change ⟪changeMeasure F q,changeMeasure G q⟫_ℂ=⟪F q,G q⟫_ℂ + rw [show changeMeasure F q=F q from hqF,show changeMeasure G q=G q from hqG] + _ = _ := by + rw [integral_smul_measure] + simp only [ENNReal.toReal_natCast,Complex.real_smul,Complex.ofReal_natCast] + +def integralCoverTrace {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + IntegralQuotientL2 H→L[ℂ]IntegralQuotientL2 K := + ContinuousLinearMap.adjoint (integralCoverPullback hHK hK) + +theorem integralCoverTrace_pairing {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (F : IntegralQuotientL2 K) (G : IntegralQuotientL2 H) : + ⟪F,integralCoverTrace hHK hK G⟫_ℂ=⟪integralCoverPullback hHK hK F,G⟫_ℂ := + ContinuousLinearMap.adjoint_inner_right _ _ _ + +theorem integralCoverTrace_pullback {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (F : IntegralQuotientL2 K) : + integralCoverTrace hHK hK (integralCoverPullback hHK hK F)=(H.relIndex K:ℂ) • F := by + apply ext_inner_left ℂ + intro G + rw [integralCoverTrace_pairing,integralCoverPullback_inner,inner_smul_right] + +theorem integralCoverPullback_opNorm_le {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + ‖integralCoverPullback hHK hK‖≤(H.relIndex K:ℝ)^((1:ℝ)/2) := by + apply ContinuousLinearMap.opNorm_le_bound _ (Real.rpow_nonneg (Nat.cast_nonneg _) _) + exact integralCoverPullback_norm_le hHK hK + +theorem integralCoverTrace_opNorm_le {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + ‖integralCoverTrace hHK hK‖≤(H.relIndex K:ℝ)^((1:ℝ)/2) := by + rw [integralCoverTrace,ContinuousLinearMap.adjoint.norm_map] + exact integralCoverPullback_opNorm_le hHK hK + +def integralCoverAverage {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + IntegralQuotientL2 H→L[ℂ]IntegralQuotientL2 K := + (H.relIndex K:ℂ)⁻¹ • integralCoverTrace hHK hK + +theorem integralCoverAverage_pullback {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (F : IntegralQuotientL2 K) : + integralCoverAverage hHK hK (integralCoverPullback hHK hK F)=F := by + have hn : (H.relIndex K:ℂ)≠0 := Nat.cast_ne_zero.mpr Subgroup.relIndex_ne_zero + change (H.relIndex K:ℂ)⁻¹ • integralCoverTrace hHK hK (integralCoverPullback hHK hK F)=F + rw [integralCoverTrace_pullback,smul_smul,inv_mul_cancel₀ hn,one_smul] + +theorem integralCoverPullback_injective {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + Function.Injective (integralCoverPullback hHK hK) := + Function.LeftInverse.injective (integralCoverAverage_pullback hHK hK) + +end + +local notation "O" => ActualEisensteinCubic.O + +def integralCoverFiberPoint (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) (w : HyperbolicSpace) : IntegralOrbitQuotient H := + Quotient.liftOn' q (fun r : K=>integralOrbitProjection H (r⁻¹•w)) (by + intro a b hab + have hh : b⁻¹*a∈H.subgroupOf K := by + have h : a⁻¹*b∈H.subgroupOf K := QuotientGroup.leftRel_apply.mp hab + simpa only [mul_inv_rev,inv_inv] using (H.subgroupOf K).inv_mem h + apply Quotient.sound + refine ⟨⟨((b⁻¹*a:K):SL(2,ActualEisensteinCubic.O)),hh⟩,?_⟩ + change (b⁻¹*a)•(a⁻¹•w)=b⁻¹•w + simp only [mul_smul,smul_inv_smul]) + +lemma integralCoverFiberPoint_mk (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (r : K) (w : HyperbolicSpace) : + integralCoverFiberPoint H K r w=integralOrbitProjection H (r⁻¹•w) := rfl + +lemma integralCoverFiberPoint_rep (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) (w : HyperbolicSpace) : + integralCoverFiberPoint H K q w= + integralOrbitProjection H ((integralCoverRep H K q)⁻¹•w) := by + conv_lhs => rw [←QuotientGroup.out_eq' q] + rfl + +lemma integralCoverFiberPoint_smul (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) (k : K) (w : HyperbolicSpace) : + integralCoverFiberPoint H K (k•q) (k•w)=integralCoverFiberPoint H K q w := by + induction q using Quotient.inductionOn with + | _ r => + change integralOrbitProjection H ((k*r)⁻¹•(k•w))=integralOrbitProjection H (r⁻¹•w) + rw [mul_inv_rev,mul_smul,inv_smul_smul] + +lemma integralCoverFiberPoint_measurable (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) : Measurable (integralCoverFiberPoint H K q) := by + have he : integralCoverFiberPoint H K q=fun w=> + integralOrbitProjection H ((integralCoverRep H K q)⁻¹•w) := + funext (integralCoverFiberPoint_rep H K q) + rw [he] + exact (measurable_integralOrbitProjection H).comp (measurable_const_smul _) + +def integralCoverTraceLift (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (w : HyperbolicSpace) : ℂ := + letI : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + ∑q : IntegralCoverCosets H K,f (integralCoverFiberPoint H K q w) + +lemma integralCoverTraceLift_smul (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (k : K) (w : HyperbolicSpace) : + integralCoverTraceLift H K f (k•w)=integralCoverTraceLift H K f w := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + unfold integralCoverTraceLift + rw [←(MulAction.bijective k).sum_comp (fun q=>f (integralCoverFiberPoint H K q (k•w)))] + simp only [integralCoverFiberPoint_smul] + +def integralCoverTraceFunction (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) : IntegralOrbitQuotient K→ℂ := + Quotient.lift (integralCoverTraceLift H K f) (by + rintro w u ⟨k,rfl⟩ + exact (integralCoverTraceLift_smul H K f k w).symm) + +lemma integralCoverTraceFunction_projection (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (w : HyperbolicSpace) : + integralCoverTraceFunction H K f (integralOrbitProjection K w)=integralCoverTraceLift H K f w := rfl + +lemma integralCoverTraceFunction_measurable (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hf : Measurable f) : + Measurable (integralCoverTraceFunction H K f) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + apply measurable_from_quotient.mpr + change Measurable (integralCoverTraceLift H K f) + unfold integralCoverTraceLift + exact Finset.measurable_sum Finset.univ (fun q _=>hf.comp (integralCoverFiberPoint_measurable H K q)) + +theorem integralCoverTraceFunction_cusp_decay (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (C : ℝ) + (hdec : ∀M : CubicKubota.levelThree,∀z : ℂ,∀v : ℝ,∀hv : 0 ActualEisensteinCubic.O + +def IntegralCoverIntertwines {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) : Prop := + ∀h : H,g*integralComplexMatrix (h:SL(2,ActualEisensteinCubic.O))= + integralComplexMatrix (e h:SL(2,ActualEisensteinCubic.O))*g + +lemma integralCoverIntertwines_action {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (h : H) (w : HyperbolicSpace) : g•(h•w)=(e h)•(g•w) := by + rw [integralSubgroup_smul,integralSubgroup_smul,←mul_smul,he, mul_smul] + +lemma integralCoverIntertwines_inverse {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + IntegralCoverIntertwines e.symm g⁻¹ := by + intro j + have hh := he (e.symm j) + rw [e.apply_symm_apply] at hh + have hh' := congrArg (fun A : SL(2,ℂ)=>g⁻¹*A*g⁻¹) hh + simpa only [mul_assoc,inv_mul_cancel_left,mul_inv_cancel_right,mul_inv_cancel,mul_one] using hh'.symm + +def integralConjugateMap {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + IntegralOrbitQuotient H→IntegralOrbitQuotient J := + Quotient.map' (fun w=>g•w) (by + rintro w u ⟨h,rfl⟩ + exact ⟨e h,(integralCoverIntertwines_action e g he h w).symm⟩) + +lemma integralConjugateMap_projection {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) (w : HyperbolicSpace) : + integralConjugateMap e g he (integralOrbitProjection H w)= + integralOrbitProjection J (g•w) := rfl + +lemma integralConjugateMap_measurable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + Measurable (integralConjugateMap e g he) := by + apply measurable_from_quotient.mpr + exact (measurable_integralOrbitProjection J).comp (measurable_const_smul g) + +lemma integralConjugateMap_continuous {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + Continuous (integralConjugateMap e g he) := + (continuous_hyperbolic_action g).quotient_map' _ + +lemma integralConjugateMap_inverse {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (q : IntegralOrbitQuotient H) : + integralConjugateMap e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) + (integralConjugateMap e g he q)=q := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection H (g⁻¹•(g•w))=integralOrbitProjection H w + rw [inv_smul_smul] + +def integralConjugateHomeomorph {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + IntegralOrbitQuotient H≃ₜIntegralOrbitQuotient J where + toFun := integralConjugateMap e g he + invFun := integralConjugateMap e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) + left_inv := integralConjugateMap_inverse e g he + right_inv q := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection J (g•(g⁻¹•w))=integralOrbitProjection J w + rw [smul_inv_smul] + continuous_toFun := integralConjugateMap_continuous e g he + continuous_invFun := integralConjugateMap_continuous e.symm g⁻¹ _ + +lemma integralConjugate_fundamentalDomain {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (hH : H≤CubicKubota.levelThree) : + IsFundamentalDomain J ((fun w : HyperbolicSpace=>g•w) '' hyperbolicFundamentalSet H) + hyperbolicVolume := by + apply (hyperbolicFundamentalSet_isFundamentalDomain H hH).image_of_equiv + (MulAction.toPerm g) + (show Measure.QuasiMeasurePreserving (MulAction.toPerm g).symm + hyperbolicVolume hyperbolicVolume from + (measurePreserving_smul g⁻¹ hyperbolicVolume).quasiMeasurePreserving) + e.symm.toEquiv + intro j w + change g•(e.symm j•w)=j•(g•w) + simpa only [e.apply_symm_apply] using integralCoverIntertwines_action e g he (e.symm j) w + +theorem integralConjugateMap_measurePreserving {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (hH : H≤CubicKubota.levelThree) (hJ : J≤CubicKubota.levelThree) : + MeasurePreserving (integralConjugateMap e g he) (integralQuotientVolume H) + (integralQuotientVolume J) := by + refine ⟨integralConjugateMap_measurable e g he,?_⟩ + have hmap := (measurePreserving_smul g hyperbolicVolume).restrict_image_emb + (measurableEmbedding_const_smul g) (hyperbolicFundamentalSet H) + change Measure.map (integralConjugateMap e g he) + (Measure.map (integralOrbitProjection H) (hyperbolicVolume.restrict (hyperbolicFundamentalSet H)))=_ + rw [Measure.map_map (integralConjugateMap_measurable e g he) (measurable_integralOrbitProjection H)] + change Measure.map ((integralOrbitProjection J) ∘ (fun w : HyperbolicSpace=>g•w)) + (hyperbolicVolume.restrict (hyperbolicFundamentalSet H))=_ + rw [←Measure.map_map (measurable_integralOrbitProjection J) (measurable_const_smul g),hmap.map_eq] + exact integralQuotientVolume_independent J hJ _ (integralConjugate_fundamentalDomain e g he hH) + +def integralConjugatePullback {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (hH : H≤CubicKubota.levelThree) (hJ : J≤CubicKubota.levelThree) : + Lp ℂ 2 (integralQuotientVolume J)→ₗᵢ[ℂ]Lp ℂ 2 (integralQuotientVolume H) := + Lp.compMeasurePreservingₗᵢ ℂ (integralConjugateMap e g he) + (integralConjugateMap_measurePreserving e g he hH hJ) + +theorem integralConjugatePullback_ae {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (hH : H≤CubicKubota.levelThree) (hJ : J≤CubicKubota.levelThree) + (F : Lp ℂ 2 (integralQuotientVolume J)) : + integralConjugatePullback e g he hH hJ F=ᵐ[integralQuotientVolume H] + fun q=>F (integralConjugateMap e g he q) := + Lp.coeFn_compMeasurePreserving F (integralConjugateMap_measurePreserving e g he hH hJ) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ConcreteTraceCRT CubicKubota EisensteinCuspModThree +local notation "O" => ActualEisensteinCubic.O + +lemma scaled_cusp_periodic_upper + (F : HyperbolicSpace→ℂ) (v : ℝ) (hv : 0levelTwoComplexCharacter G*w) + (scaled_cusp_periodic_upper + (fun w=>cubicSourceResidualFunction (integralComplexMatrix (cuspRepresentative j) • w)) + v hv (sourceCuspRepresentative_periodic j v hv) T hT n z) + _ = _ := (he _).symm + +lemma sourceCusp_scaled_continuous (M : SL(2,ActualEisensteinCubic.O)) (v : ℝ) (hv : 0cubicSourceResidualFunction + (integralComplexMatrix M • upperPoint (3*z) v hv)) := by + let c : ℂ→UpperCoordinates := fun z=>⟨(3*z,v),hv⟩ + have hc : Continuous c := by + apply Continuous.subtype_mk + exact (continuous_const.mul continuous_id).prodMk continuous_const + have ht := (continuous_translatedUpperCoordinates (integralComplexMatrix M)).comp hc + have hh : Continuous (fun z : ℂ=>integralComplexMatrix M • upperPoint (3*z) v hv) := by + simpa only [Function.comp_def,c] using ht + exact cubicSourceResidualFunction_continuous.comp hh + +theorem sourceCusp_average_enlarged (M : SL(2,ActualEisensteinCubic.O)) (b : ActualEisensteinCubic.O) (hb : b≠0) + (v : ℝ) (hv : 0cubicSourceResidualFunction (integralComplexMatrix M • upperPoint (3*z) v hv)) + (sourceCusp_scaled_continuous M v hv).measurable + (sourceCusp_scaled_periodic M v hv) b hb).trans (sourceCusp_average_all M v hv) + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +theorem period_integral_eisenstein_affine (f : ℂ→ℂ) (hf : Measurable f) + (hp : ∀n : ActualEisensteinCubic.O,∀z : ℂ,f (z+3*eisEmbedding n)=f z) (b : ActualEisensteinCubic.O) (hb : b≠0) (c : ℂ) : + (∫z in periodDomain,f (eisEmbedding b*z+c))=∫z in periodDomain,f z := by + have hg : Measurable (fun z : ℂ=>f (z+c)) := + hf.comp (continuous_id.add continuous_const).measurable + have hgp : ∀n : ActualEisensteinCubic.O,∀z : ℂ,f (z+3*eisEmbedding n+c)=f (z+c) := by + intro n z + rw [show z+3*eisEmbedding n+c=(z+c)+3*eisEmbedding n by ring,hp] + rw [period_integral_eisenstein_mul (fun z=>f (z+c)) hg hgp b hb] + simpa only [add_comm] using period_integral_translation f hp c + +lemma complex_upper_triangular_bottom_ne_zero (T : SL(2,ℂ)) (hT : T 1 0=0) : T 1 1≠0 := by + have hdet : T 0 0*T 1 1=1 := by + simpa only [Matrix.det_fin_two,hT,mul_zero,sub_zero] using T.property + intro hz + rw [hz,mul_zero] at hdet + exact zero_ne_one hdet + +lemma complex_upper_triangular_action (T : SL(2,ℂ)) (hT : T 1 0=0) + (z : ℂ) (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +theorem sourceCusp_average_enlarged_affine (M : SL(2,ActualEisensteinCubic.O)) (b : ActualEisensteinCubic.O) (hb : b≠0) + (c : ℂ) (v : ℝ) (hv : 0cubicSourceResidualFunction (integralComplexMatrix M • upperPoint (3*z) v hv)) + (sourceCusp_scaled_continuous M v hv).measurable + (sourceCusp_scaled_periodic M v hv) b hb c).trans (sourceCusp_average_all M v hv) + +theorem sourceCusp_average_complex_upper (M : SL(2,ActualEisensteinCubic.O)) (T : SL(2,ℂ)) + (hT : T 1 0=0) (b d : ActualEisensteinCubic.O) (hd : d≠0) + (hscale : (T 0 0/T 1 1)*eisEmbedding b=eisEmbedding d) + (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +def cubeCuspTriangular {A:SL(2,Eis)} {p q:Eis} (d:CubeCuspData A p q) (hp:p≠0) : SL(2,ℂ) := + (integralComplexMatrix d.matrix)⁻¹*cubeAverageMatrix p hp q*integralComplexMatrix A + +lemma cubeCuspTriangular_factor {A:SL(2,Eis)} {p q:Eis} (d:CubeCuspData A p q) (hp:p≠0) : + cubeAverageMatrix p hp q*integralComplexMatrix A= + integralComplexMatrix d.matrix*cubeCuspTriangular d hp := by + unfold cubeCuspTriangular + group + +lemma cubeCuspTriangular_entries {A:SL(2,Eis)} {p q:Eis} (d:CubeCuspData A p q) (hp:p≠0) : + cubeCuspTriangular d hp 0 0=(cubeDilationRoot p)⁻¹*eisEmbedding p^d.exponent.val ∧ + cubeCuspTriangular d hp 1 0=0 ∧ + cubeCuspTriangular d hp 1 1=(cubeDilationRoot p)⁻¹*eisEmbedding p^(3-d.exponent.val) := by + let B:=cubeAverageMatrix p hp q*integralComplexMatrix A + have hz:=cubeDilationRoot_ne_zero p hp + have he:=cubeDilationRoot_sq p + have hx:eisEmbedding (A 0 0)+3*eisEmbedding q*eisEmbedding (A 1 0)= + eisEmbedding p^d.exponent.val*eisEmbedding (d.matrix 0 0):=by + simpa only [map_add,map_mul,map_pow,map_ofNat] using congrArg eisEmbedding d.first + have hy:eisEmbedding p^3*eisEmbedding (A 1 0)= + eisEmbedding p^d.exponent.val*eisEmbedding (d.matrix 1 0):=by + simpa only [map_mul,map_pow] using congrArg eisEmbedding d.second + have hB0:B 0 0=(cubeDilationRoot p)⁻¹*eisEmbedding p^d.exponent.val*eisEmbedding (d.matrix 0 0):=by + change (∑k:Fin 2,cubeAverageMatrix p hp q 0 k*integralComplexMatrix A k 0)=_ + rw [Fin.sum_univ_two] + simp only [cubeAverageMatrix_entries,integralComplexMatrix_apply,Matrix.of_apply, + Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_fin_one] + linear_combination (cubeDilationRoot p)⁻¹*hx + have hB1:B 1 0=(cubeDilationRoot p)⁻¹*eisEmbedding p^d.exponent.val*eisEmbedding (d.matrix 1 0):=by + change (∑k:Fin 2,cubeAverageMatrix p hp q 1 k*integralComplexMatrix A k 0)=_ + rw [Fin.sum_univ_two] + simp only [cubeAverageMatrix_entries,integralComplexMatrix_apply,Matrix.cons_val_one, + Matrix.cons_val_zero,Matrix.cons_val_fin_one,Matrix.of_apply,zero_mul,zero_add] + rw [mul_assoc,←hy,←he] + field_simp + have hinv:(integralComplexMatrix d.matrix : Matrix (Fin 2) (Fin 2) ℂ)⁻¹= + !![eisEmbedding (d.matrix 1 1),-eisEmbedding (d.matrix 0 1); + -eisEmbedding (d.matrix 1 0),eisEmbedding (d.matrix 0 0)] := by + rw [Matrix.inv_def,Matrix.SpecialLinearGroup.det_coe,Ring.inverse_one,one_smul,Matrix.adjugate_fin_two] + rfl + have hT:cubeCuspTriangular d hp=(integralComplexMatrix d.matrix)⁻¹*B:=by + dsimp [cubeCuspTriangular,B] + group + have hdet:eisEmbedding (d.matrix 0 0)*eisEmbedding (d.matrix 1 1)- + eisEmbedding (d.matrix 0 1)*eisEmbedding (d.matrix 1 0)=1:=by + have hd:d.matrix 0 0*d.matrix 1 1-d.matrix 0 1*d.matrix 1 0=1:=by + simpa only [Matrix.det_fin_two] using d.matrix.property + simpa only [map_sub,map_mul,map_one] using congrArg eisEmbedding hd + have h00:cubeCuspTriangular d hp 0 0=(cubeDilationRoot p)⁻¹*eisEmbedding p^d.exponent.val:=by + rw [hT] + simp only [Matrix.SpecialLinearGroup.coe_mul,Matrix.SpecialLinearGroup.coe_inv, + Matrix.adjugate_fin_two,Matrix.mul_apply,Fin.sum_univ_two,integralComplexMatrix_apply] + simp only [Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_fin_one,Matrix.of_apply,hB0,hB1] + linear_combination (cubeDilationRoot p)⁻¹*eisEmbedding p^d.exponent.val*hdet + have h10:cubeCuspTriangular d hp 1 0=0:=by + rw [hT] + simp only [Matrix.SpecialLinearGroup.coe_mul,Matrix.SpecialLinearGroup.coe_inv, + Matrix.adjugate_fin_two,Matrix.mul_apply,Fin.sum_univ_two,integralComplexMatrix_apply] + simp only [Matrix.cons_val_zero,Matrix.cons_val_one,Matrix.cons_val_fin_one,Matrix.of_apply,hB0,hB1] + ring + refine ⟨h00,h10,?_⟩ + have hd:cubeCuspTriangular d hp 0 0*cubeCuspTriangular d hp 1 1=1:=by + simpa only [Matrix.det_fin_two,h10,mul_zero,sub_zero] using (cubeCuspTriangular d hp).property + rw [h00] at hd + have hnon:(cubeDilationRoot p)⁻¹*eisEmbedding p^d.exponent.val≠0:= + mul_ne_zero (inv_ne_zero hz) (pow_ne_zero _ (eisEmbedding_ne_zero hp)) + apply mul_left_cancel₀ hnon + rw [hd] + have hpow:eisEmbedding p^d.exponent.val*eisEmbedding p^(3-d.exponent.val)=eisEmbedding p^3:=by + rw [←pow_add,Nat.add_sub_of_le (by omega:d.exponent.val≤3)] + calc + 1=(cubeDilationRoot p)⁻¹^2*eisEmbedding p^3:=by rw [←he,inv_pow,inv_mul_cancel₀ (pow_ne_zero 2 hz)] + _=_:=by rw [←hpow];ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubeCuspTriangular_integral_scale {A:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData A p q) (hp:p≠0) : + (cubeCuspTriangular d hp 0 0/cubeCuspTriangular d hp 1 1)*eisEmbedding (p^3)= + eisEmbedding (p^(2*d.exponent.val)) := by + obtain ⟨h00,_,h11⟩:=cubeCuspTriangular_entries d hp + rw [h00,h11,map_pow,map_pow] + have he:eisEmbedding p≠0:=eisEmbedding_ne_zero hp + have hz:=cubeDilationRoot_ne_zero p hp + have hpow:eisEmbedding p^3=eisEmbedding p^d.exponent.val*eisEmbedding p^(3-d.exponent.val):=by + rw [←pow_add,Nat.add_sub_of_le (by omega:d.exponent.val≤3)] + rw [hpow] + have htwo:eisEmbedding p^(2*d.exponent.val)=(eisEmbedding p^d.exponent.val)^2:=by + rw [mul_comm 2 d.exponent.val,pow_mul] + rw [htwo] + field_simp + +private lemma cube_scale_norm_real (r:ℝ) (hr:0 norm_num [Real.rpow_neg_natCast,Real.rpow_neg_one] + all_goals field_simp + +lemma cubeCuspTriangular_norm_sq {A:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData A p q) (hp:p≠0) : + ‖cubeCuspTriangular d hp 1 1‖^2 = + ‖eisEmbedding p‖^(3-2*(d.exponent.val:ℝ)) := by + obtain ⟨_,_,h11⟩:=cubeCuspTriangular_entries d hp + rw [h11,norm_mul,norm_inv,norm_pow,mul_pow,inv_pow] + have hn:‖cubeDilationRoot p‖^2=‖eisEmbedding p‖^3:=by + rw [←norm_pow,cubeDilationRoot_sq,norm_pow] + rw [hn] + exact cube_scale_norm_real _ (norm_pos_iff.mpr (eisEmbedding_ne_zero hp)) d.exponent + +lemma cubeCuspTriangular_height {A:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData A p q) (hp:p≠0) (v:ℝ) (hv:0 ActualEisensteinCubic.O + +lemma levelTwo_primary_shift_cases (A:levelTwo) : + ∃t:Fin 2, lambda^2∣((A:SL(2,Eis)) 0 0+(t.val:Eis)*(A:SL(2,Eis)) 1 0)-1 ∨ + lambda^2∣(-((A:SL(2,Eis)) 0 0+(t.val:Eis)*(A:SL(2,Eis)) 1 0))-1 := by + rcases integer_congruence_primary_cases ((A:SL(2,Eis)) 0 0) + (levelTwoRight A 0 0) (levelTwo_entry_integer A 0 0) with ha|ha|ha + · rcases integer_congruence_primary_cases ((A:SL(2,Eis)) 1 0) + (levelTwoRight A 1 0) (levelTwo_entry_integer A 1 0) with hc|hc|hc + · have h1:(3:Eis)∣1:=by + have hd:(A:SL(2,Eis)) 0 0*(A:SL(2,Eis)) 1 1- + (A:SL(2,Eis)) 0 1*(A:SL(2,Eis)) 1 0=1:=by + simpa only [Matrix.det_fin_two] using (A:SL(2,Eis)).property + rw [←hd] + exact dvd_sub (dvd_mul_of_dvd_left ha _) (dvd_mul_of_dvd_right hc _) + have hl:lambda∣(1:Eis):=(dvd_pow_self lambda (by decide:2≠0)).trans + (lambda_sq_dvd_three.trans h1) + exact (residue_lambda_prime.not_isUnit (isUnit_of_dvd_one hl)).elim + · refine ⟨1,Or.inl ?_⟩ + convert dvd_add (lambda_sq_dvd_three.trans ha) hc using 1 ; norm_num ; ring + · refine ⟨1,Or.inr ?_⟩ + convert dvd_add (dvd_neg.mpr (lambda_sq_dvd_three.trans ha)) hc using 1 ; norm_num ; ring + · exact ⟨0,Or.inl (by simpa using ha)⟩ + · exact ⟨0,Or.inr (by simpa using ha)⟩ + +end CubicKubota +namespace CubicEisenstein +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma rationalComplex_S_sq_action (w:HyperbolicSpace) : + rationalComplex (ModularGroup.S^2) • w=w := by + have he:rationalComplex (ModularGroup.S^2)=complexDiagonal (-1) (by norm_num):=by + have hS : ((ModularGroup.S ^ 2 : SL(2,ℤ)) : Matrix (Fin 2) (Fin 2) ℤ) = + !![-1, 0; 0, -1] := by decide + apply Subtype.ext + apply Matrix.ext + intro i j + change eisEmbedding ((Int.castRingHom Eis) ((ModularGroup.S ^ 2 : SL(2,ℤ)) i j)) = _ + rw [congrFun (congrFun hS i) j] + fin_cases i <;> fin_cases j <;> simp [complexDiagonal] + obtain ⟨z,v,hv,rfl⟩:=upperPoint_surjective w + rw [he,complexDiagonal_action] + apply upperPoint_congr <;> norm_num + +lemma rationalComplex_T_eq : rationalComplex ModularGroup.T=complexTranslation 1 := by + rw [← rationalUnipotent_one] + apply Subtype.ext + rw [rationalComplex_unipotent_coe] + norm_num [complexTranslation] + +theorem exists_primary_cusp_shift (A:levelTwo) : + ∃B:levelTwo, lambda^2∣((B:SL(2,Eis)) 0 0)-1 ∧ + ∃t:Fin 2,∀w:HyperbolicSpace, + integralComplexMatrix (B:SL(2,Eis)) • w= + complexTranslation (t.val:ℂ) • (integralComplexMatrix (A:SL(2,Eis)) • w) := by + obtain ⟨t,ht⟩:=levelTwo_primary_shift_cases A + let T:levelTwo:=⟨rationalEmbedding (ModularGroup.T^t.val),rational_mem_levelTwo _⟩ + let S:levelTwo:=⟨rationalEmbedding (ModularGroup.S^2),rational_mem_levelTwo _⟩ + have hT:((T*A:levelTwo):SL(2,Eis)) 0 0= + (A:SL(2,Eis)) 0 0+(t.val:Eis)*(A:SL(2,Eis)) 1 0:=by + have hmatrix : ((ModularGroup.T ^ t.val : SL(2, ℤ)) : Matrix (Fin 2) (Fin 2) ℤ) = + !![1, (t.val : ℤ); 0, 1] := by + fin_cases t <;> decide + change ((((ModularGroup.T ^ t.val : SL(2, ℤ)) : Matrix (Fin 2) (Fin 2) ℤ).map + (Int.castRingHom Eis)) * ((A : SL(2, Eis)) : Matrix (Fin 2) (Fin 2) Eis)) 0 0 = _ + rw [hmatrix] + simp [Matrix.mul_apply, Fin.sum_univ_two] + have hST:((S*(T*A):levelTwo):SL(2,Eis)) 0 0= + -((A:SL(2,Eis)) 0 0+(t.val:Eis)*(A:SL(2,Eis)) 1 0):=by + have hneg (M:SL(2,Eis)) : (rationalEmbedding (ModularGroup.S^2)*M) 0 0= -M 0 0:=by + have hmatrix : ((ModularGroup.S ^ 2 : SL(2, ℤ)) : Matrix (Fin 2) (Fin 2) ℤ) = + !![-1, 0; 0, -1] := by decide + change ((((ModularGroup.S ^ 2 : SL(2, ℤ)) : Matrix (Fin 2) (Fin 2) ℤ).map + (Int.castRingHom Eis)) * (M : Matrix (Fin 2) (Fin 2) Eis)) 0 0 = _ + rw [hmatrix] + simp [Matrix.mul_apply, Fin.sum_univ_two] + exact (hneg ((T*A:levelTwo):SL(2,Eis))).trans (congrArg (fun x:Eis=> -x) hT) + have hzero:complexTranslation 0=1:=by + apply Matrix.SpecialLinearGroup.ext + intro i j + fin_cases i <;> fin_cases j <;> simp [complexTranslation] + have hact (w:HyperbolicSpace):integralComplexMatrix ((T*A:levelTwo):SL(2,Eis)) • w= + complexTranslation (t.val:ℂ) • (integralComplexMatrix (A:SL(2,Eis)) • w):=by + change integralComplexMatrix (rationalEmbedding (ModularGroup.T^t.val)*(A:SL(2,Eis))) • w=_ + rw [map_mul,mul_smul] + change rationalComplex (ModularGroup.T^t.val) • (integralComplexMatrix (A:SL(2,Eis)) • w)=_ + fin_cases t + · simp only [pow_zero,map_one,one_smul,Nat.cast_zero,hzero] + · simp only [pow_one,rationalComplex_T_eq,Nat.cast_one] + rcases ht with ht|ht + · exact ⟨T*A,by rwa [hT],t,hact⟩ + · refine ⟨S*(T*A),by rwa [hST],t,?_⟩ + intro w + change integralComplexMatrix (rationalEmbedding (ModularGroup.S^2)*((T*A:levelTwo):SL(2,Eis))) • w=_ + rw [map_mul,mul_smul] + change rationalComplex (ModularGroup.S^2) • (integralComplexMatrix ((T*A:levelTwo):SL(2,Eis)) • w)=_ + rw [rationalComplex_S_sq_action,hact] + +end CubicEisenstein + +namespace CubicKubota +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma matrix_mul_upper_first_column (A T:SL(2,Eis)) (hT:T 1 0=0) (i:Fin 2) : + (A*T) i 0=A i 0*T 0 0 := by + simp only [Matrix.SpecialLinearGroup.coe_mul,Matrix.mul_apply,Fin.sum_univ_two,hT,mul_zero,add_zero] + +namespace CubeCuspData +variable {A:SL(2,Eis)} {p q:Eis} + +def right_upper (d:CubeCuspData A p q) (T:SL(2,Eis)) (hT:T 1 0=0) : + CubeCuspData (A*T) p q where + exponent:=d.exponent + matrix:=d.matrix*T + first:=by + simp only [matrix_mul_upper_first_column _ T hT] + linear_combination d.first*(T 0 0) + second:=by + simp only [matrix_mul_upper_first_column _ T hT] + linear_combination d.second*(T 0 0) + congruent:=by + have he:(d.matrix*T)*(A*T)⁻¹=d.matrix*A⁻¹:=by group + rw [he] + exact d.congruent + +lemma right_upper_exponent (d:CubeCuspData A p q) (T:SL(2,Eis)) (hT:T 1 0=0) : + (d.right_upper T hT).exponent=d.exponent := rfl + +lemma right_upper_character (d:CubeCuspData A p q) (T:SL(2,Eis)) (hT:T 1 0=0) : + complexCharacter ⟨(d.right_upper T hT).matrix*(A*T)⁻¹,(d.right_upper T hT).congruent⟩= + complexCharacter ⟨d.matrix*A⁻¹,d.congruent⟩ := by + apply congrArg complexCharacter + apply Subtype.ext + change (d.matrix*T)*(A*T)⁻¹=d.matrix*A⁻¹ + group + +end CubeCuspData +end CubicKubota +end + +namespace CubicEisenstein + +section + +open MeasureTheory +open scoped Classical MatrixGroups BigOperators +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubeAverage_continuous (p:Eis) (hp:p≠0) (F:HyperbolicSpace→ℂ) (hF:Continuous F) : + Continuous (cubeAverage p hp F) := by + let:Finite (Eis⧸Ideal.span {p^3}):=finite_quotient_span (pow_ne_zero 3 hp) + let:Fintype (Eis⧸Ideal.span {p^3}):=Fintype.ofFinite _ + unfold cubeAverage + simp only [tsum_fintype] + apply continuous_const.mul + apply continuous_finsetSum + intro r hr + exact hF.comp (continuous_const_smul _) + +lemma cubeAverage_cusp_integral (p:Eis) (hp:p≠0) (F:HyperbolicSpace→ℂ) (hF:Continuous F) + (M:SL(2,Eis)) (b:Eis) (v:ℝ) (hv:0⟨(3*(eisEmbedding b*z),v),hv⟩ + have hc:Continuous c:=by + apply Continuous.subtype_mk + exact (continuous_const.mul (continuous_const.mul continuous_id)).prodMk continuous_const + have hi (r:Eis⧸Ideal.span {p^3}):IntegrableOn (fun z=> + F (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) • + (integralComplexMatrix M • upperPoint (3*(eisEmbedding b*z)) v hv))) periodDomain:=by + apply periodDomain_integrable_of_continuous + have hh:=(continuous_translatedUpperCoordinates + (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r)*integralComplexMatrix M)).comp hc + simpa only [Function.comp_def,c,mul_smul] using hF.comp hh + unfold cubeAverage + simp only [tsum_fintype] + rw [integral_const_mul] + congr 1 + exact integral_finsetSum _ (fun r _=>hi r) + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups InnerProductSpace + +theorem kernelSourceProjection_variationalResolvent (F : KernelQuotientL2) : + kernelVariationalResolvent (kernelSourceProjection F)= + kernelSourceProjection (kernelVariationalResolvent F) := by + rw [kernelSourceProjection_apply,kernelSourceProjection_apply,map_smul,map_sum] + congr 1 + apply Finset.sum_congr rfl + intro q _ + exact kernelSource_variationalResolvent _ F + +theorem kernelSourceProjection_operatorGraph (F G : KernelQuotientL2) + (hFG : (F,G)∈kernelEnergyLaplacian.graph) : + (kernelSourceProjection F,kernelSourceProjection G)∈kernelEnergyLaplacian.graph := by + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] at hFG ⊢ + rw [←map_add,kernelSourceProjection_variationalResolvent,hFG] + +theorem kernelSourceProjection_eigenvector (F : KernelQuotientL2) + (eigenvalue : ℂ) (hF : (F,eigenvalue • F)∈kernelEnergyLaplacian.graph) : + (kernelSourceProjection F,eigenvalue • kernelSourceProjection F)∈kernelEnergyLaplacian.graph := by + simpa only [map_smul] using kernelSourceProjection_operatorGraph F (eigenvalue • F) hF + +theorem kernelSourceProjection_cubicEisensteinResidue_eigenvector : + (kernelSourceProjection cubicEisensteinResidue, + (8/9:ℂ) • kernelSourceProjection cubicEisensteinResidue)∈kernelEnergyLaplacian.graph := + kernelSourceProjection_eigenvector _ _ cubicEisensteinResidue_eigenvector + +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +namespace CubicEisenstein +open ConcreteTraceCRT CubicKubota EisensteinCuspModThree +local notation "O" => ActualEisensteinCubic.O + +def sourceCuspLeadingCoefficient (M : SL(2,ActualEisensteinCubic.O)) : ℂ := + sourceCuspConstant M / ((9*Real.sqrt 3/2:ℝ):ℂ) + +def sourceCuspRemainder (M : SL(2,ActualEisensteinCubic.O)) (z : ℂ) (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +lemma integralCoverDomain_projection_measurePreserving {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + MeasurePreserving (integralOrbitProjection H) + (hyperbolicVolume.restrict (integralCoverDomain H K)) (integralQuotientVolume H) := + ⟨measurable_integralOrbitProjection H,integralQuotientVolume_independent H (hHK.trans hK) _ + (integralCoverDomain_isFundamentalDomain hHK hK)⟩ + +lemma integralCoverSheet_measurePreserving (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) (q : IntegralCoverCosets H K) : + MeasurePreserving (fun w : HyperbolicSpace=>integralCoverRep H K q•w) + (hyperbolicVolume.restrict (integralCoverSheet H K q)) + (hyperbolicVolume.restrict (hyperbolicFundamentalSet K)) := + (measurePreserving_smul (integralCoverRep H K q) hyperbolicVolume).restrict_preimage + (hyperbolicFundamentalSet_measurable K) + +lemma integralCoverFiberPoint_rep_smul (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) (w : HyperbolicSpace) : + integralCoverFiberPoint H K q (integralCoverRep H K q•w)=integralOrbitProjection H w := by + rw [integralCoverFiberPoint_rep,inv_smul_smul] + +lemma integralCoverFiber_integrable {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hf : Integrable f (integralQuotientVolume H)) (q : IntegralCoverCosets H K) : + IntegrableOn (fun w=>f (integralCoverFiberPoint H K q w)) + (hyperbolicFundamentalSet K) hyperbolicVolume := by + have hD := (integralCoverDomain_projection_measurePreserving hHK hK).integrable_comp_of_integrable hf + have hS : IntegrableOn (fun w=>f (integralOrbitProjection H w)) + (integralCoverSheet H K q) hyperbolicVolume := + IntegrableOn.mono_set hD (Set.subset_iUnion (integralCoverSheet H K) q) + apply ((integralCoverSheet_measurePreserving H K q).integrable_comp + (hmeas.comp (integralCoverFiberPoint_measurable H K q)).aestronglyMeasurable).mp + simpa only [IntegrableOn,Function.comp_def,integralCoverFiberPoint_rep_smul] using hS + +theorem integralCoverTraceFunction_integrable {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hf : Integrable f (integralQuotientVolume H)) : + Integrable (integralCoverTraceFunction H K f) (integralQuotientVolume K) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + apply ((quotient_projection_measurePreserving K).integrable_comp + (integralCoverTraceFunction_measurable H K f hmeas).aestronglyMeasurable).mp + change Integrable (fun w=>∑q : IntegralCoverCosets H K,f (integralCoverFiberPoint H K q w)) _ + exact integrable_finsetSum Finset.univ (fun q _=>integralCoverFiber_integrable hHK hK f hmeas hf q) + +lemma integralCoverFiber_integral (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) (f : IntegralOrbitQuotient H→ℂ) : + (∫w in hyperbolicFundamentalSet K,f (integralCoverFiberPoint H K q w)∂hyperbolicVolume)= + ∫w in integralCoverSheet H K q,f (integralOrbitProjection H w)∂hyperbolicVolume := by + have hh := (measurePreserving_smul (integralCoverRep H K q) hyperbolicVolume).setIntegral_preimage_emb + (measurableEmbedding_const_smul (integralCoverRep H K q)) + (fun w=>f (integralCoverFiberPoint H K q w)) (hyperbolicFundamentalSet K) + simpa only [integralCoverSheet,integralCoverFiberPoint_rep_smul] using hh.symm + +theorem integralCoverTraceFunction_integral {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hf : Integrable f (integralQuotientVolume H)) : + (∫q,integralCoverTraceFunction H K f q∂integralQuotientVolume K)= + ∫q,f q∂integralQuotientVolume H := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + have hD := (integralCoverDomain_projection_measurePreserving hHK hK).integrable_comp_of_integrable hf + have hS (q : IntegralCoverCosets H K) : IntegrableOn (fun w=>f (integralOrbitProjection H w)) + (integralCoverSheet H K q) hyperbolicVolume := + IntegrableOn.mono_set hD (Set.subset_iUnion (integralCoverSheet H K) q) + rw [integralQuotientVolume_integral K _ + (integralCoverTraceFunction_measurable H K f hmeas).aestronglyMeasurable] + change (∫w in hyperbolicFundamentalSet K, + ∑q : IntegralCoverCosets H K,f (integralCoverFiberPoint H K q w)∂hyperbolicVolume)=_ + rw [integral_finsetSum Finset.univ (fun q _=>integralCoverFiber_integrable hHK hK f hmeas hf q)] + simp_rw [integralCoverFiber_integral H K] + rw [←integral_iUnion_fintype (integralCoverSheet_measurable H K) + (integralCoverSheet_pairwiseDisjoint H K hK) hS] + change (∫w in integralCoverDomain H K,f (integralOrbitProjection H w)∂hyperbolicVolume)=_ + rw [←(integralCoverDomain_projection_measurePreserving hHK hK).map_eq] + exact (integral_map (measurable_integralOrbitProjection H).aemeasurable hmeas.aestronglyMeasurable).symm + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CubeEigenrelation.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CubeEigenrelation.lean new file mode 100644 index 0000000000000000000000000000000000000000..370dddfd3c63ea221d66ab32e237b200d488000d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CubeEigenrelation.lean @@ -0,0 +1,611 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CorrespondenceEnergy + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section + +open scoped Classical MatrixGroups BigOperators +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma positive_cube_cpow_third (r:ℝ) (hr:0 ActualEisensteinCubic.O + +def cubeSourceDifference (p:Eis) (hp:p≠0) (w:HyperbolicSpace) : ℂ := + cubeAverage p hp cubicSourceResidualFunction w- + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*cubicSourceResidualFunction w + +lemma cubeSourceDifference_continuous (p:Eis) (hp:p≠0) : + Continuous (cubeSourceDifference p hp) := + (cubeAverage_continuous p hp cubicSourceResidualFunction cubicSourceResidualFunction_continuous).sub + (continuous_const.mul cubicSourceResidualFunction_continuous) + +lemma cubeSourceDifference_period_three (p:Eis) (hp:p≠0) (n:Eis) (w:HyperbolicSpace) : + cubeSourceDifference p hp (complexTranslation (3*eisEmbedding n) • w)=cubeSourceDifference p hp w := by + unfold cubeSourceDifference + rw [cubeAverage_period_three p hp cubicSourceResidualFunction cubicSource_period_three, + cubicSource_period_three] + +lemma cubeSourceDifference_period_one (p:Eis) (hp:p≠0) (hprimary:lambda^2∣p-1) (w:HyperbolicSpace) : + cubeSourceDifference p hp (complexTranslation 1 • w)=cubeSourceDifference p hp w := by + unfold cubeSourceDifference + rw [cubeAverage_period_one p hp hprimary cubicSourceResidualFunction cubicSource_period_three cubicSource_period_one, + cubicSource_period_one] + +lemma sourceCusp_period_nine (M:SL(2,Eis)) (z:ℂ) (v:ℝ) (hv:0(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3*t) + (tsum_congr (fun r:Eis⧸Ideal.span {p^3}=>cubeSource_summand_cusp_period + (actualCubeCuspData M p (GaussianShiftedPartition.representative (p^3) r) hp hprimary) hp.ne_zero z v hv n)) + exact congrArg₂ (fun a b:ℂ=>a-(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*b) + hU (sourceCusp_period_nine M z v hv (p^3*n)) + +lemma cubeSourceDifference_cusp_average_zero (M:SL(2,Eis)) (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (v:ℝ) (hv:0 inferInstance) + unfold common + infer_instance + +def toSource (K R : Subgroup G) (a : ι → G ≃* G) (i : ι) : common K R a →* R where + toFun h := ⟨a i (h : G), common_le_preimage K R a i h.property⟩ + map_one' := Subtype.ext (map_one (a i)) + map_mul' x y := Subtype.ext (map_mul (a i) (x : G) (y : G)) + +@[simp] lemma toSource_coe (K R : Subgroup G) (a : ι → G ≃* G) (i : ι) + (h : common K R a) : (toSource K R a i h : G) = a i (h : G) := rfl + +lemma toSource_injective (K R : Subgroup G) (a : ι → G ≃* G) (i : ι) : + Function.Injective (toSource K R a i) := by + intro x y hxy + apply Subtype.ext + exact (a i).injective (congrArg (fun r : R => (r : G)) hxy) + +lemma toSource_range (K R : Subgroup G) (a : ι → G ≃* G) (i : ι) : + (toSource K R a i).range = + (common K R a).comap ((a i).symm.toMonoidHom.comp R.subtype) := by + ext r + constructor + · rintro ⟨h,rfl⟩ + change (a i).symm (a i (h : G)) ∈ common K R a + simpa only [MulEquiv.symm_apply_apply] using h.property + · intro hr + refine ⟨⟨(a i).symm (r : G),hr⟩,?_⟩ + apply Subtype.ext + exact (a i).apply_symm_apply (r : G) + +instance toSource_range_finiteIndex [Finite ι] (K R : Subgroup G) (a : ι → G ≃* G) + [K.FiniteIndex] [R.FiniteIndex] (i : ι) : (toSource K R a i).range.FiniteIndex := by + rw [toSource_range] + infer_instance + +def hom (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) (i : ι) : + common K R a →* G := + lengthScale.subtype.comp (e.toMonoidHom.comp (toSource K R a i)) + +@[simp] lemma hom_apply (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) + (i : ι) (h : common K R a) : + hom K R lengthScale a e i h = (e (toSource K R a i h) : G) := rfl + +lemma hom_injective (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) (i : ι) : + Function.Injective (hom K R lengthScale a e i) := + lengthScale.subtype_injective.comp (e.injective.comp (toSource_injective K R a i)) + +def target (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) (i : ι) : Subgroup G := + (hom K R lengthScale a e i).range + +lemma target_le (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) (i : ι) : + target K R lengthScale a e i ≤ lengthScale := by + rintro x ⟨h,rfl⟩ + exact (e (toSource K R a i h)).property + +lemma target_le_common_ambient (K R lengthScale : Subgroup G) (a : ι → G ≃* G) + (e : R ≃* lengthScale) (hLK : lengthScale ≤ K) (i : ι) : target K R lengthScale a e i ≤ K := + (target_le K R lengthScale a e i).trans hLK + +lemma target_eq_map (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) (i : ι) : + target K R lengthScale a e i = ((toSource K R a i).range.map e.toMonoidHom).map lengthScale.subtype := by + rw [target,hom,MonoidHom.range_comp,MonoidHom.range_comp] + +instance target_finiteIndex [Finite ι] (K R lengthScale : Subgroup G) (a : ι → G ≃* G) + (e : R ≃* lengthScale) [K.FiniteIndex] [R.FiniteIndex] [lengthScale.FiniteIndex] (i : ι) : + (target K R lengthScale a e i).FiniteIndex := by + let : ((toSource K R a i).range.map e.toMonoidHom).FiniteIndex := + Subgroup.FiniteIndex.map_of_surjective _ e.surjective + constructor + rw [target_eq_map,Subgroup.index_map_subtype] + exact mul_ne_zero Subgroup.FiniteIndex.index_ne_zero Subgroup.FiniteIndex.index_ne_zero + +def equiv (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) (i : ι) : + common K R a ≃* target K R lengthScale a e i := + MonoidHom.ofInjective (hom_injective K R lengthScale a e i) + +@[simp] lemma equiv_coe (K R lengthScale : Subgroup G) (a : ι → G ≃* G) (e : R ≃* lengthScale) + (i : ι) (h : common K R a) : + (equiv K R lengthScale a e i h : G) = (e (toSource K R a i h) : G) := rfl + +end FiniteAutomorphismCover + +namespace CubicKubota +open scoped BigOperators Classical MatrixGroups + +open CubicEisenstein ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +lemma literalCube_zero_pair (p : ActualEisensteinCubic.O) (hp : p≠0) (x : cubeKernelCorrespondence p) : + cubeAverageMatrix p hp 0*integralComplexMatrix (cubeKernelRightGlobal p hp x)= + integralComplexMatrix (cubeKernelLeftGlobal p x)*cubeAverageMatrix p hp 0 := by + let M := cubeKernelLeftGlobal p x + let N := cubeKernelRightGlobal p hp x + let z := cubeDilationRoot p + have hz : z^2=eisEmbedding p^3 := cubeDilationRoot_sq p + have hz0 : z≠0 := cubeDilationRoot_ne_zero p hp + have he := cubeCorrespondence_entries p x.1 + change p^3*M 0 0=N 0 0*p^3 ∧ p^3*M 0 1=N 0 1 ∧ + M 1 0=N 1 0*p^3 ∧ M 1 1=N 1 1 at he + have h00 : eisEmbedding (M 0 0)=eisEmbedding (N 0 0) := + congrArg eisEmbedding (mul_left_cancel₀ (pow_ne_zero 3 hp) (he.1.trans (mul_comm _ _))) + have h01 := congrArg eisEmbedding he.2.1 + have h10 := congrArg eisEmbedding he.2.2.1 + have h11 := congrArg eisEmbedding he.2.2.2 + simp only [map_mul,map_pow] at h01 h10 + apply Matrix.SpecialLinearGroup.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp only [Matrix.SpecialLinearGroup.coe_mul,Matrix.mul_apply,Fin.sum_univ_two, + cubeAverageMatrix_entries,integralComplexMatrix_apply] + · change z⁻¹*eisEmbedding (N 0 0)+(z⁻¹*(3*eisEmbedding 0))*eisEmbedding (N 1 0)= + eisEmbedding (M 0 0)*z⁻¹+eisEmbedding (M 0 1)*0 + rw [h00,map_zero] + ring + · change z⁻¹*eisEmbedding (N 0 1)+(z⁻¹*(3*eisEmbedding 0))*eisEmbedding (N 1 1)= + eisEmbedding (M 0 0)*(z⁻¹*(3*eisEmbedding 0))+eisEmbedding (M 0 1)*z + rw [←h01,←hz,map_zero] + field_simp [hz0] + ; ring + · change 0*eisEmbedding (N 0 0)+z*eisEmbedding (N 1 0)= + eisEmbedding (M 1 0)*z⁻¹+eisEmbedding (M 1 1)*0 + rw [h10,←hz] + field_simp [hz0] + ; ring + · change 0*eisEmbedding (N 0 1)+z*eisEmbedding (N 1 1)= + eisEmbedding (M 1 0)*(z⁻¹*(3*eisEmbedding 0))+eisEmbedding (M 1 1)*z + rw [h11,map_zero] + ring + +theorem literalCube_zero_intertwines (p : ActualEisensteinCubic.O) (hp : p≠0) : + IntegralCoverIntertwines (cubeKernelRangeEquiv p hp).symm (cubeAverageMatrix p hp 0) := by + intro r + let x := (MonoidHom.ofInjective (cubeKernelRightGlobal_injective p hp)).symm r + have hr : cubeKernelRightGlobal p hp x=(r:SL(2,ActualEisensteinCubic.O)) := + MonoidHom.apply_ofInjective_symm (cubeKernelRightGlobal_injective p hp) r + change cubeAverageMatrix p hp 0*integralComplexMatrix (r:SL(2,ActualEisensteinCubic.O))= + integralComplexMatrix (cubeKernelLeftGlobal p x)*cubeAverageMatrix p hp 0 + rw [←hr] + exact literalCube_zero_pair p hp x + +lemma cubeTranslation_complex (q : ActualEisensteinCubic.O) : + integralComplexMatrix (upperTranslation q:SL(2,ActualEisensteinCubic.O))=complexTranslation (3*eisEmbedding q) := by + apply Matrix.SpecialLinearGroup.ext + intro i j + rw [integralComplexMatrix_apply] + fin_cases i <;> fin_cases j <;> simp [upperTranslation, complexTranslation, map_ofNat] + +lemma cubeAverageMatrix_factor_zero (p : ActualEisensteinCubic.O) (hp : p≠0) (q : ActualEisensteinCubic.O) : + cubeAverageMatrix p hp q=cubeAverageMatrix p hp 0* + integralComplexMatrix (upperTranslation q:SL(2,ActualEisensteinCubic.O)) := by + rw [cubeTranslation_complex] + have h0 : complexTranslation 0=1 := by + apply Matrix.SpecialLinearGroup.ext + intro i j + fin_cases i <;> fin_cases j <;> simp [complexTranslation] + simp only [cubeAverageMatrix,map_zero,mul_zero,h0,mul_one] + +theorem literalCube_summand_intertwines (p : ActualEisensteinCubic.O) (hp : p≠0) (q : ActualEisensteinCubic.O) + (A : SL(2,ActualEisensteinCubic.O)) (r : (cubeKernelRightGlobal p hp).range) + (hA : (upperTranslation q:SL(2,ActualEisensteinCubic.O))*A=(r:SL(2,ActualEisensteinCubic.O))*(upperTranslation q:SL(2,ActualEisensteinCubic.O))) : + cubeAverageMatrix p hp q*integralComplexMatrix A= + integralComplexMatrix ((cubeKernelRangeEquiv p hp).symm r:SL(2,ActualEisensteinCubic.O))*cubeAverageMatrix p hp q := by + have hAc := congrArg integralComplexMatrix hA + simp only [map_mul] at hAc + rw [cubeAverageMatrix_factor_zero,mul_assoc,hAc,←mul_assoc, + literalCube_zero_intertwines p hp r,mul_assoc] + +end CubicKubota + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups InnerProductSpace +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma integralCoverIntertwines_trans {H J K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (f : J≃*K) (g h : SL(2,ℂ)) + (he : IntegralCoverIntertwines e g) (hf : IntegralCoverIntertwines f h) : + IntegralCoverIntertwines (e.trans f) (h*g) := by + intro x + change (h*g)*integralComplexMatrix (x:SL(2,ActualEisensteinCubic.O))= + integralComplexMatrix (f (e x):SL(2,ActualEisensteinCubic.O))*(h*g) + rw [mul_assoc,he x,←mul_assoc,hf (e x),mul_assoc] + +lemma integralConjugateMap_trans {H J K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (f : J≃*K) (g h : SL(2,ℂ)) + (he : IntegralCoverIntertwines e g) (hf : IntegralCoverIntertwines f h) + (q : IntegralOrbitQuotient H) : + integralConjugateMap f h hf (integralConjugateMap e g he q)= + integralConjugateMap (e.trans f) (h*g) (integralCoverIntertwines_trans e f g h he hf) q := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection K (h•(g•w))=integralOrbitProjection K ((h*g)•w) + rw [mul_smul] + +lemma integralConjugatePullback_trans {H J K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (e : H≃*J) (f : J≃*K) (g h : SL(2,ℂ)) + (he : IntegralCoverIntertwines e g) (hf : IntegralCoverIntertwines f h) + (hH : H≤CubicKubota.levelThree) (hJ : J≤CubicKubota.levelThree) + (hK : K≤CubicKubota.levelThree) (F : IntegralQuotientL2 K) : + integralConjugatePullback e g he hH hJ (integralConjugatePullback f h hf hJ hK F)= + integralConjugatePullback (e.trans f) (h*g) (integralCoverIntertwines_trans e f g h he hf) hH hK F := by + apply Lp.ext + have hinner := (integralConjugateMap_measurePreserving e g he hH hJ).quasiMeasurePreserving.ae_eq_comp + (integralConjugatePullback_ae f h hf hJ hK F) + filter_upwards [integralConjugatePullback_ae e g he hH hJ (integralConjugatePullback f h hf hJ hK F), + hinner,integralConjugatePullback_ae (e.trans f) (h*g) + (integralCoverIntertwines_trans e f g h he hf) hH hK F] with q ho hi ht + dsimp only [Function.comp_def] at hi + rw [ho,hi,ht,integralConjugateMap_trans] + +def kernelCoverLeg {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) : + KernelQuotientL2→L[ℂ]IntegralQuotientL2 H := + (integralConjugatePullback e g he (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree)).toContinuousLinearMap.comp + (integralCoverPullback hJK globalKubotaKernel_le_levelThree) + +lemma kernelCoverLeg_representative {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (F : KernelQuotientL2) (f : KernelQuotient→ℂ) + (hrep : F=ᵐ[integralQuotientVolume globalKubotaKernel]f) : + kernelCoverLeg hHK hJK e g he F=ᵐ[integralQuotientVolume H] + fun q=>f (integralCoverMap hJK (integralConjugateMap e g he q)) := by + have hc := (integralCoverPullback_ae hJK globalKubotaKernel_le_levelThree F).trans + ((integralCoverMap_quasiMeasurePreserving hJK globalKubotaKernel_le_levelThree).ae_eq_comp hrep) + exact (integralConjugatePullback_ae e g he + (hHK.trans globalKubotaKernel_le_levelThree) (hJK.trans globalKubotaKernel_le_levelThree) _).trans + ((integralConjugateMap_measurePreserving e g he + (hHK.trans globalKubotaKernel_le_levelThree) + (hJK.trans globalKubotaKernel_le_levelThree)).quasiMeasurePreserving.ae_eq_comp hc) + +lemma kernelCoverLeg_adjoint_apply {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + (F : IntegralQuotientL2 H) : + ContinuousLinearMap.adjoint (kernelCoverLeg hHK hJK e g he) F= + integralCoverTrace hJK globalKubotaKernel_le_levelThree + (integralConjugatePullback e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) + (hJK.trans globalKubotaKernel_le_levelThree) (hHK.trans globalKubotaKernel_le_levelThree) F) := by + apply ext_inner_right ℂ + intro G + rw [ContinuousLinearMap.adjoint_inner_left] + change inner ℂ F (integralConjugatePullback e g he + (hHK.trans globalKubotaKernel_le_levelThree) (hJK.trans globalKubotaKernel_le_levelThree) + (integralCoverPullback hJK globalKubotaKernel_le_levelThree G))=_ + rw [integralConjugatePullback_pairing] + exact (ContinuousLinearMap.adjoint_inner_left (integralCoverPullback hJK globalKubotaKernel_le_levelThree) G _).symm + +theorem kernelCoverLeg_adjoint_comp {H Ji Jj : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hiK : Ji≤globalKubotaKernel) (hjK : Jj≤globalKubotaKernel) + [Ji.IsFiniteRelIndex globalKubotaKernel] [Jj.IsFiniteRelIndex globalKubotaKernel] + (ei : H≃*Ji) (ej : H≃*Jj) (gi gj : SL(2,ℂ)) + (hei : IntegralCoverIntertwines ei gi) (hej : IntegralCoverIntertwines ej gj) : + (ContinuousLinearMap.adjoint (kernelCoverLeg hHK hjK ej gj hej)).comp + (kernelCoverLeg hHK hiK ei gi hei)= + kernelCorrespondenceL2 hjK hiK (ej.symm.trans ei) (gi*gj⁻¹) + (integralCoverIntertwines_trans ej.symm ei gj⁻¹ gi + (integralCoverIntertwines_inverse ej gj hej) hei) := by + apply ContinuousLinearMap.ext + intro F + change ContinuousLinearMap.adjoint (kernelCoverLeg hHK hjK ej gj hej) + (kernelCoverLeg hHK hiK ei gi hei F)=_ + rw [kernelCoverLeg_adjoint_apply] + change integralCoverTrace hjK globalKubotaKernel_le_levelThree + (integralConjugatePullback ej.symm gj⁻¹ (integralCoverIntertwines_inverse ej gj hej) + (hjK.trans globalKubotaKernel_le_levelThree) (hHK.trans globalKubotaKernel_le_levelThree) + (integralConjugatePullback ei gi hei + (hHK.trans globalKubotaKernel_le_levelThree) (hiK.trans globalKubotaKernel_le_levelThree) + (integralCoverPullback hiK globalKubotaKernel_le_levelThree F)))=_ + rw [integralConjugatePullback_trans] + rfl + +end CubicEisenstein + +open scoped Classical MatrixGroups BigOperators + +namespace CubicKubota +open CubicEisenstein ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +abbrev CubeResidues (p : ActualEisensteinCubic.O) := ActualEisensteinCubic.O ⧸ Ideal.span {p^3} + +def cubeCommonAutomorphism (p : ActualEisensteinCubic.O) (r : CubeResidues p) : SL(2,ActualEisensteinCubic.O) ≃* SL(2,ActualEisensteinCubic.O) := + MulAut.conj (upperTranslation (GaussianShiftedPartition.representative (p^3) r):SL(2,ActualEisensteinCubic.O)) + +def cubeCommonCover (p : ActualEisensteinCubic.O) (hp : p≠0) : Subgroup (SL(2,ActualEisensteinCubic.O)) := + FiniteAutomorphismCover.common globalKubotaKernel + (cubeKernelRightGlobal p hp).range (cubeCommonAutomorphism p) + +lemma cubeCommonCover_le (p : ActualEisensteinCubic.O) (hp : p≠0) : cubeCommonCover p hp≤globalKubotaKernel := + FiniteAutomorphismCover.common_le _ _ _ + +lemma cubeCommonCover_finiteIndex (p : ActualEisensteinCubic.O) (hp : p≠0) : (cubeCommonCover p hp).FiniteIndex := by + let : globalKubotaKernel.FiniteIndex := globalKubotaKernel_finiteIndex + let : Finite (CubeResidues p) := finite_quotient_span (pow_ne_zero 3 hp) + let := (cubeKernelGlobal_finite_covers p hp).2 + exact FiniteAutomorphismCover.common_finiteIndex _ _ _ + +def cubeCommonTarget (p : ActualEisensteinCubic.O) (hp : p≠0) (r : CubeResidues p) : Subgroup (SL(2,ActualEisensteinCubic.O)) := + FiniteAutomorphismCover.target globalKubotaKernel + (cubeKernelRightGlobal p hp).range (cubeKernelLeftGlobal p).range + (cubeCommonAutomorphism p) (cubeKernelRangeEquiv p hp).symm r + +lemma cubeCommonTarget_le (p : ActualEisensteinCubic.O) (hp : p≠0) (r : CubeResidues p) : + cubeCommonTarget p hp r≤globalKubotaKernel := + FiniteAutomorphismCover.target_le_common_ambient _ _ _ _ _ (cubeKernelLeftGlobal_le p) r + +lemma cubeCommonTarget_finiteIndex (p : ActualEisensteinCubic.O) (hp : p≠0) (r : CubeResidues p) : + (cubeCommonTarget p hp r).FiniteIndex := by + let : globalKubotaKernel.FiniteIndex := globalKubotaKernel_finiteIndex + let : Finite (CubeResidues p) := finite_quotient_span (pow_ne_zero 3 hp) + let := (cubeKernelGlobal_finite_covers p hp).1 + let := (cubeKernelGlobal_finite_covers p hp).2 + exact FiniteAutomorphismCover.target_finiteIndex _ _ _ _ _ r + +def cubeCommonEquiv (p : ActualEisensteinCubic.O) (hp : p≠0) (r : CubeResidues p) : + cubeCommonCover p hp≃*cubeCommonTarget p hp r := + FiniteAutomorphismCover.equiv globalKubotaKernel + (cubeKernelRightGlobal p hp).range (cubeKernelLeftGlobal p).range + (cubeCommonAutomorphism p) (cubeKernelRangeEquiv p hp).symm r + +lemma cubeCommon_intertwines (p : ActualEisensteinCubic.O) (hp : p≠0) (r : CubeResidues p) : + IntegralCoverIntertwines (cubeCommonEquiv p hp r) + (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r)) := by + intro h + let q := GaussianShiftedPartition.representative (p^3) r + let rh := FiniteAutomorphismCover.toSource globalKubotaKernel + (cubeKernelRightGlobal p hp).range (cubeCommonAutomorphism p) r h + have hA : (upperTranslation q:SL(2,ActualEisensteinCubic.O))*(h:SL(2,ActualEisensteinCubic.O))= + (rh:SL(2,ActualEisensteinCubic.O))*(upperTranslation q:SL(2,ActualEisensteinCubic.O)) := by + change (upperTranslation q:SL(2,ActualEisensteinCubic.O))*(h:SL(2,ActualEisensteinCubic.O))= + ((upperTranslation q:SL(2,ActualEisensteinCubic.O))*(h:SL(2,ActualEisensteinCubic.O))*(upperTranslation q:SL(2,ActualEisensteinCubic.O))⁻¹)* + (upperTranslation q:SL(2,ActualEisensteinCubic.O)) + simp only [mul_assoc,inv_mul_cancel,mul_one] + exact literalCube_summand_intertwines p hp q (h:SL(2,ActualEisensteinCubic.O)) rh hA + +def cubeCommonLeg (p : ActualEisensteinCubic.O) (hp : p≠0) (r : CubeResidues p) : + KernelQuotientL2→L[ℂ]IntegralQuotientL2 (cubeCommonCover p hp) := by + letI := cubeCommonTarget_finiteIndex p hp r + letI : (cubeCommonTarget p hp r).IsFiniteRelIndex globalKubotaKernel := + Subgroup.isFiniteRelIndex_of_finiteIndex + exact kernelCoverLeg (cubeCommonCover_le p hp) (cubeCommonTarget_le p hp r) + (cubeCommonEquiv p hp r) + (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r)) + (cubeCommon_intertwines p hp r) + +end CubicKubota + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CubeResidueStrata.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CubeResidueStrata.lean new file mode 100644 index 0000000000000000000000000000000000000000..30131152abfeb423e317a3c5201150d815f95ea7 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CubeResidueStrata.lean @@ -0,0 +1,627 @@ +import OAI.NumberTheory.DirichletL.Reciprocity.PrimaryCongruences + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +local notation "O" => ActualEisensteinCubic.O +namespace SubexponentialBesselCoefficients + +theorem series_cusp_decay (coeff : SubexponentialBesselCoefficients) (a : ℝ) (ha : 0 (Real.exp_pos _).le) + have hs := summable_exp_neg_cuspFrequency_norm (Real.pi*a/2) (by positivity) + refine ⟨D*S*(2/(2*residualCuspDecayRate)),by have := residualCuspDecayRate_pos;positivity,?_⟩ + intro v z hav + have hv : 0 ?_⟩ + simpa only [fullFunction,zero_mul,zero_add,function,hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + using hbound v z hav + +end SubexponentialBesselCoefficients +end + +open scoped BigOperators Classical MatrixGroups Matrix + +section +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal GoodElement) +local notation "Eis" => ActualEisensteinCubic.O +local notation "ramLambda" => (omega-1:Eis) + +lemma halfPrimary_lambda_dvd_three : ramLambda ∣ (3:Eis) := by + exact (dvd_pow_self ramLambda (by decide : (2:ℕ)≠0)).trans lambda_sq_dvd_three + +lemma halfPrimary_lambda_not_dvd_one : ¬ramLambda ∣ (1:Eis) := by + intro h + exact PrimaryIdealUnitReindex.lambda_prime_actual.not_isUnit (isUnit_of_dvd_one h) + +lemma halfPrimary_omega_pow (j:ℕ) : ramLambda ∣ omega^j-1 := by + simpa only [one_pow] using sub_dvd_pow_sub_pow omega (1:Eis) j + +lemma halfPrimary_not_negative (j:ℕ) : ¬ramLambda ∣ -(omega^j)-1 := by + intro h + have h2 : ramLambda ∣ (2:Eis) := by + have hh:=dvd_add h (halfPrimary_omega_pow j) + convert dvd_neg.mpr hh using 1 ;ring + apply halfPrimary_lambda_not_dvd_one + convert dvd_sub halfPrimary_lambda_dvd_three h2 using 1 ;ring + +abbrev HalfPrimary := {b:Eis // ramLambda ∣ b-1} + +lemma halfPrimary_ne_zero (b:HalfPrimary) : b.val≠0 := by + intro h + apply halfPrimary_lambda_not_dvd_one + simpa only [h,zero_sub,dvd_neg] using b.2 + +lemma halfPrimary_not_dvd (b:HalfPrimary) : ¬ramLambda∣b.val := by + intro h + apply halfPrimary_lambda_not_dvd_one + convert dvd_sub h b.2 using 1 ;ring + +def halfPrimaryFromAssociate (p:Fin 3×PrimaryLower) : HalfPrimary := + ⟨omega^p.1.val*p.2.val,by + have ha:ramLambda∣p.2.val-1:=halfPrimary_lambda_dvd_three.trans p.2.2 + convert dvd_add ((halfPrimary_omega_pow p.1.val).mul_right p.2.val) ha using 1 ;ring⟩ + +lemma halfPrimaryFromAssociate_injective : Function.Injective halfPrimaryFromAssociate := by + intro p q hpq + have he:omega^p.1.val*p.2.val=omega^q.1.val*q.2.val:=congrArg Subtype.val hpq + have hunit (j:Fin 3):IsUnit (omega^j.val):=(omega_primitive.isUnit (by decide)).pow _ + have hs:(Ideal.span {p.2.val}:Ideal Eis)=Ideal.span {q.2.val}:=by + simpa only [Ideal.span_singleton_mul_left_unit (hunit p.1), + Ideal.span_singleton_mul_left_unit (hunit q.1)] using + congrArg (fun z:Eis=>(Ideal.span {z}:Ideal Eis)) he + have hab:p.2=q.2:=by + apply Subtype.ext + have hg:=congrArg primaryGenerator hs + simpa only [primaryGenerator_span p.2.val (primaryLower_ne_zero p.2) (primaryLower_primary p.2), + primaryGenerator_span q.2.val (primaryLower_ne_zero q.2) (primaryLower_primary q.2)] using hg + have hj:p.1=q.1:=by + apply Fin.ext + apply omega_primitive.pow_inj p.1.isLt q.1.isLt + rw [hab] at he + exact mul_right_cancel₀ (primaryLower_ne_zero q.2) he + exact Prod.ext hj hab + +lemma halfPrimaryFromAssociate_surjective : Function.Surjective halfPrimaryFromAssociate := by + intro b + let z:GoodElement:=⟨b.val,PrimaryIdealUnitReindex.primaryGenerator_span_ne_zero_iff b.val |>.mpr + (halfPrimary_not_dvd b)⟩ + let p:=PrimaryIdealUnitReindex.unitIdealEquiv.symm z + have he:(p.1:Eis)*primaryGenerator p.2.val=b.val:= + congrArg Subtype.val (PrimaryIdealUnitReindex.unitIdealEquiv.apply_symm_apply z) + let a:PrimaryLower:=primaryLowerIdealEquiv.symm p.2 + have ha:a.val=primaryGenerator p.2.val:=rfl + have hea:(p.1:Eis)*a.val=b.val:=by simpa only [ha] using he + have hu:ramLambda∣(p.1:Eis)-1:=by + have hpa:ramLambda∣a.val-1:=halfPrimary_lambda_dvd_three.trans a.2 + have hh:=dvd_sub b.2 (hpa.mul_left (p.1:Eis)) + rw [←hea] at hh + convert hh using 1 ;ring + obtain ⟨j,hj|hj⟩:=unit_eq_sign_omega p.1 + · exact ⟨(j,a),Subtype.ext (by simpa only [halfPrimaryFromAssociate,hj] using hea)⟩ + · exact (halfPrimary_not_negative j.val (by simpa only [hj] using hu)).elim + +def halfPrimaryAssociateEquiv : Fin 3×PrimaryLower ≃ HalfPrimary := + Equiv.ofBijective halfPrimaryFromAssociate + ⟨halfPrimaryFromAssociate_injective,halfPrimaryFromAssociate_surjective⟩ + +lemma halfPrimaryAssociateEquiv_apply (j:Fin 3) (a:PrimaryLower) : + (halfPrimaryAssociateEquiv (j,a)).val=omega^j.val*a.val:=rfl + +lemma halfPrimary_tsum (f:Eis→ℂ) : + (∑'b:HalfPrimary,f b.val)=∑'p:Fin 3×PrimaryLower,f (omega^p.1.val*p.2.val) := + halfPrimaryAssociateEquiv.tsum_eq (fun b:HalfPrimary=>f b.val) |>.symm + +end + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def unitCuspUpper (b : Eis) : SL(2,Eis) := ⟨!![1,b;0,1],by simp [Matrix.det_fin_two]⟩ +def unitCuspDiagonal (u : Eisˣ) : SL(2,Eis) := ⟨!![(u:Eis),0;0,(↑u⁻¹:Eis)],by + simp [Matrix.det_fin_two]⟩ + +theorem rational_cusp_lower_factor (u : Eisˣ) (n : ℤ) : + rationalEmbedding ModularGroup.S*unitCuspUpper (n:Eis)*lowerCuspMatrix (u:Eis)= + unitCuspDiagonal (-u)*lowerCuspMatrix (-(u:Eis)*(1+(n:Eis)*(u:Eis)))* + unitCuspUpper (↑u⁻¹:Eis) := by + apply Subtype.ext + change ((!![(0 : ℤ), -1; 1, 0]).map (Int.castRingHom Eis) * + !![1, (n : Eis); 0, 1] * !![1, 0; (u : Eis), 1]) = + (!![(↑(-u) : Eis), 0; 0, (↑(-u)⁻¹ : Eis)] * + !![1, 0; -(u : Eis) * (1 + (n : Eis) * (u : Eis)), 1] * + !![1, (↑u⁻¹ : Eis); 0, 1]) + funext i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, neg_mul, Units.val_neg, + mul_add, add_mul, mul_assoc, add_comm] + +lemma unitCuspUpper_section (b : Eis) (z : ℂ) (v : ℝ) (hv : 0 fin_cases j <;> simp [Matrix.mul_apply, Fin.sum_univ_two] + ring + +lemma unitCuspDiagonal_norm (u : Eisˣ) : + ‖eisEmbedding (u:Eis)‖=1 ∧ ‖eisEmbedding (↑u⁻¹:Eis)‖=1 := + ⟨GaussGeneratorTransport.norm_eisEmbedding_unit u, + GaussGeneratorTransport.norm_eisEmbedding_unit u⁻¹⟩ + +end CubicEisenstein + +open scoped Classical MatrixGroups +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +abbrev CubeResidueStrata (p:Eis) := Σj:Fin 4,CubicUnitResidue (p^(3-j.val)) + +def cubeResidueStratumMap (p:Eis) (x:CubeResidueStrata p) : Eis⧸Ideal.span {p^3} := + Ideal.Quotient.mk _ (p^x.1.val * GaussianShiftedPartition.representative (p^(3-x.1.val)) x.2.1) + +private lemma unit_rep_coprime (c:Eis) (x:CubicUnitResidue c) : + IsCoprime c (GaussianShiftedPartition.representative c x.1) := by + apply (isUnit_quotient_span_iff c _).mp + simpa only [GaussianShiftedPartition.representative_spec] using x.2 + +private lemma cube_strata_exponents (p:Eis) (hp:Prime p) (j k:Fin 4) + (b d:Eis) (hb:IsCoprime (p^(3-j.val)) b) + (he:p^3∣p^j.val*b-p^k.val*d) : ¬j.val ActualEisensteinCubic.O + +def cubeStratumSymbol (p C:Eis) (j:Fin 4) (b:CubicUnitResidue (p^(3-j.val))) : ℂ := + eisEmbedding (symbol (GaussianShiftedPartition.representative (p^(3-j.val)) b.1*C) (p^(3-j.val))) + +lemma unit_stratum_symbol_gauss (p C:Eis) (hp:lambda^2∣p-1) (n:ℕ) : + (∑' b:CubicUnitResidue (p^n), + eisEmbedding (symbol (GaussianShiftedPartition.representative (p^n) b.1*C) (p^n))) = + cubicUnitGaussSum 0 (p^n)*eisEmbedding (symbol C (p^n)) := by + rw [cubicUnitGaussSum] + simp only [mul_zero,residueAdditive,map_zero,cuspFrequency,zero_div,zero_mul, + AddChar.map_zero_eq_one,mul_one] + rw [←tsum_mul_right] + apply tsum_congr + intro b + rw [symbol_mul_numerator _ _ _ (primary_pow_congruence p hp n),map_mul] + +lemma cubeStratumSymbol_sum (p C:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (hC:IsCoprime C p) (j:Fin 4) : + (∑' b:CubicUnitResidue (p^(3-j.val)), cubeStratumSymbol p C j b) = + if j=0 then (Ideal.absNorm (Ideal.span {p}):ℂ)^2*((Ideal.absNorm (Ideal.span {p}):ℂ)-1) + else if j=3 then 1 else 0 := by + have h3:eisEmbedding (symbol C (p^3))=1:=by + rw [cubicSymbol_pow_denominator,symbol_cube_of_isCoprime C p hprimary hC,map_one] + unfold cubeStratumSymbol + rw [unit_stratum_symbol_gauss p C hprimary (3-j.val)] + fin_cases j + · have hh:=cubicUnitGaussSum_prime_power_zero p hp hprimary 2 + norm_num at hh ⊢ + rw [hh,h3,mul_one] + · have hh:=cubicUnitGaussSum_prime_power_zero p hp hprimary 1 + norm_num at hh ⊢ + simp [hh] + · have hh:=cubicUnitGaussSum_prime_power_zero p hp hprimary 0 + norm_num at hh ⊢ + simp [hh] + · simp + +lemma cubeStrata_weighted_sum (p C:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (hC:IsCoprime C p) (w:Fin 4→ℂ) : + (∑ j:Fin 4, w j * ∑' b:CubicUnitResidue (p^(3-j.val)), cubeStratumSymbol p C j b) = + w 0*(Ideal.absNorm (Ideal.span {p}):ℂ)^2*((Ideal.absNorm (Ideal.span {p}):ℂ)-1)+w 3 := by + simp_rw [cubeStratumSymbol_sum p C hp hprimary hC] + simp [Fin.sum_univ_succ] + ring + +end CubicEisenstein + +open scoped Classical MatrixGroups +namespace CubicKubota +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma comparison_mod_three (A N:SL(2,Eis)) (hNA:N*A⁻¹∈levelThree) (i j:Fin 2) : + (3:Eis)∣N i j-A i j := by + have hh:Matrix.SpecialLinearGroup.map (n:=Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3:Eis)})) (N*A⁻¹)=1:=hNA + rw [map_mul,map_inv] at hh + have he:=mul_inv_eq_one.mp hh + have he' :=congrArg (fun B:SL(2,Eis⧸Ideal.span {(3:Eis)})=>B i j) he + exact Ideal.mem_span_singleton.mp ((Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp he') + +lemma comparison_primary (A N:SL(2,Eis)) (hNA:N*A⁻¹∈levelThree) + (hA:lambda^2∣A 0 0-1) : lambda^2∣N 0 0-1 := by + have hh:=lambda_sq_dvd_three.trans (comparison_mod_three A N hNA 0 0) + simpa only [sub_add_sub_cancel] using dvd_add hh hA + +lemma comparison_levelTwo (A:levelTwo) (N:SL(2,Eis)) + (hNA:N*(A:SL(2,Eis))⁻¹∈levelThree) : N∈levelTwo := by + have hh:=Subgroup.mul_mem levelTwo (levelThree_le_levelTwo hNA) A.property + simpa only [inv_mul_cancel_right] using hh + +lemma levelTwo_cube_zero_phase (A N:levelTwo) (p q:Eis) + (hp:lambda^2∣p-1) + (hA:lambda^2∣((A:SL(2,Eis)) 0 0)-1) + (hN:lambda^2∣((N:SL(2,Eis)) 0 0)-1) + (hx:(A:SL(2,Eis)) 0 0+3*q*(A:SL(2,Eis)) 1 0=(N:SL(2,Eis)) 0 0) + (hc:(N:SL(2,Eis)) 1 0=p^3*(A:SL(2,Eis)) 1 0) + (hNA:(N:SL(2,Eis))*(A:SL(2,Eis))⁻¹∈levelThree) : + complexCharacter ⟨(N:SL(2,Eis))*(A:SL(2,Eis))⁻¹,hNA⟩=1 := by + have hcop:IsCoprime ((N:SL(2,Eis)) 0 0) p:=by + refine ⟨(N:SL(2,Eis)) 1 1,-(N:SL(2,Eis)) 0 1*p^2*(A:SL(2,Eis)) 1 0,?_⟩ + have hd:(N:SL(2,Eis)) 0 0*(N:SL(2,Eis)) 1 1- + (N:SL(2,Eis)) 0 1*(N:SL(2,Eis)) 1 0=1:=by + simpa only [Matrix.det_fin_two] using (N:SL(2,Eis)).property + rw [hc] at hd + linear_combination hd + have hcube:eisEmbedding (symbol ((N:SL(2,Eis)) 0 0) p)^3=1:=by + rw [←map_pow,symbol_cube_of_isCoprime _ _ hp hcop,map_one] + have hb:=levelTwo_cube_phase_balance A N p q 0 hp hA hN (by simpa using hx) (by simpa using hc) + simp only [pow_zero,mul_one,Nat.sub_zero,hcube] at hb + have hcomp:=levelTwo_comparison_character A N hNA + have hbase:levelTwoComplexCharacter A≠0:=by + intro he + have hh:=levelTwoComplexCharacter_cube A + rw [he] at hh + norm_num at hh + apply mul_right_cancel₀ hbase + rw [one_mul,hcomp,hb] + +lemma cube_exponent_zero_of_lower_divisible (A N:SL(2,Eis)) (p q:Eis) (j:ℕ) + (hp:Prime p) (hC:p∣A 1 0) + (hx:A 0 0+3*q*A 1 0=p^j*N 0 0) : j=0 := by + by_contra hj + have hpx:p∣A 0 0+3*q*A 1 0:=by + rw [hx] + exact dvd_mul_of_dvd_left (dvd_pow_self p hj) (N 0 0) + have hpa:p∣A 0 0:=by + simpa only [add_sub_cancel_right] using dvd_sub hpx (dvd_mul_of_dvd_right hC (3*q)) + have hone:p∣(1:Eis):=by + have hh:=dvd_sub (dvd_mul_of_dvd_left hpa (A 1 1)) (dvd_mul_of_dvd_right hC (A 0 1)) + have hd:A 0 0*A 1 1-A 0 1*A 1 0=1:=by + simpa only [Matrix.det_fin_two] using A.property + rwa [hd] at hh + exact hp.not_isUnit (isUnit_of_dvd_one hone) + +end CubicKubota + +namespace CubicEisenstein +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma cube_affine_coefficient_unit (p C:Eis) (hprimary:lambda^2∣p-1) (hC:IsCoprime C p) : + IsUnit (Ideal.Quotient.mk (Ideal.span {p^3}) (3*C)) := by + obtain ⟨t,ht⟩:=(three_dvd_primary_sub_one p hprimary) + have hp3:IsCoprime p (3:Eis):=by + refine ⟨1,-t,?_⟩ + linear_combination ht + apply (isUnit_quotient_span_iff _ _).mpr + exact hp3.pow_left.mul_right hC.symm.pow_left + +def cubeCuspAffineEquiv (p A C:Eis) (hprimary:lambda^2∣p-1) (hC:IsCoprime C p) : + (Eis⧸Ideal.span {p^3})≃(Eis⧸Ideal.span {p^3}) := by + let a:=Ideal.Quotient.mk (Ideal.span {p^3}) A + let u:Units (Eis⧸Ideal.span {p^3}):=(cube_affine_coefficient_unit p C hprimary hC).unit + exact { + toFun:=fun r=>a+(u:_) * r + invFun:=fun r=>(↑u⁻¹:_)*(r-a) + left_inv:=by + intro r + simp only [add_sub_cancel_left,←mul_assoc,Units.inv_mul,one_mul] + right_inv:=by + intro r + simp only [←mul_assoc,Units.mul_inv,one_mul,add_sub_cancel] } + +lemma cubeCuspAffineEquiv_apply (p A C:Eis) (hprimary:lambda^2∣p-1) (hC:IsCoprime C p) + (r:Eis⧸Ideal.span {p^3}) : + cubeCuspAffineEquiv p A C hprimary hC r= + Ideal.Quotient.mk (Ideal.span {p^3}) A+ + Ideal.Quotient.mk (Ideal.span {p^3}) (3*C)*r := by + simp only [cubeCuspAffineEquiv,IsUnit.unit_spec] + rfl + +lemma cubeCuspAffineEquiv_mk (p A C q:Eis) (hprimary:lambda^2∣p-1) (hC:IsCoprime C p) : + cubeCuspAffineEquiv p A C hprimary hC (Ideal.Quotient.mk _ q)= + Ideal.Quotient.mk (Ideal.span {p^3}) (A+3*q*C) := by + rw [cubeCuspAffineEquiv_apply] + simp only [map_add,map_mul] + ring + +end CubicEisenstein + +open scoped Classical MatrixGroups BigOperators +namespace CubicKubota +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +structure CubeCuspData (A:SL(2,Eis)) (p q:Eis) where + exponent : Fin 4 + matrix : SL(2,Eis) + first : A 0 0+3*q*A 1 0=p^exponent.val*matrix 0 0 + second : p^3*A 1 0=p^exponent.val*matrix 1 0 + congruent : matrix*A⁻¹∈levelThree + +def actualCubeCuspData (A:SL(2,Eis)) (p q:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) : + CubeCuspData A p q := by + let h:=cube_average_cusp_reduction A p q hp hprimary + let j:=Classical.choose h + have hj:j≤3:=(Classical.choose_spec h).1 + let N:=Classical.choose (Classical.choose_spec h).2 + have hN:=(Classical.choose_spec (Classical.choose_spec h).2) + exact ⟨⟨j,by omega⟩,N,hN.1,hN.2.1,hN.2.2.1⟩ + +namespace CubeCuspData +variable {A:SL(2,Eis)} {p q:Eis} + +lemma lower_eq (d:CubeCuspData A p q) (hp:p≠0) : + d.matrix 1 0=p^(3-d.exponent.val)*A 1 0 := by + apply mul_left_cancel₀ (pow_ne_zero d.exponent.val hp) + rw [←d.second,←mul_assoc,←pow_add,Nat.add_sub_of_le (by omega:d.exponent.val≤3)] + +lemma unit_top (d:CubeCuspData A p q) (hp:p≠0) : + IsUnit (Ideal.Quotient.mk (Ideal.span {p^(3-d.exponent.val)}) (d.matrix 0 0)) := by + apply (isUnit_quotient_span_iff _ _).mpr + refine ⟨-d.matrix 0 1*A 1 0,d.matrix 1 1,?_⟩ + have hd:d.matrix 0 0*d.matrix 1 1-d.matrix 0 1*d.matrix 1 0=1:=by + simpa only [Matrix.det_fin_two] using d.matrix.property + rw [d.lower_eq hp] at hd + linear_combination hd + +def stratum (d:CubeCuspData A p q) (hp:p≠0) : CubeResidueStrata p := + ⟨d.exponent,⟨Ideal.Quotient.mk _ (d.matrix 0 0),d.unit_top hp⟩⟩ + +lemma stratum_map (d:CubeCuspData A p q) (hp:p≠0) : + cubeResidueStratumMap p (d.stratum hp)= + Ideal.Quotient.mk (Ideal.span {p^3}) (A 0 0+3*q*A 1 0) := by + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + apply Ideal.mem_span_singleton.mpr + change p^3∣p^d.exponent.val*GaussianShiftedPartition.representative + (p^(3-d.exponent.val)) (Ideal.Quotient.mk _ (d.matrix 0 0))-(A 0 0+3*q*A 1 0) + rw [d.first,←mul_sub] + have hpow:p^3=p^d.exponent.val*p^(3-d.exponent.val):=by + rw [←pow_add,Nat.add_sub_of_le (by omega:d.exponent.val≤3)] + rw [hpow] + exact mul_dvd_mul_left _ (gaussRep_mk_congr _ _) + +lemma comparison_phase (A2:levelTwo) (d:CubeCuspData (A2:SL(2,Eis)) p q) + (hp:Prime p) (hprimary:lambda^2∣p-1) + (hA:lambda^2∣((A2:SL(2,Eis)) 0 0)-1) + (hC:IsCoprime ((A2:SL(2,Eis)) 1 0) p) : + complexCharacter ⟨d.matrix*(A2:SL(2,Eis))⁻¹,d.congruent⟩ = + cubeStratumSymbol p ((A2:SL(2,Eis)) 1 0) d.exponent (d.stratum hp.ne_zero).2 := by + let N2:levelTwo:=⟨d.matrix,comparison_levelTwo A2 d.matrix d.congruent⟩ + have hN:lambda^2∣d.matrix 0 0-1:=comparison_primary _ _ d.congruent hA + have he:=levelTwo_cube_comparison_phase A2 N2 p q d.exponent.val + (by omega:d.exponent.val≤3) hprimary hA hN d.first (d.lower_eq hp.ne_zero) hC d.congruent + rw [he] + unfold cubeStratumSymbol + rw [←map_pow,←cubicSymbol_pow_denominator] + apply congrArg eisEmbedding + apply symbol_congr + have hd:=gaussRep_mk_congr (p^(3-d.exponent.val)) (d.matrix 0 0) + change p^(3-d.exponent.val)∣d.matrix 0 0*((A2:SL(2,Eis)) 1 0)- + GaussianShiftedPartition.representative (p^(3-d.exponent.val)) + (Ideal.Quotient.mk _ (d.matrix 0 0))*((A2:SL(2,Eis)) 1 0) + convert dvd_mul_of_dvd_left (dvd_neg.mpr hd) ((A2:SL(2,Eis)) 1 0) using 1 ; ring + +end CubeCuspData +end CubicKubota + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspAverage.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspAverage.lean new file mode 100644 index 0000000000000000000000000000000000000000..43d6d62f242a1a8bfde01ff0a790897bb213fbe6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspAverage.lean @@ -0,0 +1,635 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.RationalTranslations + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +lemma ramified_denominator_ne_zero (s : ℂ) (hs : 12*translatedCuspFamily 0 oppositeSource 2 3 (by norm_num) (by norm_num) s) + (fun s=>((3:ℂ)^(3*s-3)-1)*baseOutgoingConstant s) + {s : ℂ | 12*translatedCuspFamily 0 oppositeSource 2 3 (by norm_num) (by norm_num) s) domain := by + intro s hs + exact analyticAt_const.mul (translatedCuspFamily_analyticAt_nonreal 0 oppositeSource 2 3 + (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne') + have hright : AnalyticOnNhd ℂ + (fun s=>((3:ℂ)^(3*s-3)-1)*baseOutgoingConstant s) domain := by + intro s hs + have hp : AnalyticAt ℂ (fun z:ℂ=>(3:ℂ)^(3*z-3)-1) s := by + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + exact Eventually.of_forall fun z=> + ((((differentiableAt_const (3:ℂ)).mul differentiableAt_id).sub_const 3).const_cpow + (Or.inl (by norm_num))).sub_const 1 + exact hp.mul (baseOutgoingConstant_analyticAt s hs.1 hs.2) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s:ℂ | 42*translatedCuspFamily 0 oppositeSource 2 3 (by norm_num) (by norm_num) s) + =ᶠ[𝓝 (5+Complex.I:ℂ)] (fun s=>((3:ℂ)^(3*s-3)-1)*baseOutgoingConstant s) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + exact opposite_zero_initial_cross s hs.1 hs.2 + exact hleft.eqOn_of_preconnected_of_eventuallyEq hright hconvex.isPreconnected hstart hevent + +theorem translatedCuspFourier_opposite_zero_residue : + translatedCuspFourier 0 oppositeSource cubicEisensteinResidue=cuspConstantAverageResidue := by + have hd : Tendsto (fun s:ℂ=>(3:ℂ)^(3*s-3)-1) (𝓝[≠] (4/3:ℂ)) (𝓝 (2:ℂ)) := by + have hc : Continuous (fun s:ℂ=>(3:ℂ)^(3*s-3)-1) := + (((continuous_const.mul continuous_id).sub continuous_const).const_cpow + (Or.inl (by norm_num))).sub continuous_const + convert hc.continuousAt.tendsto.mono_left nhdsWithin_le_nhds using 1 ; norm_num + have hl := ((translatedCuspFamily_residue_limit 0 oppositeSource 2 3 + (by norm_num) (by norm_num)).const_mul 2).comp upperVertical_tendsto_cubic_punctured + have hr := (hd.mul baseOutgoingConstant_residue_limit).comp upperVertical_tendsto_cubic_punctured + have hevent : (fun t:ℝ=>2*((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)* + translatedCuspFamily 0 oppositeSource 2 3 (by norm_num) (by norm_num) ((4/3:ℂ)+(t:ℂ)*Complex.I))) + =ᶠ[𝓝[>] (0:ℝ)] (fun t:ℝ=>((3:ℂ)^(3*((4/3:ℂ)+(t:ℂ)*Complex.I)-3)-1)* + ((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)*baseOutgoingConstant ((4/3:ℂ)+(t:ℂ)*Complex.I))) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 ActualEisensteinCubic.O + +lemma rationalComplex_conjugate (r:SL(2,ℤ)) (M:levelThree) : + complexMatrix (levelThreeConjugate (rationalEmbedding r) M)*rationalComplex r= + rationalComplex r*complexMatrix M := by + rw [←integralComplexMatrix_levelThree,←integralComplexMatrix_levelThree] + change integralComplexMatrix ((rationalEmbedding r)*(M:SL(2,Eis))*(rationalEmbedding r)⁻¹)* + integralComplexMatrix (rationalEmbedding r)= + integralComplexMatrix (rationalEmbedding r)*integralComplexMatrix (M:SL(2,Eis)) + rw [←map_mul,inv_mul_cancel_right,map_mul] + +lemma hyperbolicEisenstein_rational_automorphy (r:SL(2,ℤ)) (M:levelThree) + (s:ℂ) (hs:2(g:HyperbolicSpace)) (upperTranslation_section a z v hv).symm + rw [he,hyperbolicEisenstein_rational_automorphy r _ s hs,complexCharacter_upperTranslation,one_mul] + +lemma rationalComplex_unipotent_coe (t : ℤ) : + (rationalComplex (rationalUnipotent t) : Matrix (Fin 2) (Fin 2) ℂ) = + !![1,(t : ℂ);0,1] := by + apply Matrix.ext + intro i j + change eisEmbedding ((Int.castRingHom Eis) ((!![1,t;0,1] : Matrix (Fin 2) (Fin 2) ℤ) i j)) = _ + fin_cases i <;> fin_cases j <;> simp + +lemma rationalUnipotent_section (t:ℤ) (z:ℂ) (v:ℝ) (hv:0 fin_cases j <;> simp [Matrix.mul_apply,Fin.sum_univ_two] + all_goals ring + +lemma rationalComplex_T_pow_upper (n:ℕ) (z:ℂ) (v:ℝ) (hv:0(g:HyperbolicSpace)) (rationalUnipotent_section (n:ℤ) z v hv) + simpa only [rationalUnipotent_nat,Int.cast_natCast] using he + +theorem rational_cusp_average_right_T (r:SL(2,ℤ)) (n:ℕ) (s:ℂ) (hs:2hyperbolicEisenstein s (rationalComplex (r*ModularGroup.T^n) • w) + let g : HyperbolicSpace→ℂ := fun w=>hyperbolicEisenstein s (rationalComplex r • w) + have hf : Continuous f := (hyperbolicEisenstein_continuous s hs).comp (continuous_hyperbolic_action _) + have hg : Continuous g := (hyperbolicEisenstein_continuous s hs).comp (continuous_hyperbolic_action _) + change (∫w in cuspPeriodStrip 5 6,f w∂hyperbolicVolume)=∫w in cuspPeriodStrip 5 6,g w∂hyperbolicVolume + rw [cuspPeriodStrip_integral_coordinates f hf.aestronglyMeasurable (cuspCoordinateLift_weighted_integrable f hf), + cuspPeriodStrip_integral_coordinates g hg.aestronglyMeasurable (cuspCoordinateLift_weighted_integrable g hg)] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hv0 : 0q/(v:ℂ)^3) + simp_rw [f,g,cuspCoordinateLift_positive v _ hv0,map_mul,mul_smul,rationalComplex_T_pow_upper] + have hh:=period_integral_translation + (fun z=>hyperbolicEisenstein s (rationalComplex r • upperPoint z v hv0)) + (fun a z=>hyperbolicEisenstein_rational_periodic r a s hs z v hv0) (n:ℂ) + simpa only [add_comm] using hh + +lemma cuspFourierPhase_zero (w:HyperbolicSpace) : cuspFourierPhase (0:Eis) w=1 := by + simp [cuspFourierPhase,cuspFrequency] + +lemma kernelCuspFourier_zero (F:KernelQuotientL2) : + kernelCuspFourier (0:Eis) F=kernelCuspStripAverage F := by + rw [kernelCuspFourier_integral,kernelCuspStripAverage_hyperbolic] + simp only [cuspFourierPhase_zero,mul_one] + +theorem translatedCuspFourier_residue_eq_of_initial (M N:levelTwo) + (he : ∀s:ℂ,4 + translatedCuspFamily_analyticAt_nonreal 0 M 2 3 (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne' + have hg : AnalyticOnNhd ℂ g domain := fun s hs=> + translatedCuspFamily_analyticAt_nonreal 0 N 2 3 (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne' + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s:ℂ | 4((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*z) hv + +end + +open CubicKubota + +lemma sourceComplexMatrix_rationalLift (r:SL(2,ℤ)) : + sourceComplexMatrix (rationalLift r)=rationalComplex r := rfl + +lemma translatedCuspFourier_one_residue : + translatedCuspFourier 0 1 cubicEisensteinResidue=cuspConstantAverageResidue := by + rw [translatedCuspFourier,ContinuousLinearMap.comp_apply, + LinearIsometry.coe_toContinuousLinearMap,kernelSourcePullback_one, + kernelCuspFourier_zero,cubicEisensteinResidue_cusp_average] + +lemma translatedCuspFourier_bruhat_residue (i:RationalBruhatIndex) : + translatedCuspFourier 0 (rationalLift (rationalBruhatRep i)) cubicEisensteinResidue= + cuspConstantAverageResidue := by + rcases i with ⟨e,a|⟨a,b⟩⟩ + · calc + _=translatedCuspFourier 0 1 cubicEisensteinResidue := by + apply translatedCuspFourier_residue_eq_of_initial + intro s hs hi + simp_rw [sourceComplexMatrix_rationalLift,hyperbolicEisenstein_bruhat] + simp only [map_one,one_smul] + _=cuspConstantAverageResidue := translatedCuspFourier_one_residue + · calc + _=translatedCuspFourier 0 oppositeSource cubicEisensteinResidue := by + apply translatedCuspFourier_residue_eq_of_initial + intro s hs hi + simp_rw [sourceComplexMatrix_rationalLift,hyperbolicEisenstein_bruhat] + change (∫w in cuspPeriodStrip 5 6, + hyperbolicEisenstein s (rationalComplex ModularGroup.S • + (rationalComplex (ModularGroup.T^b.val) • w))∂hyperbolicVolume)= + ∫w in cuspPeriodStrip 5 6,hyperbolicEisenstein s (rationalComplex ModularGroup.S • w)∂hyperbolicVolume + simpa only [map_mul,mul_smul] using + rational_cusp_average_right_T ModularGroup.S b.val s (by linarith) + _=cuspConstantAverageResidue := translatedCuspFourier_opposite_zero_residue + +theorem kernelSourceProjection_residue_cusp_average : + kernelCuspStripAverage (kernelSourceProjection cubicEisensteinResidue)= + cuspConstantAverageResidue := by + rw [←kernelCuspFourier_zero,kernelSourceProjection_eq_twentyFour,map_smul,map_sum] + have he (i:RationalBruhatIndex) : + kernelCuspFourier 0 (kernelSourcePullback (rationalLift (rationalBruhatRep i)) cubicEisensteinResidue)= + cuspConstantAverageResidue := translatedCuspFourier_bruhat_residue i + simp only [he,Finset.sum_const,Finset.card_univ,Fintype.card_prod,Fintype.card_sum, + Fintype.card_fin,smul_eq_mul,nsmul_eq_mul] + norm_num + ring + +theorem kernelSourceProjection_cubicEisensteinResidue_ne_zero : + kernelSourceProjection cubicEisensteinResidue≠0 := by + intro hz + have hh:=kernelSourceProjection_residue_cusp_average + rw [hz,map_zero] at hh + exact cuspConstantAverageResidue_ne_zero hh.symm + +theorem cubicSourceResidualFunction_cusp_average : + (∫w in cuspPeriodStrip 5 6,cubicSourceResidualFunction w∂hyperbolicVolume)= + cuspConstantAverageResidue := by + rw [←kernelSourceProjection_residue_cusp_average,kernelCuspStripAverage_hyperbolic] + apply integral_congr_ae + filter_upwards [ae_restrict_of_ae cubicSourceResidualFunction_represents_projection] with w hw + exact hw.symm + +theorem cubicSourceResidualFunction_ne_zero : cubicSourceResidualFunction≠0 := by + intro hz + have he:=cubicSourceResidualFunction_cusp_average + rw [hz] at he + simp only [Pi.zero_apply,integral_zero] at he + exact cuspConstantAverageResidue_ne_zero he.symm + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +section + +lemma complex_gaussian_power_integrable (s : ℂ) (r : ℝ) + (hs : 0 (x:ℂ)^(s-1)*Complex.exp (-(r:ℂ)*(x:ℂ)^2)) + (Set.Ioi 0) volume := by + have hs2 : 0<(s/(2:ℂ)).re := by simpa using half_pos hs + have hbase : MellinConvergent (fun t : ℝ => Complex.exp (-(t:ℂ))) (s/2) := by + simpa only [MellinConvergent,smul_eq_mul,Complex.ofReal_exp,Complex.ofReal_neg,mul_comm] + using Complex.GammaIntegral_convergent hs2 + have hlinear := (MellinConvergent.comp_mul_left + (f := fun t : ℝ => Complex.exp (-(t:ℂ))) (s := s/2) hr).mpr hbase + have hgaussian := (MellinConvergent.comp_rpow + (f := fun t : ℝ => Complex.exp (-((r*t:ℝ):ℂ))) (s := s) (a := 2) + (by norm_num)).mpr hlinear + simpa only [MellinConvergent,smul_eq_mul,Real.rpow_two, + Complex.ofReal_mul,Complex.ofReal_pow,neg_mul] using hgaussian + +lemma complex_gaussian_power_integral (s : ℂ) (r : ℝ) + (hs : 0 Complex.exp (-((r*t:ℝ):ℂ))) s 2 + simp only [mellin,smul_eq_mul,Real.rpow_two,Complex.ofReal_mul, + Complex.ofReal_pow,Complex.real_smul] at he + norm_num only [Complex.ofReal_ofNat] at he + rw [Complex.integral_cpow_mul_exp_neg_mul_Ioi hs2 hr] at he + simpa [neg_mul] using he + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +def cubicMellinMixture (s : ℂ) (t x : ℝ) : ℂ := + (t:ℂ)^(-(2:ℂ)/3)*Complex.exp (-(t:ℂ))* + ((x:ℂ)^((s-1/3)-1)*Complex.exp (-((1/(4*t):ℝ):ℂ)*(x:ℂ)^2)) + +lemma cubicMellinMixture_slice_integrable (s : ℂ) (hs : 1/3 cubicMellinMixture s p.1 p.2) + ((volume.restrict (Set.Ioi 0)).prod (volume.restrict (Set.Ioi 0))) := by + have hm : AEStronglyMeasurable (fun p : ℝ × ℝ => cubicMellinMixture s p.1 p.2) + ((volume.restrict (Set.Ioi 0)).prod (volume.restrict (Set.Ioi 0))) := by + unfold cubicMellinMixture + fun_prop + apply (integrable_prod_iff hm).mpr + constructor + · filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + exact cubicMellinMixture_slice_integrable s hs t ht + · have hg := (Real.GammaIntegral_convergent + (show 0<(s.re+1/3)/2 by linarith)).const_mul + ((1/2:ℝ)*(4:ℝ)^((s.re-1/3)/2)*Real.Gamma ((s.re-1/3)/2)) + apply hg.congr + filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + rw [cubicMellinMixture_integral_norm s hs t ht] + ring + +lemma cubicMellinMixture_integral_t (s : ℂ) (x : ℝ) : + (∫t : ℝ in Set.Ioi 0,cubicMellinMixture s t x) = + (x:ℂ)^((s-1/3)-1)*schlafliIntegral (1/3) x := by + rw [schlafliIntegral,←integral_const_mul] + apply setIntegral_congr_fun measurableSet_Ioi + intro t ht + dsimp only + have ht0 : (t:ℂ)≠0 := Complex.ofReal_ne_zero.mpr (ne_of_gt ht) + have he : Complex.exp (-(t:ℂ))*Complex.exp (-((1/(4*t):ℝ):ℂ)*(x:ℂ)^2)= + Complex.exp (-(t:ℂ)-(x:ℂ)^2/(4*t)) := by + rw [←Complex.exp_add] + congr 1 + push_cast + field_simp + ring + rw [show (1/3:ℂ)-1=-(2:ℂ)/3 by ring] + unfold cubicMellinMixture + linear_combination (t:ℂ)^(-(2:ℂ)/3)*(x:ℂ)^((s-1/3)-1)*he + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +lemma schlafliBesselK_cubic_mellin_mixture (s : ℂ) (x : ℝ) (hx : 0 (x:ℂ)^(s-1)*schlafliBesselK (1/3) x) + (Set.Ioi 0) volume := by + apply ((cubicMellinMixture_integrable s hs).integral_prod_right.const_mul + ((1/2:ℂ)*(2:ℂ)^(1/3:ℂ))).congr + filter_upwards [ae_restrict_mem measurableSet_Ioi] with x hx + exact (schlafliBesselK_cubic_mellin_mixture s x hx).symm + +lemma cubicMellinMixture_double_integral (s : ℂ) (hs : 1/3 ActualEisensteinCubic.O + +def ramifiedTraceLambda : Eis := 1+2*omega + +lemma ramifiedEmbedding_traceLambda : eisEmbedding ramifiedTraceLambda=eisLam := by + change eisEmbedding (1+2*omega)=1+2*EisensteinEmbedding.omega3 + rw [map_add,map_one,map_mul,map_ofNat,eisEmbedding_omega_actual] + +lemma breveE_embedding_third_eval (A B : ℤ) : + ShortDraftTrace.breveE (eisEmbedding (ActualEisensteinCoordinates.eval A B)/3)= + eisEmbedding (cubicExp (2*A-B)) := by + have htrace : ramifiedTraceLambda=ActualEisensteinCoordinates.eval 1 2 := by + change 1+2*omega=(1:Eis)+(2:Eis)*omega + rfl + have h := breveE_real_trace_of_O (3:ℝ) + (ActualEisensteinCoordinates.eval A B*ramifiedTraceLambda) + rw [map_mul,ramifiedEmbedding_traceLambda,mul_div_cancel_right₀ _ eisLam_ne_zero] at h + rw [htrace,ActualEisensteinCoordinates.eval_mul,ShortDraftLatticeCount.coords_eval] at h + norm_num only [Complex.ofReal_ofNat] at h + rw [h,embedding_cubicExp] + congr 3 + ring_nf + +lemma primary_add_three (a r : Eis) (ha : lambda^2∣a-1) : + lambda^2∣a+3*r-1 := by + have h3 : (3:Eis)∣a-1 := three_dvd_lambda_sq.trans ha + exact lambda_sq_dvd_three.trans (by + convert dvd_add h3 (dvd_mul_right (3:Eis) r) using 1 ;ring) + +lemma symbol_omega_pow_primary_shift (j : ℕ) (a r : Eis) (ha : lambda^2∣a-1) : + eisEmbedding (symbol (omega^j) (a+3*r))= + eisEmbedding (symbol (omega^j) a)* + ShortDraftTrace.breveE ((j:ℂ)*eisEmbedding r/3) := by + obtain ⟨A,B,rfl⟩ := exists_primaryCoord a ha + let C := (ActualEisensteinCoordinates.coords r).1 + let D := (ActualEisensteinCoordinates.coords r).2 + have hr : r=ActualEisensteinCoordinates.eval C D := (ActualEisensteinCoordinates.eval_coords r).symm + have hsum : primaryCoord A B+3*r=primaryCoord (A+C) (B+D) := by + rw [hr,primaryCoord_eq,primaryCoord_eq] + change 1+3*(A:Eis)+3*(B:Eis)*omega+3*((C:Eis)+(D:Eis)*omega)=_ + push_cast + ring + rw [hsum,symbol_pow_numerator _ _ (primaryCoord_primary _ _) j, + symbol_pow_numerator _ _ (primaryCoord_primary _ _) j, + symbol_omega_eq_linearRay _ (primaryCoord_primary _ _), + symbol_omega_eq_linearRay _ (primaryCoord_primary _ _), + linearRay_primaryCoord,linearRay_primaryCoord,map_pow,map_pow] + have hp : ShortDraftTrace.breveE ((j:ℂ)*eisEmbedding r/3)= + (ShortDraftTrace.breveE (eisEmbedding r/3))^j := by + simpa only [nsmul_eq_mul,mul_div_assoc] using + AddChar.map_nsmul_eq_pow ShortDraftTrace.breveE j (eisEmbedding r/3) + rw [hp,hr,breveE_embedding_third_eval] + rw [show 2*(A+C)+(-1)*(B+D)=(2*A+(-1)*B)+(2*C-D) by ring, + cubicExp_add,map_mul,mul_pow] + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +def ninthCuspFrequency (h : Eis) : ℂ := cuspFrequency h/3 + +def unitLowerGauss (h : Eis) (u : Eisˣ) (a : Eis) : ℂ := + ∑'r:CubicUnitResidue a, + (eisEmbedding (symbol (u:Eis) (a+3*GaussianShiftedPartition.representative a r.val))* + eisEmbedding (symbol (a+3*GaussianShiftedPartition.representative a r.val) a))* + ShortDraftTrace.breveE (ninthCuspFrequency h* + eisEmbedding (a+3*GaussianShiftedPartition.representative a r.val)/eisEmbedding ((u:Eis)*a)) + +lemma unitLower_phase_identity (h a r k : Eis) (u : Eisˣ) (j : ℕ) + (ha : a≠0) (hk : 3*k=h*(↑u⁻¹:Eis)+(j:Eis)*a*ramifiedTraceLambda) : + ShortDraftTrace.breveE ((j:ℂ)*eisEmbedding r/3)* + ShortDraftTrace.breveE (ninthCuspFrequency h*eisEmbedding (a+3*r)/eisEmbedding ((u:Eis)*a))= + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))*residueAdditive (3*k) a r := by + have ha0 := eisEmbedding_ne_zero ha + have hu0 := eisEmbedding_ne_zero u.ne_zero + have hui : eisEmbedding (↑u⁻¹:Eis)=(eisEmbedding (u:Eis))⁻¹ := by + apply eq_inv_of_mul_eq_one_left + rw [←map_mul] + simp + have hk' : 3*eisEmbedding k=eisEmbedding h/(eisEmbedding (u:Eis))+ + (j:ℂ)*eisEmbedding a*eisLam := by + have he := congrArg eisEmbedding hk + simpa only [map_mul,map_add,map_ofNat,map_natCast,hui,ramifiedEmbedding_traceLambda, + div_eq_mul_inv] using he + have hkk : eisEmbedding k=(eisEmbedding h/eisEmbedding (u:Eis)+ + (j:ℂ)*eisEmbedding a*eisLam)/3 := by + apply (eq_div_iff (by norm_num : (3:ℂ)≠0)).mpr + linear_combination hk' + rw [←AddChar.map_add_eq_mul] + unfold residueAdditive + rw [←AddChar.map_add_eq_mul] + apply congrArg ShortDraftTrace.breveE + simp only [ninthCuspFrequency,cuspFrequency,map_add,map_mul,map_ofNat] + rw [hkk] + field_simp [ha0,hu0,eisLam_ne_zero] + ;ring + +lemma unitLowerGauss_factor (h a k : Eis) (u : Eisˣ) (j : ℕ) + (ha : a≠0) (hprimary : lambda^2∣a-1) (hu : (u:Eis)=omega^j) + (hk : 3*k=h*(↑u⁻¹:Eis)+(j:Eis)*a*ramifiedTraceLambda) : + unitLowerGauss h u a= + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))* + (eisEmbedding (symbol (u:Eis) a)*eisEmbedding (symbol 3 a))*cubicUnitGaussSum k a := by + rw [unitLowerGauss,cubicUnitGaussSum,←tsum_mul_left] + apply tsum_congr + intro r + let x := GaussianShiftedPartition.representative a r.val + have hchar : eisEmbedding (symbol (u:Eis) (a+3*x))= + eisEmbedding (symbol (u:Eis) a)*ShortDraftTrace.breveE ((j:ℂ)*eisEmbedding x/3) := by + rw [hu] + exact symbol_omega_pow_primary_shift j a x hprimary + have hs : symbol (a+3*x) a=symbol (3*x) a := symbol_congr ⟨1,by ring⟩ + change (eisEmbedding (symbol (u:Eis) (a+3*x))*eisEmbedding (symbol (a+3*x) a))* + ShortDraftTrace.breveE (ninthCuspFrequency h*eisEmbedding (a+3*x)/eisEmbedding ((u:Eis)*a))=_ + rw [hchar,hs,symbol_mul_numerator _ _ _ hprimary,map_mul] + have hp := unitLower_phase_identity h a x k u j ha hk + calc + _ = (eisEmbedding (symbol (u:Eis) a)*eisEmbedding (symbol 3 a)*eisEmbedding (symbol x a))* + (ShortDraftTrace.breveE ((j:ℂ)*eisEmbedding x/3)* + ShortDraftTrace.breveE (ninthCuspFrequency h*eisEmbedding (a+3*x)/eisEmbedding ((u:Eis)*a))) := by ring + _ = _ := by rw [hp];ring + +theorem unitLowerGauss_eq_unramified (h a k : Eis) (u : Eisˣ) (j : ℕ) + (ha : a≠0) (hprimary : lambda^2∣a-1) (hu : (u:Eis)=omega^j) + (hk : 3*k=h*(↑u⁻¹:Eis)+(j:Eis)*a*ramifiedTraceLambda) : + unitLowerGauss h u a= + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))* + cubicUnitGaussSum (3*h*(u:Eis)) a := by + rw [unitLowerGauss_factor h a k u j ha hprimary hu hk] + have hu3 : (u:Eis)^3=1 := by + rw [hu,←pow_mul,mul_comm j 3,pow_mul,omega_primitive.pow_eq_one,one_pow] + have hu4 : (u:Eis)^4=(u:Eis) := by + rw [show (4:ℕ)=3+1 by rfl,pow_add,hu3,pow_one,one_mul] + have hcop : IsCoprime (3*(u:Eis)^2) a := + (isCoprime_mul_unit_right_left (u.isUnit.pow 2) 3 a).mpr + (primary_coprime_three a hprimary).symm + have hphase := cubicUnitGaussSum_phase_shift k ((u:Eis)^2) a ha hprimary hcop + have hchars : eisEmbedding (symbol ((u:Eis)^2) a)*eisEmbedding (symbol (3*(u:Eis)^2) a)= + eisEmbedding (symbol (u:Eis) a)*eisEmbedding (symbol 3 a) := by + rw [←map_mul,←symbol_mul_numerator _ _ a hprimary] + rw [show (u:Eis)^2*(3*(u:Eis)^2)=3*(u:Eis)^4 by ring,hu4, + symbol_mul_numerator _ _ a hprimary,map_mul] + ring + rw [hchars] at hphase + have hcong : a∣k*(9*(u:Eis)^2)-3*h*(u:Eis) := by + refine ⟨3*(j:Eis)*ramifiedTraceLambda*(u:Eis)^2,?_⟩ + have hi : (↑u⁻¹:Eis)*(u:Eis)^2=(u:Eis) := by + rw [pow_two,←mul_assoc] + simp + have he := congrArg (fun z:Eis=>3*(u:Eis)^2*z) hk + have hi' : (u:Eis)^2*(↑u⁻¹:Eis)=(u:Eis) := by simpa only [mul_comm] using hi + linear_combination he+3*h*hi' + have hg := cubicUnitGaussSum_frequency_congr (k*(9*(u:Eis)^2)) (3*h*(u:Eis)) a ha hcong + calc + _ = ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))* + (eisEmbedding (symbol (u:Eis) a)*eisEmbedding (symbol 3 a)*cubicUnitGaussSum k a) := by ring + _ = _ := by rw [hphase,hg] + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def UnitCuspFrequency (h : Eis) (u : Eisˣ) (j : ℕ) : Prop := + (3:Eis)∣h*(↑u⁻¹:Eis)+(j:Eis)*ramifiedTraceLambda + +lemma unitCuspFrequency_lift (h a : Eis) (u : Eisˣ) (j : ℕ) + (ha : lambda^2∣a-1) (hh : UnitCuspFrequency h u j) : + ∃k:Eis,3*k=h*(↑u⁻¹:Eis)+(j:Eis)*a*ramifiedTraceLambda := by + obtain ⟨q,hq⟩ := hh + obtain ⟨r,hr⟩ := three_dvd_lambda_sq.trans ha + refine ⟨q+(j:Eis)*r*ramifiedTraceLambda,?_⟩ + linear_combination -hq-(j:Eis)*ramifiedTraceLambda*hr + +lemma unitLowerGauss_eq_unramified_of_frequency (h : Eis) (a : PrimaryLower) + (u : Eisˣ) (j : ℕ) (hu : (u:Eis)=omega^j) (hh : UnitCuspFrequency h u j) : + unitLowerGauss h u a.val= + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))* + cubicUnitGaussSum (3*h*(u:Eis)) a.val := by + obtain ⟨k,hk⟩ := unitCuspFrequency_lift h a.val u j (primaryLower_primary a) hh + exact unitLowerGauss_eq_unramified h a.val k u j (primaryLower_ne_zero a) + (primaryLower_primary a) hu hk + +def unitCuspArithmeticSeries (s : ℂ) (h : Eis) (u : Eisˣ) : ℂ := + ∑'a:PrimaryLower,((‖eisEmbedding a.val‖^2:ℝ):ℂ)^(-s)*unitLowerGauss h u a.val + +theorem unitCuspArithmeticSeries_eq (s : ℂ) (h : Eis) (u : Eisˣ) (j : ℕ) + (hu : (u:Eis)=omega^j) (hh : UnitCuspFrequency h u j) : + unitCuspArithmeticSeries s h u= + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))* + unramifiedCubicGaussSeries s (3*h*(u:Eis)) := by + rw [unitCuspArithmeticSeries,←primaryLowerIdealEquiv.symm.tsum_eq, + unramifiedCubicGaussSeries,←tsum_mul_left] + apply tsum_congr + intro I + rw [unitLowerGauss_eq_unramified_of_frequency h _ u j hu hh] + change ((‖eisEmbedding (primaryGenerator I.val)‖^2:ℝ):ℂ)^(-s)* + (ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (u:Eis))* + cubicUnitGaussSum (3*h*(u:Eis)) (primaryGenerator I.val))=_ + rw [eisEmbedding_norm_sq_eq_absNorm_span,(primaryGenerator_spec I.val I.2).1, + Complex.ofReal_natCast] + ring + +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +namespace CubicEisenstein + +lemma cuspTransition_dilate (A : ℝ) (hA : A≠0) : + cuspTransition A (2*A)=fun v => cuspTransition 1 2 (v/A) := by + funext v + unfold cuspTransition + congr 1 + field_simp + +lemma cuspTransition_dilate_deriv (A v : ℝ) (hA : A≠0) : + deriv (cuspTransition A (2*A)) v=deriv (cuspTransition 1 2) (v/A)/A := by + rw [cuspTransition_dilate A hA] + have hd := (((cuspTransition_contDiff 1 2).differentiable (by simp) (v/A)).hasDerivAt).comp v + ((hasDerivAt_id v).div_const A) + simpa [Function.comp_def,id_eq,div_eq_mul_inv] using hd.deriv + +lemma cuspTransition_dilate_second (A v : ℝ) (hA : A≠0) : + deriv (deriv (cuspTransition A (2*A))) v= + deriv (deriv (cuspTransition 1 2)) (v/A)/A^2 := by + have he : deriv (cuspTransition A (2*A))= + fun x => deriv (cuspTransition 1 2) (x/A)/A := by + funext x + exact cuspTransition_dilate_deriv A x hA + rw [he] + have hc := (contDiff_infty_iff_deriv.mp (cuspTransition_contDiff 1 2)).2 + have hd := (((hc.differentiable (by simp) (v/A)).hasDerivAt).comp v + ((hasDerivAt_id v).div_const A)).div_const A + simp only [Function.comp_def,id_eq] at hd + convert hd.deriv using 1; field_simp + +def cuspBaseDefectFactor (s : ℂ) (x : ℝ) : ℂ := + (x:ℂ)^2*(deriv (deriv (cuspTransition 1 2)) x:ℝ)+ + (2*s-1)*(x:ℂ)*(deriv (cuspTransition 1 2) x:ℝ) + +lemma cuspBaseDefectFactor_continuous (s : ℂ) : Continuous (cuspBaseDefectFactor s) := by + have h1 := (contDiff_infty_iff_deriv.mp (cuspTransition_contDiff 1 2)).2 + have h2 := (contDiff_infty_iff_deriv.mp h1).2 + unfold cuspBaseDefectFactor + exact ((Complex.continuous_ofReal.pow 2).mul (Complex.continuous_ofReal.comp h2.continuous)).add + ((continuous_const.mul Complex.continuous_ofReal).mul (Complex.continuous_ofReal.comp h1.continuous)) + +lemma cuspBaseDefectFactor_compact (s : ℂ) : HasCompactSupport (cuspBaseDefectFactor s) := by + apply HasCompactSupport.of_support_subset_isCompact (isCompact_Icc : IsCompact (Set.Icc (1:ℝ) 2)) + intro x hx + by_contra hn + have hout : x<1 ∨ 2 ?_⟩ + have hApos : 0.mpr hv.2) hC + _ = (4*C)*A^2 := by ring + · have hout : v cuspCutoffCorrection_norm_le _ _ (by positivity) (hbound A hA) w⟩ + +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace + +lemma movingDefect_product_bound + (f : KernelQuotient→ℂ) (K C : ℝ) (hK : 0≤K) (hC : 0≤C) + (hdec : ∀w : HyperbolicSpace, ∀r : CuspCosets,1 + change ‖f (integralOrbitProjection globalKubotaKernel w)‖* + ‖smoothCuspSeedDefect A (2*A) (4/3) w‖≤_ + have hApos : 0 + intro hr + change 1 ActualEisensteinCubic.O + +lemma exists_congruent_cusp_completion (A : SL(2,Eis)) (x y : Eis) + (hxy : IsCoprime x y) (hx : (3:Eis)∣x-A 0 0) (hy : (3:Eis)∣y-A 1 0) : + ∃ N : SL(2,Eis), N 0 0=x ∧ N 1 0=y ∧ N*A⁻¹∈levelThree := by + obtain ⟨u,v,huv⟩ := hxy + let t := u*A 0 1+v*A 1 1 + let N : SL(2,Eis) := ⟨!![x,-v+x*t;y,u+y*t],by + rw [Matrix.det_fin_two_of] + linear_combination huv⟩ + have hd : A 0 0*A 1 1-A 0 1*A 1 0=1 := by + simpa only [Matrix.det_fin_two] using A.property + have hr : (3:Eis)∣1+y*A 0 1-x*A 1 1 := by + convert dvd_sub (dvd_mul_of_dvd_left hy (A 0 1)) + (dvd_mul_of_dvd_left hx (A 1 1)) using 1 ; linear_combination -hd + have hmod : ∀i j,(3:Eis)∣N i j-A i j := by + intro i j + fin_cases i <;> fin_cases j + · exact hx + · have hv := dvd_mul_of_dvd_left hr (-v) + convert hv using 1 ; dsimp [N,t] ; linear_combination (A 0 1)*huv + · exact hy + · have hu := dvd_mul_of_dvd_left hr u + convert hu using 1 ; dsimp [N,t] ; linear_combination (A 1 1)*huv + have hq : Matrix.SpecialLinearGroup.map (n:=Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3:Eis)})) N = + Matrix.SpecialLinearGroup.map (n:=Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3:Eis)})) A := by + apply Matrix.SpecialLinearGroup.ext + intro i j + exact (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + (Ideal.mem_span_singleton.mpr (hmod i j)) + refine ⟨N,rfl,rfl,?_⟩ + change Matrix.SpecialLinearGroup.map (n:=Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3:Eis)})) (N*A⁻¹)=1 + rw [map_mul,map_inv,hq,mul_inv_cancel] + +lemma cusp_completion_upper_factor (A N : SL(2,Eis)) (q g x y : Eis) + (hx : A 0 0+3*q*A 1 0=g*N 0 0) (hy : x*A 1 0=g*N 1 0) + (hg : g≠0) (hdet : x=g*y) : + N.val⁻¹ * (!![1,3*q;0,x] * A.val) = + !![g,(N.val⁻¹ * (!![1,3*q;0,x] * A.val)) 0 1;0,y] := by + have hNdet : N 0 0*N 1 1-N 0 1*N 1 0=1 := by + simpa only [Matrix.det_fin_two] using N.property + have hAdet : A 0 0*A 1 1-A 0 1*A 1 0=1 := by + simpa only [Matrix.det_fin_two] using A.property + have hinv : N.val⁻¹ = !![N 1 1,-N 0 1;-N 1 0,N 0 0] := by + rw [Matrix.inv_def,Matrix.SpecialLinearGroup.det_coe,Ring.inverse_one,one_smul,Matrix.adjugate_fin_two] + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j + · norm_num [hinv,Matrix.mul_apply,Matrix.vecMul,dotProduct,Fin.sum_univ_two] + rw [hx,hy] + linear_combination g*hNdet + · rfl + · norm_num [hinv,Matrix.mul_apply,Matrix.vecMul,dotProduct,Fin.sum_univ_two] + rw [hx,hy] + ring + · norm_num [hinv,Matrix.mul_apply,Matrix.vecMul,dotProduct,Fin.sum_univ_two] + apply mul_left_cancel₀ hg + linear_combination x*hAdet-x*(A 1 1)*hx+(A 0 1+3*q*A 1 1)*hy+hdet + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +private lemma bounded_power_factor (p a : Eis) (n : ℕ) : + ∃ j≤n,∃b,a=p^j*b ∧ (j=n ∨ ¬p∣b) := by + induction n generalizing a with + | zero => exact ⟨0,le_rfl,a,by simp,Or.inl rfl⟩ + | succ n ih => + by_cases h:p∣a + · obtain ⟨a',rfl⟩:=h + obtain ⟨j,hj,b,hab,hb⟩:=ih a' + refine ⟨j+1,Nat.succ_le_succ hj,b,?_,?_⟩ + · rw [hab,pow_succ] + ring + · exact hb.elim (fun h=>Or.inl (congrArg (fun k=>k+1) h)) Or.inr + · exact ⟨0,Nat.zero_le _,a,by simp,Or.inr h⟩ + +lemma cube_average_cusp_reduction (A : SL(2,Eis)) (p q : Eis) + (hp : Prime p) (hprimary : lambda^2∣p-1) : + ∃ j≤3,∃N : SL(2,Eis), + A 0 0+3*q*A 1 0=p^j*N 0 0 ∧ + p^3*A 1 0=p^j*N 1 0 ∧ N*A⁻¹∈levelThree ∧ + (j=3 ∨ ¬p∣N 0 0) ∧ + N.val⁻¹*(!![1,3*q;0,p^3]*A.val)= + !![p^j,(N.val⁻¹*(!![1,3*q;0,p^3]*A.val)) 0 1;0,p^(3-j)] := by + let a:=A 0 0+3*q*A 1 0 + have haC:IsCoprime a (A 1 0) := by + have hd : A 0 0*A 1 1-A 0 1*A 1 0=1 := by + simpa only [Matrix.det_fin_two] using A.property + refine ⟨A 1 1,-(A 0 1+3*q*A 1 1),?_⟩ + dsimp [a] + linear_combination hd + obtain ⟨j,hj,b,hab,hb⟩:=bounded_power_factor p a 3 + have hbC:IsCoprime b (A 1 0) := by + rw [hab] at haC + exact haC.of_mul_left_right + have hbY:IsCoprime b (p^(3-j)*A 1 0) := by + rcases hb with h | h + · simpa [h] using hbC + · exact ((hp.coprime_iff_not_dvd.mpr h).symm.pow_right).mul_right hbC + have hpow (k:ℕ):(3:Eis)∣p^k-1 := by + have hd:(3:Eis)∣p-1:=CubicJacobiGlobal.three_dvd_primary_sub_one p hprimary + simpa using hd.trans (sub_dvd_pow_sub_pow p 1 k) + have hbA:(3:Eis)∣b-A 0 0 := by + have h1:(3:Eis)∣a-A 0 0:=by + refine ⟨q*A 1 0,?_⟩ + dsimp [a] + ring + have h2:(3:Eis)∣a-b:=by + rw [hab] + convert dvd_mul_of_dvd_left (hpow j) b using 1 ; ring + convert dvd_sub h1 h2 using 1 ; ring + have hyC:(3:Eis)∣p^(3-j)*A 1 0-A 1 0 := by + convert dvd_mul_of_dvd_left (hpow (3-j)) (A 1 0) using 1 ; ring + obtain ⟨N,hN0,hN1,hNA⟩:=exists_congruent_cusp_completion A b (p^(3-j)*A 1 0) hbY hbA hyC + have hA:a=p^j*N 0 0:=by rw [hN0];exact hab + have hC:p^3*A 1 0=p^j*N 1 0:=by + rw [hN1,←mul_assoc,←pow_add,Nat.add_sub_of_le hj] + refine ⟨j,hj,N,hA,hC,hNA,?_,?_⟩ + · simpa [hN0] using hb + · exact cusp_completion_upper_factor A N q (p^j) (p^3) (p^(3-j)) + hA hC (pow_ne_zero j hp.ne_zero) (by rw [←pow_add,Nat.add_sub_of_le hj]) + +end CubicKubota + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspHeight.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspHeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..c49a8fe267d1a63e35e66c2c798882e23c825339 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspHeight.lean @@ -0,0 +1,654 @@ +import OAI.NumberTheory.DirichletL.GaussSum.ReflectedBranches + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold + +lemma kernelCompact_smooth_cutoff (K : Set KernelQuotient) (hK : IsCompact K) : + ∃χ : KernelQuotient→ℝ,ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℝ) ∞ χ ∧ + HasCompactSupport χ ∧ (∀q∈K,χ=ᶠ[𝓝 q](fun _ => 1)) ∧ ∀q,χ q∈Set.Icc 0 1 := by + obtain ⟨J,hJ,hKJ⟩ := exists_compact_superset hK + obtain ⟨χ,hχone,hχzero,hχrange⟩ := exists_contMDiffMap_one_nhds_of_subset_interior + 𝓘(ℝ,SpatialCoordinates) hK.isClosed hKJ (n := (⊤ : ℕ∞)) + refine ⟨χ,χ.contMDiff,?_,?_,hχrange⟩ + · apply HasCompactSupport.of_support_subset_isCompact hJ + intro q hq + by_contra hn + exact hq (hχzero q hn) + · intro q hq + exact hχone.filter_mono (nhds_le_nhdsSet hq) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +lemma integral_upper_triangular_height_all (M : SL(2,ActualEisensteinCubic.O)) + (hc : M 1 0=0) (w : HyperbolicSpace) : + hyperbolicHeight (integralComplexMatrix M • w)=hyperbolicHeight w := by + obtain ⟨z,v,hv,rfl⟩ := upperPoint_surjective w + rw [integral_upper_triangular_height M hc,hyperbolicHeight_upperPoint] + +def fullMatrixHeight (M : SL(2,ActualEisensteinCubic.O)) (w : HyperbolicSpace) : ℝ := + hyperbolicHeight (integralComplexMatrix M • w) + +def fullCuspHeightRelation : Setoid (SL(2,ActualEisensteinCubic.O)) := Setoid.ker fullMatrixHeight +abbrev FullCuspClasses := Quotient fullCuspHeightRelation + +def fullCuspOf (M : SL(2,ActualEisensteinCubic.O)) : FullCuspClasses := Quotient.mk _ M + +def fullCuspHeight : FullCuspClasses→HyperbolicSpace→ℝ := + Quotient.lift fullMatrixHeight (fun _ _ h => h) + +lemma fullCuspHeight_of (M : SL(2,ActualEisensteinCubic.O)) (w : HyperbolicSpace) : + fullCuspHeight (fullCuspOf M) w=fullMatrixHeight M w := rfl + +lemma fullCuspHeight_continuous (x : FullCuspClasses) : Continuous (fullCuspHeight x) := by + induction x using Quotient.inductionOn with + | _ M => exact hyperbolicHeight_continuous.comp (continuous_hyperbolic_action (integralComplexMatrix M)) + +lemma fullMatrixHeight_eq_of_lower_zero (M N : SL(2,ActualEisensteinCubic.O)) + (h : (M*N⁻¹) 1 0=0) : fullMatrixHeight M=fullMatrixHeight N := by + funext w + have hh := integral_upper_triangular_height_all (M*N⁻¹) h (integralComplexMatrix N • w) + simpa only [fullMatrixHeight,map_mul,map_inv,mul_smul,inv_smul_smul] using hh + +lemma fullCuspOf_eq_iff (M N : SL(2,ActualEisensteinCubic.O)) : + fullCuspOf M=fullCuspOf N ↔ (M*N⁻¹) 1 0=0 := by + constructor + · intro h + by_contra hc + have he : fullMatrixHeight M=fullMatrixHeight N := Quotient.exact h + let w := upperPoint 0 2 (by norm_num : (0:ℝ)<2) + have hh := congrFun he (integralComplexMatrix N⁻¹ • w) + have hp := integral_hyperbolicHeight_mul_le_one (M*N⁻¹) hc w + have hN : hyperbolicHeight w=2 := hyperbolicHeight_upperPoint _ _ _ + change hyperbolicHeight (integralComplexMatrix M • (integralComplexMatrix N⁻¹ • w))= + hyperbolicHeight (integralComplexMatrix N • (integralComplexMatrix N⁻¹ • w)) at hh + simp only [map_inv,smul_inv_smul] at hh + simp only [map_mul,map_inv,mul_smul] at hp + rw [hh,hN] at hp + norm_num at hp + · intro h + exact Quotient.sound (fullMatrixHeight_eq_of_lower_zero M N h) + +def fullCuspTranslate (M : SL(2,ActualEisensteinCubic.O)) : FullCuspClasses→FullCuspClasses := + Quotient.map (fun N => N*M) (by + intro N P h + change fullMatrixHeight (N*M)=fullMatrixHeight (P*M) + funext w + have hh := congrFun h (integralComplexMatrix M • w) + simpa only [fullMatrixHeight,map_mul,mul_smul] using hh) + +lemma fullCuspTranslate_mul (M N : SL(2,ActualEisensteinCubic.O)) (x : FullCuspClasses) : + fullCuspTranslate N (fullCuspTranslate M x)=fullCuspTranslate (M*N) x := by + induction x using Quotient.inductionOn with + | _ P => change fullCuspOf ((P*M)*N)=fullCuspOf (P*(M*N)); rw [mul_assoc] + +lemma fullCuspTranslate_one (x : FullCuspClasses) : fullCuspTranslate 1 x=x := by + induction x using Quotient.inductionOn with + | _ P => change fullCuspOf (P*1)=fullCuspOf P; rw [mul_one] + +def fullCuspRightEquiv (M : SL(2,ActualEisensteinCubic.O)) : FullCuspClasses≃FullCuspClasses where + toFun := fullCuspTranslate M + invFun := fullCuspTranslate M⁻¹ + left_inv x := by rw [fullCuspTranslate_mul,mul_inv_cancel,fullCuspTranslate_one] + right_inv x := by rw [fullCuspTranslate_mul,inv_mul_cancel,fullCuspTranslate_one] + +lemma fullCuspHeight_translate (M : SL(2,ActualEisensteinCubic.O)) (x : FullCuspClasses) + (w : HyperbolicSpace) : + fullCuspHeight (fullCuspRightEquiv M x) w=fullCuspHeight x (integralComplexMatrix M • w) := by + induction x using Quotient.inductionOn with + | _ N => change fullMatrixHeight (N*M) w=fullMatrixHeight N (integralComplexMatrix M • w) + simp only [fullMatrixHeight,map_mul,mul_smul] + +lemma fullCuspHeight_high_unique (w : HyperbolicSpace) (x y : FullCuspClasses) + (hx : 1 + induction y using Quotient.inductionOn with + | _ N => + apply (fullCuspOf_eq_iff M N).mpr + by_contra hc + have hp := integral_hyperbolicHeight_mul_le_one (M*N⁻¹) hc (integralComplexMatrix N • w) + simp only [map_mul,map_inv,mul_smul,inv_smul_smul] at hp + change 1 F (fullCuspHeight x w)) := by + have hs : Set.Subsingleton {x : FullCuspClasses | 1 fullCuspHeight_high_unique w x y hx hy + apply hs.finite.subset + intro x hx + by_contra hn + exact hx (hF _ (le_of_not_gt hn)) + +def fullCuspProfileSum (F : ℝ→ℝ) (w : HyperbolicSpace) : ℝ := + ∑'x : FullCuspClasses,F (fullCuspHeight x w) + +lemma fullCuspProfileSum_summable (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) (w : HyperbolicSpace) : + Summable (fun x : FullCuspClasses => F (fullCuspHeight x w)) := + summable_of_hasFiniteSupport (fullCusp_profile_finite F hF w) + +lemma fullCuspProfileSum_invariant (F : ℝ→ℝ) (M : SL(2,ActualEisensteinCubic.O)) (w : HyperbolicSpace) : + fullCuspProfileSum F (integralComplexMatrix M • w)=fullCuspProfileSum F w := by + unfold fullCuspProfileSum + simp only [←fullCuspHeight_translate M] + exact (fullCuspRightEquiv M).tsum_eq (fun x : FullCuspClasses => F (fullCuspHeight x w)) + +lemma fullCuspProfileSum_eq_single (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) + (w : HyperbolicSpace) (x : FullCuspClasses) (hx : 1 cuspBarrierProfile a b (fullCuspHeight x w)) := + fullCuspProfileSum_summable _ (fun v hv => cuspBarrierProfile_zero a b hab v (hv.trans ha)) w + +lemma cuspBarrier_one_le (a b : ℝ) (ha : 1≤a) (hab : a cuspBarrierProfile_nonneg a b ha hab _)) + +lemma cuspBarrier_invariant (a b : ℝ) (M : SL(2,ActualEisensteinCubic.O)) (w : HyperbolicSpace) : + cuspBarrier a b (integralComplexMatrix M • w)=cuspBarrier a b w := by + rw [cuspBarrier,cuspBarrier,fullCuspProfileSum_invariant] + +theorem cuspBarrier_high (a b : ℝ) (ha : 1≤a) (hab : a cuspBarrierProfile_zero a b hab y (hy.trans ha)) _ (fullCuspOf 1) + (by rw [hx]; linarith),hx,cuspBarrierProfile,cuspTransition_one a b v hab hbv.le,one_mul] + ring + +def kernelQuotientBarrier (a b : ℝ) : KernelQuotient→ℝ := + Quotient.lift (cuspBarrier a b) (by + rintro w u ⟨M,hM⟩ + rw [←hM] + exact (cuspBarrier_invariant a b (M:SL(2,ActualEisensteinCubic.O)) w).symm) + +lemma kernelQuotientBarrier_one_le (a b : ℝ) (ha : 1≤a) (hab : a exact cuspBarrier_one_le a b ha hab w + +lemma kernelQuotientBarrier_fordCusp (a b : ℝ) (ha : 1≤a) (hab : a fullCuspOf ((N:SL(2,ActualEisensteinCubic.O))*r⁻¹)) (by + intro N P h + apply Quotient.sound + funext w + have he : cosetOf N=cosetOf P := Quotient.sound h + have hh := congrArg (fun x => cosetHeight x (integralComplexMatrix r⁻¹ • w)) he + simpa only [cosetHeight_cosetOf,fullMatrixHeight,map_mul,mul_smul,integralComplexMatrix_levelThree] using hh) + +lemma fullCuspFromPrincipal_height (r : SL(2,ActualEisensteinCubic.O)) (x : CuspCosets) + (w : HyperbolicSpace) : + fullCuspHeight (fullCuspFromPrincipal r x) w=cosetHeight x (integralComplexMatrix r⁻¹ • w) := by + induction x using Quotient.inductionOn with + | _ N => + change fullMatrixHeight ((N:SL(2,ActualEisensteinCubic.O))*r⁻¹) w=cosetHeight (cosetOf N) _ + simp only [fullMatrixHeight,cosetHeight_cosetOf,map_mul,mul_smul,integralComplexMatrix_levelThree] + +lemma fullCusp_finite_principal_cover : + ∃S : Finset (SL(2,ActualEisensteinCubic.O)),∀x : FullCuspClasses, + ∃r∈S,∃y : CuspCosets,fullCuspFromPrincipal r y=x := by + let : CubicKubota.levelThree.FiniteIndex := levelThree_finiteIndex + obtain ⟨S,hS⟩ := finite_right_representatives CubicKubota.levelThree + refine ⟨S,fun x => ?_⟩ + induction x using Quotient.inductionOn with + | _ M => + obtain ⟨r,hr,hM⟩ := hS M⁻¹ + have hm : M*r∈CubicKubota.levelThree := by + simpa only [mul_inv_rev,inv_inv] using CubicKubota.levelThree.inv_mem hM + refine ⟨r,hr,cosetOf ⟨M*r,hm⟩,?_⟩ + change fullCuspOf ((M*r)*r⁻¹)=fullCuspOf M + rw [mul_inv_cancel_right] + +lemma full_high_locally_finite (w : HyperbolicSpace) : + ∃U : Set HyperbolicSpace,IsOpen U ∧ w∈U ∧ ∃T : Finset FullCuspClasses, + ∀z∈U,∀x∉T,fullCuspHeight x z<1 := by + obtain ⟨S,hS⟩ := fullCusp_finite_principal_cover + choose U hU hw T hT using fun r : S => principal_high_locally_finite (integralComplexMatrix r.1⁻¹ • w) + let V : Set HyperbolicSpace := ⋂r : S,(fun z => integralComplexMatrix r.1⁻¹ • z) ⁻¹' U r + let B : Finset FullCuspClasses := Finset.univ.biUnion (fun r : S => (T r).image (fullCuspFromPrincipal r.1)) + refine ⟨V,isOpen_iInter_of_finite (fun r => (hU r).preimage (continuous_hyperbolic_action _)),?_,B,?_⟩ + · exact Set.mem_iInter.mpr hw + · intro z hz x hx + obtain ⟨r,hr,y,hxy⟩ := hS x + let i : S := ⟨r,hr⟩ + have hy : y∉T i := by + intro hy + apply hx + exact Finset.mem_biUnion.mpr ⟨i,Finset.mem_univ _,Finset.mem_image.mpr ⟨y,hy,hxy⟩⟩ + rw [←hxy,fullCuspFromPrincipal_height] + exact hT i _ (Set.mem_iInter.mp hz i) y hy + +lemma fullCuspProfileSum_locally_finite (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) (w : HyperbolicSpace) : + ∃T : Finset FullCuspClasses,fullCuspProfileSum F =ᶠ[𝓝 w] + (fun z => ∑x∈T,F (fullCuspHeight x z)) := by + obtain ⟨U,hU,hw,T,hT⟩ := full_high_locally_finite w + refine ⟨T,?_⟩ + filter_upwards [hU.mem_nhds hw] with z hz + apply tsum_eq_sum + intro x hx + exact hF _ (hT z hz x hx).le + +lemma fullCuspProfileSum_continuous (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) (hFc : Continuous F) : + Continuous (fullCuspProfileSum F) := by + rw [continuous_iff_continuousAt] + intro w + obtain ⟨T,hT⟩ := fullCuspProfileSum_locally_finite F hF w + apply ContinuousAt.congr _ hT.symm + exact (continuous_finsetSum T (fun x hx => hFc.comp (fullCuspHeight_continuous x))).continuousAt + +lemma cuspBarrier_continuous (a b : ℝ) (ha : 1≤a) (hab : a cuspBarrierProfile_zero a b hab v (hv.trans ha)) (cuspBarrierProfile_smooth a b).continuous) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold MatrixGroups + +lemma fullCuspHeight_chart_contDiffAt (x : FullCuspClasses) (p : SpatialCoordinates) + (hp : p∈hyperbolicSpatialChart.target) : + ContDiffAt ℝ ∞ (fun q => fullCuspHeight x (hyperbolicSpatialChart.symm q)) p := by + induction x using Quotient.inductionOn with + | _ M => + have hh : ContDiffAt ℝ ∞ (fun q => mobiusSpatial (integralComplexMatrix M) q 2) p := + (contDiff_apply ℝ ℝ 2).contDiffAt.comp p + (mobiusSpatial_contDiffAt _ p (hyperbolicSpatialChart_target_positive hp)) + apply hh.congr_of_eventuallyEq + filter_upwards [hyperbolicSpatialChart.open_target.mem_nhds hp] with q hq + rw [hyperbolicSpatialChart_symm_eq hq] + exact congrArg (fun r : SpatialCoordinates => r 2) + (mobiusSpatial_coordinates (integralComplexMatrix M) q + (hyperbolicSpatialChart_target_positive hq)) + +lemma fullCuspProfileSum_chart_contDiffAt (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) + (hFc : ContDiff ℝ ∞ F) (p : SpatialCoordinates) (hp : p∈hyperbolicSpatialChart.target) : + ContDiffAt ℝ ∞ (fun q => fullCuspProfileSum F (hyperbolicSpatialChart.symm q)) p := by + obtain ⟨T,hT⟩ := fullCuspProfileSum_locally_finite F hF (hyperbolicSpatialChart.symm p) + have hc := hyperbolicSpatialChart.continuousAt_symm hp + have he := hT.comp_tendsto hc + apply ContDiffAt.congr_of_eventuallyEq _ he + exact ContDiffAt.sum (fun x hx => hFc.contDiffAt.comp p + (fullCuspHeight_chart_contDiffAt x p hp)) + +lemma cuspBarrier_chart_contDiffAt (a b : ℝ) (ha : 1≤a) (hab : a cuspBarrier a b (hyperbolicSpatialChart.symm q)) p := + contDiffAt_const.add (fullCuspProfileSum_chart_contDiffAt _ + (fun v hv => cuspBarrierProfile_zero a b hab v (hv.trans ha)) + (cuspBarrierProfile_smooth a b) p hp) + +lemma kernelQuotientBarrier_continuous (a b : ℝ) (ha : 1≤a) (hab : a kernelQuotientBarrier a b ((kernelQuotientChart q).symm p))= + (fun p => cuspBarrier a b (hyperbolicSpatialChart.symm p)) := by + funext p + rw [kernelQuotientChart_symm] + rfl + have hh' := (he.symm ▸ hh).contDiffWithinAt (s := Set.univ) + simpa only [extChartAt_coe,extChartAt_coe_symm,modelWithCornersSelf_coe, + modelWithCornersSelf_coe_symm,Function.id_comp,Function.comp_id,Set.range_id, + chartAt_self_eq,kernelSpatial_chartAt,OpenPartialHomeomorph.refl_apply,Function.comp_def,id_eq] using hh' + +lemma cuspBarrier_euclidean_contDiffAt (a b : ℝ) (ha : 1≤a) (hab : a cuspBarrier a b (euclideanToHyperbolic q)) p := + (((kernelQuotientBarrier_contMDiff a b ha hab).comp kernelProjection_contMDiff) + (euclideanToHyperbolic p) |>.comp p (euclideanToHyperbolic_contMDiffAt p hp)).contDiffAt + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff MatrixGroups + +def positiveHeightLaplacian (F : ℝ→ℝ) (v : ℝ) : ℝ := + v*deriv F v-v^2*deriv (deriv F) v + +def cuspBarrierDefectProfile (a b v : ℝ) : ℝ := + positiveHeightLaplacian (cuspBarrierProfile a b) v-cuspBarrierProfile a b v + +lemma positiveHeightLaplacian_smooth (F : ℝ→ℝ) (hF : ContDiff ℝ ∞ F) : + ContDiff ℝ ∞ (positiveHeightLaplacian F) := by + have hD : ContDiff ℝ ∞ (deriv F) := (contDiff_infty_iff_deriv.mp hF).2 + exact (contDiff_id.mul hD).sub ((contDiff_id.pow 2).mul ((contDiff_infty_iff_deriv.mp hD).2)) + +lemma cuspBarrierDefectProfile_smooth (a b : ℝ) : + ContDiff ℝ ∞ (cuspBarrierDefectProfile a b) := + (positiveHeightLaplacian_smooth _ (cuspBarrierProfile_smooth a b)).sub + (cuspBarrierProfile_smooth a b) + +lemma cuspBarrierDefectProfile_zero (a b v : ℝ) (hab : a (0:ℝ)) := by + filter_upwards [Iio_mem_nhds hv] with x hx + exact cuspBarrierProfile_zero a b hab x hx.le + have hd := he.deriv_eq + have hdd : deriv (deriv (cuspBarrierProfile a b)) v=0 := by + simpa only [show deriv (fun _ : ℝ => (0:ℝ))=(fun _ => 0) from funext (fun x => deriv_const x 0),deriv_const] using he.deriv.deriv_eq + simp only [deriv_const] at hd + simp only [cuspBarrierDefectProfile,positiveHeightLaplacian,he.eq_of_nhds,hd,hdd,mul_zero,sub_zero] + +lemma cuspBarrierDefectProfile_one (a b v : ℝ) (hab : a x-1) := by + filter_upwards [Ioi_mem_nhds hv] with x hx + rw [cuspBarrierProfile,cuspTransition_one a b x hab hx.le,one_mul] + have hd := he.deriv_eq + have hlin : deriv (fun x : ℝ => x-1)=(fun _ => 1) := by ext x; simp + have hdd : deriv (deriv (cuspBarrierProfile a b)) v=0 := by + simpa only [hlin,deriv_const] using he.deriv.deriv_eq + simp only [deriv_sub_const,deriv_id''] at hd + simp only [cuspBarrierDefectProfile,positiveHeightLaplacian,he.eq_of_nhds,hd,hdd] + ring + +def cuspBarrierDefect (a b : ℝ) (w : HyperbolicSpace) : ℝ := + -1+fullCuspProfileSum (cuspBarrierDefectProfile a b) w + +lemma cuspBarrierDefect_invariant (a b : ℝ) (M : SL(2,ActualEisensteinCubic.O)) + (w : HyperbolicSpace) : + cuspBarrierDefect a b (integralComplexMatrix M • w)=cuspBarrierDefect a b w := by + rw [cuspBarrierDefect,cuspBarrierDefect,fullCuspProfileSum_invariant] + +lemma cuspBarrierDefect_high (a b : ℝ) (ha : 1 cuspBarrierDefectProfile_zero a b y hab (hy.trans_lt ha)) _ (fullCuspOf 1) + (by rw [hx]; linarith),hx,cuspBarrierDefectProfile_one a b v hab hbv] + ring + +def kernelQuotientBarrierDefect (a b : ℝ) : KernelQuotient→ℝ := + Quotient.lift (cuspBarrierDefect a b) (by + rintro w u ⟨M,hM⟩ + rw [←hM] + exact (cuspBarrierDefect_invariant a b (M:SL(2,ActualEisensteinCubic.O)) w).symm) + +lemma kernelQuotientBarrierDefect_hasCompactSupport (a b : ℝ) (ha : 1 cuspBarrierDefectProfile_zero a b v hab (hv.trans_lt ha)) + (cuspBarrierDefectProfile_smooth a b).continuous) + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff MatrixGroups + +def fullCuspRow (x : FullCuspClasses) : Fin 2→ℂ := + complexBottomRow (integralComplexMatrix x.out) + +lemma fullCuspRow_ne_zero (x : FullCuspClasses) : fullCuspRow x≠0 := + complexBottomRow_ne_zero _ + +lemma fullCuspRow_height (x : FullCuspClasses) (p : SpatialCoordinates) (hp : 0

rw [←hx] + rw [fullCuspHeight_of,fullMatrixHeight,hyperbolicHeight_action_upperPoint] + rw [rowHeight_eq_transformedHeight] + simp only [transformedHeight,heightDenominator,fullCuspRow,complexBottomRow,spatialHorizontal] + +def fullCuspProfileField (F : ℝ→ℝ) (p : SpatialCoordinates) : ℝ := + ∑'x : FullCuspClasses,F (rowHeight (fullCuspRow x) p) + +lemma fullCuspProfileField_eq (F : ℝ→ℝ) (p : SpatialCoordinates) (hp : 0

simp + rw [←he] + exact hyperbolicSpatialChart.map_source (Set.mem_univ _) + have he : hyperbolicSpatialChart.symm p=w := by + rw [hyperbolicSpatialChart_symm_eq ht] + have hnear := (hyperbolicSpatialChart.continuousAt_symm ht) (by simpa only [he] using hU.mem_nhds hw) + refine ⟨T,?_⟩ + filter_upwards [hnear,hyperbolicSpatialChart.open_target.mem_nhds ht] with q hq hqt + have hpos := hyperbolicSpatialChart_target_positive hqt + intro x hx + rw [fullCuspRow_height x q hpos,←hyperbolicSpatialChart_symm_eq hqt] + exact hT _ hq x hx + +lemma fullCuspProfileField_locally_finite (F : ℝ→ℝ) (hF : ∀v≤1,F v=0) + (p : SpatialCoordinates) (hp : 0

∑x∈T,F (rowHeight (fullCuspRow x) q)) := by + obtain ⟨T,hT⟩ := fullCuspRows_locally_finite p hp + refine ⟨T,?_⟩ + filter_upwards [hT] with q hq + apply tsum_eq_sum + intro x hx + exact hF _ (hq x hx).le + +lemma cast_profile_deriv (F : ℝ→ℝ) (hF : Differentiable ℝ F) (v : ℝ) : + deriv (fun y => (F y:ℂ)) v=((deriv F v:ℝ):ℂ) := + (hF v).hasDerivAt.ofReal_comp.deriv + +lemma cast_profile_deriv2 (F : ℝ→ℝ) (hF : ContDiff ℝ ∞ F) (v : ℝ) : + deriv (deriv (fun y => (F y:ℂ))) v=((deriv (deriv F) v:ℝ):ℂ) := by + have he : deriv (fun y => (F y:ℂ))=(fun y => ((deriv F y:ℝ):ℂ)) := + funext (cast_profile_deriv F (hF.differentiable (by simp))) + rw [he] + exact cast_profile_deriv (deriv F) (((contDiff_infty_iff_deriv.mp hF).2).differentiable (by simp)) v + +lemma fullCuspProfile_row_laplacian (F : ℝ→ℝ) (hF : ContDiff ℝ ∞ F) + (x : FullCuspClasses) (p : SpatialCoordinates) (hp : 0

(F (rowHeight (fullCuspRow x) q):ℂ)) p= + (positiveHeightLaplacian F (rowHeight (fullCuspRow x) p):ℂ) := by + rw [rowProfile_laplacian (fun y => (F y:ℂ)) (fun v hv => Complex.ofRealCLM.contDiff.contDiffAt.comp v hF.contDiffAt) + _ (fullCuspRow_ne_zero x) p hp,cast_profile_deriv F (hF.differentiable (by simp)),cast_profile_deriv2 F hF] + simp only [positiveHeightLaplacian,Complex.ofReal_sub,Complex.ofReal_mul,Complex.ofReal_pow] + ring + +lemma fullCuspProfileField_laplacian (F : ℝ→ℝ) (hF : ContDiff ℝ ∞ F) + (hzero : ∀v≤1,F v=0) (hLzero : ∀v≤1,positiveHeightLaplacian F v=0) + (p : SpatialCoordinates) (hp : 0

(fullCuspProfileField F q:ℂ)) p= + (fullCuspProfileField (positiveHeightLaplacian F) p:ℂ) := by + obtain ⟨T,hT⟩ := fullCuspRows_locally_finite p hp + have he : (fun q => (fullCuspProfileField F q:ℂ)) =ᶠ[𝓝 p] + (fun q => ∑x∈T,(F (rowHeight (fullCuspRow x) q):ℂ)) := by + filter_upwards [hT] with q hq + have hh : fullCuspProfileField F q=∑x∈T,F (rowHeight (fullCuspRow x) q) := + tsum_eq_sum (fun x hx => hzero _ (hq x hx).le) + rw [hh] + push_cast + rfl + have hval : fullCuspProfileField (positiveHeightLaplacian F) p= + ∑x∈T,positiveHeightLaplacian F (rowHeight (fullCuspRow x) p) := + tsum_eq_sum (fun x hx => hLzero _ (hT.self_of_nhds x hx).le) + have hreg : ∀x∈T,∀q,0 (F (rowHeight (fullCuspRow x) z):ℂ)) q j) (q j) ∧ + DifferentiableAt ℝ (deriv (axisSlice (fun z => (F (rowHeight (fullCuspRow x) z):ℂ)) q j)) (q j) := by + intro x hx q hq j + have hd := rowProfile_axis_derivatives (fun v => (F v:ℂ)) + (fun v hv => Complex.ofRealCLM.contDiff.contDiffAt.comp v hF.contDiffAt) + (fullCuspRow x) (fullCuspRow_ne_zero x) q hq j + exact ⟨hd.1.differentiableAt,hd.2.differentiableAt⟩ + rw [axisLaplacian_congr_eventuallyEq _ _ p he,axisLaplacian_finset_sum T _ hreg p hp,hval] + rw [←Finset.sum_neg_distrib] + push_cast + exact Finset.sum_congr rfl (fun x hx => fullCuspProfile_row_laplacian F hF x p hp) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspIntegration.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspIntegration.lean new file mode 100644 index 0000000000000000000000000000000000000000..e3468ff3eae71340a820d38117582e112720bdf1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspIntegration.lean @@ -0,0 +1,765 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.LogarithmicTargets + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +def spatialTriple (x y v : ℝ) : SpatialCoordinates := ![x,y,v] +@[simp] lemma spatialTriple_zero (x y v : ℝ) : spatialTriple x y v 0=x := rfl +@[simp] lemma spatialTriple_one (x y v : ℝ) : spatialTriple x y v 1=y := rfl +@[simp] lemma spatialTriple_two (x y v : ℝ) : spatialTriple x y v 2=v := rfl + +def cuspCylinderMeasure (a b : ℝ) : Measure (ℝ × (ℝ × ℝ)) := + (volume.restrict (Set.Icc a b)).prod + ((volume.restrict (Set.Icc 0 (3*Real.sqrt 3))).prod + (volume.restrict (Set.Icc 0 3))) + +def cuspBoxIntegral (a b : ℝ) (f : SpatialCoordinates → ℂ) : ℂ := + ∫q, f (spatialTriple q.2.2 q.2.1 q.1) ∂cuspCylinderMeasure a b + +lemma continuous_spatialTriple {X : Type*} [TopologicalSpace X] + {x y v : X → ℝ} (hx : Continuous x) (hy : Continuous y) (hv : Continuous v) : + Continuous (fun p => spatialTriple (x p) (y p) (v p)) := by + rw [continuous_pi_iff] + intro j + fin_cases j <;> assumption + +lemma continuous_cuspBox_integrand (f : SpatialCoordinates → ℂ) (hf : Continuous f) : + Continuous (fun q : ℝ × (ℝ × ℝ) => f (spatialTriple q.2.2 q.2.1 q.1)) := + hf.comp (continuous_spatialTriple (by fun_prop) (by fun_prop) (by fun_prop)) + +lemma integrable_cuspBox (f : SpatialCoordinates → ℂ) (hf : Continuous f) (a b : ℝ) : + Integrable (fun q : ℝ × (ℝ × ℝ) => f (spatialTriple q.2.2 q.2.1 q.1)) + (cuspCylinderMeasure a b) := by + have h : IntegrableOn (fun q : ℝ × (ℝ × ℝ) => f (spatialTriple q.2.2 q.2.1 q.1)) + (Set.Icc a b ×ˢ (Set.Icc 0 (3*Real.sqrt 3) ×ˢ Set.Icc 0 3)) volume := + (continuous_cuspBox_integrand f hf).continuousOn.integrableOn_compact + (isCompact_Icc.prod (isCompact_Icc.prod isCompact_Icc)) + simpa only [cuspCylinderMeasure,Measure.prod_restrict,← Measure.volume_eq_prod,IntegrableOn] using h + +lemma cuspBoxIntegral_add (f g : SpatialCoordinates → ℂ) (hf : Continuous f) (hg : Continuous g) + (a b : ℝ) : cuspBoxIntegral a b (fun p => f p+g p)=cuspBoxIntegral a b f+cuspBoxIntegral a b g := + integral_add (integrable_cuspBox f hf a b) (integrable_cuspBox g hg a b) +lemma cuspBoxIntegral_sub (f g : SpatialCoordinates → ℂ) (hf : Continuous f) (hg : Continuous g) + (a b : ℝ) : cuspBoxIntegral a b (fun p => f p-g p)=cuspBoxIntegral a b f-cuspBoxIntegral a b g := + integral_sub (integrable_cuspBox f hf a b) (integrable_cuspBox g hg a b) +lemma cuspBoxIntegral_const_mul (c : ℂ) (f : SpatialCoordinates → ℂ) (a b : ℝ) : + cuspBoxIntegral a b (fun p => c*f p)=c*cuspBoxIntegral a b f := integral_const_mul _ _ + +lemma cuspBoxIntegral_eq_iterated (f : SpatialCoordinates → ℂ) (hf : Continuous f) + (a b : ℝ) (hab : a≤b) : + cuspBoxIntegral a b f= + ∫v in a..b, ∫y in (0:ℝ)..(3*Real.sqrt 3), ∫x in (0:ℝ)..3, f (spatialTriple x y v) := by + unfold cuspBoxIntegral cuspCylinderMeasure + rw [integral_prod _ (integrable_cuspBox f hf a b)] + have hY : (0:ℝ)≤3*Real.sqrt 3 := by positivity + simp_rw [intervalIntegral.integral_of_le hab,intervalIntegral.integral_of_le hY, + intervalIntegral.integral_of_le (show (0:ℝ)≤3 by norm_num),← integral_Icc_eq_integral_Ioc] + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun v => by + have hc : Continuous (fun q : ℝ×ℝ => f (spatialTriple q.2 q.1 v)) := + hf.comp (continuous_spatialTriple (by fun_prop) (by fun_prop) continuous_const) + have hi : IntegrableOn (fun q : ℝ×ℝ => f (spatialTriple q.2 q.1 v)) + (Set.Icc 0 (3*Real.sqrt 3) ×ˢ Set.Icc 0 3) volume := + hc.continuousOn.integrableOn_compact (isCompact_Icc.prod isCompact_Icc) + have hi' : Integrable (fun q : ℝ×ℝ => f (spatialTriple q.2 q.1 v)) + ((volume.restrict (Set.Icc 0 (3*Real.sqrt 3))).prod (volume.restrict (Set.Icc 0 3))) := by + simpa only [Measure.prod_restrict,← Measure.volume_eq_prod,IntegrableOn] using hi + exact integral_prod _ hi') + +lemma cuspBoxIntegral_eq_vertical (f : SpatialCoordinates → ℂ) (hf : Continuous f) + (a b : ℝ) (hab : a≤b) : + cuspBoxIntegral a b f= + ∫y in (0:ℝ)..(3*Real.sqrt 3), ∫x in (0:ℝ)..3, ∫v in a..b, f (spatialTriple x y v) := by + unfold cuspBoxIntegral cuspCylinderMeasure + rw [integral_prod_symm _ (integrable_cuspBox f hf a b)] + have hc : Continuous (fun q : (ℝ×ℝ)×ℝ => f (spatialTriple q.1.2 q.1.1 q.2)) := + hf.comp (continuous_spatialTriple (by fun_prop) (by fun_prop) (by fun_prop)) + have hcI : Continuous (fun q : ℝ×ℝ => ∫v in Set.Icc a b, f (spatialTriple q.2 q.1 v)) := + continuous_parametric_integral_of_continuous hc isCompact_Icc + have hi : IntegrableOn (fun q : ℝ×ℝ => ∫v in Set.Icc a b, f (spatialTriple q.2 q.1 v)) + (Set.Icc 0 (3*Real.sqrt 3) ×ˢ Set.Icc 0 3) volume := + hcI.continuousOn.integrableOn_compact (isCompact_Icc.prod isCompact_Icc) + have hi' : Integrable (fun q : ℝ×ℝ => ∫v in Set.Icc a b, f (spatialTriple q.2 q.1 v)) + ((volume.restrict (Set.Icc 0 (3*Real.sqrt 3))).prod (volume.restrict (Set.Icc 0 3))) := by + simpa only [Measure.prod_restrict,← Measure.volume_eq_prod,IntegrableOn] using hi + rw [integral_prod _ hi'] + have hY : (0:ℝ)≤3*Real.sqrt 3 := by positivity + simp_rw [intervalIntegral.integral_of_le hab,intervalIntegral.integral_of_le hY, + intervalIntegral.integral_of_le (show (0:ℝ)≤3 by norm_num),← integral_Icc_eq_integral_Ioc] + +lemma rectangle_interval_swap (f : ℝ→ℝ→ℂ) (hf : Continuous f.uncurry) : + (∫y in (0:ℝ)..(3*Real.sqrt 3), ∫x in (0:ℝ)..3, f x y)= + ∫x in (0:ℝ)..3, ∫y in (0:ℝ)..(3*Real.sqrt 3), f x y := by + apply intervalIntegral_intervalIntegral_swap + have hc : Continuous (Function.uncurry (fun y x => f x y)) := hf.comp continuous_swap + exact (hc.continuousOn.integrableOn_compact (isCompact_uIcc.prod isCompact_uIcc)).mono_set + (Set.prod_mono Set.uIoc_subset_uIcc Set.uIoc_subset_uIcc) + +def greenSecondField (s t : ℂ) (j : Fin 3) (p : SpatialCoordinates) : ℂ := + greenSecondTerm (axisSlice (upperEisensteinField s) p j) + (axisSlice (upperEisensteinField t) p j) (p j) +def greenWronskianField (s t : ℂ) (p : SpatialCoordinates) : ℂ := + greenWronskian (axisSlice (upperEisensteinField s) p 2) + (axisSlice (upperEisensteinField t) p 2) (p 2) +def greenAxisDensity (s t : ℂ) (j : Fin 3) (p : SpatialCoordinates) : ℂ := + greenSecondField s t j p/(p 2:ℂ) +def greenVerticalDensity (s t : ℂ) (p : SpatialCoordinates) : ℂ := + greenAxisDensity s t 2 p-greenWronskianField s t p/(p 2:ℂ)^2 +def greenBoundaryFlux (s t : ℂ) (p : SpatialCoordinates) : ℂ := + greenWronskianField s t p/(p 2:ℂ) + +def clampHeight (deltaLoss : ℝ) (p : SpatialCoordinates) : SpatialCoordinates := + spatialTriple (p 0) (p 1) (max deltaLoss (p 2)) +lemma clampHeight_continuous (deltaLoss : ℝ) : Continuous (clampHeight deltaLoss) := + continuous_spatialTriple (continuous_apply 0) (continuous_apply 1) + (continuous_const.max (continuous_apply 2)) +lemma clampHeight_eq (deltaLoss : ℝ) (p : SpatialCoordinates) (hp : deltaLoss≤p 2) : clampHeight deltaLoss p=p := by + ext j + fin_cases j <;> simp [clampHeight,spatialTriple,max_eq_right hp] + +def extendAboveHeight (deltaLoss : ℝ) (f : SpatialCoordinates → ℂ) (p : SpatialCoordinates) : ℂ := + f (clampHeight deltaLoss p) +lemma extendAboveHeight_continuous (deltaLoss : ℝ) (hδ : 0 (q 2:ℂ)) p := + Complex.continuous_ofReal.continuousAt.comp (continuous_apply 2).continuousAt + have hn : (p 2:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hv.ne' + have hG (j : Fin 3) : ContinuousAt (greenSecondField s t j) p := by + unfold greenSecondField greenSecondTerm + simp only [axisSlice_self] + exact (((hS.2 j).2.mul hT.1.star).sub (hS.1.mul (hT.2 j).2.star)) + have hW : ContinuousAt (greenWronskianField s t) p := by + unfold greenWronskianField greenWronskian + simp only [axisSlice_self] + exact (((hS.2 2).1.mul hT.1.star).sub (hS.1.mul (hT.2 2).1.star)) + exact ⟨fun j => (hG j).div hV hn,((hG 2).div hV hn).sub (hW.div (hV.pow 2) (pow_ne_zero 2 hn)), + hW.div hV hn⟩ + +lemma actual_green_fields_density (s t : ℂ) (hs : 2 simp [spatialTriple,Function.update] +lemma spatialTriple_update_one (x y v : ℝ) : + spatialTriple x y v=Function.update (spatialTriple x 0 v) 1 y := by + ext j; fin_cases j <;> simp [spatialTriple,Function.update] +lemma spatialTriple_update_two (x y v : ℝ) : + spatialTriple x y v=Function.update (spatialTriple x y 0) 2 v := by + ext j; fin_cases j <;> simp [spatialTriple,Function.update] + +lemma actual_green_axis_zero_integral (s t : ℂ) (hs : 2 greenAxisDensity s t 0 (spatialTriple x y v))= + (fun x => greenSecondTerm (axisSlice (upperEisensteinField s) (spatialTriple 0 y v) 0) + (axisSlice (upperEisensteinField t) (spatialTriple 0 y v) 0) x/(v:ℂ)) := by + funext x + unfold greenAxisDensity + simp only [spatialTriple_two] + rw [spatialTriple_update_zero,greenSecondField_update] + rw [hf,intervalIntegral.integral_div] + have h := actual_green_real_period_zero s t hs ht (spatialTriple 0 y v) hv + simp only [greenSecondTerm,h,zero_div] + +lemma actual_green_axis_one_integral (s t : ℂ) (hs : 2 greenAxisDensity s t 1 (spatialTriple x y v))= + (fun y => greenSecondTerm (axisSlice (upperEisensteinField s) (spatialTriple x 0 v) 1) + (axisSlice (upperEisensteinField t) (spatialTriple x 0 v) 1) y/(v:ℂ)) := by + funext y + unfold greenAxisDensity + simp only [spatialTriple_two] + rw [spatialTriple_update_one,greenSecondField_update] + rw [hf,intervalIntegral.integral_div] + have h := actual_green_imag_period_zero s t hs ht (spatialTriple x 0 v) hv + simp only [greenSecondTerm,h,zero_div] + +lemma actual_green_vertical_integral (s t : ℂ) (hs : 2 extendAboveHeight_eq a f p hp.1) + +lemma integrable_cuspBox_of_positive_continuity (f : SpatialCoordinates → ℂ) + (hf : ∀p,0

f (spatialTriple q.2.2 q.2.1 q.1)) + (cuspCylinderMeasure a b) := by + have hi := integrable_cuspBox (extendAboveHeight a f) (extendAboveHeight_continuous a ha f hf) a b + apply hi.congr + filter_upwards [cuspCylinder_ae_height a b] with q hq + exact extendAboveHeight_eq a f _ hq.1 + +lemma cuspBox_green_axis_zero (s t : ℂ) (hs : 2 (greenFields_continuousAt s t hs ht p hp).1 0) + rw [cuspBoxIntegral_eq_iterated _ hf a b hab] + trans ∫v in a..b, (0:ℂ) + · apply intervalIntegral.integral_congr + intro v hv + have hav : a≤v := by simpa only [min_eq_left hab,spatialTriple_two] using hv.1 + have hext (x y : ℝ) : f (spatialTriple x y v)=greenAxisDensity s t 0 (spatialTriple x y v) := + extendAboveHeight_eq a _ _ hav + change (∫y in (0:ℝ)..(3*Real.sqrt 3), ∫x in (0:ℝ)..3, f (spatialTriple x y v))=0 + simp_rw [hext,actual_green_axis_zero_integral s t hs ht _ v (lt_of_lt_of_le ha hav)] + simp only [intervalIntegral.integral_zero] + · simp only [intervalIntegral.integral_zero] + +lemma cuspBox_green_axis_one (s t : ℂ) (hs : 2 (greenFields_continuousAt s t hs ht p hp).1 1) + rw [cuspBoxIntegral_eq_iterated _ hf a b hab] + trans ∫v in a..b, (0:ℂ) + · apply intervalIntegral.integral_congr + intro v hv + have hav : a≤v := by simpa only [min_eq_left hab,spatialTriple_two] using hv.1 + have hext (x y : ℝ) : f (spatialTriple x y v)=greenAxisDensity s t 1 (spatialTriple x y v) := + extendAboveHeight_eq a _ _ hav + change (∫y in (0:ℝ)..(3*Real.sqrt 3), ∫x in (0:ℝ)..3, f (spatialTriple x y v))=0 + rw [rectangle_interval_swap (fun x y => f (spatialTriple x y v)) + (hf.comp (continuous_spatialTriple continuous_fst continuous_snd continuous_const))] + simp_rw [hext,actual_green_axis_one_integral s t hs ht _ v (lt_of_lt_of_le ha hav)] + simp only [intervalIntegral.integral_zero] + · simp only [intervalIntegral.integral_zero] + +lemma cuspBox_green_vertical (s t : ℂ) (hs : 2 (greenFields_continuousAt s t hs ht p hp).2.1) + rw [cuspBoxIntegral_eq_vertical _ hf a b hab] + apply intervalIntegral.integral_congr + intro y hy + apply intervalIntegral.integral_congr + intro x hx + calc + _ = ∫v in a..b, greenVerticalDensity s t (spatialTriple x y v) := by + apply intervalIntegral.integral_congr + intro v hv + exact extendAboveHeight_eq a _ _ (by simpa only [min_eq_left hab,spatialTriple_two] using hv.1) + _ = _ := actual_green_vertical_integral s t hs ht x y a b ha (lt_of_lt_of_le ha hab) + +def eisensteinHermitianDensity (s t : ℂ) (p : SpatialCoordinates) : ℂ := + upperEisensteinField s p*star (upperEisensteinField t p)/(p 2:ℂ)^3 + +lemma integrable_eisensteinHermitianDensity (s t : ℂ) (hs : 2 eisensteinHermitianDensity s t (spatialTriple q.2.2 q.2.1 q.1)) + (cuspCylinderMeasure a b) := by + apply integrable_cuspBox_of_positive_continuity _ _ a b ha + intro p hp + have hV : ContinuousAt (fun q : SpatialCoordinates => (q 2:ℂ)) p := + Complex.continuous_ofReal.continuousAt.comp (continuous_apply 2).continuousAt + exact (((actual_spatial_continuousAt s hs p hp).1).mul + (actual_spatial_continuousAt t ht p hp).1.star).div (hV.pow 3) + (pow_ne_zero 3 (Complex.ofReal_ne_zero.mpr hp.ne')) + +theorem actual_eisenstein_cylinder_green (s t : ℂ) (hs : 2 (greenFields_continuousAt s t hs ht p hp).1 0) + have h₁ : Continuous f₁ := extendAboveHeight_continuous a ha _ (fun p hp => (greenFields_continuousAt s t hs ht p hp).1 1) + have h₂ : Continuous f₂ := extendAboveHeight_continuous a ha _ (fun p hp => (greenFields_continuousAt s t hs ht p hp).2.1) + have hD : cuspBoxIntegral a b (fun p => f₀ p+f₁ p+f₂ p)= + (s*(s-2)-star (t*(t-2)))*cuspBoxIntegral a b (eisensteinHermitianDensity s t) := by + rw [← cuspBoxIntegral_const_mul] + apply cuspBoxIntegral_congr + intro p hp + change extendAboveHeight a (greenAxisDensity s t 0) p+ + extendAboveHeight a (greenAxisDensity s t 1) p+ + extendAboveHeight a (greenVerticalDensity s t) p=_ + rw [extendAboveHeight_eq _ _ _ hp.1,extendAboveHeight_eq _ _ _ hp.1,extendAboveHeight_eq _ _ _ hp.1, + actual_green_fields_density s t hs ht p (lt_of_lt_of_le ha hp.1)] + unfold eisensteinHermitianDensity + ring + rw [← hD,cuspBoxIntegral_add (fun p => f₀ p+f₁ p) f₂ (h₀.add h₁) h₂, + cuspBoxIntegral_add f₀ f₁ h₀ h₁] + rw [cuspBox_green_axis_zero s t hs ht a b ha hab,cuspBox_green_axis_one s t hs ht a b ha hab, + cuspBox_green_vertical s t hs ht a b ha hab] + simp only [zero_add] + +lemma cuspBoxIntegral_eq_iterated_positive (f : SpatialCoordinates → ℂ) + (hf : ∀p,0

(q 2:ℂ)) p := + Complex.continuous_ofReal.continuousAt.comp (continuous_apply 2).continuousAt + exact (((actual_spatial_continuousAt s hs p hp).1).mul + (actual_spatial_continuousAt t ht p hp).1.star).div (hV.pow 3) + (pow_ne_zero 3 (Complex.ofReal_ne_zero.mpr hp.ne')) + +theorem actual_eisenstein_cylinder_green_iterated (s t : ℂ) (hs : 2 rw [← hS, Finset.powerset_image] + rw [Finset.sum_image] + · apply Finset.sum_congr rfl + intro E hE + congr 1 + rw [Finset.prod_image] + exact fun _ _ _ _ h => Subtype.val_injective h + · exact fun _ _ _ _ h => Finset.image_injective Subtype.val_injective h + +theorem primePool_singleton_eq_primeSupport (G : Ideal O) : + primePool {G} = primeSupport G := by + simp [primePool, primeSupport] + +theorem primePool_subset_sum_eq_divisors (G : Ideal O) (hG : Squarefree G) (f : Ideal O → ℂ) : + (∑ E ∈ (Finset.univ : Finset (primePool {G})).powerset, + f (∏ P ∈ E, P.val)) = ∑ d ∈ idealDivisors G, f d := by + rw [sum_subtype_powerset_products, primePool_singleton_eq_primeSupport] + exact (squarefree_divisor_sum_eq_support G hG f).symm + +theorem middleTruncation_eq_ideal_divisors (G : Ideal O) (hG : Squarefree G) + (W : ℝ → ℂ) (X Y Z lengthScale : ℝ) : + middleTruncation (fun P : primePool {G} => P.val) Finset.univ W X Y Z lengthScale = + (X : ℂ) * ∑ d ∈ idealDivisors G, + if Y < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z then + (UniqueFactorizationMonoid.moebius d : ℂ) / (Ideal.absNorm d : ℂ) * + ∑ h ∈ rowNormDisk ⌊lengthScale⌋₊, + paperRadialFourier W ((X / (Ideal.absNorm d : ℝ)) * ‖eisEmbedding h‖ ^ 2) + else 0 := by + classical + let f : Ideal O → ℂ := fun d => + if Y < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z then + (UniqueFactorizationMonoid.moebius d : ℂ) / (Ideal.absNorm d : ℂ) * + ∑ h ∈ rowNormDisk ⌊lengthScale⌋₊, + paperRadialFourier W ((X / (Ideal.absNorm d : ℝ)) * ‖eisEmbedding h‖ ^ 2) + else 0 + change middleTruncation _ _ W X Y Z lengthScale = (X : ℂ) * ∑ d ∈ idealDivisors G, f d + rw [← primePool_subset_sum_eq_divisors G hG f] + unfold middleTruncation middleDivisors smallDivisors + simp only [Finset.sum_filter] + congr 1 + apply Finset.sum_congr rfl + intro E hE + dsimp only [f, subsetNorm, subsetMobius] + push_cast + by_cases hY : Y < (Ideal.absNorm (∏ P ∈ E, P.val) : ℝ) <;> + by_cases hZ : (Ideal.absNorm (∏ P ∈ E, P.val) : ℝ) ≤ Z <;> simp only [hY, hZ, and_self, + false_and, and_false, ite_true, ite_false] + +theorem middleTruncation_eq_ideal_frequencies (G : Ideal O) (hG : Squarefree G) + (W : ℝ → ℂ) (X Y Z lengthScale : ℝ) : + middleTruncation (fun P : primePool {G} => P.val) Finset.univ W X Y Z lengthScale = + ∑ h ∈ rowNormDisk ⌊lengthScale⌋₊, ∑ d ∈ idealDivisors G, + if Y < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z then + (UniqueFactorizationMonoid.moebius d : ℂ) * + (((X / (Ideal.absNorm d : ℝ) : ℝ) : ℂ) * + paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2 / (Ideal.absNorm d : ℝ))) + else 0 := by + classical + rw [middleTruncation_eq_ideal_divisors G hG, Finset.mul_sum] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro d hd + by_cases hc : Y < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z + · simp only [hc, and_self, ite_true, Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + have harg : (X / (Ideal.absNorm d : ℝ)) * ‖eisEmbedding h‖ ^ 2 = + X * ‖eisEmbedding h‖ ^ 2 / (Ideal.absNorm d : ℝ) := by ring + rw [harg] + push_cast + ring + · simp only [hc, ite_false, mul_zero, Finset.sum_const_zero] + +theorem principalTruncation_eq_ideal_divisors (G : Ideal O) (hG : Squarefree G) + (W : ℝ → ℂ) (X Z : ℝ) : + principalTruncation (fun P : primePool {G} => P.val) Finset.univ W X Z = + (X : ℂ) * paperRadialFourier W 0 * + (∏ P : primePool {G}, (1 - (1 : ℂ) / Ideal.absNorm P.val)) - + (X : ℂ) * paperRadialFourier W 0 * + (∑ d ∈ idealDivisors G, if Z < (Ideal.absNorm d : ℝ) then + (UniqueFactorizationMonoid.moebius d : ℂ) / (Ideal.absNorm d : ℂ) else 0) - + W 0 * (∑ d ∈ idealDivisors G, if (Ideal.absNorm d : ℝ) ≤ Z then + (UniqueFactorizationMonoid.moebius d : ℂ) else 0) := by + classical + rw [← primePool_subset_sum_eq_divisors G hG + (fun d => if Z < (Ideal.absNorm d : ℝ) then + (UniqueFactorizationMonoid.moebius d : ℂ) / (Ideal.absNorm d : ℂ) else 0), + ← primePool_subset_sum_eq_divisors G hG + (fun d => if (Ideal.absNorm d : ℝ) ≤ Z then (UniqueFactorizationMonoid.moebius d : ℂ) else 0)] + unfold principalTruncation largeDivisors smallDivisors + simp only [Finset.sum_filter, subsetNorm, subsetMobius, Complex.ofReal_natCast] + +end + +open ActualEisensteinCubic + +theorem finite_middle_triangle + {m n p H D : Type*} [Fintype m] [Fintype n] [Fintype p] [Fintype H] [Fintype D] + (muCoefficient : D → ℂ) (hμ : ∀ d, ‖muCoefficient d‖ ≤ 1) (A : m → n → p → H → D → ℂ) : + ‖∑ i, ∑ j, ∑ k, ∑ h, ∑ d, muCoefficient d * A i j k h d‖ ≤ + ∑ h, ∑ i, ∑ d, ‖∑ j, ∑ k, A i j k h d‖ := by + classical + have he : (∑ i, ∑ j, ∑ k, ∑ h, ∑ d, muCoefficient d * A i j k h d) = + ∑ h, ∑ i, ∑ d, muCoefficient d * (∑ j, ∑ k, A i j k h d) := by + simp_rw [Finset.sum_comm (s := (Finset.univ : Finset p)) (t := (Finset.univ : Finset H)), + Finset.sum_comm (s := (Finset.univ : Finset n)) (t := (Finset.univ : Finset H)), + Finset.sum_comm (s := (Finset.univ : Finset m)) (t := (Finset.univ : Finset H)), + Finset.sum_comm (s := (Finset.univ : Finset p)) (t := (Finset.univ : Finset D)), + Finset.sum_comm (s := (Finset.univ : Finset n)) (t := (Finset.univ : Finset D))] + simp only [Finset.mul_sum] + rw [he] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro h hh + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro i hi + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro d hd + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (hμ d) + +theorem finite_nonzero_frequency_sum_le (H : Finset O) (hH : ∀ h ∈ H, h ≠ 0) + (f : O → ℝ) (hf : ∀ h, 0 ≤ f h) + (hs : Summable (fun h : {h : O // h ≠ 0} => f h.val)) : + (∑ h ∈ H, f h) ≤ ∑' h : {h : O // h ≠ 0}, f h.val := by + classical + let e : H → {h : O // h ≠ 0} := fun h => ⟨h.val, hH h.val h.property⟩ + have he : Function.Injective e := by + intro h k hh + apply Subtype.ext + exact congrArg (fun x : {h : O // h ≠ 0} => x.val) hh + have hsH : Summable (fun h : H => f h.val) := + summable_of_hasFiniteSupport (Set.toFinite _) + have hb := hsH.tsum_le_tsum_of_inj e he (fun h _ => hf h.val) (fun _ => le_rfl) hs + rw [tsum_fintype, Finset.sum_coe_sort H f] at hb + exact hb + +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge EisensteinSchwartzPoisson +open TruncatedPrincipalPoisson IdealMobiusDivisorSum + +theorem sum_two_finite_subtypes {α β A : Type*} [AddCommMonoid A] + (S : Finset α) (T : Finset β) (f : α → β → A) : + (∑ a : S, ∑ b : T, f a.val b.val) = ∑ a ∈ S, ∑ b ∈ T, f a b := by + rw [Finset.sum_coe_sort S (fun a => ∑ b : T, f a b.val)] + exact Finset.sum_congr rfl (fun a _ => Finset.sum_coe_sort T (f a)) + +variable {m n p : Type} [Fintype m] [Fintype n] [Fintype p] + [DecidableEq m] [DecidableEq n] [DecidableEq p] + +def originalTruncatedMiddle (W : 𝓢(ℝ, ℂ)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (M : ℝ) (Y Z : m → ℝ) (lengthScale : ℝ) : ℂ := + ∑ i, ∑ j, ∑ k, originalTerm rows left right a b 1 1 i j k * + middleTruncation (fun P : primePool {left j * right k} => P.val) Finset.univ W + (Real.sqrt (M / (Ideal.absNorm (rows i) : ℝ))) (Y i) (Z i) lengthScale + +omit [Fintype m] [Fintype n] [Fintype p] [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem original_truncated_pair_expansion + (W : 𝓢(ℝ, ℂ)) (K : Finset (Ideal O)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (M : ℝ) (Y Z : m → ℝ) (lengthScale : ℝ) + (hleft : ∀ j, Admissible (left j)) (hright : ∀ k, Admissible (right k)) + (hK : ∀ j k d, d ∣ left j * right k → d ∈ K) (i : m) (j : n) (k : p) : + originalTerm rows left right a b 1 1 i j k * + middleTruncation (fun P : primePool {left j * right k} => P.val) Finset.univ W + (Real.sqrt (M / (Ideal.absNorm (rows i) : ℝ))) (Y i) (Z i) lengthScale = + ∑ h : rowNormDisk ⌊lengthScale⌋₊, ∑ d : K, (UniqueFactorizationMonoid.moebius d.val : ℂ) * + (if Y i < (Ideal.absNorm d.val : ℝ) ∧ (Ideal.absNorm d.val : ℝ) ≤ Z i then + if d.val ∣ left j * right k then + originalTerm rows left right a b 1 1 i j k * originalPrincipalKernel W rows M h.val d.val i + else 0 else 0) := by + classical + rw [sum_two_finite_subtypes (rowNormDisk ⌊lengthScale⌋₊) K (fun h d => + (UniqueFactorizationMonoid.moebius d : ℂ) * + (if Y i < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z i then + if d ∣ left j * right k then + originalTerm rows left right a b 1 1 i j k * originalPrincipalKernel W rows M h d i + else 0 else 0))] + by_cases hc : IsCoprime (left j) (right k) + · have hsq : Squarefree (left j * right k) := + squarefree_mul_iff.mpr ⟨hc.isRelPrime, (hleft j).2.1, (hright k).2.1⟩ + rw [middleTruncation_eq_ideal_frequencies _ hsq, Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + rw [← divisorPool_filter K (left j * right k) hsq.ne_zero (hK j k), Finset.sum_filter, Finset.mul_sum] + apply Finset.sum_congr rfl + intro d hd + by_cases hdv : d ∣ left j * right k + · by_cases hp : Y i < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z i + · simp only [hdv, hp, and_self, ite_true, originalPrincipalKernel] + ring + · simp only [hdv, hp, ite_true, ite_false, mul_zero] + · simp only [hdv, ite_false, ite_self, mul_zero] + · have hz : originalTerm rows left right a b 1 1 i j k = 0 := by simp only [originalTerm, hc, ite_false] + simp only [hz, zero_mul, ite_self, mul_zero, Finset.sum_const_zero] + +omit [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem originalTruncatedMiddle_le_product_divisors + (W : 𝓢(ℝ, ℂ)) (K : Finset (Ideal O)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (M : ℝ) (Y Z : m → ℝ) (lengthScale : ℝ) + (hleft : ∀ j, Admissible (left j)) (hright : ∀ k, Admissible (right k)) + (hK : ∀ j k d, d ∣ left j * right k → d ∈ K) : + ‖originalTruncatedMiddle W rows left right a b M Y Z lengthScale‖ ≤ + ∑ h ∈ rowNormDisk ⌊lengthScale⌋₊, originalProductDivisorMiddleAt W K rows left right a b M + (fun d i => Y i < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z i) h := by + classical + let A : m → n → p → rowNormDisk ⌊lengthScale⌋₊ → K → ℂ := fun i j k h d => + if Y i < (Ideal.absNorm d.val : ℝ) ∧ (Ideal.absNorm d.val : ℝ) ≤ Z i then + if d.val ∣ left j * right k then + originalTerm rows left right a b 1 1 i j k * originalPrincipalKernel W rows M h.val d.val i + else 0 else 0 + have he : originalTruncatedMiddle W rows left right a b M Y Z lengthScale = + ∑ i, ∑ j, ∑ k, ∑ h : rowNormDisk ⌊lengthScale⌋₊, ∑ d : K, + (UniqueFactorizationMonoid.moebius d.val : ℂ) * A i j k h d := by + unfold originalTruncatedMiddle + apply Finset.sum_congr rfl + intro i hi + apply Finset.sum_congr rfl + intro j hj + apply Finset.sum_congr rfl + intro k hk + exact original_truncated_pair_expansion W K rows left right a b M Y Z lengthScale hleft hright hK i j k + rw [he] + apply (finite_middle_triangle (fun d : K => (UniqueFactorizationMonoid.moebius d.val : ℂ)) + (fun d => QuadraticInitialBound.norm_ideal_moebius_le_one d.val) A).trans_eq + rw [Finset.sum_coe_sort (rowNormDisk ⌊lengthScale⌋₊) (fun h => ∑ i, ∑ d : K, + ‖∑ j, ∑ k, if Y i < (Ideal.absNorm d.val : ℝ) ∧ (Ideal.absNorm d.val : ℝ) ≤ Z i then + if d.val ∣ left j * right k then + originalTerm rows left right a b 1 1 i j k * originalPrincipalKernel W rows M h d.val i + else 0 else 0‖)] + apply Finset.sum_congr rfl + intro h hh + unfold originalProductDivisorMiddleAt + apply Finset.sum_congr rfl + intro i hi + rw [Finset.sum_coe_sort K (fun d => + ‖∑ j, ∑ k, if Y i < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z i then + if d ∣ left j * right k then + originalTerm rows left right a b 1 1 i j k * originalPrincipalKernel W rows M h d i + else 0 else 0‖)] + apply Finset.sum_congr rfl + intro d hd + by_cases hp : Y i < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z i <;> + simp only [hp, and_self, ite_true, ite_false, Finset.sum_const_zero, norm_zero] + +theorem HasSieveExponent.original_truncated_middle {α : ℝ} (hexp : HasSieveExponent α) + (deltaLoss : ℝ) (hδ : 0 < deltaLoss) (ε : ℝ) (hε : 0 < ε) + (B N M U : ℝ) (hB : 1 ≤ B) (hN : 1 ≤ N) (hM : 0 < M) (hU : 0 ≤ U) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (hr : Function.Injective rows) (hl : Function.Injective left) (hri : Function.Injective right) + (hrows : ∀ i, Admissible (rows i) ∧ B / 2 ≤ (Ideal.absNorm (rows i) : ℝ) ∧ (Ideal.absNorm (rows i) : ℝ) ≤ B) + (a : n → ℂ) (b : p → ℂ) (W : 𝓢(ℝ, ℂ)) (Y Z : m → ℝ) (lengthScale : ℝ) + (hleft : ∀ j, Admissible (left j) ∧ (Ideal.absNorm (left j) : ℝ) ≤ N) + (hright : ∀ k, Admissible (right k) ∧ (Ideal.absNorm (right k) : ℝ) ≤ N) + (hZ : ∀ i, Z i ≤ U * Real.sqrt (M / (Ideal.absNorm (rows i) : ℝ))) : + ‖originalTruncatedMiddle W rows left right a b M Y Z lengthScale‖ ≤ + ((columnDyadicLength N + 1 : ℕ) : ℝ) ^ 2 * + ((2 * nonzeroLatticeEnvelopeConstant * originalMiddleDecayConstant W) * + divisorEnergyFactor ε hε N a b * (divisorExponentConstant hexp deltaLoss hδ * (B * N) ^ deltaLoss) * + (N + (2 * U) * Real.sqrt M * B ^ (α - 1 / 2))) := by + let pairCols : n × p → Ideal O := fun x => left x.1 * right x.2 + let K := columnDivisorPool pairCols + have hPair : ∀ x, pairCols x ≠ 0 := fun x => mul_ne_zero (hleft x.1).1.1 (hright x.2).1.1 + have hK (j : n) (k : p) (d : Ideal O) (hd : d ∣ left j * right k) : d ∈ K := + mem_columnDivisorPool_of_dvd pairCols hPair (j, k) d hd + let P : Ideal O → m → Prop := fun d i => + Y i < (Ideal.absNorm d : ℝ) ∧ (Ideal.absNorm d : ℝ) ≤ Z i + have hb := hexp.original_product_divisor_middle deltaLoss hδ ε hε K B N M U hB hN hM hU + rows left right hr hl hri hrows a b (fun _ => a) (fun _ => b) + (fun _ _ => le_rfl) (fun _ _ => le_rfl) W P hleft hright + (fun d hd i hp => hp.2.trans (hZ i)) + have hH (h : O) (hh : h ∈ rowNormDisk ⌊lengthScale⌋₊) : h ≠ 0 := by + intro hz + have hn := (mem_rowNormDisk.mp hh).1 + simp [hz] at hn + calc + _ ≤ ∑ h ∈ rowNormDisk ⌊lengthScale⌋₊, originalProductDivisorMiddleAt W K rows left right a b M P h := + originalTruncatedMiddle_le_product_divisors W K rows left right a b M Y Z lengthScale + (fun j => (hleft j).1) (fun k => (hright k).1) hK + _ ≤ ∑' h : {h : O // h ≠ 0}, originalProductDivisorMiddleAt W K rows left right a b M P h.val := + finite_nonzero_frequency_sum_le (rowNormDisk ⌊lengthScale⌋₊) hH _ + (fun h => originalProductDivisorMiddleAt_nonneg W K rows left right a b M P h) hb.1 + _ ≤ _ := hb.2 + +end CanonicalQuadraticSieve + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspResidues.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspResidues.lean new file mode 100644 index 0000000000000000000000000000000000000000..8004cf8d00ce8f622d272a2d775875fc05d01c47 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/CuspResidues.lean @@ -0,0 +1,701 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.SeedHeight + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace MatrixGroups Matrix + +lemma levelThree_integral_eq_translation (M : CubicKubota.levelThree) + (hc : (M : SL(2,ActualEisensteinCubic.O)) 1 0=0) : + integralComplexMatrix M.1=complexTranslation (ConcreteTraceCRT.eisEmbedding ((M : SL(2,ActualEisensteinCubic.O)) 0 1)) := by + have hr := row_eq_one_of_lower_left_zero M hc + have hd : (M : SL(2,ActualEisensteinCubic.O)) 1 1=1 := by + simpa [row,Matrix.one_apply] using congrFun hr 1 + have ha : (M : SL(2,ActualEisensteinCubic.O)) 0 0=1 := by + have hh : (M : SL(2,ActualEisensteinCubic.O)) 0 0 * (M : SL(2,ActualEisensteinCubic.O)) 1 1- + (M : SL(2,ActualEisensteinCubic.O)) 0 1 * (M : SL(2,ActualEisensteinCubic.O)) 1 0=1 := by + simpa only [Matrix.det_fin_two] using (M : SL(2,ActualEisensteinCubic.O)).property + simpa only [hc,hd,mul_zero,mul_one,sub_zero] using hh + ext i j + fin_cases i <;> fin_cases j <;> + simp [complexTranslation,ha,hc,hd] + +lemma periodDomain_unique_translate (z w t : ℂ) (hz : z∈periodDomain) (hw : w∈periodDomain) + (ht : t∈periodLattice) (he : z=w+t) : z=w := by + have hf := ZSpan.fract_add_ZSpan periodBasis w ht + rw [←he,(ZSpan.fract_eq_self (b := periodBasis)).mpr hz, + (ZSpan.fract_eq_self (b := periodBasis)).mpr hw] at hf + exact hf + +def cuspPeriodRegion : Set HyperbolicSpace := + {w | hyperbolicHorizontal w∈periodDomain ∧ 1 (s-4/3)*kernelCuspAverageFamily a b ha hab s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (kernelCuspStripAverage (kernelEisensteinResidueVector a b ha hab))) := by + have hh := kernelCuspStripAverage.continuous.continuousAt.tendsto.comp + (kernelLocalCorrectedSeed_residue_limit kernelCuspAverageCompact kernelCuspAverageCompact_isCompact a b ha hab) + simpa only [Function.comp_def,map_smul,smul_eq_mul,kernelCuspStripAverage_restrict,kernelCuspAverageFamily] using hh + +lemma kernelCuspAverageFamily_actual_integral (a b : ℝ) (ha : 0 g (cuspCoordinateLift q)/(q.1:ℂ)^3) + (Set.Icc (5:ℝ) 6 ×ˢ periodDomain) volume) : + (∫w in cuspPeriodStrip 5 6,g w∂hyperbolicVolume)= + ∫v in Set.Icc (5:ℝ) 6,(∫z in periodDomain,g (cuspCoordinateLift (v,z)))/(v:ℂ)^3 := by + have hm := euclideanToHyperbolic_measurePreserving_on cuspEuclideanStrip + cuspEuclideanStrip_measurable cuspEuclideanStrip_positive + rw [cuspEuclideanStrip_preimage] at hm + have hh := hg.mono_measure (Measure.restrict_le_self (s := cuspPeriodStrip 5 6)) + have he : (∫w in cuspPeriodStrip 5 6,g w∂hyperbolicVolume)= + ∫p in cuspEuclideanStrip,g (euclideanToHyperbolic p)∂hyperbolicEuclideanVolume := by + rw [←hm.map_eq] at hh ⊢ + exact integral_map hm.measurable.aemeasurable hh + rw [he,hyperbolicEuclidean_setIntegral_complex cuspEuclideanStrip + cuspEuclideanStrip_measurable cuspEuclideanStrip_positive] + have hsplit := spatialComplexSplit.measurableEmbedding.setIntegral_map + (fun q : ℝ × ℂ => g (cuspCoordinateLift q)/(q.1:ℂ)^3) + (Set.Icc (5:ℝ) 6 ×ˢ periodDomain) («μ» := (volume : Measure EuclideanSpatial)) + rw [spatialComplexSplit_preserves_volume.map_eq] at hsplit + have heq : (∫p in cuspEuclideanStrip,g (euclideanToHyperbolic p)/(p 2:ℂ)^3)= + ∫q in Set.Icc (5:ℝ) 6 ×ˢ periodDomain,g (cuspCoordinateLift q)/(q.1:ℂ)^3 := by + rw [hsplit] + simp only [cuspEuclideanStrip,cuspCoordinateLift,spatialComplexSplit.symm_apply_apply, + spatialComplexSplit_fst] + rw [heq] + change (∫q in Set.Icc (5:ℝ) 6 ×ˢ periodDomain, + g (cuspCoordinateLift q)/(q.1:ℂ)^3 ∂((volume : Measure ℝ).prod volume))=_ + rw [setIntegral_prod _ hint] + congr 1 + ext v + exact integral_div ((v:ℂ)^3) (fun z => g (cuspCoordinateLift (v,z))) + +lemma hyperbolicEisenstein_continuous (s : ℂ) (hs : 2 + upperEisenstein p.1.1 p.1.2 p.2 s) := by + apply continuous_iff_continuousAt.mpr + intro p + have hin : ContinuousAt (fun q : UpperCoordinates => (q,s)) p := + continuousAt_id.prodMk continuousAt_const + exact ContinuousAt.comp (f := fun q : UpperCoordinates => (q,s)) + (upperEisenstein_joint_continuousAt (p,s) hs) hin + convert hcoord.comp hyperbolicCoordinates_continuous using 1 + ext w + obtain ⟨z,v,hv,rfl⟩ := upperPoint_surjective w + simp only [Function.comp_def,hyperbolicEisenstein_upperPoint,hyperbolicCoordinates, + hyperbolicHorizontal_upperPoint,hyperbolicHeight_upperPoint] + +lemma spatialComplexSplit_symm_eq (q : ℝ × ℂ) : + spatialComplexSplit.symm q=WithLp.toLp 2 ![q.2.re,q.2.im,q.1] := by + apply spatialComplexSplit.injective + rw [spatialComplexSplit.apply_symm_apply] + apply Prod.ext + · rfl + · exact (Complex.re_add_im q.2).symm + +lemma spatialComplexSplit_symm_continuous : Continuous spatialComplexSplit.symm := by + change Continuous (fun q : ℝ × ℂ => spatialComplexSplit.symm q) + simp_rw [spatialComplexSplit_symm_eq] + fun_prop + +lemma cuspCoordinateLift_continuousAt (q : ℝ × ℂ) (hq : 0 g (cuspCoordinateLift q)/(q.1:ℂ)^3) + (Set.Icc (5:ℝ) 6 ×ˢ periodDomain) volume := by + let radiusBound : ℝ := ∑i,‖periodBasis i‖ + have hc : ContinuousOn (fun q : ℝ × ℂ => g (cuspCoordinateLift q)/(q.1:ℂ)^3) + (Set.Icc (5:ℝ) 6 ×ˢ Metric.closedBall (0:ℂ) radiusBound) := by + intro q hq + have hpos : 0 (v:ℂ)^s) (Set.Icc (5:ℝ) 6) volume := by + apply ContinuousOn.integrableOn_Icc + intro v hv + exact (Complex.continuousAt_ofReal_cpow_const v s (Or.inr (by linarith [hv.1]))).continuousWithinAt + +lemma cuspMainHeightFactor_integral (s : ℂ) (hs : s≠2) : + (∫v in Set.Icc (5:ℝ) 6,(v:ℂ)^(s-3))=cuspMainHeightFactor s := by + rw [integral_Icc_eq_integral_Ioc,←intervalIntegral.integral_of_le (by norm_num : (5:ℝ)≤6)] + have hr : s-3≠(-1:ℂ) := by intro h; apply hs; linear_combination h + rw [integral_cpow (Or.inr ⟨hr,by norm_num⟩)] + change ((6:ℂ)^(s-3+1)-(5:ℂ)^(s-3+1))/(s-3+1)=_ + have he : s-3+1=s-2 := by ring + rw [he] + rfl + +lemma cuspScatterHeightFactor_integral (s : ℂ) (hs : s≠0) : + (∫v in Set.Icc (5:ℝ) 6,(v:ℂ)^(-s-1))=cuspScatterHeightFactor s := by + rw [integral_Icc_eq_integral_Ioc,←intervalIntegral.integral_of_le (by norm_num : (5:ℝ)≤6)] + have hr : -s-1≠(-1:ℂ) := by intro h; apply hs; linear_combination -h + rw [integral_cpow (Or.inr ⟨hr,by norm_num⟩)] + change ((6:ℂ)^(-s-1+1)-(5:ℂ)^(-s-1+1))/(-s-1+1)=_ + have he : -s-1+1=-s := by ring + rw [he,cuspScatterHeightFactor] + ring + +lemma cuspMainHeightFactor_differentiableAt (s : ℂ) (hs : s≠2) : + DifferentiableAt ℂ cuspMainHeightFactor s := by + have hd : DifferentiableAt ℂ (fun z : ℂ => z-2) s := differentiableAt_id.sub_const 2 + exact ((hd.const_cpow (Or.inl (by norm_num))).sub + (hd.const_cpow (Or.inl (by norm_num)))).div hd (sub_ne_zero.mpr hs) + +lemma cuspScatterHeightFactor_differentiableAt (s : ℂ) (hs : s≠0) : + DifferentiableAt ℂ cuspScatterHeightFactor s := by + have hd : DifferentiableAt ℂ (fun z : ℂ => -z) s := differentiableAt_id.neg + exact ((hd.const_cpow (Or.inl (by norm_num))).sub + (hd.const_cpow (Or.inl (by norm_num)))).div differentiableAt_id hs + +def cuspConstantAverage (s : ℂ) : ℂ := + ((9*Real.sqrt 3/2:ℝ):ℂ)*(cuspMainHeightFactor s+ + ((Real.pi:ℂ)/(s-1))*scatteringCoefficient s 0*cuspScatterHeightFactor s) + +lemma hyperbolicEisenstein_cusp_average_eq (s : ℂ) (hs : 2 scatteringCoefficient z 0) s := + (arithmeticDirichletSeries_zero_differentiableAt s hs).div_const _ + exact ((cuspMainHeightFactor_differentiableAt s hs2).add + ((((differentiableAt_const (Real.pi:ℂ)).div (differentiableAt_id.sub_const 1) + (sub_ne_zero.mpr hs1)).mul hsc).mul + (cuspScatterHeightFactor_differentiableAt s hs0))).const_mul _ + +lemma cuspScatterHeightFactor_center_re_pos : + 0<(cuspScatterHeightFactor (4/3:ℂ)).re := by + have h5 := Complex.ofReal_cpow (by norm_num : (0:ℝ)≤5) (-(4/3:ℝ)) + have h6 := Complex.ofReal_cpow (by norm_num : (0:ℝ)≤6) (-(4/3:ℝ)) + norm_num only [Complex.ofReal_neg,Complex.ofReal_div,Complex.ofReal_ofNat] at h5 h6 + have he : cuspScatterHeightFactor (4/3:ℂ)= + (((5:ℝ)^(-(4/3:ℝ))-(6:ℝ)^(-(4/3:ℝ)))/(4/3:ℝ):ℝ) := by + rw [cuspScatterHeightFactor,←h5,←h6] + push_cast + rfl + rw [he,Complex.ofReal_re] + apply div_pos + · exact sub_pos.mpr (Real.rpow_lt_rpow_of_neg (by norm_num) (by norm_num) (by norm_num)) + · norm_num + +def cuspConstantAverageResidue : ℂ := + ((9*Real.sqrt 3/2:ℝ):ℂ)*(3*(Real.pi:ℂ))*constantArithmeticResidue* + cuspScatterHeightFactor (4/3:ℂ) + +lemma cuspConstantAverageResidue_ne_zero : cuspConstantAverageResidue≠0 := by + apply mul_ne_zero + · exact mul_ne_zero (mul_ne_zero cusp_volume_ne_zero + (mul_ne_zero (by norm_num) (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero))) + constantArithmeticResidue_ne_zero + · intro he + have hh := cuspScatterHeightFactor_center_re_pos + rw [he,Complex.zero_re] at hh + exact lt_irrefl 0 hh + +lemma cuspConstantAverage_oneSidedResidue : + Tendsto (fun x : ℝ => ((x:ℂ)-(4/3:ℂ))*cuspConstantAverage (x:ℂ)) + (𝓝[>] (4/3:ℝ)) (𝓝 cuspConstantAverageResidue) := by + have harg : Tendsto (fun x : ℝ => (x:ℂ)) (𝓝[>] (4/3:ℝ)) (𝓝 (4/3:ℂ)) := by + convert Complex.continuous_ofReal.continuousAt.tendsto.mono_left nhdsWithin_le_nhds using 1 ; norm_num + have hlinear := harg.sub_const (4/3:ℂ) + norm_num only [sub_self] at hlinear + have hm := (cuspMainHeightFactor_differentiableAt (4/3:ℂ) (by norm_num)).continuousAt.tendsto.comp harg + have hh := (cuspScatterHeightFactor_differentiableAt (4/3:ℂ) (by norm_num)).continuousAt.tendsto.comp harg + have hpi : Tendsto (fun x : ℝ => (Real.pi:ℂ)/((x:ℂ)-1)) + (𝓝[>] (4/3:ℝ)) (𝓝 (3*(Real.pi:ℂ))) := by + convert tendsto_const_nhds.div (harg.sub_const 1) (by norm_num : (4/3:ℂ)-1≠0) using 1 ; ring_nf + have hall := ((hlinear.mul hm).add + ((hpi.mul scatteringCoefficient_zero_oneSidedResidue).mul hh)).const_mul + ((9*Real.sqrt 3/2:ℝ):ℂ) + convert hall using 1 + · ext x + dsimp only [cuspConstantAverage,Function.comp_def] + ring + · simp only [zero_mul,zero_add,cuspConstantAverageResidue] + ring_nf + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +lemma kernelSpectralResolvent_analyticAt_of_isUnit (z : ℂ) + (hz : IsUnit (kernelSpectralFormOperator z)) : + AnalyticAt ℂ kernelSpectralResolvent z := by + exact (ContinuousLinearMap.analyticAt (𝕜 := ℂ) + (E := KernelEnergyGraph→L[ℂ]KernelEnergyGraph) + (F := KernelQuotientL2→L[ℂ]KernelQuotientL2) kernelL2SandwichCLM + (Ring.inverse (kernelSpectralFormOperator z))).comp_of_eq + (kernelSpectralFormInverse_analyticAt_of_isUnit z hz) rfl + +lemma kernelEisensteinResolvent_analyticAt_of_isUnit (s : ℂ) + (hs : IsUnit (kernelSpectralFormOperator (kernelEisensteinSpectralParameter s))) : + AnalyticAt ℂ kernelEisensteinResolvent s := by + exact (kernelSpectralResolvent_analyticAt_of_isUnit _ hs).comp_of_eq + (by unfold kernelEisensteinSpectralParameter; fun_prop) rfl + +lemma kernelCuspAverageFamily_analyticAt_of_isUnit (a b : ℝ) (ha : 0 (x:ℂ)+(t:ℂ)*Complex.I) (𝓝[>] (0:ℝ)) (𝓝 (x:ℂ)) := by + have hcont : Continuous (fun t : ℝ => (x:ℂ)+(t:ℂ)*Complex.I) := + (Complex.continuous_ofReal.mul_const Complex.I).const_add (x:ℂ) + have hh := (hcont.tendsto 0).mono_left (show 𝓝[>] (0:ℝ)≤𝓝 0 from nhdsWithin_le_nhds) + simpa only [Complex.ofReal_zero,zero_mul,add_zero] using hh + have hleft := (kernelCuspAverageFamily_analyticAt_of_isUnit a b ha hab (x:ℂ) hunit).continuousAt.tendsto.comp hpath + have hx2' : (x:ℂ)≠2 := by exact_mod_cast hx2 + have hright := (cuspConstantAverage_differentiableAt (x:ℂ) hx hx2').continuousAt.tendsto.comp hpath + have hevent : (fun t : ℝ => kernelCuspAverageFamily a b ha hab ((x:ℂ)+(t:ℂ)*Complex.I)) + =ᶠ[𝓝[>] (0:ℝ)] (fun t : ℝ => cuspConstantAverage ((x:ℂ)+(t:ℂ)*Complex.I)) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 (x:ℂ)) (𝓝[>] (4/3:ℝ)) (𝓝[≠] (4/3:ℂ)) := by + apply tendsto_nhdsWithin_iff.mpr + constructor + · convert Complex.continuous_ofReal.continuousAt.tendsto.mono_left nhdsWithin_le_nhds using 1 ; norm_num + · filter_upwards [self_mem_nhdsWithin] with x hx + change (4/3:ℝ)] (4/3:ℝ),x<2 := by + have hh : ∀ᶠx : ℝ in 𝓝 (4/3:ℝ),x<2 := Iio_mem_nhds (by norm_num) + exact hh.filter_mono nhdsWithin_le_nhds + have hevent : (fun x : ℝ => ((x:ℂ)-4/3)*kernelCuspAverageFamily a b ha hab (x:ℂ)) + =ᶠ[𝓝[>] (4/3:ℝ)] (fun x : ℝ => ((x:ℂ)-4/3)*cuspConstantAverage (x:ℂ)) := by + filter_upwards [self_mem_nhdsWithin,hunit,hlt] with x hx hux hxx + rw [kernelCuspAverageFamily_eq_real_of_upper a b ha hab hupper x hx hxx.ne hux] + exact tendsto_nhds_unique_of_eventuallyEq hleft cuspConstantAverage_oneSidedResidue hevent + +lemma kernelEisensteinResidueVector_ne_zero_of_overlap (a b : ℝ) (ha : 0 (hf n).toLp (f n)) atTop (𝓝 (hg.toLp g)) := by + have hsq : Tendsto (fun n => ∫a,‖f n a-g a‖^2∂«μ») atTop (𝓝 0) := by + have h := tendsto_integral_of_dominated_convergence («μ» := «μ») + (F := fun n a => ‖f n a-g a‖^2) (f := fun _ => (0:ℝ)) (fun _ => (B+C)^2) + (fun n => ((hf n).aestronglyMeasurable.sub hg.aestronglyMeasurable).norm.pow 2) + (integrable_const _) ?_ ?_ + · simpa only [integral_zero] using h + · intro n + exact Eventually.of_forall (fun a => by + rw [Real.norm_of_nonneg (sq_nonneg _)] + apply (sq_le_sq₀ (norm_nonneg _) (add_nonneg hB hC)).mpr + exact (norm_sub_le _ _).trans (add_le_add (hfB n a) (hgC a))) + · exact Eventually.of_forall (fun a => by + apply tendsto_const_nhds.congr' + filter_upwards [hlim a] with n hn + simp only [hn,sub_self,norm_zero,zero_pow (by decide : 2≠0)]) + have hn : Tendsto (fun n => ‖(hf n).toLp (f n)-hg.toLp g‖^2) atTop (𝓝 0) := by + simpa only [l2_toLp_sub_norm_sq] using hsq + apply tendsto_iff_norm_sub_tendsto_zero.mpr + have hsqrt := Real.continuous_sqrt.continuousAt.tendsto.comp hn + simpa only [Function.comp_def,Real.sqrt_sq_eq_abs,abs_norm,Real.sqrt_zero] using hsqrt + +end BoundedConvergence + +instance kernelFundamentalVolume_finite : IsFiniteMeasure KernelFundamentalVolume := by + refine ⟨?_⟩ + change (hyperbolicVolume.restrict (hyperbolicFundamentalSet globalKubotaKernel)) Set.univ<⊤ + rw [Measure.restrict_apply MeasurableSet.univ,Set.univ_inter] + let : globalKubotaKernel.FiniteIndex := globalKubotaKernel_finiteIndex + exact hyperbolicFundamentalSet_volume_lt_top globalKubotaKernel globalKubotaKernel_le_levelThree + +def kernelFunctionField (f : KernelQuotient→ℂ) (p : EuclideanSpatial) : ℂ := + f (kernelEuclideanProjection p) + +lemma kernelFunctionField_smooth (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) + (p : EuclideanSpatial) (hp : 0

(hyperbolicHeight w:ℂ)* + fderiv ℝ (kernelFunctionField f) (hyperbolicEuclideanCoordinates w) (euclideanCoordinateVector j)) + +lemma kernelFunctionGradient_continuous (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) : + Continuous (kernelFunctionGradient f) := by + apply (PiLp.continuousLinearEquiv 2 ℂ (fun _ : Fin 3 => ℂ)).symm.continuous.comp + apply continuous_pi + intro j + apply (Complex.continuous_ofReal.comp hyperbolicHeight_continuous).mul + rw [continuous_iff_continuousAt] + intro w + exact (((kernelFunctionField_smooth f hf _ (hyperbolicHeight_pos w)).continuousAt_fderiv + (by simp)).clm_apply continuousAt_const).comp hyperbolicEuclideanCoordinates_continuous.continuousAt + +lemma norm_three_vector_bound (v : EuclideanSpace ℂ (Fin 3)) (B : ℝ) (hB : 0≤B) + (hv : ∀j,‖v j‖≤B) : ‖v‖≤3*B := by + have hsq : ‖v‖^2≤3*B^2 := by + rw [PiLp.norm_sq_eq_of_L2] + calc + _ ≤ ∑j : Fin 3,B^2 := Finset.sum_le_sum (fun j hj => + (sq_le_sq₀ (norm_nonneg _) hB).mpr (hv j)) + _ = _ := by simp + nlinarith [norm_nonneg v,sq_nonneg B] + +lemma kernelFunctionGradient_bound (f : KernelQuotient→ℂ) (B : ℝ) (hB : 0≤B) + (hgrad : ∀p : EuclideanSpatial,0

(kernelExhaustionCutoff n q:ℂ)*f q,?_,?_⟩ + · have hm : ContDiff ℝ ∞ (fun z : ℂ × ℂ => z.1*z.2) := contDiff_fst.mul contDiff_snd + exact hm.contMDiff.comp + ((Complex.ofRealCLM.contDiff.contMDiff.comp (kernelExhaustionCutoff_smooth n)).prodMk_space hf) + · apply HasCompactSupport.of_support_subset_isCompact (kernelExhaustionCutoff_hasCompactSupport n) + intro q hq + by_contra hn + have hz : kernelExhaustionCutoff n q=0 := image_eq_zero_of_notMem_tsupport hn + exact hq (by simp [hz]) + +lemma kernelFunctionCutoff_apply (n : ℕ) (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) (q : KernelQuotient) : + (kernelFunctionCutoff n f hf).1 q=(kernelExhaustionCutoff n q:ℂ)*f q := rfl + +lemma kernelFunctionCutoff_field (n : ℕ) (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) : + kernelTestField (kernelFunctionCutoff n f hf)= + fun p => (kernelExhaustionCutoff n (kernelEuclideanProjection p):ℂ)*kernelFunctionField f p := rfl + +lemma kernelFunctionGradient_of_test (f : kernelSmoothTests) (w : HyperbolicSpace) : + kernelFunctionGradient f.1 w=kernelGradientAt w f := by + unfold kernelFunctionGradient + simp only [euclideanCoordinateVector_eq_basis] + rfl + +lemma kernelFunctionCutoff_field_eventually (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) + (p : EuclideanSpatial) (hp : 0

(kernelExhaustionCutoff n (kernelEuclideanProjection q):ℂ)) p + (euclideanCoordinateVector j)‖≤D) + (n : ℕ) (p : EuclideanSpatial) (hp : 0

(kernelExhaustionCutoff n (kernelEuclideanProjection q):ℂ) + have hc : DifferentiableAt ℝ c p := + (kernelFunctionField_smooth (fun q => (kernelExhaustionCutoff n q:ℂ)) + (Complex.ofRealCLM.contDiff.contMDiff.comp (kernelExhaustionCutoff_smooth n)) p hp).differentiableAt (by simp) + have hd := (kernelFunctionField_smooth f hf p hp).differentiableAt (by simp) + rw [kernelFunctionCutoff_field,fderiv_fun_mul hc hd] + simp only [_root_.add_apply,_root_.smul_apply,smul_eq_mul] + have he : (p 2:ℂ)*(c p*fderiv ℝ (kernelFunctionField f) p (euclideanCoordinateVector j)+ + kernelFunctionField f p*fderiv ℝ c p (euclideanCoordinateVector j))= + c p*((p 2:ℂ)*fderiv ℝ (kernelFunctionField f) p (euclideanCoordinateVector j))+ + kernelFunctionField f p*((p 2:ℂ)*fderiv ℝ c p (euclideanCoordinateVector j)) := by ring + change ‖(p 2:ℂ)*(c p*fderiv ℝ (kernelFunctionField f) p (euclideanCoordinateVector j)+ + kernelFunctionField f p*fderiv ℝ c p (euclideanCoordinateVector j))‖≤_ + rw [he] + apply (norm_add_le _ _).trans + rw [norm_mul,norm_mul] + have hc1 : ‖c p‖≤1 := by + rw [Complex.norm_of_nonneg (kernelExhaustionCutoff_bounds n _).1] + exact (kernelExhaustionCutoff_bounds n _).2 + have hleft : ‖c p‖*‖(p 2:ℂ)*fderiv ℝ (kernelFunctionField f) p (euclideanCoordinateVector j)‖≤G := + (mul_le_mul hc1 (hgrad p hp j) (norm_nonneg _) zero_le_one).trans_eq (one_mul G) + have hright : ‖kernelFunctionField f p‖*‖(p 2:ℂ)*fderiv ℝ c p (euclideanCoordinateVector j)‖≤B*D := + mul_le_mul (hfB (kernelEuclideanProjection p)) (hcut n p hp j) (norm_nonneg _) hB + simpa only [norm_mul] using add_le_add hleft hright + +lemma kernelFunctionCutoff_gradient_bound (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) + (B G : ℝ) (hB : 0≤B) (hG : 0≤G) (hfB : ∀q,‖f q‖≤B) + (hgrad : ∀p : EuclideanSpatial,0

kernelSmoothTestsToL2 (kernelFunctionCutoff n f hf)) atTop (𝓝 (hfL.toLp f)) := by + apply l2_tendsto_of_bounded_eventuallyEq (integralQuotientVolume globalKubotaKernel) + (fun n => (kernelFunctionCutoff n f hf).1) f + (fun n => kernelSmoothTests_memLp (kernelFunctionCutoff n f hf)) hfL B B hB hB + (kernelFunctionCutoff_mass_bound f hf B hB hbound) hbound + intro q + filter_upwards [kernelExhaustionCutoff_eventually_one q] with n hn + rw [kernelFunctionCutoff_apply,hn] + simp + +theorem kernelFunctionCutoff_gradient_tendsto (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) + (hgL : MemLp (kernelFunctionGradient f) 2 KernelFundamentalVolume) + (B G : ℝ) (hB : 0≤B) (hG : 0≤G) (hfB : ∀q,‖f q‖≤B) + (hgrad : ∀p : EuclideanSpatial,0

kernelGradientToL2 (kernelFunctionCutoff n f hf)) atTop + (𝓝 (hgL.toLp (kernelFunctionGradient f))) := by + obtain ⟨D,hD,hbound⟩ := kernelFunctionCutoff_gradient_bound f hf B G hB hG hfB hgrad + apply l2_tendsto_of_bounded_eventuallyEq KernelFundamentalVolume + (fun n w => kernelGradientAt w (kernelFunctionCutoff n f hf)) (kernelFunctionGradient f) + (fun n => kernelGradientAt_memLp (kernelFunctionCutoff n f hf)) hgL D (3*G) hD (by positivity) + hbound (kernelFunctionGradient_bound f G hG hgrad) + exact kernelFunctionCutoff_gradient_eventually f hf + +theorem kernel_bounded_smooth_energy_exists (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) + (hfL : MemLp f 2 (integralQuotientVolume globalKubotaKernel)) + (hgL : MemLp (kernelFunctionGradient f) 2 KernelFundamentalVolume) + (B G : ℝ) (hB : 0≤B) (hG : 0≤G) (hfB : ∀q,‖f q‖≤B) + (hgrad : ∀p : EuclideanSpatial,0

kernelEnergyCore (kernelFunctionCutoff n f hf)) atTop (𝓝 x) := by + have h := (WithLp.prodContinuousLinearEquiv 2 ℂ KernelQuotientL2 KernelGradientL2).symm.continuous.continuousAt.tendsto.comp hp + exact h + have hx : x∈kernelEnergyGraphSubmodule := by + change x∈closure (Set.range kernelEnergyCore) + exact mem_closure_of_tendsto ht (Eventually.of_forall (fun n => ⟨kernelFunctionCutoff n f hf,rfl⟩)) + exact ⟨⟨x,hx⟩,rfl,rfl⟩ + +def kernelEisensteinRemainderL2 (a b : ℝ) (ha : 1 exact eisenstein_sub_seed_bounded a b ha.le hab s hs w + obtain ⟨G,hG,hgrad⟩ := kernelEisensteinRemainder_scaled_fderiv_bound a b ha hab s hs + have hgrad' : ∀p : EuclideanSpatial,0

Function.update p j t) := by + apply contDiff_pi.mpr + intro k + by_cases h : k=j + · subst k + simpa only [Function.update_self,id_eq] using! (contDiff_id : ContDiff ℝ ∞ (fun t : ℝ => t)) + · simpa only [Function.update_of_ne h] using (contDiff_const : ContDiff ℝ ∞ (fun _ : ℝ => p k)) + +lemma smooth_positive_axis_regular (f : SpatialCoordinates→ℂ) + (hf : ∀p,0

f q-g q) p=axisLaplacian f p-axisLaplacian g p := by + let F : Fin 2→SpatialCoordinates→ℂ:=![f,fun q => (-1:ℂ)*g q] + have hF : ∀i : Fin 2,∀q,0 smooth_positive_axis_regular (F i) (hF i) q hq j) p hp + have he : (fun q => ∑i : Fin 2,F i q)=(fun q => f q-g q) := by + funext q + simp [F,Fin.sum_univ_two,sub_eq_add_neg] + rw [he] at hh + simp only [Fin.sum_univ_two,F,Matrix.cons_val_zero,Matrix.cons_val_one] at hh + rw [axisLaplacian_const_mul] at hh + simpa only [neg_one_mul,sub_eq_add_neg] using hh + +lemma eisensteinRemainder_coordinate_equation (a b : ℝ) (ha : 1 inner ℂ (kernelGradientToL2 (kernelFunctionCutoff n f hf)) + (kernelGradientToL2 g)) atTop (𝓝 (inner ℂ (hgL.toLp (kernelFunctionGradient f)) (kernelGradientToL2 g))) := + (kernelFunctionCutoff_gradient_tendsto f hf hgL B G hB hG hfB hgrad).inner + (tendsto_const_nhds (x := kernelGradientToL2 g)) + exact tendsto_nhds_unique hlim (tendsto_const_nhds.congr' (hconstant.mono (fun n hn => hn.symm))) + +theorem kernel_bounded_smooth_operator_graph (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) + (hfL : MemLp f 2 (integralQuotientVolume globalKubotaKernel)) + (B G : ℝ) (hB : 0≤B) (hG : 0≤G) (hfB : ∀q,‖f q‖≤B) + (hgrad : ∀p : EuclideanSpatial,0

+ inner ℂ (kernelEnergyGradient u) (kernelEnergyGradient v))) + (by fun_prop : Continuous (fun v : KernelEnergyGraph => inner ℂ (hA.toLp A) (kernelEnergyMass v)))) + (fun g => by + rw [hug,kernelEnergyGradient_core,kernelEnergyMass_core] + exact kernelBoundedFunction_form_equation f hf hgL B G hB hG hfB hgrad A hA hEq g) + have hu : u=kernelVariationalSolution (hfL.toLp f+hA.toLp A) := by + apply kernelVariationalSolution_unique + intro v + rw [hum,hform v,inner_add_left] + have hm := congrArg kernelEnergyMass hu + rw [hum] at hm + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] + exact hm.symm + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold + +theorem kernelEisensteinRemainderL2_graph (a b : ℝ) (ha : 1 exact eisenstein_sub_seed_bounded a b ha.le hab s hs w + obtain ⟨G,hG,hgrad⟩ := kernelEisensteinRemainder_scaled_fderiv_bound a b ha hab s hs + let A : KernelQuotient→ℂ := fun q => kernelQuotientDefect a b s q+ + kernelEisensteinSpectralParameter s*f q + have hD := kernelQuotientDefect_memLp a b s (by linarith) hab + have hA : MemLp A 2 (integralQuotientVolume globalKubotaKernel) := + hD.add (hfL.const_smul (kernelEisensteinSpectralParameter s)) + have hEq : ∀p : EuclideanSpatial,0

hD.toLp (kernelQuotientDefect a b s)+x) + (hfL.toLp_const_smul (kernelEisensteinSpectralParameter s))) + rw [hAL] at hgraph + exact hgraph + +theorem kernelEisensteinL2Correction_eq_remainder (a b : ℝ) (ha : 1 kernelQuotientEisenstein s (by linarith) q-kernelQuotientSeed a b s q := by + rw [kernelEisensteinL2Correction_eq_remainder a b ha hab s hs hi] + exact kernelEisensteinRemainderL2_ae a b ha hab s hs + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/DirichletForm.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/DirichletForm.lean new file mode 100644 index 0000000000000000000000000000000000000000..31e55062e1bc4afba39d17724f7fdd772f271346 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/DirichletForm.lean @@ -0,0 +1,617 @@ +import OAI.NumberTheory.DirichletL.GaussSum.ReflectedBranches + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold ENNReal MatrixGroups + +namespace CubicEisenstein + +def kernelTestPartial (f : kernelSmoothTests) (w : HyperbolicSpace) (j : Fin 3) : ℂ := + fderiv ℝ (kernelTestField f) (hyperbolicEuclideanCoordinates w) (EuclideanSpace.basisFun (Fin 3) ℝ j) + +lemma kernelTestPartial_add (f g : kernelSmoothTests) (w : HyperbolicSpace) (j : Fin 3) : + kernelTestPartial (f+g) w j=kernelTestPartial f w j+kernelTestPartial g w j := by + unfold kernelTestPartial + have he : kernelTestField (f+g)=kernelTestField f+kernelTestField g := rfl + rw [he,fderiv_add ((kernelTestField_contDiffAt f _ (hyperbolicHeight_pos w)).differentiableAt (by simp)) + ((kernelTestField_contDiffAt g _ (hyperbolicHeight_pos w)).differentiableAt (by simp))] + rfl + +lemma kernelTestPartial_sub (f g : kernelSmoothTests) (w : HyperbolicSpace) (j : Fin 3) : + kernelTestPartial (f-g) w j=kernelTestPartial f w j-kernelTestPartial g w j := by + unfold kernelTestPartial + have he : kernelTestField (f-g)=kernelTestField f-kernelTestField g := rfl + rw [he,fderiv_sub ((kernelTestField_contDiffAt f _ (hyperbolicHeight_pos w)).differentiableAt (by simp)) + ((kernelTestField_contDiffAt g _ (hyperbolicHeight_pos w)).differentiableAt (by simp))] + rfl + +lemma kernelTestPartial_smul (c : ℂ) (f : kernelSmoothTests) (w : HyperbolicSpace) (j : Fin 3) : + kernelTestPartial (c•f) w j=c*kernelTestPartial f w j := by + unfold kernelTestPartial + have he : kernelTestField (c•f)=c•kernelTestField f := rfl + rw [he,fderiv_const_smul ((kernelTestField_contDiffAt f _ (hyperbolicHeight_pos w)).differentiableAt (by simp))] + rfl + +lemma kernelTestEnergyDensity_eq_partials (f : kernelSmoothTests) (w : HyperbolicSpace) : + kernelTestEnergyDensity f w=(hyperbolicHeight w)^2*∑j:Fin 3,‖kernelTestPartial f w j‖^2 := by + have hd := ((kernelTestField_contDiffAt f (hyperbolicEuclideanCoordinates w) (hyperbolicHeight_pos w)).differentiableAt (by simp)).hasFDerivAt + have hr := (Complex.reCLM.hasFDerivAt.comp (hyperbolicEuclideanCoordinates w) hd).fderiv + have hi := (Complex.imCLM.hasFDerivAt.comp (hyperbolicEuclideanCoordinates w) hd).fderiv + change fderiv ℝ (fun p => (kernelTestField f p).re) (hyperbolicEuclideanCoordinates w)=_ at hr + change fderiv ℝ (fun p => (kernelTestField f p).im) (hyperbolicEuclideanCoordinates w)=_ at hi + unfold kernelTestEnergyDensity euclideanScalarDirichletDensity + rw [hr,hi,(EuclideanSpace.basisFun (Fin 3) ℝ).norm_dual, + (EuclideanSpace.basisFun (Fin 3) ℝ).norm_dual,←mul_add,←Finset.sum_add_distrib] + congr 1 + apply Finset.sum_congr rfl + intro j hj + change (kernelTestPartial f w j).re^2+(kernelTestPartial f w j).im^2=‖kernelTestPartial f w j‖^2 + simpa only [Complex.normSq_apply,pow_two] using Complex.normSq_eq_norm_sq (kernelTestPartial f w j) + +lemma kernelTestEnergyDensity_smul (c : ℂ) (f : kernelSmoothTests) (w : HyperbolicSpace) : + kernelTestEnergyDensity (c•f) w=‖c‖^2*kernelTestEnergyDensity f w := by + simp only [kernelTestEnergyDensity_eq_partials,kernelTestPartial_smul,norm_mul,mul_pow,←Finset.mul_sum] + ring + +lemma kernelTestEnergyDensity_parallelogram (f g : kernelSmoothTests) (w : HyperbolicSpace) : + kernelTestEnergyDensity (f+g) w+kernelTestEnergyDensity (f-g) w= + 2*(kernelTestEnergyDensity f w+kernelTestEnergyDensity g w) := by + simp only [kernelTestEnergyDensity_eq_partials,kernelTestPartial_add,kernelTestPartial_sub] + rw [←mul_add,←Finset.sum_add_distrib] + simp only [parallelogram_law_with_norm ℂ,←Finset.mul_sum,Finset.sum_add_distrib] + ring + +lemma kernelQuotientEnergyDensity_smul (c : ℂ) (f : kernelSmoothTests) (q : KernelQuotient) : + kernelQuotientEnergyDensity (c•f) q=‖c‖^2*kernelQuotientEnergyDensity f q := by + induction q using Quotient.inductionOn with + | _ w => exact kernelTestEnergyDensity_smul c f w + +lemma kernelQuotientEnergyDensity_parallelogram (f g : kernelSmoothTests) (q : KernelQuotient) : + kernelQuotientEnergyDensity (f+g) q+kernelQuotientEnergyDensity (f-g) q= + 2*(kernelQuotientEnergyDensity f q+kernelQuotientEnergyDensity g q) := by + induction q using Quotient.inductionOn with + | _ w => exact kernelTestEnergyDensity_parallelogram f g w + +lemma kernelDirichletEnergy_smul (c : ℂ) (f : kernelSmoothTests) : + kernelDirichletEnergy (c•f)=‖c‖^2*kernelDirichletEnergy f := by + unfold kernelDirichletEnergy + simp_rw [kernelQuotientEnergyDensity_smul] + exact integral_const_mul _ _ + +lemma kernelDirichletEnergy_parallelogram (f g : kernelSmoothTests) : + kernelDirichletEnergy (f+g)+kernelDirichletEnergy (f-g)= + 2*(kernelDirichletEnergy f+kernelDirichletEnergy g) := by + unfold kernelDirichletEnergy + rw [←integral_add (kernelQuotientEnergyDensity_integrable _) (kernelQuotientEnergyDensity_integrable _)] + simp_rw [kernelQuotientEnergyDensity_parallelogram] + rw [integral_const_mul,integral_add (kernelQuotientEnergyDensity_integrable _) (kernelQuotientEnergyDensity_integrable _)] + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold ENNReal MatrixGroups InnerProductSpace + +def kernelGradientAt (w : HyperbolicSpace) : kernelSmoothTests→ₗ[ℂ]EuclideanSpace ℂ (Fin 3) where + toFun f := WithLp.toLp 2 (fun j => (hyperbolicHeight w:ℂ)*kernelTestPartial f w j) + map_add' f g := by + apply (WithLp.equiv 2 (Fin 3→ℂ)).injective + funext j + simp [kernelTestPartial_add,mul_add] + map_smul' c f := by + apply (WithLp.equiv 2 (Fin 3→ℂ)).injective + funext j + simp [kernelTestPartial_smul,smul_eq_mul,mul_left_comm] + +lemma kernelGradientAt_norm_sq (w : HyperbolicSpace) (f : kernelSmoothTests) : + ‖kernelGradientAt w f‖^2=kernelTestEnergyDensity f w := by + rw [PiLp.norm_sq_eq_of_L2,kernelTestEnergyDensity_eq_partials] + change (∑j:Fin 3,‖(hyperbolicHeight w:ℂ)*kernelTestPartial f w j‖^2)=_ + simp only [norm_mul,mul_pow,Complex.norm_real,Real.norm_of_nonneg (hyperbolicHeight_pos w).le, + Finset.mul_sum] + +def kernelDirichletPairDensity (f g : kernelSmoothTests) (q : KernelQuotient) : ℂ := + ((kernelQuotientEnergyDensity (f+g) q:ℂ)-(kernelQuotientEnergyDensity (f-g) q:ℂ)+ + ((kernelQuotientEnergyDensity (f-Complex.I•g) q:ℂ)- + (kernelQuotientEnergyDensity (f+Complex.I•g) q:ℂ))*Complex.I)/4 + +lemma kernelDirichletPairDensity_coordinate (f g : kernelSmoothTests) (w : HyperbolicSpace) : + kernelDirichletPairDensity f g (integralOrbitProjection globalKubotaKernel w)= + inner ℂ (kernelGradientAt w f) (kernelGradientAt w g) := by + rw [inner_eq_sum_norm_sq_div_four] + simp only [←map_add,←map_sub,←map_smul,RCLike.ofReal_eq_complex_ofReal,←Complex.ofReal_pow,kernelGradientAt_norm_sq] + rfl + +lemma kernelDirichletPairDensity_integrable (f g : kernelSmoothTests) : + Integrable (kernelDirichletPairDensity f g) (integralQuotientVolume globalKubotaKernel) := by + have hf : ∀h : kernelSmoothTests,Integrable (fun q => (kernelQuotientEnergyDensity h q:ℂ)) + (integralQuotientVolume globalKubotaKernel) := fun h => + (kernelQuotientEnergyDensity_integrable h).ofReal + exact ((hf (f+g)).sub (hf (f-g)) |>.add (((hf (f-Complex.I•g)).sub (hf (f+Complex.I•g))).mul_const _)).div_const _ + +lemma kernelDirichletPairDensity_add_right (f g h : kernelSmoothTests) (q : KernelQuotient) : + kernelDirichletPairDensity f (g+h) q=kernelDirichletPairDensity f g q+kernelDirichletPairDensity f h q := by + induction q using Quotient.inductionOn with + | _ w => simp only [←show integralOrbitProjection globalKubotaKernel w=Quotient.mk _ w from rfl, + kernelDirichletPairDensity_coordinate,map_add,inner_add_right] + +lemma kernelDirichletPairDensity_smul_right (c : ℂ) (f g : kernelSmoothTests) (q : KernelQuotient) : + kernelDirichletPairDensity f (c•g) q=c*kernelDirichletPairDensity f g q := by + induction q using Quotient.inductionOn with + | _ w => simp only [←show integralOrbitProjection globalKubotaKernel w=Quotient.mk _ w from rfl, + kernelDirichletPairDensity_coordinate,map_smul,inner_smul_right] + +lemma kernelDirichletPairDensity_conj (f g : kernelSmoothTests) (q : KernelQuotient) : + star (kernelDirichletPairDensity g f q)=kernelDirichletPairDensity f g q := by + induction q using Quotient.inductionOn with + | _ w => + change star (kernelDirichletPairDensity g f (integralOrbitProjection globalKubotaKernel w))= + kernelDirichletPairDensity f g (integralOrbitProjection globalKubotaKernel w) + rw [kernelDirichletPairDensity_coordinate,kernelDirichletPairDensity_coordinate] + exact inner_conj_symm _ _ + +lemma kernelDirichletPairDensity_self (f : kernelSmoothTests) (q : KernelQuotient) : + kernelDirichletPairDensity f f q=(kernelQuotientEnergyDensity f q:ℂ) := by + induction q using Quotient.inductionOn with + | _ w => + change kernelDirichletPairDensity f f (integralOrbitProjection globalKubotaKernel w)=_ + rw [kernelDirichletPairDensity_coordinate,inner_self_eq_norm_sq_to_K,RCLike.ofReal_eq_complex_ofReal,←Complex.ofReal_pow,kernelGradientAt_norm_sq] + rfl + +def kernelDirichletForm (f g : kernelSmoothTests) : ℂ := + ∫q,kernelDirichletPairDensity f g q ∂integralQuotientVolume globalKubotaKernel + +lemma kernelDirichletForm_add_right (f g h : kernelSmoothTests) : + kernelDirichletForm f (g+h)=kernelDirichletForm f g+kernelDirichletForm f h := by + unfold kernelDirichletForm + simp_rw [kernelDirichletPairDensity_add_right] + exact integral_add (kernelDirichletPairDensity_integrable f g) (kernelDirichletPairDensity_integrable f h) + +lemma kernelDirichletForm_smul_right (c : ℂ) (f g : kernelSmoothTests) : + kernelDirichletForm f (c•g)=c*kernelDirichletForm f g := by + unfold kernelDirichletForm + simp_rw [kernelDirichletPairDensity_smul_right] + exact integral_const_mul _ _ + +lemma kernelDirichletForm_conj (f g : kernelSmoothTests) : + star (kernelDirichletForm g f)=kernelDirichletForm f g := by + unfold kernelDirichletForm + simp only [Complex.star_def] + rw [←integral_conj] + apply integral_congr_ae + exact Filter.Eventually.of_forall (kernelDirichletPairDensity_conj f g) + +lemma kernelDirichletForm_self (f : kernelSmoothTests) : + kernelDirichletForm f f=(kernelDirichletEnergy f:ℂ) := by + unfold kernelDirichletForm kernelDirichletEnergy + simp_rw [kernelDirichletPairDensity_self] + exact integral_complex_ofReal + +lemma kernelDirichletForm_self_nonneg (f : kernelSmoothTests) : 0≤(kernelDirichletForm f f).re := by + rw [kernelDirichletForm_self,Complex.ofReal_re] + exact kernelDirichletEnergy_nonneg f + +end CubicEisenstein + +namespace CompletedGauss + +section + +open scoped BigOperators Classical SchwartzMap +open MeasureTheory + +theorem finite_integral_energy_bound {κ : Type*} [Fintype κ] + (b : ℝ→ℂ) (φ : κ→ℝ→ℂ) (E : ℝ) (hE : 0≤E) + (hb : Integrable (fun t => ‖b t‖)) + (hφ : ∀k,Integrable (fun t => b t*φ k t)) + (hbound : ∀t,(∑k,‖φ k t‖^2)≤E) : + (∑k,‖∫t : ℝ,b t*φ k t‖^2)≤E*(∫t : ℝ,‖b t‖)^2 := by + let e := PiLp.continuousLinearEquiv 2 ℂ (fun _ : κ => ℂ) + let F : ℝ→EuclideanSpace ℂ κ := fun t => e.symm (fun k => b t*φ k t) + have hF (t : ℝ) : ‖F t‖≤‖b t‖*Real.sqrt E := by + apply (sq_le_sq₀ (norm_nonneg _) (by positivity)).mp + rw [EuclideanSpace.norm_sq_eq,mul_pow,Real.sq_sqrt hE] + change (∑k,‖b t*φ k t‖^2)≤‖b t‖^2*E + simp only [norm_mul,mul_pow,←Finset.mul_sum] + exact mul_le_mul_of_nonneg_left (hbound t) (sq_nonneg _) + have he : (∫t : ℝ,F t)=e.symm (fun k => ∫t : ℝ,b t*φ k t) := by + rw [show F=(fun t => e.symm (fun k => b t*φ k t)) from rfl,e.symm.integral_comp_comm] + congr 1 + funext k + exact eval_integral hφ k + have hn : ‖e.symm (fun k => ∫t : ℝ,b t*φ k t)‖≤(∫t : ℝ,‖b t‖)*Real.sqrt E := by + rw [←he,←integral_mul_const] + exact norm_integral_le_of_norm_le (hb.mul_const _) (Filter.Eventually.of_forall hF) + have hs := pow_le_pow_left₀ (norm_nonneg _) hn 2 + rw [EuclideanSpace.norm_sq_eq,mul_pow,Real.sq_sqrt hE] at hs + simpa [e,mul_comm] using hs + +open CanonicalQuadraticSieve ActualEisensteinCubic + +theorem integrated_product_quadratic (ε : ℝ) (hε : 0<ε) : + ∃C : ℝ,0 β t n b)) → + (∀t,∀n∈S,∀b∈T,‖β t n b‖≤lengthScale) → + ∀rowPhase : idealRange K→ℝ→ℂ,(∀k,Continuous (rowPhase k)) → (∀k t,‖rowPhase k t‖≤1) → + ∀b : 𝓢(ℝ,ℂ), + (∑k : idealRange K,‖∫t : ℝ,b t*(rowPhase k t* + ∑n∈S,∑v∈T,quadraticRow k.val (primaryGenerator (n*v))*β t n v)‖^2)≤ + C*(K*(U*B))^ε*(K+U*B)*(U*B)*lengthScale^2*(∫t : ℝ,‖b t‖)^2 := by + obtain ⟨C,hC,hbound⟩ := product_quadratic_norm_scaled ε hε + refine ⟨C,hC,?_⟩ + intro K U B lengthScale hK hU hB hL S T hS hT β hβc hβ rowPhase hωc hω b + let E := C*(K*(U*B))^ε*(K+U*B)*(U*B)*lengthScale^2 + have hE : 0≤E := by dsimp [E]; positivity + let φ : idealRange K→ℝ→ℂ := fun k t => rowPhase k t* + ∑n∈S,∑v∈T,quadraticRow k.val (primaryGenerator (n*v))*β t n v + have hφc (k : idealRange K) : Continuous (φ k) := by + apply (hωc k).mul + apply continuous_finsetSum + intro n hn + apply continuous_finsetSum + intro v hv + exact continuous_const.mul (hβc n v) + have hφbound (t : ℝ) : (∑k,‖φ k t‖^2)≤E := by + apply le_trans _ (hbound K U B lengthScale hK hU hB hL S T hS hT (β t) (hβ t)) + apply Finset.sum_le_sum + intro k hk + exact pow_le_pow_left₀ (norm_nonneg _) (by + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (hω k t)) 2 + have hpoint (k : idealRange K) (t : ℝ) : ‖φ k t‖≤Real.sqrt E := by + apply (Real.le_sqrt (norm_nonneg _) hE).mpr + exact (Finset.single_le_sum (fun j _ => sq_nonneg ‖φ j t‖) (Finset.mem_univ k)).trans (hφbound t) + have hφint (k : idealRange K) : Integrable (fun t : ℝ => b t*φ k t) := + b.integrable.mul_bdd (hφc k).aestronglyMeasurable (Filter.Eventually.of_forall (hpoint k)) + exact finite_integral_energy_bound b φ E hE b.integrable.norm hφint hφbound + +end + +section +open ActualEisensteinCubic CanonicalQuadraticSieve + +def completedRowFiber (S : Finset (Ideal O)) (Q A T : Ideal O) : Finset (Ideal O) := + S.filter (fun I => rowPowerfulPart I=A ∧ rowMaskPart I Q=T) + +theorem rowResidualPart_injective_on_fiber (S : Finset (Ideal O)) (Q A T : Ideal O) + (hS : ∀I∈S,I≠0) : Set.InjOn (fun I => rowResidualPart I Q) (completedRowFiber S Q A T) := by + intro I hI J hJ he + change rowResidualPart I Q=rowResidualPart J Q at he + obtain ⟨hIS,hIA,hIT⟩ := Finset.mem_filter.mp hI + obtain ⟨hJS,hJA,hJT⟩ := Finset.mem_filter.mp hJ + calc + I = rowPowerfulPart I*rowMaskPart I Q*rowResidualPart I Q := (row_powerful_mask_residual_product I Q (hS I hIS)).symm + _ = rowPowerfulPart J*rowMaskPart J Q*rowResidualPart J Q := by rw [hIA,hJA,hIT,hJT,he] + _ = J := row_powerful_mask_residual_product J Q (hS J hJS) + +theorem completedRowFiber_residual_range (S : Finset (Ideal O)) (Q A T : Ideal O) + (hbad : ∀P∈fixedBadPrimes,P∣Q) (K : ℝ) + (hS : ∀I∈S,I≠0 ∧ (Ideal.absNorm I:ℝ)≤K) (I : Ideal O) + (hI : I∈completedRowFiber S Q A T) : + rowResidualPart I Q∈idealRange (K/((Ideal.absNorm A:ℝ)*(Ideal.absNorm T:ℝ))) := by + obtain ⟨hIS,hIA,hIT⟩ := Finset.mem_filter.mp hI + apply mem_idealRange.mpr + refine ⟨rowResidualPart_admissible I Q hbad,?_⟩ + rw [rowResidualPart_norm I Q (hS I hIS).1,hIA,hIT] + exact div_le_div_of_nonneg_right (hS I hIS).2 (by positivity) + +theorem completedRowFiber_energy_le (S : Finset (Ideal O)) (Q A T : Ideal O) + (hbad : ∀P∈fixedBadPrimes,P∣Q) (K : ℝ) + (hS : ∀I∈S,I≠0 ∧ (Ideal.absNorm I:ℝ)≤K) (f : Ideal O→ℂ) : + (∑I∈completedRowFiber S Q A T,‖f (rowResidualPart I Q)‖^2)≤ + ∑J : idealRange (K/((Ideal.absNorm A:ℝ)*(Ideal.absNorm T:ℝ))),‖f J.val‖^2 := by + let U := (completedRowFiber S Q A T).image (fun I => rowResidualPart I Q) + have he : (∑I∈completedRowFiber S Q A T,‖f (rowResidualPart I Q)‖^2)=∑J∈U,‖f J‖^2 := by + rw [Finset.sum_image (rowResidualPart_injective_on_fiber S Q A T (fun I hI => (hS I hI).1))] + rw [he,Finset.sum_coe_sort (s := idealRange (K/((Ideal.absNorm A:ℝ)*(Ideal.absNorm T:ℝ)))) (f := fun J : Ideal O => ‖f J‖^2)] + apply Finset.sum_le_sum_of_subset_of_nonneg + · intro J hJ + obtain ⟨I,hI,rfl⟩ := Finset.mem_image.mp hJ + exact completedRowFiber_residual_range S Q A T hbad K hS I hI + · intro _ _ _ + exact sq_nonneg _ + +end + +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory +open ActualEisensteinCubic CanonicalQuadraticSieve + +theorem completed_kernel_three_window + (V₀ V₁ V₂ : ℝ→ℂ) (M₀ M₁ M₂ : ℝ) + (hM₀ : 0≤M₀) (hM₁ : 0≤M₁) (hM₂ : 0≤M₂) + (hV₀ : ∀y,V₀ y≠0 → |y|≤M₀) (hV₁ : ∀y,V₁ y≠0 → |y|≤M₁) + (hV₂ : ∀y,V₂ y≠0 → |y|≤M₂) + (W : ℝ→ℂ) (a b : ℝ) (ha : 0 assumption + have hv : ∀i y,V i y≠0 → |y|≤M i := by intro i; fin_cases i <;> assumption + obtain ⟨C,hC,h⟩ := completed_kernel_log_separation V slope M hm hv W a b ha hsupp hW A 0 + refine ⟨C,hC,?_⟩ + intro R hR + obtain ⟨B,hB,hi,hbound,hpoint⟩ := h R hR + refine ⟨B,?_,by simpa only [pow_zero,one_mul] using hbound⟩ + intro r u v + simpa [V,slope,Fin.prod_univ_succ,Fin.sum_univ_succ,mul_assoc,add_assoc] using hB ![r,u,v] + +theorem completed_smooth_quadratic + (V₀ V₁ V₂ : ℝ→ℂ) (M₀ M₁ M₂ : ℝ) + (hM₀ : 0≤M₀) (hM₁ : 0≤M₁) (hM₂ : 0≤M₂) + (hV₀ : ∀y,V₀ y≠0 → |y|≤M₀) (hV₁ : ∀y,V₁ y≠0 → |y|≤M₁) + (hV₂ : ∀y,V₂ y≠0 → |y|≤M₂) + (hV₀n : ∀y,‖V₀ y‖≤1) (hV₁n : ∀y,‖V₁ y‖≤1) (hV₂n : ∀y,‖V₂ y‖≤1) + (W : ℝ→ℂ) (a b : ℝ) (ha : 0 V₀ (yr k)*FourierBridge.logPhase t (-2*yr k) + let βt : ℝ→Ideal O→Ideal O→ℂ := fun t n v => + β n v*(V₁ (yn n)*FourierBridge.logPhase t (yn n))*(V₂ (yb v)*FourierBridge.logPhase t (3*yb v)) + have hphase (t x : ℝ) : ‖FourierBridge.logPhase t x‖=1 := FourierBridge.logPhase_norm t x + have hrowPhase (k : idealRange K) (t : ℝ) : ‖rowPhase k t‖≤1 := by + simp only [rowPhase,norm_mul,hphase,mul_one] + exact hV₀n _ + have hβt (t : ℝ) (n : Ideal O) (hn : n∈S) (v : Ideal O) (hv : v∈T) : ‖βt t n v‖≤lengthScale := by + simp only [βt,norm_mul,hphase,mul_one] + exact (mul_le_of_le_one_right (by positivity) + (hV₂n _)).trans ((mul_le_of_le_one_right (norm_nonneg _) (hV₁n _)).trans (hβ n hn v hv)) + have hrowPhasec (k : idealRange K) : Continuous (rowPhase k) := + continuous_const.mul (FourierBridge.logPhase_continuous_left _) + have hβtc (n v : Ideal O) : Continuous (fun t => βt t n v) := + (continuous_const.mul (continuous_const.mul (FourierBridge.logPhase_continuous_left _))).mul + (continuous_const.mul (FourierBridge.logPhase_continuous_left _)) + have hi := hq K U B lengthScale hK hU hB hL S T hS hT βt hβtc hβt rowPhase hrowPhasec hrowPhase g + have he (k : idealRange K) : + (∑n∈S,∑v∈T,quadraticRow k.val (primaryGenerator (n*v))*β n v* + (V₀ (yr k)*V₁ (yn n)*V₂ (yb v)*CubicReflectionKernel.paperKernel (Vstar W) + (R*Real.exp (-2*yr k+yn n+3*yb v)))) = + ∫t : ℝ,g t*(rowPhase k t*∑n∈S,∑v∈T,quadraticRow k.val (primaryGenerator (n*v))*βt t n v) := by + have hint (n v : Ideal O) : Integrable (fun t : ℝ => + g t*(rowPhase k t*(quadraticRow k.val (primaryGenerator (n*v))*βt t n v))) := by + apply g.integrable.mul_bdd (c := ‖quadraticRow k.val (primaryGenerator (n*v))*β n v‖) + · exact ((hrowPhasec k).mul (continuous_const.mul (hβtc n v))).aestronglyMeasurable + · filter_upwards [] with t + simp only [rowPhase,βt,norm_mul,hphase,mul_one] + have hv01 : ‖V₀ (yr k)‖*‖V₁ (yn n)‖≤1 := by + simpa only [one_mul] using mul_le_mul (hV₀n (yr k)) (hV₁n (yn n)) (norm_nonneg _) zero_le_one + have hv012 : (‖V₀ (yr k)‖*‖V₁ (yn n)‖)*‖V₂ (yb v)‖≤1 := by + simpa only [one_mul] using mul_le_mul hv01 (hV₂n (yb v)) (norm_nonneg _) zero_le_one + calc + _ = (‖quadraticRow k.val (primaryGenerator (n*v))‖*‖β n v‖)* + ((‖V₀ (yr k)‖*‖V₁ (yn n)‖)*‖V₂ (yb v)‖) := by ring + _ ≤ (‖quadraticRow k.val (primaryGenerator (n*v))‖*‖β n v‖)*1 := + mul_le_mul_of_nonneg_left hv012 (by positivity) + _ = _ := by ring + simp only [Finset.mul_sum] + rw [integral_finsetSum _ (fun n hn => integrable_finsetSum _ (fun v hv => hint n v))] + apply Finset.sum_congr rfl + intro n hn + rw [integral_finsetSum _ (fun v hv => hint n v)] + apply Finset.sum_congr rfl + intro v hv + rw [hsep (yr k) (yn n) (yb v),←integral_const_mul] + apply integral_congr_ae + filter_upwards [] with t + dsimp [rowPhase,βt] + ring + simp_rw [he] + apply hi.trans + have hpow : 0<(1+R)^A := by positivity + have hmass : (∫t : ℝ,‖g t‖)≤Ck/(1+R)^A := (le_div_iff₀ hpow).mpr (by simpa only [mul_comm] using hg) + have hmass2 := pow_le_pow_left₀ (integral_nonneg (fun t => norm_nonneg _)) hmass 2 + have hbase : 0≤Cq*(K*(U*B))^ε*(K+U*B)*(U*B)*lengthScale^2 := by positivity + calc + _ ≤ (Cq*(K*(U*B))^ε*(K+U*B)*(U*B)*lengthScale^2)*(Ck/(1+R)^A)^2 := + mul_le_mul_of_nonneg_left hmass2 hbase + _ ≤ (Cq*(K*(U*B))^ε*(K+U*B)*(U*B)*lengthScale^2)*((Ck^2+1)/(1+R)^(2*A)) := by + apply mul_le_mul_of_nonneg_left _ hbase + rw [div_pow,←pow_mul] + have hp : A*2=2*A := Nat.mul_comm _ _ + rw [hp] + exact div_le_div_of_nonneg_right (by nlinarith : Ck^2≤Ck^2+1) (by positivity) + _ = _ := by ring + +end CompletedGauss + +open scoped BigOperators Classical SchwartzMap ContDiff + +namespace InitialMeanSquare +open ActualEisensteinCubic +open ConcreteTraceCRT (eisEmbedding eisEmbedding_ne_zero) +open FirstPassCubeLabels (primeProductNorm normalizedColumn columnLog) + +def initialLogProfile (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) : 𝓢(ℝ,ℂ) := + ((CubicReflectionKernel.logProfile_compact W a b ha hs).mul_left + (f := fun t : ℝ => (Real.exp (t/2) : ℂ))).toSchwartzMap (by + change ContDiff ℝ ∞ (fun t : ℝ => (Real.exp (t/2) : ℂ)*W (Real.exp t)) + have he : ContDiff ℝ ∞ (fun t : ℝ => Real.exp (t/2)) := + Real.contDiff_exp.comp (contDiff_id.div_const 2) + exact (Complex.ofRealCLM.contDiff.comp he).mul + (hW.comp Real.contDiff_exp)) + +@[simp] lemma initialLogProfile_apply (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) (t : ℝ) : + initialLogProfile W a b ha hs hW t = + (Real.exp (t/2) : ℂ)*W (Real.exp t) := rfl + +theorem initialLogProfile_support (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) : + ∀ t, initialLogProfile W a b ha hs hW t ≠ 0 → + |t| ≤ |Real.log a|+|Real.log b|+1 := by + intro t ht + have hw : W (Real.exp t) ≠ 0 := by + intro hz + simp only [initialLogProfile_apply, hz, mul_zero] at ht + exact ht rfl + have hm := hs hw + have hlo : Real.log a ≤ t := by + simpa only [Real.log_exp] using Real.log_le_log ha hm.1 + have hhi : t ≤ Real.log b := by + simpa only [Real.log_exp] using Real.log_le_log (Real.exp_pos t) hm.2 + rw [abs_le] + constructor <;> linarith [le_abs_self (Real.log a), neg_abs_le (Real.log a), + le_abs_self (Real.log b), abs_nonneg (Real.log a), abs_nonneg (Real.log b)] + +theorem initialLogProfile_normalized {ι : Type*} (p : ι → O) + (hp : ∀ i, p i ≠ 0) (S : Finset ι) (Z : ℝ) (hZ : 0 < Z) + (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) : + normalizedColumn p (fun T => initialLogProfile W a b ha hs hW (columnLog p Z T)) S = + (Real.sqrt Z : ℂ)⁻¹*W (primeProductNorm p S/Z) := by + let n := ‖eisEmbedding (∏ i ∈ S,p i)‖ + have hn : 0 < n := norm_pos_iff.mpr + (eisEmbedding_ne_zero (Finset.prod_ne_zero_iff.mpr (fun i _ => hp i))) + have hpos : 0 < n^2/Z := div_pos (sq_pos_of_pos hn) hZ + have hexp : Real.exp (Real.log (n^2/Z)/2)=n/Real.sqrt Z := by + rw [←JointLogSeparation.sqrt_exp_half, Real.exp_log hpos, + Real.sqrt_div (sq_nonneg n), Real.sqrt_sq hn.le] + change ((Real.exp (Real.log (n^2/Z)/2) : ℂ)*W (Real.exp (Real.log (n^2/Z)))) / + (n : ℂ) = (Real.sqrt Z : ℂ)⁻¹*W (n^2/Z) + rw [hexp, Real.exp_log hpos, Complex.ofReal_div] + have hn0 : (n : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hn.ne' + have hsz : (Real.sqrt Z : ℂ) ≠ 0 := + Complex.ofReal_ne_zero.mpr (Real.sqrt_pos.mpr hZ).ne' + field_simp + +variable {ι : Type*} [DecidableEq ι] (p : ι → O) + [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + +omit [DecidableEq ι] in +lemma mobiusRow_mul (F : Finset ι) (Ψ : O →* ℂ) (m : O) + (H : Finset ι → ℂ) (c : ℂ) (z : O) : + mobiusRow p hg F Ψ m (fun S => c*H S) z = c*mobiusRow p hg F Ψ m H z := by + simp only [mobiusRow, Finset.mul_sum] + apply Finset.sum_congr rfl + intro S hS + simp only [inputColumn] + ring + +omit [DecidableEq ι] in +theorem mobiusRow_initial_normalization (hp : ∀ i, p i ≠ 0) + (F : Finset ι) (Ψ : O →* ℂ) (m : O) (z : O) (Z : ℝ) (hZ : 0 < Z) + (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) : + mobiusRow p hg F Ψ m + (normalizedColumn p (fun T => initialLogProfile W a b ha hs hW (columnLog p Z T))) z = + (Real.sqrt Z : ℂ)⁻¹*mobiusRow p hg F Ψ m (fun T => W (primeProductNorm p T/Z)) z := by + have hc : normalizedColumn p (fun T => initialLogProfile W a b ha hs hW (columnLog p Z T)) = + fun T => (Real.sqrt Z : ℂ)⁻¹*W (primeProductNorm p T/Z) := by + funext T + exact initialLogProfile_normalized p hp T Z hZ W a b ha hs hW + rw [hc, mobiusRow_mul] + +omit [DecidableEq ι] in +theorem mobiusRow_initial_energy (hp : ∀ i, p i ≠ 0) + (F : Finset ι) (Ψ : O →* ℂ) (m : O) (z : O) (Z : ℝ) (hZ : 0 < Z) + (W : ℝ → ℂ) (a b : ℝ) (ha : 0 < a) + (hs : Function.support W ⊆ Set.Icc a b) (hW : ContDiff ℝ ∞ W) : + ‖mobiusRow p hg F Ψ m + (normalizedColumn p (fun T => initialLogProfile W a b ha hs hW (columnLog p Z T))) z‖^2 = + ‖mobiusRow p hg F Ψ m (fun T => W (primeProductNorm p T/Z)) z‖^2/Z := by + rw [mobiusRow_initial_normalization p hg hp F Ψ m z Z hZ W a b ha hs hW, + norm_mul, norm_inv, Complex.norm_real, Real.norm_eq_abs, + abs_of_pos (Real.sqrt_pos.mpr hZ), mul_pow, inv_pow, Real.sq_sqrt hZ.le] + ring + +end InitialMeanSquare + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/EntireMellinProfile.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/EntireMellinProfile.lean new file mode 100644 index 0000000000000000000000000000000000000000..66e72fa4e541ffe7ebae77f971e4e4d7297dbdd5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/EntireMellinProfile.lean @@ -0,0 +1,645 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.RamifiedTransform + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein +open scoped BigOperators Classical +open MeasureTheory +open Finset AddChar MulChar EisensteinEmbedding + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma finite_mellin_entire {ι : Type*} [Fintype ι] (f : ι→ℝ→ℂ) (weight : ι→ℂ) + (hf : ∀i,(∀s:ℂ,MellinConvergent (f i) s) ∧ Differentiable ℂ (mellin (f i))) : + (∀s:ℂ,MellinConvergent (fun v=>∑i,weight i*f i v) s) ∧ + Differentiable ℂ (mellin (fun v=>∑i,weight i*f i v)) := by + have hs (s : ℂ) (i : ι) : MellinConvergent (fun v=>weight i*f i v) s := by + simpa only [smul_eq_mul] using (hf i).1 s |>.const_smul (weight i) + have hsi (s : ℂ) (i : ι) : IntegrableOn (fun v:ℝ=>(v:ℂ)^(s-1)*(weight i*f i v)) (Set.Ioi 0) := by + simpa only [MellinConvergent,smul_eq_mul] using hs s i + have he (s : ℂ) : mellin (fun v=>∑i,weight i*f i v) s=∑i,weight i*mellin (f i) s := by + unfold mellin + simp only [smul_eq_mul,Finset.mul_sum] + rw [integral_finsetSum Finset.univ (fun i hi=>hsi s i)] + apply Finset.sum_congr rfl + intro i hi + simpa only [mellin,smul_eq_mul] using mellin_const_smul (f i) s (weight i) + constructor + · intro s + change IntegrableOn (fun v:ℝ=>(v:ℂ)^(s-1)*(∑i,weight i*f i v)) (Set.Ioi 0) + simpa only [IntegrableOn,Finset.mul_sum] using integrable_finsetSum Finset.univ (fun i hi=>hsi s i) + · rw [show mellin (fun v=>∑i,weight i*f i v)=(fun s=>∑i,weight i*mellin (f i) s) from funext he] + exact Differentiable.fun_sum (fun i hi=>(hf i).2.const_mul (weight i)) + +lemma thetaTwistedCuspProfile_mellin_entire (Ψ : Eis→*ℂ) (c : Eis) (hc : c≠0) + [Fintype (Eis⧸Ideal.span {c})] : + (∀s:ℂ,MellinConvergent (thetaTwistedCuspProfile Ψ c hc) s) ∧ + Differentiable ℂ (mellin (thetaTwistedCuspProfile Ψ c hc)) := by + apply finite_mellin_entire + intro h + have he : thetaFourierTranslation c h=(-3:ℂ)*eisEmbedding (Quotient.out h)/eisEmbedding c := by + rw [thetaFourierTranslation,TraceLambdaPhase.eisLam_sq] + rw [he] + exact conjugateSource_finite_twist_cusp_mellin_entire (Quotient.out h) c hc + +theorem completedBesselProfile_mellin_entire_of_periodic + (Ψ : Eis→*ℂ) (Q : Ideal Eis) (hΨ : CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c : Eis) (hc : c≠0) [Fintype (Eis⧸Ideal.span {c})] + (hcQ : Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) : + (∀s:ℂ,MellinConvergent (completedBesselProfile Ψ thetaBesselScale) s) ∧ + Differentiable ℂ (mellin (completedBesselProfile Ψ thetaBesselScale)) := by + have hf := thetaTwistedCuspProfile_mellin_entire Ψ c hc + have he (v : ℝ) (hv : 0thetaDerivativeScalar⁻¹*mellin (thetaTwistedCuspProfile Ψ c hc) s) from funext hm] + exact hf.2.const_mul _ + +theorem completedBesselProfile_mellin_entire + (Ψ : Eis→*ℂ) (Q : Ideal Eis) (hQ : Q≠⊥) + (hΨ : CanonicalCoefficientClass.FactorsModulo Q Ψ) : + (∀s:ℂ,MellinConvergent (completedBesselProfile Ψ (1/Real.sqrt 27)) s) ∧ + Differentiable ℂ (mellin (completedBesselProfile Ψ (1/Real.sqrt 27))) := by + have h9 : (Ideal.span {(9:Eis)} : Ideal Eis)≠⊥ := + Ideal.span_singleton_eq_bot.not.mpr (by norm_num) + have hN : Ideal.span {(9:Eis)}*Q≠⊥ := fun hz=>(Ideal.mul_eq_bot.mp hz).elim h9 hQ + let c := ConcretePrimeRowBridge.idealGenerator (Ideal.span {(9:Eis)}*Q) + have hc : c≠0 := ConcretePrimeRowBridge.idealGenerator_ne_zero _ hN + let : Finite (Eis⧸Ideal.span {c}) := finite_quotient_span hc + let : Fintype (Eis⧸Ideal.span {c}) := Fintype.ofFinite _ + have hcQ : Ideal.span {c}≤Ideal.span {(9:Eis)}*Q := by + rw [ConcretePrimeRowBridge.span_idealGenerator] + simpa only [thetaBesselScale_eq] using + completedBesselProfile_mellin_entire_of_periodic Ψ Q hΨ c hc hcQ + +end CubicEisenstein + +namespace CompletedGauss +open Filter MeasureTheory +open scoped Classical BigOperators Topology ContDiff + +lemma mellin_eq_of_positive_eq (F G : ℝ→ℂ) (hFG : ∀v : ℝ,0∑i,w i*F i v) q s= + ∑i,w i*continuedBesselDirichlet (F i) q s := by + have hi (i : ι) : IntegrableOn (fun v : ℝ=>(v:ℂ)^(2*s-1)*(w i*F i v)) (Set.Ioi 0) := by + simpa only [MellinConvergent,smul_eq_mul] using (hF i).const_smul (w i) + have hm : mellin (fun v=>∑i,w i*F i v) (2*s)=∑i,w i*mellin (F i) (2*s) := by + unfold mellin + simp only [smul_eq_mul,Finset.mul_sum] + rw [integral_finsetSum Finset.univ (fun i _=>hi i)] + apply Finset.sum_congr rfl + intro i _ + simpa only [mellin,smul_eq_mul] using mellin_const_smul (F i) (2*s) (w i) + rw [continuedBesselDirichlet,hm,Finset.mul_sum] + apply Finset.sum_congr rfl + intro i _ + unfold continuedBesselDirichlet + ring + +lemma besselSmoothingIntegrand_finite_sum {ι : Type*} [Fintype ι] + (F : ℝ→ℂ) (G : ι→ℝ→ℂ) (w : ι→ℂ) + (hFG : ∀v : ℝ,0∑i,w i*G i v) hFG (2*s) + have hd : continuedBesselDirichlet F q s= + continuedBesselDirichlet (fun v=>∑i,w i*G i v) q s := by + simp only [continuedBesselDirichlet,hm] + rw [besselSmoothingIntegrand,hd,continuedBesselDirichlet_finite_sum G w q s hG, + Finset.mul_sum] + apply Finset.sum_congr rfl + intro i _ + unfold besselSmoothingIntegrand + ring + +theorem besselSmoothingIntegrand_finite_integrable {ι : Type*} [Fintype ι] + (F : ℝ→ℂ) (G : ι→ℝ→ℂ) (w : ι→ℂ) + (hFG : ∀v : ℝ,0besselSmoothingIntegrand (G i) q V X ((σ:ℂ)+t*Complex.I))) : + Integrable (fun t : ℝ=>besselSmoothingIntegrand F q V X ((σ:ℂ)+t*Complex.I)) := by + have hsum := integrable_finsetSum Finset.univ (fun i _=>(hi i).const_mul (w i)) + apply hsum.congr + filter_upwards with t + exact (besselSmoothingIntegrand_finite_sum F G w hFG q V X _ (fun i=>hG i t)).symm + +end CompletedGauss + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def unramifiedResidualCoefficient (h:Eis) :ℂ:=cubicBesselNormalizer h*unramifiedGaussResidue h + +lemma primeCubicGauss_two_norm (p:Eis) (hp:Prime p) (hpp:lambda^2∣p-1) + (h:Eis) (hph:¬p∣h) : ‖primeCubicGauss p hp hpp 2 h‖=‖eisEmbedding p‖ := by + have he:=congrArg norm (primeCubicGauss_one_mul_two p hp hpp h hph) + rw [norm_mul,primeCubicGauss_two_eq_star,norm_star,Complex.norm_natCast] at he + have hn:=eisEmbedding_norm_sq_eq_absNorm_span p + have hg:0≤‖primeCubicGauss p hp hpp 1 h‖:=norm_nonneg _ + have hr:0≤‖eisEmbedding p‖:=norm_nonneg _ + rw [primeCubicGauss_two_eq_star,norm_star] + nlinarith + +lemma unramifiedResidualCoefficient_prime_factor (p:Eis) (hp:Prime p) + (hpp:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + unramifiedResidualCoefficient (h*p)= + (primeCubicGauss p hp hpp 2 h/(‖eisEmbedding p‖:ℂ))*unramifiedResidualCoefficient h := by + rw [unramifiedResidualCoefficient,cubicBesselNormalizer_mul, + unramifiedGaussResidue_prime_factor p hp hpp h hph,unramifiedResidualCoefficient] + calc + _=((‖eisEmbedding p‖:ℂ)^(1/3:ℂ)*(Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ)))* + primeCubicGauss p hp hpp 2 h*(cubicBesselNormalizer h*unramifiedGaussResidue h):=by ring + _=_:=by rw [prime_normalizer_powers p hp.ne_zero]; ring + +lemma unramifiedResidualCoefficient_prime_norm (p:Eis) (hp:Prime p) + (hpp:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + ‖unramifiedResidualCoefficient (h*p)‖=‖unramifiedResidualCoefficient h‖ := by + rw [unramifiedResidualCoefficient_prime_factor p hp hpp h hph,norm_mul,norm_div, + primeCubicGauss_two_norm p hp hpp h hph,Complex.norm_real, + Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _), + div_self (norm_ne_zero_iff.mpr (eisEmbedding_ne_zero hp.ne_zero)),one_mul] + +theorem unramifiedGaussResidue_primary_cube (b:Eis) (hb:b≠0) + (hbp:lambda^2∣b-1) (h:Eis) : + unramifiedGaussResidue (h*b^3)=unramifiedGaussResidue h := by + obtain ⟨s,hs,hpr⟩:=exists_primary_prime_factorization b hb hbp + rw [←hs] + clear hs hb hbp b + induction s using Multiset.induction_on generalizing h with + | empty=>simp + | @cons p s ih=> + have hp:=hpr p (Multiset.mem_cons_self _ _) + have hs:∀q∈s,Prime q∧lambda^2∣q-1:=fun q hq=>hpr q (Multiset.mem_cons_of_mem hq) + rw [Multiset.prod_cons,show h*(p*s.prod)^3=(h*s.prod^3)*p^3 by ring, + unramifiedGaussResidue_prime_cube p hp.1 hp.2] + exact ih h hs + +lemma unramifiedResidualCoefficient_primary_cube (b:Eis) (hb:b≠0) + (hbp:lambda^2∣b-1) (h:Eis) : + unramifiedResidualCoefficient (h*b^3)= + (‖eisEmbedding b‖:ℂ)*unramifiedResidualCoefficient h := by + rw [unramifiedResidualCoefficient,cubicBesselNormalizer_mul_cube h b hb, + unramifiedGaussResidue_primary_cube b hb hbp h,unramifiedResidualCoefficient] + ring + +theorem unramifiedResidualCoefficient_prime_product_norm {ι:Type*} + (s:Finset ι) (p:ι→Eis) (hp:∀i∈s,Prime (p i)) + (hprimary:∀i∈s,lambda^2∣p i-1) + (hpair:∀i∈s,∀j∈s,i≠j→IsCoprime (p i) (p j)) + (h:Eis) (hph:∀i∈s,¬p i∣h) : + ‖unramifiedResidualCoefficient (h*(∏i∈s,p i))‖=‖unramifiedResidualCoefficient h‖ := by + classical + induction s using Finset.induction_on with + | empty=>simp + | @insert i s hi ih=> + have hpi:=hp i (Finset.mem_insert_self _ _) + have hpri:=hprimary i (Finset.mem_insert_self _ _) + have hps:∀j∈s,Prime (p j):=fun j hj=>hp j (Finset.mem_insert_of_mem hj) + have hprs:∀j∈s,lambda^2∣p j-1:=fun j hj=>hprimary j (Finset.mem_insert_of_mem hj) + have hcpi:IsCoprime (p i) (∏j∈s,p j):=IsCoprime.prod_right (fun j hj=> + hpair i (Finset.mem_insert_self _ _) j (Finset.mem_insert_of_mem hj) (by intro he;subst j;exact hi hj)) + have hpb:¬p i∣h*(∏j∈s,p j):=by + intro hd + rcases hpi.dvd_mul.mp hd with hd|hd + · exact hph i (Finset.mem_insert_self _ _) hd + · exact hpi.not_isUnit (hcpi.isUnit_of_dvd hd) + rw [Finset.prod_insert hi,show h*(p i*(∏j∈s,p j))=(h*(∏j∈s,p j))*p i by ring, + unramifiedResidualCoefficient_prime_norm (p i) hpi hpri _ hpb] + exact ih hps hprs (fun j hj k hk hjk=>hpair j (Finset.mem_insert_of_mem hj) k (Finset.mem_insert_of_mem hk) hjk) + (fun j hj=>hph j (Finset.mem_insert_of_mem hj)) + +theorem unramifiedResidualCoefficient_squarefree_cube_norm (I J:Ideal Eis) + (hI:primaryGenerator I≠0) (hJ:primaryGenerator J≠0) (hsq:Squarefree I) + (u:Eisˣ) (m:ℕ) : + ‖unramifiedResidualCoefficient ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)‖= + ‖eisEmbedding (primaryGenerator J)‖*‖unramifiedResidualCoefficient (u.val*lambda^m)‖ := by + rw [unramifiedResidualCoefficient_primary_cube _ hJ (primaryGenerator_spec J hJ).2,norm_mul, + Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _)] + congr 1 + rw [primaryGenerator_squarefree_support I hI hsq] + apply unramifiedResidualCoefficient_prime_product_norm + · exact fun P hP=>primaryPrime_isPrime_of_mem I P hI hP + · exact fun P hP=>(primaryPrime_spec P (primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP))).2.2.2 + · exact primaryPrime_support_coprime I hI + · intro P hP hd + have hp:=primaryPrime_isPrime_of_mem I P hI hP + have hpp:lambda^2∣primaryPrime P-1:= + (primaryPrime_spec P (primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP))).2.2.2 + have hc:IsCoprime (u.val*lambda^m) (primaryPrime P):= + (ramified_primary_coprime u m _ hpp).of_mul_left_right + exact hp.not_isUnit (hc.symm.isUnit_of_dvd hd) + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +def threeRamifiedUnit :Eisˣ:=-(ramifiedOmegaUnit^2) +def traceRamifiedUnit :Eisˣ:=-ramifiedOmegaUnit + +lemma three_eq_ramifiedUnit : (3:Eis)=(threeRamifiedUnit:Eis)*lambda^2 := by + have hw:omega^2=-omega-1:=by linear_combination ramified_omega_relation + have hl:lambda^2=-3*omega:=by + change (omega-1)^2=-3*omega + linear_combination hw + simp only [threeRamifiedUnit,Units.val_neg,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val,hl] + calc + (3:Eis)=3*omega^3:=by rw [omega_primitive.pow_eq_one]; ring + _=_:=by ring + +lemma trace_eq_ramifiedUnit : ramifiedTraceLambda=(traceRamifiedUnit:Eis)*lambda := by + have hw:=ramified_omega_relation + simp only [traceRamifiedUnit,Units.val_neg,ramifiedOmegaUnit_val] + change 1+2*omega=-omega*(omega-1) + linear_combination hw + +def ramifiedSixUnit (side:Bool) :RamifiedSixBranch→Eisˣ + | .inl _=>threeRamifiedUnit*ramifiedCuspRoot side + | .inr (.inl _)=>threeRamifiedUnit*(-ramifiedCuspRoot side)⁻¹^4*(-ramifiedCuspRoot side) + | .inr (.inr (.inl _))=>threeRamifiedUnit*(-ramifiedCuspRoot side)⁻¹^4 + | .inr (.inr (.inr j))=>threeRamifiedUnit*(-ramifiedCuspRoot side)⁻¹^4* + ramifiedCuspScaleUnit side*traceRamifiedUnit*ramifiedOmegaUnit^j.val + +def ramifiedSixPower :RamifiedSixBranch→ℕ + | .inl _=>2 + | .inr (.inl _)=>2 + | .inr (.inr (.inl _))=>2 + | .inr (.inr (.inr _))=>3 + +lemma ramifiedSixPower_bounds (i:RamifiedSixBranch) : 2≤ramifiedSixPower i ∧ ramifiedSixPower i≤3 := by + rcases i with i|i + · norm_num [ramifiedSixPower] + rcases i with i|i + · norm_num [ramifiedSixPower] + rcases i with i|i <;> norm_num [ramifiedSixPower] + +lemma unitCuspUnramifiedIndex_multiplier (u t:Eisˣ) (h:Eis) : + unitCuspUnramifiedIndex u t h=(3*(↑u⁻¹:Eis)^4*(t:Eis))*h := by + unfold unitCuspUnramifiedIndex + have ht:(t:Eis)*(↑t⁻¹:Eis)=1:=by simp + calc + _=(3*(↑u⁻¹:Eis)^4*(t:Eis)*h)*((t:Eis)*(↑t⁻¹:Eis)):=by ring + _=_:=by rw [ht,mul_one] + +theorem ramifiedSixIndex_multiplier (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) (i:RamifiedSixBranch) : + ramifiedSixIndex side h hf i= + ((ramifiedSixUnit side i:Eis)*lambda^(ramifiedSixPower i))*h := by + rcases i with i|i + · simp only [ramifiedSixIndex,unitCuspUnramifiedIndex_multiplier, + ramifiedSixUnit,ramifiedSixPower,Units.val_mul,Units.val_one,inv_one,one_pow] + rw [three_eq_ramifiedUnit] + ring + rcases i with i|i + · simp only [ramifiedSixIndex,unitCuspUnramifiedIndex_multiplier, + ramifiedSixUnit,ramifiedSixPower,Units.val_mul,Units.val_pow_eq_pow_val] + rw [three_eq_ramifiedUnit] + ring + rcases i with i|j + · simp only [ramifiedSixIndex,unitCuspUnramifiedIndex_multiplier, + ramifiedSixUnit,ramifiedSixPower,Units.val_mul,Units.val_pow_eq_pow_val,Units.val_one,mul_one] + rw [three_eq_ramifiedUnit] + ring + · have hh:=onceCuspFrequencyQuotient_spec (ramifiedCuspScaleUnit side) h hf j + change 3*((↑(-ramifiedCuspRoot side)⁻¹:Eis)^2* + (onceCuspScale (ramifiedCuspScaleUnit side)*omega^j.val))^2* + onceCuspFrequencyQuotient (ramifiedCuspScaleUnit side) h hf j=_ + calc + _=3*(↑(-ramifiedCuspRoot side)⁻¹:Eis)^4* + (onceCuspScale (ramifiedCuspScaleUnit side)*omega^j.val)*h:=by + conv_rhs => rw [hh] + ring + _=_:=by + simp only [ramifiedSixUnit,ramifiedSixPower,Units.val_mul,Units.val_pow_eq_pow_val, + ramifiedOmegaUnit_val,onceCuspScale] + rw [three_eq_ramifiedUnit,trace_eq_ramifiedUnit] + ring + +theorem ramifiedBesselValue_prime_power_vanish (side:Bool) (p:Eis) (hp:Prime p) + (hpp:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (k:ℕ) (hk:k%3=2) : + ramifiedBesselValue side (h*p^k)=0 := by + unfold ramifiedBesselValue + split_ifs with hf + · have hr:ramifiedArithmeticResidue side (h*p^k) hf=0:=by + unfold ramifiedArithmeticResidue + apply Finset.sum_eq_zero + intro i hi + rw [ramifiedSixIndex_multiplier] + have hc:IsCoprime ((ramifiedSixUnit side i:Eis)*lambda^(ramifiedSixPower i)) p:= + (ramified_primary_coprime (ramifiedSixUnit side i) (ramifiedSixPower i) p hpp).of_mul_left_right + have hnot:¬p∣((ramifiedSixUnit side i:Eis)*lambda^(ramifiedSixPower i))*h:=by + intro hd + rcases hp.dvd_mul.mp hd with hd|hd + · exact hp.not_isUnit (hc.symm.isUnit_of_dvd hd) + · exact hph hd + rw [←mul_assoc,unramifiedGaussResidue_prime_power_table p hp hpp _ hnot,hk] + norm_num + rw [hr,mul_zero,zero_div] + · rfl + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma ramified_norm_third (u:Eisˣ) (m:ℕ) : + ‖eisEmbedding (u.val*lambda^m)‖^(1/3:ℝ)=(3:ℝ)^((m:ℝ)/6) := by + have hs:‖eisEmbedding (u.val*lambda^m)‖^2=(3:ℝ)^m:=by + rw [eisEmbedding_norm_sq_eq_absNorm_span,ramifiedElement_absNorm,Nat.cast_pow,Nat.cast_ofNat] + calc + _=(‖eisEmbedding (u.val*lambda^m)‖^2)^(1/6:ℝ):=by + rw [←Real.rpow_natCast_mul (norm_nonneg _)] + congr 1 + norm_num + _=((3:ℝ)^m)^(1/6:ℝ):=by rw [hs] + _=(3:ℝ)^((m:ℝ)/6):=by + rw [←Real.rpow_natCast_mul (by norm_num : (0:ℝ)≤3)] + congr 1 + ring + +lemma cubicBesselNormalizer_ramified_mul_norm (h:Eis) (u:Eisˣ) (m:ℕ) : + ‖cubicBesselNormalizer (h*(u.val*lambda^m))‖= + ‖cubicBesselNormalizer h‖*(3:ℝ)^((m:ℝ)/6) := by + have hp:0<‖eisEmbedding (u.val*lambda^m)‖:= + norm_pos_iff.mpr (eisEmbedding_ne_zero (ramifiedElement_ne_zero u m)) + rw [cubicBesselNormalizer_mul,norm_mul] + have he:=Complex.norm_cpow_eq_rpow_re_of_pos hp (1/3:ℂ) + have hre:(1/3:ℂ).re=(1/3:ℝ):=by norm_num + rw [hre,ramified_norm_third] at he + rw [he] + ring + +def unramifiedCoefficientBaseBound :ℝ:= + ‖cubicBesselNormalizer 1‖*ramifiedResidueFamilyMass 1 + +lemma unramifiedCoefficientBaseBound_nonneg :0≤unramifiedCoefficientBaseBound:= + mul_nonneg (norm_nonneg _) (ramifiedResidueFamilyMass_nonneg _) + +lemma unramifiedResidualCoefficient_ramified_bound (u:Eisˣ) (m:ℕ) : + ‖unramifiedResidualCoefficient (u.val*lambda^m)‖≤ + unramifiedCoefficientBaseBound*(3:ℝ)^((m:ℝ)/6) := by + have hc:‖cubicBesselNormalizer (u.val*lambda^m)‖= + ‖cubicBesselNormalizer 1‖*(3:ℝ)^((m:ℝ)/6):=by + simpa only [one_mul] using cubicBesselNormalizer_ramified_mul_norm 1 u m + rw [unramifiedResidualCoefficient,norm_mul,hc,unramifiedCoefficientBaseBound] + have he:=mul_le_mul_of_nonneg_left (unramifiedGaussResidue_unit_lambda_norm_le u m) + (mul_nonneg (norm_nonneg (cubicBesselNormalizer 1)) (Real.rpow_nonneg (show (0:ℝ)≤3 by norm_num) ((m:ℝ)/6))) + exact he.trans_eq (by ring) + +theorem unramifiedResidualCoefficient_squarefree_cube_bound (I J:Ideal Eis) + (hI:CompletedGauss.primaryGenerator I≠0) (hJ:CompletedGauss.primaryGenerator J≠0) (hsq:Squarefree I) + (u:Eisˣ) (m:ℕ) : + ‖unramifiedResidualCoefficient ((u.val*lambda^m)*CompletedGauss.primaryGenerator I* + (CompletedGauss.primaryGenerator J)^3)‖≤ + unramifiedCoefficientBaseBound*(3:ℝ)^((m:ℝ)/6)*‖eisEmbedding (CompletedGauss.primaryGenerator J)‖ := by + rw [unramifiedResidualCoefficient_squarefree_cube_norm I J hI hJ hsq u m] + exact (mul_le_mul_of_nonneg_left (unramifiedResidualCoefficient_ramified_bound u m) + (norm_nonneg _)).trans_eq (by ring) + +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +namespace CubicEisenstein +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma ramifiedSixWeight_norm_le_one (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) (i:RamifiedSixBranch) : + ‖ramifiedSixWeight side h hf i (4/3)‖≤1 := by + rcases i with i|i + · norm_num [ramifiedSixWeight,norm_mul,breveE_norm] + rcases i with i|i + · norm_num [ramifiedSixWeight,norm_mul,breveE_norm] + rcases i with i|i + · norm_num [ramifiedSixWeight,norm_mul,breveE_norm] + · unfold ramifiedSixWeight + dsimp only + split_ifs + · simp only [norm_mul,breveE_norm,mul_one] + norm_num only [norm_inv,norm_div,norm_one,Complex.norm_ofNat] + have hw:=ramifiedWeight_norm_scalar 1 + norm_num only [pow_one,Nat.cast_ofNat] at hw + have hb:=ramifiedDecayRatio_lt_one.le + nlinarith [norm_nonneg ((3:ℂ)^(-(4/3:ℂ)))] + · simp + +lemma ramifiedSixIndex_squarefree_cube (side:Bool) (u:Eisˣ) (m:ℕ) (n b:Eis) + (hf:(3:Eis)∣((u.val*lambda^m)*n*b^3)-onceCuspScale (ramifiedCuspScaleUnit side)) + (i:RamifiedSixBranch) : + ramifiedSixIndex side ((u.val*lambda^m)*n*b^3) hf i= + (((ramifiedSixUnit side i*u:Eisˣ):Eis)*lambda^(ramifiedSixPower i+m))*n*b^3 := by + rw [ramifiedSixIndex_multiplier,Units.val_mul,pow_add] + ring + +lemma ramifiedSix_normalized_term_bound (side:Bool) (I J:Ideal Eis) + (hI:primaryGenerator I≠0) (hJ:primaryGenerator J≠0) (hsq:Squarefree I) + (u:Eisˣ) (m:ℕ) + (hf:(3:Eis)∣((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)- + onceCuspScale (ramifiedCuspScaleUnit side)) (i:RamifiedSixBranch) : + ‖cubicBesselNormalizer ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)* + unramifiedGaussResidue (ramifiedSixIndex side + ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3) hf i)‖≤ + (unramifiedCoefficientBaseBound*(3:ℝ)^(1/2:ℝ))*(3:ℝ)^((m:ℝ)/6)* + ‖eisEmbedding (primaryGenerator J)‖ := by + let h:=(u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3 + let idx:=ramifiedSixIndex side h hf i + have hc:‖cubicBesselNormalizer idx‖= + ‖cubicBesselNormalizer h‖*(3:ℝ)^((ramifiedSixPower i:ℝ)/6):=by + dsimp only [idx] + rw [ramifiedSixIndex_multiplier,mul_comm] + exact cubicBesselNormalizer_ramified_mul_norm h (ramifiedSixUnit side i) (ramifiedSixPower i) + have hp:1≤(3:ℝ)^((ramifiedSixPower i:ℝ)/6):= + Real.one_le_rpow (by norm_num) (by positivity) + have hcle:‖cubicBesselNormalizer h‖≤‖cubicBesselNormalizer idx‖:=by + rw [hc] + exact le_mul_of_one_le_right (norm_nonneg _) hp + have hnorm:‖unramifiedResidualCoefficient idx‖≤ + unramifiedCoefficientBaseBound*(3:ℝ)^(((ramifiedSixPower i+m:ℕ):ℝ)/6)* + ‖eisEmbedding (primaryGenerator J)‖:=by + dsimp only [idx,h] + rw [ramifiedSixIndex_squarefree_cube] + exact unramifiedResidualCoefficient_squarefree_cube_bound I J hI hJ hsq + (ramifiedSixUnit side i*u) (ramifiedSixPower i+m) + have hexp:((ramifiedSixPower i+m:ℕ):ℝ)/6≤(m:ℝ)/6+1/2:=by + have hr:(ramifiedSixPower i:ℝ)≤3:=by exact_mod_cast (ramifiedSixPower_bounds i).2 + push_cast + linarith + have hpow:(3:ℝ)^(((ramifiedSixPower i+m:ℕ):ℝ)/6)≤ + (3:ℝ)^((m:ℝ)/6)*(3:ℝ)^(1/2:ℝ):=by + rw [←Real.rpow_add (by norm_num : (0:ℝ)<3)] + exact Real.rpow_le_rpow_of_exponent_le (by norm_num) hexp + calc + _≤‖unramifiedResidualCoefficient idx‖:=by + rw [unramifiedResidualCoefficient,norm_mul,norm_mul] + exact mul_le_mul_of_nonneg_right hcle (norm_nonneg _) + _≤unramifiedCoefficientBaseBound*(3:ℝ)^(((ramifiedSixPower i+m:ℕ):ℝ)/6)* + ‖eisEmbedding (primaryGenerator J)‖:=hnorm + _≤unramifiedCoefficientBaseBound*((3:ℝ)^((m:ℝ)/6)*(3:ℝ)^(1/2:ℝ))* + ‖eisEmbedding (primaryGenerator J)‖:= + mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hpow unramifiedCoefficientBaseBound_nonneg) + (norm_nonneg _) + _=_:=by ring + +theorem ramifiedBesselValue_squarefree_cube_bound : + ∃C:ℝ,0 ActualEisensteinCubic.O + +lemma divisor_principal_norm_le (c0 c:Eis) (hc:c≠0) (hdiv:c0∣c) : + (Ideal.absNorm (Ideal.span {c0}):ℝ)≤(Ideal.absNorm (Ideal.span {c}):ℝ) := by + have hp:0 norm_num [sourceCuspScale] + unfold fixedCuspLevelScale fixedCuspLevelBound + calc + 27*(sourceCuspScale j)^2*(Ideal.absNorm (Ideal.span {c0}):ℝ)^2≤ + 27*9*(Ideal.absNorm (Ideal.span {c}):ℝ)^2:=by gcongr + _=_:=by ring + +end + +section +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss CubicKubota +open CubicJacobiGlobal ShortDraftCusp ShortDraftCRT FiniteGaussPhase +local notation "Eis" => ActualEisensteinCubic.O + +lemma A4_traceLambda_pow_four : ramifiedTraceLambda^4=(9:Eis) := by + apply eisEmbedding_injective + rw [map_pow,map_ofNat,ramifiedEmbedding_traceLambda] + calc + _=(eisLam^2)^2:=by ring + _=9:=by rw [TraceLambdaPhase.eisLam_sq];norm_num + +structure PrincipalStratumArithmetic {ι:Type*} [Fintype ι] + (p:ι→Eis) (N a0 c0:Eis) where + lift : (∀i,(Eis⧸Ideal.span {p i})ˣ)→ι→Eis + lift_period : ∀v i,N^2∣lift v i + lift_residue : ∀v i,Ideal.Quotient.mk (Ideal.span {p i}) (lift v i)=(v i:Eis⧸Ideal.span {p i}) + U : Eis + w : Eis + bezout : U*(∏i,p i)+(ramifiedTraceLambda^3*w)*c0=1 + sigma : ∀i,(Eis⧸Ideal.span {p i})ˣ + epsilon : ∀i,(Eis⧸Ideal.span {p i})ˣ + sigma_value : ∀i,(sigma i:Eis⧸Ideal.span {p i})= + Ideal.Quotient.mk (Ideal.span {p i}) (ramifiedTraceLambda^2*c0*cofactor p i) + epsilon_value : ∀i,Ideal.Quotient.mk (Ideal.span {p i}) (ramifiedTraceLambda^3*c0*cofactor p i)* + (sigma i:Eis⧸Ideal.span {p i})*(epsilon i:Eis⧸Ideal.span {p i})=-1 + gamma : (∀i,(Eis⧸Ideal.span {p i})ˣ)→levelThree + numerator : ∀v,(gamma v:SL(2,Eis)) 0 0=finiteCrossNumerator a0 c0 ramifiedTraceLambda p (lift v) + denominator : ∀v,(gamma v:SL(2,Eis)) 1 0=c0*∏i,p i + numerator_fixed : ∀v,(9:Eis)*c0∣(gamma v:SL(2,Eis)) 0 0-(gamma (fun _=>1):SL(2,Eis)) 0 0 + inverse_fixed : ∀v,ramifiedTraceLambda^3*c0∣(gamma v:SL(2,Eis)) 1 1-(gamma (fun _=>1):SL(2,Eis)) 1 1 + +theorem exists_principalStratumArithmetic {ι:Type*} [Fintype ι] + (p:ι→Eis) [∀i,(Ideal.span {p i}).IsMaximal] (hp:∀i,p i≠0) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hprimary:∀i,lambda^2∣p i-1) + (N a0 c0:Eis) (hc0:c0≠0) (hc3:(3:Eis)∣c0) + (hN:(9:Eis)*c0∣N) (ha0:lambda^2∣a0-1) (hac:IsCoprime a0 c0) + (hNp:∀i,IsCoprime N (p i)) : + Nonempty (PrincipalStratumArithmetic p N a0 c0) := by + have h9N:(9:Eis)∣N:=(dvd_mul_right 9 c0).trans hN + have hcN:c0∣N:=(dvd_mul_left c0 9).trans hN + have hD9:ramifiedTraceLambda^3*c0∣(9:Eis)*c0 := by + refine ⟨ramifiedTraceLambda,?_⟩ + rw [←A4_traceLambda_pow_four] + ring + have hDN:ramifiedTraceLambda^3*c0∣N:=hD9.trans hN + have hl9:ramifiedTraceLambda∣(9:Eis) := by + rw [←A4_traceLambda_pow_four] + exact dvd_pow_self _ (by decide) + have hlN:ramifiedTraceLambda∣N:=hl9.trans h9N + have hstdN:lambda^2∣N:=lambda_sq_dvd_three.trans + ((show (3:Eis)∣9 from ⟨3,by norm_num⟩).trans h9N) + let r:Eis:=∏i,p i + have hr:lambda^2∣r-1:=primary_finset_product Finset.univ p (fun i _=>hprimary i) + have hNr:IsCoprime N r:=IsCoprime.prod_right (fun i _=>hNp i) + have hrNc:IsCoprime r (N*c0):=hNr.symm.mul_right + (hNr.symm.of_isCoprime_of_dvd_right hcN) + obtain ⟨U,w,huw⟩:=hNr.symm.of_isCoprime_of_dvd_right hDN + have hbez:U*r+(ramifiedTraceLambda^3*w)*c0=1 := by + linear_combination huw + obtain ⟨σ,ε,hσ,hε⟩:=exists_A4_local_units p hp hcop c0 U w hbez + have hlf (v:∀i,(Eis⧸Ideal.span {p i})ˣ):= + exists_strong_unit_frequency_lifts N p hNp v + choose lift hlift hres hlcop using hlf + let a:=fun v=>finiteCrossNumerator a0 c0 ramifiedTraceLambda p (lift v) + have hap:∀v,lambda^2∣a v-1 := by + intro v + have hfixed:N∣a v-a0*r:=finiteCrossNumerator_fixed N a0 c0 ramifiedTraceLambda p (lift v) + (fun i=>(dvd_pow_self N (by decide : (2:ℕ)≠0)).trans (hlift v i)) + have hbase:=primary_mul a0 r ha0 hr + convert dvd_add (hstdN.trans hfixed) hbase using 1 ; ring + have hpairs:Pairwise (Function.onFun IsCoprime p):=by + intro i k hik + exact (Ideal.isCoprime_span_singleton_iff _ _).mp (hcop hik) + have hacop:∀v,IsCoprime (a v) (c0*r) := by + intro v + exact finiteCrossNumerator_coprime a0 c0 ramifiedTraceLambda p (lift v) hac hpairs + (fun i=>(hNp i).of_isCoprime_of_dvd_left hcN) + (fun i=>(hNp i).of_isCoprime_of_dvd_left hlN) (hlcop v) + obtain ⟨b,d,C,hdet,hb,hd,hmat⟩:=exists_primary_numerator_sector_completions + N c0 hc0 h9N (fun (_:∀i,(Eis⧸Ideal.span {p i})ˣ)=>()) a (fun _=>r) + hap (fun _=>hr) hacop (fun _=>hrNc) + (fun v z _=>finiteCrossNumerator_fixed_sector N a0 c0 ramifiedTraceLambda p (lift v) + p (lift z) hcN (hlift v) (hlift z) (by simp)) + (fun _ _ _=>by simp) + let mat:=fun v=>controlledCompletionMatrix (a v) (b v) (c0*r) (d v) (hdet v) + have hm:∀v,mat v∈levelThree:=by + intro v + apply A3_principal_mem_levelThree (mat v) + · exact three_dvd_primary_sub_one (a v) (hap v) + · exact (show (3:Eis)∣9 from ⟨3,by norm_num⟩).trans (hb v) + · exact dvd_mul_of_dvd_left hc3 r + · exact hd v + let gamma:=fun v=>(⟨mat v,hm v⟩:levelThree) + have hentry (v:∀i,(Eis⧸Ideal.span {p i})ˣ) (i j:Fin 2): + N∣(mat v) i j-(mat (fun _=>1)) i j := by + have he:=congrArg (fun T:Matrix (Fin 2) (Fin 2) (Eis⧸Ideal.span {N})=>T i j) + ((hmat v).trans (hmat (fun _=>1)).symm) + change Ideal.Quotient.mk (Ideal.span {N}) ((mat v) i j)= + Ideal.Quotient.mk (Ideal.span {N}) ((mat (fun _=>1)) i j) at he + exact Ideal.mem_span_singleton.mp (Ideal.Quotient.eq.mp he) + exact ⟨{ + lift := lift + lift_period := hlift + lift_residue := hres + U := U + w := w + bezout := hbez + sigma := σ + epsilon := ε + sigma_value := hσ + epsilon_value := hε + gamma := gamma + numerator := fun _=>rfl + denominator := fun _=>rfl + numerator_fixed := fun v=>hN.trans (hentry v 0 0) + inverse_fixed := fun v=>hDN.trans (hentry v 1 1) + }⟩ + +lemma PrincipalStratumArithmetic.frequency_congruence {ι:Type*} [Fintype ι] + {p:ι→Eis} {N a0 c0:Eis} (D:PrincipalStratumArithmetic p N a0 c0) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) (i:ι) : + Ideal.Quotient.mk (Ideal.span {p i}) ((D.gamma v:SL(2,Eis)) 0 0)= + (D.sigma i:Eis⧸Ideal.span {p i})*(v i:Eis⧸Ideal.span {p i}) := by + rw [D.numerator,finiteCrossNumerator_local,D.sigma_value,D.lift_residue] + +end + +open scoped BigOperators Classical ContDiff MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss CompletedDyadic +open CubicKubota CubicJacobiGlobal ShortDraftCusp LocalReflectionBrackets FiniteGaussPhase +local notation "Eis" => ActualEisensteinCubic.O +namespace PrincipalStratumArithmetic +variable {ι:Type*} [Fintype ι] {p:ι→Eis} {N a0 c0:Eis} + +noncomputable def datum (D:PrincipalStratumArithmetic p N a0 c0) + (hp:∀i,p i≠0) (hc0:c0≠0) (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : SourceCuspDatum := + principalCuspDatum (D.gamma v) (by + rw [D.denominator];exact mul_ne_zero hc0 (Finset.prod_ne_zero_iff.mpr (fun i _=>hp i))) + +lemma datum_point (D:PrincipalStratumArithmetic p N a0 c0) + (hp:∀i,p i≠0) (hc0:c0≠0) (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + (D.datum hp hc0 v).point=eisEmbedding a0/eisEmbedding c0+ + eisLam^2*∑i,eisEmbedding (D.lift v i)/eisEmbedding (p i) := by + rw [SourceCuspDatum.point,datum,principalCuspDatum_matrix, + integralComplexMatrix_apply,integralComplexMatrix_apply,D.numerator,D.denominator] + simpa only [ramifiedEmbedding_traceLambda] using + ShortDraftCRT.finiteCrossNumerator_fraction a0 c0 ramifiedTraceLambda p (D.lift v) hc0 hp + +noncomputable def smoothedValue (D:PrincipalStratumArithmetic p N a0 c0) + [∀i,(Ideal.span {p i}).IsMaximal] (hp:∀i,p i≠0) (hc0:c0≠0) + (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) (W:ℝ→ℂ) (X:ℝ) : ℂ := by + letI (i:ι):Fintype (Eis⧸Ideal.span {p i}):=Fintype.ofFinite _ + exact ∑v:∀i,(Eis⧸Ideal.span {p i})ˣ, + (∏i,finiteAdditiveFourierCoeff (quotientTrace (p i) (hp i)) + (fun t=>(actualSextic (Ideal.span {p i}) (hg i)^j i) t) (v i))* + (D.datum hp hc0 v).smoothedKernel W X + +noncomputable def reflectedValue (D:PrincipalStratumArithmetic p N a0 c0) + [∀i,(Ideal.span {p i}).IsMaximal] (hp:∀i,p i≠0) (hc0:c0≠0) + (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) (W:ℝ→ℂ) (X:ℝ) : ℂ := by + letI (i:ι):Field (Eis⧸Ideal.span {p i}):=Ideal.Quotient.field _ + letI (i:ι):Fintype (Eis⧸Ideal.span {p i}):=Fintype.ofFinite _ + let c:=c0*∏i,p i + let Q:ℝ:=‖eisEmbedding c‖^2 + exact fixedRadialCoefficientScalar*∑'t:ThetaFullIndex, + ((fixedConjugateCuspArray 0 t.1 t.2.1 t.2.2.1.val t.2.2.2.val* + sourceFrequencyAngle (thetaFullFrequency t))/ + ((ramifiedScale 1 completedRamifiedStep t.2.1* + Real.sqrt (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ):ℝ):ℂ))* + CubicReflectionKernel.paperKernel (Vstar W) + (X*sourceCuspRadialLength (thetaFullFrequency t)/(27*Q^2))* + (-(Q:ℂ)/(eisEmbedding c)^2* + ((star (eisEmbedding (symbol c0 ((D.gamma (fun _=>1):SL(2,Eis)) 0 0)))* + A4BadPhase c0 hc0 ((D.gamma (fun _=>1):SL(2,Eis)) 1 1) D.U (ramifiedTraceLambda*thetaFullFrequency t))* + ∏i,(((actualSextic (Ideal.span {p i}) (hg i))⁻¹)^2) (D.sigma i)* + phase (actualSextic (Ideal.span {p i}) (hg i)) (quotientTrace (p i) (hp i)) (j i) (D.epsilon i)* + bracket (actualSextic (Ideal.span {p i}) (hg i)) (j i) + (Ideal.Quotient.mk _ (ramifiedTraceLambda*thetaFullFrequency t)))) + +theorem smoothed_eq_reflected (D:PrincipalStratumArithmetic p N a0 c0) + [∀i,(Ideal.span {p i}).IsMaximal] (hp:∀i,p i≠0) (hc0:c0≠0) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,lambda∉Ideal.span {p i}) (hchar:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (hr:lambda^2∣(∏i,p i)-1) (j:ι→ℕ) (hj:∀i,j i<6) + (W:ℝ→ℂ) (lo hi:ℝ) (hlo:0Ideal.span {p i}))) + (hprimary:∀i,lambda^2∣p i-1) + (hg:∀i,lambda∉Ideal.span {p i}) (hchar:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (N a0 c0:Eis) (hc0:c0≠0) (hc3:(3:Eis)∣c0) + (hN:(9:Eis)*c0∣N) (ha0:lambda^2∣a0-1) (hac:IsCoprime a0 c0) + (hNp:∀i,IsCoprime N (p i)) : + ∃D:PrincipalStratumArithmetic p N a0 c0, + ∀j:ι→ℕ,(∀i,j i<6)→∀(W:ℝ→ℂ)(lo hi:ℝ),0hprimary i)) j hj W lo hi hlo hsupp hW X hX + +end CubicEisenstein + +open scoped BigOperators Classical + +namespace CanonicalRowCompletion + +section +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve UniqueFactorizationMonoid +local notation "Eis" => ActualEisensteinCubic.O + +abbrev BasePrimeIndex (I Q:Ideal Eis) := {P:PrimeIndex I // Q≤P.val} +abbrev FreePrimeIndex (I Q:Ideal Eis) := {P:PrimeIndex I // ¬Q≤P.val} + +def basePrimeRow (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) : Eis→*ℂ where + toFun n:=∏P:BasePrimeIndex I Q, + (actualSextic P.val.val ((supported_factors_good I hI P.val.val + (Multiset.mem_toFinset.mp P.val.property)).2.1)^((normalizedFactors I).count P.val.val%6)) + (Ideal.Quotient.mk P.val.val n) + map_one' := by simp only [map_one,Finset.prod_const_one] + map_mul' x y := by simp only [map_mul,Finset.prod_mul_distrib] + +def freePrimeRow (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) : Eis→*ℂ where + toFun n:=∏P:FreePrimeIndex I Q, + (actualSextic P.val.val ((supported_factors_good I hI P.val.val + (Multiset.mem_toFinset.mp P.val.property)).2.1)^((normalizedFactors I).count P.val.val%6)) + (Ideal.Quotient.mk P.val.val n) + map_one' := by simp only [map_one,Finset.prod_const_one] + map_mul' x y := by simp only [map_mul,Finset.prod_mul_distrib] + +lemma basePrimeRow_norm (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) (n:Eis) : + ‖basePrimeRow I hI Q n‖≤1 := by + change ‖∏P:BasePrimeIndex I Q,_‖≤1 + rw [norm_prod] + apply Finset.prod_le_one₀ + · intro P hP;exact norm_nonneg _ + · intro P hP;exact FiniteRayExpansion.norm_char_le_one _ _ + +lemma freePrimeRow_norm (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) (n:Eis) : + ‖freePrimeRow I hI Q n‖≤1 := by + change ‖∏P:FreePrimeIndex I Q,_‖≤1 + rw [norm_prod] + apply Finset.prod_le_one₀ + · intro P hP;exact norm_nonneg _ + · intro P hP;exact FiniteRayExpansion.norm_char_le_one _ _ + +lemma basePrimeRow_periodic (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) : + CanonicalCoefficientClass.FactorsModulo Q (basePrimeRow I hI Q) := by + intro x y hxy + change (∏P:BasePrimeIndex I Q,_)=∏P:BasePrimeIndex I Q,_ + apply Finset.prod_congr rfl + intro P hP + have he:Ideal.Quotient.mk P.val.val x=Ideal.Quotient.mk P.val.val y:= + Ideal.Quotient.eq.mpr (P.property hxy) + rw [he] + +lemma idealRowHom_fixed_conductor_split (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) (n:Eis) : + idealRowHom n I=basePrimeRow I hI Q n*freePrimeRow I hI Q n := by + rw [idealRowHom_eq_prime_count_product I hI n] + exact (Fintype.prod_subtype_mul_prod_subtype (fun P:PrimeIndex I=>Q≤P.val) + (fun P:PrimeIndex I=>(actualSextic P.val ((supported_factors_good I hI P.val + (Multiset.mem_toFinset.mp P.property)).2.1)^((normalizedFactors I).count P.val%6)) + (Ideal.Quotient.mk P.val n))).symm + +lemma freePrimeIndex_pairwise_coprime (I Q:Ideal Eis) : + Pairwise (Function.onFun IsCoprime (fun P:FreePrimeIndex I Q=>P.val.val)) := by + intro P R hPR + exact Ideal.isCoprime_of_isMaximal (fun he=>hPR (Subtype.ext (Subtype.ext he))) + +lemma freePrimeIndex_coprime (I Q:Ideal Eis) (P:FreePrimeIndex I Q) : + IsCoprime Q P.val.val := by + apply Ideal.isCoprime_iff_sup_eq.mpr + by_contra ht + have he:P.val.val=Q⊔P.val.val:= + (show P.val.val.IsMaximal from inferInstance).eq_of_le ht le_sup_right + exact P.property (le_sup_left.trans he.symm.le) + +lemma freePrimeProduct_coprime (I Q:Ideal Eis) : + IsCoprime Q (∏P:FreePrimeIndex I Q,P.val.val) := + IsCoprime.prod_right (fun P _=>freePrimeIndex_coprime I Q P) + +lemma freePrimeRow_eq_principalSexticRow (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) (n:Eis) : + freePrimeRow I hI Q n= + principalSexticRow (fun P:FreePrimeIndex I Q=>P.val.val) (freePrimeIndex_pairwise_coprime I Q) + (fun P=>(supported_factors_good I hI P.val.val (Multiset.mem_toFinset.mp P.val.property)).2.1) + (fun P=>(normalizedFactors I).count P.val.val%6) + (finitePrimeModulus (fun P:FreePrimeIndex I Q=>P.val.val)) + (span_finitePrimeModulus _) (Ideal.Quotient.mk _ n) := by + rw [principalSexticRow_mk] + rfl + +theorem fixed_conductor_absorb_shared_primes (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) + (φ:Eis→*ℂ) (hφ:CanonicalCoefficientClass.FactorsModulo Q φ) (hφn:∀n,‖φ n‖≤1) : + CanonicalCoefficientClass.FactorsModulo Q (φ*basePrimeRow I hI Q) ∧ + (∀n,‖(φ*basePrimeRow I hI Q) n‖≤1) ∧ + IsCoprime Q (∏P:FreePrimeIndex I Q,P.val.val) ∧ + (∀n,φ n*idealRowHom n I=(φ*basePrimeRow I hI Q) n*freePrimeRow I hI Q n) := by + refine ⟨?_,?_,freePrimeProduct_coprime I Q,?_⟩ + · intro x y hxy + change φ x*basePrimeRow I hI Q x=φ y*basePrimeRow I hI Q y + rw [hφ x y hxy,basePrimeRow_periodic I hI Q x y hxy] + · intro n + change ‖φ n*basePrimeRow I hI Q n‖≤1 + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (hφn n)).trans (basePrimeRow_norm I hI Q n) + · intro n + rw [idealRowHom_fixed_conductor_split I hI Q n] + exact (mul_assoc _ _ _).symm + +end +section + +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve +local notation "Eis" => ActualEisensteinCubic.O + +lemma freePrimeRow_periodic (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) : + CanonicalCoefficientClass.FactorsModulo (∏P:FreePrimeIndex I Q,P.val.val) (freePrimeRow I hI Q) := by + intro x y hxy + change (∏P:FreePrimeIndex I Q,_)=∏P:FreePrimeIndex I Q,_ + apply Finset.prod_congr rfl + intro P hP + have hm:x-y∈P.val.val:= + (Ideal.prod_le_inf.trans (Finset.inf_le (Finset.mem_univ P))) hxy + rw [Ideal.Quotient.eq.mpr hm] + +lemma fixedFreeRow_periodic (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) + (φ:Eis→*ℂ) (hφ:CanonicalCoefficientClass.FactorsModulo Q φ) : + CanonicalCoefficientClass.FactorsModulo (Q*(∏P:FreePrimeIndex I Q,P.val.val)) + (φ*freePrimeRow I hI Q) := by + intro x y hxy + change φ x*freePrimeRow I hI Q x=φ y*freePrimeRow I hI Q y + rw [hφ x y (Ideal.mul_le_left hxy),freePrimeRow_periodic I hI Q x y (Ideal.mul_le_right hxy)] + +lemma fixedFreeRow_norm (I:Ideal Eis) (hI:Supported I) (Q:Ideal Eis) + (φ:Eis→*ℂ) (hφ:∀n,‖φ n‖≤1) (n:Eis) : ‖(φ*freePrimeRow I hI Q) n‖≤1 := by + change ‖φ n*freePrimeRow I hI Q n‖≤1 + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) (hφ n)).trans (freePrimeRow_norm I hI Q n) + +theorem exists_actual_coprime_row (Ψ:Eis→*ℂ) (Q:Ideal Eis) + (hΨ:CanonicalCoefficientClass.FactorsModulo Q Ψ) (hΨnorm:∀n,‖Ψ n‖≤1) + (m f z:Eis) (hm:m≠0) (hf:f≠0) (hz:z≠0) (hmLam:lambda∣m) (hm2:(2:Eis)∣m) : + ∃(I:Ideal Eis)(hI:Supported I)(φ:Eis→*ℂ), + CanonicalCoefficientClass.FactorsModulo (Q*Ideal.span {(72:Eis)}) φ ∧ + (∀n,‖φ n‖≤1) ∧ + IsCoprime (Q*Ideal.span {(72:Eis)}) + (∏P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)}),P.val.val) ∧ + (∀n,lambda^2∣n-1 → rowTwist Ψ m f z n=φ n*freePrimeRow I hI (Q*Ideal.span {(72:Eis)}) n) := by + obtain ⟨I,hI,φ,hφ,hφn,hrow⟩:=exists_fixed_twist_principal_row Ψ Q hΨ hΨnorm m f z hm hf hz hmLam hm2 + obtain ⟨hperiod,hnorm,hcop,hprod⟩:=fixed_conductor_absorb_shared_primes I hI _ φ hφ hφn + refine ⟨I,hI,φ*basePrimeRow I hI _,hperiod,hnorm,hcop,?_⟩ + intro n hpn + rw [hrow n hpn,←idealRowHom_eq_principalSexticRow I hI n,hprod n] + +theorem exists_actual_coprime_completed_row (Ψ:Eis→*ℂ) (Q:Ideal Eis) + (hQ:Q≠0) (hΨ:CanonicalCoefficientClass.FactorsModulo Q Ψ) (hΨnorm:∀n,‖Ψ n‖≤1) + (m f z:Eis) (hm:m≠0) (hf:f≠0) (hz:z≠0) (hmLam:lambda∣m) (hm2:(2:Eis)∣m) : + ∃(I:Ideal Eis)(hI:Supported I)(φ:Eis→*ℂ), + CanonicalCoefficientClass.FactorsModulo (Q*Ideal.span {(72:Eis)}) φ ∧ + (∀n,‖φ n‖≤1) ∧ + IsCoprime (Q*Ideal.span {(72:Eis)}) + (∏P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)}),P.val.val) ∧ + (Q*Ideal.span {(72:Eis)}*(∏P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)}),P.val.val))≠0 ∧ + CanonicalCoefficientClass.FactorsModulo + (Q*Ideal.span {(72:Eis)}*(∏P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)}),P.val.val)) + (φ*freePrimeRow I hI (Q*Ideal.span {(72:Eis)})) ∧ + (∀n,‖(φ*freePrimeRow I hI (Q*Ideal.span {(72:Eis)})) n‖≤1) ∧ + (∀W X,completedT (rowTwist Ψ m f z) W X= + completedT (φ*freePrimeRow I hI (Q*Ideal.span {(72:Eis)})) W X) := by + obtain ⟨I,hI,φ,hφ,hφn,hcop,hrow⟩:=exists_actual_coprime_row Ψ Q hΨ hΨnorm m f z hm hf hz hmLam hm2 + refine ⟨I,hI,φ,hφ,hφn,hcop,?_,fixedFreeRow_periodic I hI _ φ hφ, + fixedFreeRow_norm I hI _ φ hφn,?_⟩ + · apply mul_ne_zero + · apply mul_ne_zero hQ + simp only [ne_eq,Ideal.zero_eq_bot,Ideal.span_singleton_eq_bot] + norm_num + · exact finite_prime_product_ne_bot (fun P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)})=>P.val.val) + · intro W X + exact completedT_congr_primary _ _ hrow W X + +def fixedQuotientValue (Q:Ideal Eis) (φ:Eis→*ℂ) (x:Eis⧸Q) : ℂ := φ (Quotient.out x) + +lemma fixedQuotientValue_mk (Q:Ideal Eis) (φ:Eis→*ℂ) + (hφ:CanonicalCoefficientClass.FactorsModulo Q φ) (n:Eis) : + fixedQuotientValue Q φ (Ideal.Quotient.mk Q n)=φ n := + hφ _ _ (Ideal.Quotient.eq.mp (Ideal.Quotient.mk_out _)) + +lemma fixedQuotientValue_norm (Q:Ideal Eis) (φ:Eis→*ℂ) (hφ:∀n,‖φ n‖≤1) (x:Eis⧸Q) : + ‖fixedQuotientValue Q φ x‖≤1 := hφ _ + +end + +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve UniqueFactorizationMonoid +open ConcretePrimeRowBridge +local notation "Eis" => ActualEisensteinCubic.O + +def goodMaskMovingIdeal (g r:Eis) : Ideal Eis := (Ideal.span {g})^6*Ideal.span {r} + +lemma goodMaskMovingIdeal_supported (g r:Eis) + (hg:Supported (Ideal.span {g})) (hr:Supported (Ideal.span {r})) : + Supported (goodMaskMovingIdeal g r) := by + exact (supported_mul_iff _ _).mpr ⟨supported_pow hg 6,hr⟩ + +lemma good_odd_prime_two_not_mem (P:Ideal Eis) [P.IsMaximal] + (hodd:ringChar (Eis⧸P)≠2) : (2:Eis)∉P := by + intro ht + have he:=maximal_ideal_eq_span_of_mem P inferInstance (2:Eis) twoIdeal_maximal ht + exact hodd (he ▸ twoIdeal_characteristic) + +lemma count_span_eq_zero_of_not_mem (P:Ideal Eis) (x:Eis) (hx:x∉P) : + (normalizedFactors (Ideal.span {x})).count P=0 := by + apply Multiset.count_eq_zero.mpr + intro hm + have h0:(Ideal.span {x}:Ideal Eis)≠0:=by + apply Ideal.span_singleton_eq_bot.not.mpr + intro he + exact hx (he ▸ P.zero_mem) + exact hx (Ideal.dvd_span_singleton.mp + ((UniqueFactorizationMonoid.mem_normalizedFactors_iff h0).mp hm).2) + +lemma good_factor_count (P:Ideal Eis) [P.IsMaximal] + (hgood:lambda∉P) (hodd:ringChar (Eis⧸P)≠2) + (u:Eisˣ) (a b:ℕ) (r:Eis) (hr:Supported (Ideal.span {r})) : + (normalizedFactors (Ideal.span {u.val*lambda^a*(2:Eis)^b*r})).count P= + (normalizedFactors (Ideal.span {r})).count P := by + have hl:(Ideal.span {lambda}:Ideal Eis)≠0:= + Ideal.span_singleton_eq_bot.not.mpr PrimaryIdealUnitReindex.lambda_prime_actual.ne_zero + have ht:(Ideal.span {(2:Eis)}:Ideal Eis)≠0:=Ideal.span_singleton_eq_bot.not.mpr (by norm_num) + have hcl:=count_span_eq_zero_of_not_mem P lambda hgood + have hct:=count_span_eq_zero_of_not_mem P 2 (good_odd_prime_two_not_mem P hodd) + rw [show u.val*lambda^a*(2:Eis)^b*r=u.val*(lambda^a*(2:Eis)^b*r) by ring, + Ideal.span_singleton_mul_left_unit u.isUnit, + ←Ideal.span_singleton_mul_span_singleton,←Ideal.span_singleton_mul_span_singleton, + ←Ideal.span_singleton_pow,←Ideal.span_singleton_pow, + normalizedFactors_mul (mul_ne_zero (pow_ne_zero _ hl) (pow_ne_zero _ ht)) hr.1, + normalizedFactors_mul (pow_ne_zero _ hl) (pow_ne_zero _ ht)] + simp only [Multiset.count_add,normalizedFactors_pow,Multiset.count_nsmul,hcl,hct,mul_zero,zero_add] + +theorem goodMaskMovingIdeal_count (I F:Ideal Eis) (hI:I≠0) (hF:F≠0) + (m f z:Eis) (hf:Ideal.span {f}=F) (hz:Ideal.span {z}=I) + (um:Eisˣ) (am bm:ℕ) (g:Eis) (hg:Supported (Ideal.span {g})) + (hm:m=um.val*lambda^am*(2:Eis)^bm*g) + (u:Eisˣ) (a b:ℕ) (r:Eis) (hr:Supported (Ideal.span {r})) + (hx:f^4*z=u.val*lambda^a*(2:Eis)^b*r) + (P:Ideal Eis) [P.IsMaximal] (hgood:lambda∉P) (hodd:ringChar (Eis⧸P)≠2) : + (normalizedFactors (goodMaskMovingIdeal g r)).count P= + 6*(normalizedFactors (Ideal.span {m})).count P+ + 4*(normalizedFactors F).count P+(normalizedFactors I).count P := by + have hmc:(normalizedFactors (Ideal.span {m})).count P=(normalizedFactors (Ideal.span {g})).count P:=by + rw [hm] + exact good_factor_count P hgood hodd um am bm g hg + have hrc:(normalizedFactors (Ideal.span {r})).count P= + 4*(normalizedFactors F).count P+(normalizedFactors I).count P:=by + have hh:=good_factor_count P hgood hodd u a b r hr + rw [←hx,←Ideal.span_singleton_mul_span_singleton,←Ideal.span_singleton_pow,hf,hz, + normalizedFactors_mul (pow_ne_zero 4 hF) hI] at hh + simpa only [Multiset.count_add,normalizedFactors_pow,Multiset.count_nsmul] using hh.symm + rw [goodMaskMovingIdeal,normalizedFactors_mul (pow_ne_zero 6 hg.1) hr.1] + simp only [Multiset.count_add,normalizedFactors_pow,Multiset.count_nsmul,←hmc,hrc] + omega + +lemma squarefree_prime_count_indicator (F P:Ideal Eis) (hF:Squarefree F) (hP:Prime P) : + (normalizedFactors F).count P=if P∣F then 1 else 0 := by + have hle:=Multiset.nodup_iff_count_le_one.mp ((squarefree_iff_nodup_normalizedFactors hF.ne_zero).mp hF) P + by_cases hPF:P∣F + · rw [ite_eq_left hPF] + have hp:=Multiset.count_pos.mpr + ((UniqueFactorizationMonoid.mem_normalizedFactors_iff hF.ne_zero).mpr ⟨hP,hPF⟩) + omega + · rw [ite_eq_right hPF] + apply Multiset.count_eq_zero.mpr + intro hm + exact hPF ((UniqueFactorizationMonoid.mem_normalizedFactors_iff hF.ne_zero).mp hm).2 + +theorem goodMaskMovingIdeal_exponent (I F:Ideal Eis) (hI:I≠0) (hF:Squarefree F) + (m f z:Eis) (hf:Ideal.span {f}=F) (hz:Ideal.span {z}=I) + (um:Eisˣ) (am bm:ℕ) (g:Eis) (hg:Supported (Ideal.span {g})) + (hm:m=um.val*lambda^am*(2:Eis)^bm*g) + (u:Eisˣ) (a b:ℕ) (r:Eis) (hr:Supported (Ideal.span {r})) + (hx:f^4*z=u.val*lambda^a*(2:Eis)^b*r) + (P:Ideal Eis) [P.IsMaximal] (hgood:lambda∉P) (hodd:ringChar (Eis⧸P)≠2) : + (normalizedFactors (goodMaskMovingIdeal g r)).count P%6=completedLocalExponent I F P := by + rw [goodMaskMovingIdeal_count I F hI hF.ne_zero m f z hf hz um am bm g hg hm u a b r hr hx P hgood hodd, + squarefree_prime_count_indicator F P hF (Ideal.prime_of_isPrime (NeZero.ne P) inferInstance)] + unfold completedLocalExponent + omega + +theorem goodMaskMovingIdeal_generator_exponent (I F:Ideal Eis) (hI:I≠0) (hF:Squarefree F) + (m:Eis) (v:Eisˣ) + (um:Eisˣ) (am bm:ℕ) (g:Eis) (hg:Supported (Ideal.span {g})) + (hm:m=um.val*lambda^am*(2:Eis)^bm*g) + (u:Eisˣ) (a b:ℕ) (r:Eis) (hr:Supported (Ideal.span {r})) + (hx:(idealGenerator F)^4*(v.val*idealGenerator I)=u.val*lambda^a*(2:Eis)^b*r) + (P:Ideal Eis) [P.IsMaximal] (hgood:lambda∉P) (hodd:ringChar (Eis⧸P)≠2) : + (normalizedFactors (goodMaskMovingIdeal g r)).count P%6=completedLocalExponent I F P := by + exact goodMaskMovingIdeal_exponent I F hI hF m (idealGenerator F) (v.val*idealGenerator I) + (span_idealGenerator F) (by rw [Ideal.span_singleton_mul_left_unit v.isUnit,span_idealGenerator]) + um am bm g hg hm u a b r hr hx P hgood hodd + +end CanonicalRowCompletion + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedCuspArrays.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedCuspArrays.lean new file mode 100644 index 0000000000000000000000000000000000000000..4bc660f9b063cb2506f4b22c12bb67c29323a840 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedCuspArrays.lean @@ -0,0 +1,686 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.FullFrequencyExpansion + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff MatrixGroups + +open CompletedGauss ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma sourceCuspCoefficients_full_support (j:Fin 3) (h:Eis) (hh:h≠0) + (hc:(sourceCuspCoefficients j).value h≠0) : + ∃p:ThetaFullIndex,thetaFullFrequency p=h := by + have hs : ∃u:Eisˣ,∃m:ℕ,∃I J:Ideal Eis,Squarefree I ∧ + primaryGenerator I≠0 ∧ primaryGenerator J≠0 ∧ + h=(u:Eis)*ActualEisensteinCubic.lambda^m*primaryGenerator I*(primaryGenerator J)^3 := by + fin_cases j + · exact sourceResidualFourierCoefficient_full_squarefree_cube_support h hh hc + · exact ramifiedBesselValue_squarefree_cube_support false h hh hc + · exact ramifiedBesselValue_squarefree_cube_support true h hh hc + obtain ⟨u,m,I,J,hI,hIg,hJg,he⟩:=hs + exact ⟨(u,m,(⟨I,hI,hIg⟩,⟨J,hJg⟩)),he.symm⟩ + +lemma sourceCuspRadialCoefficient_full_support (j:Fin 3) (z:ℂ) (h:Eis) + (hh:h≠0) (hc:sourceCuspRadialCoefficient j z h≠0) : + ∃p:ThetaFullIndex,thetaFullFrequency p=h := by + apply sourceCuspCoefficients_full_support j h hh + intro hz + apply hc + simp only [sourceCuspRadialCoefficient,sourceCuspRadialBaseCoefficient,hz, + star_zero,mul_zero,zero_div,zero_mul] + +theorem sourceCuspRadialCoefficient_tsum_full_index (j:Fin 3) (z:ℂ) (w:Eis→ℂ) : + (∑'h:Eis,w h*sourceCuspRadialCoefficient j z h)= + ∑'p:ThetaFullIndex,w (thetaFullFrequency p)* + sourceCuspRadialCoefficient j z (thetaFullFrequency p) := by + have hs:Function.support (fun h:Eis=>w h*sourceCuspRadialCoefficient j z h)⊆ + {h:Eis|h≠0}:=by + intro h hh hz + subst h + exact hh (by + change w 0*sourceCuspRadialCoefficient j z 0=0 + rw [sourceCuspRadialCoefficient_zero,mul_zero]) + calc + _=∑'h:{h:Eis//h≠0},w h.val*sourceCuspRadialCoefficient j z h.val:= + (tsum_subtype_eq_of_support_subset hs).symm + _=_:=thetaFullFrequency_tsum (sourceCuspRadialCoefficient j z) w + (sourceCuspRadialCoefficient_full_support j z) + +lemma SourceCuspDatum.smoothedKernel_full_index (d:SourceCuspDatum) (W:ℝ→ℂ) (X:ℝ) : + d.smoothedKernel W X= + (d.multiplier*(d.heightScale:ℂ)*(sourceCuspScale d.index:ℂ)^2)* + ∑'p:ThetaFullIndex,sourceCuspRadialCoefficient d.index d.dualPoint (thetaFullFrequency p)* + CubicReflectionKernel.paperKernel (Vstar W) + (X*sourceCuspRadialLength (thetaFullFrequency p)/ + (27*(sourceCuspScale d.index)^2*d.heightScale^2)) := by + rw [d.smoothedKernel_eq] + congr 1 + have he:=sourceCuspRadialCoefficient_tsum_full_index d.index d.dualPoint + (fun h=>CubicReflectionKernel.paperKernel (Vstar W) + (X*sourceCuspRadialLength h/(27*(sourceCuspScale d.index)^2*d.heightScale^2))) + simpa only [mul_comm] using he + +lemma SourceCuspDatum.smoothedKernel_full_index_norm_summable + (d:SourceCuspDatum) (W:ℝ→ℂ) (v0 v1:ℝ) (hv0:0 + ‖sourceCuspRadialCoefficient d.index d.dualPoint (thetaFullFrequency p)* + CubicReflectionKernel.paperKernel (Vstar W) + (X*sourceCuspRadialLength (thetaFullFrequency p)/ + (27*(sourceCuspScale d.index)^2*d.heightScale^2))‖) := by + have hs:=paperKernel_weighted_norm_summable sourceCuspRadialLength sourceCuspRadialLength_pos + (sourceCuspRadialCoefficient d.index d.dualPoint) + (sourceCuspRadialCoefficient_weighted_summable _ _) + (Vstar W) v0 v1 hv0 (Vstar_support W v0 v1 hWs) (Vstar_contDiff W v0 v1 hv0 hWs hW) + (X/(27*(sourceCuspScale d.index)^2*d.heightScale^2)) + (by have := sourceCuspScale_pos d.index; have := d.heightScale_pos; positivity) + have hp:=hs.comp_injective thetaFullFrequency_injective + apply hp.congr + intro p + exact congrArg (fun y:ℝ=>‖sourceCuspRadialCoefficient d.index d.dualPoint (thetaFullFrequency p)* + CubicReflectionKernel.paperKernel (Vstar W) y‖) + (by ring : + X/(27*(sourceCuspScale d.index)^2*d.heightScale^2)*sourceCuspRadialLength (thetaFullFrequency p)= + X*sourceCuspRadialLength (thetaFullFrequency p)/(27*(sourceCuspScale d.index)^2*d.heightScale^2)) + +theorem completedT_finite_smoothed_full_index + (Ψ:Eis→*ℂ) (hΨ:∀x,‖Ψ x‖≤1) + (Q:Ideal Eis) (hperiod:CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) + (d:(Eis⧸Ideal.span {c})→SourceCuspDatum) + (hd:∀h,(d h).point=thetaFourierTranslation c h) + (W:ℝ→ℂ) (v0 v1:ℝ) (hv0:0 ActualEisensteinCubic.O + +def fixedCuspCoefficientBound : ℝ := + Classical.choose three_cusp_coefficients_squarefree_cube_bound + +lemma fixedCuspCoefficientBound_pos : 0∏i,φ i (e x i)) h= + ∏i,finiteAdditiveFourierCoeff (coordinateAddChar R e ψ i) (φ i) (e h i) := by + have hsum : (∑x:T,(∏i,φ i (e x i))*ψ (-h*x))= + ∏i,∑x:R i,φ i x*coordinateAddChar R e ψ i (-(e h i)*x) := by + calc + _ = ∑x:T,∏i,φ i (e x i)*coordinateAddChar R e ψ i (-(e h i)*e x i) := by + apply Finset.sum_congr rfl + intro x hx + rw [addChar_finite_crt_factor R e ψ (-h*x)] + simp only [map_mul,map_neg,Pi.mul_apply,Pi.neg_apply,Finset.prod_mul_distrib] + _ = ∑x:(∀i,R i),∏i,φ i (x i)*coordinateAddChar R e ψ i (-(e h i)*x i) := + Equiv.sum_comp e.toEquiv (fun x:∀i,R i=>∏i,φ i (x i)*coordinateAddChar R e ψ i (-(e h i)*x i)) + _ = _ := (Fintype.prod_sum (fun i (x:R i)=>φ i x*coordinateAddChar R e ψ i (-(e h i)*x))).symm + have hcard : (Fintype.card T:ℂ)=∏i,(Fintype.card (R i):ℂ) := by + rw [Fintype.card_congr e.toEquiv,Fintype.card_pi,Nat.cast_prod] + simp only [finiteAdditiveFourierCoeff,hsum,hcard,Finset.prod_div_distrib] + +theorem finite_fourier_weighted_crt {ι T : Type*} [Fintype ι] + (R : ι→Type*) [CommRing T] [∀i,CommRing (R i)] + [Fintype T] [∀i,Fintype (R i)] (e : T≃+*∀i,R i) + (ψ : AddChar T ℂ) (φ κ : ∀i,R i→ℂ) : + (∑h:T,finiteAdditiveFourierCoeff ψ (fun x=>∏i,φ i (e x i)) h * + ∏i,κ i (e h i))= + ∏i,∑h:R i,finiteAdditiveFourierCoeff (coordinateAddChar R e ψ i) (φ i) h*κ i h := by + simp only [finiteAdditiveFourierCoeff_crt,←Finset.prod_mul_distrib] + calc + _ = ∑h:∀i,R i,∏i,finiteAdditiveFourierCoeff (coordinateAddChar R e ψ i) (φ i) (h i)*κ i (h i) := + Equiv.sum_comp e.toEquiv + (fun h:∀i,R i=>∏i,finiteAdditiveFourierCoeff (coordinateAddChar R e ψ i) (φ i) (h i)*κ i (h i)) + _ = _ := (Fintype.prod_sum (fun i (h:R i)=> + finiteAdditiveFourierCoeff (coordinateAddChar R e ψ i) (φ i) h*κ i h)).symm + +end IdealGaussCRT + +namespace LocalReflectionBrackets + +section +open CubicEisenstein +variable {F : Type*} [Field F] [Fintype F] + +def frequencyMultiplier (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (σ ε : Fˣ) (x h : F) : ℂ := + if h=0 then 1 else (((χ⁻¹)^2) ((σ:F)*h))*ψ (((ε:F)*x)*h⁻¹) + +def frequencyRow (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (j : ℕ) (σ ε : Fˣ) (x h : F) : ℂ := + finiteAdditiveFourierCoeff ψ (fun t=>(χ^j) t) h*frequencyMultiplier χ ψ σ ε x h + +lemma frequencyRow_zero (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (j : ℕ) (σ ε : Fˣ) (x : F) : + frequencyRow χ ψ j σ ε x 0=zeroFourierCoefficient χ j := by + simp only [frequencyRow,frequencyMultiplier,finiteAdditiveFourierCoeff, + zeroFourierCoefficient,ite_true,neg_zero,zero_mul,AddChar.map_zero_eq_one, + mul_one,div_eq_mul_inv] + ring + +lemma frequencyRow_units (χ : MulChar F ℂ) (ψ : AddChar F ℂ) + (j : ℕ) (σ ε : Fˣ) (x : F) : + (∑h:Fˣ,frequencyRow χ ψ j σ ε x h)=activeRow χ ψ j σ ε x := by + unfold frequencyRow finiteAdditiveFourierCoeff frequencyMultiplier activeRow + simp only [Units.ne_zero,ite_false,Units.val_inv_eq_inv_val,Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + ring_nf + +open ActualEisensteinCubic CompletedGauss +noncomputable local instance quotientFieldFrequency (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] : + Field (ActualEisensteinCubic.O⧸P) := Ideal.Quotient.field P +noncomputable local instance quotientFintypeFrequency (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] : + Fintype (ActualEisensteinCubic.O⧸P) := Fintype.ofFinite _ + +theorem canonical_frequencyRow_zero (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] + (hgood : lambda∉P) (hchar : ringChar (ActualEisensteinCubic.O⧸P)≠2) (ψ : AddChar (ActualEisensteinCubic.O⧸P) ℂ) + (j : ℕ) (hj : j<6) (σ ε : (ActualEisensteinCubic.O⧸P)ˣ) (x : ActualEisensteinCubic.O⧸P) : + frequencyRow (actualSextic P hgood) ψ j σ ε x 0= + if j=0 then 1-(Fintype.card (ActualEisensteinCubic.O⧸P):ℂ)⁻¹ else 0 := by + rw [frequencyRow_zero] + simpa only [actualSextic] using canonical_zeroFourierCoefficient P hgood hchar j hj + +theorem canonical_frequencyRow_units (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] + (hgood : lambda∉P) (hchar : ringChar (ActualEisensteinCubic.O⧸P)≠2) (ψ : AddChar (ActualEisensteinCubic.O⧸P) ℂ) + (hψ : ψ.IsPrimitive) (j : ℕ) (hj : j<6) (σ ε : (ActualEisensteinCubic.O⧸P)ˣ) (x : ActualEisensteinCubic.O⧸P) : + (∑h:(ActualEisensteinCubic.O⧸P)ˣ,frequencyRow (actualSextic P hgood) ψ j σ ε x h)= + (((actualSextic P hgood)⁻¹)^2) σ * + phase (actualSextic P hgood) ψ j ε*bracket (actualSextic P hgood) j x := by + rw [frequencyRow_units] + simpa only [actualSextic] using canonical_A5_normalized P hgood hchar ψ hψ j hj σ ε x + +end + +open ActualEisensteinCubic CubicEisenstein IdealGaussCRT CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O +noncomputable local instance quotientFintypeCrt (P : Ideal Eis) [P.IsMaximal] : + Fintype (Eis⧸P) := Fintype.ofFinite _ + +theorem canonical_finite_reflection_crt {ι T : Type*} [Fintype ι] + [CommRing T] [Fintype T] + (P : ι→Ideal Eis) [∀i,(P i).IsMaximal] + (e : T≃+*∀i,Eis⧸P i) (ψ : AddChar T ℂ) (hψ : ψ.IsPrimitive) + (hg : ∀i,lambda∉P i) (hchar : ∀i,ringChar (Eis⧸P i)≠2) + (j : ι→ℕ) (hj : ∀i,j i<6) (σ ε : ∀i,(Eis⧸P i)ˣ) (x : ∀i,Eis⧸P i) : + let χ := fun i=>actualSextic (P i) (hg i) + let ψi := coordinateAddChar (fun i=>Eis⧸P i) e ψ + (∑h:T,finiteAdditiveFourierCoeff ψ (fun t=>∏i,(χ i^j i) (e t i)) h* + ∏i,frequencyMultiplier (χ i) (ψi i) (σ i) (ε i) (x i) (e h i))= + ∑A∈(Finset.univ:Finset ι).powerset, + (∏i∈A,(((χ i)⁻¹)^2) (σ i)*phase (χ i) (ψi i) (j i) (ε i)*bracket (χ i) (j i) (x i))* + (∏i∈(Finset.univ:Finset ι)\A,if j i=0 then 1-(Fintype.card (Eis⧸P i):ℂ)⁻¹ else 0) := by + let (i : ι) : Field (Eis⧸P i) := Ideal.Quotient.field (P i) + let χ := fun i=>actualSextic (P i) (hg i) + let ψi := coordinateAddChar (fun i=>Eis⧸P i) e ψ + let f := fun i=>frequencyRow (χ i) (ψi i) (j i) (σ i) (ε i) (x i) + have hsum : (∑h:T,finiteAdditiveFourierCoeff ψ (fun t=>∏i,(χ i^j i) (e t i)) h* + ∏i,frequencyMultiplier (χ i) (ψi i) (σ i) (ε i) (x i) (e h i))= + ∑h:∀i,Eis⧸P i,∏i,f i (h i) := by + simp only [finiteAdditiveFourierCoeff_crt,←Finset.prod_mul_distrib] + exact Equiv.sum_comp e.toEquiv (fun h:∀i,Eis⧸P i=>∏i,f i (h i)) + have hactive (i : ι) : (∑h:(Eis⧸P i)ˣ,f i h)= + (((χ i)⁻¹)^2) (σ i)*phase (χ i) (ψi i) (j i) (ε i)*bracket (χ i) (j i) (x i) := by + exact canonical_frequencyRow_units (P i) (hg i) (hchar i) (ψi i) + (coordinateAddChar_isPrimitive (fun i=>Eis⧸P i) e ψ hψ i) (j i) (hj i) (σ i) (ε i) (x i) + have hzero (i : ι) : f i 0=if j i=0 then 1-(Fintype.card (Eis⧸P i):ℂ)⁻¹ else 0 := by + exact canonical_frequencyRow_zero (P i) (hg i) (hchar i) (ψi i) (j i) (hj i) (σ i) (ε i) (x i) + change (∑h:T,finiteAdditiveFourierCoeff ψ (fun t=>∏i,(χ i^j i) (e t i)) h* + ∏i,frequencyMultiplier (χ i) (ψi i) (σ i) (ε i) (x i) (e h i))=_ + rw [hsum,FixedRayActiveSet.product_sum_by_active_set (fun i=>Eis⧸P i) f] + simp only [hactive,hzero] + rfl + +theorem canonical_principal_reflection_crt {ι : Type*} [Fintype ι] + (P : ι→Ideal Eis) [∀i,(P i).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime P)) + (hg : ∀i,lambda∉P i) (hchar : ∀i,ringChar (Eis⧸P i)≠2) + (j : ι→ℕ) (hj : ∀i,j i<6) (σ ε : ∀i,(Eis⧸P i)ˣ) (x : ∀i,Eis⧸P i) + (c : Eis) (hc : c≠0) (hcP : Ideal.span {c}=∏i,P i) + [Fintype (Eis⧸Ideal.span {c})] : + let e := (Ideal.quotEquivOfEq hcP).trans (quotientProdEquivPi P hcop) + let ψ := quotientTrace c hc + let χ := fun i=>actualSextic (P i) (hg i) + let ψi := coordinateAddChar (fun i=>Eis⧸P i) e ψ + (∑h:Eis⧸Ideal.span {c},finiteAdditiveFourierCoeff ψ (principalSexticRow P hcop hg j c hcP) h* + ∏i,frequencyMultiplier (χ i) (ψi i) (σ i) (ε i) (x i) (e h i))= + ∑A∈(Finset.univ:Finset ι).powerset, + (∏i∈A,(((χ i)⁻¹)^2) (σ i)*phase (χ i) (ψi i) (j i) (ε i)*bracket (χ i) (j i) (x i))* + (∏i∈(Finset.univ:Finset ι)\A,if j i=0 then 1-(Fintype.card (Eis⧸P i):ℂ)⁻¹ else 0) := by + let e := (Ideal.quotEquivOfEq hcP).trans (quotientProdEquivPi P hcop) + have hψ : (quotientTrace c hc).IsPrimitive := + GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive c hc + have hrow : principalSexticRow P hcop hg j c hcP= + fun t=>∏i,(actualSextic (P i) (hg i)^j i) (e t i) := by + funext t + rfl + dsimp only + rw [hrow] + exact canonical_finite_reflection_crt P e (quotientTrace c hc) hψ hg hchar j hj σ ε x + +end LocalReflectionBrackets +end + +namespace CubicEisenstein +open scoped Classical MatrixGroups Matrix + +open CubicKubota EisensteinCuspModThree ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma upper_right_removed_bottom (M T:SL(2,Eis)) (hT:T 1 0=0) : + (M*T⁻¹) 1 0=M 1 0*T 1 1 := by + simp [Matrix.SpecialLinearGroup.coe_mul,Matrix.SpecialLinearGroup.coe_inv, + Matrix.adjugate_fin_two,Matrix.mul_apply,Fin.sum_univ_two,hT] + +lemma upper_right_removed_top (M T:SL(2,Eis)) (hT:T 1 0=0) : + (M*T⁻¹) 0 0=M 0 0*T 1 1 := by + simp [Matrix.SpecialLinearGroup.coe_mul,Matrix.SpecialLinearGroup.coe_inv, + Matrix.adjugate_fin_two,Matrix.mul_apply,Fin.sum_univ_two,hT] + +lemma upper_right_removed_last (M T:SL(2,Eis)) : + (M*T⁻¹) 1 1= -M 1 0*T 0 1+M 1 1*T 0 0 := by + simp [Matrix.SpecialLinearGroup.coe_mul,Matrix.SpecialLinearGroup.coe_inv, + Matrix.adjugate_fin_two,Matrix.mul_apply,Fin.sum_univ_two] + +lemma upper_diagonal_product (T:SL(2,Eis)) (hT:T 1 0=0) : T 0 0*T 1 1=1 := by + have hd:=T.property + simpa only [Matrix.det_fin_two,hT,mul_zero,sub_zero] using hd + +structure FixedCuspShape (H:SL(2,Eis)) where + gamma : levelTwo + index : Fin 3 + upper : SL(2,Eis) + lower_zero : upper 1 0=0 + upper_unit : IsUnit (upper 0 0) + lower_unit : IsUnit (upper 1 1) + factorization : H=(gamma:SL(2,Eis))*cuspRepresentative index*upper + +lemma exists_fixedCuspShape (H:SL(2,Eis)) : Nonempty (FixedCuspShape H) := by + obtain ⟨G,j,T,hT,hT0,hT1,he⟩:=three_cusp_decomposition H + exact ⟨⟨G,j,T,hT,hT0,hT1,he⟩⟩ + +namespace FixedCuspShape +variable {H:SL(2,Eis)} (s:FixedCuspShape H) (g:levelTwo) + +lemma removed_eq : (g:SL(2,Eis))*H*s.upper⁻¹= + ((g*s.gamma:levelTwo):SL(2,Eis))*cuspRepresentative s.index := by + calc + _ = (g:SL(2,Eis))*((s.gamma:SL(2,Eis))*cuspRepresentative s.index*s.upper)*s.upper⁻¹ := + congrArg (fun K:SL(2,Eis)=>(g:SL(2,Eis))*K*s.upper⁻¹) s.factorization + _ = _ := by simp only [Subgroup.coe_mul]; group + +def datum (h:((g:SL(2,Eis))*H) 1 0≠0) : SourceCuspDatum where + gamma := g*s.gamma + index := s.index + lower_ne_zero := by + rw [←map_mul,←s.removed_eq g,integralComplexMatrix_apply, + upper_right_removed_bottom _ _ s.lower_zero,map_mul] + exact mul_ne_zero (eisEmbedding_ne_zero h) (eisEmbedding_ne_zero s.lower_unit.ne_zero) + +lemma datum_matrix (h:((g:SL(2,Eis))*H) 1 0≠0) : + (s.datum g h).matrix=integralComplexMatrix ((g:SL(2,Eis))*H*s.upper⁻¹) := by + rw [s.removed_eq g,map_mul] + rfl + +lemma datum_point (h:((g:SL(2,Eis))*H) 1 0≠0) : + (s.datum g h).point= + eisEmbedding (((g:SL(2,Eis))*H) 0 0)/eisEmbedding (((g:SL(2,Eis))*H) 1 0) := by + rw [SourceCuspDatum.point,s.datum_matrix] + rw [integralComplexMatrix_apply,integralComplexMatrix_apply, + upper_right_removed_top _ _ s.lower_zero,upper_right_removed_bottom _ _ s.lower_zero] + simp only [map_mul] + exact mul_div_mul_right _ _ (eisEmbedding_ne_zero s.lower_unit.ne_zero) + +lemma datum_heightScale (h:((g:SL(2,Eis))*H) 1 0≠0) : + (s.datum g h).heightScale=‖eisEmbedding (((g:SL(2,Eis))*H) 1 0)‖^2 := by + rw [SourceCuspDatum.heightScale,s.datum_matrix,integralComplexMatrix_apply, + upper_right_removed_bottom _ _ s.lower_zero,map_mul,norm_mul] + have hn:‖eisEmbedding (s.upper 1 1)‖=1 := by + rcases s.lower_unit with ⟨u,hu⟩ + rw [←hu] + exact GaussGeneratorTransport.norm_eisEmbedding_unit u + rw [hn,mul_one] + +lemma datum_dualPoint (h:((g:SL(2,Eis))*H) 1 0≠0) : + (s.datum g h).dualPoint= + eisEmbedding (s.upper 0 0*s.upper 0 1)- + eisEmbedding (s.upper 0 0)^2* + (eisEmbedding (((g:SL(2,Eis))*H) 1 1)/eisEmbedding (((g:SL(2,Eis))*H) 1 0)) := by + rw [SourceCuspDatum.dualPoint,s.datum_matrix] + rw [integralComplexMatrix_apply,integralComplexMatrix_apply,upper_right_removed_last, + upper_right_removed_bottom _ _ s.lower_zero] + simp only [map_add,map_neg,map_mul] + have hd:eisEmbedding (s.upper 0 0)*eisEmbedding (s.upper 1 1)=1 := by + rw [←map_mul,upper_diagonal_product _ s.lower_zero,map_one] + have hc:=eisEmbedding_ne_zero h + have ht:=eisEmbedding_ne_zero s.lower_unit.ne_zero + field_simp [hc,ht] + linear_combination (eisEmbedding (s.upper 0 0)*eisEmbedding (((g:SL(2,Eis))*H) 1 1)- + eisEmbedding (((g:SL(2,Eis))*H) 1 0)*eisEmbedding (s.upper 0 1))*hd + +lemma datum_multiplier (h:((g:SL(2,Eis))*H) 1 0≠0) : + (s.datum g h).multiplier= + -star (levelTwoComplexCharacter g)*star (levelTwoComplexCharacter s.gamma)* + eisEmbedding (s.upper 0 0)^2/eisEmbedding (((g:SL(2,Eis))*H) 1 0)^2 := by + rw [SourceCuspDatum.multiplier,s.datum_matrix,integralComplexMatrix_apply, + upper_right_removed_bottom _ _ s.lower_zero,map_mul] + change -star (levelTwoComplexCharacter (g*s.gamma))/ + (eisEmbedding (((g:SL(2,Eis))*H) 1 0)*eisEmbedding (s.upper 1 1))^2=_ + rw [map_mul,star_mul] + have hc:=eisEmbedding_ne_zero h + have ht:=eisEmbedding_ne_zero s.lower_unit.ne_zero + have hd:eisEmbedding (s.upper 0 0)*eisEmbedding (s.upper 1 1)=1 := by + rw [←map_mul,upper_diagonal_product _ s.lower_zero,map_one] + have hp:eisEmbedding (s.upper 0 0)^2*eisEmbedding (s.upper 1 1)^2=1 := by + rw [←mul_pow,hd,one_pow] + field_simp [hc,ht] + linear_combination (star (levelTwoComplexCharacter g)*star (levelTwoComplexCharacter s.gamma))*hp + +lemma datum_additive_phase (h:((g:SL(2,Eis))*H) 1 0≠0) (freq:ℂ) (scale:ℂ) : + ShortDraftTrace.breveE (-freq*(s.datum g h).dualPoint/scale)= + ShortDraftTrace.breveE (-freq*eisEmbedding (s.upper 0 0*s.upper 0 1)/scale)* + ShortDraftTrace.breveE (freq*eisEmbedding (s.upper 0 0)^2* + (eisEmbedding (((g:SL(2,Eis))*H) 1 1)/eisEmbedding (((g:SL(2,Eis))*H) 1 0))/scale) := by + rw [s.datum_dualPoint] + rw [show -freq*(eisEmbedding (s.upper 0 0*s.upper 0 1)- + eisEmbedding (s.upper 0 0)^2*(eisEmbedding (((g:SL(2,Eis))*H) 1 1)/ + eisEmbedding (((g:SL(2,Eis))*H) 1 0)))/scale= + -freq*eisEmbedding (s.upper 0 0*s.upper 0 1)/scale+ + freq*eisEmbedding (s.upper 0 0)^2*eisEmbedding (((g:SL(2,Eis))*H) 1 1)/ + eisEmbedding (((g:SL(2,Eis))*H) 1 0)/scale by ring] + simp only [AddChar.map_add_eq_mul,mul_div_assoc] + +end FixedCuspShape +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups ContDiff + +namespace CompletedGauss +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve CompletedDyadic +local notation "Eis" => ActualEisensteinCubic.O + +namespace ReflectedBranchData + +def withFixedCuspArray {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (rowPhase:ℕ→idealRange (completedResidualScale K I Q)→ℂ) + (hrow:∀m k,‖rowPhase m k‖≤1) : ReflectedBranchData levelBound K I F Q := + d.withCanonicalCuspArray (fixedConjugateCuspArray cusp u) + (fun m n b=>fixedConjugateCuspArray_norm_le_one cusp u m n.val b.val) rowPhase hrow + +lemma withFixedCuspArray_amplitude {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (rowPhase:ℕ→idealRange (completedResidualScale K I Q)→ℂ) + (hrow:∀m k,‖rowPhase m k‖≤1) (i:ℕ×ℕ×ℕ) (n b:Ideal Eis) : + (d.withFixedCuspArray cusp u rowPhase hrow).amplitude i n b= + fixedConjugateCuspArray cusp u i.1 n b := rfl + +theorem withFixedCuspArray_value {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (rowPhase:ℕ→idealRange (completedResidualScale K I Q)→ℂ) + (hrow:∀m k,‖rowPhase m k‖≤1) + (W:ℝ→ℂ) (a b:ℝ) (ha:0fixedConjugateCuspArray_norm_le_one cusp u m n.val b.val) + rowPhase hrow W a b ha hsupp hW X ρ q hX hρ hq hK k hk + +def extractedFixedCuspArray {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (m:ℕ) (n b:Ideal Eis) : ℂ := + fixedConjugateCuspArray cusp u m + (reflectionExtractedDivisor (fun p:d.primes=>p.val) + (fun p=>completedLocalExponent I F p.val) d.label 1*n) + (reflectionExtractedDivisor (fun p:d.primes=>p.val) + (fun p=>completedLocalExponent I F p.val) d.label 2*b) + +lemma extractedFixedCuspArray_norm_le_one {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (m:ℕ) (n b:Ideal Eis) : ‖d.extractedFixedCuspArray cusp u m n b‖≤1 := + fixedConjugateCuspArray_norm_le_one cusp u m _ _ + +lemma extractedFixedCuspArray_zero {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (m:ℕ) (n b:Ideal Eis) + (h:¬fixedCuspArrayEligible + (reflectionExtractedDivisor (fun p:d.primes=>p.val) + (fun p=>completedLocalExponent I F p.val) d.label 1*n) + (reflectionExtractedDivisor (fun p:d.primes=>p.val) + (fun p=>completedLocalExponent I F p.val) d.label 2*b)) : + d.extractedFixedCuspArray cusp u m n b=0 := by + simp only [extractedFixedCuspArray,fixedConjugateCuspArray, + fixedCuspArray_zero_of_ineligible _ _ _ _ _ h,star_zero] + +def withExtractedFixedCuspArray {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (rowPhase:ℕ→idealRange (completedResidualScale K I Q)→ℂ) + (hrow:∀m k,‖rowPhase m k‖≤1) : ReflectedBranchData levelBound K I F Q := + d.withCanonicalCuspArray (d.extractedFixedCuspArray cusp u) + (fun m n b=>d.extractedFixedCuspArray_norm_le_one cusp u m n.val b.val) rowPhase hrow + +lemma withExtractedFixedCuspArray_amplitude {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (rowPhase:ℕ→idealRange (completedResidualScale K I Q)→ℂ) + (hrow:∀m k,‖rowPhase m k‖≤1) (i:ℕ×ℕ×ℕ) (n b:Ideal Eis) : + (d.withExtractedFixedCuspArray cusp u rowPhase hrow).amplitude i n b= + d.extractedFixedCuspArray cusp u i.1 n b := rfl + +theorem withExtractedFixedCuspArray_value {levelBound K:ℝ} {I F Q:Ideal Eis} + (d:ReflectedBranchData levelBound K I F Q) (cusp:Fin 3) (u:Eisˣ) + (rowPhase:ℕ→idealRange (completedResidualScale K I Q)→ℂ) + (hrow:∀m k,‖rowPhase m k‖≤1) + (W:ℝ→ℂ) (a b:ℝ) (ha:0d.extractedFixedCuspArray_norm_le_one cusp u m n.val b.val) + rowPhase hrow W a b ha hsupp hW X ρ q hX hρ hq hK k hk + +end ReflectedBranchData +end CompletedGauss + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedFrequencyExpansion.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedFrequencyExpansion.lean new file mode 100644 index 0000000000000000000000000000000000000000..83199152b31b7ccd616e055436a8338c2572e59a --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedFrequencyExpansion.lean @@ -0,0 +1,637 @@ +import OAI.NumberTheory.DirichletL.Cusp.StaticReflectionPhases + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss CubicKubota +open CubicJacobiGlobal ShortDraftCusp ShortDraftCRT FiniteGaussPhase LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O +namespace ControlledStratumArithmetic +variable {ι:Type*} [Fintype ι] {p:ι→Eis} {N a0 c0:Eis} {mode:Bool} + +def fixedCusp (a0 c0:Eis) (mode:Bool) : SL(2,Eis) := + if mode then lowerCuspMatrix c0 else A3WeylCusp a0 + +lemma relative (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + D.matrix v*(fixedCusp a0 c0 mode)⁻¹∈levelThree := by + have h3N:(3:Eis)∣N:=(show (3:Eis)∣9 from ⟨3,by norm_num⟩).trans + ((dvd_mul_right 9 c0).trans hN) + cases mode + · exact D.unramified_relative h3N hr hbase a0 (by simp) v + · exact D.ramified_relative h3N hr hbase c0 (by simp) v + +def relativeGamma (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : levelThree := + ⟨D.matrix v*(fixedCusp a0 c0 mode)⁻¹,D.relative hN hr hbase v⟩ + +lemma relativeGamma_mul (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + (D.relativeGamma hN hr hbase v:SL(2,Eis))*fixedCusp a0 c0 mode=D.matrix v := by + exact inv_mul_cancel_right (D.matrix v) (fixedCusp a0 c0 mode) + +def fixedFactor (D:ControlledStratumArithmetic p N a0 c0 mode) : ℂ := + if mode then + eisEmbedding (symbol (-c0) (D.matrix (fun _=>1) 0 0-c0*D.matrix (fun _=>1) 0 1)* + symbol 1 (D.matrix (fun _=>1) 0 0)) + else eisEmbedding (symbol (D.matrix (fun _=>1) 0 0) c0) + +theorem relative_character (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + complexCharacter (D.relativeGamma hN hr hbase v)= + D.fixedFactor*eisEmbedding (symbol (D.matrix v 0 0) (∏i,p i)) := by + cases mode + · simpa only [relativeGamma,fixedCusp,fixedFactor,Bool.false_eq_true,↓reduceIte, + unramifiedFixedFactor] using D.unramified_character hN hr hbase a0 (by simp) v + · simpa only [relativeGamma,fixedCusp,fixedFactor,Bool.true_eq,↓reduceIte, + ramifiedFixedFactor] using D.ramified_character hN hr hbase c0 1 (by simp) (by simp) v + +theorem fixedFactor_norm (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) : ‖D.fixedFactor‖=1 := by + have h3N:(3:Eis)∣N:=(show (3:Eis)∣9 from ⟨3,by norm_num⟩).trans + ((dvd_mul_right 9 c0).trans hN) + cases mode + · exact norm_A3_unramified_fixed_factor _ _ _ _ _ (D.determinant (fun _=>1)) hbase + · apply norm_A3_ramified_fixed_factor _ _ 1 (∏i,p i) _ c0 + · simpa only [one_mul] using D.determinant (fun _=>1) + · exact D.numerator_primary h3N hr hbase (fun _=>1) + · exact A3_ramified_relative_primary (D.matrix (fun _=>1)) c0 + (D.ramified_relative h3N hr hbase c0 (by simp) (fun _=>1)) + +noncomputable def fourierWeight [∀i,(Ideal.span {p i}).IsMaximal] + (hp:∀i,p i≠0) (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : ℂ := by + letI (i:ι):Fintype (Eis⧸Ideal.span {p i}):=Fintype.ofFinite _ + exact ∏i,finiteAdditiveFourierCoeff (quotientTrace (p i) (hp i)) + (fun t=>(actualSextic (Ideal.span {p i}) (hg i)^j i) t) (v i) + +noncomputable def multiplierSum (D:ControlledStratumArithmetic p N a0 c0 mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (hp:∀i,p i≠0) (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) (x:Eis) : ℂ := by + letI (i:ι):Fintype (Eis⧸Ideal.span {p i}):=Fintype.ofFinite _ + exact ∑v:∀i,(Eis⧸Ideal.span {p i})ˣ, + fourierWeight hp hg j v*star (complexCharacter (D.relativeGamma hN hr hbase v))* + ShortDraftTrace.breveE (-(eisEmbedding (D.matrix v 1 1)*(eisEmbedding x/eisLam^4))/ + (eisEmbedding c0*eisEmbedding (∏i,p i))) + +noncomputable def bracketProduct (D:ControlledStratumArithmetic p N a0 c0 mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hp:∀i,p i≠0) (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) (x:Eis) : ℂ := by + letI (i:ι):Field (Eis⧸Ideal.span {p i}):=Ideal.Quotient.field _ + letI (i:ι):Fintype (Eis⧸Ideal.span {p i}):=Fintype.ofFinite _ + exact ∏i,(((actualSextic (Ideal.span {p i}) (hg i))⁻¹)^2) (D.sigma i)* + phase (actualSextic (Ideal.span {p i}) (hg i)) (quotientTrace (p i) (hp i)) (j i) (D.epsilon i)* + bracket (actualSextic (Ideal.span {p i}) (hg i)) (j i) (Ideal.Quotient.mk _ x) + +theorem multiplierSum_eq (D:ControlledStratumArithmetic p N a0 c0 mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (hp:∀i,p i≠0) (hc0:c0≠0) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,lambda∉Ideal.span {p i}) (hchar:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (j:ι→ℕ) (hj:∀i,j i<6) (x:Eis) : + D.multiplierSum hN hr hbase hp hg j x= + (star D.fixedFactor*A4BadPhase c0 hc0 (D.matrix (fun _=>1) 1 1) D.U x)* + D.bracketProduct hp hg j x := by + exact stratum_multiplier_of_cubic_factor p hp hcop hg hchar c0 D.U D.w x + (D.matrix (fun _=>1) 1 1) hc0 D.bezout + (fun v=>D.matrix v 0 0) (fun v=>D.matrix v 0 1) (fun v=>D.matrix v 1 1) + (fun v=>complexCharacter (D.relativeGamma hN hr hbase v)) D.fixedFactor + (D.relative_character hN hr hbase) D.determinant (D.inverse_fixed hN) + D.sigma D.epsilon D.frequency_congruence D.epsilon_value j hj + +end ControlledStratumArithmetic +end + +section +open scoped BigOperators Classical ContDiff MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss CompletedDyadic CubicKubota +open CubicJacobiGlobal ShortDraftCusp ShortDraftCRT FiniteGaussPhase LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O +namespace ControlledStratumArithmetic +variable {ι:Type*} [Fintype ι] {p:ι→Eis} {N a0 c0:Eis} {mode:Bool} + +def sourceGamma (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : levelTwo := + sourceLevelInclusion (D.relativeGamma hN hr hbase v) + +lemma sourceGamma_mul (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + (D.sourceGamma hN hr hbase v:SL(2,Eis))*fixedCusp a0 c0 mode=D.matrix v := + D.relativeGamma_mul hN hr hbase v + +lemma sourceGamma_character (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + levelTwoComplexCharacter (D.sourceGamma hN hr hbase v)= + complexCharacter (D.relativeGamma hN hr hbase v) := + sourceLevelInclusion_character _ + +def datum (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (s:FixedCuspShape (fixedCusp a0 c0 mode)) + (hp:∀i,p i≠0) (hc0:c0≠0) (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : SourceCuspDatum := + s.datum (D.sourceGamma hN hr hbase v) (by + rw [D.sourceGamma_mul,D.denominator] + exact mul_ne_zero hc0 (Finset.prod_ne_zero_iff.mpr (fun i _=>hp i))) + +lemma datum_point (D:ControlledStratumArithmetic p N a0 c0 mode) + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (s:FixedCuspShape (fixedCusp a0 c0 mode)) + (hp:∀i,p i≠0) (hc0:c0≠0) (v:∀i,(Eis⧸Ideal.span {p i})ˣ) : + (D.datum hN hr hbase s hp hc0 v).point=eisEmbedding a0/eisEmbedding c0+ + eisLam^2*∑i,eisEmbedding (D.lift v i)/eisEmbedding (p i) := by + rw [datum,s.datum_point,D.sourceGamma_mul,D.numerator,D.denominator] + simpa only [ramifiedEmbedding_traceLambda] using + finiteCrossNumerator_fraction a0 c0 ramifiedTraceLambda p (D.lift v) hc0 hp + +noncomputable def smoothedValue (D:ControlledStratumArithmetic p N a0 c0 mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (s:FixedCuspShape (fixedCusp a0 c0 mode)) + (hp:∀i,p i≠0) (hc0:c0≠0) (hg:∀i,lambda∉Ideal.span {p i}) + (j:ι→ℕ) (W:ℝ→ℂ) (X:ℝ) : ℂ := by + letI (i:ι):Fintype (Eis⧸Ideal.span {p i}):=Fintype.ofFinite _ + exact ∑v:∀i,(Eis⧸Ideal.span {p i})ˣ,fourierWeight hp hg j v* + (D.datum hN hr hbase s hp hc0 v).smoothedKernel W X + +noncomputable def reflectedValue (D:ControlledStratumArithmetic p N a0 c0 mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (s:FixedCuspShape (fixedCusp a0 c0 mode)) + (hp:∀i,p i≠0) (hc0:c0≠0) (hg:∀i,lambda∉Ideal.span {p i}) + (j:ι→ℕ) (W:ℝ→ℂ) (X:ℝ) : ℂ := + fixedRadialCoefficientScalar*s.stratumShapeFactor (c0*∏i,p i)* + ∑'t:ThetaFullIndex, + (s.amplitude t.1 t.2.1 t.2.2.1.val t.2.2.2.val / + ((ramifiedScale 1 completedRamifiedStep t.2.1* + Real.sqrt (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ):ℝ):ℂ))* + CubicReflectionKernel.paperKernel (Vstar W) + ((X/(27*(sourceCuspScale s.index)^2*(Ideal.absNorm (Ideal.span {c0*∏i,p i}):ℝ)^2))* + (ramifiedScale 1 completedRamifiedStep t.2.1)^3* + (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ)^3)* + ((star D.fixedFactor*A4BadPhase c0 hc0 (D.matrix (fun _=>1) 1 1) D.U + (sourceCuspPhaseNumerator s.index (s.upper 0 0) (thetaFullFrequency t)))* + D.bracketProduct hp hg j + (sourceCuspPhaseNumerator s.index (s.upper 0 0) (thetaFullFrequency t))) + +theorem smoothed_eq_reflected (D:ControlledStratumArithmetic p N a0 c0 mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hN:(9:Eis)*c0∣N) (hr:lambda^2∣(∏i,p i)-1) + (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (s:FixedCuspShape (fixedCusp a0 c0 mode)) + (hp:∀i,p i≠0) (hc0:c0≠0) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hg:∀i,lambda∉Ideal.span {p i}) (hchar:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (j:ι→ℕ) (hj:∀i,j i<6) + (W:ℝ→ℂ) (lo hi:ℝ) (hlo:0hp i)) + have hC:∀v,((D.sourceGamma hN hr hbase v:SL(2,Eis))*fixedCusp a0 c0 mode) 1 0=c0*∏i,p i := by + intro v + rw [D.sourceGamma_mul,D.denominator] + have he:=s.sum_smoothedKernel_integral_phase (D.sourceGamma hN hr hbase) _ hc hC + (fourierWeight hp hg j) W lo hi hlo hsupp hW X hX + change D.smoothedValue hN hr hbase s hp hc0 hg j W X=_ at he + rw [he] + unfold reflectedValue + apply congrArg (fun z:ℂ=>fixedRadialCoefficientScalar*s.stratumShapeFactor (c0*∏i,p i)*z) + apply tsum_congr + intro t + apply congrArg (fun z:ℂ=> + (s.amplitude t.1 t.2.1 t.2.2.1.val t.2.2.2.val / + ((ramifiedScale 1 completedRamifiedStep t.2.1* + Real.sqrt (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ):ℝ):ℂ))* + CubicReflectionKernel.paperKernel (Vstar W) + ((X/(27*(sourceCuspScale s.index)^2*(Ideal.absNorm (Ideal.span {c0*∏i,p i}):ℝ)^2))* + (ramifiedScale 1 completedRamifiedStep t.2.1)^3* + (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ)^3)*z) + simpa only [multiplierSum,D.sourceGamma_character,D.sourceGamma_mul,map_mul] using + D.multiplierSum_eq hN hr hbase hp hc0 hcop hg hchar j hj + (sourceCuspPhaseNumerator s.index (s.upper 0 0) (thetaFullFrequency t)) + +end ControlledStratumArithmetic + +theorem exists_constructed_stratum_reflection {ι:Type*} [Fintype ι] + (p:ι→Eis) [∀i,(Ideal.span {p i}).IsMaximal] (hp:∀i,p i≠0) + (hcop:Pairwise (Function.onFun IsCoprime (fun i=>Ideal.span {p i}))) + (hprimary:∀i,lambda^2∣p i-1) + (hg:∀i,lambda∉Ideal.span {p i}) (hchar:∀i,ringChar (Eis⧸Ideal.span {p i})≠2) + (N a0 c0:Eis) (hc0:c0≠0) (hN:(9:Eis)*c0∣N) + (mode:Bool) (hbase:if mode then lambda^2∣a0-1 else lambda^2∣c0-1) + (hac:IsCoprime a0 c0) (hNp:∀i,IsCoprime N (p i)) : + ∃s:FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode), + ∃D:ControlledStratumArithmetic p N a0 c0 mode, + ∀j:ι→ℕ,(∀i,j i<6)→∀(W:ℝ→ℂ)(lo hi:ℝ),0hprimary i)) + hbase s hp hc0 hg j W X=D.reflectedValue s hp hc0 hg j W X := by + obtain ⟨s⟩:=exists_fixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode) + obtain ⟨D⟩:=exists_controlledStratumArithmetic p hp hcop hprimary N a0 c0 hc0 hN mode hbase hac hNp + refine ⟨s,D,?_⟩ + intro j hj W lo hi hlo hsupp hW X hX + exact D.smoothed_eq_reflected hN _ hbase s hp hc0 hcop hg hchar j hj W lo hi hlo hsupp hW X hX + +end + +section +open scoped Classical BigOperators MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss ShortDraftCusp +local notation "Eis" => ActualEisensteinCubic.O + +structure FixedFourierGeometry (c:Eis) (h:Eis⧸Ideal.span {c}) where + a0 : Eis + c0 : Eis + denominator_ne_zero : c0≠0 + denominator_dvd : c0∣c + coprime : IsCoprime a0 c0 + point : eisEmbedding a0/eisEmbedding c0=thetaFourierTranslation c h + mode : Bool + primary : if mode then lambda^2∣a0-1 else lambda^2∣c0-1 + shape : FixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 mode) + +lemma exists_fixedFourierGeometry (c:Eis) (hc:c≠0) (h:Eis⧸Ideal.span {c}) : + Nonempty (FixedFourierGeometry c h) := by + obtain ⟨a0,c0,hc0,hdiv,hcop,hpoint,ha,hcp⟩:= + ShortDraftCRT.exists_normalized_rational_cusp (-3*Quotient.out h) c hc + have hp:eisEmbedding a0/eisEmbedding c0=thetaFourierTranslation c h := by + rw [hpoint,thetaFourierTranslation,TraceLambdaPhase.eisLam_sq] + simp only [map_mul,map_neg,map_ofNat] + by_cases hl:lambda∣c0 + · obtain ⟨s⟩:=exists_fixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 true) + exact ⟨⟨a0,c0,hc0,hdiv,hcop,hp,true,ha hl,s⟩⟩ + · obtain ⟨s⟩:=exists_fixedCuspShape (ControlledStratumArithmetic.fixedCusp a0 c0 false) + exact ⟨⟨a0,c0,hc0,hdiv,hcop,hp,false,hcp hl,s⟩⟩ + +def fixedFourierGeometry (c:Eis) (hc:c≠0) (h:Eis⧸Ideal.span {c}) : + FixedFourierGeometry c h := Classical.choice (exists_fixedFourierGeometry c hc h) + +namespace FixedFourierGeometry +variable {c:Eis} {h:Eis⧸Ideal.span {c}} (G:FixedFourierGeometry c h) + +abbrev PhaseResidue := Eis⧸Ideal.span {ramifiedTraceLambda^3*G.c0} + +instance phaseResidue_finite : Finite G.PhaseResidue := + finite_quotient_span (A4_bad_modulus_ne_zero G.c0 G.denominator_ne_zero) + +def levelScale : ℝ := fixedCuspLevelScale G.shape.index G.c0 + +lemma levelScale_pos : 0 ActualEisensteinCubic.O + +theorem completedT_of_finite_cusp_profiles + (Ψ:Eis→*ℂ) (hΨ:∀x,‖Ψ x‖≤1) + (Q:Ideal Eis) (hperiod:CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) + {ι:Type*} [Fintype ι] (d:ι→SourceCuspDatum) (w:ι→ℂ) + (hFG:∀v:ℝ,0 + cuspBarProfile cubicSourceConjugateFunction (d h).point + have hG (h:ι) : ∀s:ℂ,MellinConvergent (G h) s:= + (d h).cuspBarProfile_mellin_entire.1 + have hF:=completedBesselProfile_mellin_entire_of_periodic Ψ Q hperiod c hc hcQ + have hVs:=Vstar_support W v0 v1 hWs + have hV:=Vstar_contDiff W v0 v1 hv0 hWs hW + let J:ι→ℝ→ℂ:=fun h t=> + besselSmoothingIntegrand (G h) thetaBesselScale (Vstar W) X ((-1:ℂ)+t*Complex.I) + have hi (h:ι) : Integrable (J h):= + besselSmoothingIntegrand_reflected_integrable (G h) sourceCuspRadialLength + sourceCuspRadialLength_pos (sourceCuspRadialCoefficient (d h).index (d h).dualPoint) + thetaBesselScale (sourceCuspRadialScale (d h).index) (d h).heightScale + thetaBesselScale_pos (sourceCuspRadialScale_pos _) (d h).heightScale_pos + (d h).multiplier (d h).reflection_radial + (sourceCuspRadialCoefficient_weighted_summable _ _) (Vstar W) v0 v1 hv0 hVs hV X hX + have hireal (h:ι) : Integrable (fun t:ℝ=> + besselSmoothingIntegrand (G h) thetaBesselScale (Vstar W) X (((-1:ℝ):ℂ)+t*Complex.I)):=by + simpa only [Complex.ofReal_neg,Complex.ofReal_one,J] using hi h + have hleft:=besselSmoothingIntegrand_finite_integrable + (completedBesselProfile Ψ thetaBesselScale) G w hFG thetaBesselScale (Vstar W) X (-1) + (fun h t=>hG h _) hireal + have hshift:=completedT_mellin_shift Ψ hΨ thetaBesselScale thetaBesselScale_pos hF.1 hF.2 + W v0 v1 hv0 hWs hW X hX (-1) (by norm_num) hleft + have hline (h:ι) : (1/(2*Real.pi):ℂ)*(∫t:ℝ,J h t)=(d h).smoothedKernel W X:=by + exact besselSmoothingIntegral_reflected_kernel (G h) sourceCuspRadialLength + sourceCuspRadialLength_pos (sourceCuspRadialCoefficient (d h).index (d h).dualPoint) + thetaBesselScale (sourceCuspRadialScale (d h).index) (d h).heightScale + thetaBesselScale_pos (sourceCuspRadialScale_pos _) (d h).heightScale_pos + (d h).multiplier (d h).reflection_radial + (sourceCuspRadialCoefficient_weighted_summable _ _) (Vstar W) v0 v1 hv0 hVs hV X hX + calc + _=(1/(2*Real.pi):ℂ)*∫t:ℝ, + besselSmoothingIntegrand (completedBesselProfile Ψ thetaBesselScale) + thetaBesselScale (Vstar W) X ((-1:ℂ)+t*Complex.I):=by + simpa only [Complex.ofReal_neg,Complex.ofReal_one] using hshift + _=(1/(2*Real.pi):ℂ)*∫t:ℝ,∑h,w h*J h t:=by + congr 1 + apply integral_congr_ae + filter_upwards with t + exact besselSmoothingIntegrand_finite_sum + (completedBesselProfile Ψ thetaBesselScale) G w hFG thetaBesselScale (Vstar W) X _ + (fun h=>hG h _) + _=∑h,w h*((1/(2*Real.pi):ℂ)*∫t:ℝ,J h t):=by + rw [integral_finsetSum Finset.univ (fun h _=>(hi h).const_mul (w h)),Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + rw [integral_const_mul] + ring + _=∑h,w h*(d h).smoothedKernel W X:=by simp_rw [hline] + +end CubicEisenstein + +open scoped BigOperators Classical + +namespace CanonicalRowCompletion + +section +open ActualEisensteinCubic CompletedGauss +open CubicEisenstein hiding summand +local notation "Eis" => ActualEisensteinCubic.O + +def fixedRowFourierPhase (c:Eis) (hc:c≠0) (h:Eis⧸Ideal.span {c}) (n:Eis) : ℂ := + quotientTrace c hc (h*Ideal.Quotient.mk _ n) + +def fixedRowFourierCoeff (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ:Eis→*ℂ) (h:Eis⧸Ideal.span {c}) : ℂ := + finiteAdditiveFourierCoeff (quotientTrace c hc) (fixedQuotientValue (Ideal.span {c}) φ) h + +lemma fixedRowFourierCoeff_norm (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ:Eis→*ℂ) (hφ:∀n,‖φ n‖≤1) (h:Eis⧸Ideal.span {c}) : + ‖fixedRowFourierCoeff c hc φ h‖≤1 := + finiteAdditiveFourierCoeff_norm _ _ (fixedQuotientValue_norm _ φ hφ) h + +lemma fixedRowFourierCoeff_mass (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ:Eis→*ℂ) (hφ:∀n,‖φ n‖≤1) : + (∑h:Eis⧸Ideal.span {c},‖fixedRowFourierCoeff c hc φ h‖)≤ + (Fintype.card (Eis⧸Ideal.span {c}):ℝ) := by + calc + _≤∑_h:Eis⧸Ideal.span {c},(1:ℝ):= + Finset.sum_le_sum (fun h _=>fixedRowFourierCoeff_norm c hc φ hφ h) + _=_:=by simp + +lemma fixedRowFourierPhase_norm (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] (h:Eis⧸Ideal.span {c}) (n:Eis) : + ‖fixedRowFourierPhase c hc h n‖=1 := AddChar.norm_apply _ _ + +lemma fixedRowFourierPhase_translation (c:Eis) (hc:c≠0) (h:Eis⧸Ideal.span {c}) (n:Eis) : + fixedRowFourierPhase c hc h n= + ShortDraftTrace.breveE (-cuspFrequency n*thetaFourierTranslation c h) := + (thetaFourierTranslation_phase c hc h n).symm + +lemma fixedRowFourier_inversion (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ:Eis→*ℂ) (hφ:CanonicalCoefficientClass.FactorsModulo (Ideal.span {c}) φ) (n:Eis) : + (∑h:Eis⧸Ideal.span {c},fixedRowFourierCoeff c hc φ h*fixedRowFourierPhase c hc h n)=φ n := by + rw [show (∑h:Eis⧸Ideal.span {c},fixedRowFourierCoeff c hc φ h*fixedRowFourierPhase c hc h n)= + fixedQuotientValue (Ideal.span {c}) φ (Ideal.Quotient.mk _ n) from + finiteAdditiveFourier_inversion (quotientTrace c hc) + (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive c hc) + (fixedQuotientValue (Ideal.span {c}) φ) _] + exact fixedQuotientValue_mk _ φ hφ n + +lemma summand_mul_fixed_twist (φ χ:Eis→*ℂ) (W:ℝ→ℂ) (X:ℝ) (I J:Ideal Eis) : + summand (φ*χ) W X I J= + φ (primaryGenerator I*(primaryGenerator J)^3)*summand χ W X I J := by + have he (η:Eis→*ℂ) : cubeWeight η J= + star (FiniteGaussPhase.angularFactor (primaryGenerator J))^3* + η (primaryGenerator J)^3/(Ideal.absNorm J:ℂ):=rfl + rw [summand,summand,he,he] + simp only [columnWeight,MonoidHom.mul_apply,map_mul,map_pow,mul_pow] + ring + +def completedFixedFrequency (χ:Eis→*ℂ) (c:Eis) (hc:c≠0) + (h:Eis⧸Ideal.span {c}) (W:ℝ→ℂ) (X:ℝ) : ℂ := + ∑'p:Ideal Eis×Ideal Eis,summand χ W X p.1 p.2* + fixedRowFourierPhase c hc h (primaryGenerator p.1*(primaryGenerator p.2)^3) + +lemma completedFixedFrequency_summable (χ:Eis→*ℂ) (c:Eis) (hc:c≠0) + (h:Eis⧸Ideal.span {c}) (W:ℝ→ℂ) (hW:HasCompactSupport W) (X:ℝ) (hX:0summand χ W X p.1 p.2* + fixedRowFourierPhase c hc h (primaryGenerator p.1*(primaryGenerator p.2)^3)) := by + apply summable_of_hasFiniteSupport + apply (completedT_finite_support χ W hW X hX).subset + intro p hp + exact left_ne_zero_of_mul hp + +theorem completedT_fixed_fourier (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ χ:Eis→*ℂ) (hφ:CanonicalCoefficientClass.FactorsModulo (Ideal.span {c}) φ) + (W:ℝ→ℂ) (hW:HasCompactSupport W) (X:ℝ) (hX:0(completedFixedFrequency_summable χ c hc h W hW X hX).mul_left _) + _=_:=by simp only [tsum_mul_left,completedFixedFrequency] + +end + +open ActualEisensteinCubic CompletedGauss CanonicalQuadraticSieve +open CubicEisenstein hiding summand +local notation "Eis" => ActualEisensteinCubic.O + +theorem actual_completedT_fixed_fourier (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (Ψ:Eis→*ℂ) (Q:Ideal Eis) (hQ:Q≠0) + (hcQ:Ideal.span {c}≤Q*Ideal.span {(72:Eis)}) + (hΨ:CanonicalCoefficientClass.FactorsModulo Q Ψ) (hΨnorm:∀n,‖Ψ n‖≤1) + (m f z:Eis) (hm:m≠0) (hf:f≠0) (hz:z≠0) (hmLam:lambda∣m) (hm2:(2:Eis)∣m) : + ∃(I:Ideal Eis)(hI:Supported I)(φ:Eis→*ℂ), + CanonicalCoefficientClass.FactorsModulo (Q*Ideal.span {(72:Eis)}) φ ∧ + (∀n,‖φ n‖≤1) ∧ + IsCoprime (Q*Ideal.span {(72:Eis)}) + (∏P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)}),P.val.val) ∧ + (∀h:Eis⧸Ideal.span {c},‖fixedRowFourierCoeff c hc φ h‖≤1) ∧ + (∀(W:ℝ→ℂ),HasCompactSupport W→∀X:ℝ,0hφ x y (hcQ hxy)) W hW X hX + +end CanonicalRowCompletion + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedThetaTwists.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedThetaTwists.lean new file mode 100644 index 0000000000000000000000000000000000000000..66ca148c038898d0327583fcc9cc4edbf574052b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FixedThetaTwists.lean @@ -0,0 +1,589 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.FixedFrequencyExpansion + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical + +namespace CubicEisenstein +open ActualEisensteinCubic CompletedGauss CanonicalRowCompletion +local notation "Eis" => ActualEisensteinCubic.O + +lemma fixedThetaTwist_mul (φ χ:Eis→*ℂ) (n:Eis) : + fixedThetaTwist (φ*χ) n=fixedThetaTwist φ n*χ n := by + by_cases hn:lambda^2∣n-1 + · rw [fixedThetaTwist_primary _ n hn,fixedThetaTwist_primary _ n hn,MonoidHom.mul_apply] + ring + · rw [fixedThetaTwist_not_primary _ n hn,fixedThetaTwist_not_primary _ n hn,zero_mul] + +def fixedThetaRowCoeff (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ:Eis→*ℂ) (h:Eis⧸Ideal.span {c}) : ℂ := + finiteAdditiveFourierCoeff (quotientTrace c hc) (fixedThetaQuotient φ c) h + +lemma fixedThetaRowCoeff_norm (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (φ:Eis→*ℂ) (hφ:∀n,‖φ n‖≤1) (h:Eis⧸Ideal.span {c}) : + ‖fixedThetaRowCoeff c hc φ h‖≤1 := + finiteAdditiveFourierCoeff_norm _ _ (fixedThetaQuotient_norm_le_one φ hφ c) h + +theorem fixedThetaTwist_fixed_fourier (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (Q:Ideal Eis) (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) + (φ χ:Eis→*ℂ) (hφ:CanonicalCoefficientClass.FactorsModulo Q φ) (n:Eis) : + fixedThetaTwist (φ*χ) n= + ∑h:Eis⧸Ideal.span {c},fixedThetaRowCoeff c hc φ h*fixedRowFourierPhase c hc h n*χ n := by + rw [←Finset.sum_mul,fixedThetaTwist_mul] + congr 1 + have h:=finiteAdditiveFourier_inversion (quotientTrace c hc) + (GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive c hc) (fixedThetaQuotient φ c) + (Ideal.Quotient.mk _ n) + rw [fixedThetaQuotient_mk φ Q hφ c hcQ n] at h + exact h.symm + +theorem fixedThetaTwist_free_fourier (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (Q:Ideal Eis) (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) + (I:Ideal Eis) (hI:CanonicalQuadraticSieve.Supported I) + (φ:Eis→*ℂ) (hφ:CanonicalCoefficientClass.FactorsModulo Q φ) (n:Eis) : + fixedThetaTwist (φ*freePrimeRow I hI Q) n= + (∑h:Eis⧸Ideal.span {c},fixedThetaRowCoeff c hc φ h*fixedRowFourierPhase c hc h n)* + ActualEisensteinCubic.principalSexticRow (fun P:FreePrimeIndex I Q=>P.val.val) + (freePrimeIndex_pairwise_coprime I Q) + (fun P=>(supported_factors_good I hI P.val.val (Multiset.mem_toFinset.mp P.val.property)).2.1) + (fun P=>(UniqueFactorizationMonoid.normalizedFactors I).count P.val.val%6) + (ActualEisensteinCubic.finitePrimeModulus (fun P:FreePrimeIndex I Q=>P.val.val)) + (ActualEisensteinCubic.span_finitePrimeModulus _) (Ideal.Quotient.mk _ n) := by + rw [fixedThetaTwist_fixed_fourier c hc Q hcQ φ _ hφ n,←Finset.sum_mul, + freePrimeRow_eq_principalSexticRow I hI Q n] + +theorem actual_fixedTheta_fourier (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (Ψ:Eis→*ℂ) (Q:Ideal Eis) + (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*(Q*Ideal.span {(72:Eis)})) + (hΨ:CanonicalCoefficientClass.FactorsModulo Q Ψ) (hΨnorm:∀n,‖Ψ n‖≤1) + (m f z:Eis) (hm:m≠0) (hf:f≠0) (hz:z≠0) (hmLam:lambda∣m) (hm2:(2:Eis)∣m) : + ∃(I:Ideal Eis)(hI:CanonicalQuadraticSieve.Supported I)(φ:Eis→*ℂ), + CanonicalCoefficientClass.FactorsModulo (Q*Ideal.span {(72:Eis)}) φ ∧ + (∀n,‖φ n‖≤1) ∧ + IsCoprime (Q*Ideal.span {(72:Eis)}) + (∏P:FreePrimeIndex I (Q*Ideal.span {(72:Eis)}),P.val.val) ∧ + (∀h:Eis⧸Ideal.span {c},‖fixedThetaRowCoeff c hc φ h‖≤1) ∧ + (∀n,fixedThetaTwist (rowTwist Ψ m f z) n= + ∑h:Eis⧸Ideal.span {c},fixedThetaRowCoeff c hc φ h*fixedRowFourierPhase c hc h n* + freePrimeRow I hI (Q*Ideal.span {(72:Eis)}) n) := by + obtain ⟨I,hI,φ,hφ,hφn,hcop,hrow⟩:=exists_actual_coprime_row Ψ Q hΨ hΨnorm m f z hm hf hz hmLam hm2 + refine ⟨I,hI,φ,hφ,hφn,hcop,fixedThetaRowCoeff_norm c hc φ hφn,?_⟩ + have he:fixedThetaTwist (rowTwist Ψ m f z)= + fixedThetaTwist (φ*freePrimeRow I hI (Q*Ideal.span {(72:Eis)})):= + fixedThetaTwist_congr_primary _ _ hrow + intro n + rw [he] + exact fixedThetaTwist_fixed_fourier c hc _ hcQ φ _ hφ n + +end CubicEisenstein + +namespace CompletedGauss + +section +open ActualEisensteinCubic CanonicalQuadraticSieve ConcretePrimeRowBridge +open UniqueFactorizationMonoid LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O + +lemma admissiblePrimeGood (K:Ideal Eis) (hK:Admissible K) (P:PrimeIndex K) : lambda∉P.val := + (hK.2.2 P.val (Multiset.mem_toFinset.mp P.property)).1 + +theorem quadraticRow_eq_primeIndex (K:Ideal Eis) (hK:Admissible K) (x:Eis) : + quadraticRow K x=finiteSexticRow (fun P:PrimeIndex K=>P.val) + (admissiblePrimeGood K hK) (fun _=>3) x := by + have hs:∀I∈({K}:Finset (Ideal Eis)),Admissible I:=by + intro I hI + simpa only [Finset.mem_singleton.mp hI] using hK + have heq:primePool ({K}:Finset (Ideal Eis))=primeSupport K:=by + simp [primePool,primeSupport] + let e:primePool ({K}:Finset (Ideal Eis))≃PrimeIndex K:={ + toFun:=fun P=>⟨P.val,heq ▸ P.property⟩ + invFun:=fun P=>⟨P.val,heq.symm ▸ P.property⟩ + left_inv:=fun _=>rfl + right_inv:=fun _=>rfl } + rw [quadraticRow_eq_pool {K} hs K (Finset.mem_singleton_self K) x, + idealSupport_singleton_univ] + simp only [QuadraticInitialBound.quadraticRow,finiteSquarefreeRow,Finset.prod_pow, + finiteSexticRow,MulChar.pow_apply' _ (by decide : (3:ℕ)≠0)] + congr 1 + exact Fintype.prod_equiv e _ _ (fun P=>rfl) + +theorem completedLocalExponent_residual (I F Q:Ideal Eis) (hFQ:F∣Q) + (P:PrimeIndex (rowResidualPart I Q)) : completedLocalExponent I F P.val=1 := by + have h:=rowResidualPart_prime_exponent I Q P.val (Multiset.mem_toFinset.mp P.property) + have hnot:¬P.val∣F:=fun hd=>h.2.2 (hd.trans hFQ) + simp only [completedLocalExponent,h.2.1,ite_eq_right hnot,mul_zero,add_zero,Nat.reduceMod] + +theorem residual_bracket_eq_quadraticRow (I F Q:Ideal Eis) (hFQ:F∣Q) + (hbad:∀P∈fixedBadPrimes,P∣Q) (x:Eis) : + (∏P:PrimeIndex (rowResidualPart I Q), + bracket (actualSextic P.val + (admissiblePrimeGood _ (rowResidualPart_admissible I Q hbad) P)) + (completedLocalExponent I F P.val) (Ideal.Quotient.mk P.val x))= + quadraticRow (rowResidualPart I Q) x := by + simp_rw [completedLocalExponent_residual I F Q hFQ,bracket_one_eq_quadratic] + rw [quadraticRow_eq_primeIndex _ (rowResidualPart_admissible I Q hbad)] + simp only [finiteSexticRow,MulChar.pow_apply' _ (by decide : (3:ℕ)≠0)] + +def residualQuadraticPhase (K:Ideal Eis) (u:Eisˣ) (m:ℕ) (D E:Ideal Eis) : ℂ := + quadraticRow K ((u.val*lambda^m)*primaryGenerator (D*E)) + +lemma residualQuadraticPhase_norm_le_one (K:Ideal Eis) (u:Eisˣ) (m:ℕ) (D E:Ideal Eis) : + ‖residualQuadraticPhase K u m D E‖≤1 := quadraticRow_norm_le_one _ _ + +theorem residual_bracket_extracted_columns (I F Q:Ideal Eis) (hFQ:F∣Q) + (hbad:∀P∈fixedBadPrimes,P∣Q) (u:Eisˣ) (m:ℕ) (D E n b:Ideal Eis) : + (∏P:PrimeIndex (rowResidualPart I Q), + bracket (actualSextic P.val + (admissiblePrimeGood _ (rowResidualPart_admissible I Q hbad) P)) + (completedLocalExponent I F P.val) + (Ideal.Quotient.mk P.val + ((u.val*lambda^m)*primaryGenerator (D*n)*(primaryGenerator (E*b))^3)))= + residualQuadraticPhase (rowResidualPart I Q) u m D E * + quadraticRow (rowResidualPart I Q) (primaryGenerator (n*b)) := by + simp_rw [completedLocalExponent_residual I F Q hFQ] + rw [residual_bracket_product] + rw [←quadraticRow_eq_primeIndex _ (rowResidualPart_admissible I Q hbad), + ←quadraticRow_eq_primeIndex _ (rowResidualPart_admissible I Q hbad)] + simp only [primaryGenerator_mul,residualQuadraticPhase, + canonical_quadraticRow_argument_mul _ (rowResidualPart_admissible I Q hbad)] + ring + +end + +section +open ActualEisensteinCubic CanonicalQuadraticSieve +local notation "Eis" => ActualEisensteinCubic.O + +def actualResidualModelRow (K:ℝ) (I Q:Ideal Eis) (hI:I≠0) + (hbad:∀P∈fixedBadPrimes,P∣Q) (hIK:(Ideal.absNorm I:ℝ)≤K) : + idealRange (completedResidualScale K I Q) := by + refine ⟨rowResidualPart I Q,mem_idealRange.mpr ⟨rowResidualPart_admissible I Q hbad,?_⟩⟩ + rw [rowResidualPart_norm I Q hI,completedResidualScale] + exact div_le_div_of_nonneg_right hIK (by positivity) + +lemma actualResidualModelRow_val (K:ℝ) (I Q:Ideal Eis) (hI:I≠0) + (hbad:∀P∈fixedBadPrimes,P∣Q) (hIK:(Ideal.absNorm I:ℝ)≤K) : + (actualResidualModelRow K I Q hI hbad hIK).val=rowResidualPart I Q := rfl + +lemma actualResidualModelRow_shell (K:ℝ) (I Q:Ideal Eis) (hI:I≠0) + (hbad:∀P∈fixedBadPrimes,P∣Q) (hIK:(Ideal.absNorm I:ℝ)≤K) + (hlo:K/2≤(Ideal.absNorm I:ℝ)) : + completedResidualScale K I Q/2≤(Ideal.absNorm (actualResidualModelRow K I Q hI hbad hIK).val:ℝ) := by + change completedResidualScale K I Q/2≤(Ideal.absNorm (rowResidualPart I Q):ℝ) + rw [rowResidualPart_norm I Q hI,completedResidualScale] + have h:=div_le_div_of_nonneg_right hlo + (show 0≤(Ideal.absNorm (rowPowerfulPart I):ℝ)*(Ideal.absNorm (rowMaskPart I Q):ℝ) by positivity) + convert h using 1 ; ring + +theorem completedBranchScale_raw_argument {ι:Type*} [Fintype ι] + (K X c r:ℝ) (I F Q:Ideal Eis) (P:ι→Ideal Eis) [∀i,(P i).IsMaximal] + (e:ι→Fin 3) (k n b:Ideal Eis) (hK:0completedLocalExponent I F (P i)) e 1*n):ℝ)* + (Ideal.absNorm (reflectionExtractedDivisor P (fun i=>completedLocalExponent I F (P i)) e 2*b):ℝ)^3/ + (c*(Ideal.absNorm k:ℝ)^2*(Ideal.absNorm (∏i,P i):ℝ)^2) := by + have hkN:(Ideal.absNorm k:ℝ)≠0:=by + exact_mod_cast (Ideal.absNorm_eq_zero_iff.not.mpr hk) + have hpN:(Ideal.absNorm (∏i,P i):ℝ)≠0:=by + exact_mod_cast (Ideal.absNorm_eq_zero_iff.not.mpr + (Finset.prod_ne_zero_iff.mpr (fun i _=>NeZero.ne (P i)))) + simp only [completedBranchScale,inv_div,map_mul,Nat.cast_mul] + field_simp [hK.ne',hc.ne',hkN,hpN] + +end + +open ActualEisensteinCubic CanonicalQuadraticSieve CompletedDyadic LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O + +def residualModelRowPhase {K:ℝ} (rowPhase:ℕ→idealRange K→ℂ) + (u:Eisˣ) (D E:Ideal Eis) (m:ℕ) (k:idealRange K) : ℂ := + rowPhase m k*residualQuadraticPhase k.val u m D E + +lemma residualModelRowPhase_norm_le_one {K:ℝ} (rowPhase:ℕ→idealRange K→ℂ) + (hphase:∀m k,‖rowPhase m k‖≤1) (u:Eisˣ) (D E:Ideal Eis) (m:ℕ) (k:idealRange K) : + ‖residualModelRowPhase rowPhase u D E m k‖≤1 := by + rw [residualModelRowPhase,norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) + (hphase m k)).trans (residualQuadraticPhase_norm_le_one k.val u m D E) + +theorem residual_coefficient_eq_canonical {ι:Type*} [Fintype ι] + (I F Q:Ideal Eis) (hFQ:F∣Q) (hbad:∀P∈fixedBadPrimes,P∣Q) + (P:ι→Ideal Eis) [∀i,(P i).IsMaximal] (hg:∀i,lambda∉P i) + (j:ι→ℕ) (e:ι→Fin 3) (ρ q:ℝ) (u:Eisˣ) + (η:ℕ→Ideal Eis→Ideal Eis→ℂ) (rowPhase:ℕ→ℂ) (m:ℕ) (n b:Ideal Eis) : + let D:=reflectionExtractedDivisor P j e 1 + let E:=reflectionExtractedDivisor P j e 2 + (rowPhase m*(∏p:PrimeIndex (rowResidualPart I Q), + bracket (actualSextic p.val (admissiblePrimeGood _ (rowResidualPart_admissible I Q hbad) p)) + (completedLocalExponent I F p.val) + (Ideal.Quotient.mk p.val ((u.val*lambda^m)*primaryGenerator (D*n)*(primaryGenerator (E*b))^3))) * + η m (D*n) (E*b)*reflectedBranch P hg j e (primaryGenerator (D*n)) (primaryGenerator (E*b)))/ + ((ramifiedScale ρ q m*Real.sqrt (Ideal.absNorm (D*n):ℝ)*(Ideal.absNorm (E*b):ℝ):ℝ):ℂ)= + 4*canonicalRawBranchCoefficient P hg j e ρ q + (fun l a c=>η l (D*a) (E*c)) + (fun l=>rowPhase l*residualQuadraticPhase (rowResidualPart I Q) u l D E) + (rowResidualPart I Q) m n b := by + dsimp only + rw [residual_bracket_extracted_columns I F Q hFQ hbad] + unfold canonicalRawBranchCoefficient reflectedDyadicCoefficient + push_cast + simp only [div_eq_mul_inv,mul_inv_rev] + norm_num + ring + +end CompletedGauss + +open scoped Classical BigOperators ContDiff + +namespace CompletedGauss.FreeReflection + +section +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve CompletedDyadic LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O + +def pool (I Q Q0:Ideal Eis) : Finset (Ideal Eis) := + (completedReflectionPool I Q).filter (fun P=>¬Q0≤P) + +lemma pool_subset (I Q Q0:Ideal Eis) : pool I Q Q0⊆completedReflectionPool I Q := + Finset.filter_subset _ _ +lemma pool_maximal (I Q Q0:Ideal Eis) (P:pool I Q Q0) : P.val.IsMaximal := + completedReflectionPool_maximal I Q ⟨P.val,pool_subset I Q Q0 P.property⟩ +lemma pool_good (I Q Q0:Ideal Eis) (P:pool I Q Q0) : lambda∉P.val := + completedReflectionPool_good I Q ⟨P.val,pool_subset I Q Q0 P.property⟩ +lemma pool_odd (I Q Q0:Ideal Eis) (P:pool I Q Q0) : ringChar (Eis⧸P.val)≠2 := + completedReflectionPool_odd I Q ⟨P.val,pool_subset I Q Q0 P.property⟩ +lemma pool_divides (I Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) (P:pool I Q Q0) : P.val∣I*Q := + completedReflectionPool_divides I Q hI hQ ⟨P.val,pool_subset I Q Q0 P.property⟩ +lemma pool_nonresidual (I Q Q0:Ideal Eis) (P:pool I Q Q0) : ¬P.val∣rowResidualPart I Q := + completedReflectionPool_nonresidual I Q ⟨P.val,pool_subset I Q Q0 P.property⟩ +lemma pool_free (I Q Q0:Ideal Eis) (P:pool I Q Q0) : ¬Q0≤P.val := + (Finset.mem_filter.mp P.property).2 + +lemma pool_eq_on_fiber (I J Q Q0:Ideal Eis) (hI:I≠0) (hJ:J≠0) (hQ:Q≠0) + (hA:rowPowerfulPart I=rowPowerfulPart J) (hT:rowMaskPart I Q=rowMaskPart J Q) : + pool I Q Q0=pool J Q Q0 := by + unfold pool + rw [completedReflectionPool_eq_on_fiber I J Q hI hJ hQ hA hT] + +end + +section +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve CompletedDyadic +local notation "Eis" => ActualEisensteinCubic.O + +def reflectionChoiceValue (I Q Q0:Ideal Eis) (e:pool I Q Q0→Fin 6) + (P:Ideal Eis) : Fin 6 := + if h:P∈pool I Q Q0 then e ⟨P,h⟩ else 0 + +def reflectionActivePool (I Q Q0:Ideal Eis) (e:pool I Q Q0→Fin 6) : Finset (Ideal Eis) := + (pool I Q Q0).filter (fun P=>reflectionSixActive (reflectionChoiceValue I Q Q0 e P)) + +lemma reflectionActivePool_subset (I Q Q0:Ideal Eis) (e:pool I Q Q0→Fin 6) : + reflectionActivePool I Q Q0 e⊆pool I Q Q0 := Finset.filter_subset _ _ + +lemma mem_reflectionActivePool (I Q Q0:Ideal Eis) (e:pool I Q Q0→Fin 6) + (P:pool I Q Q0) : + P.val∈reflectionActivePool I Q Q0 e ↔ reflectionSixActive (e P) := by + rw [reflectionActivePool, Finset.mem_filter] + simp only [P.property, true_and] + rw [reflectionChoiceValue, dite_eq_left P.property] + +lemma reflectionActivePool_encode (I Q Q0:Ideal Eis) + (A:Finset (pool I Q Q0)) (e:A→Fin 3) : + reflectionActivePool I Q Q0 (encodeReflectionSix ⟨A,e⟩)=A.image Subtype.val := by + ext P + constructor + · intro hP + let p:pool I Q Q0:=⟨P,reflectionActivePool_subset I Q Q0 _ hP⟩ + have hp:p∈A:=(reflectionSixActive_encode ⟨A,e⟩ p).mp + ((mem_reflectionActivePool I Q Q0 _ p).mp hP) + exact Finset.mem_image.mpr ⟨p,hp,rfl⟩ + · intro hP + obtain ⟨p,hp,rfl⟩:=Finset.mem_image.mp hP + exact (mem_reflectionActivePool I Q Q0 _ p).mpr ((reflectionSixActive_encode ⟨A,e⟩ p).mpr hp) + +def reflectionActiveLabel (I Q Q0:Ideal Eis) (e:pool I Q Q0→Fin 6) + (P:reflectionActivePool I Q Q0 e) : Fin 3 := + reflectionSixLabel (e ⟨P.val,reflectionActivePool_subset I Q Q0 e P.property⟩) + +def sixReflectedBranch (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) + (K levelBound levelScale:ℝ) (hlevel:0pool_maximal I Q Q0 ⟨P.val,reflectionActivePool_subset I Q Q0 e P.property⟩ + good:=fun P=>pool_good I Q Q0 ⟨P.val,reflectionActivePool_subset I Q Q0 e P.property⟩ + coprime:=by + intro P R hPR + let : P.val.IsMaximal:=pool_maximal I Q Q0 ⟨P.val,reflectionActivePool_subset I Q Q0 e P.property⟩ + let : R.val.IsMaximal:=pool_maximal I Q Q0 ⟨R.val,reflectionActivePool_subset I Q Q0 e R.property⟩ + exact Ideal.isCoprime_of_isMaximal (Subtype.val_injective.ne hPR) + divides:=fun P=>pool_divides I Q Q0 hI hQ ⟨P.val,reflectionActivePool_subset I Q Q0 e P.property⟩ + nonresidual:=fun P=>pool_nonresidual I Q Q0 ⟨P.val,reflectionActivePool_subset I Q Q0 e P.property⟩ + label:=reflectionActiveLabel I Q Q0 e + nColumns:=fun i=>dualIdealDyad i.2.2 + bColumns:=fun i=>dualIdealDyad i.2.1 + nBounds:=fun i n hn=>dualIdealDyad_bounds i.2.2 n hn + bBounds:=fun i b hb=>dualIdealDyad_bounds i.2.1 b hb + amplitude:=fun i=>amplitude i.1 + amplitude_bound:=fun i n _ b _=>hamp i.1 n b + rowPhase:=fun i=>rowPhase i.1 + rowPhase_bound:=fun i k=>hrow i.1 k + +end + +section +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve CompletedDyadic +local notation "Eis" => ActualEisensteinCubic.O + +def sixPhaseFixedCuspBranch (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) + (K levelBound levelScale:ℝ) (hlevel:0p.val) + (fun p=>completedLocalExponent I F p.val) d.label 1 + let E:=reflectionExtractedDivisor (fun p:d.primes=>p.val) + (fun p=>completedLocalExponent I F p.val) d.label 2 + d.amplitude i n b=phaseArray i.1 (D*n) (E*b)*fixedConjugateCuspArray cusp u i.1 (D*n) (E*b) := rfl + +lemma sixPhaseFixedCuspBranch_scale (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) + (K X levelBound levelScale:ℝ) (hlevel:0P.val) d.label= + completedBranchScale K (X/levelScale) I F Q + (fun P:reflectionActivePool I Q Q0 e=>P.val) (reflectionActiveLabel I Q Q0 e) := rfl + +end +section + +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O +local instance poolMaximal (I Q Q0:Ideal Eis) (P:pool I Q Q0) : P.val.IsMaximal := + pool_maximal I Q Q0 P +noncomputable local instance poolField (I Q Q0:Ideal Eis) (P:pool I Q Q0) : Field (Eis⧸P.val) := + Ideal.Quotient.field P.val +noncomputable local instance poolFintype (I Q Q0:Ideal Eis) (P:pool I Q Q0) : Fintype (Eis⧸P.val) := + Fintype.ofFinite _ + +def reflectionInactiveStratumWeight (I F Q Q0:Ideal Eis) (A:Finset (pool I Q Q0)) : ℂ := + ∏P∈(Finset.univ:Finset (pool I Q Q0))\A, + zeroFourierCoefficient (actualSextic P.val (pool_good I Q Q0 P)) + (completedLocalExponent I F P.val) + +lemma reflectionInactiveStratumWeight_norm_le_one (I F Q Q0:Ideal Eis) + (A:Finset (pool I Q Q0)) : ‖reflectionInactiveStratumWeight I F Q Q0 A‖≤1 := by + rw [reflectionInactiveStratumWeight,norm_prod] + apply Finset.prod_le_one₀ (fun _ _=>norm_nonneg _) + intro P _ + by_cases hj:completedLocalExponent I F P.val=0 + · rw [hj] + exact zeroFourierCoefficient_zero_norm_le_one _ + · have he:=canonical_zeroFourierCoefficient P.val (pool_good I Q Q0 P) + (pool_odd I Q Q0 P) (completedLocalExponent I F P.val) + (Nat.mod_lt _ (by decide : 0<6)) + have hz:zeroFourierCoefficient (actualSextic P.val (pool_good I Q Q0 P)) + (completedLocalExponent I F P.val)=0 := by + simpa only [actualSextic,ite_eq_right hj] using he + rw [hz] + simp + +def reflectionSixInactiveWeight (I F Q Q0:Ideal Eis) (e:pool I Q Q0→Fin 6) : ℂ := + if reflectionSixValid e then reflectionInactiveStratumWeight I F Q Q0 (reflectionSixSupport e) else 0 + +lemma reflectionSixInactiveWeight_norm_le_one (I F Q Q0:Ideal Eis) + (e:pool I Q Q0→Fin 6) : ‖reflectionSixInactiveWeight I F Q Q0 e‖≤1 := by + unfold reflectionSixInactiveWeight + split_ifs + · exact reflectionInactiveStratumWeight_norm_le_one I F Q Q0 _ + · simp + +lemma sum_reflectionSixInactiveWeight_unpad (I F Q Q0:Ideal Eis) + (G:(pool I Q Q0→Fin 6)→ℂ) : + (∑e:pool I Q Q0→Fin 6,reflectionSixInactiveWeight I F Q Q0 e*G e)= + ∑A:Finset (pool I Q Q0),∑e:A→Fin 3, + reflectionInactiveStratumWeight I F Q Q0 A*G (encodeReflectionSix ⟨A,e⟩) := by + rw [sum_active_exceptional_eq_six] + apply Finset.sum_congr rfl + intro e _ + by_cases he:reflectionSixValid e + · rw [ite_eq_left he,encode_decodeReflectionSix e he] + simp only [reflectionSixInactiveWeight,ite_eq_left he,decodeReflectionSix] + · simp only [ite_eq_right he,reflectionSixInactiveWeight,zero_mul] + +abbrev SixReflectionIndex (rays:ℕ) (I Q Q0:Ideal Eis) := + Fin rays×(pool I Q Q0→Fin 6) + +end + +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve LocalReflectionBrackets +local notation "Eis" => ActualEisensteinCubic.O + +def sixPhaseFixedCuspFiber (rays:ℕ) (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) + (K levelBound:ℝ) (levelScale:SixReflectionIndex rays I Q Q0→ℝ) + (hlevel:∀x,0sixPhaseFixedCuspBranch I F Q Q0 hI hQ K levelBound (levelScale x) (hlevel x) (hlevelBound x) + x.2 (cusp x) (unit x) (phaseArray x) (hphase x) (rowPhase x) (hrow x) + weight:=fun x=>rayWeight x*reflectionSixInactiveWeight I F Q Q0 x.2 + weight_bound:=by + intro x + rw [norm_mul] + exact (mul_le_of_le_one_left (norm_nonneg _) + (hray x)).trans (reflectionSixInactiveWeight_norm_le_one I F Q Q0 x.2) + +theorem sixPhaseFixedCuspFiber_value (rays:ℕ) (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) + (K levelBound:ℝ) (levelScale:SixReflectionIndex rays I Q Q0→ℝ) + (hlevel:∀x,0 f z*ShortDraftTrace.breveE (-freq*z)) := by + have hchar : Continuous (fun z : ℂ => ShortDraftTrace.breveE (-freq*z)) := by + change Continuous (fun z : ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + refine hf.norm.mono' (hf.aestronglyMeasurable.mul hchar.aestronglyMeasurable) ?_ + exact Eventually.of_forall fun z => by simp only [norm_mul,breveE_norm,mul_one,le_refl] + +lemma integrableOn_periodization (f : ℂ → ℂ) (hf : Integrable f) : + IntegrableOn (fun z => ∑' n : O,f (z+3*eisEmbedding n)) periodDomain := by + let : Countable O := latticeCoordEquiv.injective.countable + have hm (n : O) : AEStronglyMeasurable (fun z => f (z+3*eisEmbedding n)) + (volume.restrict periodDomain) := + (hf.comp_add_right (3*eisEmbedding n)).aestronglyMeasurable.restrict + refine ⟨AEStronglyMeasurable.tsum hm, ?_⟩ + change (∫⁻ z in periodDomain,‖∑' n : O,f (z+3*eisEmbedding n)‖ₑ)<⊤ + apply lt_of_le_of_lt (lintegral_mono fun z => enorm_tsum_le_tsum_enorm) _ + rw [lintegral_tsum (fun n => (hm n).enorm)] + exact lt_top_iff_ne_top.mpr (periodization_lintegral_norm_ne_top f hf) + +theorem integral_fourier_periodization (f : ℂ → ℂ) (hf : Integrable f) (h : O) : + (∫ z in periodDomain,(∑' n : O,f (z+3*eisEmbedding n))* + ShortDraftTrace.breveE (-cuspFrequency h*z))= + ∫ z : ℂ,f z*ShortDraftTrace.breveE (-cuspFrequency h*z) := by + have heq : (fun z : ℂ => (∑' n : O,f (z+3*eisEmbedding n))* + ShortDraftTrace.breveE (-cuspFrequency h*z)) = + (fun z : ℂ => ∑' n : O,f (z+3*eisEmbedding n)* + ShortDraftTrace.breveE (-cuspFrequency h*(z+3*eisEmbedding n))) := by + funext z + simp only [cuspFrequency_negative_period,tsum_mul_right] + rw [heq] + exact integral_periodization _ (trace_mul_integrable f hf (cuspFrequency h)) + +end + +section +open MeasureTheory Set Filter Module +open scoped BigOperators Classical ENNReal MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT + +lemma continuous_inverse_upper_operator (v : ℝ) (hv : 0 < v) : + Continuous (fun z : ℂ => rowOperator (upperSection z v hv)⁻¹) := by + apply continuous_clm_apply.mpr + intro u + apply continuous_pi + intro i + simp only [rowOperator_apply,upperSection, + Matrix.vecMul,dotProduct,Fin.sum_univ_two] + fin_cases i <;> simp only [] <;> fun_prop + +lemma continuous_upper_rowBound (v : ℝ) (hv : 0 < v) : + Continuous (fun z : ℂ => rowBound (upperSection z v hv)) := + continuous_const.mul (continuous_const.add (continuous_inverse_upper_operator v hv).norm) + +lemma norm_mem_periodDomain (z : ℂ) (hz : z ∈ periodDomain) : + ‖z‖ ≤ ∑ i : Fin 2, ‖periodBasis i‖ := by + have heq := (ZSpan.fract_eq_self (b := periodBasis)).mpr hz + simpa only [heq] using ZSpan.norm_fract_le periodBasis z + +lemma exists_upper_rowBound (v : ℝ) (hv : 0 < v) : + ∃ C : ℝ, 0 < C ∧ ∀ z ∈ periodDomain, rowBound (upperSection z v hv) ≤ C := by + let R : ℝ := ∑ i : Fin 2, ‖periodBasis i‖ + obtain ⟨C,hC⟩ := (isCompact_closedBall (0:ℂ) R).bddAbove_image + (continuous_upper_rowBound v hv).continuousOn + refine ⟨max 1 C,lt_of_lt_of_le (by norm_num) (le_max_left _ _),?_⟩ + intro z hz + apply (hC ?_).trans (le_max_right _ _) + exact ⟨z,by simpa only [Metric.mem_closedBall,dist_zero_right] using norm_mem_periodDomain z hz,rfl⟩ + +lemma continuous_upper_summand (v : ℝ) (hv : 0 < v) (s : ℂ) (x : CuspCosets) : + Continuous (fun z : ℂ => summand (upperSection z v hv) s x) := by + simp_rw [summand_upperSection] + apply continuous_const.mul + apply Continuous.cpow + · apply Complex.continuous_ofReal.comp + apply continuous_const.div + · unfold heightDenominator + fun_prop + · intro z + exact (heightDenominator_pos z v hv _ (embeddedRow_ne_zero x)).ne' + · exact continuous_const + · intro z + apply Complex.ofReal_mem_slitPlane.mpr + exact div_pos hv (heightDenominator_pos z v hv _ (embeddedRow_ne_zero x)) + +lemma upper_summable_majorant (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) : + ∃ M : CuspCosets → ℝ, Summable M ∧ (∀ x,0 ≤ M x) ∧ + ∀ z ∈ periodDomain, ∀ x, ‖summand (upperSection z v hv) s x‖ ≤ M x := by + obtain ⟨C,hC,hbound⟩ := exists_upper_rowBound v hv + refine ⟨fun x => C^(2*s.re)*‖rowCoordinates (cosetRow x)‖^(-(2*s.re)),?_,?_,?_⟩ + · have hsumm := summable_integer_four_rpow (2*s.re) (by linarith) + have hinj : Function.Injective (fun x : CuspCosets => rowCoordinates (cosetRow x)) := + rowCoordinates_injective.comp cosetRow_injective + exact (hsumm.comp_injective hinj).mul_left _ + · intro x + positivity + · intro z hz x + apply (norm_summand_bound (upperSection z v hv) s (by linarith) x).trans + exact mul_le_mul_of_nonneg_right + (Real.rpow_le_rpow (rowBound_pos _).le (hbound z hz) (by linarith)) (by positivity) + +lemma periodDomain_finiteMeasure : IsFiniteMeasure (volume.restrict periodDomain) := by + constructor + rw [Measure.restrict_apply_univ,periodDomain_volume] + exact ENNReal.ofReal_lt_top + +theorem hasSum_integral_upperEisenstein (v : ℝ) (hv : 0 < v) (s freq : ℂ) (hs : 2 < s.re) : + HasSum (fun x : CuspCosets => ∫ z in periodDomain, + summand (upperSection z v hv) s x*ShortDraftTrace.breveE (-freq*z)) + (∫ z in periodDomain,upperEisenstein z v hv s*ShortDraftTrace.breveE (-freq*z)) := by + let : Countable CuspCosets := + (rowCoordinates_injective.comp cosetRow_injective).countable + let := periodDomain_finiteMeasure + obtain ⟨M,hM,hMnonneg,hbound⟩ := upper_summable_majorant v hv s hs + have hchar : Continuous (fun z : ℂ => ShortDraftTrace.breveE (-freq*z)) := by + change Continuous (fun z : ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + have hsum := hasSum_integral_of_dominated_convergence + («μ» := volume.restrict periodDomain) + (fun (x : CuspCosets) (_ : ℂ) => M x) + (fun x => ((continuous_upper_summand v hv s x).mul hchar).aestronglyMeasurable.restrict) + (fun x => (ae_restrict_mem periodDomain_measurable).mono fun z hz => by + simpa only [Pi.mul_apply,norm_mul,breveE_norm,mul_one] using hbound z hz x) + (Eventually.of_forall fun _ => hM) + (integrable_const (∑' x,M x)) + (Eventually.of_forall fun z => (summable_summand (upperSection z v hv) s hs).hasSum.mul_right + (ShortDraftTrace.breveE (-freq*z))) + exact hsum + +theorem integral_upperEisenstein_eq_sum (v : ℝ) (hv : 0 < v) (s freq : ℂ) (hs : 2 < s.re) : + (∫ z in periodDomain,upperEisenstein z v hv s*ShortDraftTrace.breveE (-freq*z))= + ∑' x : CuspCosets,∫ z in periodDomain, + summand (upperSection z v hv) s x*ShortDraftTrace.breveE (-freq*z) := + (hasSum_integral_upperEisenstein v hv s freq hs).tsum_eq.symm + +end + +section +open MeasureTheory Set Filter +open scoped BigOperators Classical + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal + +def shiftedHeightKernel (v : ℝ) (s b z : ℂ) : ℂ := + (v:ℂ)^(-s)*hyperbolicKernel s ((z+b)/(v:ℂ)) + +lemma shiftedHeightKernel_integrable (v : ℝ) (hv : 0 < v) (s b : ℂ) (hs : 1 < s.re) : + Integrable (shiftedHeightKernel v s b) := by + have h := ((hyperbolicKernel_integrable s hs).comp_smul (inv_ne_zero hv.ne')).comp_add_right b + apply (h.const_mul ((v:ℂ)^(-s))).congr + exact Eventually.of_forall fun z => by + simp only [shiftedHeightKernel,Complex.real_smul,Complex.ofReal_inv,div_eq_mul_inv,mul_comm] + +lemma primitiveTerm_eq_shiftedHeightKernel (z : ℂ) (v : ℝ) (hv : 0 < v) + (s : ℂ) (c d : O) (hc : c ≠ 0) : + primitiveTerm z v s c d = + (eisEmbedding (symbol c d)*(‖eisEmbedding c‖^2:ℝ) ^ (-s:ℂ))* + shiftedHeightKernel v s (eisEmbedding d/eisEmbedding c) z := by + have hc' := eisEmbedding_ne_zero hc + have hnorm : 0 < ‖eisEmbedding c‖^2 := sq_pos_of_pos (norm_pos_iff.mpr hc') + have hfac : eisEmbedding c*z+eisEmbedding d = + eisEmbedding c*(z+eisEmbedding d/eisEmbedding c) := by field_simp + have heq : v/(‖eisEmbedding c*z+eisEmbedding d‖^2+‖eisEmbedding c‖^2*v^2) = + ((‖eisEmbedding c‖^2*v)*(1+‖(z+eisEmbedding d/eisEmbedding c)/(v:ℂ)‖^2))⁻¹ := by + rw [hfac,norm_mul,mul_pow,norm_div,Complex.norm_real,Real.norm_of_nonneg hv.le] + field_simp + ; ring + unfold primitiveTerm shiftedHeightKernel hyperbolicKernel + rw [heq,Complex.ofReal_inv,Complex.inv_cpow_ofReal_nonneg (by positivity),← Complex.cpow_neg] + rw [Complex.ofReal_mul,Complex.mul_cpow_ofReal_nonneg (mul_nonneg hnorm.le hv.le) (by positivity), + Complex.ofReal_mul,Complex.mul_cpow_ofReal_nonneg hnorm.le hv.le] + ring + +lemma primitiveTerm_integrable (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 1 < s.re) + (c d : O) (hc : c ≠ 0) : Integrable (fun z => primitiveTerm z v s c d) := by + simp_rw [primitiveTerm_eq_shiftedHeightKernel _ v hv s c d hc] + exact (shiftedHeightKernel_integrable v hv s _ hs).const_mul _ + +lemma traceIntegral_translate (f : ℂ → ℂ) (b freq : ℂ) : + (∫ z : ℂ,f (z+b)*ShortDraftTrace.breveE (-freq*z))= + ShortDraftTrace.breveE (freq*b)*(∫ z : ℂ,f z*ShortDraftTrace.breveE (-freq*z)) := by + have heq (z : ℂ) : f (z+b)*ShortDraftTrace.breveE (-freq*z)= + ShortDraftTrace.breveE (freq*b)*(f (z+b)*ShortDraftTrace.breveE (-freq*(z+b))) := by + rw [mul_left_comm (ShortDraftTrace.breveE (freq*b)), + ← AddChar.map_add_eq_mul] + congr 2 + ring + simp_rw [heq] + rw [integral_const_mul,integral_add_right_eq_self (fun z => f z*ShortDraftTrace.breveE (-freq*z)) b] + +lemma traceIntegral_scale (v : ℝ) (hv : 0 < v) (s freq : ℂ) : + (∫ z : ℂ,hyperbolicKernel s (z/(v:ℂ))*ShortDraftTrace.breveE (-freq*z))= + (v:ℂ)^2*sourceFourierKernel s (freq*v) := by + have heq (z : ℂ) : hyperbolicKernel s (z/(v:ℂ))*ShortDraftTrace.breveE (-freq*z)= + (fun w : ℂ => hyperbolicKernel s w*ShortDraftTrace.breveE (-(freq*v)*w)) (v⁻¹ • z) := by + simp only [Complex.real_smul,Complex.ofReal_inv] + congr 2 + · ring + · field_simp [Complex.ofReal_ne_zero.mpr hv.ne'] + simp_rw [heq] + have h := Measure.integral_comp_inv_smul_of_nonneg (volume : Measure ℂ) + (fun w : ℂ => hyperbolicKernel s w*ShortDraftTrace.breveE (-(freq*v)*w)) hv.le + simpa only [Complex.finrank_real_complex,Complex.real_smul,Complex.ofReal_pow,sourceFourierKernel] using h + +lemma traceIntegral_shiftedHeightKernel (v : ℝ) (hv : 0 < v) (s b freq : ℂ) : + (∫ z : ℂ,shiftedHeightKernel v s b z*ShortDraftTrace.breveE (-freq*z))= + (v:ℂ)^(2-s)*ShortDraftTrace.breveE (freq*b)*sourceFourierKernel s (freq*v) := by + simp only [shiftedHeightKernel,mul_assoc] + rw [integral_const_mul,traceIntegral_translate (fun z => hyperbolicKernel s (z/(v:ℂ))) b freq, + traceIntegral_scale v hv s freq] + have hp : (v:ℂ)^(-s)*(v:ℂ)^2=(v:ℂ)^(2-s) := by + rw [← Complex.cpow_natCast,← Complex.cpow_add _ _ (Complex.ofReal_ne_zero.mpr hv.ne')] + congr 1 + ring + calc + _ = ((v:ℂ)^(-s)*(v:ℂ)^2)*ShortDraftTrace.breveE (freq*b)*sourceFourierKernel s (freq*v) := by ring + _ = _ := by rw [hp]; ring + +end + +section +open MeasureTheory Set Filter +open scoped BigOperators Classical ENNReal Pointwise + +open ActualEisensteinCubic ConcreteTraceCRT + +lemma period_integral_translation (f : ℂ → ℂ) + (hperiod : ∀ (n : O) (z : ℂ), f (z+3*eisEmbedding n)=f z) (b : ℂ) : + (∫ z in periodDomain,f (b+z))=∫ z in periodDomain,f z := by + have hperiod' (n : periodLattice) (z : ℂ) : f (n+ᵥz)=f z := by + obtain ⟨m,rfl⟩ := periodEquiv.surjective n + change f (3*eisEmbedding m+z)=f z + simpa only [add_comm] using hperiod m z + have hD := periodDomain_fundamental.vadd_of_comm b + have heq := periodDomain_fundamental.setIntegral_eq hD hperiod' + have hchange := (measurePreserving_add_left volume b).setIntegral_image_emb + (measurableEmbedding_const_vadd b) f periodDomain + exact hchange.symm.trans heq.symm + +lemma breveE_quarter_eq_neg_one : ShortDraftTrace.breveE (1/4:ℂ)=-1 := by + change Complex.exp (2*Real.pi*Complex.I*((1/4:ℂ)+starRingEnd ℂ (1/4:ℂ)))=-1 + norm_num only [map_div₀,map_one,map_ofNat] + convert Complex.exp_pi_mul_I using 1 ; congr 1 ; ring + +lemma cuspFrequency_ne_zero (h : O) (hh : h ≠ 0) : cuspFrequency h ≠ 0 := + div_ne_zero (eisEmbedding_ne_zero hh) (mul_ne_zero (by norm_num) eisLam_ne_zero) + +theorem integral_cusp_character (h : O) : + (∫ z in periodDomain,ShortDraftTrace.breveE (-cuspFrequency h*z))= + if h=0 then ((9*Real.sqrt 3/2:ℝ):ℂ) else 0 := by + by_cases hh : h=0 + · subst h + simp only [cuspFrequency,map_zero,zero_div,neg_zero,zero_mul, + AddChar.map_zero_eq_one,ite_true,setIntegral_const,measureReal_def,periodDomain_volume, + ENNReal.toReal_ofReal (by positivity : (0:ℝ) ≤ 9*Real.sqrt 3/2),Complex.real_smul,mul_one] + · rw [ite_eq_right hh] + let freq := cuspFrequency h + let b : ℂ := -(4*freq)⁻¹ + have hfreq : freq ≠ 0 := cuspFrequency_ne_zero h hh + have harg : -freq*b=(1/4:ℂ) := by dsimp [b]; field_simp + have hphase : ShortDraftTrace.breveE (-freq*b)=-1 := by rw [harg,breveE_quarter_eq_neg_one] + have heq := period_integral_translation + (fun z => ShortDraftTrace.breveE (-freq*z)) + (fun n z => cuspFrequency_negative_period h n z) b + have hpoint (z : ℂ) : ShortDraftTrace.breveE (-freq*(b+z))= + -ShortDraftTrace.breveE (-freq*z) := by + rw [mul_add,AddChar.map_add_eq_mul,hphase,neg_one_mul] + simp_rw [hpoint,integral_neg] at heq + linear_combination (-1/2:ℂ)*heq + +end + +section +open MeasureTheory Set Filter +open scoped BigOperators Classical ENNReal + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal + +def primitiveRowIntegral (v : ℝ) (s freq : ℂ) (c d : O) : ℂ := + ∫ z in periodDomain,primitiveTerm z v s c d*ShortDraftTrace.breveE (-freq*z) + +lemma integral_summand_eq_primitiveRowIntegral (v : ℝ) (hv : 0 < v) + (s freq : ℂ) (x : CuspCosets) : + (∫ z in periodDomain,summand (upperSection z v hv) s x*ShortDraftTrace.breveE (-freq*z))= + primitiveRowIntegral v s freq (cosetRow x 0) (cosetRow x 1) := by + apply integral_congr_ae + exact Eventually.of_forall fun z => by + dsimp only + rw [summand_upperSection,inverse_cosetCharacter_eq_row_symbol] + rfl + +lemma hasSum_primitiveRowIntegrals (v : ℝ) (hv : 0 < v) (s freq : ℂ) (hs : 2 < s.re) : + HasSum (fun p : Σ c : LevelLower,AdmissibleDenominator c.1 => + primitiveRowIntegral v s freq p.1.1 p.2.1) + (∫ z in periodDomain,upperEisenstein z v hv s*ShortDraftTrace.breveE (-freq*z)) := by + apply primitiveSigmaEquiv.hasSum_iff.mp + apply primitiveRowEquiv.hasSum_iff.mp + exact (hasSum_integral_upperEisenstein v hv s freq hs).congr_fun + fun x => (integral_summand_eq_primitiveRowIntegral v hv s freq x).symm + +lemma primitiveRowIntegral_sum_translate (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 1 < s.re) + (h c d : O) (hc : c ≠ 0) (hlevel : (3:O) ∣ c) (hd : (3:O) ∣ d-1) : + (∑' n : O,primitiveRowIntegral v s (cuspFrequency h) c (d+3*c*n))= + ∫ z : ℂ,primitiveTerm z v s c d*ShortDraftTrace.breveE (-cuspFrequency h*z) := by + have hint := trace_mul_integrable (fun z => primitiveTerm z v s c d) + (primitiveTerm_integrable v hv s hs c d hc) (cuspFrequency h) + rw [integral_eq_period_integrals _ hint] + apply tsum_congr + intro n + apply integral_congr_ae + exact Eventually.of_forall fun z => by + dsimp only + rw [primitiveTerm_shift z v s c d n hlevel hd,cuspFrequency_negative_period] + +lemma primitiveTerm_fourier_integral (v : ℝ) (hv : 0 < v) (s freq : ℂ) + (c d : O) (hc : c ≠ 0) : + (∫ z : ℂ,primitiveTerm z v s c d*ShortDraftTrace.breveE (-freq*z))= + ((v:ℂ)^(2-s)*sourceFourierKernel s (freq*v))* + ((‖eisEmbedding c‖^2:ℝ):ℂ)^(-s)* + (eisEmbedding (symbol c d)*ShortDraftTrace.breveE (freq*eisEmbedding d/eisEmbedding c)) := by + simp_rw [primitiveTerm_eq_shiftedHeightKernel _ v hv s c d hc,mul_assoc] + rw [integral_const_mul,integral_const_mul,traceIntegral_shiftedHeightKernel v hv s (eisEmbedding d/eisEmbedding c) freq] + ring_nf + +def arithmeticResidueSum (h c : O) : ℂ := + ∑' r : AdmissibleResidue c,eisEmbedding (symbol c (denominatorRep c r.1))* + ShortDraftTrace.breveE (cuspFrequency h*eisEmbedding (denominatorRep c r.1)/eisEmbedding c) + +lemma arithmeticResidueSum_finite (h c : O) (hc : c ≠ 0) : + letI : Fintype (AdmissibleResidue c) := @Fintype.ofFinite _ (finite_admissibleResidue c hc) + arithmeticResidueSum h c = ∑ r : AdmissibleResidue c, + eisEmbedding (symbol c (denominatorRep c r.1))* + ShortDraftTrace.breveE (cuspFrequency h*eisEmbedding (denominatorRep c r.1)/eisEmbedding c) := by + let : Fintype (AdmissibleResidue c) := @Fintype.ofFinite _ (finite_admissibleResidue c hc) + exact tsum_fintype _ + +lemma denominator_integral_formula (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) + (h : O) (c : LevelLower) (hc : c.1 ≠ 0) : + (∑' d : AdmissibleDenominator c.1,primitiveRowIntegral v s (cuspFrequency h) c.1 d.1)= + ((v:ℂ)^(2-s)*sourceFourierKernel s (cuspFrequency h*v))* + ((‖eisEmbedding c.1‖^2:ℝ):ℂ)^(-s)*arithmeticResidueSum h c.1 := by + have hsum : Summable (fun d : AdmissibleDenominator c.1 => + primitiveRowIntegral v s (cuspFrequency h) c.1 d.1) := + (hasSum_primitiveRowIntegrals v hv s (cuspFrequency h) hs).summable.sigma_factor c + rw [denominator_sum_residues c.1 hc + (fun d : O => primitiveRowIntegral v s (cuspFrequency h) c.1 d) hsum] + calc + _ = ∑' r : AdmissibleResidue c.1, ∫ z : ℂ, + primitiveTerm z v s c.1 (denominatorRep c.1 r.1)* + ShortDraftTrace.breveE (-cuspFrequency h*z) := by + apply tsum_congr + intro r + exact primitiveRowIntegral_sum_translate v hv s (by linarith) h c.1 + (denominatorRep c.1 r.1) hc c.2 r.2.2 + _ = _ := by + simp_rw [primitiveTerm_fourier_integral v hv s (cuspFrequency h) c.1 _ hc] + exact tsum_mul_left + +end + +section +open MeasureTheory Set Filter +open scoped BigOperators Classical ENNReal Matrix + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal + +instance : DiscreteTopology periodLattice := by unfold periodLattice; infer_instance +instance : IsZLattice ℝ periodLattice := by unfold periodLattice; infer_instance + +lemma summable_embedding_rpow (k : ℝ) (hk : k < -2) : + Summable (fun n : O => ‖eisEmbedding n‖^k) := by + have hrank : Module.finrank ℤ periodLattice=2 := by + rw [ZLattice.rank ℝ periodLattice,Complex.finrank_real_complex] + have hs := ZLattice.summable_norm_rpow periodLattice k (by rw [hrank]; norm_num; exact hk) + have hcomp := periodEquiv.summable_iff.mpr hs + have hscale := hcomp.mul_left (((3:ℝ)^k)⁻¹) + apply hscale.congr + intro n + change ((3:ℝ)^k)⁻¹*‖(3:ℂ)*eisEmbedding n‖^k=‖eisEmbedding n‖^k + rw [norm_mul,show ‖(3:ℂ)‖=(3:ℝ) by norm_num, + Real.mul_rpow (by norm_num) (norm_nonneg _)] + rw [← mul_assoc,inv_mul_cancel₀ (Real.rpow_pos_of_pos (by norm_num) k).ne',one_mul] + +lemma norm_row_symbol (c d : O) (hc : (3:O) ∣ c) (hd : denominatorCondition c d) : + ‖eisEmbedding (symbol c d)‖=1 := by + let r : PrimitiveRow := ⟨![c,d],hd.1,hc,hd.2⟩ + let x := primitiveRowEquiv.symm r + have heq : (cosetCharacter x)⁻¹=eisEmbedding (symbol c d) := by + rw [inverse_cosetCharacter_eq_row_symbol] + change eisEmbedding (symbol (cosetRow (primitiveRowEquiv.symm r) 0) + (cosetRow (primitiveRowEquiv.symm r) 1))=eisEmbedding (symbol c d) + rw [primitiveRowEquiv_symm_row r] + rfl + rw [← heq,norm_inv,norm_cosetCharacter,inv_one] + +lemma norm_arithmeticResidueSum_le (h c : O) (hc : c ≠ 0) (hlevel : (3:O) ∣ c) : + ‖arithmeticResidueSum h c‖ ≤ 9*‖eisEmbedding c‖^2 := by + let : Finite (DenominatorResidue c) := finite_quotient_span (mul_ne_zero (by norm_num) hc) + let : Fintype (DenominatorResidue c) := Fintype.ofFinite _ + let : Fintype (AdmissibleResidue c) := Fintype.ofFinite _ + have hcard : (Fintype.card (DenominatorResidue c):ℝ)=9*‖eisEmbedding c‖^2 := by + have hh := eisEmbedding_norm_sq_eq_absNorm_span (3*c) + simp only [Ideal.absNorm_apply,Submodule.cardQuot_apply,Nat.card_eq_fintype_card] at hh + rw [← hh,map_mul,map_ofNat,norm_mul,mul_pow] + norm_num + rw [arithmeticResidueSum,tsum_fintype] + calc + _ ≤ ∑ r : AdmissibleResidue c, ‖eisEmbedding (symbol c (denominatorRep c r.1))* + ShortDraftTrace.breveE (cuspFrequency h*eisEmbedding (denominatorRep c r.1)/eisEmbedding c)‖ := + norm_sum_le _ _ + _ = (Fintype.card (AdmissibleResidue c):ℝ) := by + have hr (r : AdmissibleResidue c) : + ‖eisEmbedding (symbol c (denominatorRep c r.1))‖=1 := + norm_row_symbol c (denominatorRep c r.1) hlevel r.2 + simp only [norm_mul,hr,breveE_norm,Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] + _ ≤ (Fintype.card (DenominatorResidue c):ℝ) := by + exact_mod_cast Fintype.card_subtype_le (fun r => denominatorCondition c (denominatorRep c r)) + _ = _ := hcard + +def arithmeticDirichletTerm (s : ℂ) (h : O) (c : LevelLower) : ℂ := + if c.1=0 then 0 else ((‖eisEmbedding c.1‖^2:ℝ):ℂ)^(-s)*arithmeticResidueSum h c.1 + +lemma norm_arithmeticDirichletTerm_le (s : ℂ) (h : O) (c : LevelLower) : + ‖arithmeticDirichletTerm s h c‖ ≤ 9*‖eisEmbedding c.1‖^(2-2*s.re) := by + unfold arithmeticDirichletTerm + split_ifs with hc + · simp only [norm_zero] + positivity + · have hn : 0 < ‖eisEmbedding c.1‖ := norm_pos_iff.mpr (eisEmbedding_ne_zero hc) + rw [norm_mul,Complex.norm_cpow_eq_rpow_re_of_pos (sq_pos_of_pos hn)] + change (‖eisEmbedding c.1‖^2)^(-s.re)*‖arithmeticResidueSum h c.1‖ ≤ _ + calc + _ ≤ (‖eisEmbedding c.1‖^2)^(-s.re)*(9*‖eisEmbedding c.1‖^2) := + mul_le_mul_of_nonneg_left (norm_arithmeticResidueSum_le h c.1 hc c.2) (by positivity) + _ = _ := by + rw [← Real.rpow_natCast_mul hn.le 2 (-s.re)] + rw [show 2-2*s.re=2+2*(-s.re) by ring,Real.rpow_add hn] + norm_num only [Nat.cast_ofNat,Real.rpow_two] + ring + +theorem arithmeticDirichletTerm_summable_norm (s : ℂ) (hs : 2 < s.re) (h : O) : + Summable (fun c : LevelLower => ‖arithmeticDirichletTerm s h c‖) := by + have hbase := (summable_embedding_rpow (2-2*s.re) (by linarith)).subtype + (fun c : O => (3:O) ∣ c) + exact (hbase.mul_left 9).of_nonneg_of_le (fun _ => norm_nonneg _) + (norm_arithmeticDirichletTerm_le s h) + +def arithmeticDirichletSeries (s : ℂ) (h : O) : ℂ := + ∑' c : LevelLower,arithmeticDirichletTerm s h c + +def scatteringCoefficient (s : ℂ) (h : O) : ℂ := + arithmeticDirichletSeries s h/((9*Real.sqrt 3/2:ℝ):ℂ) + +end + +open MeasureTheory Set Filter +open scoped BigOperators Classical + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal + +lemma zero_lower_integral (v : ℝ) (s : ℂ) (h : O) : + (∑' d : AdmissibleDenominator 0,primitiveRowIntegral v s (cuspFrequency h) 0 d.1)= + (v:ℂ)^s*(if h=0 then ((9*Real.sqrt 3/2:ℝ):ℂ) else 0) := by + let d0 : AdmissibleDenominator 0 := ⟨1,isCoprime_one_right,by simp⟩ + rw [tsum_eq_single d0] + · simp only [d0,primitiveRowIntegral,primitiveTerm,map_zero,map_one,zero_mul,zero_add, + norm_one,norm_zero,one_pow,zero_pow (by decide : (2:ℕ) ≠ 0),add_zero, + div_one,symbol_one,map_one] + rw [integral_const_mul,integral_cusp_character,one_mul] + · intro d hd + exact False.elim (hd (Subtype.ext (denominator_zero_unique d))) + +lemma integral_upperEisenstein_arithmetic (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) (h : O) : + (∫ z in periodDomain,upperEisenstein z v hv s*ShortDraftTrace.breveE (-cuspFrequency h*z))= + (v:ℂ)^s*(if h=0 then ((9*Real.sqrt 3/2:ℝ):ℂ) else 0)+ + ((v:ℂ)^(2-s)*sourceFourierKernel s (cuspFrequency h*v))*arithmeticDirichletSeries s h := by + let c0 : LevelLower := ⟨0,dvd_zero _⟩ + let F (c : LevelLower) := ∑' d : AdmissibleDenominator c.1, + primitiveRowIntegral v s (cuspFrequency h) c.1 d.1 + have hsum := hasSum_primitiveRowIntegrals v hv s (cuspFrequency h) hs + have hF : Summable F := hsum.summable.sigma + have hzero : F c0=(v:ℂ)^s*(if h=0 then ((9*Real.sqrt 3/2:ℝ):ℂ) else 0) := + zero_lower_integral v s h + calc + _ = ∑' c : LevelLower,F c := hsum.tsum_eq.symm.trans hsum.summable.tsum_sigma + _ = F c0+∑' c : LevelLower,if c=c0 then 0 else F c := hF.tsum_eq_add_tsum_ite c0 + _ = _ := by + rw [hzero] + congr 1 + rw [arithmeticDirichletSeries,← tsum_mul_left] + apply tsum_congr + intro c + by_cases hc : c.1=0 + · have heq : c=c0 := Subtype.ext hc + simp only [heq,ite_true,arithmeticDirichletTerm,c0,mul_zero] + · have heq : c ≠ c0 := fun heq => hc (congrArg Subtype.val heq) + rw [ite_eq_right heq] + change (∑' d : AdmissibleDenominator c.1, + primitiveRowIntegral v s (cuspFrequency h) c.1 d.1)=_ + rw [denominator_integral_formula v hv s hs h c hc] + simp only [arithmeticDirichletTerm,ite_eq_right hc] + ring + +def eisensteinFourierCoefficient (v : ℝ) (hv : 0 < v) (s : ℂ) (h : O) : ℂ := + (∫ z in periodDomain,upperEisenstein z v hv s*ShortDraftTrace.breveE (-cuspFrequency h*z))/ + ((9*Real.sqrt 3/2:ℝ):ℂ) + +theorem eisensteinFourierCoefficient_formula (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) (h : O) : + eisensteinFourierCoefficient v hv s h=(if h=0 then (v:ℂ)^s else 0)+ + (v:ℂ)^(2-s)*sourceFourierKernel s (cuspFrequency h*v)*scatteringCoefficient s h := by + rw [eisensteinFourierCoefficient,integral_upperEisenstein_arithmetic v hv s hs h,scatteringCoefficient] + have hvol : ((9*Real.sqrt 3/2:ℝ):ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr (by positivity) + split_ifs <;> field_simp ; ring + +theorem eisensteinConstantCoefficient_formula (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) : + eisensteinFourierCoefficient v hv s 0=(v:ℂ)^s+ + (v:ℂ)^(2-s)*((Real.pi:ℂ)/(s-1))*scatteringCoefficient s 0 := by + rw [eisensteinFourierCoefficient_formula v hv s hs 0] + simp only [ite_true,cuspFrequency,map_zero,zero_div,zero_mul] + rw [sourceFourierKernel_zero s (by linarith)] + +theorem eisensteinFourierCoefficient_bessel (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) + (h : O) (hh : h ≠ 0) : + eisensteinFourierCoefficient v hv s h= + (v:ℂ)^(2-s)* + ((2*Real.pi:ℂ)/Complex.Gamma s * + (2*Real.pi*‖cuspFrequency h*v‖:ℂ)^(s-1)* + schlafliBesselK (s-1) (4*Real.pi*‖cuspFrequency h*v‖))* + scatteringCoefficient s h := by + rw [eisensteinFourierCoefficient_formula v hv s hs h,ite_eq_right hh,zero_add] + rw [sourceFourierKernel_bessel s (cuspFrequency h*v) (by linarith) + (mul_ne_zero (cuspFrequency_ne_zero h hh) (Complex.ofReal_ne_zero.mpr hv.ne'))] + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/FredholmAlternative.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FredholmAlternative.lean new file mode 100644 index 0000000000000000000000000000000000000000..56d327fc387b0a7e4949bfaa186ac27f9da6ad26 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FredholmAlternative.lean @@ -0,0 +1,637 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.ClosedRecursion + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace + +section + +variable {E F G : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [NormedSpace ℂ F] + [NormedAddCommGroup G] [NormedSpace ℂ G] + +omit [CompleteSpace E] in +lemma ker_orthogonal_restriction_injective (T : E→L[ℂ]F) : + Function.Injective (T.domRestrict T.kerᗮ) := by + apply LinearMap.ker_eq_bot.mp + apply LinearMap.ker_eq_bot'.mpr + intro u hu + apply Subtype.ext + apply (inner_self_eq_zero (𝕜 := ℂ)).mp + exact T.ker.inner_right_of_mem_orthogonal hu u.2 + +lemma ker_orthogonal_restriction_range (T : E→L[ℂ]F) : + Set.range (T.domRestrict T.kerᗮ)=Set.range T := by + let : CompleteSpace T.ker := T.isClosed_ker.completeSpace_coe + apply Set.Subset.antisymm + · rintro _ ⟨u,rfl⟩ + exact ⟨u.1,rfl⟩ + · rintro _ ⟨u,rfl⟩ + refine ⟨⟨u-T.ker.starProjection u,T.ker.sub_starProjection_mem_orthogonal u⟩,?_⟩ + change T (u-T.ker.starProjection u)=T u + rw [map_sub] + have hz : T (T.ker.starProjection u)=0 := T.ker.starProjection_apply_mem u + rw [hz,sub_zero] + +lemma ker_orthogonal_restriction_antilipschitz (T : E→L[ℂ]F) (K : E→L[ℂ]G) + (hK : IsCompactOperator K) (A B : ℝ) + (hest : ∀u,‖u‖^2≤A*‖T u‖^2+B*‖K u‖^2) : + ∃D : NNReal,AntilipschitzWith D (T.domRestrict T.kerᗮ) := by + let : CompleteSpace T.kerᗮ := T.ker.isClosed_orthogonal.completeSpace_coe + apply antilipschitz_of_injective_compact_estimate (T.domRestrict T.kerᗮ) + (K.domRestrict T.kerᗮ) (hK.comp_clm T.kerᗮ.subtypeL) A B + (fun u => hest u) (ker_orthogonal_restriction_injective T) + +lemma closed_range_of_compact_estimate (T : E→L[ℂ]F) (K : E→L[ℂ]G) + (hK : IsCompactOperator K) (A B : ℝ) + (hest : ∀u,‖u‖^2≤A*‖T u‖^2+B*‖K u‖^2) : IsClosed (Set.range T) := by + let : CompleteSpace T.kerᗮ := T.ker.isClosed_orthogonal.completeSpace_coe + obtain ⟨D,hD⟩ := ker_orthogonal_restriction_antilipschitz T K hK A B hest + rw [←ker_orthogonal_restriction_range T] + exact hD.isClosed_range (T.domRestrict T.kerᗮ).uniformContinuous + +lemma selfAdjoint_range_eq_ker_orthogonal (T : E→L[ℂ]E) (hT : IsSelfAdjoint T) + (hrange : IsClosed (Set.range T)) : T.range=T.kerᗮ := by + have hh := T.orthogonal_ker + rw [hT.adjoint_eq] at hh + rw [hrange.submodule_topologicalClosure_eq] at hh + exact hh.symm + +end + +section +variable {E G : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup G] [NormedSpace ℂ G] + +lemma selfAdjoint_fredholm_of_compact_estimate (T : E→L[ℂ]E) (hT : IsSelfAdjoint T) + (K : E→L[ℂ]G) (hK : IsCompactOperator K) (A B : ℝ) + (hest : ∀u,‖u‖^2≤A*‖T u‖^2+B*‖K u‖^2) : T.IsFredholm := by + let : CompleteSpace T.ker := T.isClosed_ker.completeSpace_coe + let : FiniteDimensional ℂ T.ker := finiteDimensional_ker_of_compact_estimate T K hK A B hest + let : T.kerᗮ.CoFG := + (T.kerᗮ.quotientEquivOfIsCompl T.ker T.ker.isCompl_orthogonal.symm).symm.finiteDimensional + have hrange := closed_range_of_compact_estimate T K hK A B hest + have heq := selfAdjoint_range_eq_ker_orthogonal T hT hrange + let : T.range.CoFG := heq.symm ▸ (inferInstance : T.kerᗮ.CoFG) + obtain ⟨D,hD⟩ := ker_orthogonal_restriction_antilipschitz T K hK A B hest + let : CompleteSpace T.kerᗮ := T.ker.isClosed_orthogonal.completeSpace_coe + have hf : (T.domRestrict T.kerᗮ).IsFredholm := by + apply (hD.isClosedEmbedding (T.domRestrict T.kerᗮ).uniformContinuous).isFredholm + have he : (T.domRestrict T.kerᗮ).range=T.range := by + apply SetLike.coe_injective + exact ker_orthogonal_restriction_range T + rw [he] + infer_instance + exact (ContinuousLinearMap.isFredholm_domRestrict_iff T.ker.isClosed_orthogonal).mp hf + +end + +def kernelSpectralFormOperator (z : ℂ) : KernelEnergyGraph→L[ℂ]KernelEnergyGraph := + ContinuousLinearMap.id ℂ KernelEnergyGraph- + (z+1)•(kernelEnergyMass.adjoint.comp kernelEnergyMass) + +lemma kernelSpectralFormOperator_inner (z : ℂ) (u : KernelEnergyGraph) : + inner ℂ u (kernelSpectralFormOperator z u)= + ((‖kernelEnergyGradient u‖^2:ℝ):ℂ)-z*((‖kernelEnergyMass u‖^2:ℝ):ℂ) := by + change inner ℂ u (u-(z+1)•kernelEnergyMass.adjoint (kernelEnergyMass u))=_ + rw [inner_sub_right,inner_smul_right u (kernelEnergyMass.adjoint (kernelEnergyMass u)) (z + 1),kernelEnergyMass.adjoint_inner_right, + inner_self_eq_norm_sq_to_K,inner_self_eq_norm_sq_to_K] + simp only [RCLike.ofReal_eq_complex_ofReal,←Complex.ofReal_pow,kernelEnergyGraph_norm_sq,Complex.ofReal_add] + ring + +lemma kernelSpectralFormOperator_selfAdjoint (spectralParam : ℝ) : + IsSelfAdjoint (kernelSpectralFormOperator (spectralParam:ℂ)) := by + apply ContinuousLinearMap.isSelfAdjoint_iff_isSymmetric.mpr + apply (LinearMap.isSymmetric_iff_inner_map_self_real _).mpr + intro u + have hh := kernelSpectralFormOperator_inner (spectralParam:ℂ) u + have hr : inner ℂ (kernelSpectralFormOperator (spectralParam:ℂ) u) u= + (((‖kernelEnergyGradient u‖^2-spectralParam*‖kernelEnergyMass u‖^2):ℝ):ℂ) := by + rw [←inner_conj_symm,kernelSpectralFormOperator_inner] + simp only [map_sub,map_mul,Complex.conj_ofReal,Complex.ofReal_sub,Complex.ofReal_mul] + change (starRingEnd ℂ) (inner ℂ (kernelSpectralFormOperator (spectralParam:ℂ) u) u)= + inner ℂ (kernelSpectralFormOperator (spectralParam:ℂ) u) u + rw [hr,Complex.conj_ofReal] + +lemma scalar_compact_energy_estimate (m g n t k spectralParam C : ℝ) + (_hn : 0≤n) (_ht : 0≤t) (hspectralParam : 0≤spectralParam) (hspectralParamone : spectralParam<1) (hC : 0≤C) + (hspace : n^2=m^2+g^2) (hcore : m^2≤g^2+C*k^2) + (hform : g^2-spectralParam*m^2≤n*t) : + n^2≤(4/(1-spectralParam)^2)*t^2+(4*C/(1-spectralParam))*k^2 := by + have hd : 0<1-spectralParam := sub_pos.mpr hspectralParamone + have hlow : (1-spectralParam)/2*n^2≤n*t+C*k^2 := by + nlinarith [mul_nonneg (show 0≤1+spectralParam by linarith) (sub_nonneg.mpr hcore), + mul_nonneg hd.le (mul_nonneg hC (sq_nonneg k))] + have hlow' := mul_le_mul_of_nonneg_left hlow (show 0≤4*(1-spectralParam) by positivity) + have hsq : (1-spectralParam)^2*n^2≤4*t^2+4*(1-spectralParam)*C*k^2 := by + nlinarith [sq_nonneg ((1-spectralParam)*n-2*t)] + have he : (4/(1-spectralParam)^2)*t^2+(4*C/(1-spectralParam))*k^2= + (4*t^2+4*(1-spectralParam)*C*k^2)/(1-spectralParam)^2 := by + field_simp [hd.ne'] + rw [he] + exact (le_div_iff₀ (sq_pos_of_pos hd)).mpr (by nlinarith [hsq]) + +lemma kernelSpectralFormOperator_compact_estimate + (K : Set KernelQuotient) (hK : MeasurableSet K) (C : ℝ) (hC : 0≤C) + (hcore : ∀u : KernelEnergyGraph,‖kernelEnergyMass u‖^2≤‖kernelEnergyGradient u‖^2+ + C*‖kernelEnergyMassRestriction K hK u‖^2) + (spectralParam : ℝ) (hspectralParam : 0≤spectralParam) (hspectralParamone : spectralParam<1) (u : KernelEnergyGraph) : + ‖u‖^2≤(4/(1-spectralParam)^2)*‖kernelSpectralFormOperator (spectralParam:ℂ) u‖^2+ + (4*C/(1-spectralParam))*‖kernelEnergyMassRestriction K hK u‖^2 := by + apply scalar_compact_energy_estimate ‖kernelEnergyMass u‖ ‖kernelEnergyGradient u‖ + ‖u‖ ‖kernelSpectralFormOperator (spectralParam:ℂ) u‖ ‖kernelEnergyMassRestriction K hK u‖ spectralParam C + (norm_nonneg _) (norm_nonneg _) hspectralParam hspectralParamone hC (kernelEnergyGraph_norm_sq u) (hcore u) + have hh := re_inner_le_norm (𝕜 := ℂ) u (kernelSpectralFormOperator (spectralParam:ℂ) u) + rw [kernelSpectralFormOperator_inner] at hh + simpa only [RCLike.re_to_complex,Complex.sub_re,Complex.mul_re,Complex.ofReal_re, + Complex.ofReal_im,mul_zero,sub_zero] using hh + +lemma kernelSpectralFormOperator_solution_graph (z : ℂ) (F : KernelQuotientL2) + (v : KernelEnergyGraph) (hv : kernelSpectralFormOperator z v=kernelVariationalSolution F) : + (kernelEnergyMass v,F+z•kernelEnergyMass v)∈kernelEnergyLaplacian.graph := by + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] + have hh : v-(z+1)•kernelEnergyMass.adjoint (kernelEnergyMass v)=kernelEnergyMass.adjoint F := hv + have hv' : kernelEnergyMass.adjoint (F+(z+1)•kernelEnergyMass v)=v := by + rw [map_add,map_smul] + exact (sub_eq_iff_eq_add.mp hh).symm + have he : kernelEnergyMass v+(F+z•kernelEnergyMass v)=F+(z+1)•kernelEnergyMass v := by + rw [add_smul,one_smul] + abel + rw [he] + change kernelEnergyMass (kernelEnergyMass.adjoint (F+(z+1)•kernelEnergyMass v))=kernelEnergyMass v + rw [hv'] + +lemma kernelSpectralFormOperator_of_domain (z : ℂ) (u : kernelEnergyLaplacian.domain) : + kernelSpectralFormOperator z (kernelVariationalSolution (kernelEnergyLaplacian u+u))= + kernelVariationalSolution (kernelEnergyLaplacian u-z•(u:KernelQuotientL2)) := by + have hu : kernelEnergyMass (kernelVariationalSolution (kernelEnergyLaplacian u+u))=u := + kernelEnergyLaplacian_resolvent_relation u + change kernelVariationalSolution (kernelEnergyLaplacian u+u)- + (z+1)•kernelVariationalSolution (kernelEnergyMass (kernelVariationalSolution (kernelEnergyLaplacian u+u)))=_ + rw [hu,←map_smul,←map_sub] + congr 1 + rw [add_smul,one_smul] + abel + +theorem kernelSpectralFormOperator_isFredholm (spectralParam : ℝ) + (hzero : 0≤spectralParam) (hone : spectralParam<1) : + (kernelSpectralFormOperator (spectralParam:ℂ)).IsFredholm := by + obtain ⟨K,hK,C,hC,hcompact,hcoercive⟩ := kernel_global_exterior_coercivity + exact selfAdjoint_fredholm_of_compact_estimate _ + (kernelSpectralFormOperator_selfAdjoint spectralParam) + (kernelEnergyMassRestriction K hK.measurableSet) hcompact + (4/(1-spectralParam)^2) (4*C/(1-spectralParam)) + (kernelSpectralFormOperator_compact_estimate K hK.measurableSet C hC hcoercive spectralParam hzero hone) + +theorem kernel_theta_spectral_fredholm : + (kernelSpectralFormOperator (8/9:ℂ)).IsFredholm := by + convert kernelSpectralFormOperator_isFredholm (8/9) (by norm_num) (by norm_num) using 1 + norm_num + +end CubicEisenstein + +namespace CanonicalRowCompletion +open SecondPassArithmetic + +theorem cubeLogRange_sq_small_power (b ε : ℝ) (_hb : 0≤b) (hε : 0<ε) : + ∃C : ℝ,0by rw [poolPrimary_span F hF i];infer_instance + let Q':=progressingCubes S D H₀ Q + let β:=fun I v=>reopenedCubeCoefficient H₀ + (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n:=fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ) + (∀ξ : ℝ,B*rowFamilyEnergy labels (fun I z=> + reopenedCanonicalRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Q' (separatedCubeCoefficient (β I) n B ξ) + Ψ m (idealGenerator I) (fun T=>frequencyTwist V (oldHeight+ξ) (columnLog (poolPrimary F) ell T)) z) K≤ + E*(1+|oldHeight+ξ|)^(2*J)) → + X*rowFamilyEnergy labels (fun I z=> + outsideCanonicalBin S D hbad Q (normHeightTwist Ψ oldHeight) m (idealGenerator I) z W X H₀) K≤ + E*(1+|oldHeight|)^(2*J)* + (∫ξ : ℝ,‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^J)^2 := by + dsimp only + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i : primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + let Q':=progressingCubes S D H₀ Q + let β:=fun I v=>reopenedCubeCoefficient H₀ + (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n:=fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ) + intro hsource + have hX0 : 0outsideCanonicalBin S D hbad Q (normHeightTwist Ψ oldHeight) m (idealGenerator I) z W X H₀)= + (fun I z=>outsideCanonicalBin S D hbad Q' (normHeightTwist Ψ oldHeight) m (idealGenerator I) z W X H₀) := by + funext I z + exact outsideCanonicalBin_filter S D hbad Q _ m _ z W X H₀ + rw [heq] + have he := outsideCanonicalBin_energy S D hbad Q' labels (normHeightTwist Ψ oldHeight) m W + a b ha hs hW V hV B ell X H₀ K ((E/B)*(1+|oldHeight|)^(2*J)) J hB hell hX hK + (by positivity) (fun v hv=>hn v (hQsub hv)) (fun v hv=>hn' v (hQsub hv)) + have hpnt : ∀ξ : ℝ,rowFamilyEnergy labels (fun I z=> + reopenedCanonicalRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Q' (separatedCubeCoefficient (β I) n B ξ) + (normHeightTwist Ψ oldHeight) m (idealGenerator I) + (fun T=>frequencyTwist V ξ (columnLog (poolPrimary F) ell T)) z) K≤ + ((E/B)*(1+|oldHeight|)^(2*J))*(1+|ξ|)^(2*J) := by + intro ξ + change (∑I∈labels,nonzeroRowMajorantSum _ K).re≤_ + rw [reopenedCanonicalEnergy_two_heights (poolPrimary F) (poolPrimary_ne_zero F hF) + (poolPrimary_coprime F hF) (poolPrimary_good F hF) Finset.univ Q' labels + (fun I=>separatedCubeCoefficient (β I) n B ξ) Ψ m V ell K oldHeight ξ hell] + change rowFamilyEnergy labels _ K≤_ + have ht := (le_div_iff₀ hB).mpr (by simpa only [mul_comm] using hsource ξ) + calc + _ ≤ E*(1+|oldHeight+ξ|)^(2*J)/B := by simpa only [Nat.mul_comm J 2] using ht + _ ≤ E*((1+|oldHeight|)^(2*J)*(1+|ξ|)^(2*J))/B := + div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left (height_sum_bound oldHeight ξ J) hE) hB.le + _ = _ := by ring + have hf:=he hpnt + have hh:=mul_le_mul_of_nonneg_left hf hX0.le + apply hh.trans_eq + rw [hX] + field_simp + +end CanonicalRowCompletion + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace CompletedGauss +open ActualEisensteinCubic + +theorem shortCompletedSum_nonpos (Ψ : ActualEisensteinCubic.O→*ℂ) (W : ℝ→ℂ) (X H₀ : ℝ) (hH : H₀≤0) : + shortCompletedSum Ψ W X H₀=0 := by + unfold shortCompletedSum + calc + _ = ∑'I : Ideal ActualEisensteinCubic.O,(0:ℂ) := tsum_congr (fun I=>ite_eq_right (not_lt_of_ge (hH.trans (Nat.cast_nonneg (Ideal.absNorm I))))) + _ = 0 := tsum_zero + +end CompletedGauss +namespace CanonicalRowCompletion +open ActualEisensteinCubic +open CompletedGauss hiding O +open ConcretePrimeRowBridge hiding O columnWeight +open CanonicalQuadraticSieve hiding O +open SecondPassArithmetic hiding O +open ConcreteTraceCRT (eisEmbedding) + +theorem canonicalLabels_subset_idealRange + (base : ActualEisensteinCubic.O→*ℂ) (bad : Ideal ActualEisensteinCubic.O) (Z η : ℝ) (Ψ : ActualEisensteinCubic.O→*ℂ) (m : ActualEisensteinCubic.O) + (labels : Finset (Ideal ActualEisensteinCubic.O)) (X F K : ℝ) + (hstate : CanonicalStateCondition base bad Z η Ψ m labels X F K) + (hbad : ∀P∈fixedBadPrimes,P∣bad) : labels⊆idealRange F := by + intro I hI + have hb:=hstate.label_bounds I hI + exact mem_idealRange.mpr ⟨admissible_of_squarefree_coprime_bad I bad hb.2.1 hb.2.2.1 hbad,hb.2.2.2⟩ + +theorem rowFamilyEnergy_le_rectangle (labels : Finset (Ideal ActualEisensteinCubic.O)) (F K : ℝ) + (hK : 0Finset.sum_nonneg (fun z hz=>sq_nonneg _)) + _ = _ := by + congr 1 + exact (Finset.sum_coe_sort (s:=idealRange F) + (f:=fun I=>∑z∈(firstFrequencyDisk (2*K)).erase 0,‖P I z‖^2)).symm + +theorem canonicalShortEnergy_uniform_twist + (a b : ℝ) (ha : 0Ideal.span {z})) (2*K) + (X/(Ideal.absNorm H:ℝ)^3) ρ q levelBound f.val (G*f.val) + (CompletedHeight.normTwistedSource W θ) (CompletedUnitRows.unitRowFamily Ψ mask u f) lengthScale) → + rowFamilyEnergy labels (fun I z=>shortCompletedSum (rowTwist (normHeightTwist Ψ θ) + mask (idealGenerator I) z) W X (Z^((1:ℝ)/1000))) K≤ + (C*(1+‖θ‖)^d)*(rays:ℝ)^2*‖lengthScale‖^2*((2*K)*(Ideal.absNorm G:ℝ)*F)^ε*(K*F)*Z^ε := by + obtain ⟨d,hbound⟩:=CompletedUnitRows.short_completed_elements_uniform_twist a b ha ε ρ q levelBound hε hρ hq hlevel + refine ⟨d,?_⟩ + intro W hs hW + obtain ⟨C,hC,h⟩:=hbound W hs hW + refine ⟨2*SchwartzMap.seminorm ℝ 0 0 rowMajorant*C,by positivity,?_⟩ + intro θ rays Z K X F hZ hK hF hFZ G hG hbad hmargin labels hlabels Ψ hΨ mask lengthScale hmodels + have hK0 : 0shortCompletedSum (rowTwist (normHeightTwist Ψ θ) mask (idealGenerator I) z) W X (Z^((1:ℝ)/1000))) + exact hrect.trans ((mul_le_mul_of_nonneg_left hsum (apply_nonneg _ _)).trans_eq (by ring)) + +end CanonicalRowCompletion + +open MeasureTheory +open scoped BigOperators Classical SchwartzMap ContDiff +namespace CanonicalRowCompletion +open ActualEisensteinCubic +open CompletedGauss hiding O +open ConcretePrimeRowBridge hiding O columnWeight +open CanonicalQuadraticSieve hiding O +open SecondPassArithmetic hiding O +open CanonicalCubeSeparation JointLogSeparation +open FirstPassCubeLabels (columnLog) + +theorem progressingCanonicalFamily_energy + (S : Finset (Ideal ActualEisensteinCubic.O)) (D : ℕ) (hbad : fixedBadPrimes⊆S) (hSp : ∀P∈S,Prime P) + (labels : Finset (Ideal ActualEisensteinCubic.O)) (Ψ : ActualEisensteinCubic.O→*ℂ) (m : ActualEisensteinCubic.O) (W : ℝ→ℂ) + (a b : ℝ) (ha : 0by rw [poolPrimary_span F hF i];infer_instance + let β:=fun I v=>reopenedCubeCoefficient H₀ + (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) 1) (cubeIdeal F v) + let n:=fun v=>(Ideal.absNorm (cubeIdeal F v):ℝ) + (∀j∈cubeLogRange b X, + let B:=normLogScale j + let Q':=progressingCubes S D H₀ (activeCubeLogBin S D b X j) + Q'.Nonempty → ∀ξ : ℝ,B*rowFamilyEnergy labels (fun I z=> + reopenedCanonicalRow (poolPrimary F) (poolPrimary_ne_zero F hF) (poolPrimary_coprime F hF) + (poolPrimary_good F hF) Finset.univ Q' (separatedCubeCoefficient (β I) n B ξ) + Ψ m (idealGenerator I) + (fun T=>frequencyTwist V (oldHeight+ξ) (columnLog (poolPrimary F) (X/B^3) T)) z) K≤ + E*(1+|oldHeight+ξ|)^(2*J)) → + rowFamilyEnergy labels (fun I z=>outsideCanonicalRow S D hbad (normHeightTwist Ψ oldHeight) + m (idealGenerator I) z W X) K≤ + 2*X*rowFamilyEnergy labels (fun I z=> + shortCompletedSum (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) z) W X H₀) K+ + 2*((cubeLogRange b X).card:ℝ)^2*E*(1+|oldHeight|)^(2*J)* + (∫ξ : ℝ,‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^J)^2 := by + dsimp only + let F:=InitialMeanSquare.outsideSquarefreeIdeals S D + have hF:=InitialMeanSquare.outsideSquarefree_admissible S D hbad + let : ∀i : primePool F,(Ideal.span {poolPrimary F i}).IsMaximal := + fun i=>by rw [poolPrimary_span F hF i];infer_instance + intro hsource + let T:=E*(1+|oldHeight|)^(2*J)*(∫ξ : ℝ,‖reopeningCoefficient W a b ha hs hW ξ‖*(1+|ξ|)^J)^2 + have hT : 0≤T := by dsimp only [T];positivity + let binEnergy:=fun j=>rowFamilyEnergy labels (fun I z=> + outsideCanonicalBin S D hbad (activeCubeLogBin S D b X j) (normHeightTwist Ψ oldHeight) + m (idealGenerator I) z W X H₀) K + have hbin (j : ℕ) (hj : j∈cubeLogRange b X) : X*binEnergy j≤T := by + by_cases hnon : (progressingCubes S D H₀ (activeCubeLogBin S D b X j)).Nonempty + · apply progressingCanonicalBin_energy S D hbad (activeCubeLogBin S D b X j) labels Ψ m W + a b ha hs hW V hV (normLogScale j) (X/(normLogScale j)^3) X H₀ K E oldHeight J + (normLogScale_pos j) (div_pos hX (pow_pos (normLogScale_pos j) _)) + (by field_simp [(normLogScale_pos j).ne']) hK hE + (fun v hv=>(activeCubeLogBin_norms S D b X j v hv).1) + (fun v hv=>(activeCubeLogBin_norms S D b X j v hv).2) + exact hsource j hj hnon + · have hempty:=Finset.not_nonempty_iff_eq_empty.mp hnon + have heq : (fun I z=>outsideCanonicalBin S D hbad (activeCubeLogBin S D b X j) + (normHeightTwist Ψ oldHeight) m (idealGenerator I) z W X H₀)=(fun _ _=>0) := by + funext I z + exact outsideCanonicalBin_zero_of_empty_filter S D hbad _ _ m _ z W X H₀ hempty + dsimp only [binEnergy] + rw [heq] + simpa only [rowFamilyEnergy,nonzeroRowMajorantSum,norm_zero,zero_pow (by decide : (2:ℕ)≠0), + Complex.ofReal_zero,mul_zero,ite_self,tsum_zero,Finset.sum_const_zero,Complex.zero_re] using hT + have hsum : X*∑j∈cubeLogRange b X,binEnergy j≤((cubeLogRange b X).card:ℝ)*T := by + simpa only [Finset.mul_sum,Finset.sum_const,nsmul_eq_mul] using Finset.sum_le_sum hbin + have hwhole:=outsideCanonicalRow_family_binned_energy S D hbad hSp (normHeightTwist Ψ oldHeight) + m labels W hWc b X H₀ K hb hX hK (fun x hx=>(hs hx).2) hD + calc + _ ≤ 2*X*(rowFamilyEnergy labels (fun I z=> + shortCompletedSum (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) z) W X H₀) K+ + (cubeLogRange b X).card*∑j∈cubeLogRange b X,binEnergy j) := hwhole + _ = 2*X*rowFamilyEnergy labels (fun I z=> + shortCompletedSum (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) z) W X H₀) K+ + (2*((cubeLogRange b X).card:ℝ))*(X*∑j∈cubeLogRange b X,binEnergy j) := by ring + _ ≤ 2*X*rowFamilyEnergy labels (fun I z=> + shortCompletedSum (rowTwist (normHeightTwist Ψ oldHeight) (m*excludedGenerator S) (idealGenerator I) z) W X H₀) K+ + (2*((cubeLogRange b X).card:ℝ))*(((cubeLogRange b X).card:ℝ)*T) := by gcongr + _ = _ := by dsimp only [T];ring + +end CanonicalRowCompletion + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/FullFrequencyExpansion.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FullFrequencyExpansion.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e4c9089420f792370d37b8022c910c30c49b68b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FullFrequencyExpansion.lean @@ -0,0 +1,598 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.SourceCuspKernels + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open scoped Classical BigOperators + +open ActualEisensteinCubic CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +theorem thetaFullFrequency_tsum (c w : Eis→ℂ) + (hsupp : ∀h:Eis,h≠0→c h≠0→∃p:ThetaFullIndex,thetaFullFrequency p=h) : + (∑'h:{h:Eis // h≠0},w h.val*c h.val)= + ∑'p:ThetaFullIndex,w (thetaFullFrequency p)*c (thetaFullFrequency p) := by + let phi : ThetaFullIndex→{h:Eis // h≠0} := fun p=>⟨thetaFullFrequency p,thetaFullFrequency_ne_zero p⟩ + let f : {h:Eis // h≠0}→ℂ := fun h=>w h.val*c h.val + have hinj : Function.Injective phi := by + intro p q hpq + exact thetaFullFrequency_injective (congrArg Subtype.val hpq) + change (∑'h:{h:Eis // h≠0},f h)=∑'p:ThetaFullIndex,f (phi p) + apply tsum_eq_tsum_of_ne_zero_bij + (fun p:Function.support (fun p:ThetaFullIndex=>f (phi p))=>phi p.val) + · exact hinj.comp Subtype.val_injective + · intro h hh + have hc : c h.val≠0 := by + intro hz + exact hh (by simp only [f,hz,mul_zero]) + obtain ⟨p,hp⟩:=hsupp h.val h.property hc + have hphi : phi p=h := Subtype.ext hp + have hfp : f (phi p)≠0 := by rwa [hphi] + exact ⟨⟨p,hfp⟩,hphi⟩ + · intro p + rfl + +theorem sourceFourier_tsum_full_index (w : Eis→ℂ) : + (∑'h:{h:Eis // h≠0},w h.val*star (sourceResidualFourierCoefficient h.val))= + ∑'p:ThetaFullIndex,w (thetaFullFrequency p)* + star (sourceResidualFourierCoefficient (thetaFullFrequency p)) := by + apply thetaFullFrequency_tsum (fun h => star (sourceResidualFourierCoefficient h)) w + intro h hh hc + have hn : sourceResidualFourierCoefficient h≠0 := by + intro hz + exact hc (by rw [hz,star_zero]) + obtain ⟨u,m,I,J,hsq,hI,hJ,hfactor⟩:= + sourceResidualFourierCoefficient_full_squarefree_cube_support h hh hn + refine ⟨(u,m,(⟨I,hsq,hI⟩,⟨J,hJ⟩)),?_⟩ + exact hfactor.symm + +theorem ramifiedFourier_tsum_full_index (side : Bool) (w : Eis→ℂ) : + (∑'h:{h:Eis // h≠0},w h.val*star (ramifiedBesselValue side h.val))= + ∑'p:ThetaFullIndex,w (thetaFullFrequency p)* + star (ramifiedBesselValue side (thetaFullFrequency p)) := by + apply thetaFullFrequency_tsum (fun h => star (ramifiedBesselValue side h)) w + intro h hh hc + have hn : ramifiedBesselValue side h≠0 := by + intro hz + exact hc (by rw [hz,star_zero]) + obtain ⟨u,m,I,J,hsq,hI,hJ,hfactor⟩:=ramifiedBesselValue_squarefree_cube_support side h hh hn + refine ⟨(u,m,(⟨I,hsq,hI⟩,⟨J,hJ⟩)),?_⟩ + exact hfactor.symm + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma squarefreeCube_scale_le_norm_third (I J:Ideal Eis) + (hI:primaryGenerator I≠0) (u:Eisˣ) (m:ℕ) : + (3:ℝ)^((m:ℝ)/6)*‖eisEmbedding (primaryGenerator J)‖≤ + ‖eisEmbedding ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)‖^(1/3:ℝ) := by + have hn:1≤‖eisEmbedding (primaryGenerator I)‖:=cubePrime_norm_ge_one _ hI + have hn':1≤‖eisEmbedding (primaryGenerator I)‖^(1/3:ℝ):= + Real.one_le_rpow hn (by norm_num) + have hb:(‖eisEmbedding (primaryGenerator J)‖^3)^(1/3:ℝ)=‖eisEmbedding (primaryGenerator J)‖:=by + rw [←Real.rpow_natCast_mul (norm_nonneg _)] + norm_num + have he:‖eisEmbedding ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)‖^(1/3:ℝ)= + (3:ℝ)^((m:ℝ)/6)*‖eisEmbedding (primaryGenerator I)‖^(1/3:ℝ)* + ‖eisEmbedding (primaryGenerator J)‖:=by + rw [map_mul,map_mul,map_pow,norm_mul,norm_mul,norm_pow, + Real.mul_rpow (mul_nonneg (norm_nonneg _) (norm_nonneg _)) (pow_nonneg (norm_nonneg _) _), + Real.mul_rpow (norm_nonneg _) (norm_nonneg _),ramified_norm_third,hb] + rw [he] + have hscale:0≤(3:ℝ)^((m:ℝ)/6):=Real.rpow_nonneg (by norm_num) _ + have hbn:0≤‖eisEmbedding (primaryGenerator J)‖:=norm_nonneg _ + exact mul_le_mul_of_nonneg_right (le_mul_of_one_le_right hscale hn') hbn + +lemma coefficient_polynomial_of_squarefree_cube_support (F:Eis→ℂ) (C:ℝ) (hC:0≤C) + (hsupport:∀h:Eis,h≠0→F h≠0→∃(u:Eisˣ) (m:ℕ) (I J:Ideal Eis),Squarefree I ∧ + primaryGenerator I≠0 ∧ primaryGenerator J≠0 ∧ + h=(u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3) + (hbound:∀(I J:Ideal Eis),primaryGenerator I≠0→primaryGenerator J≠0→Squarefree I→ + ∀(u:Eisˣ) (m:ℕ), + ‖F ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)‖≤ + C*(3:ℝ)^((m:ℝ)/6)*‖eisEmbedding (primaryGenerator J)‖) + (h:Eis) (hh:h≠0) : ‖F h‖≤C*‖eisEmbedding h‖^(1/3:ℝ) := by + by_cases hz:F h=0 + · rw [hz,norm_zero] + positivity + obtain ⟨u,m,I,J,hsq,hI,hJ,rfl⟩:=hsupport h hh hz + refine (hbound I J hI hJ hsq u m).trans ?_ + have hb:=mul_le_mul_of_nonneg_left (squarefreeCube_scale_le_norm_third I J hI u m) hC + exact (by simpa only [mul_assoc] using hb) + +theorem three_cusp_coefficients_polynomial_bound : + ∃C:ℝ,0(hbound I J hI hJ hsq u m).1) h hh + · intro side + exact coefficient_polynomial_of_squarefree_cube_support (ramifiedBesselValue side) C hC.le + (ramifiedBesselValue_squarefree_cube_support side) + (fun I J hI hJ hsq u m=>(hbound I J hI hJ hsq u m).2 side) h hh + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma coefficient_weighted_summable_of_polynomial (F:Eis→ℂ) (C:ℝ) (hC:0≤C) + (hF:∀h:Eis,h≠0→‖F h‖≤C*‖eisEmbedding h‖^(1/3:ℝ)) : + Summable (fun h:Eis=>if h=0 then (0:ℝ) else ‖F h‖*‖cuspFrequency h‖^(-4:ℝ)) := by + let D:ℝ:=‖(3:ℂ)*eisLam‖ + have hD:0(C/D^(-4:ℝ))*‖eisEmbedding h‖^(-(11/3):ℝ)):= + (summable_embedding_rpow (-(11/3):ℝ) (by norm_num)).mul_left _ + apply Summable.of_nonneg_of_le (fun h=>by split_ifs <;> positivity) _ hs + intro h + split_ifs with hh + · exact mul_nonneg (div_nonneg hC hDp.le) (Real.rpow_nonneg (norm_nonneg _) _) + · have hx:0<‖eisEmbedding h‖:=norm_pos_iff.mpr (eisEmbedding_ne_zero hh) + have he:‖eisEmbedding h‖^(1/3:ℝ)*‖eisEmbedding h‖^(-4:ℝ)= + ‖eisEmbedding h‖^(-(11/3):ℝ):=by + rw [←Real.rpow_add hx] + congr 1 + norm_num + calc + _≤(C*‖eisEmbedding h‖^(1/3:ℝ))*‖cuspFrequency h‖^(-4:ℝ):= + mul_le_mul_of_nonneg_right (hF h hh) (Real.rpow_nonneg (norm_nonneg _) _) + _=(C/D^(-4:ℝ))*(‖eisEmbedding h‖^(1/3:ℝ)*‖eisEmbedding h‖^(-4:ℝ)):=by + rw [cuspFrequency,norm_div,Real.div_rpow (norm_nonneg _) (norm_nonneg _)] + change (C*‖eisEmbedding h‖^(1/3:ℝ))*(‖eisEmbedding h‖^(-4:ℝ)/D^(-4:ℝ))=_ + ring + _=_:=by rw [he] + +theorem three_cusp_coefficients_weighted_summable : + Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖sourceResidualFourierCoefficient h‖*‖cuspFrequency h‖^(-4:ℝ)) ∧ + ∀side:Bool,Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖ramifiedBesselValue side h‖*‖cuspFrequency h‖^(-4:ℝ)) := by + obtain ⟨C,hC,hbound⟩:=three_cusp_coefficients_polynomial_bound + constructor + · exact coefficient_weighted_summable_of_polynomial _ C hC.le (fun h hh=>(hbound h hh).1) + · intro side + exact coefficient_weighted_summable_of_polynomial _ C hC.le (fun h hh=>(hbound h hh).2 side) + +lemma derivative_coefficient_weighted_summable (F:Eis→ℂ) (A:ℂ) + (hF:Summable (fun h:Eis=>if h=0 then (0:ℝ) else ‖F h‖*‖cuspFrequency h‖^(-4:ℝ))) : + Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖A*cuspFrequency h*star (F h)‖*‖cuspFrequency h‖^(-5:ℝ)) := by + apply (hF.mul_left ‖A‖).congr + intro h + split_ifs with hh + · simp + · have hx:0<‖cuspFrequency h‖:=norm_pos_iff.mpr (cuspFrequency_ne_zero h hh) + have hp:‖cuspFrequency h‖*‖cuspFrequency h‖^(-5:ℝ)=‖cuspFrequency h‖^(-4:ℝ):=by + conv_lhs => lhs; rw [←Real.rpow_one ‖cuspFrequency h‖] + rw [←Real.rpow_add hx] + norm_num + rw [norm_mul,norm_mul,norm_star] + calc + _=‖A‖*‖F h‖*(‖cuspFrequency h‖*‖cuspFrequency h‖^(-5:ℝ)):=by rw [hp];ring + _=_:=by ring + +theorem three_cusp_derivative_coefficients_weighted_summable (A:ℂ) : + Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖A*cuspFrequency h*star (sourceResidualFourierCoefficient h)‖*‖cuspFrequency h‖^(-5:ℝ)) ∧ + ∀side:Bool,Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖A*cuspFrequency h*star (ramifiedBesselValue side h)‖*‖cuspFrequency h‖^(-5:ℝ)) := + ⟨derivative_coefficient_weighted_summable _ A three_cusp_coefficients_weighted_summable.1, + fun side=>derivative_coefficient_weighted_summable _ A (three_cusp_coefficients_weighted_summable.2 side)⟩ + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma radial_inverse_weight (x:ℝ) (hx:0if h=0 then (0:ℝ) else ‖F h‖*‖cuspFrequency h‖^(-4:ℝ))) : + Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖A*cuspFrequency h*star (F h)/((‖eisEmbedding h‖^2:ℝ):ℂ)‖* + (‖eisEmbedding h‖^2)^(-(3/2):ℝ)) := by + let D:ℝ:=‖(3:ℂ)*eisLam‖ + have hD:0if h=0 then (0:ℝ) else + ‖A*cuspFrequency h*star (sourceResidualFourierCoefficient h)/((‖eisEmbedding h‖^2:ℝ):ℂ)‖* + (‖eisEmbedding h‖^2)^(-(3/2):ℝ)) ∧ + ∀side:Bool,Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖A*cuspFrequency h*star (ramifiedBesselValue side h)/((‖eisEmbedding h‖^2:ℝ):ℂ)‖* + (‖eisEmbedding h‖^2)^(-(3/2):ℝ)) := + ⟨radialCoefficient_weighted_summable_of_fourth _ A three_cusp_coefficients_weighted_summable.1, + fun side=>radialCoefficient_weighted_summable_of_fourth _ A (three_cusp_coefficients_weighted_summable.2 side)⟩ + +end + +open ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma sourceCuspCoefficients_weighted_summable (j:Fin 3) : + Summable (fun h:Eis=>if h=0 then (0:ℝ) else + ‖(sourceCuspCoefficients j).value h‖*‖cuspFrequency h‖^(-4:ℝ)) := by + fin_cases j + · exact three_cusp_coefficients_weighted_summable.1 + · exact three_cusp_coefficients_weighted_summable.2 false + · exact three_cusp_coefficients_weighted_summable.2 true + +theorem sourceCuspRadialCoefficient_weighted_summable (j:Fin 3) (z:ℂ) : + Summable (fun h:Eis=>‖sourceCuspRadialCoefficient j z h‖* + (sourceCuspRadialLength h)^(-(3/2):ℝ)) := by + let A:ℂ:=(-2*Real.pi*Complex.I)/(sourceCuspScale j:ℂ)^2 + have hs:=radialCoefficient_weighted_summable_of_fourth (sourceCuspCoefficients j).value A + (sourceCuspCoefficients_weighted_summable j) + apply hs.congr + intro h + by_cases hh:h=0 + · subst h + simp only [ite_true,sourceCuspRadialCoefficient_zero,norm_zero,zero_mul] + · rw [ite_eq_right hh,sourceCuspRadialCoefficient_norm,sourceCuspRadialBaseCoefficient, + sourceCuspRadialLength,ite_eq_right hh] + congr 1 + apply congrArg norm + dsimp only [A] + simp only [div_eq_mul_inv,mul_inv_rev] + ring + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff MatrixGroups + +section +open CompletedGauss ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma SourceCuspDatum.cuspBarProfile_mellin_entire (d : SourceCuspDatum) : + (∀s:ℂ,MellinConvergent (cuspBarProfile cubicSourceConjugateFunction d.point) s) ∧ + Differentiable ℂ (mellin (cuspBarProfile cubicSourceConjugateFunction d.point)) := + (conjugateSource_levelTwo_three_cusp_mellin_entire d.gamma d.index d.matrix rfl d.lower_ne_zero).1 + +lemma SourceCuspDatum.reflection_radial (d : SourceCuspDatum) (v:ℝ) (hv:0 ActualEisensteinCubic.O + +lemma thetaBesselScale_square : thetaBesselScale^2=(1/27:ℝ) := by + rw [thetaBesselScale_eq,div_pow,one_pow,Real.sq_sqrt (by norm_num)] + +lemma sourceCuspRadialScale_ratio (j:Fin 3) : + thetaBesselScale/sourceCuspRadialScale j=sourceCuspScale j := by + rw [sourceCuspRadialScale] + field_simp [thetaBesselScale_pos.ne'] + +lemma sourceCuspKernel_argument (j:Fin 3) (X r Q:ℝ) : + 27*thetaBesselScale^2*(sourceCuspRadialScale j)^2*X*r/Q^2= + X*r/(27*(sourceCuspScale j)^2*Q^2) := by + rw [sourceCuspRadialScale,div_pow,thetaBesselScale_square] + ring + +lemma SourceCuspDatum.smoothedKernel_eq (d:SourceCuspDatum) (W:ℝ→ℂ) (X:ℝ) : + d.smoothedKernel W X= + (d.multiplier*(d.heightScale:ℂ)*(sourceCuspScale d.index:ℂ)^2)* + ∑'n:Eis,sourceCuspRadialCoefficient d.index d.dualPoint n* + CubicReflectionKernel.paperKernel (Vstar W) + (X*sourceCuspRadialLength n/(27*(sourceCuspScale d.index)^2*d.heightScale^2)) := by + simp only [SourceCuspDatum.smoothedKernel,sourceCuspRadialScale_ratio,sourceCuspKernel_argument] + +lemma SourceCuspDatum.smoothedKernel_prefactor_norm (d:SourceCuspDatum) : + ‖d.multiplier*(d.heightScale:ℂ)*(sourceCuspScale d.index:ℂ)^2‖= + (sourceCuspScale d.index)^2 := by + rw [norm_mul,norm_mul,norm_pow,d.multiplier_norm,Complex.norm_real,Complex.norm_real, + Real.norm_eq_abs,Real.norm_eq_abs,abs_of_pos d.heightScale_pos,abs_of_pos (sourceCuspScale_pos _)] + rw [inv_mul_cancel₀ d.heightScale_pos.ne',one_mul] + +lemma SourceCuspDatum.smoothedKernel_prefactor_norm_le (d:SourceCuspDatum) : + ‖d.multiplier*(d.heightScale:ℂ)*(sourceCuspScale d.index:ℂ)^2‖≤9 := by + rw [d.smoothedKernel_prefactor_norm] + rcases d with ⟨G,j,hj⟩ + fin_cases j <;> norm_num [sourceCuspScale] + +end + +open CompletedGauss ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +theorem completedT_finite_smoothed_reflection + (Ψ:Eis→*ℂ) (hΨ:∀x,‖Ψ x‖≤1) + (Q:Ideal Eis) (hperiod:CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) + (d:(Eis⧸Ideal.span {c})→SourceCuspDatum) + (hd:∀h,(d h).point=thetaFourierTranslation c h) + (W:ℝ→ℂ) (v0 v1:ℝ) (hv0:0 + cuspBarProfile cubicSourceConjugateFunction (d h).point + let w:(Eis⧸Ideal.span {c})→ℂ:=fun h=>thetaDerivativeScalar⁻¹* + finiteAdditiveFourierCoeff (quotientTrace c hc) (fixedThetaQuotient Ψ c) h + have hFG:∀v:ℝ,0 + besselSmoothingIntegrand (G h) thetaBesselScale (Vstar W) X ((-1:ℂ)+t*Complex.I) + have hi (h:Eis⧸Ideal.span {c}) : Integrable (J h):= + besselSmoothingIntegrand_reflected_integrable (G h) sourceCuspRadialLength + sourceCuspRadialLength_pos (sourceCuspRadialCoefficient (d h).index (d h).dualPoint) + thetaBesselScale (sourceCuspRadialScale (d h).index) (d h).heightScale + thetaBesselScale_pos (sourceCuspRadialScale_pos _) (d h).heightScale_pos + (d h).multiplier (d h).reflection_radial + (sourceCuspRadialCoefficient_weighted_summable _ _) (Vstar W) v0 v1 hv0 hVs hV X hX + have hireal (h:Eis⧸Ideal.span {c}) : Integrable (fun t:ℝ=> + besselSmoothingIntegrand (G h) thetaBesselScale (Vstar W) X (((-1:ℝ):ℂ)+t*Complex.I)):=by + simpa only [Complex.ofReal_neg,Complex.ofReal_one,J] using hi h + have hleft:=besselSmoothingIntegrand_finite_integrable + (completedBesselProfile Ψ thetaBesselScale) G w hFG thetaBesselScale (Vstar W) X (-1) + (fun h t=>hG h _) hireal + have hshift:=completedT_mellin_shift Ψ hΨ thetaBesselScale thetaBesselScale_pos hF.1 hF.2 + W v0 v1 hv0 hWs hW X hX (-1) (by norm_num) hleft + have hline (h:Eis⧸Ideal.span {c}) : (1/(2*Real.pi):ℂ)*(∫t:ℝ,J h t)=(d h).smoothedKernel W X:=by + exact besselSmoothingIntegral_reflected_kernel (G h) sourceCuspRadialLength + sourceCuspRadialLength_pos (sourceCuspRadialCoefficient (d h).index (d h).dualPoint) + thetaBesselScale (sourceCuspRadialScale (d h).index) (d h).heightScale + thetaBesselScale_pos (sourceCuspRadialScale_pos _) (d h).heightScale_pos + (d h).multiplier (d h).reflection_radial + (sourceCuspRadialCoefficient_weighted_summable _ _) (Vstar W) v0 v1 hv0 hVs hV X hX + calc + _=(1/(2*Real.pi):ℂ)*∫t:ℝ, + besselSmoothingIntegrand (completedBesselProfile Ψ thetaBesselScale) + thetaBesselScale (Vstar W) X ((-1:ℂ)+t*Complex.I):=by + simpa only [Complex.ofReal_neg,Complex.ofReal_one] using hshift + _=(1/(2*Real.pi):ℂ)*∫t:ℝ,∑h,w h*J h t:=by + congr 1 + apply integral_congr_ae + filter_upwards with t + exact besselSmoothingIntegrand_finite_sum + (completedBesselProfile Ψ thetaBesselScale) G w hFG thetaBesselScale (Vstar W) X _ + (fun h=>hG h _) + _=∑h,w h*((1/(2*Real.pi):ℂ)*∫t:ℝ,J h t):=by + rw [integral_finsetSum Finset.univ (fun h _=>(hi h).const_mul (w h)),Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + rw [integral_const_mul] + ring + _=∑h,w h*(d h).smoothedKernel W X:=by simp_rw [hline] + _=_:=by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro h hh + dsimp only [w] + ring + +theorem completedT_canonical_smoothed_reflection + (Ψ:Eis→*ℂ) (hΨ:∀x,‖Ψ x‖≤1) + (Q:Ideal Eis) (hperiod:CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c:Eis) (hc:c≠0) [Fintype (Eis⧸Ideal.span {c})] + (hcQ:Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) + (W:ℝ→ℂ) (v0 v1:ℝ) (hv0:0 ActualEisensteinCubic.O + +def fixedCuspReduction : SL(2,Eis) →* SL(2,Eis⧸Ideal.span {(3:Eis)}) := + Matrix.SpecialLinearGroup.map (n:=Fin 2) (Ideal.Quotient.mk (Ideal.span {(3:Eis)})) + +abbrev FixedCuspSector := fixedCuspReduction.range + +instance : Finite FixedCuspSector := by + let : Finite (Eis⧸Ideal.span {(3:Eis)}) := finite_quotient_span (by norm_num : (3:Eis)≠0) + infer_instance + +def fixedCuspSector (M : SL(2,Eis)) : FixedCuspSector := + ⟨fixedCuspReduction M,⟨M,rfl⟩⟩ + +def fixedCuspRepresentative (s : FixedCuspSector) : SL(2,Eis) := s.property.choose + +lemma fixedCuspRepresentative_reduction (s : FixedCuspSector) : + fixedCuspReduction (fixedCuspRepresentative s)=s.val := s.property.choose_spec + +lemma fixedCusp_difference_levelThree (M : SL(2,Eis)) : + M*(fixedCuspRepresentative (fixedCuspSector M))⁻¹∈levelThree := by + change fixedCuspReduction (M*(fixedCuspRepresentative (fixedCuspSector M))⁻¹)=1 + rw [map_mul,map_inv,fixedCuspRepresentative_reduction] + change fixedCuspReduction M*(fixedCuspReduction M)⁻¹=1 + exact mul_inv_cancel _ + +theorem exists_fixed_cusp_decomposition : + ∃(j:FixedCuspSector→Fin 3) (T:FixedCuspSector→SL(2,Eis)) + (G:SL(2,Eis)→levelTwo), + (∀s,T s 1 0=0 ∧ IsUnit (T s 0 0) ∧ IsUnit (T s 1 1)) ∧ + ∀M:SL(2,Eis),M=(G M:SL(2,Eis))*cuspRepresentative (j (fixedCuspSector M))* + T (fixedCuspSector M) := by + have h (s:FixedCuspSector) := three_cusp_decomposition (fixedCuspRepresentative s) + choose G0 j T hT hT0 hT1 he using h + let D : SL(2,Eis)→levelTwo := fun M=> + ⟨M*(fixedCuspRepresentative (fixedCuspSector M))⁻¹, + levelThree_le_levelTwo (fixedCusp_difference_levelThree M)⟩ + refine ⟨j,T,fun M=>D M*G0 (fixedCuspSector M),fun s=>⟨hT s,hT0 s,hT1 s⟩,?_⟩ + intro M + change M=(M*(fixedCuspRepresentative (fixedCuspSector M))⁻¹)* + (G0 (fixedCuspSector M):SL(2,Eis))*cuspRepresentative (j (fixedCuspSector M))*T (fixedCuspSector M) + rw [he (fixedCuspSector M)] + group + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/FundamentalDomain.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FundamentalDomain.lean new file mode 100644 index 0000000000000000000000000000000000000000..40035615383b1b535b7d9c9ae666f15f466bcb95 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/FundamentalDomain.lean @@ -0,0 +1,744 @@ +import OAI.NumberTheory.DirichletL.QuadraticSieve.GlobalBinLoss + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Matrix + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "O" => ActualEisensteinCubic.O + +def integralRowPair (M : SL(2,O)) : (Fin 2 → O)×(Fin 2 → O) := + (fun j => M 0 j,fun j => M 1 j) + +lemma integralRowPair_injective : Function.Injective integralRowPair := by + intro M N h + apply Subtype.ext + funext i j + fin_cases i + · exact congrFun (congrArg Prod.fst h) j + · exact congrFun (congrArg Prod.snd h) j + +lemma matrixFrobenius_integral (M : SL(2,O)) (g : SL(2,ℂ)) : + matrixFrobenius (integralComplexMatrix M*g)= + integralRowEnergy g (integralRowPair M).1+integralRowEnergy g (integralRowPair M).2 := by + rw [matrixFrobenius,complexMatrixRow_mul,complexMatrixRow_mul] + rfl + +lemma integralRowEnergy_nonneg (g : SL(2,ℂ)) (v : Fin 2 → O) : 0 ≤ integralRowEnergy g v := by + unfold integralRowEnergy rowEnergy + positivity + +theorem integral_frobenius_sublevel_finite (g : SL(2,ℂ)) (C : ℝ) : + Set.Finite {M : SL(2,O) | matrixFrobenius (integralComplexMatrix M*g)≤C} := by + have hs := integralRowEnergy_sublevel_finite g C + apply (Set.Finite.preimage integralRowPair_injective.injOn (hs.prod hs)).subset + intro M hM + change integralRowEnergy g (integralRowPair M).1≤C ∧ integralRowEnergy g (integralRowPair M).2≤C + change matrixFrobenius (integralComplexMatrix M*g)≤C at hM + rw [matrixFrobenius_integral] at hM + exact ⟨by linarith [integralRowEnergy_nonneg g (integralRowPair M).2], + by linarith [integralRowEnergy_nonneg g (integralRowPair M).1]⟩ + +theorem integral_hyperbolic_sublevel_finite (w : HyperbolicSpace) (C : ℝ) : + Set.Finite {M : SL(2,O) | hyperbolicFrobenius (integralComplexMatrix M • w)≤C} := by + induction w using Quotient.inductionOn with | _ g => + exact integral_frobenius_sublevel_finite g C + +theorem subgroup_hyperbolic_sublevel_finite (H : Subgroup (SL(2,O))) + (w : HyperbolicSpace) (C : ℝ) : + Set.Finite {M : H | hyperbolicFrobenius (integralComplexMatrix (M:SL(2,O)) • w)≤C} := by + exact Set.Finite.preimage Subtype.val_injective.injOn (integral_hyperbolic_sublevel_finite w C) + +theorem subgroup_orbit_minimum (H : Subgroup (SL(2,O))) (w : HyperbolicSpace) : + ∃M : H,∀N : H, + hyperbolicFrobenius (integralComplexMatrix (M:SL(2,O)) • w)≤ + hyperbolicFrobenius (integralComplexMatrix (N:SL(2,O)) • w) := by + let S : Set H := {M | hyperbolicFrobenius (integralComplexMatrix (M:SL(2,O)) • w)≤hyperbolicFrobenius w} + have hs : Set.Finite S := subgroup_hyperbolic_sublevel_finite H w _ + have hne : S.Nonempty := ⟨1,by simp [S]⟩ + obtain ⟨M,hM,hmin⟩ := Set.exists_min_image S + (fun M : H => hyperbolicFrobenius (integralComplexMatrix (M:SL(2,O)) • w)) hs hne + refine ⟨M,fun N => ?_⟩ + by_cases hN : N∈S + · exact hmin N hN + · exact hM.trans (le_of_lt (lt_of_not_ge hN)) + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "O" => ActualEisensteinCubic.O + +lemma integralComplexMatrix_injective : Function.Injective integralComplexMatrix := by + intro M N h + apply Subtype.ext + funext i j + apply eisEmbedding_injective + exact congrArg (fun A : SL(2,ℂ) => A i j) h + +lemma levelThree_trace_divisible_nine (M : levelThree) : + (9:O)∣((M:SL(2,O)) 0 0+(M:SL(2,O)) 1 1-2) := by + have ha : (3:O)∣((M:SL(2,O)) 0 0-1) := by simpa using levelThree_entry M 0 0 + have hd : (3:O)∣((M:SL(2,O)) 1 1-1) := by simpa using levelThree_entry M 1 1 + have hb : (3:O)∣(M:SL(2,O)) 0 1 := by simpa using levelThree_entry M 0 1 + have hc : (3:O)∣(M:SL(2,O)) 1 0 := by simpa using levelThree_entry M 1 0 + have hdet : (M:SL(2,O)) 0 0*(M:SL(2,O)) 1 1-(M:SL(2,O)) 0 1*(M:SL(2,O)) 1 0=1 := by + simpa only [Matrix.det_fin_two] using (M:SL(2,O)).property + have he : (M:SL(2,O)) 0 0+(M:SL(2,O)) 1 1-2= + (M:SL(2,O)) 0 1*(M:SL(2,O)) 1 0- + ((M:SL(2,O)) 0 0-1)*((M:SL(2,O)) 1 1-1) := by linear_combination hdet + rw [he] + exact dvd_sub (by simpa only [show (3:O)*3=9 by ring] using mul_dvd_mul hb hc) (by simpa only [show (3:O)*3=9 by ring] using mul_dvd_mul ha hd) + +lemma unitary_row_normSq (k : SL(2,ℂ)) (hk : k∈compactSubgroup) (i : Fin 2) : + Complex.normSq (k i 0)+Complex.normSq (k i 1)=1 := by + have hu := Matrix.mem_unitaryGroup_iff.mp hk + have he := congrArg (fun A : Matrix (Fin 2) (Fin 2) ℂ => (A i i).re) hu + simp only [Matrix.mul_apply,Fin.sum_univ_two,Matrix.star_apply,Matrix.one_apply_eq, + Complex.add_re,Complex.mul_re,Complex.star_def,Complex.conj_re,Complex.conj_im,Complex.one_re] at he + simp only [Complex.normSq_apply] + nlinarith + +lemma unitary_trace_norm_le_two (k : SL(2,ℂ)) (hk : k∈compactSubgroup) : ‖k 0 0+k 1 1‖≤2 := by + have h0 := unitary_row_normSq k hk 0 + have h1 := unitary_row_normSq k hk 1 + have ha : ‖k 0 0‖≤1 := by + rw [Complex.normSq_eq_norm_sq] at h0 + nlinarith [norm_nonneg (k 0 0),Complex.normSq_nonneg (k 0 1)] + have hd : ‖k 1 1‖≤1 := by + rw [Complex.normSq_eq_norm_sq,Complex.normSq_eq_norm_sq] at h1 + nlinarith [norm_nonneg (k 1 1),sq_nonneg ‖k 1 0‖] + exact (norm_add_le _ _).trans (by linarith) + +lemma unitary_trace_two_eq_one (k : SL(2,ℂ)) (hk : k∈compactSubgroup) + (ht : k 0 0+k 1 1=2) : k=1 := by + have h0 := unitary_row_normSq k hk 0 + have h1 := unitary_row_normSq k hk 1 + have htR := congrArg Complex.re ht + norm_num [Complex.add_re] at htR + have hs : Complex.normSq (k 0 0-1)+Complex.normSq (k 0 1)+ + Complex.normSq (k 1 0)+Complex.normSq (k 1 1-1)=0 := by + simp only [Complex.normSq_apply,Complex.sub_re,Complex.one_re,Complex.sub_im,Complex.one_im,sub_zero] at * + nlinarith + have ha : k 0 0=1 := sub_eq_zero.mp (Complex.normSq_eq_zero.mp (by + nlinarith [Complex.normSq_nonneg (k 0 0-1),Complex.normSq_nonneg (k 0 1), + Complex.normSq_nonneg (k 1 0),Complex.normSq_nonneg (k 1 1-1)])) + have hb : k 0 1=0 := Complex.normSq_eq_zero.mp (by + nlinarith [Complex.normSq_nonneg (k 0 0-1),Complex.normSq_nonneg (k 0 1), + Complex.normSq_nonneg (k 1 0),Complex.normSq_nonneg (k 1 1-1)]) + have hc : k 1 0=0 := Complex.normSq_eq_zero.mp (by + nlinarith [Complex.normSq_nonneg (k 0 0-1),Complex.normSq_nonneg (k 0 1), + Complex.normSq_nonneg (k 1 0),Complex.normSq_nonneg (k 1 1-1)]) + have hd : k 1 1=1 := sub_eq_zero.mp (Complex.normSq_eq_zero.mp (by + nlinarith [Complex.normSq_nonneg (k 0 0-1),Complex.normSq_nonneg (k 0 1), + Complex.normSq_nonneg (k 1 0),Complex.normSq_nonneg (k 1 1-1)])) + apply Subtype.ext + funext i j + fin_cases i <;> fin_cases j <;> simpa using (by first | exact ha | exact hb | exact hc | exact hd) + +lemma matrix_trace_conjugate (g h : SL(2,ℂ)) : + (g⁻¹*h*g) 0 0+(g⁻¹*h*g) 1 1=h 0 0+h 1 1 := by + have ht := Matrix.trace_mul_cycle + (((g⁻¹:SL(2,ℂ)):Matrix (Fin 2) (Fin 2) ℂ)) + (h:Matrix (Fin 2) (Fin 2) ℂ) (g:Matrix (Fin 2) (Fin 2) ℂ) + have hi : (g:Matrix (Fin 2) (Fin 2) ℂ)*(((g⁻¹:SL(2,ℂ)):Matrix (Fin 2) (Fin 2) ℂ))=1 := + congrArg (fun A : SL(2,ℂ) => (A:Matrix (Fin 2) (Fin 2) ℂ)) (mul_inv_cancel g) + rw [hi,Matrix.one_mul] at ht + simpa only [Matrix.SpecialLinearGroup.coe_mul,Matrix.trace,Matrix.diag_apply,Fin.sum_univ_two] using ht + +lemma levelThree_unitary_conjugate_eq_one (M : levelThree) (g : SL(2,ℂ)) + (hk : g⁻¹*complexMatrix M*g∈compactSubgroup) : M=1 := by + let k := g⁻¹*complexMatrix M*g + have htr := matrix_trace_conjugate g (complexMatrix M) + have hnorm : ‖complexMatrix M 0 0+complexMatrix M 1 1-2‖≤4 := by + have hb := unitary_trace_norm_le_two k hk + rw [htr] at hb + have hn := norm_sub_le (complexMatrix M 0 0+complexMatrix M 1 1) (2:ℂ) + norm_num at hn + linarith + obtain ⟨a,ha⟩ := levelThree_trace_divisible_nine M + have hmap : complexMatrix M 0 0+complexMatrix M 1 1-2=(9:ℂ)*eisEmbedding a := by + change eisEmbedding ((M:SL(2,O)) 0 0)+eisEmbedding ((M:SL(2,O)) 1 1)-2=(9:ℂ)*eisEmbedding a + simpa only [map_add,map_sub,map_ofNat,map_mul] using congrArg eisEmbedding ha + have haz : a=0 := by + by_contra hne + have hn := one_le_normSq_embedding a hne + rw [Complex.normSq_eq_norm_sq] at hn + have hn1 : 1≤‖eisEmbedding a‖ := by nlinarith [norm_nonneg (eisEmbedding a)] + rw [hmap,norm_mul] at hnorm + norm_num at hnorm + linarith + have ht2 : k 0 0+k 1 1=2 := by + rw [htr] + apply sub_eq_zero.mp + rw [hmap,haz,map_zero,mul_zero] + have hk1 : k=1 := unitary_trace_two_eq_one k hk ht2 + have hM1 : complexMatrix M=1 := by + have h := congrArg (fun A : SL(2,ℂ) => g*A*g⁻¹) hk1 + simpa [k,mul_assoc] using h + apply Subtype.ext + apply integralComplexMatrix_injective + simpa only [map_one,integralComplexMatrix_levelThree] using hM1 + +theorem levelThree_action_free (M : levelThree) (w : HyperbolicSpace) + (hw : complexMatrix M • w=w) : M=1 := by + induction w using Quotient.inductionOn with | _ g => + apply levelThree_unitary_conjugate_eq_one M g + have hrel := QuotientGroup.leftRel_apply.mp (Quotient.exact' hw.symm) + simpa only [mul_assoc,smul_eq_mul] using hrel + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "O" => ActualEisensteinCubic.O + +def hyperbolicKeyCoordinates (w : HyperbolicSpace) : Fin 9 → ℝ := + ![hyperbolicFrobenius w,(hyperbolicGram w 0 0).re,(hyperbolicGram w 0 0).im, + (hyperbolicGram w 0 1).re,(hyperbolicGram w 0 1).im, + (hyperbolicGram w 1 0).re,(hyperbolicGram w 1 0).im, + (hyperbolicGram w 1 1).re,(hyperbolicGram w 1 1).im] + +def hyperbolicOrderKey (w : HyperbolicSpace) : Lex (Fin 9 → ℝ) := toLex (hyperbolicKeyCoordinates w) + +lemma hyperbolicOrderKey_injective : Function.Injective hyperbolicOrderKey := by + intro w u h + have hc : hyperbolicKeyCoordinates w=hyperbolicKeyCoordinates u := congrArg ofLex h + apply hyperbolicGram_injective + funext i j + fin_cases i <;> fin_cases j <;> apply Complex.ext + · exact congrFun hc 1 + · exact congrFun hc 2 + · exact congrFun hc 3 + · exact congrFun hc 4 + · exact congrFun hc 5 + · exact congrFun hc 6 + · exact congrFun hc 7 + · exact congrFun hc 8 + +lemma hyperbolicOrderKey_lt_of_frobenius {w u : HyperbolicSpace} + (h : hyperbolicFrobenius w hyperbolicKeyCoordinates w i) := by + fin_cases i <;> simp only [hyperbolicKeyCoordinates] <;> fun_prop + +lemma hyperbolicOrderKey_lt_measurable {X : Type*} [TopologicalSpace X] [MeasurableSpace X] + [BorelSpace X] (f g : X → HyperbolicSpace) (hf : Continuous f) (hg : Continuous g) : + MeasurableSet {x | hyperbolicOrderKey (f x) not_lt_of_ge h,fun h => le_of_not_gt h⟩ + rw [he] + exact (hyperbolicOrderKey_lt_measurable g f hg hf).compl + +instance integralSLCountable : Countable (SL(2,O)) := by + let : Countable O := latticeCoordEquiv.injective.countable + let : Countable (Matrix (Fin 2) (Fin 2) O) := inferInstanceAs (Countable (Fin 2 → Fin 2 → O)) + exact inferInstanceAs (Countable {A : Matrix (Fin 2) (Fin 2) O // A.det=1}) + +instance integralSubgroupHyperbolicAction (H : Subgroup (SL(2,O))) : MulAction H HyperbolicSpace := + MulAction.compHom HyperbolicSpace (integralComplexMatrix.comp H.subtype) + +lemma integralSubgroup_smul (H : Subgroup (SL(2,O))) (M : H) (w : HyperbolicSpace) : + M • w=integralComplexMatrix (M:SL(2,O)) • w := rfl + +def hyperbolicFundamentalSet (H : Subgroup (SL(2,O))) : Set HyperbolicSpace := + {w | ∀M : H,hyperbolicOrderKey w≤hyperbolicOrderKey (M • w)} + +lemma hyperbolicFundamentalSet_measurable (H : Subgroup (SL(2,O))) : + MeasurableSet (hyperbolicFundamentalSet H) := by + unfold hyperbolicFundamentalSet + simp only [Set.ofPred_forall] + apply MeasurableSet.iInter + intro M + exact hyperbolicOrderKey_le_measurable _ _ continuous_id + (continuous_hyperbolic_action (integralComplexMatrix (M:SL(2,O)))) + +lemma exists_key_orbit_minimum (H : Subgroup (SL(2,O))) (w : HyperbolicSpace) : + ∃M : H,∀N : H,hyperbolicOrderKey (M • w)≤hyperbolicOrderKey (N • w) := by + let S : Set H := {M | hyperbolicFrobenius (M • w)≤hyperbolicFrobenius w} + have hs : Set.Finite S := subgroup_hyperbolic_sublevel_finite H w _ + have hne : S.Nonempty := ⟨1,by simp [S]⟩ + obtain ⟨M,hM,hmin⟩ := Set.exists_min_image S (fun M : H => hyperbolicOrderKey (M • w)) hs hne + refine ⟨M,fun N => ?_⟩ + by_cases hN : N∈S + · exact hmin N hN + · apply le_of_lt + apply hyperbolicOrderKey_lt_of_frobenius + exact hM.trans_lt (lt_of_not_ge hN) + +lemma hyperbolicFundamentalSet_covers (H : Subgroup (SL(2,O))) (w : HyperbolicSpace) : + ∃M : H,M • w∈hyperbolicFundamentalSet H := by + obtain ⟨M,hM⟩ := exists_key_orbit_minimum H w + refine ⟨M,fun N => ?_⟩ + simpa only [mul_smul] using hM (N*M) + +lemma hyperbolicFundamentalSet_orbit_unique (H : Subgroup (SL(2,O))) (w : HyperbolicSpace) + (hw : w∈hyperbolicFundamentalSet H) (M : H) + (hMw : M • w∈hyperbolicFundamentalSet H) : M • w=w := by + apply hyperbolicOrderKey_injective + apply le_antisymm + · simpa only [inv_smul_smul] using hMw M⁻¹ + · exact hw M + +lemma subgroup_action_free (H : Subgroup (SL(2,O))) (hH : H≤levelThree) (M : H) + (w : HyperbolicSpace) (hM : M • w=w) : M=1 := by + have he := levelThree_action_free (⟨(M:SL(2,O)),hH M.property⟩ : levelThree) w hM + apply Subtype.ext + exact congrArg (fun N : levelThree => (N:SL(2,O))) he + +theorem hyperbolicFundamentalSet_isFundamentalDomain (H : Subgroup (SL(2,O))) (hH : H≤levelThree) : + IsFundamentalDomain H (hyperbolicFundamentalSet H) hyperbolicVolume := by + apply IsFundamentalDomain.mk' (hyperbolicFundamentalSet_measurable H).nullMeasurableSet + intro w + obtain ⟨M,hM⟩ := hyperbolicFundamentalSet_covers H w + refine ⟨M,hM,fun N hN => ?_⟩ + have he : (N*M⁻¹) • (M • w)=M • w := + hyperbolicFundamentalSet_orbit_unique H (M • w) hM (N*M⁻¹) (by + simpa only [mul_smul,inv_smul_smul] using hN) + have hNM : N*M⁻¹=1 := subgroup_action_free H hH _ _ he + exact mul_inv_eq_one.mp hNM + +lemma globalKubotaKernel_le_levelThree : globalKubotaKernel≤levelThree := by + intro M hM + exact ((globalKubotaKernel_mem M).mp hM).choose + +theorem globalKubotaKernel_isFundamentalDomain : + IsFundamentalDomain globalKubotaKernel (hyperbolicFundamentalSet globalKubotaKernel) hyperbolicVolume := + hyperbolicFundamentalSet_isFundamentalDomain _ globalKubotaKernel_le_levelThree + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "O" => ActualEisensteinCubic.O + +instance integralSubgroupMeasurableAction (H : Subgroup (SL(2,O))) : + MeasurableConstSMul H HyperbolicSpace := + ⟨fun M => (continuous_hyperbolic_action (integralComplexMatrix (M:SL(2,O)))).measurable⟩ + +instance integralSubgroupVolumeInvariant (H : Subgroup (SL(2,O))) : + SMulInvariantMeasure H HyperbolicSpace hyperbolicVolume where + measure_preimage_smul M s hs := by + have hm := (continuous_hyperbolic_action (integralComplexMatrix (M:SL(2,O)))).measurable + have he := congrArg (fun ν : Measure HyperbolicSpace => ν s) + (hyperbolicVolume_invariant (integralComplexMatrix (M:SL(2,O)))) + simpa only [Measure.map_apply hm hs,integralSubgroup_smul] using he + +lemma measurable_integralOrbitProjection (H : Subgroup (SL(2,O))) : + Measurable (integralOrbitProjection H) := measurable_quotient_mk' (s := integralOrbitRel H) + +def integralQuotientVolume (H : Subgroup (SL(2,O))) : Measure (IntegralOrbitQuotient H) := + Measure.map (integralOrbitProjection H) (hyperbolicVolume.restrict (hyperbolicFundamentalSet H)) + +lemma quotient_projection_measurePreserving (H : Subgroup (SL(2,O))) : + MeasurePreserving (integralOrbitProjection H) + (hyperbolicVolume.restrict (hyperbolicFundamentalSet H)) (integralQuotientVolume H) := + ⟨measurable_integralOrbitProjection H,rfl⟩ + +theorem integralQuotientVolume_independent (H : Subgroup (SL(2,O))) (hH : H≤levelThree) + (D : Set HyperbolicSpace) (hD : IsFundamentalDomain H D hyperbolicVolume) : + Measure.map (integralOrbitProjection H) (hyperbolicVolume.restrict D)=integralQuotientVolume H := by + apply Measure.ext + intro S hS + have hp := measurable_integralOrbitProjection H + unfold integralQuotientVolume + rw [Measure.map_apply hp hS,Measure.map_apply hp hS,Measure.restrict_apply (hp hS), + Measure.restrict_apply (hp hS)] + apply hD.measure_set_eq (hyperbolicFundamentalSet_isFundamentalDomain H hH) (hp hS) + intro M + ext w + change integralOrbitProjection H (M • w)∈S ↔ integralOrbitProjection H w∈S + rw [integralSubgroup_smul,integralOrbitProjection_eq] + +lemma integralQuotientVolume_integral (H : Subgroup (SL(2,O))) + (f : IntegralOrbitQuotient H → ℂ) (hf : AEStronglyMeasurable f (integralQuotientVolume H)) : + (∫q,f q∂integralQuotientVolume H)= + ∫w in hyperbolicFundamentalSet H,f (integralOrbitProjection H w)∂hyperbolicVolume := + integral_map (measurable_integralOrbitProjection H).aemeasurable hf + +lemma hyperbolicEuclideanVolume_ne_zero : hyperbolicEuclideanVolume≠0 := by + have hU : IsOpen euclideanUpperHalf := isOpen_lt continuous_const (by fun_prop) + have hne : euclideanUpperHalf.Nonempty := ⟨WithLp.toLp 2 ![0,0,1],by norm_num [euclideanUpperHalf]⟩ + have hpos : 0 ν Set.univ) hz + simp only [Measure.restrict_apply MeasurableSet.univ,Set.univ_inter] at hh + exact hD hh + +abbrev KernelQuotientL2 := Lp ℂ 2 (integralQuotientVolume globalKubotaKernel) +example : InnerProductSpace ℂ KernelQuotientL2 := inferInstance +example : CompleteSpace KernelQuotientL2 := inferInstance + +lemma kernel_eisenstein_invariant (M : globalKubotaKernel) (s : ℂ) (hs : 2 h (by simp [hb,largeCubeCoefficient]) + refine ⟨hB,?_⟩ + rw [largeCubeCoefficient,ite_eq_right hB] at h + obtain ⟨H,hH,hterm⟩ := Finset.exists_ne_zero_of_sum_ne_zero h + have hlarge : H₀ ≤ (Ideal.absNorm H : ℝ) := by + by_contra hn + exact hterm (ite_eq_right hn) + have hdiv := (mem_idealDivisors hB).mp hH + have hpos : 0 < Ideal.absNorm B := Nat.pos_iff_ne_zero.mpr (fun hn => hB (Ideal.absNorm_eq_zero_iff.mp hn)) + exact hlarge.trans (by exact_mod_cast Nat.le_of_dvd hpos (map_dvd Ideal.absNorm hdiv)) + +theorem large_cube_convolution (H₀ : ℝ) (c : Ideal O →* ℂ) (hc0 : c 0=0) + (f : Ideal O → ℂ) + (hfinite : (Function.support (fun p : Ideal O × Ideal O => + (UniqueFactorizationMonoid.moebius p.1 : ℂ)*c (p.1*p.2)*f (p.1*p.2))).Finite) : + (∑' H : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then + (UniqueFactorizationMonoid.moebius H : ℂ)*c (H*J)*f (H*J) else 0) = + ∑' B : Ideal O,largeCubeCoefficient H₀ B*c B*f B := by + let F : Ideal O × Ideal O → ℂ := fun p => + if H₀ ≤ (Ideal.absNorm p.1 : ℝ) then + (UniqueFactorizationMonoid.moebius p.1 : ℂ)*c (p.1*p.2)*f (p.1*p.2) else 0 + have hF : Summable F := summable_of_hasFiniteSupport (hfinite.subset (by + intro p hp + by_contra hn + have he : (UniqueFactorizationMonoid.moebius p.1 : ℂ)*c (p.1*p.2)*f (p.1*p.2)=0 := not_ne_iff.mp hn + exact hp (by dsimp [F];rw [he];simp))) + have hfiber (B : Ideal O) : (∑' p : MulFiber B,F p.val)=largeCubeCoefficient H₀ B*c B*f B := by + by_cases hB : B=0 + · subst B + have hz : ∀ p : MulFiber 0,F p.val=0 := by + intro p + dsimp [F] + rw [p.property,hc0] + simp + simp [hz,largeCubeCoefficient] + · let e := mulFiberDivisorEquiv B hB + have hsum : (∑' p : MulFiber B, + if H₀ ≤ (Ideal.absNorm p.val.1 : ℝ) then (UniqueFactorizationMonoid.moebius p.val.1 : ℂ) else 0) = + largeCubeCoefficient H₀ B := by + calc + _ = ∑' H : {H : Ideal O // H∈idealDivisors B}, + if H₀ ≤ (Ideal.absNorm H.val : ℝ) then (UniqueFactorizationMonoid.moebius H.val : ℂ) else 0 := + e.tsum_eq _ + _ = _ := by + rw [tsum_fintype,largeCubeCoefficient,ite_eq_right (show B≠⊥ from hB)] + exact (Finset.sum_subtype (idealDivisors B) (fun H => Iff.rfl) + (fun H => if H₀ ≤ (Ideal.absNorm H : ℝ) then (UniqueFactorizationMonoid.moebius H : ℂ) else 0)).symm + calc + _ = ∑' p : MulFiber B, + (if H₀ ≤ (Ideal.absNorm p.val.1 : ℝ) then (UniqueFactorizationMonoid.moebius p.val.1 : ℂ) else 0)*(c B*f B) := by + apply tsum_congr + intro p + dsimp [F] + rw [p.property] + split_ifs <;> ring + _ = _ := by rw [tsum_mul_right,hsum];ring + have hs := hF.hasSum.tsum_fiberwise (fun p : Ideal O × Ideal O => p.1*p.2) + change HasSum (fun B : Ideal O => ∑' p : MulFiber B,F p.val) (∑' p,F p) at hs + simp_rw [hfiber] at hs + rw [← hF.tsum_prod] + exact hs.tsum_eq.symm + +theorem large_cube_inner_reopen (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0 < X) (I : Ideal O) : + (∑' H : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then expandedTerm Ψ W X I H J else 0) = + ∑' B : Ideal O,largeCubeCoefficient H₀ B*summand Ψ W X I B := by + let f : Ideal O → ℂ := fun B => + columnWeight Ψ I/(Real.sqrt (Ideal.absNorm I : ℝ) : ℂ)* + Vstar W ((Ideal.absNorm I : ℝ)*(Ideal.absNorm B : ℝ)^3/X) + have heq (H J : Ideal O) : + (UniqueFactorizationMonoid.moebius H : ℂ)*cubeWeight Ψ (H*J)*f (H*J)=expandedTerm Ψ W X I H J := by + simp only [f,expandedTerm,map_mul,Nat.cast_mul,mul_pow,mul_assoc] + have hf := finite_support_expandedTerm Ψ W hW X hX + have hp : (Function.support (fun p : Ideal O × Ideal O => expandedTerm Ψ W X I p.1 p.2)).Finite := by + change ((fun p : Ideal O × Ideal O => (I,p)) ⁻¹' + Function.support (fun p : Ideal O × Ideal O × Ideal O => expandedTerm Ψ W X p.1 p.2.1 p.2.2)).Finite + exact Set.Finite.preimage (fun a _ b _ hab => (Prod.mk.inj hab).2) hf + have hg := large_cube_convolution H₀ (cubeWeight Ψ) (cubeWeight_zero Ψ) f (by simpa only [heq] using hp) + rw [show (∑' H : Ideal O, ∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then expandedTerm Ψ W X I H J else 0)= + ∑' B : Ideal O,largeCubeCoefficient H₀ B*cubeWeight Ψ B*f B by simpa only [heq] using hg] + apply tsum_congr + intro B + dsimp [f,summand] + ring + +theorem large_cube_reopen (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0 < X) : + (∑' H : Ideal O, if H₀ ≤ (Ideal.absNorm H : ℝ) then + (UniqueFactorizationMonoid.moebius H : ℂ)*cubeWeight Ψ H* + completedT Ψ W (X/(Ideal.absNorm H : ℝ)^3) else 0) = + ∑' I : Ideal O,∑' B : Ideal O,largeCubeCoefficient H₀ B*summand Ψ W X I B := by + let F : Ideal O × Ideal O × Ideal O → ℂ := fun p => + if H₀ ≤ (Ideal.absNorm p.2.1 : ℝ) then expandedTerm Ψ W X p.1 p.2.1 p.2.2 else 0 + have hF : Summable F := summable_of_hasFiniteSupport + ((finite_support_expandedTerm Ψ W hW X hX).subset (by + intro p hp + by_contra hn + have he : expandedTerm Ψ W X p.1 p.2.1 p.2.2=0 := not_ne_iff.mp hn + exact hp (by simp [F,he]))) + let e : (Ideal O × Ideal O × Ideal O) ≃ (Ideal O × Ideal O × Ideal O) := { + toFun := fun p => (p.2.1,p.1,p.2.2) + invFun := fun p => (p.2.1,p.1,p.2.2) + left_inv := by rintro ⟨I,H,J⟩;rfl + right_inv := by rintro ⟨I,H,J⟩;rfl } + have hswap : Summable (fun p => F (e p)) := e.summable_iff.mpr hF + calc + _ = ∑' H : Ideal O,∑' I : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then expandedTerm Ψ W X I H J else 0 := by + apply tsum_congr + intro H + by_cases h : H₀ ≤ (Ideal.absNorm H : ℝ) + · simp only [ite_eq_left h,weighted_completedT_reopen] + · simp only [ite_eq_right h,tsum_zero] + _ = ∑' p : Ideal O × Ideal O × Ideal O,F (e p) := by + rw [hswap.tsum_prod] + apply tsum_congr + intro H + exact (hswap.prod_factor H).tsum_prod.symm + _ = ∑' p : Ideal O × Ideal O × Ideal O,F p := e.tsum_eq F + _ = ∑' I : Ideal O,∑' H : Ideal O,∑' J : Ideal O, + if H₀ ≤ (Ideal.absNorm H : ℝ) then expandedTerm Ψ W X I H J else 0 := by + rw [hF.tsum_prod] + apply tsum_congr + intro I + exact (hF.prod_factor I).tsum_prod + _ = _ := tsum_congr (large_cube_inner_reopen Ψ W hW X H₀ hX) + +theorem completed_cube_inverse_split (Ψ : O →* ℂ) (W : ℝ → ℂ) + (hW : HasCompactSupport W) (X H₀ : ℝ) (hX : 0 < X) : + (Real.sqrt X : ℂ)⁻¹*(∑' I : Ideal O,columnWeight Ψ I*W ((Ideal.absNorm I : ℝ)/X)) = + (∑' H : Ideal O, if (Ideal.absNorm H : ℝ) (UniqueFactorizationMonoid.moebius H : ℂ)*cubeWeight Ψ H* + completedT Ψ W (X/(Ideal.absNorm H : ℝ)^3) + have hf := cube_inverse_finite_support Ψ W hW X hX + have hs : Summable (fun H : Ideal O => if (Ideal.absNorm H : ℝ) if H₀ ≤ (Ideal.absNorm H : ℝ) then f H else 0) := + summable_of_hasFiniteSupport (hf.subset (by + intro H hH + by_contra hn + have he : f H=0 := not_ne_iff.mp hn + exact hH (by simp only [he,ite_self]))) + rw [completed_cube_inverse Ψ W hW X hX,←large_cube_reopen Ψ W hW X H₀ hX] + change (∑' H,f H)=(∑' H,if (Ideal.absNorm H : ℝ) ActualEisensteinCubic.O + +def cubicBesselNormalizer (h : ActualEisensteinCubic.O) : ℂ := + (2*Real.pi:ℂ)/Complex.Gamma (4/3)*(2*Real.pi*‖cuspFrequency h‖:ℂ)^(1/3:ℂ) + +def cubicResidualFourierCoefficient (h : ActualEisensteinCubic.O) : ℂ := + cubicBesselNormalizer h*nonzeroScatteringResidue h + +lemma sourceFourierKernel_cubic_height (h : ActualEisensteinCubic.O) (hh : h≠0) (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +lemma cuspWhittakerHeightFactor_punctured_ne_zero (h : ActualEisensteinCubic.O) (s : ℂ) (hs : 1 cuspWhittakerHeightFactor w h) {w : ℂ | 1 cuspWhittakerHeightFactor_analyticAt h w hw + have hcon : Convex ℝ {w : ℂ | 1 scatteringCoefficient w h) := by + have hopen : IsOpen {w : ℂ | 2 ActualEisensteinCubic.O + +lemma cuspWeightedWhittakerHeightFactor_differentiableAt + (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (s : ℂ) (hs : 1 cuspWeightedWhittakerHeightFactor ρ w h) s := by + have heq : (fun w => cuspWeightedWhittakerHeightFactor ρ w h)= + (fun w => ∫v in Set.Icc (5:ℝ) 6,ρ v*(v:ℂ)^(-w-1)*sourceFourierKernel w (cuspFrequency h*v)) := by + funext w + apply integral_congr_ae + exact Eventually.of_forall (fun v => (mul_assoc _ _ _).symm) + rw [heq] + exact cuspWeightedWhittakerAverage_differentiableAt ρ (cuspFrequency h) s hs + +lemma cuspWeightedWhittakerHeightFactor_analyticAt + (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (s : ℂ) (hs : 1 cuspWeightedWhittakerHeightFactor ρ w h) s := by + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + have hopen : IsOpen {w : ℂ | 1 kernelCuspWeightedFourierFamily ρ h s*cuspWhittakerHeightFactor s h) + (fun s => kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s* + cuspWeightedWhittakerHeightFactor ρ s h) {s : ℂ | 1 kernelCuspWeightedFourierFamily ρ h s*cuspWhittakerHeightFactor s h) domain := by + intro s hs + exact (kernelCuspWeightedFourierFamily_analyticAt_nonreal ρ h s hs.1.ne' hs.2.ne').mul + (cuspWhittakerHeightFactor_analyticAt h s hs.1) + have hright : AnalyticOnNhd ℂ + (fun s => kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s* + cuspWeightedWhittakerHeightFactor ρ s h) domain := by + intro s hs + exact (kernelCuspFourierFamily_analyticAt_nonreal h 2 3 (by norm_num) (by norm_num) + s hs.1.ne' hs.2.ne').mul (cuspWeightedWhittakerHeightFactor_analyticAt ρ h s hs.1) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s : ℂ | 4 kernelCuspWeightedFourierFamily ρ h s*cuspWhittakerHeightFactor s h) + =ᶠ[𝓝 (5+Complex.I:ℂ)] + (fun s => kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s* + cuspWeightedWhittakerHeightFactor ρ s h) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + rw [kernelCuspWeightedFourierFamily_initial_factor ρ h hh s hs.1 hs.2, + kernelCuspFourierFamily_eq_upper h hh ⟨by linarith [hs.1],hs.2⟩] + ring + exact hleft.eqOn_of_preconnected_of_eventuallyEq hright hconvex.isPreconnected hstart hevent + +lemma upperVertical_tendsto_cubic_punctured : + Tendsto (fun t : ℝ => (4/3:ℂ)+(t:ℂ)*Complex.I) + (𝓝[>] (0:ℝ)) (𝓝[≠] (4/3:ℂ)) := by + apply tendsto_nhdsWithin_iff.mpr + constructor + · have hc : ContinuousAt (fun t : ℝ => (4/3:ℂ)+(t:ℂ)*Complex.I) 0 := by fun_prop + simpa only [Complex.ofReal_zero,zero_mul,add_zero] using hc.tendsto.mono_left nhdsWithin_le_nhds + · filter_upwards [self_mem_nhdsWithin] with t ht + change 0 cuspWhittakerHeightFactor s h) + (𝓝[≠] (4/3:ℂ)) (𝓝 (cuspWhittakerHeightFactor (4/3:ℂ) h)) := + (cuspWhittakerHeightFactor_analyticAt h (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds + have hweight : Tendsto (fun s : ℂ => cuspWeightedWhittakerHeightFactor ρ s h) + (𝓝[≠] (4/3:ℂ)) (𝓝 (cuspWeightedWhittakerHeightFactor ρ (4/3:ℂ) h)) := + (cuspWeightedWhittakerHeightFactor_analyticAt ρ h (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds + have hleft := ((kernelCuspWeightedFourierFamily_residue_limit ρ h).mul hbase).comp + upperVertical_tendsto_cubic_punctured + have hright := ((kernelCuspFourierFamily_residue_limit h 2 3 (by norm_num) (by norm_num)).mul hweight).comp + upperVertical_tendsto_cubic_punctured + have hevent : (fun t : ℝ => + (((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*kernelCuspWeightedFourierFamily ρ h ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspWhittakerHeightFactor ((4/3:ℂ)+(t:ℂ)*Complex.I) h) + =ᶠ[𝓝[>] (0:ℝ)] (fun t : ℝ => + (((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) + ((4/3:ℂ)+(t:ℂ)*Complex.I))*cuspWeightedWhittakerHeightFactor ρ ((4/3:ℂ)+(t:ℂ)*Complex.I) h) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 ActualEisensteinCubic.O + +lemma denominatorRep_mk_congr (c d : Eis) : + 3*c ∣ denominatorRep c (Ideal.Quotient.mk (Ideal.span {3*c}) d)-d := by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + exact denominatorRep_spec c _ + +lemma isCoprime_right_congr_of_dvd (c d e : Eis) (h : c ∣ d-e) : + IsCoprime c d ↔ IsCoprime c e := by + obtain ⟨n,hn⟩ := h + have hd : d=e+c*n := by linear_combination hn + rw [hd,IsCoprime.add_mul_left_right_iff] + +abbrev CubicUnitResidue (b : Eis) := + {r : Eis ⧸ Ideal.span {b} // IsUnit r} + +def denominatorCRTMap (a b : Eis) (r : AdmissibleResidue (a*b)) : + AdmissibleResidue a × CubicUnitResidue b := + let d:=denominatorRep (a*b) r.1 + (⟨Ideal.Quotient.mk (Ideal.span {3*a}) d, + (denominatorCondition_congr a _ d (denominatorRep_mk_congr a d)).mpr + ⟨r.2.1.of_mul_left_left,r.2.2⟩⟩, + ⟨Ideal.Quotient.mk (Ideal.span {b}) d, + (isUnit_quotient_span_iff b d).mpr r.2.1.of_mul_left_right⟩) + +lemma denominatorCRTMap_injective (a b : Eis) (hab : IsCoprime (3*a) b) : + Function.Injective (denominatorCRTMap a b) := by + intro r t he + have h1:=congrArg (fun z : AdmissibleResidue a × CubicUnitResidue b => z.1.1) he + have h2:=congrArg (fun z : AdmissibleResidue a × CubicUnitResidue b => z.2.1) he + change Ideal.Quotient.mk (Ideal.span {3*a}) (denominatorRep (a*b) r.1)= + Ideal.Quotient.mk (Ideal.span {3*a}) (denominatorRep (a*b) t.1) at h1 + change Ideal.Quotient.mk (Ideal.span {b}) (denominatorRep (a*b) r.1)= + Ideal.Quotient.mk (Ideal.span {b}) (denominatorRep (a*b) t.1) at h2 + have hdiv : 3*(a*b) ∣ denominatorRep (a*b) r.1-denominatorRep (a*b) t.1 := by + simpa only [mul_assoc] using hab.mul_dvd + (Ideal.mem_span_singleton.mp ((Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp h1)) + (Ideal.mem_span_singleton.mp ((Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp h2)) + apply Subtype.ext + rw [←denominatorRep_spec (a*b) r.1,←denominatorRep_spec (a*b) t.1] + exact (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr (Ideal.mem_span_singleton.mpr hdiv) + +lemma denominatorCRTMap_surjective (a b : Eis) (hab : IsCoprime (3*a) b) : + Function.Surjective (denominatorCRTMap a b) := by + rintro ⟨r,t⟩ + obtain ⟨u,v,huv⟩ := hab + let delta:=denominatorRep a r.1 + let xi:=GaussianShiftedPartition.representative b t.1 + let d:=v*b*delta+u*(3*a)*xi + have hda : 3*a ∣ d-delta := by + refine ⟨u*(xi-delta),?_⟩ + dsimp [d] + linear_combination delta*huv + have hdb : b ∣ d-xi := by + refine ⟨v*(delta-xi),?_⟩ + dsimp [d] + linear_combination xi*huv + have hxi : IsCoprime b xi := by + apply (isUnit_quotient_span_iff b xi).mp + simpa only [xi,GaussianShiftedPartition.representative_spec] using t.2 + have had : denominatorCondition a d := (denominatorCondition_congr a d delta hda).mpr r.2 + have hbd : IsCoprime b d := (isCoprime_right_congr_of_dvd b d xi hdb).mpr hxi + have hd : denominatorCondition (a*b) d := ⟨had.1.mul_left hbd,had.2⟩ + let q : AdmissibleResidue (a*b):=⟨Ideal.Quotient.mk (Ideal.span {3*(a*b)}) d, + (denominatorCondition_congr (a*b) _ d (denominatorRep_mk_congr (a*b) d)).mpr hd⟩ + refine ⟨q,Prod.ext (Subtype.ext ?_) (Subtype.ext ?_)⟩ + · change Ideal.Quotient.mk (Ideal.span {3*a}) (denominatorRep (a*b) q.1)=r.1 + rw [←denominatorRep_spec a r.1] + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + apply Ideal.mem_span_singleton.mpr + have hh : 3*a ∣ denominatorRep (a*b) q.1-d := by + exact (show 3*a ∣ 3*(a*b) from ⟨b,by ring⟩).trans (denominatorRep_mk_congr (a*b) d) + simpa only [sub_add_sub_cancel] using dvd_add hh hda + · change Ideal.Quotient.mk (Ideal.span {b}) (denominatorRep (a*b) q.1)=t.1 + rw [←GaussianShiftedPartition.representative_spec b t.1] + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + apply Ideal.mem_span_singleton.mpr + have hh : b ∣ denominatorRep (a*b) q.1-d := by + exact (show b ∣ 3*(a*b) from ⟨3*a,by ring⟩).trans (denominatorRep_mk_congr (a*b) d) + simpa only [sub_add_sub_cancel] using dvd_add hh hdb + +def denominatorCRTEquiv (a b : Eis) (hab : IsCoprime (3*a) b) : + AdmissibleResidue (a*b) ≃ AdmissibleResidue a × CubicUnitResidue b := + Equiv.ofBijective (denominatorCRTMap a b) + ⟨denominatorCRTMap_injective a b hab,denominatorCRTMap_surjective a b hab⟩ + +def residueAdditive (h c d : Eis) : ℂ := + ShortDraftTrace.breveE (cuspFrequency h*eisEmbedding d/eisEmbedding c) + +lemma residueAdditive_congr (h c d e : Eis) (hc : c≠0) (hde : 3*c ∣ d-e) : + residueAdditive h c d=residueAdditive h c e := by + obtain ⟨n,hn⟩:=hde + have hd:d=e+3*c*n:=by linear_combination hn + have he:eisEmbedding c≠0:=eisEmbedding_ne_zero hc + unfold residueAdditive + rw [hd] + have hh : cuspFrequency h*eisEmbedding (e+3*c*n)/eisEmbedding c= + cuspFrequency h*eisEmbedding e/eisEmbedding c+cuspFrequency h*(3*eisEmbedding n) := by + simp only [map_add,map_mul,map_ofNat] + field_simp + rw [hh,AddChar.map_add_eq_mul,cuspFrequency_period,mul_one] + +def cubicUnitGaussSum (h b : Eis) : ℂ := + ∑' r : CubicUnitResidue b, + eisEmbedding (symbol (GaussianShiftedPartition.representative b r.1) b)* + residueAdditive (3*h) b (GaussianShiftedPartition.representative b r.1) + +lemma residueAdditive_three_congr (h b d e : Eis) (hb : b≠0) (hde : b ∣ d-e) : + residueAdditive (3*h) b d=residueAdditive (3*h) b e := by + obtain ⟨n,hn⟩:=hde + have hd:d=e+b*n:=by linear_combination hn + have he:eisEmbedding b≠0:=eisEmbedding_ne_zero hb + unfold residueAdditive + rw [hd] + have hh : cuspFrequency (3*h)*eisEmbedding (e+b*n)/eisEmbedding b= + cuspFrequency (3*h)*eisEmbedding e/eisEmbedding b+cuspFrequency h*(3*eisEmbedding n) := by + simp only [cuspFrequency,map_add,map_mul,map_ofNat] + field_simp + rw [hh,AddChar.map_add_eq_mul,cuspFrequency_period,mul_one] + +lemma residueAdditive_crt (h a b alpha beta d : Eis) (ha : a≠0) (hb : b≠0) + (hbez : alpha*b+beta*(3*a)=1) : + residueAdditive h (a*b) d= + residueAdditive (h*alpha) a d*residueAdditive (3*(h*beta)) b d := by + unfold residueAdditive + rw [←AddChar.map_add_eq_mul] + congr 1 + have hae:=eisEmbedding_ne_zero ha + have hbe:=eisEmbedding_ne_zero hb + have hbeq:=congrArg eisEmbedding hbez + simp only [map_add,map_mul,map_one,map_ofNat] at hbeq + simp only [cuspFrequency,map_mul,map_ofNat] + field_simp [hae,hbe,eisLam_ne_zero] + linear_combination -(eisEmbedding h*eisEmbedding d)*hbeq + +lemma arithmetic_crt_summand (h a b alpha beta : Eis) + (ha : a≠0) (hb : b≠0) (halevel : (3:Eis)∣a) + (hbprimary : lambda^2∣b-1) (hbez : alpha*b+beta*(3*a)=1) + (r : AdmissibleResidue (a*b)) : + eisEmbedding (symbol (a*b) (denominatorRep (a*b) r.1))* + residueAdditive h (a*b) (denominatorRep (a*b) r.1)= + (eisEmbedding (symbol a (denominatorRep a (denominatorCRTMap a b r).1.1))* + residueAdditive (h*alpha) a (denominatorRep a (denominatorCRTMap a b r).1.1))* + (eisEmbedding (symbol (GaussianShiftedPartition.representative b (denominatorCRTMap a b r).2.1) b)* + residueAdditive (3*(h*beta)) b (GaussianShiftedPartition.representative b (denominatorCRTMap a b r).2.1)) := by + let d:=denominatorRep (a*b) r.1 + let delta:=denominatorRep a (denominatorCRTMap a b r).1.1 + let xi:=GaussianShiftedPartition.representative b (denominatorCRTMap a b r).2.1 + have hdprimary : lambda^2∣d-1:=lambda_sq_dvd_three.trans r.2.2 + have hdelta : 3*a∣delta-d:=denominatorRep_mk_congr a d + have hxi : b∣xi-d:=by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + exact GaussianShiftedPartition.representative_spec b _ + have hchar : symbol (a*b) d=symbol a delta*symbol xi b := by + rw [symbol_mul_numerator a b d hdprimary, + symbol_reciprocity b d hb (primary_ne_zero d hdprimary) hbprimary hdprimary, + ←symbol_congr hxi] + rw [←row_symbol_congr_modulus a delta d halevel r.2.2 hdelta] + change eisEmbedding (symbol (a*b) d)*residueAdditive h (a*b) d= + (eisEmbedding (symbol a delta)*residueAdditive (h*alpha) a delta)* + (eisEmbedding (symbol xi b)*residueAdditive (3*(h*beta)) b xi) + rw [hchar,map_mul,residueAdditive_crt h a b alpha beta d ha hb hbez, + residueAdditive_congr (h*alpha) a delta d ha hdelta, + residueAdditive_three_congr (h*beta) b xi d hb hxi] + ring + +theorem arithmeticResidueSum_crt (h a b alpha beta : Eis) + (ha : a≠0) (hb : b≠0) (halevel : (3:Eis)∣a) + (hbprimary : lambda^2∣b-1) (hbez : alpha*b+beta*(3*a)=1) : + arithmeticResidueSum h (a*b)= + arithmeticResidueSum (h*alpha) a*cubicUnitGaussSum (h*beta) b := by + have hab : IsCoprime (3*a) b:=⟨beta,alpha,by linear_combination hbez⟩ + let f : AdmissibleResidue a→ℂ:=fun r=> + eisEmbedding (symbol a (denominatorRep a r.1))*residueAdditive (h*alpha) a (denominatorRep a r.1) + let g : CubicUnitResidue b→ℂ:=fun r=> + eisEmbedding (symbol (GaussianShiftedPartition.representative b r.1) b)* + residueAdditive (3*(h*beta)) b (GaussianShiftedPartition.representative b r.1) + have heq: arithmeticResidueSum h (a*b)=∑' r : AdmissibleResidue (a*b), + f (denominatorCRTEquiv a b hab r).1*g (denominatorCRTEquiv a b hab r).2 := by + unfold arithmeticResidueSum + apply tsum_congr + intro r + exact arithmetic_crt_summand h a b alpha beta ha hb halevel hbprimary hbez r + rw [heq,(denominatorCRTEquiv a b hab).tsum_eq (fun r=>f r.1*g r.2)] + let : Finite (AdmissibleResidue a):=finite_admissibleResidue a ha + let : Finite (Eis ⧸ Ideal.span {b}):=finite_quotient_span hb + let : Fintype (AdmissibleResidue a):=Fintype.ofFinite _ + let : Fintype (CubicUnitResidue b):=Fintype.ofFinite _ + change (∑' r : AdmissibleResidue a × CubicUnitResidue b,f r.1*g r.2)= + (∑' r : AdmissibleResidue a,f r)*(∑' t : CubicUnitResidue b,g t) + simp only [tsum_fintype,Fintype.sum_prod_type,Finset.mul_sum,Finset.sum_mul] + exact Finset.sum_comm + +end + +open scoped BigOperators Classical +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma residueAdditive_mul (h c t d : Eis) : + residueAdditive h c (t*d)=residueAdditive (h*t) c d := by + unfold residueAdditive cuspFrequency + simp only [map_mul] + congr 1 + ring + +lemma residueAdditive_swap (h c d : Eis) : + residueAdditive h c d=residueAdditive d c h := by + unfold residueAdditive cuspFrequency + congr 1 + ring + +lemma arithmeticResidueSum_frequency_congr (h k c : Eis) (hc : c≠0) + (hh : 3*c∣h-k) : arithmeticResidueSum h c=arithmeticResidueSum k c := by + unfold arithmeticResidueSum + apply tsum_congr + intro r + congr 1 + change residueAdditive h c (denominatorRep c r.1)=residueAdditive k c (denominatorRep c r.1) + rw [residueAdditive_swap h,residueAdditive_swap k] + exact residueAdditive_congr _ c h k hc hh + +theorem arithmeticResidueSum_frequency_twist (h c t : Eis) (hc : c≠0) + (hlevel : (3:Eis)∣c) (ht : denominatorCondition c t) : + eisEmbedding (symbol c t)*arithmeticResidueSum (h*t) c=arithmeticResidueSum h c := by + have heq:=(residueMultiplicationEquiv c hc t ht).tsum_eq + (fun r : AdmissibleResidue c=>eisEmbedding (symbol c (denominatorRep c r.1))* + residueAdditive h c (denominatorRep c r.1)) + calc + _ = ∑' r : AdmissibleResidue c,eisEmbedding (symbol c t)* + (eisEmbedding (symbol c (denominatorRep c r.1))*residueAdditive (h*t) c (denominatorRep c r.1)) := by + rw [tsum_mul_left] + rfl + _ = ∑' r : AdmissibleResidue c, + eisEmbedding (symbol c (denominatorRep c (residueMultiplicationEquiv c hc t ht r).1))* + residueAdditive h c (denominatorRep c (residueMultiplicationEquiv c hc t ht r).1) := by + apply tsum_congr + intro r + change _=eisEmbedding (symbol c (denominatorRep c (residueMultiplication c t ht r).1))* + residueAdditive h c (denominatorRep c (residueMultiplication c t ht r).1) + rw [residueMultiplication_phase c hlevel t ht r,map_mul] + dsimp only [residueMultiplication] + rw [residueAdditive_congr h c _ (t*denominatorRep c r.1) hc + (denominatorRep_product_congr c t r.1),residueAdditive_mul] + ring + _ = _ := heq + +lemma cubicUnitGaussSum_frequency_congr (h k b : Eis) (hb : b≠0) + (hh : b∣h-k) : cubicUnitGaussSum h b=cubicUnitGaussSum k b := by + unfold cubicUnitGaussSum + apply tsum_congr + intro r + congr 1 + have he (u : Eis) : residueAdditive (3*u) b (GaussianShiftedPartition.representative b r.1)= + residueAdditive (3*GaussianShiftedPartition.representative b r.1) b u := by + unfold residueAdditive cuspFrequency + simp only [map_mul,map_ofNat] + congr 1 + ring + rw [he h,he k] + exact residueAdditive_three_congr _ b h k hb hh + +def cubicUnitResidueMul (b t : Eis) (ht : IsCoprime b t) (r : CubicUnitResidue b) : + CubicUnitResidue b := + ⟨Ideal.Quotient.mk (Ideal.span {b}) t*r.1, + ((isUnit_quotient_span_iff b t).mpr ht).mul r.2⟩ + +lemma cubicUnitResidueMul_injective (b t : Eis) (ht : IsCoprime b t) : + Function.Injective (cubicUnitResidueMul b t ht) := by + intro r q heq + apply Subtype.ext + exact ((isUnit_quotient_span_iff b t).mpr ht).mul_left_cancel (congrArg Subtype.val heq) + +def cubicUnitResidueMulEquiv (b t : Eis) (hb : b≠0) (ht : IsCoprime b t) : + CubicUnitResidue b ≃ CubicUnitResidue b := by + letI : Finite (Eis ⧸ Ideal.span {b}):=finite_quotient_span hb + exact Equiv.ofBijective (cubicUnitResidueMul b t ht) + ⟨cubicUnitResidueMul_injective b t ht, + Finite.surjective_of_injective (cubicUnitResidueMul_injective b t ht)⟩ + +lemma cubicUnitResidueMul_rep_congr (b t : Eis) (ht : IsCoprime b t) + (r : CubicUnitResidue b) : + b∣GaussianShiftedPartition.representative b (cubicUnitResidueMul b t ht r).1- + t*GaussianShiftedPartition.representative b r.1 := by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + rw [GaussianShiftedPartition.representative_spec,map_mul, + GaussianShiftedPartition.representative_spec] + rfl + +theorem cubicUnitGaussSum_frequency_twist (h b t : Eis) (hb : b≠0) + (hbprimary : lambda^2∣b-1) (ht : IsCoprime b t) : + eisEmbedding (symbol t b)*cubicUnitGaussSum (h*t) b=cubicUnitGaussSum h b := by + have heq:=(cubicUnitResidueMulEquiv b t hb ht).tsum_eq + (fun r : CubicUnitResidue b=>eisEmbedding (symbol (GaussianShiftedPartition.representative b r.1) b)* + residueAdditive (3*h) b (GaussianShiftedPartition.representative b r.1)) + calc + _ = ∑' r : CubicUnitResidue b,eisEmbedding (symbol t b)* + (eisEmbedding (symbol (GaussianShiftedPartition.representative b r.1) b)* + residueAdditive (3*(h*t)) b (GaussianShiftedPartition.representative b r.1)) := by + rw [tsum_mul_left] + rfl + _ = ∑' r : CubicUnitResidue b, + eisEmbedding (symbol (GaussianShiftedPartition.representative b + (cubicUnitResidueMulEquiv b t hb ht r).1) b)* + residueAdditive (3*h) b (GaussianShiftedPartition.representative b + (cubicUnitResidueMulEquiv b t hb ht r).1) := by + apply tsum_congr + intro r + change _=eisEmbedding (symbol (GaussianShiftedPartition.representative b + (cubicUnitResidueMul b t ht r).1) b)* + residueAdditive (3*h) b (GaussianShiftedPartition.representative b (cubicUnitResidueMul b t ht r).1) + rw [symbol_congr (cubicUnitResidueMul_rep_congr b t ht r), + symbol_mul_numerator t _ b hbprimary,map_mul] + rw [residueAdditive_three_congr h b _ (t*GaussianShiftedPartition.representative b r.1) + hb (cubicUnitResidueMul_rep_congr b t ht r),residueAdditive_mul] + rw [show (3*h)*t=3*(h*t) by ring] + ring + _ = _ := heq + +theorem arithmeticResidueSum_coprime_product (h a b : Eis) + (ha : a≠0) (hb : b≠0) (halevel : (3:Eis)∣a) + (hbprimary : lambda^2∣b-1) (hab : IsCoprime (3*a) b) : + arithmeticResidueSum h (a*b)= + eisEmbedding (symbol a b)*eisEmbedding (symbol (3*a) b)* + arithmeticResidueSum h a*cubicUnitGaussSum h b := by + obtain ⟨beta,alpha,hbez⟩:=hab + have hbez' : alpha*b+beta*(3*a)=1:=by linear_combination hbez + have hab' : IsCoprime (3*a) b:=⟨beta,alpha,hbez⟩ + have hb3 : (3:Eis)∣b-1:=three_dvd_lambda_sq.trans hbprimary + have hbt : denominatorCondition a b:=⟨hab'.of_mul_left_right,hb3⟩ + have hA := arithmeticResidueSum_frequency_twist (h*alpha) a b ha halevel hbt + have hAf : 3*a∣(h*alpha)*b-h:=⟨-h*beta,by linear_combination h*hbez'⟩ + rw [arithmeticResidueSum_frequency_congr _ h a ha hAf] at hA + have hB := cubicUnitGaussSum_frequency_twist (h*beta) b (3*a) hb hbprimary hab'.symm + have hBf : b∣(h*beta)*(3*a)-h:=⟨-h*alpha,by linear_combination h*hbez'⟩ + rw [cubicUnitGaussSum_frequency_congr _ h b hb hBf] at hB + rw [arithmeticResidueSum_crt h a b alpha beta ha hb halevel hbprimary hbez',←hA,←hB] + ring + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/GreenIdentity.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/GreenIdentity.lean new file mode 100644 index 0000000000000000000000000000000000000000..1e0f2468a0bd55f5d79db2137c17db54de2e4027 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/GreenIdentity.lean @@ -0,0 +1,701 @@ +import OAI.NumberTheory.DirichletL.QuadraticSieve.GreenIntegrals + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +def greenWronskian (f g : ℝ → ℂ) (x : ℝ) : ℂ := + deriv f x*star (g x)-f x*star (deriv g x) + +def greenSecondTerm (f g : ℝ → ℂ) (x : ℝ) : ℂ := + deriv (deriv f) x*star (g x)-f x*star (deriv (deriv g) x) + +lemma hasDerivAt_greenWronskian (f g : ℝ → ℂ) (x : ℝ) + (hf : DifferentiableAt ℝ f x) (hg : DifferentiableAt ℝ g x) + (hdf : DifferentiableAt ℝ (deriv f) x) (hdg : DifferentiableAt ℝ (deriv g) x) : + HasDerivAt (greenWronskian f g) (greenSecondTerm f g x) x := by + convert ((hdf.hasDerivAt.mul hg.hasDerivAt.star).sub + (hf.hasDerivAt.mul hdg.hasDerivAt.star)) using 1 + · rfl + · dsimp [greenSecondTerm] + ring + +lemma weighted_vertical_green (f g : ℝ → ℂ) (a b : ℝ) + (hpos : ∀x∈Set.uIcc a b,0 (hf x hx).continuousAt.continuousWithinAt + have hgc : ContinuousOn g (Set.uIcc a b) := fun x hx => (hg x hx).continuousAt.continuousWithinAt + have hdfc : ContinuousOn (deriv f) (Set.uIcc a b) := fun x hx => (hdf x hx).continuousAt.continuousWithinAt + have hdgc : ContinuousOn (deriv g) (Set.uIcc a b) := fun x hx => (hdg x hx).continuousAt.continuousWithinAt + have hW : ContinuousOn (greenWronskian f g) (Set.uIcc a b) := + (hdfc.mul hgc.star).sub (hfc.mul hdgc.star) + have hne : ∀x∈Set.uIcc a b,(x:ℂ)≠0 := fun x hx => Complex.ofReal_ne_zero.mpr (hpos x hx).ne' + have hstar : IntervalIntegrable (fun x => star (deriv (deriv g) x)) volume a b := by + apply hig.mono_fun ((aestronglyMeasurable_deriv (deriv g) _).star) + exact Filter.Eventually.of_forall (fun x => by simp only [Pi.star_apply,norm_star,le_refl]) + have hG : IntervalIntegrable (greenSecondTerm f g) volume a b := + (hif.mul_continuousOn hgc.star).sub (hstar.continuousOn_mul hfc) + apply intervalIntegral.integral_eq_sub_of_hasDerivAt + · intro x hx + have h := (hasDerivAt_greenWronskian f g x (hf x hx) (hg x hx) (hdf x hx) (hdg x hx)).div + ((hasDerivAt_id x).ofReal_comp) (hne x hx) + convert h using 1 + · rfl + · simp only [id_eq,Complex.ofReal_one,mul_one] + field_simp [hne x hx] + + · have hi₁ := hG.mul_continuousOn (Complex.continuous_ofReal.continuousOn.inv₀ hne) + have hi₂ : IntervalIntegrable (fun x : ℝ => greenWronskian f g x/(x:ℂ)^2) volume a b := + (hW.div (Complex.continuous_ofReal.continuousOn.pow 2) + (fun x hx => pow_ne_zero 2 (hne x hx))).intervalIntegrable + simpa only [div_eq_mul_inv,Pi.inv_apply] using hi₁.sub hi₂ + +theorem actual_eisenstein_vertical_green (s t : ℂ) (hs : 2 (actual_axis_differentiable_at s hs p 2 x (hsafe x hx)).1 + · exact fun x hx => (actual_axis_differentiable_at t ht p 2 x (hsafe x hx)).1 + · exact fun x hx => (actual_axis_differentiable_at s hs p 2 x (hsafe x hx)).2 + · exact fun x hx => (actual_axis_differentiable_at t ht p 2 x (hsafe x hx)).2 + · apply (intervalIntegrable_iff' (by finiteness)).mpr + exact (actual_axis_second_locallyIntegrable s hs p 2).integrableOn_compact_subset hsafe isCompact_uIcc + · apply (intervalIntegrable_iff' (by finiteness)).mpr + exact (actual_axis_second_locallyIntegrable t ht p 2).integrableOn_compact_subset hsafe isCompact_uIcc + +lemma axisSlice_self (f : SpatialCoordinates → ℂ) (p : SpatialCoordinates) (j : Fin 3) : + axisSlice f p j (p j)=f p := by + simp only [axisSlice,Function.update_eq_self] + +theorem actual_eisenstein_green_density (s t : ℂ) (hs : 2 Ideal.span {p i}))) + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + +include hinj in +theorem secondExpansionSource_singleton_zero_of_not_support + (F : Finset ι) (Ψ : O →* ℂ) (m c d : O) (z : SecondRayIndex) + (g W : 𝓢(ℝ, ℂ)) (X Y M : ℝ) (hX : 0 < X) + (hgM : ∀ u, g u ≠ 0 → |u| ≤ M) + (x : SecondExpansionData ι) (hE : x.divisor ⊆ x.sourceCommon) + (hs : ¬ SecondSourceSupport p X M x) : + secondExpansionSource p hp hcop hg F Ψ m c d z {x} + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) S) + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) S) W Y = 0 := by + by_cases hd : Disjoint x.sourceCommon x.overlap + · have hb : ¬ primeProductNorm p x.sourceCommon * primeProductNorm p x.overlap ≤ X * Real.exp M := + fun hb => hs ⟨hd,hb⟩ + have hz (N : Finset ι) : + normalizedColumn p (fun A => g (columnLog p X A)) + (x.sourceCommon ∪ (x.overlap ∪ N)) = 0 := by + by_contra hn + have h := normalizedColumn_subset_norm_bound p hp g M X hX hgM + x.sourceCommon (x.overlap ∪ N) (x.sourceCommon ∪ x.overlap) + (Finset.union_subset_union Finset.Subset.rfl Finset.subset_union_left) hn + rw [FirstPassCubeLabels.primeProductNorm_union p _ _ hd] at h + exact hb h + simp only [secondExpansionSource, Finset.sum_singleton] + have hk : secondChildKernelPair p hp hcop hg F x.overlap + (secondRayMinus Ψ z) (secondRayPlus Ψ z) m (secondExpansionQuotient p x) c d + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) + x.frequency (-x.frequency) + (secondSourcePairKernel p + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) x.frequency + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) (x.sourceCommon ∪ S)) + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) (x.sourceCommon ∪ S)) W Y) = 0 := by + unfold secondChildKernelPair + apply Finset.sum_eq_zero + intro N hN + apply Finset.sum_eq_zero + intro Q hQ + simp only [secondSourcePairKernel, hz N, star_zero, zero_mul, zero_div, mul_zero] + rw [hk] + ring + · have hz := secondPreColumn_zero_of_common_overlap p hp hcop hg hinj + (secondRayPlus Ψ z) m c d + (primeSubsetGenerator (fun i => Ideal.span {p i}) x.divisor) + (-x.frequency) (fun _ => 1) x.sourceCommon x.overlap (fun h => hd h.symm) + rw [secondMaskQuotient_spec p x.divisor x.sourceCommon hE] at hz + simp only [secondExpansionSource, Finset.sum_singleton, + secondExpansionQuotient_of_subset p x hE, secondTotalWeight, secondCommonWeight, hz, + mul_zero, zero_mul] + +include hinj in + +theorem secondExpansionSource_eq_supported + (F : Finset ι) (Ψ : O →* ℂ) (m c d : O) (z : SecondRayIndex) + (g W : 𝓢(ℝ, ℂ)) (X Y M : ℝ) (hX : 0 < X) + (hgM : ∀ u, g u ≠ 0 → |u| ≤ M) + (s : Finset (SecondExpansionData ι)) + (hE : ∀ x ∈ s, x.divisor ⊆ x.sourceCommon) : + secondExpansionSource p hp hcop hg F Ψ m c d z s + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) S) + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) S) W Y = + secondExpansionSource p hp hcop hg F Ψ m c d z + (s.filter (SecondSourceSupport p X M)) + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) S) + (fun S => normalizedColumn p (fun A => g (columnLog p X A)) S) W Y := by + classical + unfold secondExpansionSource + rw [Finset.sum_filter] + apply Finset.sum_congr rfl + intro x hx + by_cases hs : SecondSourceSupport p X M x + · rw [ite_eq_left hs] + · rw [ite_eq_right hs] + have hz := secondExpansionSource_singleton_zero_of_not_support + p hp hcop hg hinj F Ψ m c d z g W X Y M hX hgM x (hE x hx) hs + simpa only [secondExpansionSource, Finset.sum_singleton] using hz + +end +section + +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm) +open ConcreteTraceCRT (eisEmbedding) + +def normLogBin (u : ℝ) : ℕ := ⌊Real.log u⌋₊ +def normLogScale (j : ℕ) : ℝ := Real.exp (j : ℝ) + +lemma normLogScale_pos (j : ℕ) : 0 < normLogScale j := Real.exp_pos _ +lemma normLogScale_ge_one (j : ℕ) : 1 ≤ normLogScale j := + Real.one_le_exp (by positivity) + +lemma normLogBin_error (u : ℝ) (hu : 1 ≤ u) : + 0 ≤ Real.log (u / normLogScale (normLogBin u)) ∧ + Real.log (u / normLogScale (normLogBin u)) ≤ 1 := by + rw [Real.log_div (by linarith) (normLogScale_pos _).ne', normLogScale, Real.log_exp] + exact ⟨sub_nonneg.mpr (Nat.floor_le (Real.log_nonneg hu)), + by have h := Nat.lt_floor_add_one (Real.log u); dsimp [normLogBin]; linarith⟩ + +lemma normLogBin_scale_bounds (u : ℝ) (hu : 1 ≤ u) : + normLogScale (normLogBin u) ≤ u ∧ + u ≤ normLogScale (normLogBin u) * Real.exp 1 := by + have hu0 : 0 < u := by linarith + constructor + · have h := Real.exp_le_exp.mpr (Nat.floor_le (Real.log_nonneg hu)) + simpa only [Real.exp_log hu0, normLogScale, normLogBin] using h + · have h := Real.exp_le_exp.mpr (Nat.lt_floor_add_one (Real.log u)).le + simpa only [Real.exp_log hu0, Real.exp_add, normLogScale, normLogBin] using h + +lemma normLogBin_mono {u v : ℝ} (hu : 0 < u) (huv : u ≤ v) : + normLogBin u ≤ normLogBin v := Nat.floor_mono (Real.log_le_log hu huv) + +abbrev SecondLogIndex := ℕ × ℕ × ℕ + +def secondLogE (j : SecondLogIndex) : ℝ := normLogScale j.1 +def secondLogV (j : SecondLogIndex) : ℝ := normLogScale j.2.1 +def secondLogK (j : SecondLogIndex) : ℝ := normLogScale j.2.2 + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + +def secondLogIndex (D : Finset ι) (x : SecondExpansionData ι) : SecondLogIndex := + (normLogBin (primeProductNorm p x.divisor), normLogBin (primeProductNorm p x.overlap), + normLogBin (‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2)) + +def secondLogX (R : Finset ι) (X : ℝ) (j : SecondLogIndex) : ℝ := + X / (secondLogE j * secondLogV j * primeProductNorm p R) + +include hp in +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +lemma secondLogX_pos (R : Finset ι) (X : ℝ) (hX : 0 < X) (j : SecondLogIndex) : + 0 < secondLogX p R X j := by + exact div_pos hX (mul_pos (mul_pos (normLogScale_pos _) (normLogScale_pos _)) + (FirstPassCubeLabels.primeProductNorm_pos p hp R)) + +omit [DecidableEq ι] in +lemma actualSecondRow_ne_zero (D E : Finset ι) (k : O) (hk : k ≠ 0) : + actualSecondRow p D E k ≠ 0 := + mul_ne_zero (mul_ne_zero (primeSubsetGenerator_ne_zero _ _) (primeSubsetGenerator_ne_zero _ _)) hk + +lemma element_norm_ge_one (a : O) (ha : a ≠ 0) : 1 ≤ ‖eisEmbedding a‖^2 := by + rw [eisEmbedding_norm_sq_eq_absNorm_span] + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (show Ideal.absNorm (Ideal.span {a}) ≠ 0 by + rw [ne_eq, Ideal.absNorm_eq_zero_iff, Ideal.span_singleton_eq_bot] + exact ha) + +include hp in + +omit [DecidableEq ι] in +theorem secondLogIndex_coordinates (C D R : Finset ι) (X : ℝ) (hX : 0 < X) + (x : SecondExpansionData ι) (hk : x.frequency ≠ 0) : + let j := secondLogIndex p D x + let y := expansionSupportData C D x + |secondSectorZ p (secondExpansionScale p X + (primeSubsetGenerator (fun i => Ideal.span {p i}) R) y) (secondLogX p R X j) y| ≤ 2 ∧ + |secondSectorUd p (primeProductNorm p D) y| ≤ 2 ∧ + |secondSectorUe p (secondLogE j) y| ≤ 2 ∧ + |secondSectorUv p (secondLogV j) y| ≤ 2 ∧ + |secondSectorKap p (secondLogK j) y| ≤ 2 := by + dsimp only + have hE := normLogBin_error (primeProductNorm p x.divisor) (primeProductNorm_ge_one p hp _) + have hV := normLogBin_error (primeProductNorm p x.overlap) (primeProductNorm_ge_one p hp _) + have hK := normLogBin_error (‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2) + (element_norm_ge_one _ (actualSecondRow_ne_zero p D x.divisor x.frequency hk)) + have hR := (FirstPassCubeLabels.primeProductNorm_pos p hp R).ne' + have hX0 := hX.ne' + have hNE := (FirstPassCubeLabels.primeProductNorm_pos p hp x.divisor).ne' + have he := (normLogScale_pos (normLogBin (primeProductNorm p x.divisor))).ne' + have hv := (normLogScale_pos (normLogBin (primeProductNorm p x.overlap))).ne' + have hratio : + primeProductNorm p x.overlap * secondLogX p R X (secondLogIndex p D x) / + secondExpansionScale p X (primeSubsetGenerator (fun i => Ideal.span {p i}) R) + (expansionSupportData C D x) = + (primeProductNorm p x.divisor / normLogScale (normLogBin (primeProductNorm p x.divisor))) * + (primeProductNorm p x.overlap / normLogScale (normLogBin (primeProductNorm p x.overlap))) := by + simp only [secondLogX, secondExpansionScale, expansionSupportData, secondLogIndex, + secondLogE, secondLogV, primeSubsetGenerator_norm_eq_productNorm] + field_simp + + refine ⟨?_, ?_, ?_, ?_, ?_⟩ + · change |Real.log (primeProductNorm p x.overlap * _ / _)| ≤ 2 + rw [hratio, Real.log_mul (div_ne_zero hNE he) + (div_ne_zero (FirstPassCubeLabels.primeProductNorm_pos p hp x.overlap).ne' hv)] + rw [abs_of_nonneg (add_nonneg hE.1 hV.1)] + linarith [hE.2,hV.2] + · simp only [secondSectorUd, expansionSupportData, primeSubsetGenerator_norm_eq_productNorm, + div_self (FirstPassCubeLabels.primeProductNorm_pos p hp D).ne', Real.log_one, abs_zero] + norm_num + · change |Real.log (‖eisEmbedding _‖^2 / _)| ≤ 2 + rw [primeSubsetGenerator_norm_eq_productNorm] + change |Real.log (primeProductNorm p x.divisor / normLogScale (normLogBin (primeProductNorm p x.divisor)))| ≤ 2 + rw [abs_of_nonneg hE.1] + linarith [hE.2] + · change |Real.log (primeProductNorm p x.overlap / normLogScale (normLogBin (primeProductNorm p x.overlap)))| ≤ 2 + rw [abs_of_nonneg hV.1] + linarith [hV.2] + · change |Real.log (‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2 / + normLogScale (normLogBin (‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2)))| ≤ 2 + rw [abs_of_nonneg hK.1] + linarith [hK.2] + +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +theorem secondLogX_radial_scale (D R : Finset ι) (X Y : ℝ) (hX : X ≠ 0) (j : SecondLogIndex) : + Y * secondLogK j / (primeProductNorm p D * (secondLogE j)^2 * + (secondLogV j)^2 * (secondLogX p R X j)^2) = + Y * secondLogK j * (primeProductNorm p R)^2 / (primeProductNorm p D * X^2) := by + unfold secondLogX secondLogE secondLogV secondLogK normLogScale + field_simp + +end +section + +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm jLabel) +open ConcreteTraceCRT (eisEmbedding) + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + +def secondBaseLabel (B C : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) : O := + primeSubsetGenerator (fun i => Ideal.span {p i}) C * jLabel p B (fun i => v₁ i+v₂ i) ε₁ ε₂ + +include hp in +omit [DecidableEq ι] in +lemma secondBaseLabel_ne_zero (B C : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) : + secondBaseLabel p B C v₁ v₂ ε₁ ε₂ ≠ 0 := by + apply mul_ne_zero (primeSubsetGenerator_ne_zero _ _) + apply Finset.prod_ne_zero_iff.mpr + intro i hi + exact pow_ne_zero _ (hp i) + +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +theorem secondSupportNewLabel_norm (B C D : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (x : SecondExpansionData ι) : + (Ideal.absNorm (secondSupportNewLabel p B v₁ v₂ ε₁ ε₂ (expansionSupportData C D x)) : ℝ) = + ‖eisEmbedding (secondBaseLabel p B C v₁ v₂ ε₁ ε₂)‖^2 * + primeProductNorm p x.divisor * primeProductNorm p x.overlap := by + rw [← secondSupportLabel_span, ← eisEmbedding_norm_sq_eq_absNorm_span] + simp only [secondSupportLabel, expansionSupportData, secondBaseLabel, + map_mul, norm_mul, mul_pow, primeSubsetGenerator_norm_eq_productNorm, primeProductNorm] + +include hp in +omit [DecidableEq ι] in +lemma secondSupportNewLabel_ne_bot (B C D : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (x : SecondExpansionData ι) : + secondSupportNewLabel p B v₁ v₂ ε₁ ε₂ (expansionSupportData C D x) ≠ ⊥ := by + rw [← secondSupportLabel_span, ne_eq, Ideal.span_singleton_eq_bot] + exact mul_ne_zero (mul_ne_zero (secondBaseLabel_ne_zero p hp B C v₁ v₂ ε₁ ε₂) + (primeSubsetGenerator_ne_zero _ _)) (Finset.prod_ne_zero_iff.mpr (fun i hi => hp i)) + +def secondLogLabelBound (B C : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (j : SecondLogIndex) : ℝ := + ‖eisEmbedding (secondBaseLabel p B C v₁ v₂ ε₁ ε₂)‖^2 * secondLogE j * secondLogV j * Real.exp 2 + +include hp in +omit [DecidableEq ι] in +lemma secondLogLabelBound_ge_one (B C : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (j : SecondLogIndex) : 1 ≤ secondLogLabelBound p B C v₁ v₂ ε₁ ε₂ j := by + 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 + (element_norm_ge_one _ (secondBaseLabel_ne_zero p hp B C v₁ v₂ ε₁ ε₂)) + (normLogScale_ge_one _)) (normLogScale_ge_one _)) + (Real.one_le_exp (by norm_num)) + +include hp in + +omit [DecidableEq ι] in +theorem secondLogIndex_target_bounds (B C D : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (x : SecondExpansionData ι) (hk : x.frequency ≠ 0) : + (Ideal.absNorm (secondSupportNewLabel p B v₁ v₂ ε₁ ε₂ (expansionSupportData C D x)) : ℝ) ≤ + secondLogLabelBound p B C v₁ v₂ ε₁ ε₂ (secondLogIndex p D x) ∧ + ‖eisEmbedding (secondSupportRow p (expansionSupportData C D x))‖^2 ≤ + secondLogK (secondLogIndex p D x) * Real.exp 1 := by + have hE := (normLogBin_scale_bounds (primeProductNorm p x.divisor) (primeProductNorm_ge_one p hp _)).2 + have hV := (normLogBin_scale_bounds (primeProductNorm p x.overlap) (primeProductNorm_ge_one p hp _)).2 + have hK := (normLogBin_scale_bounds (‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2) + (element_norm_ge_one _ (actualSecondRow_ne_zero p D x.divisor x.frequency hk))).2 + refine ⟨?_, hK⟩ + rw [secondSupportNewLabel_norm] + calc + _ ≤ ‖eisEmbedding (secondBaseLabel p B C v₁ v₂ ε₁ ε₂)‖^2 * + (normLogScale (normLogBin (primeProductNorm p x.divisor))*Real.exp 1) * + (normLogScale (normLogBin (primeProductNorm p x.overlap))*Real.exp 1) := by + exact mul_le_mul (mul_le_mul_of_nonneg_left hE (sq_nonneg _)) hV + (FirstPassCubeLabels.primeProductNorm_pos p hp _).le + (mul_nonneg (sq_nonneg _) (mul_pos (normLogScale_pos _) (Real.exp_pos _)).le) + _ = _ := by + simp only [secondLogLabelBound, secondLogIndex, secondLogE, secondLogV] + rw [show (2:ℝ)=1+1 by norm_num, Real.exp_add] + ring + +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +theorem secondLogX_label_cost (B C R : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (X : ℝ) (j : SecondLogIndex) : + secondLogX p R X j * secondLogLabelBound p B C v₁ v₂ ε₁ ε₂ j = + X * ‖eisEmbedding (secondBaseLabel p B C v₁ v₂ ε₁ ε₂)‖^2 * Real.exp 2 / + primeProductNorm p R := by + unfold secondLogX secondLogLabelBound secondLogE secondLogV normLogScale + field_simp + +end + +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm) +open ConcreteTraceCRT (eisEmbedding) + +def secondLogBinBox (U K : ℝ) : Finset SecondLogIndex := + Finset.range (normLogBin U + 1) ×ˢ + (Finset.range (normLogBin U + 1) ×ˢ Finset.range (normLogBin K + 1)) + +lemma secondLogBinBox_card (U K : ℝ) : + (secondLogBinBox U K).card = (normLogBin U + 1)^2 * (normLogBin K + 1) := by + simp only [secondLogBinBox, Finset.card_product, Finset.card_range] + ring + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem secondSourceSupport_bounds (X M : ℝ) (x : SecondExpansionData ι) + (hx : SecondSourceSupport p X M x) (hE : x.divisor ⊆ x.sourceCommon) : + primeProductNorm p x.sourceCommon ≤ X*Real.exp M ∧ + primeProductNorm p x.divisor ≤ X*Real.exp M ∧ + primeProductNorm p x.overlap ≤ X*Real.exp M := by + have hG := (le_mul_of_one_le_right (FirstPassCubeLabels.primeProductNorm_pos p hp _).le + (primeProductNorm_ge_one p hp x.overlap)).trans hx.2 + have hV := (le_mul_of_one_le_left (FirstPassCubeLabels.primeProductNorm_pos p hp _).le + (primeProductNorm_ge_one p hp x.sourceCommon)).trans hx.2 + exact ⟨hG, (primeProductNorm_mono p hp hE).trans hG, hV⟩ + +include hp in +lemma secondLogIndex_mem_box (D : Finset ι) (X M K : ℝ) (x : SecondExpansionData ι) + (hx : SecondSourceSupport p X M x) (hE : x.divisor ⊆ x.sourceCommon) + (hk : x.frequency ≠ 0) + (hK : ‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2 ≤ K) : + secondLogIndex p D x ∈ secondLogBinBox (X*Real.exp M) K := by + obtain ⟨hG,hE',hV⟩ := secondSourceSupport_bounds p hp X M x hx hE + simp only [secondLogBinBox, secondLogIndex, Finset.mem_product, Finset.mem_range, + Nat.lt_succ_iff] + exact ⟨normLogBin_mono (FirstPassCubeLabels.primeProductNorm_pos p hp _) hE', + normLogBin_mono (FirstPassCubeLabels.primeProductNorm_pos p hp _) hV, + normLogBin_mono (by have h := element_norm_ge_one _ (actualSecondRow_ne_zero p D x.divisor x.frequency hk); linarith) hK⟩ + +def secondSupportedSector (F : Finset ι) (K : Finset ι → Finset ι → Finset O) + (R : Finset ι) (X M : ℝ) : Finset (SecondExpansionData ι) := + (secondExpansionSector F (fun G E => (K G E).erase 0) R).filter (SecondSourceSupport p X M) + +def secondLogSector (D F : Finset ι) (K : Finset ι → Finset ι → Finset O) + (R : Finset ι) (X M : ℝ) (j : SecondLogIndex) : Finset (SecondExpansionData ι) := + (secondSupportedSector p F K R X M).filter (fun x => secondLogIndex p D x = j) + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +lemma secondSupportedSector_mem (F : Finset ι) (K : Finset ι → Finset ι → Finset O) + (R : Finset ι) (X M : ℝ) (x : SecondExpansionData ι) + (hx : x ∈ secondSupportedSector p F K R X M) : + x.sourceCommon ⊆ F ∧ x.divisor ⊆ x.sourceCommon ∧ x.overlap ⊆ F ∧ + x.frequency ≠ 0 ∧ x.frequency ∈ K x.sourceCommon x.divisor ∧ + x.sourceCommon \ x.divisor = R ∧ SecondSourceSupport p X M x := by + obtain ⟨hx,hs⟩ := Finset.mem_filter.mp hx + obtain ⟨hx,hr⟩ := Finset.mem_filter.mp hx + obtain ⟨hG,hE,hV,hk⟩ := (mem_secondExpansionPool _ _ _).mp hx + obtain ⟨hk0,hk⟩ := Finset.mem_erase.mp hk + exact ⟨hG,hE,hV,hk0,hk,hr,hs⟩ + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +lemma secondLogSector_subset (D F : Finset ι) (K : Finset ι → Finset ι → Finset O) + (R : Finset ι) (X M : ℝ) (j : SecondLogIndex) : + secondLogSector p D F K R X M j ⊆ secondExpansionSector F (fun G E => (K G E).erase 0) R := + (Finset.filter_subset _ _).trans (Finset.filter_subset _ _) + +include hp in + +theorem sum_secondLogSector (D F : Finset ι) (K : Finset ι → Finset ι → Finset O) + (R : Finset ι) (X M Kmax : ℝ) + (hK : ∀ x ∈ secondSupportedSector p F K R X M, + ‖eisEmbedding (actualSecondRow p D x.divisor x.frequency)‖^2 ≤ Kmax) + (H : SecondExpansionData ι → ℂ) : + (∑ j ∈ secondLogBinBox (X*Real.exp M) Kmax, + ∑ x ∈ secondLogSector p D F K R X M j, H x) = + ∑ x ∈ secondSupportedSector p F K R X M, H x := by + simp only [secondLogSector, Finset.sum_filter] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro x hx + obtain ⟨hG,hE,hV,hk0,hk,hr,hs⟩ := secondSupportedSector_mem p F K R X M x hx + have hj := secondLogIndex_mem_box p hp D X M Kmax x hs hE hk0 (hK x hx) + rw [Finset.sum_eq_single_of_mem (secondLogIndex p D x) hj] + · simp + · intro j hj hne + simp [Ne.symm hne] + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem secondLogX_lower (D F R : Finset ι) (K : Finset ι → Finset ι → Finset O) + (X M : ℝ) (hX : 0 < X) (x : SecondExpansionData ι) + (hx : x ∈ secondSupportedSector p F K R X M) : + Real.exp (-M) ≤ secondLogX p R X (secondLogIndex p D x) := by + obtain ⟨hG,hE,hV,hk0,hk,hr,hs⟩ := secondSupportedSector_mem p F K R X M x hx + have he := (normLogBin_scale_bounds (primeProductNorm p x.divisor) (primeProductNorm_ge_one p hp _)).1 + have hv := (normLogBin_scale_bounds (primeProductNorm p x.overlap) (primeProductNorm_ge_one p hp _)).1 + have hGR : primeProductNorm p x.sourceCommon = primeProductNorm p x.divisor * primeProductNorm p R := by + rw [← hr, ← FirstPassCubeLabels.primeProductNorm_union p x.divisor (x.sourceCommon\x.divisor) Finset.disjoint_sdiff, + Finset.union_sdiff_of_subset hE] + have hprod : secondLogE (secondLogIndex p D x) * secondLogV (secondLogIndex p D x) * primeProductNorm p R ≤ X*Real.exp M := by + calc + _ ≤ primeProductNorm p x.divisor * primeProductNorm p x.overlap * primeProductNorm p R := by + exact mul_le_mul_of_nonneg_right (mul_le_mul he hv (normLogScale_pos _).le + (FirstPassCubeLabels.primeProductNorm_pos p hp _).le) + (FirstPassCubeLabels.primeProductNorm_pos p hp _).le + _ = primeProductNorm p x.sourceCommon * primeProductNorm p x.overlap := by rw [hGR]; ring + _ ≤ _ := hs.2 + unfold secondLogX + apply (le_div_iff₀ (mul_pos (mul_pos (normLogScale_pos _) (normLogScale_pos _)) + (FirstPassCubeLabels.primeProductNorm_pos p hp R))).mpr + calc + _ ≤ Real.exp (-M) * (X*Real.exp M) := mul_le_mul_of_nonneg_left hprod (Real.exp_pos _).le + _ = X := by rw [Real.exp_neg]; field_simp + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/HyperbolicSpace.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/HyperbolicSpace.lean new file mode 100644 index 0000000000000000000000000000000000000000..45627aa5498aa148b200452118190a3aa3480b3c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/HyperbolicSpace.lean @@ -0,0 +1,619 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.Rows + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid + +section +open scoped BigOperators Classical MatrixGroups Matrix + +section +open CubicKubota + +def compactSubgroup : Subgroup (SL(2,ℂ)) where + carrier := {k | (k : Matrix (Fin 2) (Fin 2) ℂ) ∈ Matrix.unitaryGroup (Fin 2) ℂ} + one_mem' := (Matrix.unitaryGroup (Fin 2) ℂ).one_mem + mul_mem' := by + intro a b ha hb + exact (Matrix.unitaryGroup (Fin 2) ℂ).mul_mem ha hb + inv_mem' := by + intro k hk + have hinv : (k⁻¹ : SL(2,ℂ)) * k = 1 := inv_mul_cancel k + have hmat : ((k⁻¹ : SL(2,ℂ)) : Matrix (Fin 2) (Fin 2) ℂ) * + (k : Matrix (Fin 2) (Fin 2) ℂ) = 1 := congrArg + (fun a : SL(2,ℂ) => (a : Matrix (Fin 2) (Fin 2) ℂ)) hinv + have he := Matrix.left_inv_eq_left_inv hmat (Matrix.mem_unitaryGroup_iff'.mp hk) + change ((k⁻¹ : SL(2,ℂ)) : Matrix (Fin 2) (Fin 2) ℂ) ∈ Matrix.unitaryGroup (Fin 2) ℂ + rw [he] + exact Unitary.star_mem hk + +abbrev HyperbolicSpace := SL(2,ℂ) ⧸ compactSubgroup + +def hyperbolicEisenstein (s : ℂ) : HyperbolicSpace → ℂ := + Quotient.lift (fun g => eisenstein g s) (by + intro g h hgh + have hk : g⁻¹*h ∈ compactSubgroup := QuotientGroup.leftRel_apply.mp hgh + have hh : h = g*(g⁻¹*h) := by group + rw [hh] + exact (eisenstein_right_unitary g (g⁻¹*h) s hk).symm) + +@[simp] lemma hyperbolicEisenstein_mk (s : ℂ) (g : SL(2,ℂ)) : + hyperbolicEisenstein s (g : HyperbolicSpace) = eisenstein g s := rfl + +theorem hyperbolicEisenstein_automorphy (M : levelThree) (s : ℂ) (hs : 2 < s.re) + (w : HyperbolicSpace) : + hyperbolicEisenstein s (complexMatrix M • w) = + complexCharacter M * hyperbolicEisenstein s w := by + induction w using Quotient.inductionOn with | _ g => + exact eisenstein_automorphy M g s hs + +def upperPoint (z : ℂ) (v : ℝ) (hv : 0 < v) : HyperbolicSpace := + (upperSection z v hv : HyperbolicSpace) + +lemma hyperbolicEisenstein_upperPoint (s : ℂ) (z : ℂ) (v : ℝ) (hv : 0 < v) : + hyperbolicEisenstein s (upperPoint z v hv) = upperEisenstein z v hv s := rfl + +def complexBottomRow (g : SL(2,ℂ)) : Fin 2 → ℂ := g 1 + +lemma complexBottomRow_mul (g h : SL(2,ℂ)) : + complexBottomRow (g*h) = rowOperator h (complexBottomRow g) := by + funext j + simp only [complexBottomRow, rowOperator_apply, Matrix.SpecialLinearGroup.coe_mul, + Matrix.mul_apply, Matrix.vecMul, dotProduct] + +lemma complexBottomRow_ne_zero (g : SL(2,ℂ)) : complexBottomRow g ≠ 0 := by + intro hz + have hc : g 1 0 = 0 := congrFun hz 0 + have hd : g 1 1 = 0 := congrFun hz 1 + have h : g 0 0 * g 1 1 - g 0 1 * g 1 0 = 1 := by + simpa only [Matrix.det_fin_two] using g.property + simp only [hc, hd, mul_zero, sub_zero] at h + exact zero_ne_one h + +def liftedHeight (g : SL(2,ℂ)) : ℝ := (rowEnergy (complexBottomRow g))⁻¹ + +lemma liftedHeight_pos (g : SL(2,ℂ)) : 0 < liftedHeight g := + inv_pos.mpr (rowEnergy_pos _ (complexBottomRow_ne_zero g)) + +lemma liftedHeight_right_unitary (g k : SL(2,ℂ)) (hk : k ∈ compactSubgroup) : + liftedHeight (g*k) = liftedHeight g := by + simp only [liftedHeight, complexBottomRow_mul, rowEnergy_unitary k hk] + +def hyperbolicHeight : HyperbolicSpace → ℝ := + Quotient.lift liftedHeight (by + intro g h hgh + have hk : g⁻¹*h ∈ compactSubgroup := QuotientGroup.leftRel_apply.mp hgh + have hh : h = g*(g⁻¹*h) := by group + rw [hh] + exact (liftedHeight_right_unitary g (g⁻¹*h) hk).symm) + +@[simp] lemma hyperbolicHeight_mk (g : SL(2,ℂ)) : + hyperbolicHeight (g : HyperbolicSpace) = liftedHeight g := rfl + +lemma hyperbolicHeight_pos (w : HyperbolicSpace) : 0 < hyperbolicHeight w := by + induction w using Quotient.inductionOn with | _ g => exact liftedHeight_pos g + +theorem hyperbolicHeight_action_upperPoint (g : SL(2,ℂ)) (z : ℂ) (v : ℝ) (hv : 0 < v) : + hyperbolicHeight (g • upperPoint z v hv) = + v / (‖g 1 0*z + g 1 1‖ ^ 2 + ‖g 1 0‖ ^ 2 * v ^ 2) := by + change liftedHeight (g * upperSection z v hv) = _ + rw [liftedHeight, complexBottomRow_mul, rowEnergy_upperSection, inv_div] + rfl + +def cosetHeight (x : CuspCosets) : HyperbolicSpace → ℝ := + Quotient.lift (fun g : SL(2,ℂ) => (rowEnergy (rowOperator g (embeddedRow x)))⁻¹) (by + intro g h hgh + have hk : g⁻¹*h ∈ compactSubgroup := QuotientGroup.leftRel_apply.mp hgh + have hh : h = g*(g⁻¹*h) := by group + rw [hh, ← rowOperator_mul, rowEnergy_unitary (g⁻¹*h) hk]) + +lemma cosetHeight_cosetOf (M : levelThree) (w : HyperbolicSpace) : + cosetHeight (cosetOf M) w = hyperbolicHeight (complexMatrix M • w) := by + induction w using Quotient.inductionOn with | _ g => + change (rowEnergy (rowOperator g (embeddedRow (cosetOf M))))⁻¹ = + liftedHeight (complexMatrix M * g) + rw [liftedHeight, complexBottomRow_mul] + rfl + +theorem hyperbolicEisenstein_eq_height_series (s : ℂ) (w : HyperbolicSpace) : + hyperbolicEisenstein s w = ∑' x : CuspCosets, + (cosetCharacter x)⁻¹ * (cosetHeight x w : ℂ) ^ s := by + induction w using Quotient.inductionOn with | _ g => + apply tsum_congr + intro x + change (cosetCharacter x)⁻¹ * + (rowEnergy (rowOperator g (embeddedRow x)) : ℂ) ^ (-s) = + (cosetCharacter x)⁻¹ * ((rowEnergy (rowOperator g (embeddedRow x)))⁻¹ : ℝ) ^ s + rw [Complex.ofReal_inv, Complex.inv_cpow_ofReal_nonneg (rowEnergy_nonneg _), + Complex.cpow_neg] + +theorem height_series_summable_norm (s : ℂ) (hs : 2 < s.re) (w : HyperbolicSpace) : + Summable (fun x : CuspCosets => + ‖(cosetCharacter x)⁻¹ * (cosetHeight x w : ℂ) ^ s‖) := by + induction w using Quotient.inductionOn with | _ g => + apply (summable_norm_summand g s hs).congr + intro x + congr 1 + change (cosetCharacter x)⁻¹ * + (rowEnergy (rowOperator g (embeddedRow x)) : ℂ) ^ (-s) = + (cosetCharacter x)⁻¹ * ((rowEnergy (rowOperator g (embeddedRow x)))⁻¹ : ℝ) ^ s + rw [Complex.ofReal_inv, Complex.inv_cpow_ofReal_nonneg (rowEnergy_nonneg _), + Complex.cpow_neg] + +theorem hyperbolicEisenstein_differentiableOn (w : HyperbolicSpace) : + DifferentiableOn ℂ (fun s : ℂ => hyperbolicEisenstein s w) {s : ℂ | 2 < s.re} := by + induction w using Quotient.inductionOn with | _ g => + exact eisenstein_differentiableOn g + +end + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT + +def upperTranslation (a : O) : levelThree := by + let M : SL(2,O) := ⟨!![1, 3*a; 0, 1], by simp⟩ + refine ⟨M, ?_⟩ + change Matrix.SpecialLinearGroup.map (n := Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3 : O)})) M = 1 + have h3 : Ideal.Quotient.mk (Ideal.span {(3 : O)}) (3 : O) = 0 := + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp)) + apply Subtype.ext + funext i j + change Ideal.Quotient.mk (Ideal.span {(3 : O)}) ((!![(1 : O), 3*a; 0, 1]) i j) = + (1 : Matrix (Fin 2) (Fin 2) (O ⧸ Ideal.span {(3 : O)})) i j + fin_cases i <;> fin_cases j <;> simp [h3, map_mul] + +lemma complexCharacter_upperTranslation (a : O) : complexCharacter (upperTranslation a) = 1 := by + change eisEmbedding (value (upperTranslation a)) = 1 + rw [value_zero_lower_left _ (by rfl), map_one] + +lemma upperTranslation_section (a : O) (z : ℂ) (v : ℝ) (hv : 0 < v) : + complexMatrix (upperTranslation a) * upperSection z v hv = + upperSection (z + 3*eisEmbedding a) v hv := by + apply Subtype.ext + funext i j + change (((!![(1 : O), 3*a; 0, 1]).map eisEmbedding) * + !![(Real.sqrt v : ℂ), z/(Real.sqrt v : ℂ); 0, (Real.sqrt v : ℂ)⁻¹]) i j = + (!![(Real.sqrt v : ℂ), (z+3*eisEmbedding a)/(Real.sqrt v : ℂ); + 0, (Real.sqrt v : ℂ)⁻¹]) i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, map_mul] ; + norm_num only [map_ofNat] ; ring + +theorem upperEisenstein_periodic (a : O) (z : ℂ) (v : ℝ) (hv : 0 < v) + (s : ℂ) (hs : 2 < s.re) : + upperEisenstein (z + 3*eisEmbedding a) v hv s = upperEisenstein z v hv s := by + unfold upperEisenstein + rw [← upperTranslation_section, eisenstein_automorphy _ _ _ hs, + complexCharacter_upperTranslation, one_mul] + +end + +open MeasureTheory Set Filter +open scoped BigOperators Classical + +lemma integral_radial_sq (f : ℝ → ℂ) : + (∫ z : ℂ, f (‖z‖ ^ 2)) = (Real.pi : ℂ) * ∫ t : ℝ in Set.Ioi 0, f t := by + have hball : (volume : Measure ℂ).real (Metric.ball 0 1) = Real.pi := by + simp [Measure.real, Complex.volume_ball] + have hpolar := integral_fun_norm_addHaar (volume : Measure ℂ) (fun r : ℝ => f (r^2)) + have hsub := integral_comp_rpow_Ioi (E := ℂ) f (p := 2) (by norm_num) + norm_num [Real.rpow_two, Real.rpow_one] at hsub + simp only [Complex.finrank_real_complex, hball, Nat.reduceSub, pow_one, + nsmul_eq_mul, Complex.real_smul, ] at hpolar hsub + rw [hpolar] + rw [← hsub] + rw [show (fun x : ℝ => (2:ℂ)*x*f (x^2)) = + (fun x : ℝ => (2:ℂ)*(x*f (x^2))) by funext x; ring, integral_const_mul] + ring + +lemma integrable_radial_sq_iff (f : ℝ → ℂ) : + Integrable (fun z : ℂ => f (‖z‖ ^ 2)) ↔ IntegrableOn f (Set.Ioi 0) := by + rw [integrable_fun_norm_addHaar (volume : Measure ℂ) (f := fun r : ℝ => f (r^2))] + have h := integrableOn_Ioi_comp_rpow_iff' (E := ℂ) f (p := 2) (by norm_num) + simpa only [Complex.finrank_real_complex, Nat.reduceSub, pow_one, + show (2:ℝ)-1=1 by norm_num, Real.rpow_one, Real.rpow_two] using h + +lemma add_one_image_Ioi : (fun x : ℝ => x+1) '' Set.Ioi 0 = Set.Ioi 1 := by + ext y + constructor + · rintro ⟨x,hx,rfl⟩ + simp only [Set.mem_Ioi] at * + linarith + · intro hy + refine ⟨y-1, ?_, by ring⟩ + simp only [Set.mem_Ioi] at * + linarith + +lemma integrable_add_one_Ioi_iff (f : ℝ → ℂ) : + IntegrableOn (fun x : ℝ => f (x+1)) (Set.Ioi 0) ↔ IntegrableOn f (Set.Ioi 1) := by + have h := integrableOn_image_iff_integrableOn_abs_deriv_smul + measurableSet_Ioi + (fun x (hx : x ∈ Set.Ioi (0:ℝ)) => (hasDerivAt_id x |>.add_const 1).hasDerivWithinAt) + (fun x hx y hy hxy => by dsimp at hxy; linarith : InjOn (fun x : ℝ => x+1) (Set.Ioi 0)) f + simp only [id_eq] at h + rw [add_one_image_Ioi] at h + simpa only [abs_one, one_smul] using h.symm + +lemma integral_add_one_Ioi (f : ℝ → ℂ) : + (∫ x : ℝ in Set.Ioi 0, f (x+1)) = ∫ x : ℝ in Set.Ioi 1, f x := by + have h := integral_image_eq_integral_abs_deriv_smul + measurableSet_Ioi + (fun x (hx : x ∈ Set.Ioi (0:ℝ)) => (hasDerivAt_id x |>.add_const 1).hasDerivWithinAt) + (fun x hx y hy hxy => by dsimp at hxy; linarith : InjOn (fun x : ℝ => x+1) (Set.Ioi 0)) f + simp only [id_eq] at h + rw [add_one_image_Ioi] at h + simpa only [abs_one, one_smul] using h.symm + +def hyperbolicKernel (s : ℂ) (z : ℂ) : ℂ := ((1+‖z‖^2 : ℝ) : ℂ) ^ (-s) + +lemma hyperbolicKernel_integrable (s : ℂ) (hs : 1 < s.re) : + Integrable (hyperbolicKernel s) := by + unfold hyperbolicKernel + rw [integrable_radial_sq_iff (fun t : ℝ => ((1+t : ℝ) : ℂ)^(-s))] + have h := (integrable_add_one_Ioi_iff (fun x : ℝ => (x : ℂ)^(-s))).mpr + (integrableOn_Ioi_cpow_of_lt (by simpa using neg_lt_neg hs) (by norm_num : (0:ℝ)<1)) + simpa only [add_comm] using h + +theorem integral_hyperbolicKernel (s : ℂ) (hs : 1 < s.re) : + (∫ z : ℂ, hyperbolicKernel s z) = (Real.pi : ℂ) / (s-1) := by + unfold hyperbolicKernel + rw [integral_radial_sq (fun t : ℝ => ((1+t : ℝ) : ℂ)^(-s))] + simp_rw [add_comm (1:ℝ)] + rw [integral_add_one_Ioi (fun t : ℝ => (t : ℂ)^(-s))] + rw [integral_Ioi_cpow_of_lt (by simpa using neg_lt_neg hs) (by norm_num : (0:ℝ)<1)] + simp only [Complex.ofReal_one, Complex.one_cpow] + have hn : (-s+1)⁻¹ = -(s-1)⁻¹ := by + rw [show -s+1=-(s-1) by ring, inv_neg] + simp only [div_eq_mul_inv, hn] + ring + +open MeasureTheory Set Filter +open scoped BigOperators Classical FourierTransform RealInnerProductSpace + +lemma breveE_norm (z : ℂ) : ‖ShortDraftTrace.breveE z‖ = 1 := by + change ‖Complex.exp (2 * Real.pi * Complex.I * (z + starRingEnd ℂ z))‖ = 1 + rw [Complex.norm_exp] + have hre : (2 * Real.pi * Complex.I * (z + starRingEnd ℂ z)).re = 0 := by + simp [Complex.mul_re, Complex.mul_im] + rw [hre, Real.exp_zero] + +def sourceFourierKernel (s freq : ℂ) : ℂ := + ∫ z : ℂ, hyperbolicKernel s z * ShortDraftTrace.breveE (-freq*z) + +lemma sourceFourierKernel_integrable (s freq : ℂ) (hs : 1 < s.re) : + Integrable (fun z : ℂ => hyperbolicKernel s z * ShortDraftTrace.breveE (-freq*z)) := by + apply (hyperbolicKernel_integrable s hs).norm.mono' + · have hker : Continuous (hyperbolicKernel s) := by + unfold hyperbolicKernel + apply Continuous.cpow + · fun_prop + · exact continuous_const + · intro z + exact Complex.ofReal_mem_slitPlane.mpr (by positivity) + have hchar : Continuous (fun z : ℂ => ShortDraftTrace.breveE (-freq*z)) := by + change Continuous (fun z : ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + exact (hker.mul hchar).aestronglyMeasurable + · exact Eventually.of_forall (fun z => by simp only [norm_mul, breveE_norm, mul_one, le_refl]) + +lemma sourceFourierKernel_zero (s : ℂ) (hs : 1 < s.re) : + sourceFourierKernel s 0 = (Real.pi : ℂ)/(s-1) := by + simpa only [sourceFourierKernel, neg_zero, zero_mul, AddChar.map_zero_eq_one, mul_one] + using integral_hyperbolicKernel s hs + +lemma sourceFrequency_inner (z freq : ℂ) : inner ℝ z (2*starRingEnd ℂ freq) = 2*(freq*z).re := by + rw [real_inner_eq_re_inner (𝕜 := ℂ), RCLike.inner_apply] + change ((2 * starRingEnd ℂ freq) * starRingEnd ℂ z).re = _ + simp [Complex.mul_re, Complex.mul_im] + ring + +lemma traceIntegral_eq_fourier (f : ℂ → ℂ) (freq : ℂ) : + (∫ z : ℂ, f z * ShortDraftTrace.breveE (-freq*z)) = 𝓕 f (2*starRingEnd ℂ freq) := by + rw [Real.fourier_eq'] + apply integral_congr_ae + exact Eventually.of_forall (fun z => by + dsimp only + rw [sourceFrequency_inner] + change f z * + Complex.exp (2*Real.pi*Complex.I*((-freq*z)+starRingEnd ℂ (-freq*z))) = _ + simp only [smul_eq_mul] + rw [mul_comm (f z)] + congr 1 + congr 1 + apply Complex.ext <;> simp [Complex.mul_re, Complex.mul_im] <;> ring) + +lemma sourceFourierKernel_eq_fourier (s freq : ℂ) : + sourceFourierKernel s freq = 𝓕 (hyperbolicKernel s) (2*starRingEnd ℂ freq) := + traceIntegral_eq_fourier (hyperbolicKernel s) freq + +lemma hyperbolicKernel_laplace (s : ℂ) (hs : 0 < s.re) (z : ℂ) : + hyperbolicKernel s z * Complex.Gamma s = + ∫ t : ℝ in Set.Ioi 0, (t : ℂ)^(s-1) * + Complex.exp (-((1+‖z‖^2 : ℝ) : ℂ) * t) := by + have h := Complex.integral_cpow_mul_exp_neg_mul_Ioi hs + (by positivity : 0 < 1+‖z‖^2) + simp only [neg_mul] + rw [h] + congr 1 + rw [hyperbolicKernel, one_div, Complex.inv_cpow_ofReal_nonneg (by positivity), + Complex.cpow_neg] + +lemma source_gaussian_fourier (t : ℝ) (ht : 0 < t) (freq : ℂ) : + 𝓕 (fun z : ℂ => Complex.exp (-(t : ℂ)*‖z‖^2)) (2*starRingEnd ℂ freq) = + (Real.pi : ℂ)/t * Complex.exp (-(4*Real.pi^2*‖freq‖^2 : ℝ)/t) := by + rw [fourier_gaussian_innerProductSpace (by simpa using ht)] + norm_num only [Complex.finrank_real_complex, Nat.cast_ofNat, div_self (by norm_num : (2:ℂ)≠0), + Complex.cpow_one, norm_mul, Complex.norm_conj, Complex.norm_ofNat] + congr 2 + push_cast + ring + +def gaussianMixture (s freq : ℂ) (t : ℝ) (z : ℂ) : ℂ := + (t : ℂ)^(s-1) * Complex.exp (-t) * + Complex.exp (-(t : ℂ)*‖z‖^2) * ShortDraftTrace.breveE (-freq*z) + +lemma norm_gaussianMixture (s freq : ℂ) (t : ℝ) (ht : 0 < t) (z : ℂ) : + ‖gaussianMixture s freq t z‖ = + t ^ (s.re-1) * Real.exp (-t) * Real.exp (-t*‖z‖^2) := by + simp only [gaussianMixture, norm_mul, breveE_norm, mul_one, + Complex.norm_cpow_eq_rpow_re_of_pos ht, Complex.sub_re, Complex.one_re, + Complex.norm_exp, Complex.neg_re, Complex.ofReal_re, Complex.mul_re, + Complex.ofReal_im, ← Complex.ofReal_pow, Complex.neg_im, neg_zero, zero_mul, sub_zero] + +lemma gaussianMixture_slice_integrable (s freq : ℂ) (t : ℝ) (ht : 0 < t) : + Integrable (gaussianMixture s freq t) := by + have hg : Integrable (fun z : ℂ => Complex.exp (-(t : ℂ)*‖z‖^2)) := by + simpa only [zero_mul, add_zero] using GaussianFourier.integrable_cexp_neg_mul_sq_norm_add + (by simpa using ht : 0 < (t : ℂ).re) 0 (0 : ℂ) + apply ((hg.const_mul ((t : ℂ)^(s-1)*Complex.exp (-t))).norm).mono' + · unfold gaussianMixture + change AEStronglyMeasurable (fun z : ℂ => (t : ℂ)^(s-1)*Complex.exp (-t)* + Complex.exp (-(t : ℂ)*‖z‖^2) * + Complex.exp (2*Real.pi*Complex.I*((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + · exact Eventually.of_forall fun z => by + simp only [gaussianMixture, norm_mul, breveE_norm, mul_one, le_refl] + +lemma integral_norm_gaussianMixture (s freq : ℂ) (t : ℝ) (ht : 0 < t) : + (∫ z : ℂ, ‖gaussianMixture s freq t z‖) = + Real.pi * (Real.exp (-t)*t^(s.re-2)) := by + simp_rw [norm_gaussianMixture s freq t ht] + rw [integral_const_mul, GaussianFourier.integral_rexp_neg_mul_sq_norm ht] + norm_num only [Complex.finrank_real_complex, Nat.cast_ofNat, div_self (by norm_num : (2:ℝ)≠0), + Real.rpow_one] + have hp : t^(s.re-1)/t = t^(s.re-2) := by + calc + t^(s.re-1)/t = t^(s.re-1)/t^(1:ℝ) := by rw [Real.rpow_one] + _ = t^((s.re-1)-1) := (Real.rpow_sub ht _ _).symm + _ = _ := by congr 1; ring + calc + t^(s.re-1)*Real.exp (-t)*(Real.pi/t) = Real.pi*(Real.exp (-t)*(t^(s.re-1)/t)) := by ring + _ = _ := by rw [hp] + +theorem gaussianMixture_integrable (s freq : ℂ) (hs : 1 < s.re) : + Integrable (fun p : ℝ × ℂ => gaussianMixture s freq p.1 p.2) + ((volume.restrict (Set.Ioi 0)).prod volume) := by + have hmeas : AEStronglyMeasurable (fun p : ℝ × ℂ => gaussianMixture s freq p.1 p.2) + ((volume.restrict (Set.Ioi 0)).prod volume) := by + unfold gaussianMixture + change AEStronglyMeasurable (fun p : ℝ × ℂ => + (p.1 : ℂ)^(s-1)*Complex.exp (-p.1)*Complex.exp (-(p.1 : ℂ)*‖p.2‖^2)* + Complex.exp (2*Real.pi*Complex.I*((-freq*p.2)+starRingEnd ℂ (-freq*p.2)))) _ + fun_prop + apply (integrable_prod_iff hmeas).mpr + constructor + · filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + exact gaussianMixture_slice_integrable s freq t ht + · have hgamma := (Real.GammaIntegral_convergent (by linarith : 0 < s.re-1)).const_mul Real.pi + apply hgamma.congr + filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + rw [integral_norm_gaussianMixture s freq t ht] + congr 2 + ring_nf + +open MeasureTheory Set Filter +open scoped BigOperators Classical FourierTransform RealInnerProductSpace + +lemma gaussianMixture_laplace_form (s freq : ℂ) (t : ℝ) (z : ℂ) : + gaussianMixture s freq t z = + ((t : ℂ)^(s-1) * Complex.exp (-((1+‖z‖^2 : ℝ) : ℂ)*t)) * + ShortDraftTrace.breveE (-freq*z) := by + have he : Complex.exp (-(t : ℂ))*Complex.exp (-(t : ℂ)*‖z‖^2) = + Complex.exp (-((1+‖z‖^2 : ℝ) : ℂ)*t) := by + rw [← Complex.exp_add] + congr 1 + push_cast + ring + calc + _ = (t : ℂ)^(s-1) * (Complex.exp (-(t : ℂ))*Complex.exp (-(t : ℂ)*‖z‖^2)) * + ShortDraftTrace.breveE (-freq*z) := by unfold gaussianMixture; ring + _ = _ := by rw [he] + +lemma integral_gaussianMixture_t (s freq : ℂ) (hs : 0 < s.re) (z : ℂ) : + (∫ t : ℝ in Set.Ioi 0, gaussianMixture s freq t z) = + (hyperbolicKernel s z * Complex.Gamma s)*ShortDraftTrace.breveE (-freq*z) := by + simp_rw [gaussianMixture_laplace_form] + rw [integral_mul_const, ← hyperbolicKernel_laplace s hs z] + +lemma integral_gaussianMixture_z (s freq : ℂ) (t : ℝ) (ht : 0 < t) : + (∫ z : ℂ, gaussianMixture s freq t z) = + (Real.pi : ℂ) * ((t : ℂ)^(s-2) * + Complex.exp (-(t : ℂ) - (4*Real.pi^2*‖freq‖^2 : ℝ)/t)) := by + have hfac : (fun z : ℂ => gaussianMixture s freq t z) = + (fun z : ℂ => ((t : ℂ)^(s-1)*Complex.exp (-t))* + (Complex.exp (-(t : ℂ)*‖z‖^2)*ShortDraftTrace.breveE (-freq*z))) := by + funext z + unfold gaussianMixture + ring + rw [hfac, integral_const_mul, traceIntegral_eq_fourier, source_gaussian_fourier t ht freq] + have hp : (t : ℂ)^(s-1)/(t : ℂ) = (t : ℂ)^(s-2) := by + calc + _ = (t : ℂ)^(s-1)/(t : ℂ)^(1 : ℂ) := by rw [Complex.cpow_one] + _ = (t : ℂ)^((s-1)-1) := (Complex.cpow_sub _ _ (Complex.ofReal_ne_zero.mpr ht.ne')).symm + _ = _ := by congr 1; ring + calc + _ = (Real.pi : ℂ)*(((t : ℂ)^(s-1)/t)* + (Complex.exp (-(t : ℂ))*Complex.exp (-(4*Real.pi^2*‖freq‖^2 : ℝ)/t))) := by ring + _ = _ := by rw [hp, ← Complex.exp_add]; congr 2; ring_nf + +theorem sourceFourierKernel_gamma (s freq : ℂ) (hs : 1 < s.re) : + sourceFourierKernel s freq * Complex.Gamma s = + (Real.pi : ℂ) * ∫ t : ℝ in Set.Ioi 0, + (t : ℂ)^(s-2) * Complex.exp (-(t : ℂ) - (4*Real.pi^2*‖freq‖^2 : ℝ)/t) := by + have hmix := gaussianMixture_integrable s freq hs + calc + _ = ∫ z : ℂ, (hyperbolicKernel s z * Complex.Gamma s)* + ShortDraftTrace.breveE (-freq*z) := by + rw [sourceFourierKernel, ← integral_mul_const] + apply integral_congr_ae + exact Eventually.of_forall fun z => by ring + _ = ∫ z : ℂ, ∫ t : ℝ in Set.Ioi 0, gaussianMixture s freq t z := by + apply integral_congr_ae + exact Eventually.of_forall fun z => (integral_gaussianMixture_t s freq (by linarith) z).symm + _ = ∫ t : ℝ in Set.Ioi 0, ∫ z : ℂ, gaussianMixture s freq t z := + (integral_integral_swap hmix).symm + _ = _ := by + rw [← integral_const_mul] + apply setIntegral_congr_fun measurableSet_Ioi + intro t ht + exact integral_gaussianMixture_z s freq t ht + +def schlafliIntegral (ν : ℂ) (x : ℝ) : ℂ := + ∫ t : ℝ in Set.Ioi 0, (t : ℂ)^(ν-1)* + Complex.exp (-(t : ℂ) - (x : ℂ)^2/(4*t)) + +lemma schlafliIntegral_integrable (ν : ℂ) (x : ℝ) (hν : 0 < ν.re) : + IntegrableOn (fun t : ℝ => (t : ℂ)^(ν-1)* + Complex.exp (-(t : ℂ)-(x : ℂ)^2/(4*t))) (Set.Ioi 0) := by + apply (Real.GammaIntegral_convergent hν).mono' + · fun_prop + · filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + change 0 < t at ht + have hre : (-(t : ℂ)-(x : ℂ)^2/(4*t)).re = -t-x^2/(4*t) := by + rw [show -(t : ℂ)-(x : ℂ)^2/(4*t) = ((-t-x^2/(4*t) : ℝ) : ℂ) by push_cast; rfl] + rfl + rw [norm_mul, Complex.norm_cpow_eq_rpow_re_of_pos ht, Complex.norm_exp, hre] + simp only [Complex.sub_re, Complex.one_re] + have he := Real.exp_le_exp.mpr (show -t-x^2/(4*t) ≤ -t by linarith [div_nonneg (sq_nonneg x) (show 0 ≤ 4*t by positivity)]) + have hb := mul_le_mul_of_nonneg_left he (Real.rpow_nonneg ht.le (ν.re-1)) + simpa only [mul_comm] using hb + +def schlafliBesselK (ν : ℂ) (x : ℝ) : ℂ := + (1/2 : ℂ)*(x/2 : ℂ)^(-ν)*schlafliIntegral ν x + +lemma sourceFourierKernel_gamma_schlafli (s freq : ℂ) (hs : 1 < s.re) : + sourceFourierKernel s freq * Complex.Gamma s = + (Real.pi : ℂ)*schlafliIntegral (s-1) (4*Real.pi*‖freq‖) := by + rw [sourceFourierKernel_gamma s freq hs] + congr 1 + apply setIntegral_congr_fun measurableSet_Ioi + intro t ht + rw [show s-2=(s-1)-1 by ring] + apply congrArg (fun w : ℂ => (t : ℂ)^((s-1)-1)*Complex.exp w) + push_cast + ring + +theorem sourceFourierKernel_bessel (s freq : ℂ) (hs : 1 < s.re) (hf : freq ≠ 0) : + sourceFourierKernel s freq = + (2*Real.pi : ℂ)/Complex.Gamma s * + (2*Real.pi*‖freq‖ : ℂ)^(s-1) * + schlafliBesselK (s-1) (4*Real.pi*‖freq‖) := by + have hg := Complex.Gamma_ne_zero_of_re_pos (show 0 < s.re by linarith) + have hz : (2*Real.pi*‖freq‖ : ℂ) ≠ 0 := by + exact mul_ne_zero (mul_ne_zero (by norm_num) (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero)) + (Complex.ofReal_ne_zero.mpr (norm_ne_zero_iff.mpr hf)) + have hp : (2*Real.pi*‖freq‖ : ℂ)^(s-1) * (2*Real.pi*‖freq‖ : ℂ)^(-(s-1)) = 1 := by + rw [← Complex.cpow_add _ _ hz, add_neg_cancel, Complex.cpow_zero] + have hreorder : (2*Real.pi : ℂ)/Complex.Gamma s * + (2*Real.pi*‖freq‖ : ℂ)^(s-1) * schlafliBesselK (s-1) (4*Real.pi*‖freq‖) = + ((2*Real.pi : ℂ)*(2*Real.pi*‖freq‖ : ℂ)^(s-1)* + schlafliBesselK (s-1) (4*Real.pi*‖freq‖))/Complex.Gamma s := by ring + rw [hreorder] + apply (eq_div_iff hg).mpr + rw [sourceFourierKernel_gamma_schlafli s freq hs] + unfold schlafliBesselK + push_cast + have hhalf : (4*(Real.pi : ℂ)*‖freq‖)/2 = 2*Real.pi*‖freq‖ := by ring + rw [hhalf] + linear_combination -((Real.pi : ℂ)*schlafliIntegral (s-1) (4*Real.pi*‖freq‖))*hp + +theorem sourceFourierKernel_four_thirds (freq : ℂ) (hf : freq ≠ 0) : + sourceFourierKernel (4/3 : ℂ) freq = + (2*Real.pi : ℂ)/Complex.Gamma (4/3) * + (2*Real.pi*‖freq‖ : ℂ)^(1/3 : ℂ) * + schlafliBesselK (1/3) (4*Real.pi*‖freq‖) := by + convert sourceFourierKernel_bessel (4/3) freq (by norm_num) hf using 1 ; norm_num + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/HyperbolicVolume.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/HyperbolicVolume.lean new file mode 100644 index 0000000000000000000000000000000000000000..9a844c398867e2bb5a6d11cdf06d7186946e693b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/HyperbolicVolume.lean @@ -0,0 +1,630 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.ArithmeticBins + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein +open Filter MeasureTheory EuclideanGeometry +open scoped BigOperators Classical Topology InnerProductSpace ENNReal Matrix + +lemma linear_preserves_hyperbolicVolume (A : EuclideanSpatial →L[ℝ] EuclideanSpatial) + (k : ℝ) (hk : 0 A) A.continuous.measurable + (fun p hp => A.hasFDerivAt) hinj.injOn + · apply Set.Subset.antisymm + · rintro q ⟨p,hp,rfl⟩ + exact show 0<(A p) 2 by rw [hh]; exact mul_pos hk hp + · intro q hq + obtain ⟨p,hp⟩ := hsurj q + refine ⟨p,?_,hp⟩ + change 0

p+u) hyperbolicEuclideanVolume=hyperbolicEuclideanVolume := by + apply hyperbolic_volume_map_of_jacobian (fun p => p+u) (fun _ => ContinuousLinearMap.id ℝ _) + (continuous_id.add continuous_const).measurable + (fun p hp => (hasFDerivAt_id p).add_const u) (add_left_injective u).injOn + · apply Set.Subset.antisymm + · rintro q ⟨p,hp,rfl⟩ + simpa [euclideanUpperHalf,hu] using hp + · intro p hp + refine ⟨p-u,?_,sub_add_cancel p u⟩ + simpa [euclideanUpperHalf,hu] using hp + · intro p hp + have hid : (ContinuousLinearMap.id ℝ EuclideanSpatial).det=1 := by + change LinearMap.det (LinearMap.id : EuclideanSpatial →ₗ[ℝ] EuclideanSpatial)=1 + simp + simp [hyperbolicDensity,hu,hid] + +def euclideanMatrixOperator (M : Matrix (Fin 3) (Fin 3) ℝ) : + EuclideanSpatial →L[ℝ] EuclideanSpatial := M.toEuclideanLin.toContinuousLinearMap + +lemma euclideanMatrixOperator_apply (M : Matrix (Fin 3) (Fin 3) ℝ) (p : EuclideanSpatial) + (j : Fin 3) : euclideanMatrixOperator M p j=∑i,M j i*p i := rfl + +lemma euclideanMatrixOperator_det (M : Matrix (Fin 3) (Fin 3) ℝ) : + (euclideanMatrixOperator M).det=M.det := by + change LinearMap.det (Matrix.toEuclideanLin M)=M.det + rw [Matrix.toEuclideanLin_eq_toLin_orthonormal,LinearMap.det_toLin] + +def euclideanWeylReflection : EuclideanSpatial →L[ℝ] EuclideanSpatial := + euclideanMatrixOperator !![-1,0,0;0,1,0;0,0,1] + +lemma euclideanWeylReflection_apply (p : EuclideanSpatial) : + euclideanWeylReflection p 0= -p 0 ∧ euclideanWeylReflection p 1=p 1 ∧ + euclideanWeylReflection p 2=p 2 := by + simp [euclideanWeylReflection,euclideanMatrixOperator_apply,Fin.sum_univ_three] + +lemma euclideanWeylReflection_preserves_hyperbolicVolume : + Measure.map euclideanWeylReflection hyperbolicEuclideanVolume=hyperbolicEuclideanVolume := by + apply linear_preserves_hyperbolicVolume euclideanWeylReflection 1 (by norm_num) + · intro p + simpa using (euclideanWeylReflection_apply p).2.2 + · norm_num [euclideanWeylReflection,euclideanMatrixOperator_det,Matrix.det_fin_three] + +def euclideanComplexDilation (β : ℂ) : EuclideanSpatial →L[ℝ] EuclideanSpatial := + euclideanMatrixOperator !![(β^2).re,-(β^2).im,0;(β^2).im,(β^2).re,0;0,0,Complex.normSq β] + +lemma euclideanComplexDilation_apply (β : ℂ) (p : EuclideanSpatial) : + euclideanComplexDilation β p 0=(β^2).re*p 0-(β^2).im*p 1 ∧ + euclideanComplexDilation β p 1=(β^2).im*p 0+(β^2).re*p 1 ∧ + euclideanComplexDilation β p 2=Complex.normSq β*p 2 := by + simp [euclideanComplexDilation,euclideanMatrixOperator_apply,Fin.sum_univ_three,sub_eq_add_neg] + +lemma euclideanComplexDilation_det (β : ℂ) : + (euclideanComplexDilation β).det=Complex.normSq β^3 := by + rw [euclideanComplexDilation,euclideanMatrixOperator_det,Matrix.det_fin_three] + have h : (β^2).re^2+(β^2).im^2=(Complex.normSq β)^2 := by + simpa [Complex.normSq_apply,sq] using map_pow Complex.normSq β 2 + change (β^2).re*(β^2).re*Complex.normSq β-(β^2).re*0*0- + (-(β^2).im)*(β^2).im*Complex.normSq β+(-(β^2).im)*0*0+ + 0*(β^2).im*0-0*(β^2).re*0=Complex.normSq β^3 + calc + _ = ((β^2).re^2+(β^2).im^2)*Complex.normSq β := by ring + _ = _ := by rw [h]; ring + +lemma euclideanComplexDilation_preserves_hyperbolicVolume (β : ℂ) (hβ : β≠0) : + Measure.map (euclideanComplexDilation β) hyperbolicEuclideanVolume=hyperbolicEuclideanVolume := by + apply linear_preserves_hyperbolicVolume (euclideanComplexDilation β) (Complex.normSq β) + (Complex.normSq_pos.mpr hβ) (fun p => (euclideanComplexDilation_apply β p).2.2) + rw [euclideanComplexDilation_det,abs_of_nonneg (pow_nonneg (Complex.normSq_nonneg β) 3)] + +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +namespace CubicEisenstein + +instance hyperbolicMeasurableSpace : MeasurableSpace HyperbolicSpace := borel HyperbolicSpace +instance hyperbolicBorelSpace : BorelSpace HyperbolicSpace := ⟨rfl⟩ + +lemma continuous_hyperbolic_action (g : SL(2,ℂ)) : + Continuous (fun w : HyperbolicSpace => g • w) := by + apply (QuotientGroup.isQuotientMap_mk compactSubgroup).continuous_iff.mpr + exact continuous_hyperbolicProjection.comp (continuous_complexSL_mul g) + +def positiveCoordinateHeight (p : EuclideanSpatial) : ℝ := if 0

(p 0:ℂ)+Complex.I*(p 1:ℂ)) + fun_prop + · exact Measurable.ite euclideanUpperHalf_measurable (by fun_prop) measurable_const + +lemma euclideanToHyperbolic_measurable : Measurable euclideanToHyperbolic := + continuous_upperCoordinates.measurable.comp euclideanToUpperCoordinates_measurable + +lemma euclideanToHyperbolic_positive (p : EuclideanSpatial) (hp : 0

g • w) hyperbolicVolume=hyperbolicVolume := by + unfold hyperbolicVolume + rw [Measure.map_map (continuous_hyperbolic_action g).measurable euclideanToHyperbolic_measurable] + calc + _ = Measure.map (euclideanToHyperbolic ∘ f) hyperbolicEuclideanVolume := by + apply Measure.map_congr + filter_upwards [hyperbolicEuclideanVolume_ae_positive] with p hp + exact (hcompat p hp).symm + _ = _ := by rw [←Measure.map_map euclideanToHyperbolic_measurable hf,hvol] + +lemma matrix_point_coordinates (g : SL(2,ℂ)) : + (g : HyperbolicSpace)=upperPoint (matrixHorizontal g) (liftedHeight g) (liftedHeight_pos g) := by + obtain ⟨k,hk,hg⟩ := matrix_iwasawa_factor g + apply Eq.symm + apply Quotient.sound + apply QuotientGroup.leftRel_apply.mpr + change (upperSection (matrixHorizontal g) (liftedHeight g) (liftedHeight_pos g))⁻¹*g∈compactSubgroup + have hcancel : (upperSection (matrixHorizontal g) (liftedHeight g) (liftedHeight_pos g))⁻¹*g=k := by + calc + _ = (upperSection (matrixHorizontal g) (liftedHeight g) (liftedHeight_pos g))⁻¹* + (upperSection (matrixHorizontal g) (liftedHeight g) (liftedHeight_pos g)*k) := + congrArg (fun M => (upperSection (matrixHorizontal g) (liftedHeight g) (liftedHeight_pos g))⁻¹*M) hg + _ = k := inv_mul_cancel_left _ _ + rwa [hcancel] + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Matrix + +def matrixCross (g : SL(2,ℂ)) : ℂ := g 0 0*star (g 1 0)+g 0 1*star (g 1 1) + +lemma matrixHorizontal_eq_cross_height (g : SL(2,ℂ)) : + matrixHorizontal g=matrixCross g*(liftedHeight g:ℂ) := by + unfold matrixHorizontal matrixCross liftedHeight + rw [Complex.ofReal_inv] + rfl + +lemma matrixCross_upperSection (g : SL(2,ℂ)) (z : ℂ) (v : ℝ) (hv : 0 (QuotientGroup.mk g : HyperbolicSpace)) + apply Subtype.ext + change (complexTranslation b : Matrix (Fin 2) (Fin 2) ℂ) * + (upperSection z v hv : Matrix (Fin 2) (Fin 2) ℂ) = + (upperSection (z + b) v hv : Matrix (Fin 2) (Fin 2) ℂ) + ext i j + fin_cases i <;> fin_cases j <;> + simp [complexTranslation,upperSection,Matrix.mul_apply, + Fin.sum_univ_two,div_eq_mul_inv] ; ring + +lemma complexWeyl_action (z : ℂ) (v : ℝ) (hv : 0 fin_cases j <;> + simp [complexTranslation,complexDiagonal,complexWeyl,Matrix.mul_apply,Fin.sum_univ_two,hc] <;> + field_simp ; linear_combination -hd + +lemma complex_bruhat_zero (g : SL(2,ℂ)) (hc : g 1 0=0) : + ∃ha : g 0 0≠0,g=complexDiagonal (g 0 0) ha*complexTranslation (g 0 1/g 0 0) := by + have hd : g 0 0*g 1 1=1 := by simpa only [Matrix.det_fin_two,hc,mul_zero,sub_zero] using g.property + have ha : g 0 0≠0 := by intro h; simp [h] at hd + refine ⟨ha,?_⟩ + apply Subtype.ext + change (g : Matrix (Fin 2) (Fin 2) ℂ) = + (complexDiagonal (g 0 0) ha : Matrix (Fin 2) (Fin 2) ℂ) * + (complexTranslation (g 0 1 / g 0 0) : Matrix (Fin 2) (Fin 2) ℂ) + ext i j + fin_cases i <;> fin_cases j <;> + simp [complexTranslation,complexDiagonal,Matrix.mul_apply,Fin.sum_univ_two,hc] <;> + field_simp ; linear_combination hd + +def euclideanHorizontalTranslation (b : ℂ) : EuclideanSpatial := WithLp.toLp 2 ![b.re,b.im,0] + +lemma complexTranslation_preserves_hyperbolicVolume (b : ℂ) : + Measure.map (fun w => complexTranslation b • w) hyperbolicVolume=hyperbolicVolume := by + apply hyperbolicVolume_map_of_coordinate_action (complexTranslation b) + (fun p => p+euclideanHorizontalTranslation b) (continuous_id.add continuous_const).measurable + (translation_preserves_hyperbolicVolume _ rfl) + intro p hp + have hq : 0<(p+euclideanHorizontalTranslation b) 2 := by simpa [euclideanHorizontalTranslation] using hp + rw [euclideanToHyperbolic_positive _ hq,euclideanToHyperbolic_positive _ hp,complexTranslation_action] + apply upperPoint_congr + · apply Complex.ext <;> simp [euclideanHorizontalTranslation] + · simp [euclideanHorizontalTranslation] + +lemma complexDiagonal_preserves_hyperbolicVolume (b : ℂ) (hb : b≠0) : + Measure.map (fun w => complexDiagonal b hb • w) hyperbolicVolume=hyperbolicVolume := by + apply hyperbolicVolume_map_of_coordinate_action (complexDiagonal b hb) + (euclideanComplexDilation b) (euclideanComplexDilation b).continuous.measurable + (euclideanComplexDilation_preserves_hyperbolicVolume b hb) + intro p hp + obtain ⟨h0,h1,h2⟩ := euclideanComplexDilation_apply b p + have hq : 0<(euclideanComplexDilation b p) 2 := by rw [h2]; exact mul_pos (Complex.normSq_pos.mpr hb) hp + rw [euclideanToHyperbolic_positive _ hq,euclideanToHyperbolic_positive _ hp,complexDiagonal_action] + apply upperPoint_congr + · rw [h0,h1] + apply Complex.ext <;> simp [Complex.mul_re,Complex.mul_im] ; ring + · exact h2 + +lemma euclidean_complex_norm_sq (p : EuclideanSpatial) : + ‖(p 0:ℂ)+Complex.I*(p 1:ℂ)‖^2+(p 2)^2=‖p‖^2 := by + rw [←Complex.normSq_eq_norm_sq,Complex.normSq_apply,EuclideanSpace.real_norm_sq_eq] + simp [Fin.sum_univ_three,sq] + +def euclideanWeylAction (p : EuclideanSpatial) : EuclideanSpatial := + euclideanWeylReflection (euclideanInversion p) + +lemma euclideanWeylAction_measurable : Measurable euclideanWeylAction := + euclideanWeylReflection.continuous.measurable.comp euclideanInversion_measurable + +lemma euclideanWeylAction_preserves_hyperbolicVolume : + Measure.map euclideanWeylAction hyperbolicEuclideanVolume=hyperbolicEuclideanVolume := by + rw [show euclideanWeylAction=euclideanWeylReflection ∘ euclideanInversion from rfl, + ←Measure.map_map euclideanWeylReflection.continuous.measurable euclideanInversion_measurable, + euclideanInversion_preserves_hyperbolicVolume,euclideanWeylReflection_preserves_hyperbolicVolume] + +lemma euclideanWeylAction_apply (p : EuclideanSpatial) : + euclideanWeylAction p 0= -((1/‖p‖)^2*p 0) ∧ + euclideanWeylAction p 1=(1/‖p‖)^2*p 1 ∧ + euclideanWeylAction p 2=(1/‖p‖)^2*p 2 := by + simpa [euclideanWeylAction,euclideanInversion_apply] using + euclideanWeylReflection_apply (euclideanInversion p) + +lemma complexWeyl_preserves_hyperbolicVolume : + Measure.map (fun w => complexWeyl • w) hyperbolicVolume=hyperbolicVolume := by + apply hyperbolicVolume_map_of_coordinate_action complexWeyl euclideanWeylAction + euclideanWeylAction_measurable euclideanWeylAction_preserves_hyperbolicVolume + intro p hp + have hn : ‖p‖≠0 := norm_ne_zero_iff.mpr (euclideanUpperHalf_ne_zero p hp) + have hnc : (‖p‖:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hn + obtain ⟨h0,h1,h2⟩ := euclideanWeylAction_apply p + have hq : 0 g • w) hyperbolicVolume=hyperbolicVolume) + (hh : Measure.map (fun w => h • w) hyperbolicVolume=hyperbolicVolume) : + Measure.map (fun w => (g*h) • w) hyperbolicVolume=hyperbolicVolume := by + rw [show (fun w : HyperbolicSpace => (g*h) • w)=(fun w => g • w) ∘ (fun w => h • w) by + funext w; exact mul_smul g h w, + ←Measure.map_map (continuous_hyperbolic_action g).measurable (continuous_hyperbolic_action h).measurable, + hh,hg] + +theorem hyperbolicVolume_invariant (g : SL(2,ℂ)) : + Measure.map (fun w => g • w) hyperbolicVolume=hyperbolicVolume := by + by_cases hc : g 1 0=0 + · obtain ⟨ha,hg⟩ := complex_bruhat_zero g hc + rw [hg] + exact hyperbolicVolume_invariant_mul _ _ (complexDiagonal_preserves_hyperbolicVolume _ ha) + (complexTranslation_preserves_hyperbolicVolume _) + · rw [complex_bruhat_nonzero g hc] + exact hyperbolicVolume_invariant_mul _ _ + (hyperbolicVolume_invariant_mul _ _ + (hyperbolicVolume_invariant_mul _ _ (complexTranslation_preserves_hyperbolicVolume _) + (complexDiagonal_preserves_hyperbolicVolume _ (inv_ne_zero hc))) + complexWeyl_preserves_hyperbolicVolume) + (complexTranslation_preserves_hyperbolicVolume _) + +end CubicEisenstein + +open scoped BigOperators Classical +namespace SecondPassArithmetic +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProduct primeProductNorm) +open ConcreteTraceCRT (eisEmbedding) + +def globalBinTripleRange (B : ℝ) (j : GlobalLogIndex) : ℝ := + (B*Real.sqrt (globalLogRep j 9)/globalLogRep j 4)*globalLogRep j 2*globalLogRep j 3 + +def globalBinFirstCoefficient (K ell B F : ℝ) (j : GlobalLogIndex) : ℝ := + K/(globalLogRep j 5*ell*B^2*F*Real.sqrt (globalLogRep j 9)) + +def globalBinChildCharge (B F : ℝ) (j : GlobalLogIndex) : ℝ := + 128^3*(Real.exp 1)^14*globalPooledDelta B F j*B^2/globalLogRep j 4 + +theorem globalBinTripleRange_nonneg (B : ℝ) (hB : 0 ≤ B) (j : GlobalLogIndex) : + 0 ≤ globalBinTripleRange B j := by + unfold globalBinTripleRange + have h2 := (globalLogRep_pos j 2).le + have h3 := (globalLogRep_pos j 3).le + have h4 := (globalLogRep_pos j 4).le + positivity + +theorem globalBin_complete_cost (K ell B F : ℝ) (hK : 0 < K) (hell : 0 < ell) + (hB : 0 < B) (hF : 0 < F) (j : GlobalLogIndex) (ray : SecondRayIndex) : + globalBinFirstCoefficient K ell B F j * + globalPooledOuterBound ray ell (globalPooledRowScale K ell B F j) j * + (globalPooledColumnScale ell j*globalPooledLabelScale j) * + (128^3*(Real.exp 1)^3*globalBinTripleRange B j) = + globalBinChildCharge B F j*‖secondRayCoefficient ray‖ := by + have h (i : Fin 10) := (globalLogRep_pos j i).ne' + have hs := (Real.sqrt_pos.mpr (globalLogRep_pos j 9)).ne' + have he : Real.exp 4=(Real.exp 1)^4 := by simp + unfold globalBinFirstCoefficient globalPooledOuterBound globalPooledRowScale + globalPooledColumnScale globalPooledLabelScale globalBinTripleRange globalBinChildCharge globalPooledDelta + rw [he] + field_simp [h] + +theorem globalBin_mass_balance (ell B F : ℝ) (hB : 0 < B) (hF : 0 < F) (j : GlobalLogIndex) : + globalBinChildCharge B F j*(globalPooledColumnScale ell j*globalPooledLabelScale j) = + 128^3*(Real.exp 1)^18*((ell*B^3)*F) := by + rw [globalPooled_mass ell B F hB hF] + have hD := (globalPooledDelta_pos B F hB hF j).ne' + have hJ := (globalLogRep_pos j 4).ne' + have he : Real.exp 4=(Real.exp 1)^4 := by simp + unfold globalBinChildCharge + rw [he] + field_simp + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + +include hp in +theorem globalBin_active_bounds (side : Bool) (x : GlobalSecondData ι) (hk : x.source.frequency ≠ 0) : + Real.sqrt (globalLogRep (globalScaleIndex p side x) 9) ≤ globalCubeActiveRoot p x ∧ + globalCubeActiveRoot p x ≤ Real.sqrt (globalLogRep (globalScaleIndex p side x) 9)*Real.exp 1 := by + have hr := globalScaleIndex_bounds p hp side x hk 9 + change globalLogRep (globalScaleIndex p side x) 9 ≤ (globalCubeActiveRoot p x)^2 ∧ + (globalCubeActiveRoot p x)^2 ≤ globalLogRep (globalScaleIndex p side x) 9*Real.exp 1 at hr + have hx := (globalCubeActiveRoot_pos p hp x).le + constructor + · exact Real.sqrt_le_iff.mpr ⟨hx,hr.1⟩ + · have hs := Real.sq_sqrt (globalLogRep_pos (globalScaleIndex p side x) 9).le + have he : 1 ≤ Real.exp 1 := Real.one_le_exp (by norm_num) + have hrep := (globalLogRep_pos (globalScaleIndex p side x) 9).le + have hm : (globalCubeActiveRoot p x)^2 ≤ + (Real.sqrt (globalLogRep (globalScaleIndex p side x) 9)*Real.exp 1)^2 := by + calc + _ ≤ globalLogRep (globalScaleIndex p side x) 9*Real.exp 1 := hr.2 + _ ≤ globalLogRep (globalScaleIndex p side x) 9*(Real.exp 1)^2 := by gcongr; nlinarith + _ = _ := by rw [mul_pow,hs] + exact (sq_le_sq₀ hx (mul_nonneg (Real.sqrt_nonneg _) (Real.exp_pos 1).le)).mp hm + +include hp in +theorem globalBin_first_coefficient_bound (K ell B F : ℝ) (hK : 0 ≤ K) (hell : 0 < ell) + (hB : 0 < B) (hF : 0 < F) (side : Bool) (x : GlobalSecondData ι) + (hk : x.source.frequency ≠ 0) : + K/(primeProductNorm p x.firstDivisor*ell*B^2*F*globalCubeActiveRoot p x) ≤ + globalBinFirstCoefficient K ell B F (globalScaleIndex p side x) := by + have hd := (globalScaleIndex_bounds p hp side x hk 5).1 + have ha := (globalBin_active_bounds p hp side x hk).1 + change globalLogRep (globalScaleIndex p side x) 5 ≤ primeProductNorm p x.firstDivisor at hd + have h5 := globalLogRep_pos (globalScaleIndex p side x) 5 + have hs := Real.sqrt_pos.mpr (globalLogRep_pos (globalScaleIndex p side x) 9) + have hd0 := (FirstPassCubeLabels.primeProductNorm_pos p hp x.firstDivisor).le + unfold globalBinFirstCoefficient + apply div_le_div_of_nonneg_left hK (by positivity) + gcongr + +include hp in +theorem globalBin_triple_bounds (B : ℝ) (hB : 0 < B) (side : Bool) (x : GlobalSecondData ι) + (hk : x.source.frequency ≠ 0) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) : + let j := globalScaleIndex p side x + (Ideal.absNorm (globalSecondFixedTriple p x).1 : ℝ) ≤ B*(Real.sqrt (globalLogRep j 9)*Real.exp 1)/globalLogRep j 4 ∧ + (Ideal.absNorm (globalSecondFixedTriple p x).2.1 : ℝ) ≤ globalLogRep j 2*Real.exp 1 ∧ + (Ideal.absNorm (globalSecondFixedTriple p x).2.2 : ℝ) ≤ globalLogRep j 3*Real.exp 1 := by + dsimp only + exact globalSecondFixedTriple_norm_bounds p hp x B _ _ _ _ hB.le (globalLogRep_pos _ 4) + hb₁ hb₂ (globalBin_active_bounds p hp side x hk).2 + (globalScaleIndex_bounds p hp side x hk 4).1 + (globalScaleIndex_bounds p hp side x hk 2).2 (globalScaleIndex_bounds p hp side x hk 3).2 + +include hp in + +theorem globalBin_triple_count (B : ℝ) (hB : 0 < B) (side : Bool) + (s : Finset (GlobalSecondData ι)) (j : GlobalLogIndex) + (hj : ∀ x∈s,globalScaleIndex p side x=j) + (hk : ∀ x∈s,x.source.frequency ≠ 0) + (hb₁ : ∀ x∈s,‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ∀ x∈s,‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) : + ((s.image (globalSecondFixedTriple p)).card : ℝ) ≤ + 128^3*(Real.exp 1)^3*globalBinTripleRange B j := by + by_cases hs : s.Nonempty + · obtain ⟨x,hxs⟩ := hs + have hb := globalBin_triple_bounds p hp B hB side x (hk x hxs) (hb₁ x hxs) (hb₂ x hxs) + dsimp only at hb + rw [hj x hxs] at hb + have hn : 1 ≤ (Ideal.absNorm (globalSecondFixedTriple p x).1 : ℝ) := by + have hh : 1 ≤ Ideal.absNorm (globalSecondFixedTriple p x).1 := + Nat.one_le_iff_ne_zero.mpr (fun h => (globalSecondFixedTriple_nonzero p hp x).1 (Ideal.absNorm_eq_zero_iff.mp h)) + exact_mod_cast hh + have hcount := globalSecondFixedTriple_count p hp s B + (Real.sqrt (globalLogRep j 9)*Real.exp 1) (globalLogRep j 4) + (globalLogRep j 2*Real.exp 1) (globalLogRep j 3*Real.exp 1) + hB.le (globalLogRep_pos j 4) (hn.trans hb.1) + (one_le_mul_of_one_le_of_one_le (globalLogRep_ge_one j 2) (Real.one_le_exp (by norm_num))) + (one_le_mul_of_one_le_of_one_le (globalLogRep_ge_one j 3) (Real.one_le_exp (by norm_num))) hb₁ hb₂ + (fun y hy => by have hh := (globalBin_active_bounds p hp side y (hk y hy)).2; rwa [hj y hy] at hh) + (fun y hy => by have hh := (globalScaleIndex_bounds p hp side y (hk y hy) 4).1; rwa [hj y hy] at hh) + (fun y hy => by have hh := (globalScaleIndex_bounds p hp side y (hk y hy) 2).2; rwa [hj y hy] at hh) + (fun y hy => by have hh := (globalScaleIndex_bounds p hp side y (hk y hy) 3).2; rwa [hj y hy] at hh) + convert hcount using 1 ; unfold globalBinTripleRange ; ring + · have hz : s=∅ := Finset.not_nonempty_iff_eq_empty.mp hs + rw [hz] + simp only [Finset.image_empty,Finset.card_empty,Nat.cast_zero] + exact mul_nonneg (by positivity) (globalBinTripleRange_nonneg B hB.le j) + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/IntegralCover.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/IntegralCover.lean new file mode 100644 index 0000000000000000000000000000000000000000..22811d95ccd68d7796a55f74237efe33ddccd8ff --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/IntegralCover.lean @@ -0,0 +1,706 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.AffineCuspFourier + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open MeasureTheory Filter +open scoped BigOperators Classical MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +def ramifiedOmegaUnit : Eisˣ := (omega_primitive.isUnit (by decide)).unit +lemma ramifiedOmegaUnit_val : (ramifiedOmegaUnit:Eis)=omega := + (omega_primitive.isUnit (by decide)).unit_spec + +lemma onceCusp_q_as_scale (t:Eisˣ) (l:Fin 3) : + onceCuspScale (t*ramifiedOmegaUnit^l.val)=onceCuspScale t*omega^l.val := by + simp only [onceCuspScale,Units.val_mul,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val] + ring + +lemma onceCusp_q_congr_scale (t:Eisˣ) (l:Fin 3) : + (3:Eis)∣onceCuspScale t*omega^l.val-onceCuspScale t := by + obtain ⟨b,hb⟩:=halfPrimary_omega_pow l.val + have he:onceCuspScale t*omega^l.val-onceCuspScale t= + (onceCuspScale t*(omega-1))*b:=by + linear_combination onceCuspScale t*hb + rw [he] + exact (onceCusp_scale_lambda t).mul_right b + +lemma onceCusp_q_dvd_three (t:Eisˣ) (l:Fin 3) : + onceCuspScale t*omega^l.val∣(3:Eis) := by + rw [←onceCusp_q_as_scale] + exact ⟨onceCuspComplement _,(onceCusp_scale_complement _).symm⟩ + +lemma onceCusp_q_trace_dvd (t:Eisˣ) (l:Fin 3) : + (3:Eis)∣ramifiedTraceLambda*(onceCuspScale t*omega^l.val) := by + refine ⟨-(t:Eis)*omega^l.val,?_⟩ + unfold onceCuspScale + linear_combination (t:Eis)*omega^l.val*ramifiedTraceLambda_square + +lemma onceCusp_q_dvd_frequency (t:Eisˣ) (l:Fin 3) (h:Eis) + (hfreq:(3:Eis)∣h-onceCuspScale t) : onceCuspScale t*omega^l.val∣h := by + have hd:(3:Eis)∣h-onceCuspScale t*omega^l.val:=by + convert dvd_sub hfreq (onceCusp_q_congr_scale t l) using 1 ;ring + have hh:onceCuspScale t*omega^l.val∣h-onceCuspScale t*omega^l.val:= + (onceCusp_q_dvd_three t l).trans hd + simpa only [sub_add_cancel] using dvd_add hh (dvd_refl (onceCuspScale t*omega^l.val)) + +lemma onceCusp_period_congruence (t:Eisˣ) (l:Fin 3) (h:Eis) (j:ℕ) + (hfreq:(3:Eis)∣h-onceCuspScale t) : + (3:Eis)∣h+ramifiedAffineParameter j 1*(onceCuspScale t*omega^l.val) := by + have hd:(3:Eis)∣h-onceCuspScale t*omega^l.val:=by + convert dvd_sub hfreq (onceCusp_q_congr_scale t l) using 1 ;ring + have ht:=(onceCusp_q_trace_dvd t l).mul_left (j:Eis) + convert dvd_add hd ht using 1 ; simp only [ramifiedAffineParameter,Nat.cast_one] ;ring + +def onceCuspFrequencyQuotient (t:Eisˣ) (h:Eis) + (hfreq:(3:Eis)∣h-onceCuspScale t) (l:Fin 3) : Eis := + Classical.choose (onceCusp_q_dvd_frequency t l h hfreq) + +lemma onceCuspFrequencyQuotient_spec (t:Eisˣ) (h:Eis) + (hfreq:(3:Eis)∣h-onceCuspScale t) (l:Fin 3) : + h=(onceCuspScale t*omega^l.val)*onceCuspFrequencyQuotient t h hfreq l := + Classical.choose_spec (onceCusp_q_dvd_frequency t l h hfreq) + +def onceCuspRayUnit (u t:Eisˣ) (l:Fin 3) : Eisˣ := u⁻¹^2*t*ramifiedOmegaUnit^l.val + +def onceCuspRayIndex (u t:Eisˣ) (l:Fin 3) : Fin 3 := + Classical.choose (unit_eq_sign_omega (onceCuspRayUnit u t l)) + +lemma onceCuspRayIndex_spec (u t:Eisˣ) (l:Fin 3) : + (↑u⁻¹:Eis)^2*(onceCuspScale t*omega^l.val)=omega^(onceCuspRayIndex u t l).val*ramifiedTraceLambda ∨ + (↑u⁻¹:Eis)^2*(onceCuspScale t*omega^l.val)=-(omega^(onceCuspRayIndex u t l).val*ramifiedTraceLambda) := by + have he:(↑u⁻¹:Eis)^2*(onceCuspScale t*omega^l.val)= + (onceCuspRayUnit u t l:Eis)*ramifiedTraceLambda:=by + simp only [onceCuspRayUnit,onceCuspScale,Units.val_mul,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val] + ring + have hh:=Classical.choose_spec (unit_eq_sign_omega (onceCuspRayUnit u t l)) + change (onceCuspRayUnit u t l:Eis)=omega^(onceCuspRayIndex u t l).val ∨ + (onceCuspRayUnit u t l:Eis)=-(omega^(onceCuspRayIndex u t l).val) at hh + rw [he] + rcases hh with hh|hh + · exact Or.inl (by rw [hh]) + · exact Or.inr (by rw [hh];ring) + +def onceCuspGaussSeries (u t:Eisˣ) (h:Eis) (hfreq:(3:Eis)∣h-onceCuspScale t) (s:ℂ) : ℂ := + ∑l:Fin 3,if (3:Eis)∣onceCuspFrequencyQuotient t h hfreq l+ + ramifiedAffineParameter (onceCuspRayIndex u t l).val 1 then + (3:ℂ)*(3:ℂ)^(-s)*ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (onceCuspScale t*omega^l.val))* + unramifiedCubicGaussSeries s + (3*((↑u⁻¹:Eis)^2*(onceCuspScale t*omega^l.val))^2*onceCuspFrequencyQuotient t h hfreq l) else 0 + +theorem onceCusp_eisenstein_fourier (u t:Eisˣ) (h:Eis) + (hfreq:(3:Eis)∣h-onceCuspScale t) (v:ℝ) (hv:0(onceCuspRayIndex u t l).val) h + (onceCuspFrequencyQuotient t h hfreq) (onceCuspRayIndex_spec u t) + (onceCuspFrequencyQuotient_spec t h hfreq) + (fun l=>onceCusp_period_congruence t l h _ hfreq) v hv s hs, + onceCuspGaussSeries,Finset.mul_sum] + apply Finset.sum_congr rfl + intro l hl + split_ifs <;>ring + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Manifold ContDiff +open Finset AddChar MulChar EisensteinEmbedding + +lemma hyperbolicAction_contMDiff (g : SL(2,ℂ)) : + ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,SpatialCoordinates) ∞ + (fun w : HyperbolicSpace=>g•w) := by + intro w + rw [contMDiffAt_iff] + refine ⟨(continuous_hyperbolic_action g).continuousAt,?_⟩ + have hp : hyperbolicSpatialCoordinates w∈hyperbolicSpatialChart.target := + hyperbolicSpatialChart.map_source (Set.mem_univ _) + have he : (fun p : SpatialCoordinates=>hyperbolicSpatialCoordinates + (g•hyperbolicSpatialChart.symm p))=ᶠ[𝓝 (hyperbolicSpatialCoordinates w)]mobiusSpatial g := by + filter_upwards [hyperbolicSpatialChart.open_target.mem_nhds hp] with p hpt + rw [mobiusSpatial_coordinates_global] + exact congrArg (mobiusSpatial g) (hyperbolicSpatialChart.right_inv hpt) + have hd := ((mobiusSpatial_contDiffAt g _ (hyperbolicSpatialCoordinates_positive w)).congr_of_eventuallyEq he).contDiffWithinAt (s:=Set.univ) + simpa only [extChartAt_coe,extChartAt_coe_symm,modelWithCornersSelf_coe, + modelWithCornersSelf_coe_symm,Function.id_comp,Function.comp_id,Set.preimage_id_eq,Set.range_id, + hyperbolicSpatial_chartAt,hyperbolicSpatialChart_apply,Function.comp_def,id_eq] using hd + +lemma kernel_contMDiff_of_lift (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ + (fun w : HyperbolicSpace=>f (integralOrbitProjection globalKubotaKernel w))) : + ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f := by + intro q + have hq : q∈(kernelQuotientChart q).source := mem_chart_source SpatialCoordinates q + have hp : kernelQuotientChart q q∈hyperbolicSpatialChart.target := + ((kernelQuotientChart q).map_source hq).1 + have hs : ContMDiffOn 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,SpatialCoordinates) ∞ + hyperbolicSpatialChart.symm hyperbolicSpatialChart.target := by + simpa only [hyperbolicSpatial_chartAt] using + (contMDiffOn_chart_symm (I:=𝓘(ℝ,SpatialCoordinates)) (n:=∞) (x:=q.out)) + have hd := (hf (hyperbolicSpatialChart.symm (kernelQuotientChart q q))).comp _ + (hs.contMDiffAt (hyperbolicSpatialChart.open_target.mem_nhds hp)) + have he : (fun p=>f ((kernelQuotientChart q).symm p))= + (fun p=>f (integralOrbitProjection globalKubotaKernel (hyperbolicSpatialChart.symm p))) := by + funext p + rw [kernelQuotientChart_symm] + have hdc : ContDiffAt ℝ ∞ (fun p=>f ((kernelQuotientChart q).symm p)) + (kernelQuotientChart q q) := by + rw [he] + exact hd.contDiffAt + have hc : ContinuousAt f q := by + have hc := hdc.continuousAt.comp + ((kernelQuotientChart q).continuousOn.continuousAt + ((kernelQuotientChart q).open_source.mem_nhds hq)) + apply hc.congr + filter_upwards [(kernelQuotientChart q).open_source.mem_nhds hq] with r hr + exact congrArg f ((kernelQuotientChart q).left_inv hr) + rw [contMDiffAt_iff] + refine ⟨hc,?_⟩ + have hh := hdc.contDiffWithinAt (s:=Set.univ) + simpa only [extChartAt_coe,extChartAt_coe_symm,modelWithCornersSelf_coe, + modelWithCornersSelf_coe_symm,Function.id_comp,Function.comp_id,Set.range_id, + kernelSpatial_chartAt,chartAt_self_eq,OpenPartialHomeomorph.refl_apply,Function.comp_def,id_eq] using hh + +lemma kernelSource_comp_contMDiff (M : CubicKubota.levelTwo) (f : KernelQuotient→ℂ) + (hf : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f) : + ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ (fun q=>f (kernelSourceAction M q)) := by + apply kernel_contMDiff_of_lift + exact (hf.comp kernelProjection_contMDiff).comp (hyperbolicAction_contMDiff (sourceComplexMatrix M)) + +def kernelSourceTest (M : CubicKubota.levelTwo) (f : kernelSmoothTests) : kernelSmoothTests := + ⟨fun q=>f.1 (kernelSourceAction M q),kernelSource_comp_contMDiff M f.1 f.2.1, + f.2.2.comp_homeomorph (kernelSourceHomeomorph M)⟩ + +def kernelSourceTestLinear (M : CubicKubota.levelTwo) : kernelSmoothTests→ₗ[ℂ]kernelSmoothTests where + toFun := kernelSourceTest M + map_add' _ _ := rfl + map_smul' _ _ := rfl + +lemma kernelSourceTest_field (M : CubicKubota.levelTwo) (f : kernelSmoothTests) : + kernelTestField (kernelSourceTest M f)=kernelTestField f ∘ euclideanAction (sourceComplexMatrix M) := by + funext p + change f.1 (integralOrbitProjection globalKubotaKernel + (sourceComplexMatrix M•euclideanToHyperbolic p))= + f.1 (integralOrbitProjection globalKubotaKernel + (euclideanToHyperbolic (euclideanAction (sourceComplexMatrix M) p))) + rw [euclideanAction,euclideanToHyperbolic_coordinates] + +lemma kernelSourceTest_energyDensity (M : CubicKubota.levelTwo) (f : kernelSmoothTests) + (w : HyperbolicSpace) : + kernelTestEnergyDensity (kernelSourceTest M f) w= + kernelTestEnergyDensity f (sourceComplexMatrix M•w) := by + have hp := hyperbolicHeight_pos w + have he : hyperbolicEuclideanCoordinates (sourceComplexMatrix M•w)= + euclideanAction (sourceComplexMatrix M) (hyperbolicEuclideanCoordinates w) := by + rw [euclideanAction,euclideanToHyperbolic_coordinates] + have hR := hyperbolic_cotangent_energy_comp (sourceComplexMatrix M) + (fun p : EuclideanSpatial=>(kernelTestField f p).re) (hyperbolicEuclideanCoordinates w) hp + ((kernelTestField_re_contDiffAt f _ (euclideanAction_positive _ _)).differentiableAt (by simp)) + have hI := hyperbolic_cotangent_energy_comp (sourceComplexMatrix M) + (fun p : EuclideanSpatial=>(kernelTestField f p).im) (hyperbolicEuclideanCoordinates w) hp + ((kernelTestField_im_contDiffAt f _ (euclideanAction_positive _ _)).differentiableAt (by simp)) + unfold kernelTestEnergyDensity euclideanScalarDirichletDensity + rw [kernelSourceTest_field,he] + exact congrArg₂ (fun a b : ℝ=>a+b) hR hI + +lemma kernelSourceTest_quotientDensity (M : CubicKubota.levelTwo) (f : kernelSmoothTests) + (q : KernelQuotient) : + kernelQuotientEnergyDensity (kernelSourceTest M f) q= + kernelQuotientEnergyDensity f (kernelSourceAction M q) := by + induction q using Quotient.inductionOn with + | _ w => exact kernelSourceTest_energyDensity M f w + +lemma kernelSourceTest_energy (M : CubicKubota.levelTwo) (f : kernelSmoothTests) : + kernelDirichletEnergy (kernelSourceTest M f)=kernelDirichletEnergy f := by + unfold kernelDirichletEnergy + simp_rw [kernelSourceTest_quotientDensity] + exact (kernelSourceAction_measurePreserving M).integral_comp + (kernelSourceHomeomorph M).measurableEmbedding _ + +lemma kernelSourceTest_mass (M : CubicKubota.levelTwo) (f : kernelSmoothTests) : + kernelSmoothTestsToL2 (kernelSourceTest M f)=kernelSourcePullback M (kernelSmoothTestsToL2 f) := by + apply Lp.ext + have hbase := (kernelSourceAction_measurePreserving M).quasiMeasurePreserving.ae_eq_comp + (kernelSmoothTests_memLp f).coeFn_toLp + filter_upwards [(kernelSmoothTests_memLp (kernelSourceTest M f)).coeFn_toLp, + kernelSourcePullback_ae_eq M (kernelSmoothTestsToL2 f),hbase] with q hnew hpull hbase + exact hnew.trans (hpull.trans hbase).symm + +lemma kernelSourceTest_graph_norm (M : CubicKubota.levelTwo) (f : kernelSmoothTests) : + ‖kernelEnergyGraphCore (kernelSourceTest M f)‖=‖kernelEnergyGraphCore f‖ := by + apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp + rw [kernelEnergyGraphCore_norm_sq,kernelEnergyGraphCore_norm_sq, + kernelSourceTest_energy,kernelSourceTest_mass,LinearIsometry.norm_map] + +def kernelSourceEnergyPullback (M : CubicKubota.levelTwo) : KernelEnergyGraph→ₗᵢ[ℂ]KernelEnergyGraph := + (kernelEnergyGraphCore.comp (kernelSourceTestLinear M)).extendOfIsometry + kernelEnergyGraphCore_dense (kernelSourceTest_graph_norm M) + +lemma kernelSourceEnergyPullback_core (M : CubicKubota.levelTwo) (f : kernelSmoothTests) : + kernelSourceEnergyPullback M (kernelEnergyGraphCore f)=kernelEnergyGraphCore (kernelSourceTest M f) := + LinearMap.extendOfIsometry_eq (kernelEnergyGraphCore.comp (kernelSourceTestLinear M)) + kernelEnergyGraphCore_dense (kernelSourceTest_graph_norm M) f + +lemma kernelSourceEnergyPullback_mass (M : CubicKubota.levelTwo) (u : KernelEnergyGraph) : + kernelEnergyMass (kernelSourceEnergyPullback M u)=kernelSourcePullback M (kernelEnergyMass u) := by + apply congrFun (kernelEnergyGraphCore_dense.equalizer + (kernelEnergyMass.continuous.comp (kernelSourceEnergyPullback M).continuous) + ((kernelSourcePullback M).continuous.comp kernelEnergyMass.continuous) ?_) u + funext f + change kernelEnergyMass (kernelSourceEnergyPullback M (kernelEnergyGraphCore f))= + kernelSourcePullback M (kernelEnergyMass (kernelEnergyGraphCore f)) + rw [kernelSourceEnergyPullback_core,kernelEnergyMass_core,kernelEnergyMass_core,kernelSourceTest_mass] + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups InnerProductSpace +open Finset AddChar MulChar EisensteinEmbedding + +lemma kernelSourceEnergyPullback_inverse (M : CubicKubota.levelTwo) (u : KernelEnergyGraph) : + kernelSourceEnergyPullback M (kernelSourceEnergyPullback M⁻¹ u)=u := by + apply kernelEnergyMass_injective + rw [kernelSourceEnergyPullback_mass,kernelSourceEnergyPullback_mass, + kernelSourcePullback_comp,inv_mul_cancel,kernelSourcePullback_one] + +lemma kernelSourceEnergyPullback_surjective (M : CubicKubota.levelTwo) : + Function.Surjective (kernelSourceEnergyPullback M) := + fun u=>⟨kernelSourceEnergyPullback M⁻¹ u,kernelSourceEnergyPullback_inverse M u⟩ + +theorem kernelSource_variationalSolution (M : CubicKubota.levelTwo) (F : KernelQuotientL2) : + kernelSourceEnergyPullback M (kernelVariationalSolution F)= + kernelVariationalSolution (kernelSourcePullback M F) := by + apply kernelVariationalSolution_unique + intro v + obtain ⟨w,rfl⟩ := kernelSourceEnergyPullback_surjective M v + rw [←kernelEnergyGraph_inner,LinearIsometry.inner_map_map, + kernelSourceEnergyPullback_mass,LinearIsometry.inner_map_map,kernelEnergyGraph_inner] + exact kernelVariationalSolution_equation F w + +theorem kernelSource_variationalResolvent (M : CubicKubota.levelTwo) (F : KernelQuotientL2) : + kernelVariationalResolvent (kernelSourcePullback M F)= + kernelSourcePullback M (kernelVariationalResolvent F) := by + change kernelEnergyMass (kernelVariationalSolution (kernelSourcePullback M F))= + kernelSourcePullback M (kernelEnergyMass (kernelVariationalSolution F)) + rw [←kernelSource_variationalSolution,kernelSourceEnergyPullback_mass] + +theorem kernelSource_operatorGraph (M : CubicKubota.levelTwo) + (F G : KernelQuotientL2) (hFG : (F,G)∈kernelEnergyLaplacian.graph) : + (kernelSourcePullback M F,kernelSourcePullback M G)∈kernelEnergyLaplacian.graph := by + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] at hFG ⊢ + rw [←map_add,kernelSource_variationalResolvent,hFG] + +theorem kernelSource_eigenvector (M : CubicKubota.levelTwo) (F : KernelQuotientL2) + (eigenvalue : ℂ) (hF : (F,eigenvalue • F)∈kernelEnergyLaplacian.graph) : + (kernelSourcePullback M F,eigenvalue • kernelSourcePullback M F)∈kernelEnergyLaplacian.graph := by + simpa only [map_smul] using kernelSource_operatorGraph M F (eigenvalue • F) hF + +end CubicEisenstein + +section + +open scoped Classical MatrixGroups BigOperators +namespace CubicKubota +open ActualEisensteinCubic ConcreteTraceCRT CubicEisenstein CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +def cubeCuspHeightWeight (p:Eis) (j:Fin 4) : ℂ := + (((Ideal.absNorm (Ideal.span {p}):ℝ)^((2*(j.val:ℝ)-3)/3)):ℝ) + +lemma cubeCuspHeightWeight_zero (p:Eis) : + cubeCuspHeightWeight p 0=(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹ := by + unfold cubeCuspHeightWeight + generalize Ideal.absNorm (Ideal.span {p}) = n + norm_num [Real.rpow_neg_one] + +lemma cubeCuspHeightWeight_three (p:Eis) : + cubeCuspHeightWeight p 3=(Ideal.absNorm (Ideal.span {p}):ℂ) := by + unfold cubeCuspHeightWeight + generalize Ideal.absNorm (Ideal.span {p}) = n + norm_num + +theorem actualCubeCuspPhaseSum_height (A:levelTwo) (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (hA:lambda^2∣((A:SL(2,Eis)) 0 0)-1) : + actualCubeCuspPhaseSum A p hp hprimary (cubeCuspHeightWeight p)= + (Ideal.absNorm (Ideal.span {p}):ℂ)^2 := by + have hqN:Ideal.absNorm (Ideal.span {p})≠0:= + (Ideal.absNorm_ne_zero_iff _).mpr (finite_quotient_span hp.ne_zero) + have hq:(Ideal.absNorm (Ideal.span {p}):ℂ)≠0:=by exact_mod_cast hqN + by_cases hc:p∣((A:SL(2,Eis)) 1 0) + · rw [actualCubeCuspPhaseSum_dvd A p hp hprimary hA hc, + cubeCuspHeightWeight_zero] + field_simp + · have hcop:IsCoprime ((A:SL(2,Eis)) 1 0) p:=(hp.coprime_iff_not_dvd.mpr hc).symm + rw [actualCubeCuspPhaseSum_coprime A p hp hprimary hA hcop, + cubeCuspHeightWeight_zero,cubeCuspHeightWeight_three] + field_simp + ; ring + +theorem actualCubeCuspPhaseSum_normalized (A:levelTwo) (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (hA:lambda^2∣((A:SL(2,Eis)) 0 0)-1) : + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3 * + actualCubeCuspPhaseSum A p hp hprimary (cubeCuspHeightWeight p)= + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹ := by + have hqN:Ideal.absNorm (Ideal.span {p})≠0:= + (Ideal.absNorm_ne_zero_iff _).mpr (finite_quotient_span hp.ne_zero) + have hq:(Ideal.absNorm (Ideal.span {p}):ℂ)≠0:=by exact_mod_cast hqN + rw [actualCubeCuspPhaseSum_height A p hp hprimary hA] + field_simp + +end CubicKubota + +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +def cubeDilationRoot (p:Eis) : ℂ := + Classical.choose (IsAlgClosed.exists_pow_nat_eq (eisEmbedding p^3) (by decide : 0<2)) + +lemma cubeDilationRoot_sq (p:Eis) : cubeDilationRoot p^2=eisEmbedding p^3 := + Classical.choose_spec (IsAlgClosed.exists_pow_nat_eq (eisEmbedding p^3) (by decide : 0<2)) + +lemma cubeDilationRoot_ne_zero (p:Eis) (hp:p≠0) : cubeDilationRoot p≠0 := by + intro h + have hs:=cubeDilationRoot_sq p + rw [h,zero_pow (by decide)] at hs + exact pow_ne_zero 3 (eisEmbedding_ne_zero hp) hs.symm + +def cubeAverageMatrix (p:Eis) (hp:p≠0) (q:Eis) : SL(2,ℂ) := + complexDiagonal (cubeDilationRoot p)⁻¹ (inv_ne_zero (cubeDilationRoot_ne_zero p hp)) * + complexTranslation (3*eisEmbedding q) + +lemma cubeAverageMatrix_entries (p:Eis) (hp:p≠0) (q:Eis) : + (cubeAverageMatrix p hp q : Matrix (Fin 2) (Fin 2) ℂ)= + !![(cubeDilationRoot p)⁻¹,(cubeDilationRoot p)⁻¹*(3*eisEmbedding q);0,cubeDilationRoot p] := by + unfold cubeAverageMatrix + rw [Matrix.SpecialLinearGroup.coe_mul] + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [complexDiagonal, complexTranslation, Matrix.mul_apply, Fin.sum_univ_two] + +lemma cubeAverageMatrix_add_multiple (p:Eis) (hp:p≠0) (q n:Eis) : + cubeAverageMatrix p hp (q+p^3*n)= + complexTranslation (3*eisEmbedding n)*cubeAverageMatrix p hp q := by + apply Subtype.ext + simp only [Matrix.SpecialLinearGroup.coe_mul, cubeAverageMatrix_entries] + apply Matrix.ext + intro i j + have hz := cubeDilationRoot_ne_zero p hp + have he := cubeDilationRoot_sq p + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, complexTranslation, + map_add, map_mul, map_pow] + rw [← he] + field_simp + +lemma cubeAverageMatrix_translate_one (p:Eis) (hp:p≠0) (q t:Eis) + (ht:3*t=1-p^3) : + cubeAverageMatrix p hp q*complexTranslation 1= + complexTranslation 1*cubeAverageMatrix p hp (q+t) := by + have ht':3*eisEmbedding t=1-eisEmbedding p^3:=by + simpa only [map_mul,map_sub,map_one,map_ofNat,map_pow] using congrArg eisEmbedding ht + have hz:=cubeDilationRoot_ne_zero p hp + have he:=cubeDilationRoot_sq p + apply Subtype.ext + simp only [Matrix.SpecialLinearGroup.coe_mul, cubeAverageMatrix_entries] + apply Matrix.ext + intro i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply, Fin.sum_univ_two, complexTranslation, map_add] + field_simp + linear_combination -ht'-he + +def cubeAverage (p:Eis) (hp:p≠0) (F:HyperbolicSpace→ℂ) (w:HyperbolicSpace) : ℂ := + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3 * + ∑' r:Eis⧸Ideal.span {p^3}, + F (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) • w) + +lemma cubeAverage_summand_congr (p:Eis) (hp:p≠0) (F:HyperbolicSpace→ℂ) + (hF:∀n:Eis,∀w:HyperbolicSpace,F (complexTranslation (3*eisEmbedding n) • w)=F w) + (a b:Eis) (hab:p^3∣a-b) (w:HyperbolicSpace) : + F (cubeAverageMatrix p hp a • w)=F (cubeAverageMatrix p hp b • w) := by + obtain ⟨n,hn⟩:=hab + have ha:a=b+p^3*n:=by linear_combination hn + rw [ha,cubeAverageMatrix_add_multiple,mul_smul,hF] + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubeAverageMatrix_action (p:Eis) (hp:p≠0) (q:Eis) + (z:ℂ) (v:ℝ) (hv:0r+Ideal.Quotient.mk _ t + invFun:=fun r=>r-Ideal.Quotient.mk _ t + left_inv:=fun r=>add_sub_cancel_right r _ + right_inv:=fun r=>sub_add_cancel r _ } + let f (r:Eis⧸Ideal.span {p^3}):= + F (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) • w) + have hpoint (r:Eis⧸Ideal.span {p^3}): + F (cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) • + (complexTranslation 1 • w))=f (a r) := by + rw [←mul_smul,cubeAverageMatrix_translate_one p hp _ t ht.symm,mul_smul,hF1] + apply cubeAverage_summand_congr p hp F hF + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + rw [map_add,GaussianShiftedPartition.representative_spec, + GaussianShiftedPartition.representative_spec] + rfl + unfold cubeAverage + congr 1 + calc + _ = ∑' r,f (a r):=tsum_congr hpoint + _ = ∑' r,f r:=a.tsum_eq f + +end CubicEisenstein +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise +open Finset AddChar MulChar EisensteinEmbedding + +namespace CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +def integralCoverMap {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) : + IntegralOrbitQuotient H→IntegralOrbitQuotient K := + Quotient.map' id (by + rintro w u ⟨M,hM⟩ + exact ⟨Subgroup.inclusion hHK M,hM⟩) + +lemma integralCoverMap_projection {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) (w : HyperbolicSpace) : + integralCoverMap hHK (integralOrbitProjection H w)=integralOrbitProjection K w := rfl + +lemma integralCoverMap_measurable {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) : + Measurable (integralCoverMap hHK) := by + apply measurable_from_quotient.mpr + exact measurable_integralOrbitProjection K + +lemma integralCoverMap_continuous {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) : + Continuous (integralCoverMap hHK) := continuous_id.quotient_map' _ + +lemma integralCoverMap_surjective {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) : + Function.Surjective (integralCoverMap hHK) := by + intro q + induction q using Quotient.inductionOn with + | _ w => exact ⟨integralOrbitProjection H w,rfl⟩ + +abbrev IntegralCoverCosets (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) := K ⧸ H.subgroupOf K + +def integralCoverRep (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) (q : IntegralCoverCosets H K) : K := q.out + +def integralCoverSheet (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) (q : IntegralCoverCosets H K) : Set HyperbolicSpace := + (fun w=>integralCoverRep H K q • w) ⁻¹' hyperbolicFundamentalSet K + +def integralCoverDomain (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) : Set HyperbolicSpace := + ⋃q : IntegralCoverCosets H K,integralCoverSheet H K q + +lemma integralCoverSheet_measurable (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) (q : IntegralCoverCosets H K) : + MeasurableSet (integralCoverSheet H K q) := + (measurable_const_smul (integralCoverRep H K q)) (hyperbolicFundamentalSet_measurable K) + +lemma integralCoverDomain_measurable (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) [H.IsFiniteRelIndex K] : + MeasurableSet (integralCoverDomain H K) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + exact MeasurableSet.iUnion (integralCoverSheet_measurable H K) + +lemma fundamental_reduction_unique (K : Subgroup (SL(2,ActualEisensteinCubic.O))) (hK : K≤CubicKubota.levelThree) + (r s : K) (w : HyperbolicSpace) (hr : r•w∈hyperbolicFundamentalSet K) + (hs : s•w∈hyperbolicFundamentalSet K) : r=s := by + have he : s•w=r•w := by + have hh := hyperbolicFundamentalSet_orbit_unique K (r•w) hr (s*r⁻¹) + (by simpa only [mul_smul,inv_smul_smul] using hs) + simpa only [mul_smul,inv_smul_smul] using hh + have hfix : (r⁻¹*s)•w=w := by rw [mul_smul,he,inv_smul_smul] + exact inv_mul_eq_one.mp (subgroup_action_free K hK _ w hfix) + +lemma integralCoverSheet_pairwiseDisjoint (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (hK : K≤CubicKubota.levelThree) : Pairwise (fun q r=>Disjoint (integralCoverSheet H K q) (integralCoverSheet H K r)) := by + intro q r hqr + apply Set.disjoint_left.mpr + intro w hwq hwr + have he := fundamental_reduction_unique K hK (integralCoverRep H K q) + (integralCoverRep H K r) w hwq hwr + apply hqr + exact Quotient.out_injective he + +lemma integralCoverRep_mul_projection {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) + (q : IntegralCoverCosets H K) (h : H) : + ((integralCoverRep H K q*Subgroup.inclusion hHK h : K) : IntegralCoverCosets H K)=q := by + rw [QuotientGroup.mk_mul_of_mem _ (show Subgroup.inclusion hHK h∈H.subgroupOf K from h.property)] + exact QuotientGroup.out_eq' q + +lemma integralCover_inclusion_smul {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (h : H) (w : HyperbolicSpace) : + (Subgroup.inclusion hHK h)•w=h•w := rfl + +private lemma mul_smul_mem_set_iff {G X : Type*} [Monoid G] [MulAction G X] + (a b : G) (w v : X) (hv : v = b • w) (S : Set X) : + a • v ∈ S ↔ (a * b) • w ∈ S := by + rw [hv, mul_smul] + +private lemma mem_integralCoverSheet (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + (q : IntegralCoverCosets H K) (w : HyperbolicSpace) : + w ∈ integralCoverSheet H K q ↔ + integralCoverRep H K q • w ∈ hyperbolicFundamentalSet K := Iff.rfl + +lemma integralCoverSheet_membership {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (q : IntegralCoverCosets H K) (h : H) (w : HyperbolicSpace) : + h•w∈integralCoverSheet H K q ↔ + (integralCoverRep H K q*Subgroup.inclusion hHK h)•w∈hyperbolicFundamentalSet K := by + exact (mem_integralCoverSheet H K q (h • w)).trans + (mul_smul_mem_set_iff (integralCoverRep H K q) (Subgroup.inclusion hHK h) + w (h • w) (integralCover_inclusion_smul hHK h w).symm (hyperbolicFundamentalSet K)) + +lemma integralCoverDomain_covers {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (w : HyperbolicSpace) : + ∃h : H,h•w∈integralCoverDomain H K := by + obtain ⟨k,hk⟩ := hyperbolicFundamentalSet_covers K w + let q : IntegralCoverCosets H K := k + let r := integralCoverRep H K q + have hr : r⁻¹*k∈H.subgroupOf K := + QuotientGroup.eq.mp (QuotientGroup.out_eq' q) + let h : H := ⟨((r⁻¹*k:K):SL(2,ActualEisensteinCubic.O)),hr⟩ + have hin : Subgroup.inclusion hHK h=r⁻¹*k := rfl + refine ⟨h,Set.mem_iUnion.mpr ⟨q,?_⟩⟩ + apply (integralCoverSheet_membership hHK q h w).mpr + change (r*Subgroup.inclusion hHK h)•w∈hyperbolicFundamentalSet K + rw [hin,mul_inv_cancel_left] + exact hk + +lemma integralCoverDomain_unique {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) (w : HyperbolicSpace) + (h1 h2 : H) (hh1 : h1•w∈integralCoverDomain H K) + (hh2 : h2•w∈integralCoverDomain H K) : h1=h2 := by + obtain ⟨q1,hq1⟩ := Set.mem_iUnion.mp hh1 + obtain ⟨q2,hq2⟩ := Set.mem_iUnion.mp hh2 + have he : integralCoverRep H K q1*Subgroup.inclusion hHK h1= + integralCoverRep H K q2*Subgroup.inclusion hHK h2 := by + apply fundamental_reduction_unique K hK _ _ w + · exact (integralCoverSheet_membership hHK q1 h1 w).mp hq1 + · exact (integralCoverSheet_membership hHK q2 h2 w).mp hq2 + have hqeq : q1=q2 := by + have hproj := congrArg (fun k : K=>(k : IntegralCoverCosets H K)) he + rw [integralCoverRep_mul_projection hHK q1 h1, + integralCoverRep_mul_projection hHK q2 h2] at hproj + exact hproj + subst q2 + exact (Subgroup.inclusion_injective hHK) (mul_left_cancel he) + +theorem integralCoverDomain_isFundamentalDomain {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] : + IsFundamentalDomain H (integralCoverDomain H K) hyperbolicVolume := by + apply IsFundamentalDomain.mk' (integralCoverDomain_measurable H K).nullMeasurableSet + intro w + obtain ⟨h,hh⟩ := integralCoverDomain_covers hHK w + exact ⟨h,hh,fun g hg=>integralCoverDomain_unique hHK hK w g h hg hh⟩ + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/InverseCorrespondence.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/InverseCorrespondence.lean new file mode 100644 index 0000000000000000000000000000000000000000..556b12f2e6db92aadddb5140756b7f726edc812f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/InverseCorrespondence.lean @@ -0,0 +1,654 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CubeCuspAverage + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise ENNReal InnerProductSpace +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma integralCoverFiber_memLp {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hf : MemLp f 2 (integralQuotientVolume H)) (q : IntegralCoverCosets H K) : + MemLp (fun w=>f (integralCoverFiberPoint H K q w)) 2 + (hyperbolicVolume.restrict (hyperbolicFundamentalSet K)) := by + have hD := hf.comp_measurePreserving (integralCoverDomain_projection_measurePreserving hHK hK) + have hS := MemLp.mono_measure + (Measure.restrict_mono_set hyperbolicVolume (Set.subset_iUnion (integralCoverSheet H K) q)) hD + have hm := integralCoverSheet_measurePreserving H K q + have hi := memLp_map_measure_iff (p:=2) + (hmeas.comp (integralCoverFiberPoint_measurable H K q)).aestronglyMeasurable hm.aemeasurable + rw [hm.map_eq] at hi + apply hi.mpr + simpa only [Function.comp_def,integralCoverFiberPoint_rep_smul] using hS + +theorem integralCoverTraceFunction_memLp {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hf : MemLp f 2 (integralQuotientVolume H)) : + MemLp (integralCoverTraceFunction H K f) 2 (integralQuotientVolume K) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + have hm := quotient_projection_measurePreserving K + have hi := memLp_map_measure_iff (p:=2) + (integralCoverTraceFunction_measurable H K f hmeas).aestronglyMeasurable hm.aemeasurable + rw [hm.map_eq] at hi + apply hi.mpr + change MemLp (fun w=>∑q : IntegralCoverCosets H K,f (integralCoverFiberPoint H K q w)) 2 _ + exact memLp_finsetSum Finset.univ (fun q _=>integralCoverFiber_memLp hHK hK f hmeas hf q) + +lemma integralCoverMap_fiberPoint {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} (hHK : H≤K) + (q : IntegralCoverCosets H K) (w : HyperbolicSpace) : + integralCoverMap hHK (integralCoverFiberPoint H K q w)=integralOrbitProjection K w := by + rw [integralCoverFiberPoint_rep,integralCoverMap_projection,integralSubgroup_smul, + integralOrbitProjection_eq] + +lemma integralCoverTraceFunction_pairing {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) [H.IsFiniteRelIndex K] (F : IntegralOrbitQuotient K→ℂ) + (f : IntegralOrbitQuotient H→ℂ) (q : IntegralOrbitQuotient K) : + integralCoverTraceFunction H K (fun r=>inner ℂ (F (integralCoverMap hHK r)) (f r)) q= + inner ℂ (F q) (integralCoverTraceFunction H K f q) := by + let : Fintype (IntegralCoverCosets H K) := Fintype.ofFinite _ + induction q using Quotient.inductionOn with + | _ w => + change (∑r : IntegralCoverCosets H K,inner ℂ + (F (integralCoverMap hHK (integralCoverFiberPoint H K r w))) + (f (integralCoverFiberPoint H K r w)))= + inner ℂ (F (integralOrbitProjection K w)) (∑r : IntegralCoverCosets H K,f (integralCoverFiberPoint H K r w)) + simp only [integralCoverMap_fiberPoint,inner_sum] + +theorem integralCoverTrace_toLp_ae {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hf : MemLp f 2 (integralQuotientVolume H)) : + integralCoverTrace hHK hK (hf.toLp f)=ᵐ[integralQuotientVolume K] + integralCoverTraceFunction H K f := by + let htr := integralCoverTraceFunction_memLp hHK hK f hmeas hf + let Tf : IntegralQuotientL2 K := htr.toLp (integralCoverTraceFunction H K f) + have he : Tf=integralCoverTrace hHK hK (hf.toLp f) := by + apply ext_inner_left ℂ + intro F + let pair : IntegralOrbitQuotient H→ℂ := fun r=>inner ℂ (F (integralCoverMap hHK r)) (f r) + have hpm : Measurable pair := by + have hFm : Measurable (fun r=>F (integralCoverMap hHK r)) := + (Lp.stronglyMeasurable F).measurable.comp (integralCoverMap_measurable hHK) + have hstar : Measurable (fun r=>star (F (integralCoverMap hHK r))) := + continuous_star.measurable.comp hFm + have hm := hmeas.mul hstar + change Measurable (fun r=>f r*star (F (integralCoverMap hHK r))) at hm + simpa only [pair,RCLike.inner_apply,starRingEnd_apply] using hm + have hae : (fun r=>inner ℂ (integralCoverPullback hHK hK F r) (hf.toLp f r)) + =ᵐ[integralQuotientVolume H]pair := by + filter_upwards [integralCoverPullback_ae hHK hK F,hf.coeFn_toLp] with r hr hfR + dsimp [pair] + rw [hr,hfR] + have hpi : Integrable pair (integralQuotientVolume H) := + (L2.integrable_inner (integralCoverPullback hHK hK F) (hf.toLp f)).congr hae + calc + inner ℂ F Tf = ∫q,inner ℂ (F q) (integralCoverTraceFunction H K f q)∂integralQuotientVolume K := by + rw [L2.inner_def] + apply integral_congr_ae + filter_upwards [htr.coeFn_toLp] with q hq + change inner ℂ (F q) (htr.toLp (integralCoverTraceFunction H K f) q)=_ + rw [hq] + _ = ∫q,integralCoverTraceFunction H K pair q∂integralQuotientVolume K := by + apply integral_congr_ae + exact Eventually.of_forall (fun q=>(integralCoverTraceFunction_pairing hHK F f q).symm) + _ = ∫r,pair r∂integralQuotientVolume H := + integralCoverTraceFunction_integral hHK hK pair hpm hpi + _ = inner ℂ (integralCoverPullback hHK hK F) (hf.toLp f) := + (integral_congr_ae hae).symm + _ = inner ℂ F (integralCoverTrace hHK hK (hf.toLp f)) := + (integralCoverTrace_pairing hHK hK F (hf.toLp f)).symm + rw [←he] + exact htr.coeFn_toLp + +theorem integralCoverTrace_representative {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (G : IntegralQuotientL2 H) (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hrep : G=ᵐ[integralQuotientVolume H]f) : + integralCoverTrace hHK hK G=ᵐ[integralQuotientVolume K]integralCoverTraceFunction H K f := by + have hf : MemLp f 2 (integralQuotientVolume H) := (memLp_congr_ae hrep).mp (Lp.memLp G) + have he : G=hf.toLp f := Lp.ext (hrep.trans hf.coeFn_toLp.symm) + rw [he] + exact integralCoverTrace_toLp_ae hHK hK f hmeas hf + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +theorem integralCoverTrace_cusp_representative {H K : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤K) (hK : K≤CubicKubota.levelThree) [H.IsFiniteRelIndex K] + (G : IntegralQuotientL2 H) (f : IntegralOrbitQuotient H→ℂ) (hmeas : Measurable f) + (hrep : G=ᵐ[integralQuotientVolume H]f) (C : ℝ) + (hdec : ∀M : CubicKubota.levelThree,∀z : ℂ,∀v : ℝ,∀hv : 0 ActualEisensteinCubic.O + +def primaryDenominatorShift (a:PrimaryLower) (m:Eis) : PrimaryCoprimeDenominator a≃PrimaryCoprimeDenominator a where + toFun d:=⟨⟨d.val.val+3*a.val*m,by + convert dvd_add d.val.2 (show (3:Eis)∣3*a.val*m from ⟨a.val*m,by ring⟩) using 1 ;ring⟩,by + exact (isCoprime_right_congr_of_dvd a.val (d.val.val+3*a.val*m) d.val.val ⟨3*m,by ring⟩).mpr d.2⟩ + invFun d:=⟨⟨d.val.val-3*a.val*m,by + convert dvd_sub d.val.2 (show (3:Eis)∣3*a.val*m from ⟨a.val*m,by ring⟩) using 1 ;ring⟩,by + exact (isCoprime_right_congr_of_dvd a.val (d.val.val-3*a.val*m) d.val.val ⟨-(3*m),by ring⟩).mpr d.2⟩ + left_inv d:=by apply Subtype.ext;apply Subtype.ext;dsimp;ring + right_inv d:=by apply Subtype.ext;apply Subtype.ext;dsimp;ring + +def unitLowerDataShift (m:Eis) : UnitLowerData≃UnitLowerData := + Equiv.sigmaCongrRight (fun a=>primaryDenominatorShift a m) + +lemma affineCusp_term_weighted_period (h q r:Eis) (j n:ℕ) (a d:PrimaryLower) (m:Eis) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hbase:(3:Eis)∣h+ramifiedAffineParameter j n*q) (z:ℂ) (v:ℝ) (s:ℂ) : + affineLowerTerm q r z v s a.val (d.val+3*a.val*(q*m))*ShortDraftTrace.breveE (-ninthCuspFrequency h*z)= + affineLowerTerm q r (z+3*eisEmbedding m) v s a.val d.val* + ShortDraftTrace.breveE (-ninthCuspFrequency h*(z+3*eisEmbedding m)) := by + have hd:(3:Eis)∣d.val-a.val:=by simpa only [sub_sub_sub_cancel_right] using dvd_sub d.2 a.2 + obtain ⟨x,hx⟩:=hd + have hdx:d.val=a.val+3*x:=by linear_combination hx + have hb:(3:Eis)∣h+ramifiedAffineParameter j n*q*a.val:=by + convert dvd_add hbase (a.2.mul_left (ramifiedAffineParameter j n*q)) using 1 ;ring + obtain ⟨ell,hell⟩:=hb + have he:=affineCusp_general_weighted_translate h q r a.val ell x (q*m) j n + (primaryLower_primary a) hq hr hell.symm z v s + have hqm:Ideal.Quotient.mk (Ideal.span {q}) (q*m)=0:= + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr (dvd_mul_right q m)) + rw [hqm,AddChar.map_zero_eq_one,one_mul] at he + have hshift:3*eisEmbedding (q*m)/eisEmbedding q=3*eisEmbedding m:=by + rw [map_mul] + field_simp [eisEmbedding_ne_zero hq] + rw [hshift] at he + rw [hdx,show a.val+3*x+3*a.val*(q*m)=a.val+3*(x+a.val*(q*m)) by ring] + exact he + +def affineCuspBlock (q r:Eis) (z:ℂ) (v:ℝ) (s:ℂ) : ℂ := + ∑'p:UnitLowerData,affineLowerTerm q r z v s p.1.val p.2.val.val + +lemma affineCuspBlock_weighted_periodic (h q r:Eis) (j n:ℕ) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hbase:(3:Eis)∣h+ramifiedAffineParameter j n*q) (v:ℝ) (s:ℂ) (m:Eis) (z:ℂ) : + affineCuspBlock q r (z+3*eisEmbedding m) v s* + ShortDraftTrace.breveE (-ninthCuspFrequency h*(z+3*eisEmbedding m))= + affineCuspBlock q r z v s*ShortDraftTrace.breveE (-ninthCuspFrequency h*z) := by + rw [affineCuspBlock,affineCuspBlock,←tsum_mul_right,←tsum_mul_right] + calc + _ = ∑'p:UnitLowerData,affineLowerTerm q r z v s + ((unitLowerDataShift (q*m) p).1.val) ((unitLowerDataShift (q*m) p).2.val.val)* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z) := by + apply tsum_congr + intro p + exact (affineCusp_term_weighted_period h q r j n p.1 p.2.val m hq hr hbase z v s).symm + _ = _ := (unitLowerDataShift (q*m)).tsum_eq + (fun p:UnitLowerData=>affineLowerTerm q r z v s p.1.val p.2.val.val*ShortDraftTrace.breveE (-ninthCuspFrequency h*z)) + +lemma period_integral_twisted_translation (f:ℂ→ℂ) (freq:ℂ) + (hp:∀(n:Eis)(z:ℂ),f (z+3*eisEmbedding n)*ShortDraftTrace.breveE (-freq*(z+3*eisEmbedding n))= + f z*ShortDraftTrace.breveE (-freq*z)) (b:ℂ) : + (∫z in periodDomain,f (z+b)*ShortDraftTrace.breveE (-freq*z))= + ShortDraftTrace.breveE (freq*b)*∫z in periodDomain,f z*ShortDraftTrace.breveE (-freq*z) := by + let g:ℂ→ℂ:=fun z=>f z*ShortDraftTrace.breveE (-freq*z) + have he (z:ℂ):f (z+b)*ShortDraftTrace.breveE (-freq*z)=ShortDraftTrace.breveE (freq*b)*g (b+z):=by + dsimp only [g] + rw [mul_left_comm,←AddChar.map_add_eq_mul] + congr 1 + · rw [add_comm] + · congr 1;ring + simp_rw [he] + rw [integral_const_mul,period_integral_translation g hp b] + +lemma affineCuspBlock_integral_translation (h q r:Eis) (j n:ℕ) + (hq:q≠0) (hr:r=omega^j*ramifiedTraceLambda^n ∨ r=-(omega^j*ramifiedTraceLambda^n)) + (hbase:(3:Eis)∣h+ramifiedAffineParameter j n*q) (v:ℝ) (s b:ℂ) : + (∫z in periodDomain,affineCuspBlock q r (z+b) v s*ShortDraftTrace.breveE (-ninthCuspFrequency h*z))= + ShortDraftTrace.breveE (ninthCuspFrequency h*b)* + ∫z in periodDomain,affineCuspBlock q r z v s*ShortDraftTrace.breveE (-ninthCuspFrequency h*z) := + period_integral_twisted_translation (fun z=>affineCuspBlock q r z v s) (ninthCuspFrequency h) + (affineCuspBlock_weighted_periodic h q r j n hq hr hbase v s) b + +end +section + +open Filter MeasureTheory +open scoped BigOperators Classical MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma diagonal_unit_weighted_periodic (u t:Eisˣ) (j:ℕ) (h:Eis) + (hr:(↑u⁻¹:Eis)^2*(t:Eis)=omega^j ∨ (↑u⁻¹:Eis)^2*(t:Eis)=-(omega^j)) + (hbase:(3:Eis)∣h+ramifiedAffineParameter j 0*(t:Eis)) + (v:ℝ) (hv:0affineLowerTerm (onceCuspScale t*omega^p.1.val) + ((↑u⁻¹:Eis)^2*(onceCuspScale t*omega^p.1.val)) z v s p.2.1.val p.2.2.val.val):= + hsum.congr (fun p=>diagonal_once_summand u t z v hv s p) + rw [mul_assoc,diagonal_once_eisenstein_rows,ht.tsum_prod,tsum_fintype] + rfl + +lemma diagonal_once_weighted_periodic (u t:Eisˣ) (h:Eis) + (hfreq:(3:Eis)∣h-onceCuspScale t) (v:ℝ) (hv:0eisenstein (integralComplexMatrix (unitCuspDiagonal u)*integralComplexMatrix (lowerCuspMatrix (t:Eis))*upperSection z v hv) s) + (ninthCuspFrequency h) (diagonal_unit_weighted_periodic u t j h hr hbase v hv s) b + +lemma diagonal_once_fourier_shift (u t:Eisˣ) (h:Eis) + (hfreq:(3:Eis)∣h-onceCuspScale t) (v:ℝ) (hv:0eisenstein (integralComplexMatrix (unitCuspDiagonal u)*integralComplexMatrix (lowerCuspMatrix (onceCuspScale t))*upperSection z v hv) s) + (ninthCuspFrequency h) (diagonal_once_weighted_periodic u t h hfreq v hv s hs) b + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def ramifiedCuspRoot (b:Bool) : Eisˣ := if b then ramifiedOmegaUnit^2 else ramifiedOmegaUnit + +def ramifiedCuspScaleUnit (b:Bool) : Eisˣ := if b then ramifiedOmegaUnit^2 else -ramifiedOmegaUnit + +def ramifiedCuspDirectIndex (b:Bool) : ℕ := if b then 2 else 1 + +def ramifiedCuspOppositeIndex (b:Bool) : ℕ := if b then 1 else 2 + +lemma ramified_omega_four : omega^4=omega := by + rw [show (4:ℕ)=3+1 from rfl,pow_add,omega_primitive.pow_eq_one,pow_one,one_mul] + +lemma ramifiedCuspRoot_val (b:Bool) : (ramifiedCuspRoot b:Eis)=omega^(ramifiedCuspDirectIndex b) := by + cases b <;>simp [ramifiedCuspRoot,ramifiedCuspDirectIndex,ramifiedOmegaUnit_val] + +lemma ramifiedCuspRoot_cube (b:Bool) : (ramifiedCuspRoot b:Eis)^3=1 := by + rw [ramifiedCuspRoot_val,←pow_mul,Nat.mul_comm,pow_mul,omega_primitive.pow_eq_one,one_pow] + +lemma ramifiedCuspRoot_primitive (b:Bool) : + (ramifiedCuspRoot b:Eis)^2+(ramifiedCuspRoot b:Eis)+1=0 := by + cases b + · simpa [ramifiedCuspRoot,ramifiedOmegaUnit_val] using ramified_omega_relation + · simp only [ramifiedCuspRoot,ite_true,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val,←pow_mul] + rw [show 2*2=4 from rfl,ramified_omega_four] + linear_combination ramified_omega_relation + +lemma ramifiedCuspScaleUnit_spec (b:Bool) : + -(ramifiedCuspRoot b:Eis)*(1+2*(ramifiedCuspRoot b:Eis))=onceCuspScale (ramifiedCuspScaleUnit b) := by + cases b + · simp [ramifiedCuspRoot,ramifiedCuspScaleUnit,onceCuspScale,ramifiedTraceLambda,ramifiedOmegaUnit_val] + · simp only [ramifiedCuspRoot,ramifiedCuspScaleUnit,ite_true,onceCuspScale,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val, + ramifiedTraceLambda] + linear_combination -(2*omega^2)*ramified_omega_relation + +lemma ramifiedCusp_neg_inv_square (b:Bool) : + (↑(-(ramifiedCuspRoot b))⁻¹:Eis)^2=(ramifiedCuspRoot b:Eis) := by + have hi:(↑(-(ramifiedCuspRoot b))⁻¹:Eis)=-(ramifiedCuspRoot b:Eis)^2:=by + apply (-(ramifiedCuspRoot b)).inv_eq_of_mul_eq_one_right + change -(ramifiedCuspRoot b:Eis)*(-(ramifiedCuspRoot b:Eis)^2)=1 + convert ramifiedCuspRoot_cube b using 1 ;ring + rw [hi] + linear_combination (ramifiedCuspRoot b:Eis)*ramifiedCuspRoot_cube b + +lemma ramifiedCusp_opposite_character (b:Bool) : + (↑(-(ramifiedCuspRoot b))⁻¹:Eis)^2*(-(ramifiedCuspRoot b:Eis))= + -(omega^(ramifiedCuspOppositeIndex b)) := by + rw [ramifiedCusp_neg_inv_square,ramifiedCuspRoot_val] + cases b + · simp [ramifiedCuspDirectIndex,ramifiedCuspOppositeIndex,pow_two] + · simp only [ramifiedCuspDirectIndex,ramifiedCuspOppositeIndex,ite_true,pow_one] + rw [mul_neg,←pow_add,show 2+2=4 from rfl,ramified_omega_four] + +lemma ramifiedCusp_direct_period_constant (b:Bool) : + (3:Eis)∣onceCuspScale (ramifiedCuspScaleUnit b)+ + ramifiedAffineParameter (ramifiedCuspDirectIndex b) 0*(ramifiedCuspRoot b:Eis) := by + cases b + · refine ⟨0,?_⟩ + simp [ramifiedCuspRoot,ramifiedCuspScaleUnit,onceCuspScale,ramifiedCuspDirectIndex, + ramifiedAffineParameter,ramifiedOmegaUnit_val] + ring + · refine ⟨ramifiedTraceLambda*omega^2,?_⟩ + simp [ramifiedCuspRoot,ramifiedCuspScaleUnit,onceCuspScale,ramifiedCuspDirectIndex, + ramifiedAffineParameter,ramifiedOmegaUnit_val] + ring + +lemma ramifiedCusp_opposite_period_constant (b:Bool) : + (3:Eis)∣onceCuspScale (ramifiedCuspScaleUnit b)+ + ramifiedAffineParameter (ramifiedCuspOppositeIndex b) 0*(-(ramifiedCuspRoot b:Eis)) := by + cases b + · refine ⟨-(omega*ramifiedTraceLambda),?_⟩ + simp [ramifiedCuspRoot,ramifiedCuspScaleUnit,onceCuspScale,ramifiedCuspOppositeIndex, + ramifiedAffineParameter,ramifiedOmegaUnit_val] + ring + · refine ⟨0,?_⟩ + simp [ramifiedCuspRoot,ramifiedCuspScaleUnit,onceCuspScale,ramifiedCuspOppositeIndex, + ramifiedAffineParameter,ramifiedOmegaUnit_val] + ring + +lemma ramifiedCusp_unit_period_constant (b:Bool) : + (3:Eis)∣onceCuspScale (ramifiedCuspScaleUnit b)+ + ramifiedAffineParameter (ramifiedCuspDirectIndex b) 0 := by + cases b + · refine ⟨-omega^2,?_⟩ + simp [ramifiedCuspScaleUnit,ramifiedCuspDirectIndex,onceCuspScale,Units.val_neg, + ramifiedOmegaUnit_val,ramifiedAffineParameter,Nat.cast_one,one_mul,sub_zero, + ramifiedTraceLambda] + linear_combination ramified_omega_relation + · refine ⟨-omega^2,?_⟩ + simp only [ramifiedCuspScaleUnit,ramifiedCuspDirectIndex,ite_true,onceCuspScale,Units.val_pow_eq_pow_val, + ramifiedOmegaUnit_val,ramifiedAffineParameter,Nat.cast_ofNat,Nat.cast_zero,sub_zero, + ramifiedTraceLambda] + linear_combination (2*omega+2)*ramified_omega_relation + +lemma ramifiedCusp_support_standard (b:Bool) (h:Eis) : + (3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b) ↔ + (3:Eis)∣h-(if b then -(omega-1) else omega-1) := by + have hc:(3:Eis)∣onceCuspScale (ramifiedCuspScaleUnit b)-(if b then -(omega-1) else omega-1):=by + cases b + · refine ⟨1,?_⟩ + simp [ramifiedCuspScaleUnit,onceCuspScale,Units.val_neg,ramifiedOmegaUnit_val, + ramifiedTraceLambda] + linear_combination -2*ramified_omega_relation + · refine ⟨0,?_⟩ + simp only [ramifiedCuspScaleUnit,ite_true,onceCuspScale,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val, + ramifiedTraceLambda] + linear_combination (2*omega-1)*ramified_omega_relation + constructor + · intro hh + convert dvd_add hh hc using 1 ;ring + · intro hh + convert dvd_sub hh hc using 1 ;ring + +end + +open Filter MeasureTheory +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def unitCuspGaussSeries (u t:Eisˣ) (h:Eis) (s:ℂ) : ℂ := + ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (t:Eis))* + unramifiedCubicGaussSeries s (3*((↑u⁻¹:Eis)^2*(t:Eis))^2*((↑t⁻¹:Eis)*h)) + +lemma unitCusp_eisenstein_fourier_base (u t:Eisˣ) (j:ℕ) (h:Eis) + (hr:(↑u⁻¹:Eis)^2*(t:Eis)=omega^j ∨ (↑u⁻¹:Eis)^2*(t:Eis)=-(omega^j)) + (hbase:(3:Eis)∣h+ramifiedAffineParameter j 0*(t:Eis)) + (v:ℝ) (hv:0fin_cases j <;>simp [unitCuspDiagonal] + +lemma ramifiedCusp_direct_base (b:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b)) : + (3:Eis)∣h+ramifiedAffineParameter (ramifiedCuspDirectIndex b) 0*(ramifiedCuspRoot b:Eis) := by + convert dvd_add hf (ramifiedCusp_direct_period_constant b) using 1 ;ring + +lemma ramifiedCusp_opposite_base (b:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b)) : + (3:Eis)∣h+ramifiedAffineParameter (ramifiedCuspOppositeIndex b) 0*(-(ramifiedCuspRoot b:Eis)) := by + convert dvd_add hf (ramifiedCusp_opposite_period_constant b) using 1 ;ring + +lemma ramifiedCusp_unit_base (b:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b)) : + (3:Eis)∣h+ramifiedAffineParameter (ramifiedCuspDirectIndex b) 0 := by + convert dvd_add hf (ramifiedCusp_unit_period_constant b) using 1 ;ring + +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +namespace CubicKubota +open CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +lemma cubeKernelLeftGlobal_injective (p : ActualEisensteinCubic.O) (hp : p≠0) : + Function.Injective (cubeKernelLeftGlobal p) := by + intro x y hxy + apply (cubeKernel_finite_covers p hp).1 + apply Subtype.ext + apply Subtype.ext + exact hxy + +lemma cubeKernelRightGlobal_injective (p : ActualEisensteinCubic.O) (hp : p≠0) : + Function.Injective (cubeKernelRightGlobal p hp) := by + intro x y hxy + apply (cubeKernel_finite_covers p hp).2.1 + apply Subtype.ext + apply Subtype.ext + exact hxy + +def cubeKernelRangeEquiv (p : ActualEisensteinCubic.O) (hp : p≠0) : + (cubeKernelLeftGlobal p).range≃*(cubeKernelRightGlobal p hp).range := + (MonoidHom.ofInjective (cubeKernelLeftGlobal_injective p hp)).symm.trans + (MonoidHom.ofInjective (cubeKernelRightGlobal_injective p hp)) + +def cubeCoverMatrix (p : ActualEisensteinCubic.O) (hp : p≠0) : SL(2,ℂ) := + (cubeArchimedean_correspondence p hp).choose + +lemma cubeCoverMatrix_spec (p : ActualEisensteinCubic.O) (hp : p≠0) : + cubeCoverMatrix p hp 0 1=0 ∧ cubeCoverMatrix p hp 1 0=0 ∧ + cubeCoverMatrix p hp 0 0/cubeCoverMatrix p hp 1 1=ConcreteTraceCRT.eisEmbedding p^3 ∧ + ∀x : cubeKernelCorrespondence p, + cubeCoverMatrix p hp*integralComplexMatrix (cubeKernelLeftGlobal p x)= + integralComplexMatrix (cubeKernelRightGlobal p hp x)*cubeCoverMatrix p hp := + (cubeArchimedean_correspondence p hp).choose_spec + +lemma cubeCoverMatrix_intertwines (p : ActualEisensteinCubic.O) (hp : p≠0) : + IntegralCoverIntertwines (cubeKernelRangeEquiv p hp) (cubeCoverMatrix p hp) := by + intro h + let x := (MonoidHom.ofInjective (cubeKernelLeftGlobal_injective p hp)).symm h + have hl : cubeKernelLeftGlobal p x=(h : SL(2,ActualEisensteinCubic.O)) := + MonoidHom.apply_ofInjective_symm (cubeKernelLeftGlobal_injective p hp) h + change cubeCoverMatrix p hp*integralComplexMatrix (h : SL(2,ActualEisensteinCubic.O))= + integralComplexMatrix (cubeKernelRightGlobal p hp x)*cubeCoverMatrix p hp + rw [←hl] + exact (cubeCoverMatrix_spec p hp).2.2.2 x + +lemma cubeLeft_le_levelThree (p : ActualEisensteinCubic.O) : + (cubeKernelLeftGlobal p).range≤levelThree := + (cubeKernelLeftGlobal_le p).trans globalKubotaKernel_le_levelThree + +lemma cubeRight_le_levelThree (p : ActualEisensteinCubic.O) (hp : p≠0) : + (cubeKernelRightGlobal p hp).range≤levelThree := + (cubeKernelRightGlobal_le p hp).trans globalKubotaKernel_le_levelThree + +def cubeForwardL2Pullback (p : ActualEisensteinCubic.O) (hp : p≠0) : + IntegralQuotientL2 (cubeKernelRightGlobal p hp).range→ₗᵢ[ℂ] + IntegralQuotientL2 (cubeKernelLeftGlobal p).range := + integralConjugatePullback (cubeKernelRangeEquiv p hp) (cubeCoverMatrix p hp) + (cubeCoverMatrix_intertwines p hp) (cubeLeft_le_levelThree p) (cubeRight_le_levelThree p hp) + +def cubeInverseL2Pullback (p : ActualEisensteinCubic.O) (hp : p≠0) : + IntegralQuotientL2 (cubeKernelLeftGlobal p).range→ₗᵢ[ℂ] + IntegralQuotientL2 (cubeKernelRightGlobal p hp).range := + integralConjugatePullback (cubeKernelRangeEquiv p hp).symm (cubeCoverMatrix p hp)⁻¹ + (integralCoverIntertwines_inverse _ _ (cubeCoverMatrix_intertwines p hp)) + (cubeRight_le_levelThree p hp) (cubeLeft_le_levelThree p) + +theorem cubeInverseL2Pullback_ae (p : ActualEisensteinCubic.O) (hp : p≠0) + (F : IntegralQuotientL2 (cubeKernelLeftGlobal p).range) : + cubeInverseL2Pullback p hp F=ᵐ[integralQuotientVolume (cubeKernelRightGlobal p hp).range] + fun q=>F (integralConjugateMap (cubeKernelRangeEquiv p hp).symm (cubeCoverMatrix p hp)⁻¹ + (integralCoverIntertwines_inverse _ _ (cubeCoverMatrix_intertwines p hp)) q) := + integralConjugatePullback_ae _ _ _ _ _ F + +def cubeInverseL2Correspondence (p : ActualEisensteinCubic.O) (hp : p≠0) : KernelQuotientL2→L[ℂ]KernelQuotientL2 := by + letI := (cubeKernelGlobal_finite_covers p hp).1 + letI := (cubeKernelGlobal_finite_covers p hp).2 + letI : (cubeKernelLeftGlobal p).range.IsFiniteRelIndex globalKubotaKernel := + Subgroup.isFiniteRelIndex_of_finiteIndex + letI : (cubeKernelRightGlobal p hp).range.IsFiniteRelIndex globalKubotaKernel := + Subgroup.isFiniteRelIndex_of_finiteIndex + exact (integralCoverTrace (cubeKernelRightGlobal_le p hp) globalKubotaKernel_le_levelThree).comp + ((cubeInverseL2Pullback p hp).toContinuousLinearMap.comp + (integralCoverPullback (cubeKernelLeftGlobal_le p) globalKubotaKernel_le_levelThree)) + +end CubicKubota + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/InverseCuspCoordinates.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/InverseCuspCoordinates.lean new file mode 100644 index 0000000000000000000000000000000000000000..a660ae491923e706779633d16642dc421df5c03e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/InverseCuspCoordinates.lean @@ -0,0 +1,604 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.BesselDerivatives + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ComplexConjugate MatrixGroups Matrix + +def inverseCuspCoordinates (c d : ℂ) (v : ℝ) (z : ℂ) : ℂ×ℝ := + (-d/c-star z/(c^2*((v^2+‖z‖^2:ℝ):ℂ)),v/(‖c‖^2*(v^2+‖z‖^2))) + +lemma inverseCuspCoordinates_height_pos (c d : ℂ) (v : ℝ) (z : ℂ) + (hc : c≠0) (hv : 0 lhs; rw [←k.re_add_im] + ring_nf + simp only [Complex.I_sq] + ring + +theorem inverse_cusp_wirtingerBar (c d : ℂ) (v : ℝ) (hc : c≠0) (hv : 0F (inverseCuspCoordinates c d v z)) 0= + (-1/(c^2*(v:ℂ)^2))*((1/2:ℂ)*(A (1,0)-Complex.I*A (Complex.I,0))) := by + have h1 := (inverseCuspPath_comp_hasDerivAt c d v 1 hc hv F A hF).deriv + have hI := (inverseCuspPath_comp_hasDerivAt c d v Complex.I hc hv F A hF).deriv + have he1 : (fun t : ℝ=>F (inverseCuspCoordinates c d v (t:ℂ)))= + (fun t : ℝ=>F (inverseCuspPath c d v 1 t)) := by + funext t + rw [←inverseCuspCoordinates_line] + simp only [mul_one] + have heI : (fun t : ℝ=>F (inverseCuspCoordinates c d v ((t:ℂ)*Complex.I)))= + (fun t : ℝ=>F (inverseCuspPath c d v Complex.I t)) := by + funext t + rw [inverseCuspCoordinates_line] + rw [horizontalWirtingerBar] + simp only [zero_add] + rw [he1,heI,h1,hI] + simp only [star_one,Complex.star_def,Complex.conj_I,neg_neg] + convert real_linear_wirtinger_swap A (-1/(c^2*(v:ℂ)^2)) using 1 ; + congr 2 ; ring_nf + +def horizontalWirtingerZ (f : ℂ→ℂ) (z : ℂ) : ℂ := + (1/2:ℂ)*(deriv (fun t : ℝ=>f (z+(t:ℂ))) 0- + Complex.I*deriv (fun t : ℝ=>f (z+(t:ℂ)*Complex.I)) 0) + +lemma horizontalWirtingerZ_eq_fderiv (F : ℂ×ℝ→ℂ) (A : (ℂ×ℝ)→L[ℝ]ℂ) + (z : ℂ) (v : ℝ) (hF : HasFDerivAt F A (z,v)) : + horizontalWirtingerZ (fun w=>F (w,v)) z= + (1/2:ℂ)*(A (1,0)-Complex.I*A (Complex.I,0)) := by + have hline (direction : ℂ) : + HasDerivAt (fun t : ℝ=>F (z+(t:ℂ)*direction,v)) (A (direction,0)) 0 := by + have hz : HasDerivAt (fun t : ℝ=>z+(t:ℂ)*direction) direction 0 := by + simpa using (((hasDerivAt_id (0:ℝ)).ofReal_comp.mul_const direction).const_add z) + have hp := hz.prodMk (hasDerivAt_const (0:ℝ) v) + have hf : HasFDerivAt F A (z+(0:ℂ)*direction,v) := by simpa using hF + exact hf.comp_hasDerivAt 0 hp + have h1 := (hline 1).deriv + have hI := (hline Complex.I).deriv + simp only [mul_one] at h1 + rw [horizontalWirtingerZ,h1,hI] + +theorem inverse_cusp_wirtinger_rule (c d : ℂ) (v : ℝ) (hc : c≠0) (hv : 0F (inverseCuspCoordinates c d v z)) 0= + (-1/(c^2*(v:ℂ)^2))* + horizontalWirtingerZ (fun z=>F (z,1/(‖c‖^2*v))) (-d/c) := by + rw [horizontalWirtingerZ_eq_fderiv F A _ _ hF] + exact inverse_cusp_wirtingerBar c d v hc hv F A hF + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +section + +theorem cusp_mellin_reflection (g : ℝ→ℂ) (A s : ℂ) (Q : ℝ) (hQ : 0A*((v:ℂ)^(-2:ℂ)*g ((Q*v)⁻¹))) (2*s)= + A*(Q:ℂ)^(2-2*s)*mellin g (2-2*s) := by + have he : (fun v : ℝ=>A*((v:ℂ)^(-2:ℂ)*g ((Q*v)⁻¹)))= + (fun v : ℝ=>A • ((v:ℂ)^(-2:ℂ) • g ((Q*v)⁻¹))) := by + funext v; simp only [smul_eq_mul] + rw [he,mellin_const_smul,mellin_cpow_smul] + have hm := mellin_comp_mul_left (fun v : ℝ=>g v⁻¹) (2*s+(-2:ℂ)) hQ + rw [mellin_comp_inv] at hm + rw [hm] + simp only [smul_eq_mul] + rw [show -(2*s+(-2:ℂ))=2-2*s by ring] + ring + +theorem cusp_mellin_reflection_of_identity (f g : ℝ→ℂ) (A s : ℂ) + (Q : ℝ) (hQ : 0 ActualEisensteinCubic.O + +def horizontalPhaseCLM (freq : ℂ) : ℂ →L[ℝ] ℂ := + (2*Real.pi*Complex.I:ℂ) • + (freq • ContinuousLinearMap.id ℝ ℂ + + (Complex.conjCLE : ℂ →L[ℝ] ℂ).comp (freq • ContinuousLinearMap.id ℝ ℂ)) + +lemma horizontalPhaseCLM_apply (freq direction : ℂ) : + horizontalPhaseCLM freq direction = horizontalPhaseMultiplier freq direction := by + simp [horizontalPhaseCLM,horizontalPhaseMultiplier] + ring + +lemma brevePhase_hasFDerivAt (freq z : ℂ) : + HasFDerivAt (fun w : ℂ => ShortDraftTrace.breveE (freq*w)) + (ShortDraftTrace.breveE (freq*z) • horizontalPhaseCLM freq) z := by + have hh := (horizontalPhaseCLM freq).hasFDerivAt.cexp (x:=z) + convert! hh using 1 + +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +def amplitudeDeriv (v : ℝ) (h : ActualEisensteinCubic.O) : ℂ := + if h=0 then 0 else coeff.value h* + (schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v)+ + (v:ℂ)*(4*Real.pi*‖cuspFrequency h‖:ℝ)* + schlafliBesselK_cubic_derivative (4*Real.pi*‖cuspFrequency h‖*v)) + +lemma amplitude_hasDerivAt (v : ℝ) (hv : 0 coeff.amplitude y h) (coeff.amplitudeDeriv v h) v := by + by_cases hh : h=0 + · simp only [amplitude,amplitudeDeriv,ite_eq_left hh] + exact hasDerivAt_const v 0 + have hr : 0<‖cuspFrequency h‖ := norm_pos_iff.mpr (cuspFrequency_ne_zero h hh) + have hslope : HasDerivAt (fun y : ℝ => 4*Real.pi*‖cuspFrequency h‖*y) + (4*Real.pi*‖cuspFrequency h‖) v := by + simpa only [id_eq,mul_one] using (hasDerivAt_id v).const_mul (4*Real.pi*‖cuspFrequency h‖) + have hk := (schlafliBesselK_cubic_hasDerivAt (4*Real.pi*‖cuspFrequency h‖*v) + (by positivity)).scomp v hslope + have hvd := (Complex.ofRealCLM.hasDerivAt (x:=v)).mul hk + have hfull := hvd.const_mul (coeff.value h) + simp only [amplitude,amplitudeDeriv,ite_eq_right hh] + convert! hfull using 1 <;> simp [Function.comp_def,Pi.mul_apply,Complex.ofRealCLM_apply,Complex.real_smul,mul_assoc] + +def termFDeriv (h : ActualEisensteinCubic.O) (p : ℝ × ℂ) : (ℝ × ℂ) →L[ℝ] ℂ := + if h=0 then 0 else + (ContinuousLinearMap.fst ℝ ℝ ℂ).smulRight + (coeff.amplitudeDeriv p.1 h*ShortDraftTrace.breveE (cuspFrequency h*p.2))+ + coeff.term h p • (horizontalPhaseCLM (cuspFrequency h)).comp + (ContinuousLinearMap.snd ℝ ℝ ℂ) + +lemma term_hasFDerivAt (h : ActualEisensteinCubic.O) (p : ℝ × ℂ) (hp : 0 (0:ℂ)) := by + funext q + simp only [term,ite_eq_left hh] + rw [hzero,termFDeriv,ite_eq_left hh] + exact hasFDerivAt_const (𝕜:=ℝ) (0:ℂ) p + have hvd := (coeff.amplitude_hasDerivAt p.1 hp h).hasFDerivAt.comp p + (hasFDerivAt_fst (𝕜:=ℝ) (p:=p)) + have hzd := (brevePhase_hasFDerivAt (cuspFrequency h) p.2).comp p + (hasFDerivAt_snd (𝕜:=ℝ) (p:=p)) + have hprod : HasFDerivAt (fun q : ℝ × ℂ => coeff.amplitude q.1 h* + ShortDraftTrace.breveE (cuspFrequency h*q.2)) (coeff.termFDeriv h p) p := by + convert! hvd.mul hzd using 1 + apply ContinuousLinearMap.ext + intro direction + simp only [termFDeriv,ite_eq_right hh] + change (direction.1:ℂ)*(coeff.amplitudeDeriv p.1 h* + ShortDraftTrace.breveE (cuspFrequency h*p.2))+ + coeff.term h p*horizontalPhaseCLM (cuspFrequency h) direction.2 = + coeff.amplitude p.1 h*(ShortDraftTrace.breveE (cuspFrequency h*p.2)* + horizontalPhaseCLM (cuspFrequency h) direction.2)+ + ShortDraftTrace.breveE (cuspFrequency h*p.2)* + ((direction.1:ℂ)*coeff.amplitudeDeriv p.1 h) + rw [coeff.term_eq_amplitude p.1 hp h p.2] + ring + apply hprod.congr_of_eventuallyEq + filter_upwards [continuousAt_fst.tendsto.eventually (Ioi_mem_nhds hp)] with q hq + exact coeff.term_eq_amplitude q.1 hq h q.2 + +end SubexponentialBesselCoefficients +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +section +local notation "O" => ActualEisensteinCubic.O +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma weighted_bessel_bounds (a : ℝ) (ha : 0 ActualEisensteinCubic.O + +lemma summable_one_add_norm_exp_neg_cuspFrequency (a : ℝ) (ha : 0 (1+‖cuspFrequency h‖)*Real.exp (-a*‖cuspFrequency h‖)) := by + simpa only [add_mul,one_mul] using + (summable_exp_neg_cuspFrequency_norm a ha).add (summable_norm_mul_exp_neg_cuspFrequency a ha) + +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma termFDeriv_summable (p : ℝ × ℂ) (hp : 0 coeff.termFDeriv h p) := by + obtain ⟨C,hC,hbound⟩ := coeff.termFDeriv_slab_bound p.1 p.1 hp le_rfl + apply Summable.of_norm + exact Summable.of_nonneg_of_le (fun h => norm_nonneg _) + (fun h => hbound h p ⟨le_rfl,le_rfl⟩) + ((summable_one_add_norm_exp_neg_cuspFrequency (Real.pi*p.1) (mul_pos Real.pi_pos hp)).mul_left C) + +lemma series_hasFDerivAt (p : ℝ × ℂ) (hp : 0 coeff.term_hasFDerivAt h q (ha.trans hq.1.1)) + (fun h q hq => hbound h q ⟨hq.1.1.le,hq.1.2.le⟩) + hpSlab (coeff.summable p hp) hpSlab + +lemma series_differentiableAt (p : ℝ × ℂ) (hp : 0 coeff.fullFunction constant (cuspCoordinateLift q)) p := by + have hc := ((hasDerivAt_ofReal_cpow_const hp.ne' (r:=(2/3:ℂ)) + (by norm_num)).const_mul constant).differentiableAt.comp p + (differentiableAt_fst (𝕜:=ℝ) (p:=p)) + have ht : DifferentiableAt ℝ (fun q : ℝ × ℂ => + constant*(q.1:ℂ)^(2/3:ℂ)+coeff.series q) p := by + convert! hc.add (coeff.series_differentiableAt p hp) using 1 + apply ht.congr_of_eventuallyEq + filter_upwards [continuousAt_fst.tendsto.eventually (Ioi_mem_nhds hp)] with q hq + exact coeff.fullFunction_cusp_eq constant q hq + +lemma fullFunction_split_differentiableAt (constant : ℂ) (p : ℂ × ℝ) (hp : 0 coeff.fullFunction constant (cuspCoordinateLift (q.2,q.1))) p := by + have hswap : DifferentiableAt ℝ (fun q : ℂ × ℝ => (q.2,q.1)) p := + differentiableAt_snd.prodMk differentiableAt_fst + exact (coeff.fullFunction_cusp_differentiableAt constant (p.2,p.1) hp).comp p hswap + +end SubexponentialBesselCoefficients +end + +open Filter MeasureTheory Asymptotics +open scoped BigOperators Classical Topology + +def truncatedCuspProfile (c : ℝ) (f : ℝ→ℂ) (x : ℝ) : ℂ := + if c] 0] 0 := by + have he : ∀ᶠx : ℝ in 𝓝[>] 0,xf (max (c/2) x)) := + hf.comp_continuous (continuous_const.max continuous_id) + (fun x=>lt_of_lt_of_le (by linarith : 0f (max (c/2) x)) := by + funext x + by_cases hx : cReal.exp (-decay*x))) : + (∀s : ℂ,MellinConvergent (truncatedCuspProfile c f) s) ∧ + Differentiable ℂ (mellin (truncatedCuspProfile c f)) := by + have hlocal := (truncatedCuspProfile_locallyIntegrable c hc f hf).locallyIntegrableOn (Set.Ioi 0) + have htop : truncatedCuspProfile c f =O[atTop] (fun x : ℝ=>Real.exp (-decay*x)) := + hbound.congr' (truncatedCuspProfile_eventually_top c f).symm Filter.EventuallyEq.rfl + have hzero (b : ℝ) : truncatedCuspProfile c f =O[𝓝[>] 0] (fun x : ℝ=>x^(-b)) := + (Asymptotics.isBigO_zero (fun x : ℝ=>x^(-b)) (𝓝[>] 0)).congr' + (truncatedCuspProfile_eventually_zero c hc f).symm Filter.EventuallyEq.rfl + constructor + · intro s + exact mellinConvergent_of_isBigO_rpow_exp hdecay hlocal htop (hzero (s.re-1)) (by linarith) + · intro s + exact mellin_differentiableAt_of_isBigO_rpow_exp hdecay hlocal htop (hzero (s.re-1)) (by linarith) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/LocalCutoffs.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/LocalCutoffs.lean new file mode 100644 index 0000000000000000000000000000000000000000..8cda032e5aca1e1827785ec4b17447cd05c8783b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/LocalCutoffs.lean @@ -0,0 +1,649 @@ +import OAI.NumberTheory.DirichletL.GaussSum.BranchScaling + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology SchwartzMap LineDeriv ContDiff + +structure PositiveChartCutoff where + func : EuclideanSpatial → ℝ + smooth : ContDiff ℝ ∞ func + compact : HasCompactSupport func + positive : tsupport func ⊆ {p | 0 < p 2} + +lemma kernelChartCutoff_exists (p : EuclideanSpatial) (hp : 0

(hχ hq).1⟩,hvalue,hrange,?_⟩ + intro q hq r hr heq + have hwEq := hUinj (hχ hq).2 (hχ hr).2 heq + have hc := congrArg hyperbolicEuclideanCoordinates hwEq + simpa only [hyperbolicEuclideanCoordinates_toHyperbolic _ (hχ hq).1, + hyperbolicEuclideanCoordinates_toHyperbolic _ (hχ hr).1] using hc + +def kernelLocalizedField (χ : PositiveChartCutoff) (f : kernelSmoothTests) + (p : EuclideanSpatial) : ℂ := χ.func p • kernelTestField f p + +lemma kernelLocalizedField_compact (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + HasCompactSupport (kernelLocalizedField χ f) := χ.compact.smul_right + +lemma kernelLocalizedField_tsupport (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + tsupport (kernelLocalizedField χ f) ⊆ tsupport χ.func := tsupport_smul_subset_left _ _ + +lemma kernelLocalizedField_smooth (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + ContDiff ℝ ∞ (kernelLocalizedField χ f) := by + rw [contDiff_iff_contDiffAt] + intro p + by_cases hp : 0 < p 2 + · exact χ.smooth.contDiffAt.smul (kernelTestField_contDiffAt f p hp) + · have hn : p ∉ tsupport χ.func := fun h => hp (χ.positive h) + have hz := notMem_tsupport_iff_eventuallyEq.mp hn + apply (contDiffAt_const : ContDiffAt ℝ ∞ (fun _ : EuclideanSpatial => (0 : ℂ)) p).congr_of_eventuallyEq + filter_upwards [hz] with q hq + simp only [kernelLocalizedField,hq,Pi.zero_apply,zero_smul] + +def kernelLocalizedSchwartz (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + 𝓢(EuclideanSpatial,ℂ) := + (kernelLocalizedField_compact χ f).toSchwartzMap (kernelLocalizedField_smooth χ f) + +lemma kernelLocalizedSchwartz_coe (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + (kernelLocalizedSchwartz χ f : EuclideanSpatial → ℂ)=kernelLocalizedField χ f := rfl + +def kernelLocalizedH1 (χ : PositiveChartCutoff) (f : kernelSmoothTests) : EuclideanH1 := by + let g := kernelLocalizedSchwartz χ f + let v := WithLp.toLp 2 (fun j => (∂_{euclideanCoordinateVector j} g).toLp 2 volume) + refine ⟨WithLp.toLp 2 (g.toLp 2 volume,v),?_⟩ + change (g.toLp 2 volume,v)∈euclideanWeakGradientGraph + exact schwartz_mem_euclideanWeakGradientGraph g + +lemma kernelLocalizedH1_embedding (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + euclideanH1Embedding (kernelLocalizedH1 χ f)= + (kernelLocalizedSchwartz χ f).toLp 2 volume := rfl + +lemma kernelLocalizedH1_gradient (χ : PositiveChartCutoff) (f : kernelSmoothTests) (j : Fin 3) : + euclideanH1Gradient (kernelLocalizedH1 χ f) j= + (∂_{euclideanCoordinateVector j} (kernelLocalizedSchwartz χ f)).toLp 2 volume := rfl + +lemma kernelLocalizedField_fderiv (χ : PositiveChartCutoff) (f : kernelSmoothTests) + (p : EuclideanSpatial) (hp : 0 < p 2) (u : EuclideanSpatial) : + fderiv ℝ (kernelLocalizedField χ f) p u= + χ.func p • fderiv ℝ (kernelTestField f) p u+ + (fderiv ℝ χ.func p u) • kernelTestField f p := by + change fderiv ℝ (χ.func • kernelTestField f) p u=_ + rw [fderiv_smul (χ.smooth.differentiable (by simp)).differentiableAt + ((kernelTestField_contDiffAt f p hp).differentiableAt (by simp))] + rfl + +lemma complex_norm_add_sq_le (z w : ℂ) : + ‖z+w‖^2 ≤ 2*‖z‖^2+2*‖w‖^2 := by + have hh := norm_add_le z w + have hn := norm_nonneg (z+w) + nlinarith [sq_nonneg (‖z‖-‖w‖)] + +lemma kernelLocalizedField_energy_bound (χ : PositiveChartCutoff) (f : kernelSmoothTests) + (p : EuclideanSpatial) (hp : 0

q 2) hc + simp only [hv,kernelTestPartial,hc] + rw [he] + have hh := mul_le_mul_of_nonneg_left hsum (sq_nonneg (p 2)) + simpa only [Finset.sum_add_distrib,←Finset.mul_sum,←Finset.sum_mul, + mul_add,mul_assoc,mul_left_comm,mul_comm] using hh + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff ENNReal + +def kernelEuclideanProjection : EuclideanSpatial → KernelQuotient := + integralOrbitProjection globalKubotaKernel ∘ euclideanToHyperbolic + +lemma kernelEuclideanProjection_measurable : Measurable kernelEuclideanProjection := + (measurable_integralOrbitProjection _).comp euclideanToHyperbolic_measurable + +lemma euclideanToHyperbolic_measurePreserving_on (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (_hpos : S⊆euclideanUpperHalf) : + MeasurePreserving euclideanToHyperbolic (hyperbolicEuclideanVolume.restrict S) + (hyperbolicVolume.restrict (hyperbolicEuclideanCoordinates ⁻¹' S)) := by + have hU : MeasurableSet (hyperbolicEuclideanCoordinates ⁻¹' S) := + hyperbolicEuclideanCoordinates_continuous.measurable hS + have hset : euclideanToHyperbolic ⁻¹' (hyperbolicEuclideanCoordinates ⁻¹' S)=ᵐ[hyperbolicEuclideanVolume]S := by + filter_upwards [hyperbolicEuclideanVolume_ae_positive] with p hp + simp only [Set.mem_preimage,hyperbolicEuclideanCoordinates_toHyperbolic p hp] + refine ⟨euclideanToHyperbolic_measurable,?_⟩ + rw [hyperbolicVolume,Measure.restrict_map euclideanToHyperbolic_measurable hU, + Measure.restrict_congr_set hset] + +lemma euclideanToHyperbolic_image_positive (S : Set EuclideanSpatial) + (hpos : S⊆euclideanUpperHalf) : + euclideanToHyperbolic '' S=hyperbolicEuclideanCoordinates ⁻¹' S := by + ext w + constructor + · rintro ⟨p,hp,rfl⟩ + simpa only [Set.mem_preimage,hyperbolicEuclideanCoordinates_toHyperbolic p (hpos hp)] using hp + · intro hw + exact ⟨hyperbolicEuclideanCoordinates w,hw,euclideanToHyperbolic_coordinates w⟩ + +lemma kernelEuclideanProjection_measurePreserving_on (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (hpos : S⊆euclideanUpperHalf) + (hinj : Set.InjOn kernelEuclideanProjection S) : + MeasurePreserving kernelEuclideanProjection (hyperbolicEuclideanVolume.restrict S) + ((integralQuotientVolume globalKubotaKernel).restrict (kernelEuclideanProjection '' S)) := by + have hU : MeasurableSet (hyperbolicEuclideanCoordinates ⁻¹' S) := + hyperbolicEuclideanCoordinates_continuous.measurable hS + have hi : Set.InjOn (integralOrbitProjection globalKubotaKernel) + (hyperbolicEuclideanCoordinates ⁻¹' S) := by + intro u hu v hv heq + have hh := hinj hu hv (by simpa only [kernelEuclideanProjection,Function.comp_apply, + euclideanToHyperbolic_coordinates] using heq) + have hh' := congrArg euclideanToHyperbolic hh + simpa only [euclideanToHyperbolic_coordinates] using hh' + have hcomp := (kernelProjection_measurePreserving_on _ hU hi).comp + (euclideanToHyperbolic_measurePreserving_on S hS hpos) + have himage : integralOrbitProjection globalKubotaKernel '' + (hyperbolicEuclideanCoordinates ⁻¹' S)=kernelEuclideanProjection '' S := by + rw [←euclideanToHyperbolic_image_positive S hpos,Set.image_image] + rfl + rwa [himage] at hcomp + +lemma kernelEuclideanProjection_integral (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (hpos : S⊆euclideanUpperHalf) + (hinj : Set.InjOn kernelEuclideanProjection S) (g : KernelQuotient → ℝ) + (hg : AEStronglyMeasurable g (integralQuotientVolume globalKubotaKernel)) : + (∫p in S,g (kernelEuclideanProjection p)∂hyperbolicEuclideanVolume)= + ∫q in kernelEuclideanProjection '' S,g q∂integralQuotientVolume globalKubotaKernel := by + have hm := kernelEuclideanProjection_measurePreserving_on S hS hpos hinj + have hh := hg.mono_measure (Measure.restrict_le_self (s := kernelEuclideanProjection '' S)) + rw [←hm.map_eq] at hh ⊢ + exact (integral_map hm.measurable.aemeasurable hh).symm + +lemma kernelEuclideanProjection_integral_le (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (hpos : S⊆euclideanUpperHalf) + (hinj : Set.InjOn kernelEuclideanProjection S) (g : KernelQuotient → ℝ) + (hg : Integrable g (integralQuotientVolume globalKubotaKernel)) (hgn : ∀q,0≤g q) : + (∫p in S,g (kernelEuclideanProjection p)∂hyperbolicEuclideanVolume)≤ + ∫q,g q∂integralQuotientVolume globalKubotaKernel := by + rw [kernelEuclideanProjection_integral S hS hpos hinj g hg.aestronglyMeasurable] + exact setIntegral_le_integral hg (Eventually.of_forall hgn) + +lemma kernelLocalEnergy_le (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (hpos : S⊆euclideanUpperHalf) + (hinj : Set.InjOn kernelEuclideanProjection S) (f : kernelSmoothTests) : + (∫p in S,kernelTestEnergyDensity f (euclideanToHyperbolic p)∂hyperbolicEuclideanVolume)≤ + kernelDirichletEnergy f := by + exact kernelEuclideanProjection_integral_le S hS hpos hinj _ + (kernelQuotientEnergyDensity_integrable f) (kernelQuotientEnergyDensity_nonneg f) + +lemma kernelSmoothTestsToL2_norm_sq (f : kernelSmoothTests) : + ‖kernelSmoothTestsToL2 f‖^2= + ∫q,‖f.1 q‖^2∂integralQuotientVolume globalKubotaKernel := by + calc + ‖kernelSmoothTestsToL2 f‖^2=inner ℝ (kernelSmoothTestsToL2 f) (kernelSmoothTestsToL2 f) := + (real_inner_self_eq_norm_sq _).symm + _ = ∫q,inner ℝ (kernelSmoothTestsToL2 f q) (kernelSmoothTestsToL2 f q) + ∂integralQuotientVolume globalKubotaKernel := rfl + _ = _ := by + apply integral_congr_ae + filter_upwards [(kernelSmoothTests_memLp f).coeFn_toLp] with q hq + change inner ℝ (((kernelSmoothTests_memLp f).toLp f.1) q) + (((kernelSmoothTests_memLp f).toLp f.1) q)=_ + rw [hq,real_inner_self_eq_norm_sq] + +lemma kernelLocalMass_le (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (hpos : S⊆euclideanUpperHalf) + (hinj : Set.InjOn kernelEuclideanProjection S) (f : kernelSmoothTests) : + (∫p in S,‖kernelTestField f p‖^2∂hyperbolicEuclideanVolume)≤‖kernelSmoothTestsToL2 f‖^2 := by + rw [kernelSmoothTestsToL2_norm_sq] + exact kernelEuclideanProjection_integral_le S hS hpos hinj _ + (kernelSmoothTests_memLp f).norm.integrable_sq (fun _ => sq_nonneg _) + +lemma euclideanVolume_le_heightCube_hyperbolic (S : Set EuclideanSpatial) + (hS : MeasurableSet S) (hpos : S⊆euclideanUpperHalf) (b : ℝ) (hb : 0≤b) + (hheight : ∀p∈S,p 2≤b) : + volume.restrict S≤ENNReal.ofReal (b^3) • hyperbolicEuclideanVolume.restrict S := by + have hw : hyperbolicEuclideanVolume.restrict S=(volume.restrict S).withDensity hyperbolicDensity := by + rw [hyperbolicEuclideanVolume,MeasureTheory.restrict_withDensity hS, + Measure.restrict_restrict hS,Set.inter_eq_left.mpr hpos] + rw [hw] + have hbd : (1 : EuclideanSpatial→ℝ≥0∞)≤ᵐ[volume.restrict S] + ENNReal.ofReal (b^3) • hyperbolicDensity := by + filter_upwards [ae_restrict_mem hS] with p hp + have ht : 0

hgn (kernelEuclideanProjection p))) + (hgi.smul_measure ENNReal.ofReal_ne_top) + rw [integral_smul_measure,ENNReal.toReal_ofReal (pow_nonneg hb 3)] at hh + exact hh.trans (mul_le_mul_of_nonneg_left + (kernelEuclideanProjection_integral_le S hS hpos hinj g hg hgn) (pow_nonneg hb 3)) + +end CubicEisenstein + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace CompletedGauss + +section +open ActualEisensteinCubic CanonicalQuadraticSieve CompletedDyadic + +theorem completed_scaled_shape (ε k y H c B : ℝ) (hε : 0≤ε) (hk : 0 IsCoprime (P i) (P j)) → + (∀i,P i∣I*Q) → (∀i,¬P i∣rowResidualPart I Q) → + ∀e : ι→Fin 3,∀S T : (ℕ×ℕ×ℕ)→Finset (Ideal O), + (∀i,∀J∈S i,J≠0 ∧ (2:ℝ)^i.2.2/2≤(Ideal.absNorm J:ℝ) ∧ (Ideal.absNorm J:ℝ)≤(2:ℝ)^i.2.2) → + (∀i,∀J∈T i,J≠0 ∧ (2:ℝ)^i.2.1/2≤(Ideal.absNorm J:ℝ) ∧ (Ideal.absNorm J:ℝ)≤(2:ℝ)^i.2.1) → + ∀η : (ℕ×ℕ×ℕ)→Ideal O→Ideal O→ℂ, + (∀i,∀n∈S i,∀v∈T i,‖η i n v‖≤1) → + ∀σ : (ℕ×ℕ×ℕ)→idealRange (completedResidualScale K I Q)→ℂ,(∀i k,‖σ i k‖≤1) → + (∑k : idealRange (completedResidualScale K I Q),‖∑'i : ℕ×ℕ×ℕ, + reflectedBranchBlock P hg (fun i => completedLocalExponent I F (P i)) e W + (completedResidualScale K I Q) (completedBranchScale K (X/c) I F Q P e) ρ q S T η σ i k‖^2) + ≤C*(K*(Ideal.absNorm Q:ℝ))^(10*deltaLoss)*(K+K^2*(Ideal.absNorm Q:ℝ)/X)/ + (Ideal.absNorm (rowPowerfulPart I):ℝ) := by + obtain ⟨C,hC,h⟩ := completed_reflected_branch_series W a b ha hsupp hW deltaLoss ρ q hδ hρ hq + refine ⟨C*B^(2*deltaLoss+1),by positivity,?_⟩ + intro K X c hK hX hc hcB I F Q hI hQ hIK hk ι _ P _ hg hcop hpool hres e S T hS hT η hη σ hσ + have hn (J : Ideal O) (hJ : J≠0) : 0<(Ideal.absNorm J:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun hz => hJ (Ideal.absNorm_eq_zero_iff.mp hz)) + have hj (v : Fin 3) := hn _ (reflectionExtractedDivisor_ne_zero P (fun i => NeZero.ne (P i)) + (fun i => completedLocalExponent I F (P i)) e v) + have hp := hn (∏i,P i) (Finset.prod_ne_zero_iff.mpr (fun i _ => NeZero.ne (P i))) + have hk0 : 0 completedLocalExponent I F (P i)) e S T hS hT η hη σ hσ).2 + have hs := completed_scaled_shape (2*deltaLoss) (completedResidualScale K I Q) + (completedBranchScale K X I F Q P e) _ c B (by positivity) hk0 hy + (mul_pos (hj 0) (hj 2)) hc hcB hB + have hcst := completed_actual_fiber_cost deltaLoss K X hδ.le hK hX I F Q hI hQ hIK P hcop hpool hres e + have hh := hs.trans (mul_le_mul_of_nonneg_left hcst (by positivity : 0≤B^(2*deltaLoss+1))) + apply hb.trans + have hfinal := mul_le_mul_of_nonneg_left hh hC.le + convert hfinal using 1 <;> (try dsimp [completedResidualScale,completedBranchScale]) <;> ring + +end + +open ActualEisensteinCubic CanonicalQuadraticSieve + +structure ReflectedBranchData (levelBound K : ℝ) (I F Q : Ideal O) where + levelScale : ℝ + levelScale_pos : 0 IsCoprime p.val r.val) + divides : ∀p : primes,p.val∣I*Q + nonresidual : ∀p : primes,¬p.val∣rowResidualPart I Q + label : primes→Fin 3 + nColumns : (ℕ×ℕ×ℕ)→Finset (Ideal O) + bColumns : (ℕ×ℕ×ℕ)→Finset (Ideal O) + nBounds : ∀i,∀J∈nColumns i,J≠0 ∧ (2:ℝ)^i.2.2/2≤(Ideal.absNorm J:ℝ) ∧ (Ideal.absNorm J:ℝ)≤(2:ℝ)^i.2.2 + bBounds : ∀i,∀J∈bColumns i,J≠0 ∧ (2:ℝ)^i.2.1/2≤(Ideal.absNorm J:ℝ) ∧ (Ideal.absNorm J:ℝ)≤(2:ℝ)^i.2.1 + amplitude : (ℕ×ℕ×ℕ)→Ideal O→Ideal O→ℂ + amplitude_bound : ∀i,∀n∈nColumns i,∀b∈bColumns i,‖amplitude i n b‖≤1 + rowPhase : (ℕ×ℕ×ℕ)→idealRange (completedResidualScale K I Q)→ℂ + rowPhase_bound : ∀i k,‖rowPhase i k‖≤1 + +namespace ReflectedBranchData + +def value {levelBound K : ℝ} {I F Q : Ideal O} (d : ReflectedBranchData levelBound K I F Q) + (W : ℝ→ℂ) (X ρ q : ℝ) (k : idealRange (completedResidualScale K I Q)) : ℂ := by + letI : ∀p : d.primes,p.val.IsMaximal := d.maximal + exact ∑'i : ℕ×ℕ×ℕ,reflectedBranchBlock (fun p : d.primes => p.val) d.good + (fun p => completedLocalExponent I F p.val) d.label W + (completedResidualScale K I Q) (completedBranchScale K (X/d.levelScale) I F Q (fun p : d.primes => p.val) d.label) + ρ q d.nColumns d.bColumns d.amplitude d.rowPhase i k + +theorem energy_bound + (W : ℝ→ℂ) (a b : ℝ) (ha : 0 (1:ℝ)) (fun t => ‖w t*f t k‖) + have hn : ‖∑t,w t*f t k‖^2≤(∑t,‖w t*f t k‖)^2 := + pow_le_pow_left₀ (norm_nonneg _) (norm_sum_le _ _) 2 + apply hn.trans + apply (show (∑t,‖w t*f t k‖)^2≤(Fintype.card τ:ℝ)*∑t,‖w t*f t k‖^2 by simpa using h).trans + apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg _) + apply Finset.sum_le_sum + intro t _ + apply pow_le_pow_left₀ (norm_nonneg _) + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (hw t) + calc + _ ≤ ∑k,(Fintype.card τ:ℝ)*∑t,‖f t k‖^2 := Finset.sum_le_sum (fun k _ => hpoint k) + _ = (Fintype.card τ:ℝ)*∑t,∑k,‖f t k‖^2 := by rw [←Finset.mul_sum,Finset.sum_comm] + _ ≤ (Fintype.card τ:ℝ)*∑_t : τ,E := + mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun t _ => hf t)) (Nat.cast_nonneg _) + _ = _ := by simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul]; ring + +theorem energy_bound + (W : ℝ→ℂ) (a b : ℝ) (ha : 0 p.val) + Subtype.val_injective d.divides + have hnorm : (Ideal.absNorm (I*Q):ℝ)≤K*(Ideal.absNorm Q:ℝ) := by + simp only [map_mul,Nat.cast_mul] + exact mul_le_mul_of_nonneg_right hIK (Nat.cast_nonneg _) + have hcount' : (6:ℝ)^(2*d.pool.card)≤Cp*(K*(Ideal.absNorm Q:ℝ))^ε := by + have hc : (6:ℝ)^(2*d.pool.card)≤Cp*(Ideal.absNorm (I*Q):ℝ)^ε := by + simpa only [Fintype.card_coe] using hcount + exact hc.trans (mul_le_mul_of_nonneg_left (Real.rpow_le_rpow (Nat.cast_nonneg _) hnorm hε.le) hCp.le) + have he := finite_energy_bound + (fun b => (d.branch b).value W X ρ q) d.weight d.weight_bound _ + (fun b => hb K X hK hX I F Q hI hQ hIK hk (d.branch b)) + change (∑k,‖d.value W X ρ q k‖^2)≤_ at he + apply he.trans + have hc : (Fintype.card (Fin rays×(d.pool→Fin 6)):ℝ)^2=(rays:ℝ)^2*(6:ℝ)^(2*d.pool.card) := by + simp only [Fintype.card_prod,Fintype.card_fun,Fintype.card_fin,Fintype.card_coe,Nat.cast_mul,Nat.cast_pow] + rw [mul_pow,←pow_mul,Nat.mul_comm d.pool.card 2] + norm_num + rw [hc] + have hnQ : 0<(Ideal.absNorm Q:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun hz => hQ (Ideal.absNorm_eq_zero_iff.mp hz)) + have hKQ : 0 + squarefreeResidualPart_ne_zero (rowSimplePart I) Q (Ideal.absNorm_eq_zero_iff.mp hz)) + apply hn.trans + rw [rowResidualPart_norm I Q hI,completedResidualScale] + exact div_le_div_of_nonneg_right hIK (by positivity) + +namespace ReflectedFiberData + +def idealValue {rays : ℕ} {levelBound K : ℝ} {I F Q : Ideal O} (d : ReflectedFiberData rays levelBound K I F Q) + (W : ℝ→ℂ) (X ρ q : ℝ) (J : Ideal O) : ℂ := + if h : J∈idealRange (completedResidualScale K I Q) then d.value W X ρ q ⟨J,h⟩ else 0 + +theorem idealValue_at {rays : ℕ} {levelBound K : ℝ} {I F Q : Ideal O} (d : ReflectedFiberData rays levelBound K I F Q) + (W : ℝ→ℂ) (X ρ q : ℝ) (J : idealRange (completedResidualScale K I Q)) : + d.idealValue W X ρ q J.val=d.value W X ρ q J := by + simp only [idealValue,dite_eq_left J.property] + +end ReflectedFiberData + +def HasExactCompletedModels (rays : ℕ) (rows : Finset (Ideal O)) + (K X ρ q levelBound : ℝ) (F Q : Ideal O) (W : ℝ→ℂ) (Ψ : Ideal O→O→*ℂ) (lengthScale : ℂ) : Prop := + ∀A∈rows.image rowPowerfulPart,∀T∈rows.image (fun I => rowMaskPart I Q), + (completedRowFiber rows Q A T).Nonempty → + ∃I∈completedRowFiber rows Q A T,∃d : ReflectedFiberData rays levelBound K I F Q, + ∀J∈completedRowFiber rows Q A T, + completedT (Ψ J) W X=lengthScale*d.idealValue W X ρ q (rowResidualPart J Q) + +theorem completed_energy_of_exact_models + (W : ℝ→ℂ) (a b : ℝ) (ha : 0 rowMaskPart I Q), + (∑I∈completedRowFiber rows Q A T,‖completedT (Ψ I) W X‖^2)≤B/(Ideal.absNorm A:ℝ) := by + intro A hA T hT + by_cases hempty : (completedRowFiber rows Q A T).Nonempty + · obtain ⟨I,hIf,d,hd⟩ := hexact A hA T hT hempty + obtain ⟨hIr,hIA,hIT⟩ := Finset.mem_filter.mp hIf + have hI := (hrows I hIr).1 + have hIK := (hrows I hIr).2 + have hk := one_le_completedResidualScale K I Q hI hIK + have hdenergy := hm rays K X hK hX I F Q hI hQ hIK hk d + have hembed := completedRowFiber_energy_le rows Q A T hbad K hrows + (d.idealValue W X ρ q) + have hscale : K/((Ideal.absNorm A:ℝ)*(Ideal.absNorm T:ℝ))=completedResidualScale K I Q := by + simp only [completedResidualScale,hIA,hIT] + rw [hscale] at hembed + simp_rw [ReflectedFiberData.idealValue_at] at hembed + have hsource : (∑J∈completedRowFiber rows Q A T,‖completedT (Ψ J) W X‖^2)= + ‖lengthScale‖^2*∑J∈completedRowFiber rows Q A T,‖d.idealValue W X ρ q (rowResidualPart J Q)‖^2 := by + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + rw [hd J hJ,norm_mul,mul_pow] + rw [hsource] + apply (mul_le_mul_of_nonneg_left (hembed.trans hdenergy) (sq_nonneg _)).trans + apply le_of_eq + dsimp [B] + rw [hIA] + ring + · rw [Finset.not_nonempty_iff_eq_empty.mp hempty,Finset.sum_empty] + exact div_nonneg hB (Nat.cast_nonneg _) + have hh := ho rows Q hQ (fun I => ‖completedT (Ψ I) W X‖^2) B hB hblocks + apply hh.trans_eq + dsimp [B] + ring + +end CompletedGauss + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/MeromorphicResolvent.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/MeromorphicResolvent.lean new file mode 100644 index 0000000000000000000000000000000000000000..a966372450e690c876f01af94ea12ee4dc9315f3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/MeromorphicResolvent.lean @@ -0,0 +1,702 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.FredholmAlternative + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open scoped Topology + +lemma kernelSpectralFormOperator_analyticAt (z : ℂ) : + AnalyticAt ℂ kernelSpectralFormOperator z := by + let S : KernelEnergyGraph→L[ℂ]KernelEnergyGraph := kernelEnergyMass.adjoint.comp kernelEnergyMass + have hc : AnalyticAt ℂ (fun w : ℂ => w • S) (z+1) := by + simpa only [ContinuousLinearMap.smulRight_apply,ContinuousLinearMap.id_apply] using! + (ContinuousLinearMap.analyticAt (𝕜 := ℂ) (E := ℂ) + (F := KernelEnergyGraph→L[ℂ]KernelEnergyGraph) + (ContinuousLinearMap.smulRight (ContinuousLinearMap.id ℂ ℂ) S) (z+1)) + have hz : AnalyticAt ℂ (fun w : ℂ => w+1) z := analyticAt_id.add analyticAt_const + exact analyticAt_const.sub (hc.comp_of_eq hz rfl) + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace + +def kernelMassGram : KernelEnergyGraph→L[ℂ]KernelEnergyGraph := + kernelEnergyMass.adjoint.comp kernelEnergyMass + +private lemma selfAdjoint_adjoint_comp {E F : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + (A : E →L[ℂ] F) : IsSelfAdjoint (A.adjoint.comp A) := by + rw [ContinuousLinearMap.isSelfAdjoint_iff'] + rw [ContinuousLinearMap.adjoint_comp,ContinuousLinearMap.adjoint_adjoint] + +lemma kernelMassGram_selfAdjoint : IsSelfAdjoint kernelMassGram := + selfAdjoint_adjoint_comp kernelEnergyMass + +def kernelThetaNull : Submodule ℂ KernelEnergyGraph := + (kernelSpectralFormOperator (8/9:ℂ)).ker + +def kernelThetaRegular : Submodule ℂ KernelEnergyGraph := kernelThetaNullᗮ + +instance kernelThetaNull_complete : CompleteSpace kernelThetaNull := + (kernelSpectralFormOperator (8/9:ℂ)).isClosed_ker.completeSpace_coe + +instance kernelThetaRegular_complete : CompleteSpace kernelThetaRegular := + kernelThetaNull.isClosed_orthogonal.completeSpace_coe + +instance kernelThetaNull_finiteDimensional : FiniteDimensional ℂ kernelThetaNull := + kernel_theta_spectral_fredholm.finite_ker + +lemma kernelThetaNull_gram_eq (u : KernelEnergyGraph) (hu : u∈kernelThetaNull) : + kernelMassGram u=(9/17:ℂ)•u := by + have hh : u-(8/9+1:ℂ)•kernelMassGram u=0 := hu + have he : u=(17/9:ℂ)•kernelMassGram u := by + simpa only [show (8/9+1:ℂ)=17/9 by norm_num] using sub_eq_zero.mp hh + calc + _ = (9/17:ℂ)•((17/9:ℂ)•kernelMassGram u) := by rw [smul_smul]; norm_num + _ = _ := by rw [←he] + +lemma kernelThetaNull_spectral_eq (z : ℂ) (u : KernelEnergyGraph) (hu : u∈kernelThetaNull) : + kernelSpectralFormOperator z u=((8/9-z)*(9/17):ℂ)•u := by + change u-(z+1)•kernelMassGram u=_ + rw [kernelThetaNull_gram_eq u hu,smul_smul] + calc + u-((z+1)*(9/17):ℂ)•u=(1-(z+1)*(9/17):ℂ)•u := by rw [sub_smul,one_smul] + _ = _ := by congr 1; ring + +lemma kernelMassGram_preserves_regular (u : KernelEnergyGraph) (hu : u∈kernelThetaRegular) : + kernelMassGram u∈kernelThetaRegular := by + apply (kernelThetaNull.mem_orthogonal _).mpr + intro v hv + have he : inner ℂ v (kernelMassGram u)=inner ℂ (kernelMassGram v) u := by + simpa only [ContinuousLinearMap.coe_coe] using (kernelMassGram_selfAdjoint.isSymmetric v u).symm + rw [he,kernelThetaNull_gram_eq v hv,inner_smul_left (𝕜 := ℂ) v u (9/17:ℂ)] + rw [kernelThetaNull.inner_right_of_mem_orthogonal hv hu,mul_zero] + +lemma kernelSpectralFormOperator_preserves_regular (z : ℂ) + (u : KernelEnergyGraph) (hu : u∈kernelThetaRegular) : + kernelSpectralFormOperator z u∈kernelThetaRegular := + kernelThetaRegular.sub_mem hu (kernelThetaRegular.smul_mem _ (kernelMassGram_preserves_regular u hu)) + +def kernelRegularGram : kernelThetaRegular→L[ℂ]kernelThetaRegular := + kernelMassGram.restrict kernelMassGram_preserves_regular + +def kernelRegularPencil (z : ℂ) : kernelThetaRegular→L[ℂ]kernelThetaRegular := + ContinuousLinearMap.id ℂ kernelThetaRegular-(z+1)•kernelRegularGram + +lemma kernelRegularPencil_apply (z : ℂ) (u : kernelThetaRegular) : + (kernelRegularPencil z u:KernelEnergyGraph)=kernelSpectralFormOperator z u := rfl + +lemma kernelRegularPencil_center_isUnit : IsUnit (kernelRegularPencil (8/9:ℂ)) := by + apply (ContinuousLinearMap.isUnit_iff_bijective (𝕜 := ℂ) (E := kernelThetaRegular)).mpr + constructor + · intro u v huv + apply ker_orthogonal_restriction_injective (kernelSpectralFormOperator (8/9:ℂ)) + exact congrArg (fun w : kernelThetaRegular => (w:KernelEnergyGraph)) huv + · intro v + have he : (kernelSpectralFormOperator (8/9:ℂ)).range=kernelThetaRegular := by + exact selfAdjoint_range_eq_ker_orthogonal _ + (by convert kernelSpectralFormOperator_selfAdjoint (8/9) using 1 ; norm_num) + kernel_theta_spectral_fredholm.isClosed_range + have hv : (v:KernelEnergyGraph)∈(kernelSpectralFormOperator (8/9:ℂ)).range := by + rw [he] + exact v.2 + obtain ⟨u,hu⟩ := hv + change kernelSpectralFormOperator (8/9:ℂ) u=(v:KernelEnergyGraph) at hu + let w : kernelThetaRegular := ⟨u-kernelThetaNull.starProjection u,kernelThetaNull.sub_starProjection_mem_orthogonal u⟩ + refine ⟨w,Subtype.ext ?_⟩ + rw [kernelRegularPencil_apply] + change kernelSpectralFormOperator (8/9:ℂ) (u-kernelThetaNull.starProjection u)=v + rw [map_sub,hu] + have hz : kernelSpectralFormOperator (8/9:ℂ) (kernelThetaNull.starProjection u)=0 := + kernelThetaNull.starProjection_apply_mem u + rw [hz,sub_zero] + +private abbrev endomorphismNormedSpace (E : Type*) [NormedAddCommGroup E] + [NormedSpace ℂ E] : NormedSpace ℂ (E →L[ℂ] E) := inferInstance + +local instance : NormedSpace ℂ (kernelThetaRegular →L[ℂ] kernelThetaRegular) := + endomorphismNormedSpace kernelThetaRegular + +lemma kernelRegularPencil_analyticAt (z : ℂ) : + AnalyticAt ℂ kernelRegularPencil z := by + have hc : AnalyticAt ℂ (fun w : ℂ => w • kernelRegularGram) (z+1) := by + simpa only [ContinuousLinearMap.smulRight_apply,ContinuousLinearMap.id_apply] using! + (ContinuousLinearMap.analyticAt (𝕜 := ℂ) (E := ℂ) + (F := kernelThetaRegular→L[ℂ]kernelThetaRegular) + (ContinuousLinearMap.smulRight (ContinuousLinearMap.id ℂ ℂ) kernelRegularGram) (z+1)) + have hz : AnalyticAt ℂ (fun w : ℂ => w+1) z := analyticAt_id.add analyticAt_const + exact analyticAt_const.sub (hc.comp_of_eq hz rfl) + +lemma kernelRegularPencil_eventually_isUnit : + ∀ᶠ z : ℂ in 𝓝 (8/9:ℂ), IsUnit (kernelRegularPencil z) := + (kernelRegularPencil_analyticAt (8/9)).continuousAt.eventually + ((Units.isOpen (R := kernelThetaRegular→L[ℂ]kernelThetaRegular)).mem_nhds + (show kernelRegularPencil (8/9)∈{x : kernelThetaRegular→L[ℂ]kernelThetaRegular | IsUnit x} from + kernelRegularPencil_center_isUnit)) + +lemma kernelRegularInverse_analyticAt : + AnalyticAt ℂ (fun z : ℂ => Ring.inverse (kernelRegularPencil z)) (8/9:ℂ) := by + have hi := (analyticOnNhd_inverse (𝕜 := ℂ) + (A := kernelThetaRegular→L[ℂ]kernelThetaRegular)) + (kernelRegularPencil (8/9)) kernelRegularPencil_center_isUnit + exact hi.comp_of_eq (kernelRegularPencil_analyticAt (8/9)) rfl + +private def continuousLinearSandwich {H G : Type*} + [NormedAddCommGroup H] [NormedSpace ℂ H] + [NormedAddCommGroup G] [NormedSpace ℂ G] + (A : H →L[ℂ] G) (B : G →L[ℂ] H) : + (H →L[ℂ] H) →L[ℂ] (G →L[ℂ] G) := + (ContinuousLinearMap.compL ℂ G H G A).comp + ((ContinuousLinearMap.compL ℂ G H H).flip B) + +def kernelRegularLiftCLM : + (kernelThetaRegular→L[ℂ]kernelThetaRegular)→L[ℂ](KernelEnergyGraph→L[ℂ]KernelEnergyGraph) := + continuousLinearSandwich (H := kernelThetaRegular) (G := KernelEnergyGraph) + kernelThetaRegular.subtypeL + kernelThetaRegular.orthogonalProjectionOnto + +def kernelRegularInverseLift (z : ℂ) : KernelEnergyGraph→L[ℂ]KernelEnergyGraph := + kernelRegularLiftCLM (Ring.inverse (kernelRegularPencil z)) + +lemma kernelRegularInverseLift_apply (z : ℂ) (u : KernelEnergyGraph) : + kernelRegularInverseLift z u = + (Ring.inverse (kernelRegularPencil z) (kernelThetaRegular.orthogonalProjectionOnto u) : + KernelEnergyGraph) := rfl + +lemma kernelRegularInverseLift_analyticAt : + AnalyticAt ℂ kernelRegularInverseLift (8/9:ℂ) := by + exact (ContinuousLinearMap.analyticAt (𝕜 := ℂ) + (E := kernelThetaRegular→L[ℂ]kernelThetaRegular) + (F := KernelEnergyGraph→L[ℂ]KernelEnergyGraph) + kernelRegularLiftCLM (Ring.inverse (kernelRegularPencil (8/9)))).comp_of_eq + kernelRegularInverse_analyticAt rfl + +def kernelLocalEnergyResolvent (z : ℂ) : KernelEnergyGraph→L[ℂ]KernelEnergyGraph := + ((17/9)/(8/9-z):ℂ) • kernelThetaNull.starProjection + kernelRegularInverseLift z + +lemma kernelLocalEnergyResolvent_meromorphicAt : + MeromorphicAt kernelLocalEnergyResolvent (8/9:ℂ) := by + have hs : MeromorphicAt (fun z : ℂ => (17/9)/(8/9-z)) (8/9:ℂ) := by fun_prop + have hp : MeromorphicAt (fun z : ℂ => ((17/9)/(8/9-z):ℂ) • kernelThetaNull.starProjection) (8/9:ℂ) := by + obtain ⟨n,hn⟩ := hs + refine ⟨n,?_⟩ + let A := ContinuousLinearMap.smulRight (ContinuousLinearMap.id ℂ ℂ) kernelThetaNull.starProjection + have ha := ContinuousLinearMap.analyticAt (𝕜 := ℂ) (E := ℂ) + (F := KernelEnergyGraph→L[ℂ]KernelEnergyGraph) A + (((8/9:ℂ)-(8/9))^n*((17/9)/(8/9-(8/9)))) + convert ha.comp_of_eq hn rfl using 1 ; + simp [A,Function.comp_def,smul_smul,smul_eq_mul] + exact hp.add kernelRegularInverseLift_analyticAt.meromorphicAt + +lemma kernelSpectralFormOperator_regularInverseLift (z : ℂ) + (hz : IsUnit (kernelRegularPencil z)) (u : KernelEnergyGraph) : + kernelSpectralFormOperator z (kernelRegularInverseLift z u)= + kernelThetaRegular.starProjection u := by + rw [kernelRegularInverseLift_apply,←kernelRegularPencil_apply] + have he := congrArg (fun A : kernelThetaRegular→L[ℂ]kernelThetaRegular => + A (kernelThetaRegular.orthogonalProjectionOnto u)) + (Ring.mul_inverse_cancel (kernelRegularPencil z) hz) + exact congrArg (fun v : kernelThetaRegular => (v:KernelEnergyGraph)) he + +lemma kernelLocalEnergyResolvent_right_inverse (z : ℂ) (hne : z≠8/9) + (hz : IsUnit (kernelRegularPencil z)) (u : KernelEnergyGraph) : + kernelSpectralFormOperator z (kernelLocalEnergyResolvent z u)=u := by + change kernelSpectralFormOperator z + (((17/9)/(8/9-z):ℂ) • kernelThetaNull.starProjection u + kernelRegularInverseLift z u)=u + rw [map_add,map_smul,kernelThetaNull_spectral_eq z _ + (kernelThetaNull.starProjection_apply_mem u),smul_smul] + have hc : ((17/9)/(8/9-z):ℂ)*((8/9-z)*(9/17))=1 := by + calc + _ = (((17/9)/(8/9-z):ℂ)*(8/9-z))*(9/17) := by ring + _ = (17/9:ℂ)*(9/17) := by rw [div_mul_cancel₀ _ (sub_ne_zero.mpr hne.symm)] + _ = 1 := by norm_num + rw [hc,one_smul,kernelSpectralFormOperator_regularInverseLift z hz] + exact kernelThetaNull.starProjection_add_starProjection_orthogonal u + +lemma selfAdjoint_one_sub_smul_normal {H : Type*} [NormedAddCommGroup H] + [InnerProductSpace ℂ H] [CompleteSpace H] (S : H→L[ℂ]H) + (hS : IsSelfAdjoint S) (z : ℂ) : IsStarNormal (1-z•S) := by + let : IsStarNormal S := hS.isStarNormal + infer_instance + +lemma kernelSpectralFormOperator_normal (z : ℂ) : IsStarNormal (kernelSpectralFormOperator z) := by + exact selfAdjoint_one_sub_smul_normal kernelMassGram kernelMassGram_selfAdjoint (z+1) + +lemma kernelSpectralFormOperator_isUnit_near (z : ℂ) (hne : z≠8/9) + (hz : IsUnit (kernelRegularPencil z)) : IsUnit (kernelSpectralFormOperator z) := by + have hsur : Function.Surjective (kernelSpectralFormOperator z) := fun u => + ⟨kernelLocalEnergyResolvent z u,kernelLocalEnergyResolvent_right_inverse z hne hz u⟩ + apply (ContinuousLinearMap.isUnit_iff_bijective (𝕜 := ℂ) (E := KernelEnergyGraph)).mpr + refine ⟨?_,hsur⟩ + change Function.Injective (kernelSpectralFormOperator z).toLinearMap + apply LinearMap.ker_eq_bot.mp + rw [←ContinuousLinearMap.IsStarNormal.orthogonal_range (kernelSpectralFormOperator_normal z)] + have hr : (kernelSpectralFormOperator z).range=⊤ := LinearMap.range_eq_top.mpr hsur + rw [hr,Submodule.top_orthogonal_eq_bot] + +lemma kernelLocalEnergyResolvent_left_inverse (z : ℂ) (hne : z≠8/9) + (hz : IsUnit (kernelRegularPencil z)) (u : KernelEnergyGraph) : + kernelLocalEnergyResolvent z (kernelSpectralFormOperator z u)=u := by + have hinj := (ContinuousLinearMap.isUnit_iff_bijective (𝕜 := ℂ) (E := KernelEnergyGraph)).mp + (kernelSpectralFormOperator_isUnit_near z hne hz) + exact hinj.1 (kernelLocalEnergyResolvent_right_inverse z hne hz _) + +lemma kernelLocalEnergyResolvent_eq_inverse (z : ℂ) (hne : z≠8/9) + (hz : IsUnit (kernelRegularPencil z)) : + kernelLocalEnergyResolvent z = Ring.inverse (kernelSpectralFormOperator z) := by + apply ContinuousLinearMap.ext + intro u + apply ((ContinuousLinearMap.isUnit_iff_bijective (𝕜 := ℂ) (E := KernelEnergyGraph)).mp + (kernelSpectralFormOperator_isUnit_near z hne hz)).1 + rw [kernelLocalEnergyResolvent_right_inverse z hne hz] + have hi := congrArg (fun A : KernelEnergyGraph→L[ℂ]KernelEnergyGraph => A u) + (Ring.mul_inverse_cancel (kernelSpectralFormOperator z) (kernelSpectralFormOperator_isUnit_near z hne hz)) + exact hi.symm + +lemma kernelSpectralFormInverse_meromorphicAt : + MeromorphicAt (fun z : ℂ => Ring.inverse (kernelSpectralFormOperator z)) (8/9:ℂ) := by + apply kernelLocalEnergyResolvent_meromorphicAt.congr + filter_upwards [kernelRegularPencil_eventually_isUnit.filter_mono nhdsWithin_le_nhds, + self_mem_nhdsWithin] with z hz hne + exact kernelLocalEnergyResolvent_eq_inverse z hne hz + +end + +open scoped Topology + +lemma meromorphicAt_clm {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E] + [NormedAddCommGroup F] [NormedSpace ℂ F] (A : E→L[ℂ]F) {f : ℂ→E} {z : ℂ} + (hf : MeromorphicAt f z) : MeromorphicAt (fun w => A (f w)) z := by + obtain ⟨n,hn⟩ := hf + refine ⟨n,?_⟩ + have hh := (A.analyticAt ((z-z)^n•f z)).comp_of_eq hn rfl + simpa only [Function.comp_def,map_smul] using hh + +lemma meromorphicAt_bilinear {E F G : Type*} + [NormedAddCommGroup E] [NormedSpace ℂ E] + [NormedAddCommGroup F] [NormedSpace ℂ F] + [NormedAddCommGroup G] [NormedSpace ℂ G] + (B : E→L[ℂ]F→L[ℂ]G) {f : ℂ→E} {g : ℂ→F} {z : ℂ} + (hf : MeromorphicAt f z) (hg : MeromorphicAt g z) : + MeromorphicAt (fun w => B (f w) (g w)) z := by + obtain ⟨m,hm⟩ := hf + obtain ⟨n,hn⟩ := hg + refine ⟨m+n,?_⟩ + have hh := (B.analyticAt_bilinear (((z-z)^m•f z),((z-z)^n•g z))).comp₂ hm hn + simpa only [map_smul,_root_.smul_apply,smul_smul,pow_add,mul_comm] using hh + +lemma meromorphicAt_clm_apply {E F : Type*} + [NormedAddCommGroup E] [NormedSpace ℂ E] + [NormedAddCommGroup F] [NormedSpace ℂ F] + {A : ℂ→E→L[ℂ]F} {f : ℂ→E} {z : ℂ} + (hA : MeromorphicAt A z) (hf : MeromorphicAt f z) : + MeromorphicAt (fun w => A w (f w)) z := + meromorphicAt_bilinear (ContinuousLinearMap.apply ℂ F) hf hA + +lemma selfAdjoint_pencil_isUnit_nonreal {H : Type*} [NormedAddCommGroup H] + [InnerProductSpace ℂ H] [CompleteSpace H] (S : H→L[ℂ]H) + (hS : IsSelfAdjoint S) (z : ℂ) (hz : z.im≠0) : IsUnit (1-z•S) := by + have hne : z≠0 := fun h => hz (by rw [h]; rfl) + have hi : z⁻¹.im≠0 := by + rw [Complex.inv_im] + exact div_ne_zero (neg_ne_zero.mpr hz) (mt Complex.normSq_eq_zero.mp hne) + have hout : z⁻¹∉spectrum ℂ S := fun h => hi (hS.im_eq_zero_of_mem_spectrum h) + have hu := (spectrum.notMem_iff (R := ℂ) (A := H→L[ℂ]H)).mp hout + have hv := hu.smul (Units.mk0 z hne) + simpa only [Units.smul_def,Units.val_mk0,Algebra.algebraMap_eq_smul_one, + smul_sub,smul_smul,mul_inv_cancel₀ hne,one_smul] using hv + +lemma kernelSpectralFormOperator_isUnit_nonreal (z : ℂ) (hz : z.im≠0) : + IsUnit (kernelSpectralFormOperator z) := by + exact selfAdjoint_pencil_isUnit_nonreal kernelMassGram kernelMassGram_selfAdjoint (z+1) + (by simpa using hz) + +lemma kernelSpectralFormInverse_analyticAt_of_isUnit (z : ℂ) + (hz : IsUnit (kernelSpectralFormOperator z)) : + AnalyticAt ℂ (fun w => Ring.inverse (kernelSpectralFormOperator w)) z := by + have hi := (analyticOnNhd_inverse (𝕜 := ℂ) + (A := KernelEnergyGraph→L[ℂ]KernelEnergyGraph)) (kernelSpectralFormOperator z) hz + exact hi.comp_of_eq (kernelSpectralFormOperator_analyticAt z) rfl + +lemma kernelSpectralFormInverse_analyticAt_nonreal (z : ℂ) (hz : z.im≠0) : + AnalyticAt ℂ (fun w => Ring.inverse (kernelSpectralFormOperator w)) z := + kernelSpectralFormInverse_analyticAt_of_isUnit z (kernelSpectralFormOperator_isUnit_nonreal z hz) + +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace + +def kernelL2SandwichCLM : (KernelEnergyGraph→L[ℂ]KernelEnergyGraph)→L[ℂ] + (KernelQuotientL2→L[ℂ]KernelQuotientL2) := + continuousLinearSandwich kernelEnergyMass kernelEnergyMass.adjoint + +def kernelSpectralResolvent (z : ℂ) : KernelQuotientL2→L[ℂ]KernelQuotientL2 := + kernelL2SandwichCLM (Ring.inverse (kernelSpectralFormOperator z)) + +lemma kernelSpectralResolvent_apply (z : ℂ) (F : KernelQuotientL2) : + kernelSpectralResolvent z F= + kernelEnergyMass (Ring.inverse (kernelSpectralFormOperator z) (kernelVariationalSolution F)) := rfl + +private lemma meromorphicAt_operator_clm {H G : Type*} + [NormedAddCommGroup H] [NormedSpace ℂ H] + [NormedAddCommGroup G] [NormedSpace ℂ G] + (A : (H →L[ℂ] H) →L[ℂ] (G →L[ℂ] G)) + {f : ℂ → (H →L[ℂ] H)} {z : ℂ} (hf : MeromorphicAt f z) : + MeromorphicAt (fun w => A (f w)) z := + meromorphicAt_clm A hf + +lemma kernelSpectralResolvent_meromorphicAt : + MeromorphicAt kernelSpectralResolvent (8/9:ℂ) := by + exact meromorphicAt_operator_clm + (H := KernelEnergyGraph) (G := KernelQuotientL2) + (f := fun z : ℂ => Ring.inverse (kernelSpectralFormOperator z)) + kernelL2SandwichCLM kernelSpectralFormInverse_meromorphicAt + +lemma kernelSpectralResolvent_analyticAt_nonreal (z : ℂ) (hz : z.im≠0) : + AnalyticAt ℂ kernelSpectralResolvent z := by + exact (ContinuousLinearMap.analyticAt (𝕜 := ℂ) + (E := KernelEnergyGraph→L[ℂ]KernelEnergyGraph) + (F := KernelQuotientL2→L[ℂ]KernelQuotientL2) kernelL2SandwichCLM + (Ring.inverse (kernelSpectralFormOperator z))).comp_of_eq + (kernelSpectralFormInverse_analyticAt_nonreal z hz) rfl + +lemma kernelSpectralResolvent_graph (z : ℂ) (hz : IsUnit (kernelSpectralFormOperator z)) + (F : KernelQuotientL2) : + (kernelSpectralResolvent z F,F+z•kernelSpectralResolvent z F)∈kernelEnergyLaplacian.graph := by + apply kernelSpectralFormOperator_solution_graph z F + have hi := congrArg (fun A : KernelEnergyGraph→L[ℂ]KernelEnergyGraph => + A (kernelVariationalSolution F)) (Ring.mul_inverse_cancel (kernelSpectralFormOperator z) hz) + exact hi + +lemma kernelSpectralResolvent_left_inverse (z : ℂ) (hz : IsUnit (kernelSpectralFormOperator z)) + (u : kernelEnergyLaplacian.domain) : + kernelSpectralResolvent z (kernelEnergyLaplacian u-z•(u:KernelQuotientL2))=u := by + rw [kernelSpectralResolvent_apply,←kernelSpectralFormOperator_of_domain z u] + have hi := congrArg (fun A : KernelEnergyGraph→L[ℂ]KernelEnergyGraph => + A (kernelVariationalSolution (kernelEnergyLaplacian u+u))) + (Ring.inverse_mul_cancel (kernelSpectralFormOperator z) hz) + change Ring.inverse (kernelSpectralFormOperator z) + (kernelSpectralFormOperator z (kernelVariationalSolution (kernelEnergyLaplacian u+u)))= + kernelVariationalSolution (kernelEnergyLaplacian u+u) at hi + rw [hi] + exact kernelEnergyLaplacian_resolvent_relation u + +lemma kernelSpectralResolvent_unique (z : ℂ) (hz : IsUnit (kernelSpectralFormOperator z)) + (u F : KernelQuotientL2) (hu : (u,F+z•u)∈kernelEnergyLaplacian.graph) : + kernelSpectralResolvent z F=u := by + let v : kernelEnergyLaplacian.domain := ⟨u,LinearPMap.mem_domain_of_mem_graph hu⟩ + have hv : kernelEnergyLaplacian v=F+z•u := + kernelEnergyLaplacian.mem_graph_snd_inj (kernelEnergyLaplacian.mem_graph v) hu rfl + have hh := kernelSpectralResolvent_left_inverse z hz v + rw [hv] at hh + simpa only [v,add_sub_cancel_right] using hh + +def kernelEisensteinSpectralParameter (s : ℂ) : ℂ := s*(2-s) + +def kernelEisensteinResolvent (s : ℂ) : KernelQuotientL2→L[ℂ]KernelQuotientL2 := + kernelSpectralResolvent (kernelEisensteinSpectralParameter s) + +lemma kernelEisensteinSpectralParameter_center : + kernelEisensteinSpectralParameter (4/3)=8/9 := by + norm_num [kernelEisensteinSpectralParameter] + +lemma kernelEisensteinResolvent_meromorphicAt : + MeromorphicAt kernelEisensteinResolvent (4/3:ℂ) := by + have hh : MeromorphicAt kernelSpectralResolvent (kernelEisensteinSpectralParameter (4/3)) := by + rw [kernelEisensteinSpectralParameter_center] + exact kernelSpectralResolvent_meromorphicAt + exact hh.comp_analyticAt (by unfold kernelEisensteinSpectralParameter; fun_prop) + +lemma kernelEisensteinSpectralParameter_nonreal (s : ℂ) (hs : s.re≠1) (hi : s.im≠0) : + (kernelEisensteinSpectralParameter s).im≠0 := by + have he : (kernelEisensteinSpectralParameter s).im=2*(1-s.re)*s.im := by + simp only [kernelEisensteinSpectralParameter,Complex.mul_im,Complex.sub_re,Complex.sub_im] + norm_num + ring + rw [he] + exact mul_ne_zero (mul_ne_zero (by norm_num) (sub_ne_zero.mpr hs.symm)) hi + +lemma kernelEisensteinResolvent_analyticAt_nonreal (s : ℂ) (hs : s.re≠1) (hi : s.im≠0) : + AnalyticAt ℂ kernelEisensteinResolvent s := by + exact (kernelSpectralResolvent_analyticAt_nonreal _ + (kernelEisensteinSpectralParameter_nonreal s hs hi)).comp_of_eq + (by unfold kernelEisensteinSpectralParameter; fun_prop) rfl + +lemma kernelEisensteinResolvent_forcing_meromorphicAt + (F : ℂ→KernelQuotientL2) (hF : MeromorphicAt F (4/3:ℂ)) : + MeromorphicAt (fun s => kernelEisensteinResolvent s (F s)) (4/3:ℂ) := + meromorphicAt_clm_apply kernelEisensteinResolvent_meromorphicAt hF + +lemma kernelEisensteinPencil_eventually_isUnit : + ∀ᶠ s : ℂ in 𝓝[≠] (4/3:ℂ), IsUnit (kernelSpectralFormOperator (kernelEisensteinSpectralParameter s)) := by + have hc : ContinuousAt kernelEisensteinSpectralParameter (4/3:ℂ) := by + unfold kernelEisensteinSpectralParameter + fun_prop + have hp : ∀ᶠ s : ℂ in 𝓝 (4/3:ℂ), IsUnit (kernelRegularPencil (kernelEisensteinSpectralParameter s)) := by + have hh : ∀ᶠ z : ℂ in 𝓝 (kernelEisensteinSpectralParameter (4/3)), IsUnit (kernelRegularPencil z) := by + rw [kernelEisensteinSpectralParameter_center] + exact kernelRegularPencil_eventually_isUnit + exact hc.eventually hh + filter_upwards [hp.filter_mono nhdsWithin_le_nhds, + eventually_ne_nhdsWithin (show (4/3:ℂ)≠2/3 by norm_num),self_mem_nhdsWithin] with s hs htwo hfour + apply kernelSpectralFormOperator_isUnit_near _ _ hs + intro he + have hzero : (s-4/3)*(s-2/3)=0 := by + have hid : (s-4/3)*(s-2/3)=(8/9:ℂ)-kernelEisensteinSpectralParameter s := by + unfold kernelEisensteinSpectralParameter + ring + rw [hid,he,sub_self] + rcases mul_eq_zero.mp hzero with h | h + · exact hfour (sub_eq_zero.mp h) + · exact htwo (sub_eq_zero.mp h) + +def kernelEisensteinL2Correction (a b : ℝ) (ha : 0 kernelRegularL2Resolvent (kernelEisensteinSpectralParameter s)) (4/3:ℂ) := by + have hreg : AnalyticAt ℂ kernelRegularL2Resolvent (kernelEisensteinSpectralParameter (4/3)) := by + rw [kernelEisensteinSpectralParameter_center] + exact kernelRegularL2Resolvent_analyticAt + exact hreg.comp_of_eq (by unfold kernelEisensteinSpectralParameter; fun_prop) rfl + have happ := ((ContinuousLinearMap.apply ℂ KernelQuotientL2).analyticAt_bilinear + (kernelL2Defect a b ha hab (4/3),kernelRegularL2Resolvent (kernelEisensteinSpectralParameter (4/3)))).comp₂ hf hr + have hscalar : AnalyticAt ℂ (fun s : ℂ => (17/9)/(s-2/3)) (4/3:ℂ) := by + apply AnalyticAt.div analyticAt_const (analyticAt_id.sub analyticAt_const) + norm_num + exact (hscalar.smul hp).add ((analyticAt_id.sub analyticAt_const).smul happ) + +lemma kernelEisensteinCorrectionNumerator_eventually (a b : ℝ) (ha : 0 (s-4/3)•kernelEisensteinL2Correction a b ha hab s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (kernelEisensteinResidueVector a b ha hab)) := by + apply (tendsto_congr' (kernelEisensteinCorrectionNumerator_eventually a b ha hab)).mpr + rw [←kernelEisensteinCorrectionNumerator_center a b ha hab] + exact (kernelEisensteinCorrectionNumerator_analyticAt a b ha hab).continuousAt.tendsto.mono_left + nhdsWithin_le_nhds + +instance kernelThetaMassProjection_range_finiteDimensional : + FiniteDimensional ℂ kernelThetaMassProjection.range := by + let B : kernelThetaNull→L[ℂ]KernelQuotientL2 := kernelEnergyMass.comp kernelThetaNull.subtypeL + have : FiniteDimensional ℂ B.range := LinearMap.finiteDimensional_range B.toLinearMap + apply Submodule.finiteDimensional_of_le (S₂ := B.range) + rintro y ⟨x,rfl⟩ + exact ⟨kernelThetaNull.orthogonalProjectionOnto (kernelEnergyMass.adjoint x),rfl⟩ + +lemma kernelEisensteinResidueVector_graph (a b : ℝ) (ha : 0 ActualEisensteinCubic.O + +abbrev PrimaryLower:={c:Eis//(3:Eis)∣c-1} +abbrev OppositeData:=Σc:PrimaryLower,{x:Eis//IsCoprime c.val x} + +lemma primaryLower_primary (c:PrimaryLower):lambda^2∣c.val-1:=lambda_sq_dvd_three.trans c.2 +lemma primaryLower_ne_zero (c:PrimaryLower):c.val≠0:=primary_ne_zero c.val (primaryLower_primary c) + +def oppositeDataToPrimitive (p:OppositeData):PrimitiveRow:= + ⟨![-3*p.2.val,p.1.val],by + change IsCoprime (-3*p.2.val) p.1.val ∧ (3:Eis)∣-3*p.2.val ∧ (3:Eis)∣p.1.val-1 + refine ⟨?_,⟨-p.2.val,by ring⟩,p.1.2⟩ + simpa only [neg_mul] using + ((primary_coprime_three p.1.val (primaryLower_primary p.1)).mul_right p.2.2).symm.neg_left⟩ + +lemma oppositeDataToPrimitive_bijective:Function.Bijective oppositeDataToPrimitive:=by + constructor + · rintro ⟨c,x,hx⟩ ⟨d,y,hy⟩ h + have hrow:=congrArg Subtype.val h + have hcd:c=d:=by + apply Subtype.ext + exact congrFun hrow 1 + subst d + have hxy:x=y:=by + have he:-(3:Eis)*x=-(3:Eis)*y:=congrFun hrow 0 + exact mul_left_cancel₀ (by norm_num : -(3:Eis)≠0) he + subst y + rfl + · intro r + obtain ⟨t,ht⟩:=r.2.2.1 + let c:PrimaryLower:=⟨r.1 1,r.2.2.2⟩ + have hx:IsCoprime c.val (-t):=by + have hh:IsCoprime c.val (3*t):=by simpa only [c,ht] using r.2.1.symm + exact (hh.of_isCoprime_of_dvd_right (dvd_mul_left t 3)).neg_right + refine ⟨⟨c,-t,hx⟩,Subtype.ext ?_⟩ + funext i + fin_cases i + · change -3*(-t)=r.1 0 + rw [ht] + ring + · rfl + +def oppositeDataEquiv:OppositeData≃PrimitiveRow:= + Equiv.ofBijective oppositeDataToPrimitive oppositeDataToPrimitive_bijective + +def oppositeMatrix:SL(2,ℂ):=⟨!![0,-1;1,0],by simp [Matrix.det_fin_two]⟩ + +lemma rowOperator_opposite (v:Fin 2→ℂ):rowOperator oppositeMatrix v=![v 1,-v 0]:=by + rw [rowOperator_apply] + funext i + fin_cases i <;> simp [oppositeMatrix,Matrix.vecMul,dotProduct,Fin.sum_univ_two] + +def oppositeEisenstein (z:ℂ) (v:ℝ) (hv:0 + simp [oppositeDataEquiv, Equiv.ofBijective_apply, oppositeDataToPrimitive, r, map_mul] + have hr0:r≠0:=by + intro hh + have he:=congrFun hh 0 + exact eisEmbedding_ne_zero (primaryLower_ne_zero p.1) he + have hp:0‖oppositeTerm z v s p.1.val p.2.val‖):=by + have hh:=(oppositeDataEquiv.trans primitiveRowEquiv.symm).summable_iff.mpr + (summable_norm_summand (oppositeMatrix*upperSection z v hv) s hs) + exact hh.congr (fun p=>congrArg norm (opposite_summand z v hv s p)) + +def primaryLowerIdealEquiv:PrimaryLower≃GoodIdeal where + toFun c:=⟨Ideal.span {c.val},by rw [primaryGenerator_span c.val (primaryLower_ne_zero c) (primaryLower_primary c)];exact primaryLower_ne_zero c⟩ + invFun I:=⟨primaryGenerator I.val,three_dvd_primary_sub_one _ (primaryGenerator_spec I.val I.2).2⟩ + left_inv c:=Subtype.ext (primaryGenerator_span c.val (primaryLower_ne_zero c) (primaryLower_primary c)) + right_inv I:=Subtype.ext (primaryGenerator_spec I.val I.2).1 + +end + +section + +open scoped BigOperators Classical +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal) +local notation "Eis" => ActualEisensteinCubic.O + +abbrev CoprimeElement (c:Eis):={x:Eis//IsCoprime c x} + +def cubicResidueElementMap (c:Eis) (p:CubicUnitResidue c×Eis):CoprimeElement c:= + ⟨GaussianShiftedPartition.representative c p.1.val+c*p.2,by + apply (isUnit_quotient_span_iff c _).mp + have hc:Ideal.Quotient.mk (Ideal.span {c}) c=0:= + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp)) + simpa only [map_add,map_mul,hc,zero_mul,add_zero, + GaussianShiftedPartition.representative_spec] using p.1.2⟩ + +lemma cubicResidueElementMap_bijective (c:Eis) (hc:c≠0): + Function.Bijective (cubicResidueElementMap c):=by + have hmod (r:CubicUnitResidue c) (n:Eis): + Ideal.Quotient.mk (Ideal.span {c}) + (GaussianShiftedPartition.representative c r.val+c*n)=r.val:=by + have hzero:Ideal.Quotient.mk (Ideal.span {c}) c=0:= + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.subset_span (by simp)) + rw [map_add,map_mul,hzero,zero_mul,add_zero,GaussianShiftedPartition.representative_spec] + constructor + · rintro ⟨r,n⟩ ⟨t,m⟩ h + have he:=congrArg Subtype.val h + change GaussianShiftedPartition.representative c r.val+c*n= + GaussianShiftedPartition.representative c t.val+c*m at he + have hrt:r=t:=Subtype.ext (by + simpa only [hmod] using congrArg (Ideal.Quotient.mk (Ideal.span {c})) he) + subst t + have hnm:n=m:=mul_left_cancel₀ hc (add_left_cancel he) + subst m + rfl + · intro x + let r:CubicUnitResidue c:=⟨Ideal.Quotient.mk (Ideal.span {c}) x.val, + (isUnit_quotient_span_iff c x.val).mpr x.2⟩ + have hdiv:c∣x.val-GaussianShiftedPartition.representative c r.val:=by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + exact (GaussianShiftedPartition.representative_spec c r.val).symm + obtain ⟨n,hn⟩:=hdiv + refine ⟨(r,n),Subtype.ext ?_⟩ + change GaussianShiftedPartition.representative c r.val+c*n=x.val + linear_combination -hn + +def cubicResidueElementEquiv (c:Eis) (hc:c≠0): + CubicUnitResidue c×Eis≃CoprimeElement c:= + Equiv.ofBijective (cubicResidueElementMap c) (cubicResidueElementMap_bijective c hc) + +lemma oppositeTerm_shift (z:ℂ) (v:ℝ) (s:ℂ) (c x n:Eis): + oppositeTerm z v s c (x+c*n)=oppositeTerm (z+3*eisEmbedding n) v s c x:=by + have hsym:symbol (3*(x+c*n)) c=symbol (3*x) c:=symbol_congr ⟨3*n,by ring⟩ + have harg:eisEmbedding c*z+eisEmbedding (3*(x+c*n))= + eisEmbedding c*(z+3*eisEmbedding n)+eisEmbedding (3*x):=by + simp only [map_mul,map_add,map_ofNat] + ring + rw [oppositeTerm,oppositeTerm,hsym,harg] + +def oppositeGaussSum (h c:Eis):ℂ:= + ∑'r:CubicUnitResidue c, + eisEmbedding (symbol (3*GaussianShiftedPartition.representative c r.val) c)* + residueAdditive h c (3*GaussianShiftedPartition.representative c r.val) + +theorem oppositeGaussSum_eq (h:Eis) (c:PrimaryLower): + oppositeGaussSum h c.val=cubicUnitGaussSum (9*h) c.val:=by + have hp:=primaryLower_primary c + have hc:=primaryLower_ne_zero c + have he:oppositeGaussSum h c.val= + eisEmbedding (symbol 3 c.val)*cubicUnitGaussSum h c.val:=by + rw [oppositeGaussSum,cubicUnitGaussSum,←tsum_mul_left] + apply tsum_congr + intro r + rw [symbol_mul_numerator _ _ _ hp,map_mul] + have hadd:residueAdditive h c.val (3*GaussianShiftedPartition.representative c.val r.val)= + residueAdditive (3*h) c.val (GaussianShiftedPartition.representative c.val r.val):=by + unfold residueAdditive cuspFrequency + simp only [map_mul,map_ofNat] + congr 1 + ring + rw [hadd] + ring + rw [he] + have hs:=cubicUnitGaussSum_phase_shift h 1 c.val hc hp (by + simpa only [mul_one] using (primary_coprime_three c.val hp).symm) + simpa only [symbol_one_numerator c.val hp,map_one,one_mul,mul_one,mul_comm h 9] using hs + +def oppositeArithmeticSeries (s:ℂ) (h:Eis):ℂ:= + ∑'c:PrimaryLower,((‖eisEmbedding c.val‖^2:ℝ):ℂ)^(-s)*oppositeGaussSum h c.val + +theorem oppositeArithmeticSeries_eq (s:ℂ) (h:Eis): + oppositeArithmeticSeries s h=unramifiedCubicGaussSeries s (9*h):=by + rw [oppositeArithmeticSeries,←primaryLowerIdealEquiv.symm.tsum_eq,unramifiedCubicGaussSeries] + apply tsum_congr + intro I + rw [oppositeGaussSum_eq] + change ((‖eisEmbedding (primaryGenerator I.val)‖^2:ℝ):ℂ)^(-s)* + cubicUnitGaussSum (9*h) (primaryGenerator I.val)=_ + rw [eisEmbedding_norm_sq_eq_absNorm_span,(primaryGenerator_spec I.val I.2).1, + Complex.ofReal_natCast] + +end + +section + +open MeasureTheory Set Filter Module +open scoped BigOperators Classical ENNReal MatrixGroups Matrix +open ActualEisensteinCubic ConcreteTraceCRT + +lemma continuous_inverse_fixed_left_operator (a:SL(2,ℂ)) (v:ℝ) (hv:0rowOperator (a*upperSection z v hv)⁻¹):=by + have he (z:ℂ):rowOperator (a*upperSection z v hv)⁻¹= + (rowOperator a⁻¹).comp (rowOperator (upperSection z v hv)⁻¹):=by + ext u + simp only [mul_inv_rev,ContinuousLinearMap.comp_apply,rowOperator_mul] + simp_rw [he] + exact continuous_const.clm_comp (continuous_inverse_upper_operator v hv) + +lemma exists_fixed_left_rowBound (a:SL(2,ℂ)) (v:ℝ) (hv:0rowBound (a*upperSection z v hv)):= + continuous_const.mul (continuous_const.add (continuous_inverse_fixed_left_operator a v hv).norm) + let R:ℝ:=∑i:Fin 2,‖periodBasis i‖ + obtain ⟨C,hC⟩:=(isCompact_closedBall (0:ℂ) R).bddAbove_image hc.continuousOn + refine ⟨max 1 C,lt_of_lt_of_le (by norm_num) (le_max_left _ _),?_⟩ + intro z hz + apply (hC ?_).trans (le_max_right _ _) + exact ⟨z,by simpa only [Metric.mem_closedBall,dist_zero_right] using norm_mem_periodDomain z hz,rfl⟩ + +lemma continuous_fixed_left_summand (a:SL(2,ℂ)) (v:ℝ) (hv:0summand (a*upperSection z v hv) s x):=by + simp_rw [summand,←rowOperator_mul,rowEnergy_upperSection] + apply continuous_const.mul + apply Continuous.cpow + · apply Complex.continuous_ofReal.comp + unfold heightDenominator + fun_prop + · exact continuous_const + · intro z + apply Complex.ofReal_mem_slitPlane.mpr + exact div_pos (heightDenominator_pos z v hv _ + (rowOperator_ne_zero a _ (embeddedRow_ne_zero x))) hv + +lemma fixed_left_summable_majorant (a:SL(2,ℂ)) (v:ℝ) (hv:0C^(2*s.re)*‖rowCoordinates (cosetRow x)‖^(-(2*s.re)),?_,?_,?_⟩ + · have hsumm:=summable_integer_four_rpow (2*s.re) (by linarith) + have hinj:Function.Injective (fun x:CuspCosets=>rowCoordinates (cosetRow x)):= + rowCoordinates_injective.comp cosetRow_injective + exact (hsumm.comp_injective hinj).mul_left _ + · intro x + positivity + · intro z hz x + apply (norm_summand_bound (a*upperSection z v hv) s (by linarith) x).trans + exact mul_le_mul_of_nonneg_right + (Real.rpow_le_rpow (rowBound_pos _).le (hbound z hz) (by linarith)) (by positivity) + +theorem hasSum_integral_fixed_left_Eisenstein (a:SL(2,ℂ)) (v:ℝ) (hv:0∫z in periodDomain, + summand (a*upperSection z v hv) s x*ShortDraftTrace.breveE (-freq*z)) + (∫z in periodDomain,eisenstein (a*upperSection z v hv) s*ShortDraftTrace.breveE (-freq*z)):=by + let:Countable CuspCosets:=(rowCoordinates_injective.comp cosetRow_injective).countable + let:=periodDomain_finiteMeasure + obtain ⟨M,hM,hMnonneg,hbound⟩:=fixed_left_summable_majorant a v hv s hs + have hchar:Continuous (fun z:ℂ=>ShortDraftTrace.breveE (-freq*z)):=by + change Continuous (fun z:ℂ=>Complex.exp (2*Real.pi*Complex.I*((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + exact hasSum_integral_of_dominated_convergence + («μ»:=volume.restrict periodDomain) + (fun (x:CuspCosets) (_:ℂ)=>M x) + (fun x=>((continuous_fixed_left_summand a v hv s x).mul hchar).aestronglyMeasurable.restrict) + (fun x=>(ae_restrict_mem periodDomain_measurable).mono fun z hz=>by + simpa only [Pi.mul_apply,norm_mul,breveE_norm,mul_one] using hbound z hz x) + (Eventually.of_forall fun _=>hM) + (integrable_const (∑'x,M x)) + (Eventually.of_forall fun z=>(summable_summand (a*upperSection z v hv) s hs).hasSum.mul_right + (ShortDraftTrace.breveE (-freq*z))) + +end + +section + +open MeasureTheory Set Filter +open scoped BigOperators Classical ENNReal +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def oppositeIntegral (v:ℝ) (s freq:ℂ) (c x:Eis):ℂ:= + ∫z in periodDomain,oppositeTerm z v s c x*ShortDraftTrace.breveE (-freq*z) + +theorem hasSum_oppositeIntegrals (v:ℝ) (hv:0oppositeIntegral v s freq p.1.val p.2.val) + (∫z in periodDomain,oppositeEisenstein z v hv s*ShortDraftTrace.breveE (-freq*z)):=by + have hh:=(oppositeDataEquiv.trans primitiveRowEquiv.symm).hasSum_iff.mpr + (hasSum_integral_fixed_left_Eisenstein oppositeMatrix v hv s freq hs) + apply hh.congr_fun + intro p + apply integral_congr_ae + exact Eventually.of_forall fun z=>by + dsimp only [Equiv.trans_apply] + rw [opposite_summand] + +lemma oppositeTerm_integrable (v:ℝ) (hv:0oppositeTerm z v s c x):=by + simp_rw [oppositeTerm_eq_shifted _ v hv s c x hc] + exact (shiftedHeightKernel_integrable v hv s _ hs).const_mul _ + +lemma oppositeIntegral_sum_translate (v:ℝ) (hv:0oppositeTerm z v s c x) + (oppositeTerm_integrable v hv s hs c x hc) (cuspFrequency h) + rw [integral_eq_period_integrals _ hint] + apply tsum_congr + intro n + apply integral_congr_ae + exact Eventually.of_forall fun z=>by + dsimp only [oppositeIntegral] + rw [oppositeTerm_shift,cuspFrequency_negative_period] + +lemma oppositeTerm_fourier_integral (v:ℝ) (hv:0oppositeIntegral v s (cuspFrequency h) c.val x.val):= + (hasSum_oppositeIntegrals v hv s (cuspFrequency h) hs).summable.sigma_factor c + have hsum:=(cubicResidueElementEquiv c.val (primaryLower_ne_zero c)).summable_iff.mpr hf + change Summable (fun q:CubicUnitResidue c.val×Eis=> + oppositeIntegral v s (cuspFrequency h) c.val + (GaussianShiftedPartition.representative c.val q.1.val+c.val*q.2)) at hsum + rw [←(cubicResidueElementEquiv c.val (primaryLower_ne_zero c)).tsum_eq] + change (∑'q:CubicUnitResidue c.val×Eis, + oppositeIntegral v s (cuspFrequency h) c.val + (GaussianShiftedPartition.representative c.val q.1.val+c.val*q.2))=_ + rw [hsum.tsum_prod] + change (∑'r:CubicUnitResidue c.val,∑'n:Eis, + oppositeIntegral v s (cuspFrequency h) c.val + (GaussianShiftedPartition.representative c.val r.val+c.val*n))=_ + simp_rw [oppositeIntegral_sum_translate v hv s (by linarith) h c.val _ (primaryLower_ne_zero c), + oppositeTerm_fourier_integral v hv s (cuspFrequency h) c.val _ (primaryLower_ne_zero c)] + exact tsum_mul_left + +lemma unramifiedCubicGaussSeries_twentySeven (s:ℂ) (h:Eis): + unramifiedCubicGaussSeries s (27*h)=unramifiedCubicGaussSeries s h:=by + apply tsum_congr + intro I + congr 1 + have hp:lambda^2∣primaryGenerator I.val-1:=(primaryGenerator_spec I.val I.2).2 + simpa only [show (3:Eis)^3=27 by norm_num,mul_comm h 27] using + cubicUnitGaussSum_cube_shift h (primaryGenerator I.val) 3 I.2 hp + (primary_coprime_three _ hp) + +theorem oppositeEisenstein_fourier (v:ℝ) (hv:0 measurableSet_Ioc) + +lemma periodIocCube_ae : periodCube=ᵐ[volume]periodIocCube := by + simpa only [periodIocCube,zero_add] using periodCube_ae_Ioc + +def periodSection (t : UnitAddTorus (Fin 2)) : ℂ := + periodVector ((UnitAddTorus.measurableEquivPiIoc (fun _ : Fin 2 => (0:ℝ)) t).val) + +lemma periodSection_measurableEmbedding : MeasurableEmbedding periodSection := + periodVector.toHomeomorph.toMeasurableEquiv.measurableEmbedding.comp + ((MeasurableEmbedding.subtype_coe periodIocCube_measurable).comp + (UnitAddTorus.measurableEquivPiIoc (fun _ : Fin 2 => (0:ℝ))).measurableEmbedding) + +lemma periodTorus_measurable : Measurable periodTorus := by + apply Measurable.of_eval + intro i + exact AddCircle.measurable_mk'.comp + ((measurable_pi_apply i).comp periodBasis.equivFunL.continuous.measurable) + +lemma periodTorus_section (t : UnitAddTorus (Fin 2)) : periodTorus (periodSection t)=t := by + rw [periodSection,periodTorus_periodVector] + exact (UnitAddTorus.measurableEquivPiIoc (fun _ : Fin 2 => (0:ℝ))).symm_apply_apply t + +lemma periodVector_Ioc_measurePreserving : + MeasurePreserving periodVector (volume.restrict periodIocCube) + (periodCovolumeDensity • volume.restrict periodDomain) := by + refine ⟨periodVector.continuous.measurable,?_⟩ + rw [←Measure.restrict_congr_set periodIocCube_ae,←periodVector_preimage_domain, + ←Measure.restrict_map periodVector.continuous.measurable periodDomain_measurable, + periodVector_map_volume,Measure.restrict_smul] + rfl + +lemma periodSection_measurePreserving : + MeasurePreserving periodSection volume + (periodCovolumeDensity • volume.restrict periodDomain) := + periodVector_Ioc_measurePreserving.comp + ((measurePreserving_subtype_coe periodIocCube_measurable).comp + (UnitAddTorus.measurePreserving_equivPiIoc (fun _ : Fin 2 => (0:ℝ)))) + +lemma periodTorus_measurePreserving : + MeasurePreserving periodTorus (periodCovolumeDensity • volume.restrict periodDomain) volume := by + refine ⟨periodTorus_measurable,?_⟩ + rw [←periodSection_measurePreserving.map_eq, + Measure.map_map periodTorus_measurable periodSection_measurableEmbedding.measurable] + have he : periodTorus ∘ periodSection=id := funext periodTorus_section + rw [he,Measure.map_id] + +lemma periodSection_torus_ae : + (fun z => periodSection (periodTorus z))=ᵐ[volume.restrict periodDomain] (fun z : ℂ => z) := by + apply (Measure.ae_ennreal_smul_measure_iff periodCovolumeDensity_ne_zero).mp + rw [←periodSection_measurePreserving.map_eq] + apply periodSection_measurableEmbedding.ae_map_iff.mpr + exact Eventually.of_forall (fun t => by dsimp only; rw [periodTorus_section]) + +lemma periodSection_memLp (f : ℂ→ℂ) (hf : MemLp f 2 (volume.restrict periodDomain)) : + MemLp (f ∘ periodSection) 2 volume := + (hf.smul_measure (by simp [periodCovolumeDensity])).comp_measurePreserving + periodSection_measurePreserving + +def periodTorusL2Lift (f : ℂ→ℂ) (hf : MemLp f 2 (volume.restrict periodDomain)) : PeriodTorusL2 := + (periodSection_memLp f hf).toLp (f ∘ periodSection) + +lemma periodTorusL2Lift_ae (f : ℂ→ℂ) (hf : MemLp f 2 (volume.restrict periodDomain)) : + periodTorusL2Lift f hf=ᵐ[volume]f ∘ periodSection := + MemLp.coeFn_toLp (periodSection_memLp f hf) + +lemma periodTorusL2Lift_pullback (f : ℂ→ℂ) (hf : MemLp f 2 (volume.restrict periodDomain)) : + (fun z => periodTorusL2Lift f hf (periodTorus z))=ᵐ[volume.restrict periodDomain]f := by + have he := periodTorus_measurePreserving.quasiMeasurePreserving.ae_eq_comp (periodTorusL2Lift_ae f hf) + have he' := (Measure.ae_ennreal_smul_measure_iff periodCovolumeDensity_ne_zero).mp he + filter_upwards [he',periodSection_torus_ae] with z hz hsec + change periodTorusL2Lift f hf (periodTorus z)=f (periodSection (periodTorus z)) at hz + rw [hsec] at hz + exact hz + +lemma periodTorusL2Lift_frequency_integral (f : ℂ→ℂ) + (hf : MemLp f 2 (volume.restrict periodDomain)) (h : ActualEisensteinCubic.O) : + (∫z in periodDomain,periodTorusL2Lift f hf (periodTorus z)* + ShortDraftTrace.breveE (-cuspFrequency h*z))= + ∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency h*z) := by + apply integral_congr_ae + filter_upwards [periodTorusL2Lift_pullback f hf] with z hz + rw [hz] + +lemma periodTorusL2Lift_fourierCoeff (f : ℂ→ℂ) (hf : MemLp f 2 (volume.restrict periodDomain)) + (n : Fin 2→ℤ) : + UnitAddTorus.mFourierCoeff (periodTorusL2Lift f hf) n=(2/(9*Real.sqrt 3):ℝ) • + (∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency (periodFrequencyEquiv n)*z)) := by + rw [periodTorus_fourierCoeff] + congr 1 + apply integral_congr_ae + filter_upwards [periodTorusL2Lift_pullback f hf] with z hz + rw [hz] + +theorem periodDomain_L2_ext (f g : ℂ→ℂ) + (hf : MemLp f 2 (volume.restrict periodDomain)) + (hg : MemLp g 2 (volume.restrict periodDomain)) + (h : ∀h : ActualEisensteinCubic.O, + (∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency h*z))= + ∫z in periodDomain,g z*ShortDraftTrace.breveE (-cuspFrequency h*z)) : + f=ᵐ[volume.restrict periodDomain]g := by + have he : periodTorusL2Lift f hf=periodTorusL2Lift g hg := by + apply periodTorus_L2_ext + intro hfreq + rw [periodTorusL2Lift_frequency_integral,periodTorusL2Lift_frequency_integral,h] + filter_upwards [periodTorusL2Lift_pullback f hf,periodTorusL2Lift_pullback g hg] with z hz hz' + rw [←hz,←hz',he] + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimeGaussFactors.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimeGaussFactors.lean new file mode 100644 index 0000000000000000000000000000000000000000..c89ffbcd262837931e0edb4e2bff1f6e1f12b75e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimeGaussFactors.lean @@ -0,0 +1,653 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.PrimeRecurrence + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +lemma unramifiedCubicGaussSeries_prime_two_power (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (s:ℂ) (hs:21+(Ideal.absNorm (Ideal.span {p}):ℂ)^3* + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^3 + have hA (s:ℂ):AnalyticAt ℂ A s:=analyticAt_const.add + (analyticAt_const.mul ((gaussPrimeWeight_analytic p hp s).pow 3)) + have he:=unramifiedGaussResidue_of_initial_relation (h*p^5) (h*p^2) 0 A (fun _=>0) + (fun s _=>hA s) (fun _ _=>analyticAt_const) (hA _).continuousAt continuousAt_const + (fun s hs _=>by simpa only [A,zero_mul,add_zero] using + unramifiedCubicGaussSeries_square_cube p hp hprimary s (by linarith) h hph) + dsimp only [A] at he + rw [gaussPrimeWeight_center p hp] at he + simpa only [zero_mul,add_zero] using he + +lemma principalResidueTerm_square_cube (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (u:Eisˣ) (n:ℕ) : + principalResidueTerm (h*p^5) u n= + (1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*principalResidueTerm (h*p^2) u n := by + let c:=u.val*lambda^(n+2) + have hA:=arithmeticResidueSum_frequency_cube (h*p^2) c p + (ramifiedElement_ne_zero u (n+2)) (ramifiedElement_level u (n+2) (by omega)) hprimary + (ramified_primary_coprime u (n+2) p hprimary).of_mul_left_right + have hfreq:¬p∣h*(9*c):=ramified_prime_frequency_not_dvd h p hp hprimary hph u (n+2) + rw [show (h*p^2)*p^3=h*p^5 by ring] at hA + change _*arithmeticResidueSum (h*p^5) c*unramifiedGaussResidue ((h*p^5)*(9*c))=_ + rw [hA,show (h*p^5)*(9*c)=(h*(9*c))*p^5 by ring, + unramifiedGaussResidue_square_cube p hp hprimary (h*(9*c)) hfreq] + change _=(1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)* + (((3^(n+2):ℕ):ℂ)^(-(4/3:ℂ))*arithmeticResidueSum (h*p^2) c* + unramifiedGaussResidue ((h*p^2)*(9*c))) + rw [show (h*p^2)*(9*c)=(h*(9*c))*p^2 by ring] + ring + +lemma principalArithmeticResidue_square_cube (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + principalArithmeticResidue (h*p^5)= + (1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*principalArithmeticResidue (h*p^2) := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + let N:=max (ramifiedFrequencyBound (h*p^5)+1) (ramifiedFrequencyBound (h*p^2)+1) + rw [principalArithmeticResidue_eq_sum (h*p^5) (mul_ne_zero hh (pow_ne_zero _ hp.ne_zero)) N (le_max_left _ _), + principalArithmeticResidue_eq_sum (h*p^2) (mul_ne_zero hh (pow_ne_zero _ hp.ne_zero)) N (le_max_right _ _)] + simp_rw [principalResidueTerm_square_cube p hp hprimary h hph,←Finset.mul_sum] + ring + +theorem sourceArithmeticResidue_square_cube (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + sourceArithmeticResidue (h*p^5)= + (1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*sourceArithmeticResidue (h*p^2) := by + have hm:ShortDraftTrace.breveE (cuspFrequency (h*p^5))= + ShortDraftTrace.breveE (cuspFrequency (h*p^2)):=by + rw [show h*p^5=(((h*p^2)*p)*p)*p by ring] + rw [sourceRayPhase_mul_primary _ p hprimary,sourceRayPhase_mul_primary _ p hprimary, + sourceRayPhase_mul_primary _ p hprimary] + have hp9:¬p∣9*h:=by + have hh:=ramified_prime_frequency_not_dvd h p hp hprimary hph (1:Eisˣ) 0 + simpa only [Units.val_one,pow_zero,one_mul,mul_one,mul_comm 9 h] using hh + simp only [sourceArithmeticResidue,hm] + split_ifs + · rw [principalArithmeticResidue_square_cube p hp hprimary h hph, + show 9*(h*p^5)=(9*h)*p^5 by ring, + unramifiedGaussResidue_square_cube p hp hprimary (9*h) hp9, + show 9*(h*p^2)=(9*h)*p^2 by ring] + ring + · ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma sourceArithmeticResidue_prime_pow_mod (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hh:h≠0) (n:ℕ) : + sourceArithmeticResidue (h*p^n)=sourceArithmeticResidue (h*p^(n%3)) := by + induction n using Nat.strong_induction_on with + | h n ih=> + by_cases hn:n<3 + · rw [Nat.mod_eq_of_lt hn] + · have hn3:3≤n:=by omega + have he:h*p^n=(h*p^(n-3))*p^3:=by rw [mul_assoc,←pow_add,Nat.sub_add_cancel hn3] + rw [he,sourceArithmeticResidue_prime_cube p hp hprimary _ (mul_ne_zero hh (pow_ne_zero _ hp.ne_zero)), + ih (n-3) (by omega)] + have hm:(n-3)%3=n%3:=by omega + rw [hm] + +theorem sourceArithmeticResidue_prime_square (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + sourceArithmeticResidue (h*p^2)=0 := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + have he:=sourceArithmeticResidue_square_cube p hp hprimary h hph + rw [show h*p^5=(h*p^2)*p^3 by ring, + sourceArithmeticResidue_prime_cube p hp hprimary _ (mul_ne_zero hh (pow_ne_zero _ hp.ne_zero))] at he + have hq:(Ideal.absNorm (Ideal.span {p}):ℂ)≠0:=Nat.cast_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + have hz:(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*sourceArithmeticResidue (h*p^2)=0:=by + linear_combination -he + exact (mul_eq_zero.mp hz).resolve_left (inv_ne_zero hq) + +theorem sourceArithmeticResidue_prime_factor (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + sourceArithmeticResidue (h*p)= + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ))* + primeCubicGauss p hp hprimary 2 (9*h)*sourceArithmeticResidue h := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + have hrec:=sourceArithmeticResidue_prime_recurrence p hp hprimary h hph + rw [sourceArithmeticResidue_prime_cube p hp hprimary h hh] at hrec + have hrel:(Ideal.absNorm (Ideal.span {p}):ℂ)^(-(4/3:ℂ))* + primeCubicGauss p hp hprimary 1 (9*h)*sourceArithmeticResidue (h*p)= + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*sourceArithmeticResidue h:=by + linear_combination hrec + have hp9:¬p∣9*h:=by + have ht:=ramified_prime_frequency_not_dvd h p hp hprimary hph (1:Eisˣ) 0 + simpa only [Units.val_one,pow_zero,one_mul,mul_one,mul_comm 9 h] using ht + have hG:=primeCubicGauss_one_mul_two p hp hprimary (9*h) hp9 + let q:ℂ:=(Ideal.absNorm (Ideal.span {p}):ℂ) + have hq:q≠0:=Nat.cast_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + have hpower:q^(-(2/3:ℂ))*q^(-(4/3:ℂ))*q^2=1:=by + rw [←Complex.cpow_add _ _ hq,←Complex.cpow_natCast q 2, + ←Complex.cpow_add _ _ hq] + norm_num + calc + sourceArithmeticResidue (h*p)= + (q^(-(2/3:ℂ))*q^(-(4/3:ℂ))*q^2)*sourceArithmeticResidue (h*p):=by rw [hpower,one_mul] + _=q^(-(2/3:ℂ))*q*primeCubicGauss p hp hprimary 2 (9*h)* + (q^(-(4/3:ℂ))*primeCubicGauss p hp hprimary 1 (9*h)*sourceArithmeticResidue (h*p)):=by + calc + _=q^(-(2/3:ℂ))*q^(-(4/3:ℂ))*q* + (primeCubicGauss p hp hprimary 1 (9*h)*primeCubicGauss p hp hprimary 2 (9*h))* + sourceArithmeticResidue (h*p):=by rw [hG];ring + _=_:=by ring + _=q^(-(2/3:ℂ))*q*primeCubicGauss p hp hprimary 2 (9*h)*(q⁻¹*sourceArithmeticResidue h):=by rw [hrel] + _=_:=by + change q^(-(2/3:ℂ))*q*primeCubicGauss p hp hprimary 2 (9*h)*(q⁻¹*sourceArithmeticResidue h)= + q^(-(2/3:ℂ))*primeCubicGauss p hp hprimary 2 (9*h)*sourceArithmeticResidue h + field_simp [hq] + +theorem sourceArithmeticResidue_prime_power_table (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (n:ℕ) : + sourceArithmeticResidue (h*p^n)= + if n%3=0 then sourceArithmeticResidue h + else if n%3=1 then + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ))* + primeCubicGauss p hp hprimary 2 (9*h)*sourceArithmeticResidue h + else 0 := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + rw [sourceArithmeticResidue_prime_pow_mod p hp hprimary h hh n] + split_ifs with h0 h1 + · simp only [h0,pow_zero,mul_one] + · simp only [h1,pow_one] + exact sourceArithmeticResidue_prime_factor p hp hprimary h hph + · have hn:n%3=2:=by omega + rw [hn,sourceArithmeticResidue_prime_square p hp hprimary h hph] + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma primeCubicMulChar_inverse (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) : + (primeCubicMulChar p hp hprimary)⁻¹=primeCubicMulChar p hp hprimary^2 := by + apply inv_eq_of_mul_eq_one_right + simpa only [←pow_succ'] using primeCubicMulChar_cube p hp hprimary + +lemma primeCubicGauss_two_eq_star (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (h:Eis) : + primeCubicGauss p hp hprimary 2 h=star (primeCubicGauss p hp hprimary 1 h) := by + let:(Ideal.span {p}:Ideal Eis).IsMaximal:=PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + let:Field (Eis⧸Ideal.span {p}):=Ideal.Quotient.field _ + let:Fintype (Eis⧸Ideal.span {p}):=Fintype.ofFinite _ + rw [primeCubicGauss_eq_gaussSum,primeCubicGauss_eq_gaussSum,pow_one,star_gaussSum_eq, + primeCubicMulChar_inverse] + have he:=mul_gaussSum_inv_eq_gaussSum + (primeCubicMulChar p hp hprimary^2) ((quotientTrace p hp.ne_zero).mulShift (Ideal.Quotient.mk _ h)) + have hm:(primeCubicMulChar p hp hprimary^2) (-1 : Eis⧸Ideal.span {p})=1:=by + rw [MulChar.pow_apply' _ (by decide : (2:ℕ)≠0),←map_pow] + norm_num + rw [hm,one_mul] at he + exact he.symm + +lemma primeCubicGauss_one_normalized (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + [(Ideal.span {p}:Ideal Eis).IsMaximal] (hg:lambda∉(Ideal.span {p}:Ideal Eis)) : + primeCubicGauss p hp hprimary 1 1/(‖eisEmbedding p‖:ℂ)= + breveGamma2 (Ideal.span {p}) hg p rfl hp.ne_zero := by + let:Fintype (Eis⧸Ideal.span {p}):=Fintype.ofFinite _ + unfold breveGamma2 + rw [primeCubicGauss_eq_gaussSum,pow_one,canonicalSextic_pow_two] + simp only [map_one,AddChar.mulShift_one] + congr 2 + apply DFunLike.ext + intro x + obtain ⟨d,rfl⟩:=Ideal.Quotient.mk_surjective x + simp only [primeCubicMulChar_mk,MulChar.ringHomComp_apply, + symbol_prime p hp hprimary,primeValue_eq _ hg] + +lemma primeCubicGauss_two_twist (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (h:Eis) (hph:¬p∣h) : + primeCubicGauss p hp hprimary 2 h=eisEmbedding (symbol h p)*primeCubicGauss p hp hprimary 2 1 := by + have hcop:IsCoprime p h:=hp.coprime_iff_not_dvd.mpr hph + have he:=cubicUnitGaussSum_frequency_twist (1:Eis) p h hp.ne_zero hprimary hcop + simp only [one_mul,←primeCubicGauss_one_eq p hp hprimary] at he + have hs:(eisEmbedding (symbol h p))^3=1:=by + rw [←map_pow,symbol_cube_of_isCoprime h p hprimary hcop.symm,map_one] + have hstar:star (eisEmbedding (symbol h p))*eisEmbedding (symbol h p)=1:=by + have hn:‖eisEmbedding (symbol h p)‖=1:=by + have hn:=congrArg norm hs + simp only [norm_pow,norm_one] at hn + exact (pow_left_inj₀ (norm_nonneg _) zero_le_one (by decide : (3:ℕ)≠0)).mp (by simpa using hn) + rw [mul_comm] + simpa only [Complex.star_def,Complex.normSq_eq_norm_sq,hn,one_pow,Complex.ofReal_one] using Complex.mul_conj (eisEmbedding (symbol h p)) + have hconj:=congrArg star he + simp only [star_mul,←primeCubicGauss_two_eq_star] at hconj + calc + _=(star (eisEmbedding (symbol h p))*eisEmbedding (symbol h p))*primeCubicGauss p hp hprimary 2 h:=by rw [hstar,one_mul] + _=eisEmbedding (symbol h p)*(star (eisEmbedding (symbol h p))*primeCubicGauss p hp hprimary 2 h):=by ring + _=_:=by rw [mul_comm (star (eisEmbedding (symbol h p))),hconj] + +lemma cubicBesselNormalizer_mul (h p:Eis) : + cubicBesselNormalizer (h*p)=(‖eisEmbedding p‖:ℂ)^(1/3:ℂ)*cubicBesselNormalizer h := by + have hfreq:‖cuspFrequency (h*p)‖=‖cuspFrequency h‖*‖eisEmbedding p‖:=by + rw [cuspFrequency_mul_right,norm_mul] + have he:(2*Real.pi*‖cuspFrequency (h*p)‖:ℂ)= + (‖eisEmbedding p‖:ℂ)*((2*Real.pi*‖cuspFrequency h‖:ℝ):ℂ):=by rw [hfreq];push_cast;ring + unfold cubicBesselNormalizer + rw [he,Complex.mul_cpow_ofReal_nonneg (norm_nonneg _) (by positivity)] + push_cast + ring + +lemma prime_normalizer_powers (p:Eis) (hp:p≠0) : + (‖eisEmbedding p‖:ℂ)^(1/3:ℂ)*(Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ))= + (‖eisEmbedding p‖:ℂ)⁻¹ := by + have hr:(‖eisEmbedding p‖:ℂ)≠0:=Complex.ofReal_ne_zero.mpr (norm_ne_zero_iff.mpr (eisEmbedding_ne_zero hp)) + rw [←Complex.ofReal_natCast,←eisEmbedding_norm_sq_eq_absNorm_span,pow_two, + Complex.ofReal_mul,Complex.mul_cpow_ofReal_nonneg (norm_nonneg _) (norm_nonneg _), + ←mul_assoc,←Complex.cpow_add _ _ hr,←Complex.cpow_add _ _ hr] + convert Complex.cpow_neg_one (‖eisEmbedding p‖:ℂ) using 1 ; congr 1 ; norm_num + +theorem sourceResidualFourierCoefficient_prime_factor (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + sourceResidualFourierCoefficient (h*p)= + (primeCubicGauss p hp hprimary 2 (9*h)/(‖eisEmbedding p‖:ℂ))*sourceResidualFourierCoefficient h := by + rw [sourceResidualFourierCoefficient,cubicBesselNormalizer_mul, + sourceArithmeticResidue_prime_factor p hp hprimary h hph,sourceResidualFourierCoefficient] + calc + _=((‖eisEmbedding p‖:ℂ)^(1/3:ℂ)*(Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ)))* + primeCubicGauss p hp hprimary 2 (9*h)*(cubicBesselNormalizer h*sourceArithmeticResidue h):=by ring + _=_:=by rw [prime_normalizer_powers p hp.ne_zero];ring + +theorem sourceResidualFourierCoefficient_prime_gamma (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) [(Ideal.span {p}:Ideal Eis).IsMaximal] + (hg:lambda∉(Ideal.span {p}:Ideal Eis)) (h:Eis) (hph:¬p∣h) : + sourceResidualFourierCoefficient (h*p)= + eisEmbedding (symbol (9*h) p)*star (breveGamma2 (Ideal.span {p}) hg p rfl hp.ne_zero)* + sourceResidualFourierCoefficient h := by + have hp9:¬p∣9*h:=by + have ht:=ramified_prime_frequency_not_dvd h p hp hprimary hph (1:Eisˣ) 0 + simpa only [Units.val_one,pow_zero,one_mul,mul_one,mul_comm 9 h] using ht + rw [sourceResidualFourierCoefficient_prime_factor p hp hprimary h hph, + primeCubicGauss_two_twist p hp hprimary (9*h) hp9,primeCubicGauss_two_eq_star, + ←primeCubicGauss_one_normalized p hp hprimary hg,star_div₀,Complex.star_def,Complex.conj_ofReal] + ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +def normalizedCubicUnitGauss (n:Eis) : ℂ := + cubicUnitGaussSum 1 n/(‖eisEmbedding n‖:ℂ) + +@[simp] lemma normalizedCubicUnitGauss_one : normalizedCubicUnitGauss 1=1 := by + simp [normalizedCubicUnitGauss] + +lemma cubicSymbol_star_mul (a b:Eis) (hb:lambda^2∣b-1) (hab:IsCoprime a b) : + star (eisEmbedding (symbol a b))*eisEmbedding (symbol a b)=1 := by + have hc:(eisEmbedding (symbol a b))^3=1:=by + rw [←map_pow,symbol_cube_of_isCoprime a b hb hab,map_one] + have hn:‖eisEmbedding (symbol a b)‖=1:=by + apply (pow_left_inj₀ (norm_nonneg _) zero_le_one (by decide : (3:ℕ)≠0)).mp + simpa only [norm_pow,norm_one,one_pow] using congrArg norm hc + rw [mul_comm] + simpa only [Complex.star_def,Complex.normSq_eq_norm_sq,hn,one_pow,Complex.ofReal_one] using + Complex.mul_conj (eisEmbedding (symbol a b)) + +lemma normalizedCubicUnitGauss_coprime_product (a b:Eis) (ha:a≠0) (hb:b≠0) + (hap:lambda^2∣a-1) (hbp:lambda^2∣b-1) (hab:IsCoprime a b) : + star (normalizedCubicUnitGauss (a*b))= + eisEmbedding (symbol a b)*star (normalizedCubicUnitGauss a)*star (normalizedCubicUnitGauss b) := by + have hG:=cubicUnitGaussSum_coprime_product 1 a b ha hb hap hbp hab + simp only [one_mul] at hG + have ht:=cubicUnitGaussSum_frequency_twist 1 b a hb hbp hab.symm + simp only [one_mul] at ht + have hN:eisEmbedding (symbol a b)*normalizedCubicUnitGauss (a*b)= + normalizedCubicUnitGauss a*normalizedCubicUnitGauss b:=by + unfold normalizedCubicUnitGauss + rw [hG,map_mul,norm_mul,Complex.ofReal_mul] + calc + _=cubicUnitGaussSum 1 a*(eisEmbedding (symbol a b)*cubicUnitGaussSum a b)/ + ((‖eisEmbedding a‖:ℂ)*(‖eisEmbedding b‖:ℂ)):=by ring + _=_:=by rw [ht];ring + have hs:=congrArg star hN + simp only [star_mul] at hs + have hc:=cubicSymbol_star_mul a b hbp hab + calc + _=(star (eisEmbedding (symbol a b))*eisEmbedding (symbol a b))* + star (normalizedCubicUnitGauss (a*b)):=by rw [hc,one_mul] + _=eisEmbedding (symbol a b)*(star (normalizedCubicUnitGauss (a*b))* + star (eisEmbedding (symbol a b))):=by ring + _=_:=by rw [hs];ring + +lemma sourceResidualFourierCoefficient_prime_normalized (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + sourceResidualFourierCoefficient (h*p)= + eisEmbedding (symbol (9*h) p)*star (normalizedCubicUnitGauss p)*sourceResidualFourierCoefficient h := by + have hp9:¬p∣9*h:=by + have ht:=ramified_prime_frequency_not_dvd h p hp hprimary hph (1:Eisˣ) 0 + simpa only [Units.val_one,pow_zero,one_mul,mul_one,mul_comm 9 h] using ht + rw [sourceResidualFourierCoefficient_prime_factor p hp hprimary h hph, + primeCubicGauss_two_twist p hp hprimary (9*h) hp9,primeCubicGauss_two_eq_star, + normalizedCubicUnitGauss,←primeCubicGauss_one_eq p hp hprimary, + star_div₀,Complex.star_def,Complex.conj_ofReal] + ring + +lemma primary_finset_product {ι:Type*} (s:Finset ι) (p:ι→Eis) + (hp:∀i∈s,lambda^2∣p i-1) : lambda^2∣(∏i∈s,p i)-1 := by + classical + induction s using Finset.induction_on with + | empty=>simp + | @insert i s hi ih=> + rw [Finset.prod_insert hi] + exact primary_mul _ _ (hp i (Finset.mem_insert_self _ _)) + (ih (fun j hj=>hp j (Finset.mem_insert_of_mem hj))) + +theorem sourceResidualFourierCoefficient_prime_product {ι:Type*} + (s:Finset ι) (p:ι→Eis) (hp:∀i∈s,Prime (p i)) + (hprimary:∀i∈s,lambda^2∣p i-1) + (hpair:∀i∈s,∀j∈s,i≠j→IsCoprime (p i) (p j)) + (h:Eis) (hph:∀i∈s,¬p i∣h) : + sourceResidualFourierCoefficient (h*(∏i∈s,p i))= + eisEmbedding (symbol (9*h) (∏i∈s,p i))* + star (normalizedCubicUnitGauss (∏i∈s,p i))*sourceResidualFourierCoefficient h := by + classical + induction s using Finset.induction_on with + | empty=>simp + | @insert i s hi ih=> + have hpi:=hp i (Finset.mem_insert_self _ _) + have hpri:=hprimary i (Finset.mem_insert_self _ _) + have hps:∀j∈s,Prime (p j):=fun j hj=>hp j (Finset.mem_insert_of_mem hj) + have hprs:∀j∈s,lambda^2∣p j-1:=fun j hj=>hprimary j (Finset.mem_insert_of_mem hj) + have hcpi:IsCoprime (p i) (∏j∈s,p j):=IsCoprime.prod_right (fun j hj=> + hpair i (Finset.mem_insert_self _ _) j (Finset.mem_insert_of_mem hj) (by intro he;subst j;exact hi hj)) + have hbs:(∏j∈s,p j)≠0:=Finset.prod_ne_zero_iff.mpr (fun j hj=>(hps j hj).ne_zero) + have hpb:¬p i∣h*(∏j∈s,p j):=by + intro hd + rcases hpi.dvd_mul.mp hd with hd|hd + · exact hph i (Finset.mem_insert_self _ _) hd + · exact hpi.not_isUnit (hcpi.isUnit_of_dvd hd) + have hih:=ih hps hprs (fun j hj k hk hjk=>hpair j (Finset.mem_insert_of_mem hj) k (Finset.mem_insert_of_mem hk) hjk) + (fun j hj=>hph j (Finset.mem_insert_of_mem hj)) + rw [Finset.prod_insert hi,show h*(p i*(∏j∈s,p j))=(h*(∏j∈s,p j))*p i by ring, + sourceResidualFourierCoefficient_prime_normalized (p i) hpi hpri _ hpb,hih] + rw [mul_comm (p i) (∏j∈s,p j), + normalizedCubicUnitGauss_coprime_product _ _ hbs hpi.ne_zero + (primary_finset_product s p hprs) hpri hcpi.symm, + symbol_mul_denominator,map_mul] + rw [show (9:Eis)*(h*(∏j∈s,p j))=(9*h)*(∏j∈s,p j) by ring, + symbol_mul_numerator _ _ (p i) hpri,map_mul] + ring + +lemma symbol_nine_eq_paperLambda (n:Eis) (hn:lambda^2∣n-1) : + symbol 9 n=symbol ramifiedTraceLambda n := by + have he:(9:Eis)=ramifiedTraceLambda^4:=by + rw [show (4:ℕ)=2*2 from rfl,pow_mul,ramifiedTraceLambda_square] + norm_num + have hcop:IsCoprime ramifiedTraceLambda n:= + ramified_character_coprime 0 1 _ n (Or.inl (by simp)) hn + rw [he,symbol_pow_numerator _ _ hn,show (4:ℕ)=3+1 from rfl,pow_add, + symbol_cube_of_isCoprime _ _ hn hcop,pow_one,one_mul] + +theorem sourceResidualFourierCoefficient_primary_product {ι:Type*} + (s:Finset ι) (p:ι→Eis) (hp:∀i∈s,Prime (p i)) + (hprimary:∀i∈s,lambda^2∣p i-1) + (hpair:∀i∈s,∀j∈s,i≠j→IsCoprime (p i) (p j)) : + star (sourceResidualFourierCoefficient (∏i∈s,p i))= + star (sourceResidualFourierCoefficient 1)* + star (eisEmbedding (symbol ramifiedTraceLambda (∏i∈s,p i)))* + normalizedCubicUnitGauss (∏i∈s,p i) := by + have he:=sourceResidualFourierCoefficient_prime_product s p hp hprimary hpair 1 + (fun i hi=>fun hd=>(hp i hi).not_isUnit (isUnit_of_dvd_one hd)) + simp only [one_mul,mul_one] at he + rw [symbol_nine_eq_paperLambda _ (primary_finset_product s p hprimary)] at he + rw [he,star_mul,star_mul,star_star] + ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +theorem sourceArithmeticResidue_primary_cube (b:Eis) (hb:b≠0) + (hbprimary:lambda^2∣b-1) (h:Eis) (hh:h≠0) : + sourceArithmeticResidue (h*b^3)=sourceArithmeticResidue h := by + obtain ⟨s,hs,hpr⟩:=exists_primary_prime_factorization b hb hbprimary + rw [←hs] + clear hs hb hbprimary b + induction s using Multiset.induction_on generalizing h with + | empty=>simp + | @cons p s ih=> + have hp:=hpr p (Multiset.mem_cons_self _ _) + have hs:∀q∈s,Prime q∧lambda^2∣q-1:=fun q hq=>hpr q (Multiset.mem_cons_of_mem hq) + have hs0:s.prod≠0:=by + intro hz + exact (hs 0 (Multiset.prod_eq_zero_iff.mp hz)).1.ne_zero rfl + rw [Multiset.prod_cons,show h*(p*s.prod)^3=(h*s.prod^3)*p^3 by ring, + sourceArithmeticResidue_prime_cube p hp.1 hp.2 _ (mul_ne_zero hh (pow_ne_zero _ hs0))] + exact ih h hh hs + +theorem sourceResidualFourierCoefficient_primary_cube (b:Eis) (hb:b≠0) + (hbprimary:lambda^2∣b-1) (h:Eis) (hh:h≠0) : + sourceResidualFourierCoefficient (h*b^3)= + (‖eisEmbedding b‖:ℂ)*sourceResidualFourierCoefficient h := by + rw [sourceResidualFourierCoefficient,cubicBesselNormalizer_mul_cube h b hb, + sourceArithmeticResidue_primary_cube b hb hbprimary h hh,sourceResidualFourierCoefficient] + ring + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubicSymbol_prime_zero (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (x:Eis) (hpx:p∣x) : symbol x p=0 := by + let:(Ideal.span {p}:Ideal Eis).IsMaximal:=PrincipalIdealRing.isMaximal_of_irreducible hp.irreducible + have hg:lambda∉(Ideal.span {p}:Ideal Eis):= + primary_maximal_divisor_good p hprimary _ (Ideal.subset_span (by simp)) + rw [symbol_prime p hp hprimary,primeValue_eq _ hg, + Ideal.Quotient.eq_zero_iff_mem.mpr (Ideal.mem_span_singleton.mpr hpx),MulChar.map_zero] + +lemma cubicSymbol_zero_of_not_coprime (n:Eis) (hn:n≠0) (hprimary:lambda^2∣n-1) + (x:Eis) (hnot:¬IsCoprime n x) : symbol x n=0 := by + obtain ⟨s,hs,hp⟩:=exists_primary_prime_factorization n hn hprimary + rw [←hs] at hnot ⊢ + clear hs hn hprimary n + induction s using Multiset.induction_on with + | empty=>exact False.elim (hnot (by simpa using (isCoprime_one_left : IsCoprime (1:Eis) x))) + | @cons p s ih=> + have hprime:=hp p (Multiset.mem_cons_self _ _) + have hrest:∀q∈s,Prime q∧lambda^2∣q-1:=fun q hq=>hp q (Multiset.mem_cons_of_mem hq) + rw [Multiset.prod_cons,symbol_mul_denominator] + by_cases hc:IsCoprime p x + · have hnc:¬IsCoprime s.prod x:=fun h=>hnot (by simpa using hc.mul_left h) + rw [ih hnc hrest,mul_zero] + · rw [cubicSymbol_prime_zero p hprime.1 hprime.2 x + (hprime.1.irreducible.dvd_iff_not_isCoprime.mpr hc),zero_mul] + +lemma cubicRow_eq_idealSymbol (I:Ideal Eis) (hI:primaryGenerator I≠0) + (hsq:Squarefree I) (a:Eis) : + cubicRow I hI (Ideal.Quotient.mk I a)=eisEmbedding (idealSymbol I a) := by + rw [cubicRow_mk] + simp_rw [canonicalSextic_pow_two,MulChar.ringHomComp_apply,←primeValue_eq] + change (∏P:primeSupport I,eisEmbedding (primeValue P.val a))=eisEmbedding (idealSymbol I a) + rw [←Finset.prod_subtype (primeSupport I) (fun _=>Iff.rfl) + (fun P=>eisEmbedding (primeValue P a)),←map_prod] + have hI0:=primaryGenerator_ne_zero_ideal I hI + have hnodup: (UniqueFactorizationMonoid.normalizedFactors I).Nodup:= + (UniqueFactorizationMonoid.squarefree_iff_nodup_normalizedFactors hI0).mp hsq + congr 1 + rw [idealSymbol,ite_eq_right hI0] + change (((primeSupport I).val.map (fun P=>primeValue P a)).prod)=_ + have hv:(primeSupport I).val=UniqueFactorizationMonoid.normalizedFactors I:=by + simpa only [primeSupport, Multiset.toFinset_val] using hnodup.dedup + rw [hv] + +lemma cubicUnitGaussSum_full (n:Eis) (hn:n≠0) (hprimary:lambda^2∣n-1) (h:Eis) : + cubicUnitGaussSum h n= + ∑'x:Eis⧸Ideal.span {n},eisEmbedding (symbol (GaussianShiftedPartition.representative n x) n)* + quotientTrace n hn (Ideal.Quotient.mk _ h*x) := by + let f:(Eis⧸Ideal.span {n})→ℂ:=fun x=> + eisEmbedding (symbol (GaussianShiftedPartition.representative n x) n)* + quotientTrace n hn (Ideal.Quotient.mk _ h*x) + have hsup:Function.support f⊆{x|IsUnit x}:=by + intro x hx + by_contra hnot + change ¬IsUnit x at hnot + have hcop:¬IsCoprime n (GaussianShiftedPartition.representative n x):=by + intro hc + apply hnot + have hh:=(isUnit_quotient_span_iff n (GaussianShiftedPartition.representative n x)).mpr hc + simpa only [GaussianShiftedPartition.representative_spec] using hh + exact hx (by simp only [f,cubicSymbol_zero_of_not_coprime n hn hprimary _ hcop,map_zero,zero_mul]) + change cubicUnitGaussSum h n=∑'x,f x + rw [←tsum_subtype_eq_of_support_subset hsup] + unfold cubicUnitGaussSum + apply tsum_congr + intro x + dsimp only [f] + rw [←GaussianShiftedPartition.representative_spec n x.val,quotientTrace_mk_product] + simp only [GaussianShiftedPartition.representative_spec] + +theorem normalizedCubicUnitGauss_eq_gaussTwo (I:Ideal Eis) + (hI:primaryGenerator I≠0) (hsq:Squarefree I) : + normalizedCubicUnitGauss (primaryGenerator I)=gaussTwo I hI := by + let n:=primaryGenerator I + let:Finite (Eis⧸Ideal.span {n}):=finite_quotient_span hI + let:Fintype (Eis⧸Ideal.span {n}):=Fintype.ofFinite _ + let e:=Ideal.quotEquivOfEq (primaryGenerator_spec I hI).1 + rw [normalizedCubicUnitGauss,cubicUnitGaussSum_full _ hI (primaryGenerator_spec I hI).2 1, + tsum_fintype] + change (∑x:Eis⧸Ideal.span {n},eisEmbedding (symbol (GaussianShiftedPartition.representative n x) n)* + quotientTrace n hI (Ideal.Quotient.mk _ 1*x))/(‖eisEmbedding n‖:ℂ)= + (∑x:Eis⧸Ideal.span {n},cubicRow I hI (e x)*quotientTrace n hI x)/(‖eisEmbedding n‖:ℂ) + congr 1 + apply Finset.sum_congr rfl + intro x hx + obtain ⟨a,rfl⟩:=Ideal.Quotient.mk_surjective x + rw [Ideal.quotEquivOfEq_mk,cubicRow_eq_idealSymbol I hI hsq] + have hc:n∣GaussianShiftedPartition.representative n (Ideal.Quotient.mk (Ideal.span {n}) a)-a:= + gaussRep_mk_congr n a + have hs:symbol a n=idealSymbol I a:=by + unfold symbol + rw [(primaryGenerator_spec I hI).1] + rw [symbol_congr hc,hs,map_one,one_mul] + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimePowerGaussSums.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimePowerGaussSums.lean new file mode 100644 index 0000000000000000000000000000000000000000..83e2df3aad4a0c00b964bb671a75eef62e8d4c88 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimePowerGaussSums.lean @@ -0,0 +1,657 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.ResidualCuspDecay + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open scoped BigOperators Classical +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +@[simp] lemma cubicUnitGaussSum_one (h:Eis):cubicUnitGaussSum h 1=1:=by + let:Subsingleton (Eis⧸Ideal.span {(1:Eis)}):= + Ideal.Quotient.subsingleton_iff.mpr (by simp) + let r:CubicUnitResidue (1:Eis):=⟨1,isUnit_one⟩ + rw [cubicUnitGaussSum,tsum_eq_single r (fun b hb=>False.elim (hb (Subsingleton.elim b r)))] + rw [symbol_one,map_one,one_mul, + residueAdditive_three_congr h 1 _ 0 one_ne_zero (one_dvd _)] + simp only [residueAdditive,map_zero,mul_zero,zero_div,AddChar.map_zero_eq_one] + +lemma cubicUnitGaussSum_frequency_dvd (h c:Eis) (hc:c≠0) (hch:c∣h): + cubicUnitGaussSum h c=cubicUnitGaussSum 0 c:= + cubicUnitGaussSum_frequency_congr h 0 c hc (by simpa only [sub_zero] using hch) + +lemma cubicUnitGaussSum_prime_power_zero (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) (n:ℕ): + cubicUnitGaussSum 0 (p^(n+1))= + if 3∣n+1 then (Ideal.absNorm (Ideal.span {p}):ℂ)^n* + ((Ideal.absNorm (Ideal.span {p}):ℂ)-1) else 0:=by + have he:=cubicUnitGaussSum_prime_power_lift p hp hprimary n 0 + simp only [mul_zero] at he + rw [he,primeCubicGauss_of_dvd p hp hprimary (n+1) 0 (dvd_zero _)] + split_ifs <;>ring + +lemma cubicUnitGaussSum_prime_power_too_large (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (a k:ℕ) (hk:a+1omega + | succ n=> + have hd:=cubicUnitGaussSum_prime_power_support p hp hprimary n (h*p^a) hG + have hd':p^(a+1)∣p^a*h:=by + rw [mul_comm] + exact (pow_dvd_pow p (by omega:a+1≤n)).trans hd + rw [pow_succ] at hd' + exact hph ((mul_dvd_mul_iff_left (pow_ne_zero _ hp.ne_zero)).mp hd') + +lemma unramifiedPrimeDeletedSeries_pow_mod (p:Eis) (hp:Prime p) (s:ℂ) (h:Eis) (n:ℕ): + unramifiedPrimeDeletedSeries p s (h*p^n)= + unramifiedPrimeDeletedSeries p s (h*p^(n%3)):=by + apply tsum_congr + intro I + congr 1 + have he:p^n=p^(n%3)*(p^(n/3))^3:=by + rw [←pow_mul,←pow_add] + congr 1 + omega + rw [he,←mul_assoc] + exact cubicUnitGaussSum_cube_shift _ _ _ I.val.2 + (primaryGenerator_spec I.val.val I.val.2).2 + (primeDeleted_generator_coprime p hp I).symm.pow_right + +theorem unramifiedCubicGaussSeries_prime_finite (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (s:ℂ) (hs:2 ActualEisensteinCubic.O + +structure SubexponentialBesselCoefficients where + value : ActualEisensteinCubic.O→ℂ + growth : ∀epsilon : ℝ,0 (q.1:ℂ)^(2/3:ℂ)) p := + (Complex.continuousAt_ofReal_cpow_const p.1 (2/3:ℂ) (Or.inr hp.ne')).comp continuousAt_fst + have hsource : ContinuousAt (fun q : ℝ × ℂ => sourceFourierKernel (4/3) (cuspFrequency h*q.1)) p := + (sourceFourierKernel_continuous_freq (4/3) (by norm_num)).continuousAt.comp (by fun_prop) + have hphase : Continuous (fun q : ℝ × ℂ => ShortDraftTrace.breveE (cuspFrequency h*q.2)) := by + change Continuous (fun q : ℝ × ℂ => Complex.exp (2*Real.pi*Complex.I* + ((cuspFrequency h*q.2)+starRingEnd ℂ (cuspFrequency h*q.2)))) + fun_prop + exact (((continuousAt_const.mul hpow).mul hsource).mul hphase.continuousAt).continuousWithinAt + +lemma slab_bound (a b : ℝ) (ha : 0 coeff.term h p) := by + obtain ⟨C,hC,hbound⟩ := coeff.slab_bound p.1 p.1 hp le_rfl + apply Summable.of_norm + exact Summable.of_nonneg_of_le (fun h => norm_nonneg _) (fun h => hbound h p ⟨le_rfl,le_rfl⟩) + ((summable_exp_neg_cuspFrequency_norm (Real.pi*p.1) (mul_pos Real.pi_pos hp)).mul_left C) + +def series (p : ℝ × ℂ) : ℂ := ∑'h : ActualEisensteinCubic.O,coeff.term h p + +lemma series_continuousOn_slab (a b : ℝ) (ha : 0 C*Real.exp (-(Real.pi*a)*‖cuspFrequency h‖)) + · intro h + exact (coeff.term_continuousOn h).mono (fun p hp => ha.trans_le hp.1) + · exact (summable_exp_neg_cuspFrequency_norm (Real.pi*a) (mul_pos Real.pi_pos ha)).mul_left C + · exact hbound + +lemma series_continuousOn : ContinuousOn coeff.series {p : ℝ × ℂ | 0 fun p : ℝ × ℂ => ∑h∈t,coeff.term h p) + coeff.series atTop {p : ℝ × ℂ | p.1∈Set.Icc a b} := by + obtain ⟨C,hC,hbound⟩ := coeff.slab_bound a b ha hab + exact tendstoUniformlyOn_tsum + ((summable_exp_neg_cuspFrequency_norm (Real.pi*a) (mul_pos Real.pi_pos ha)).mul_left C) hbound + +lemma series_bessel (v : ℝ) (hv : 0 coeff.term_eq_amplitude v hv h z) + +lemma series_period (v : ℝ) (z : ℂ) (n : ActualEisensteinCubic.O) : + coeff.series (v,z+3*ConcreteTraceCRT.eisEmbedding n)=coeff.series (v,z) := by + apply tsum_congr + intro h + by_cases hh : h=0 + · simp only [term,ite_eq_left hh] + simp only [term,ite_eq_right hh] + rw [mul_add,AddChar.map_add_eq_mul,cuspFrequency_period,mul_one] + +def function (w : HyperbolicSpace) : ℂ := coeff.series (hyperbolicHeight w,hyperbolicHorizontal w) + +lemma function_continuous : Continuous coeff.function := by + apply continuous_iff_continuousAt.mpr + intro w + have hopen : IsOpen {p : ℝ × ℂ | 0 (hyperbolicHeight u,hyperbolicHorizontal u)) + (hyperbolicHeight_continuous.prodMk hyperbolicHorizontal_continuous).continuousAt + +end SubexponentialBesselCoefficients +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ENNReal +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma series_fourier (v : ℝ) (hv : 0 coeff.amplitude v h*ShortDraftTrace.breveE (cuspFrequency h*z)* + ShortDraftTrace.breveE (-cuspFrequency k*z) + have hc (h : ActualEisensteinCubic.O) : Continuous (f h) := by + change Continuous (fun z : ℂ => coeff.amplitude v h* + Complex.exp (2*Real.pi*Complex.I*((cuspFrequency h*z)+starRingEnd ℂ (cuspFrequency h*z)))* + Complex.exp (2*Real.pi*Complex.I*((-cuspFrequency k*z)+starRingEnd ℂ (-cuspFrequency k*z)))) + fun_prop + obtain ⟨C,hC,hbound⟩ := coeff.slab_bound v v hv le_rfl + have hfbound (h : ActualEisensteinCubic.O) (z : ℂ) : ‖f h z‖≤C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖) := by + change ‖(coeff.amplitude v h*ShortDraftTrace.breveE (cuspFrequency h*z))* + ShortDraftTrace.breveE (-cuspFrequency k*z)‖≤_ + rw [←coeff.term_eq_amplitude v hv h z,norm_mul,breveE_norm,mul_one] + exact hbound h (v,z) ⟨le_rfl,le_rfl⟩ + have hi (h : ActualEisensteinCubic.O) : IntegrableOn (f h) periodDomain volume := + (integrable_const (C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖))).mono' + (hc h).aestronglyMeasurable (Eventually.of_forall (hfbound h)) + have hnorm (h : ActualEisensteinCubic.O) : (∫z in periodDomain,‖f h z‖)≤ + volume.real periodDomain*(C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖)) := by + have hh := integral_mono_ae (hi h).norm (integrable_const (C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖))) + (Eventually.of_forall (hfbound h)) + simpa only [setIntegral_const,smul_eq_mul] using hh + have hs : Summable (fun h : ActualEisensteinCubic.O => ∫z in periodDomain,‖f h z‖) := by + apply Summable.of_nonneg_of_le (fun h => integral_nonneg (fun z => norm_nonneg _)) hnorm + exact ((summable_exp_neg_cuspFrequency_norm (Real.pi*v) (mul_pos Real.pi_pos hv)).mul_left C).mul_left + (volume.real periodDomain) + have hterm (h : ActualEisensteinCubic.O) : (∫z in periodDomain,f h z)= + if h=k then ((9*Real.sqrt 3/2:ℝ):ℂ)*coeff.amplitude v h else 0 := by + change (∫z in periodDomain,coeff.amplitude v h*ShortDraftTrace.breveE (cuspFrequency h*z)* + ShortDraftTrace.breveE (-cuspFrequency k*z))=_ + simp_rw [mul_assoc] + rw [integral_const_mul,integral_cusp_character_product] + split_ifs <;> ring + calc + _ = ∫z in periodDomain,∑'h : ActualEisensteinCubic.O,f h z := by + apply integral_congr_ae + exact Eventually.of_forall (fun z => by + change (∑'h : ActualEisensteinCubic.O,coeff.term h (v,z))*ShortDraftTrace.breveE (-cuspFrequency k*z)=_ + rw [←tsum_mul_right] + apply tsum_congr + intro h + rw [coeff.term_eq_amplitude v hv h z]) + _ = ∑'h : ActualEisensteinCubic.O,∫z in periodDomain,f h z := (integral_tsum_of_summable_integral_norm hi hs).symm + _ = ∑'h : ActualEisensteinCubic.O,if h=k then ((9*Real.sqrt 3/2:ℝ):ℂ)*coeff.amplitude v h else 0 := tsum_congr hterm + _ = _ := by simp + +lemma series_height_continuous (v : ℝ) (hv : 0 coeff.series (v,z)) := by + apply continuous_iff_continuousAt.mpr + intro z + have hopen : IsOpen {p : ℝ × ℂ | 0 (v,z)) (by fun_prop) + +def fullFunction (constant : ℂ) (w : HyperbolicSpace) : ℂ := + constant*(hyperbolicHeight w:ℂ)^(2/3:ℂ)+coeff.function w + +lemma fullFunction_continuous (constant : ℂ) : Continuous (coeff.fullFunction constant) := by + have hp : Continuous (fun w : HyperbolicSpace => (hyperbolicHeight w:ℂ)^(2/3:ℂ)) := by + apply continuous_iff_continuousAt.mpr + intro w + exact (Complex.continuousAt_ofReal_cpow_const (hyperbolicHeight w) (2/3:ℂ) + (Or.inr (hyperbolicHeight_pos w).ne')).comp (f := hyperbolicHeight) hyperbolicHeight_continuous.continuousAt + exact (continuous_const.mul hp).add coeff.function_continuous + +lemma fullFunction_fourier (constant : ℂ) (v : ℝ) (hv : 0 ShortDraftTrace.breveE (-cuspFrequency k*z)) := by + change Continuous (fun z : ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-cuspFrequency k*z)+starRingEnd ℂ (-cuspFrequency k*z)))) + fun_prop + have hc0 := periodDomain_integrable_of_continuous + (fun z => (constant*(v:ℂ)^(2/3:ℂ))*ShortDraftTrace.breveE (-cuspFrequency k*z)) + (continuous_const.mul hphase) + have hcn := periodDomain_integrable_of_continuous + (fun z => coeff.series (v,z)*ShortDraftTrace.breveE (-cuspFrequency k*z)) + ((coeff.series_height_continuous v hv).mul hphase) + simp_rw [fullFunction,function,hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint,add_mul] + rw [integral_add hc0 hcn,integral_const_mul,integral_cusp_character,coeff.series_fourier v hv k] + by_cases hk : k=0 + · simp only [ite_eq_left hk,amplitude,mul_zero] + ring + · simp only [ite_eq_right hk,mul_zero,zero_add] + +lemma fullFunction_period (constant : ℂ) (v : ℝ) (hv : 0 coeff.fullFunction constant (upperPoint z v hv)) := by + have hc := coeff.series_height_continuous v hv + simp only [fullFunction,function,hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + fun_prop + +lemma fullFunction_height_memLp (constant : ℂ) (v : ℝ) (hv : 0 coeff.fullFunction constant (cuspCoordinateLift (v,z))) 2 + (volume.restrict periodDomain) := by + simp_rw [cuspCoordinateLift_positive v _ hv] + have hc := coeff.fullFunction_height_continuous constant v hv + apply (memLp_two_iff_integrable_sq_norm hc.aestronglyMeasurable).mpr + have hn : Continuous (fun z : ℂ => ‖coeff.fullFunction constant (upperPoint z v hv)‖^2) := by + fun_prop + apply (hn.continuousOn.integrableOn_compact + (isCompact_closedBall (0:ℂ) (∑i,‖periodBasis i‖))).mono_set + intro z hz + simpa only [Metric.mem_closedBall,dist_zero_right] using norm_mem_periodDomain z hz + +end SubexponentialBesselCoefficients +end CubicEisenstein + +open scoped BigOperators Classical + +namespace ShortDraftCRT +variable {R : Type*} [CommRing R] + +theorem inverse_residue_congr (D r r0 u u0 : R) (hcop : IsCoprime D r) + (hr : D∣r-r0) (hu : D∣u*r-1) (hu0 : D∣u0*r0-1) : D∣u-u0 := by + apply hcop.dvd_of_dvd_mul_right + have hh := dvd_sub (dvd_sub hu hu0) (dvd_mul_of_dvd_right hr u0) + convert hh using 1 ; ring + +theorem inverse_weight_residue_congr (D r r0 u u0 d d0 : R) + (hcop : IsCoprime D r) (hr : D∣r-r0) + (hu : D∣u*r-1) (hu0 : D∣u0*r0-1) (hd : D∣d-d0) : + D∣(-d*u)-(-d0*u0) := by + have hi := inverse_residue_congr D r r0 u u0 hcop hr hu hu0 + have hh := dvd_add (dvd_mul_of_dvd_left hd u) (dvd_mul_of_dvd_right hi d0) + convert dvd_neg.mpr hh using 1 ; ring + +theorem fixed_additive_sector {K : Type*} [Field K] + (ι : R→+*K) (ψ : AddChar K ℂ) (lam D r r0 u u0 d d0 x : R) + (hlam : ι lam≠0) (hD : ι D≠0) + (hperiod : ∀y : R,ψ (ι y/ι lam)=1) + (hcop : IsCoprime D r) (hr : D∣r-r0) + (hu : D∣u*r-1) (hu0 : D∣u0*r0-1) (hd : D∣d-d0) : + ψ (ι (-d*u)*ι x/(ι lam*ι D))= + ψ (ι (-d0*u0)*ι x/(ι lam*ι D)) := + addChar_congr_of_dvd ι ψ lam D (-d*u) (-d0*u0) x hlam hD hperiod + (inverse_weight_residue_congr D r r0 u u0 d d0 hcop hr hu hu0 hd) + +theorem strong_sector_additive_congruences (M lam c r r0 d d0 : R) + (hlam : lam^3∣M) (hc : c∣M) (hr : M^2∣r-r0) (hd : M*c∣d-d0) : + lam^3*c∣r-r0 ∧ lam^3*c∣d-d0 := by + constructor + · apply (show lam^3*c∣M^2 by simpa only [pow_two] using mul_dvd_mul hlam hc).trans hr + · exact (mul_dvd_mul hlam (dvd_refl c)).trans hd + +end ShortDraftCRT + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +namespace CubicEisenstein +open CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +def translatedHeightCompact (M:levelTwo) (a b:ℝ) : Set KernelQuotient := + kernelSourceAction M '' cuspHeightQuotientCompact a b + +lemma translatedHeightCompact_isCompact (M:levelTwo) (a b:ℝ) (ha:0z*cuspWeightedFourierPhase ρ h w) hw + +lemma translatedHeightFourier_restrict (a b:ℝ) (ha:0z*cuspWeightedFourierPhase ρ h w) + (hw.trans (Set.indicator_of_mem hm _)) + +def translatedHeightFamily (a b:ℝ) (ha:0(s-4/3)*translatedHeightFamily a b ha ρ h M s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (translatedHeightFourier a b ha ρ h M cubicEisensteinResidue)) := by + have hh:=(translatedHeightFourier a b ha ρ h M).continuous.continuousAt.tendsto.comp + (cubicEisensteinResidue_local_limit _ (translatedHeightCompact_isCompact M a b ha)) + simpa only [Function.comp_def,map_smul,smul_eq_mul,translatedHeightFourier_restrict, + translatedHeightFamily] using hh + +lemma translatedHeightFamily_initial (a b:ℝ) (ha:0 ActualEisensteinCubic.O + +theorem integralCoverTraceFunction_integral_cusp_decay (H K : Subgroup (SL(2,ActualEisensteinCubic.O))) + [H.IsFiniteRelIndex K] (f : IntegralOrbitQuotient H→ℂ) (C : ℝ) + (hdec : ∀M : SL(2,ActualEisensteinCubic.O),∀z : ℂ,∀v : ℝ,∀hv : 0f (integralConjugateMap e.symm g⁻¹ (integralCoverIntertwines_inverse e g he) q)) + +lemma kernelCoverLegAdjointFunction_measurable (f : IntegralOrbitQuotient H→ℂ) + (hf : Measurable f) : Measurable (kernelCoverLegAdjointFunction e g he f) := + integralCoverTraceFunction_measurable J globalKubotaKernel _ + (hf.comp (integralConjugateMap_measurable _ _ _)) + +theorem kernelCoverLegAdjointFunction_represents (D : IntegralQuotientL2 H) + (f : IntegralOrbitQuotient H→ℂ) (hf : Measurable f) + (hrep : D=ᵐ[integralQuotientVolume H]f) : + ContinuousLinearMap.adjoint (kernelCoverLeg hHK hJK e g he) D + =ᵐ[integralQuotientVolume globalKubotaKernel]kernelCoverLegAdjointFunction e g he f := by + rw [kernelCoverLeg_adjoint_apply] + have hconj := (integralConjugatePullback_ae e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) + (hJK.trans globalKubotaKernel_le_levelThree) (hHK.trans globalKubotaKernel_le_levelThree) D).trans + ((integralConjugateMap_measurePreserving e.symm g⁻¹ + (integralCoverIntertwines_inverse e g he) + (hJK.trans globalKubotaKernel_le_levelThree) (hHK.trans globalKubotaKernel_le_levelThree)).quasiMeasurePreserving.ae_eq_comp hrep) + exact integralCoverTrace_representative hJK globalKubotaKernel_le_levelThree _ _ + (hf.comp (integralConjugateMap_measurable _ _ _)) hconj + +theorem kernelCoverLegAdjointFunction_cusp_decay (f : IntegralOrbitQuotient H→ℂ) (C : ℝ) + (hdec : ∀M : SL(2,ActualEisensteinCubic.O),∀z : ℂ,∀v : ℝ,∀hv : 0 ActualEisensteinCubic.O + +theorem commonCover_source_sum_eq_zero_of_inverse_cusp_decay + {H : Subgroup (SL(2,ActualEisensteinCubic.O))} {ι : Type*} [Fintype ι] + (J : ι→Subgroup (SL(2,ActualEisensteinCubic.O))) + (hHK : H≤globalKubotaKernel) (hJK : ∀i,J i≤globalKubotaKernel) + [∀i,(J i).IsFiniteRelIndex globalKubotaKernel] + (e : ∀i,H≃*J i) (g : ι→SL(2,ℂ)) (he : ∀i,IntegralCoverIntertwines (e i) (g i)) + (c : ι→ℂ) (D : IntegralQuotientL2 H) + (hD : D=∑i,c i • kernelCoverLeg hHK (hJK i) (e i) (g i) (he i) + (kernelSourceProjection cubicEisensteinResidue)) + (f : IntegralOrbitQuotient H→ℂ) (hf : Measurable f) + (hrep : D=ᵐ[integralQuotientVolume H]f) + (C : ι→ℝ) (hC : ∀i,0≤C i) + (hdec : ∀i,∀M : SL(2,ActualEisensteinCubic.O),∀z : ℂ,∀v : ℝ,∀hv : 0kernelCoverLegAdjointFunction (e i) (g i) (he i) f) + (C:=fun i=>(J i).relIndex globalKubotaKernel*C i) + · intro i + rw [hD] + exact kernelCoverLeg_adjoint_sum_eigenvector J hHK hJK e g he + (kernelSourceProjection cubicEisensteinResidue) (8/9:ℂ) + kernelSourceProjection_cubicEisensteinResidue_eigenvector c i + · intro i + exact kernelCoverLegAdjointFunction_represents hHK (hJK i) (e i) (g i) (he i) D f hf hrep + · intro i + exact mul_nonneg (Nat.cast_nonneg _) (hC i) + · intro i M z v hv hlarge + exact kernelCoverLegAdjointFunction_cusp_decay (e i) (g i) (he i) f (C i) (hdec i) M z v hv hlarge + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise + +local notation "Eis" => ActualEisensteinCubic.O + +lemma integralProjection_quasiMeasurePreserving (H:Subgroup (SL(2,Eis))) + (hH:H≤CubicKubota.levelThree) : + Measure.QuasiMeasurePreserving (integralOrbitProjection H) + hyperbolicVolume (integralQuotientVolume H) := by + let proj:=integralOrbitProjection H + have hp:Measurable proj:=measurable_integralOrbitProjection H + refine ⟨hp,Measure.AbsolutelyContinuous.mk fun S hS hzero=>?_⟩ + rw [Measure.map_apply hp hS] + have hd:hyperbolicVolume ((proj ⁻¹' S)∩hyperbolicFundamentalSet H)=0:=by + simpa only [integralQuotientVolume,proj, + Measure.map_apply (measurable_integralOrbitProjection _) hS, + Measure.restrict_apply ((measurable_integralOrbitProjection _) hS)] using hzero + have hinv:∀M:H,M • (proj ⁻¹' S)=proj ⁻¹' S:=by + intro M + ext w + constructor + · rintro ⟨u,hu,rfl⟩ + change proj (M • u)∈S + change proj u∈S at hu + rwa [show proj (M • u)=proj u from integralOrbitProjection_eq H M u] + · intro hw + refine ⟨M⁻¹ • w,?_,smul_inv_smul M w⟩ + change proj (M⁻¹ • w)∈S + rwa [show proj (M⁻¹ • w)=proj w from integralOrbitProjection_eq H M⁻¹ w] + exact (hyperbolicFundamentalSet_isFundamentalDomain H hH).measure_zero_of_invariant + (proj ⁻¹' S) hinv hd + +theorem integralQuotient_continuous_lifts_eq (H:Subgroup (SL(2,Eis))) + (hH:H≤CubicKubota.levelThree) (F G:IntegralOrbitQuotient H→ℂ) + (f g:HyperbolicSpace→ℂ) (hf:Continuous f) (hg:Continuous g) + (hF:∀w,F (integralOrbitProjection H w)=f w) + (hG:∀w,G (integralOrbitProjection H w)=g w) + (he:F=ᵐ[integralQuotientVolume H]G) : f=g := by + have hl: f=ᵐ[hyperbolicVolume]g:=by + have hh:=(integralProjection_quasiMeasurePreserving H hH).ae_eq_comp he + simpa only [Function.comp_def,hF,hG] using hh + exact Measure.eq_of_ae_eq hl hf hg + +theorem integralQuotient_zero_continuous_lift (H:Subgroup (SL(2,Eis))) + (hH:H≤CubicKubota.levelThree) (F:IntegralOrbitQuotient H→ℂ) + (f:HyperbolicSpace→ℂ) (hf:Continuous f) + (hF:∀w,F (integralOrbitProjection H w)=f w) + (hzero:F=ᵐ[integralQuotientVolume H]0) : ∀w,f w=0 := by + have he:f=0:=integralQuotient_continuous_lifts_eq H hH F 0 f 0 hf + continuous_const hF (fun _=>rfl) hzero + intro w + exact congrFun he w + +end + +section +open Filter MeasureTheory +open scoped Classical MatrixGroups BigOperators + +open CubicKubota ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +theorem cubeDifferenceL2_eq_zero (p : ActualEisensteinCubic.O) (hp : Prime p) + (hprimary : ActualEisensteinCubic.lambda^2∣p-1) : + cubeDifferenceL2 p hp.ne_zero=0 := by + let : Finite (CubeResidues p) := finite_quotient_span (pow_ne_zero 3 hp.ne_zero) + let : Fintype (CubeResidues p) := Fintype.ofFinite _ + let : ∀i : CubeLegIndex p,(cubeLegTarget p hp.ne_zero i).FiniteIndex := + cubeLegTarget_finiteIndex p hp.ne_zero + let : ∀i : CubeLegIndex p,(cubeLegTarget p hp.ne_zero i).IsFiniteRelIndex globalKubotaKernel := + fun i=>Subgroup.isFiniteRelIndex_of_finiteIndex + obtain ⟨C0,hC0,h0⟩ := cubeSourceDifference_cubic_decay p hp hprimary + obtain ⟨C1,hC1,h1⟩ := cubeSourceDifference_inverse_cubic_decay p hp hprimary + let C : CubeLegIndex p→ℝ := fun i=>i.elim C0 (fun _=>C1) + apply commonCover_source_sum_eq_zero_of_inverse_cusp_decay + (cubeLegTarget p hp.ne_zero) (cubeCommonCover_le p hp.ne_zero) + (cubeLegTarget_le p hp.ne_zero) (cubeLegEquiv p hp.ne_zero) + (cubeLegMatrix p hp.ne_zero) (cubeLeg_intertwines p hp.ne_zero) + (cubeLegCoefficient p) (cubeDifferenceL2 p hp.ne_zero) ?_ + (cubeDifferenceQuotientFunction p hp.ne_zero) + (cubeDifferenceQuotientFunction_measurable p hp.ne_zero) + (cubeDifferenceL2_representative p hp.ne_zero) C ?_ ?_ + · simp only [cubeDifferenceL2,tsum_fintype,cubeLeg] + · intro i + cases i with + | none => exact hC0 + | some r => exact hC1 + · intro i M z v hv hlarge + rw [cubeDifferenceQuotientFunction_projection] + cases i with + | none => + simpa only [cubeLegMatrix,inv_one,one_smul,C,Option.elim] using h0 M z v hv hlarge.le + | some r => + exact h1 (GaussianShiftedPartition.representative (p^3) r) M z v hv hlarge.le + +theorem cubeSourceDifference_eq_zero (p : ActualEisensteinCubic.O) (hp : Prime p) + (hprimary : ActualEisensteinCubic.lambda^2∣p-1) (w : HyperbolicSpace) : + cubeSourceDifference p hp.ne_zero w=0 := by + have hz : cubeDifferenceQuotientFunction p hp.ne_zero + =ᵐ[integralQuotientVolume (cubeCommonCover p hp.ne_zero)]0 := by + apply (cubeDifferenceL2_representative p hp.ne_zero).symm.trans + rw [cubeDifferenceL2_eq_zero p hp hprimary] + exact Lp.coeFn_zero ℂ 2 _ + exact integralQuotient_zero_continuous_lift (cubeCommonCover p hp.ne_zero) + ((cubeCommonCover_le p hp.ne_zero).trans globalKubotaKernel_le_levelThree) + (cubeDifferenceQuotientFunction p hp.ne_zero) (cubeSourceDifference p hp.ne_zero) + (cubeSourceDifference_continuous p hp.ne_zero) + (cubeDifferenceQuotientFunction_projection p hp.ne_zero) hz w + +theorem cubicSource_cubeAverage (p : ActualEisensteinCubic.O) (hp : Prime p) + (hprimary : ActualEisensteinCubic.lambda^2∣p-1) (w : HyperbolicSpace) : + cubeAverage p hp.ne_zero cubicSourceResidualFunction w= + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*cubicSourceResidualFunction w := + sub_eq_zero.mp (cubeSourceDifference_eq_zero p hp hprimary w) + +theorem sourceArithmeticResidue_prime_cube (p : ActualEisensteinCubic.O) (hp : Prime p) + (hprimary : ActualEisensteinCubic.lambda^2∣p-1) (h : ActualEisensteinCubic.O) (hh : h≠0) : + sourceArithmeticResidue (h*p^3)=sourceArithmeticResidue h := + sourceArithmeticResidue_cube_of_eigenrelation p hp.ne_zero + (cubicSource_cubeAverage p hp hprimary) h hh + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma rational_inversion_complex : + integralComplexMatrix (rationalEmbedding ModularGroup.S)=complexWeyl := by + apply Matrix.SpecialLinearGroup.ext + intro i j + simp only [integralComplexMatrix_apply, rationalEmbedding, + Matrix.SpecialLinearGroup.map_apply_coe] + fin_cases i <;> fin_cases j <;> simp [ModularGroup.S, complexWeyl] + +theorem exists_nonzero_sourceResidualFourierCoefficient : + ∃h:Eis,h≠0 ∧ sourceResidualFourierCoefficient h≠0 := by + by_contra hn + have hz:∀h:Eis,h≠0→sourceResidualFourierCoefficient h=0:=by + intro h hh + by_contra hne + exact hn ⟨h,hh,hne⟩ + let C:ℂ:=(3*(Real.pi:ℂ))*constantArithmeticResidue + have hC:C≠0:=mul_ne_zero + (mul_ne_zero (by norm_num) (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero)) + constantArithmeticResidue_ne_zero + have hprofile (z:ℂ) (v:ℝ) (hv:0 norm_num + have hi:=cubicSourceResidualFunction_rational_invariant ModularGroup.S + (upperPoint 0 2 (by norm_num)) + rw [hpoint,hprofile,hprofile] at hi + have hc:(1/2:ℂ)^(2/3:ℂ)=(2:ℂ)^(2/3:ℂ):=by + exact mul_left_cancel₀ hC (by simpa only [Complex.ofReal_div,Complex.ofReal_one, + Complex.ofReal_ofNat] using hi) + have hr:(1/2:ℝ)^(2/3:ℝ)=(2:ℝ)^(2/3:ℝ):=by + apply Complex.ofReal_injective + have h1:=Complex.ofReal_cpow (show (0:ℝ)≤1/2 by norm_num) (2/3:ℝ) + have h2:=Complex.ofReal_cpow (show (0:ℝ)≤2 by norm_num) (2/3:ℝ) + norm_num only [Complex.ofReal_div,Complex.ofReal_one,Complex.ofReal_ofNat] at h1 h2 + exact h1.trans (hc.trans h2.symm) + have hlt:(1/2:ℝ)^(2/3:ℝ)<(2:ℝ)^(2/3:ℝ):= + Real.rpow_lt_rpow (by norm_num) (by norm_num) (by norm_num) + exact hlt.ne hr + +theorem exists_nonzero_sourceArithmeticResidue : + ∃h:Eis,h≠0 ∧ sourceArithmeticResidue h≠0 := by + obtain ⟨h,hh,hn⟩:=exists_nonzero_sourceResidualFourierCoefficient + refine ⟨h,hh,?_⟩ + intro hz + apply hn + simp only [sourceResidualFourierCoefficient,hz,mul_zero] + +end + +section +open ActualEisensteinCubic +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +abbrev PrincipalRamifiedIndex (h:Eis) := Eisˣ × Fin (ramifiedFrequencyBound h+1) + +def principalRamifiedIndex (h:Eis) (i:PrincipalRamifiedIndex h) : Eis := + h*(9*(i.1.val*lambda^(i.2.val+2))) + +def principalRamifiedWeight (h:Eis) (i:PrincipalRamifiedIndex h) (s:ℂ) : ℂ := + ((3^(i.2.val+2):ℕ):ℂ)^(-s)*explicitRamifiedCoefficient h i.1 (i.2.val+2) + +lemma principalRamifiedWeight_analytic (h:Eis) (i:PrincipalRamifiedIndex h) (s:ℂ) : + AnalyticAt ℂ (principalRamifiedWeight h i) s := by + apply AnalyticAt.mul _ analyticAt_const + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + exact Eventually.of_forall fun z=>(differentiableAt_id.neg).const_cpow + (Or.inl (by exact_mod_cast (pow_ne_zero (i.2.val+2) (by norm_num : (3:ℕ)≠0)))) + +lemma scatteringCoefficient_eq_principalRamified (s:ℂ) (hs:2(principalRamifiedWeight_analytic h i s).mul + (cuspWhittakerHeightFactor_analyticAt h s hs)) + (kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num)) + (kernelCuspFourier h cubicEisensteinResidue) + (fun s hs hi=>kernelCuspFourierFamily_analyticAt_nonreal h 2 3 + (by norm_num) (by norm_num) s hs.ne' hi.ne') + (kernelCuspFourierFamily_residue_limit h 2 3 (by norm_num) (by norm_num)) + (fun s hs hi=>by + rw [kernelCuspFourierFamily_eq_upper h hh ⟨by linarith,hi⟩] + dsimp only + rw [scatteringCoefficient_eq_principalRamified s (by linarith) h hh] + simp only [coeff] + rw [mul_div_cancel₀ _ cusp_volume_ne_zero,Finset.sum_mul] + apply Finset.sum_congr rfl + intro i hi' + ring) + rw [kernelCuspFourier_principal_residue] at he + have hH:=cuspWhittakerHeightFactor_center_ne_zero h + apply (eq_div_iff cusp_volume_ne_zero).mpr + apply mul_right_cancel₀ hH + calc + principalArithmeticResidue h*((9*Real.sqrt 3/2:ℝ):ℂ)*cuspWhittakerHeightFactor (4/3) h + = kernelCuspFourier h cubicEisensteinResidue := by + rw [kernelCuspFourier_principal_residue] + ring + _ = _ := by + rw [kernelCuspFourier_principal_residue,he] + simp only [coeff] + rw [Finset.sum_mul] + apply Finset.sum_congr rfl + intro i hi + ring + +theorem sourceArithmeticResidue_eq_ramified_table (h:Eis) (hh:h≠0) : + sourceArithmeticResidue h= + if ShortDraftTrace.breveE (cuspFrequency h)=1 then + ((∑i:PrincipalRamifiedIndex h,principalRamifiedWeight h i (4/3)* + unramifiedGaussResidue (principalRamifiedIndex h i))+ + 3*unramifiedGaussResidue (9*h))/(4*((9*Real.sqrt 3/2:ℝ):ℂ)) + else 0 := by + rw [sourceArithmeticResidue,principalArithmeticResidue_eq_ramified_table h hh] + split_ifs + · ring + · rfl + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +lemma arithmeticResidueSum_frequency_cube (h c p:Eis) (hc:c≠0) + (hlevel:(3:Eis)∣c) (hprimary:lambda^2∣p-1) (hcp:IsCoprime c p) : + arithmeticResidueSum (h*p^3) c=arithmeticResidueSum h c := by + have ht:denominatorCondition c p:=⟨hcp,three_dvd_lambda_sq.trans hprimary⟩ + have hb:(eisEmbedding (symbol c p))^3=1:=by + rw [←map_pow,symbol_cube_of_isCoprime c p hprimary hcp,map_one] + have h1:=arithmeticResidueSum_frequency_twist h c p hc hlevel ht + have h2:=arithmeticResidueSum_frequency_twist (h*p) c p hc hlevel ht + have h3:=arithmeticResidueSum_frequency_twist (h*p*p) c p hc hlevel ht + rw [show h*p^3=h*p*p*p by ring] + calc + _=eisEmbedding (symbol c p)^3*arithmeticResidueSum (h*p*p*p) c:=by rw [hb,one_mul] + _=eisEmbedding (symbol c p)^2*arithmeticResidueSum (h*p*p) c:=by rw [pow_succ,mul_assoc,h3] + _=eisEmbedding (symbol c p)*arithmeticResidueSum (h*p) c:=by rw [pow_two,mul_assoc,h2] + _=arithmeticResidueSum h c:=h1 + +lemma ramified_prime_Gauss_cancel (h c p:Eis) (hc:c≠0) (hlevel:(3:Eis)∣c) + (hp:Prime p) (hprimary:lambda^2∣p-1) (hcp:IsCoprime c p) : + arithmeticResidueSum h c*primeCubicGauss p hp hprimary 1 (h*(9*c))= + arithmeticResidueSum (h*p) c*primeCubicGauss p hp hprimary 1 (9*h) := by + have ht:denominatorCondition c p:=⟨hcp,three_dvd_lambda_sq.trans hprimary⟩ + have hA:=arithmeticResidueSum_frequency_twist h c p hc hlevel ht + have hG:=cubicUnitGaussSum_frequency_twist (9*h) p c hp.ne_zero hprimary hcp.symm + rw [←primeCubicGauss_one_eq p hp hprimary,←primeCubicGauss_one_eq p hp hprimary] at hG + rw [show (9*h)*c=h*(9*c) by ring] at hG + have hb:eisEmbedding (symbol c p)≠0:=by + have hcube:(eisEmbedding (symbol c p))^3=1:=by + rw [←map_pow,symbol_cube_of_isCoprime c p hprimary hcp,map_one] + intro hz + simp only [hz,zero_pow (by decide : (3:ℕ)≠0)] at hcube + exact zero_ne_one hcube + apply mul_left_cancel₀ hb + calc + _=arithmeticResidueSum h c*(eisEmbedding (symbol c p)* + primeCubicGauss p hp hprimary 1 (h*(9*c))):=by ring + _=arithmeticResidueSum h c*primeCubicGauss p hp hprimary 1 (9*h):=by rw [hG] + _=(eisEmbedding (symbol c p)*arithmeticResidueSum (h*p) c)* + primeCubicGauss p hp hprimary 1 (9*h):=by rw [hA] + _=_:=by ring + +lemma ramified_prime_frequency_not_dvd (h p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (hph:¬p∣h) (u:Eisˣ) (n:ℕ) : + ¬p∣h*(9*(u.val*lambda^n)) := by + intro hd + rcases hp.dvd_mul.mp hd with hh|hc + · exact hph hh + have hcp: IsCoprime (9*(u.val*lambda^n)) p := by + have h3: IsCoprime (3:Eis) p:=(primary_coprime_three p hprimary).symm + have hram: IsCoprime (u.val*lambda^n) p:= + (ramified_primary_coprime u n p hprimary).of_mul_left_right + convert h3.pow_left (m:=2) |>.mul_left hram using 1 ; norm_num + exact hp.not_isUnit (hcp.symm.isUnit_of_dvd hc) + +lemma sourceRayPhase_mul_primary (h p:Eis) (hprimary:lambda^2∣p-1) : + ShortDraftTrace.breveE (cuspFrequency (h*p))= + ShortDraftTrace.breveE (cuspFrequency h) := by + obtain ⟨d,hd⟩:=three_dvd_lambda_sq.trans hprimary + have hp:p=1+3*d:=by linear_combination hd + have he:cuspFrequency (h*p)=cuspFrequency h+cuspFrequency h*(3*eisEmbedding d):=by + rw [hp,cuspFrequency,cuspFrequency,map_mul,map_add,map_mul,map_one,map_ofNat] + ring + rw [he,AddChar.map_add_eq_mul,cuspFrequency_period,mul_one] + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def principalResidueTerm (h:Eis) (u:Eisˣ) (n:ℕ) : ℂ := + ((3^(n+2):ℕ):ℂ)^(-(4/3:ℂ))*arithmeticResidueSum h (u.val*lambda^(n+2))* + unramifiedGaussResidue (h*(9*(u.val*lambda^(n+2)))) + +lemma principalResidueTerm_vanish (h:Eis) (hh:h≠0) (u:Eisˣ) (n:ℕ) + (hn:ramifiedFrequencyBound hhph (he▸dvd_zero p) + let N:=max (ramifiedFrequencyBound (h*p^3)+1) + (max (ramifiedFrequencyBound h+1) (ramifiedFrequencyBound (h*p)+1)) + rw [principalArithmeticResidue_eq_sum (h*p^3) (mul_ne_zero hh (pow_ne_zero _ hp.ne_zero)) N (le_max_left _ _), + principalArithmeticResidue_eq_sum h hh N (le_trans (le_max_left _ _) (le_max_right _ _)), + principalArithmeticResidue_eq_sum (h*p) (mul_ne_zero hh hp.ne_zero) N + (le_trans (le_max_right _ _) (le_max_right _ _))] + simp_rw [principalResidueTerm_prime_recurrence p hp hprimary h hph, + Finset.sum_sub_distrib,←Finset.mul_sum] + ring + +theorem sourceArithmeticResidue_prime_recurrence (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + sourceArithmeticResidue (h*p^3)= + (1+(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹)*sourceArithmeticResidue h- + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(4/3:ℂ))*primeCubicGauss p hp hprimary 1 (9*h)* + sourceArithmeticResidue (h*p) := by + have hm:ShortDraftTrace.breveE (cuspFrequency (h*p^3))= + ShortDraftTrace.breveE (cuspFrequency h):=by + rw [show h*p^3=((h*p)*p)*p by ring] + rw [sourceRayPhase_mul_primary _ p hprimary,sourceRayPhase_mul_primary _ p hprimary, + sourceRayPhase_mul_primary _ p hprimary] + have hp9:¬p∣9*h:=by + have hh:=ramified_prime_frequency_not_dvd h p hp hprimary hph (1:Eisˣ) 0 + simpa only [Units.val_one,pow_zero,one_mul,mul_one,mul_comm 9 h] using hh + simp only [sourceArithmeticResidue,hm,sourceRayPhase_mul_primary h p hprimary] + split_ifs with hh + · rw [principalArithmeticResidue_prime_recurrence p hp hprimary h hph, + show 9*(h*p^3)=(9*h)*p^3 by ring, + unramifiedGaussResidue_prime_recurrence p hp hprimary (9*h) hp9, + show 9*(h*p)=(9*h)*p by ring] + ring + · ring + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimitiveRows.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimitiveRows.lean new file mode 100644 index 0000000000000000000000000000000000000000..165f549527782d50e20e1cb204898e226fa084de --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/PrimitiveRows.lean @@ -0,0 +1,651 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.Rows + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid + +namespace CubicEisenstein +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT + +lemma levelThree_of_entries (M : SL(2,O)) + (h : ∀ i j : Fin 2, (3 : O) ∣ M i j - (if i=j then 1 else 0)) : + M ∈ levelThree := by + change Matrix.SpecialLinearGroup.map (n := Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3 : O)})) M = 1 + apply Subtype.ext + funext i j + change Ideal.Quotient.mk (Ideal.span {(3 : O)}) (M i j) = + (1 : Matrix (Fin 2) (Fin 2) (O ⧸ Ideal.span {(3 : O)})) i j + have hh : Ideal.Quotient.mk (Ideal.span {(3 : O)}) (M i j) = + Ideal.Quotient.mk (Ideal.span {(3 : O)}) (if i=j then 1 else 0) := + (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + (Ideal.mem_span_singleton.mpr (h i j)) + simpa only [Matrix.one_apply, apply_ite, map_one, map_zero] using hh + +lemma row_coprime (M : levelThree) : IsCoprime (row M 0) (row M 1) := by + have h : (M : SL(2,O)) 0 0*(M : SL(2,O)) 1 1 - + (M : SL(2,O)) 0 1*(M : SL(2,O)) 1 0 = 1 := by + simpa only [Matrix.det_fin_two] using (M : SL(2,O)).property + refine ⟨-(M : SL(2,O)) 0 1, (M : SL(2,O)) 0 0, ?_⟩ + change -(M : SL(2,O)) 0 1*(M : SL(2,O)) 1 0 + + (M : SL(2,O)) 0 0*(M : SL(2,O)) 1 1 = 1 + linear_combination h + +lemma exists_matrix_of_primitive_row (c d : O) (hcop : IsCoprime c d) + (hc : (3 : O) ∣ c) (hd : (3 : O) ∣ d-1) : + ∃ M : levelThree, row M = ![c,d] := by + obtain ⟨r,s,hrs⟩ := hcop + let M : SL(2,O) := ⟨!![s+r*c,r*(d-1); c,d], by + rw [Matrix.det_fin_two] + change (s+r*c)*d-(r*(d-1))*c=1 + linear_combination hrs⟩ + have hA : s+r*c-1 = -s*(d-1) := by linear_combination hrs + have hM : M ∈ levelThree := by + apply levelThree_of_entries + intro i j + fin_cases i <;> fin_cases j + · change (3 : O) ∣ s+r*c-1 + rw [hA] + exact hd.mul_left (-s) + · change (3 : O) ∣ r*(d-1)-0 + simpa only [sub_zero] using hd.mul_left r + · change (3 : O) ∣ c-(if (1 : Fin 2)=0 then 1 else 0) + simpa only [show (1 : Fin 2) ≠ 0 by decide, ite_false, sub_zero] using hc + · change (3 : O) ∣ d-1 + exact hd + exact ⟨⟨M,hM⟩, rfl⟩ + +def PrimitiveRow := {v : Fin 2 → O // + IsCoprime (v 0) (v 1) ∧ (3 : O) ∣ v 0 ∧ (3 : O) ∣ v 1-1} + +def cosetPrimitiveRow (x : CuspCosets) : PrimitiveRow := + ⟨cosetRow x, by + induction x using Quotient.inductionOn with | _ M => + change IsCoprime (row M 0) (row M 1) ∧ (3 : O) ∣ row M 0 ∧ (3 : O) ∣ row M 1-1 + exact ⟨row_coprime M, levelThree_lower M, by simpa [row] using levelThree_entry M 1 1⟩⟩ + +lemma cosetPrimitiveRow_bijective : Function.Bijective cosetPrimitiveRow := by + constructor + · intro x y hxy + exact cosetRow_injective (congrArg Subtype.val hxy) + · intro v + obtain ⟨M,hM⟩ := exists_matrix_of_primitive_row (v.1 0) (v.1 1) + v.2.1 v.2.2.1 v.2.2.2 + refine ⟨cosetOf M, ?_⟩ + apply Subtype.ext + change row M = v.1 + rw [hM] + funext i + fin_cases i <;> rfl + +def primitiveRowEquiv : CuspCosets ≃ PrimitiveRow := Equiv.ofBijective _ cosetPrimitiveRow_bijective + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT CubicJacobiGlobal + +lemma inverse_character_eq_row_symbol (M : levelThree) : + (complexCharacter M)⁻¹ = eisEmbedding (symbol (row M 0) (row M 1)) := by + let a := (M : SL(2,O)) 0 0 + let b := (M : SL(2,O)) 0 1 + let c := (M : SL(2,O)) 1 0 + let d := (M : SL(2,O)) 1 1 + have hdet : a*d-b*c=1 := by + simpa only [a,b,c,d,Matrix.det_fin_two] using (M : SL(2,O)).property + have had : a*d-1=b*c := by linear_combination hdet + have ha : lambda^2 ∣ a-1 := levelThree_primary M + have hd3 : (3 : O) ∣ d-1 := by simpa [d] using levelThree_entry M 1 1 + have hd : lambda^2 ∣ d-1 := lambda_sq_dvd_three.trans hd3 + obtain ⟨b0,hb⟩ := levelThree_upper M + obtain ⟨c0,hc⟩ := levelThree_lower M + change b=3*b0 at hb + change c=3*c0 at hc + have h9 : (9 : O) ∣ a*d-1 := by + refine ⟨b0*c0, ?_⟩ + rw [had,hb,hc] + ring + have hcd : c ∣ a*d-1 := by rw [had]; exact dvd_mul_left c b + have hs := symbol_denominator_congr c (a*d) 1 (primary_mul a d ha hd) (by simp) h9 hcd + rw [symbol_mul_denominator, symbol_one] at hs + have hm : eisEmbedding (symbol c a)*eisEmbedding (symbol c d)=1 := by + simpa only [map_mul, map_one] using congrArg eisEmbedding hs + change (eisEmbedding (symbol c a))⁻¹ = eisEmbedding (symbol c d) + exact inv_eq_of_mul_eq_one_right hm + +lemma inverse_cosetCharacter_eq_row_symbol (x : CuspCosets) : + (cosetCharacter x)⁻¹ = eisEmbedding (symbol (cosetRow x 0) (cosetRow x 1)) := by + induction x using Quotient.inductionOn with | _ M => exact inverse_character_eq_row_symbol M + +def primitiveRowPhase (v : PrimitiveRow) : ℂ := + eisEmbedding (symbol (v.1 0) (v.1 1)) + +lemma primitiveRowEquiv_val (x : CuspCosets) : (primitiveRowEquiv x).1 = cosetRow x := rfl + +lemma primitiveRowEquiv_symm_row (v : PrimitiveRow) : + cosetRow (primitiveRowEquiv.symm v) = v.1 := by + exact congrArg Subtype.val (primitiveRowEquiv.apply_symm_apply v) + +theorem upperEisenstein_eq_primitive_rows (z : ℂ) (v : ℝ) (hv : 0 < v) (s : ℂ) : + upperEisenstein z v hv s = ∑' row : PrimitiveRow, + primitiveRowPhase row * + ((v / (‖eisEmbedding (row.1 0)*z+eisEmbedding (row.1 1)‖^2 + + ‖eisEmbedding (row.1 0)‖^2*v^2) : ℝ) : ℂ)^s := by + rw [upperEisenstein_eq_source_series] + rw [← primitiveRowEquiv.symm.tsum_eq] + apply tsum_congr + intro r + rw [inverse_cosetCharacter_eq_row_symbol, primitiveRowEquiv_symm_row] + simp only [primitiveRowPhase, transformedHeight, heightDenominator, embeddedRow, + Function.comp_apply, primitiveRowEquiv_symm_row] + +theorem primitive_rows_summable_norm (z : ℂ) (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) : + Summable (fun row : PrimitiveRow => ‖primitiveRowPhase row * + ((v / (‖eisEmbedding (row.1 0)*z+eisEmbedding (row.1 1)‖^2 + + ‖eisEmbedding (row.1 0)‖^2*v^2) : ℝ) : ℂ)^s‖) := by + apply primitiveRowEquiv.summable_iff.mp + apply (summable_norm_summand (upperSection z v hv) s hs).congr + intro x + rw [summand_upperSection, inverse_cosetCharacter_eq_row_symbol] + rfl + +lemma primitiveRow_zero_left (row : PrimitiveRow) (hc : row.1 0 = 0) : row.1 1 = 1 := by + have hu : IsUnit (row.1 1) := by simpa only [hc, isCoprime_zero_left] using row.2.1 + exact A3_primary_unit_eq_one _ hu (lambda_sq_dvd_three.trans row.2.2.2) + +end CubicEisenstein + +open scoped BigOperators Classical SchwartzMap +namespace TruncatedPrincipalPoisson + +section +local notation "O" => ActualEisensteinCubic.O +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge EisensteinSchwartzPoisson + +def radialSource (W : ℝ → ℂ) (X : ℝ) : ℂ := + ∑' z : O, if z = 0 then 0 else W (‖eisEmbedding z‖ ^ 2 / X) + +def radialDual (W : ℝ → ℂ) (X : ℝ) : ℂ := + ∑' h : O, if h = 0 then 0 else paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2) + +theorem radialSource_summable (W : 𝓢(ℝ, ℂ)) (X : ℝ) (hX : 0 < X) : + Summable (fun z : O => if z = 0 then 0 else W (‖eisEmbedding z‖ ^ 2 / X)) := by + have hs : Summable (fun z : O => W (‖eisEmbedding z‖ ^ 2 / X)) := by + simpa only [scaledRadialTest_apply] using + (actual_eisenstein_summable_norm (scaledRadialTest W X hX)).of_norm + convert hs.indicator {z : O | z ≠ 0} using 1 + ext z + by_cases hz : z = 0 <;> simp [hz] + +theorem radialSource_poisson (W : 𝓢(ℝ, ℂ)) (X : ℝ) (hX : 0 < X) : + radialSource W X = (X : ℂ) * paperRadialFourier W 0 - W 0 + + (X : ℂ) * radialDual W X := by + let P : Empty → Ideal O := Empty.elim + let : ∀ i, (P i).IsMaximal := fun i => nomatch i + have hi : Function.Injective P := by intro i; cases i + have hp := masked_principal_radial_poisson_zero_split P hi ∅ W X hX + simp only [maskedPrincipalRemainder, Finset.prod_empty, Finset.powerset_empty, + Finset.sum_singleton, UniqueFactorizationMonoid.moebius_one, map_one, + Int.cast_one, Nat.cast_one, div_one, mul_one] at hp + simp only [rowCoprimeMask, Finset.notMem_empty, false_and, exists_false, + ite_false, one_mul] at hp + have hs : Summable (fun z : O => W (‖eisEmbedding z‖ ^ 2 / X)) := by + simpa only [scaledRadialTest_apply] using + (actual_eisenstein_summable_norm (scaledRadialTest W X hX)).of_norm + have hz := hs.tsum_eq_add_tsum_ite 0 + simp only [map_zero, norm_zero, zero_pow (by decide : 2 ≠ 0), zero_div] at hz + change (∑' z : O, W (‖eisEmbedding z‖ ^ 2 / X)) = + (X : ℂ) * paperRadialFourier W 0 + (X : ℂ) * radialDual W X at hp + change (∑' z : O, W (‖eisEmbedding z‖ ^ 2 / X)) = W 0 + radialSource W X at hz + linear_combination hp - hz + +def subsetNorm {ι : Type*} (P : ι → Ideal O) (E : Finset ι) : ℝ := + Ideal.absNorm (∏ i ∈ E, P i) + +def subsetMobius {ι : Type*} (P : ι → Ideal O) (E : Finset ι) : ℂ := + UniqueFactorizationMonoid.moebius (∏ i ∈ E, P i) + +def smallDivisors {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) (S : Finset ι) (Z : ℝ) := + S.powerset.filter (fun E => subsetNorm P E ≤ Z) + +def largeDivisors {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) (S : Finset ι) (Z : ℝ) := + S.powerset.filter (fun E => Z < subsetNorm P E) + +theorem subsetNorm_pos {ι : Type*} (P : ι → Ideal O) [∀ i, (P i).IsMaximal] (E : Finset ι) : + 0 < subsetNorm P E := by + rw [subsetNorm, ← primeSubsetGenerator_norm_sq] + exact sq_pos_of_pos (norm_pos_iff.mpr (eisEmbedding_ne_zero (primeSubsetGenerator_ne_zero P E))) + +theorem sum_small_add_large {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) + (S : Finset ι) (Z : ℝ) (f : Finset ι → ℂ) : + (∑ E ∈ smallDivisors P S Z, f E) + (∑ E ∈ largeDivisors P S Z, f E) = + ∑ E ∈ S.powerset, f E := by + simpa only [smallDivisors, largeDivisors, not_le] using + Finset.sum_filter_add_sum_filter_not S.powerset (fun E => subsetNorm P E ≤ Z) f + +theorem masked_radialSource_dilations {ι : Type*} [DecidableEq ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] (hinj : Function.Injective P) + (S : Finset ι) (W : 𝓢(ℝ, ℂ)) (X : ℝ) (hX : 0 < X) : + (∑' z : O, rowCoprimeMask P S z * + (if z = 0 then 0 else W (‖eisEmbedding z‖ ^ 2 / X))) = + ∑ E ∈ S.powerset, subsetMobius P E * radialSource W (X / subsetNorm P E) := by + rw [tsum_rowCoprimeMask_dilations P hinj S _ (radialSource_summable W X hX)] + apply Finset.sum_congr rfl + intro E hE + change subsetMobius P E * _ = _ + congr 1 + apply tsum_congr + intro z + rw [mul_eq_zero, or_iff_right (primeSubsetGenerator_ne_zero P E)] + by_cases hz : z = 0 + · simp [hz] + · rw [ite_eq_right hz, ite_eq_right hz, map_mul, norm_mul, mul_pow, primeSubsetGenerator_norm_sq] + congr 1 + simp only [subsetNorm, div_div_eq_mul_div] + ring + +theorem masked_radialSource_truncated {ι : Type*} [DecidableEq ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] (hinj : Function.Injective P) + (S : Finset ι) (W : 𝓢(ℝ, ℂ)) (X Z : ℝ) (hX : 0 < X) : + (∑' z : O, rowCoprimeMask P S z * + (if z = 0 then 0 else W (‖eisEmbedding z‖ ^ 2 / X))) = + (X : ℂ) * paperRadialFourier W 0 * + (∑ E ∈ smallDivisors P S Z, subsetMobius P E / (subsetNorm P E : ℂ)) - + W 0 * (∑ E ∈ smallDivisors P S Z, subsetMobius P E) + + (X : ℂ) * (∑ E ∈ smallDivisors P S Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * radialDual W (X / subsetNorm P E)) + + (∑ E ∈ largeDivisors P S Z, subsetMobius P E * radialSource W (X / subsetNorm P E)) := by + rw [masked_radialSource_dilations P hinj S W X hX, + ← sum_small_add_large P S Z] + congr 1 + simp only [Finset.mul_sum, ← Finset.sum_sub_distrib, ← Finset.sum_add_distrib] + apply Finset.sum_congr rfl + intro E hE + rw [radialSource_poisson W _ (div_pos hX (subsetNorm_pos P E))] + push_cast + ring + +theorem masked_radialSource_truncated_euler {ι : Type*} [DecidableEq ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] (hinj : Function.Injective P) + (S : Finset ι) (W : 𝓢(ℝ, ℂ)) (X Z : ℝ) (hX : 0 < X) : + (∑' z : O, rowCoprimeMask P S z * + (if z = 0 then 0 else W (‖eisEmbedding z‖ ^ 2 / X))) = + (X : ℂ) * paperRadialFourier W 0 * + (∏ i ∈ S, (1 - (1 : ℂ) / Ideal.absNorm (P i))) - + (X : ℂ) * paperRadialFourier W 0 * + (∑ E ∈ largeDivisors P S Z, subsetMobius P E / (subsetNorm P E : ℂ)) - + W 0 * (∑ E ∈ smallDivisors P S Z, subsetMobius P E) + + (X : ℂ) * (∑ E ∈ smallDivisors P S Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * radialDual W (X / subsetNorm P E)) + + (∑ E ∈ largeDivisors P S Z, subsetMobius P E * radialSource W (X / subsetNorm P E)) := by + rw [masked_radialSource_truncated P hinj S W X Z hX] + have hs := sum_small_add_large P S Z (fun E => subsetMobius P E / (subsetNorm P E : ℂ)) + have hprime : ∀ i, Prime (P i) := fun i => Ideal.prime_of_isPrime (NeZero.ne (P i)) inferInstance + have he := primeSubset_moebius_norm_sum P hprime hinj S + change (∑ E ∈ S.powerset, subsetMobius P E / (subsetNorm P E : ℂ)) = _ at he + rw [he] at hs + linear_combination (X : ℂ) * paperRadialFourier W 0 * hs + +end + +local notation "O" => ActualEisensteinCubic.O +open ActualEisensteinCubic ConcreteTraceCRT EisensteinSchwartzPoisson + +def middleDivisors {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) (S : Finset ι) (Y Z : ℝ) := + (smallDivisors P S Z).filter (fun E => Y < subsetNorm P E) + +def dualNear (W : ℝ → ℂ) (X lengthScale : ℝ) : ℂ := + ∑' h : O, if ‖eisEmbedding h‖ ^ 2 ≤ lengthScale then + (if h = 0 then 0 else paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2)) else 0 + +def dualFar (W : ℝ → ℂ) (X lengthScale : ℝ) : ℂ := + ∑' h : O, if lengthScale < ‖eisEmbedding h‖ ^ 2 then + (if h = 0 then 0 else paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2)) else 0 + +theorem radialDual_summable (W : 𝓢(ℝ, ℂ)) (X : ℝ) (hX : 0 < X) : + Summable (fun h : O => if h = 0 then 0 else paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2)) := by + have hs := (paperRadialFourier_lattice_summable_norm W X hX).of_norm + convert hs.indicator {z : O | z ≠ 0} using 1 + ext z + by_cases hz : z = 0 <;> simp [hz] + +theorem radialDual_near_add_far (W : 𝓢(ℝ, ℂ)) (X lengthScale : ℝ) (hX : 0 < X) : + radialDual W X = dualNear W X lengthScale + dualFar W X lengthScale := by + have hs := radialDual_summable W X hX + have hn : Summable (fun h : O => if ‖eisEmbedding h‖ ^ 2 ≤ lengthScale then + (if h = 0 then 0 else paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2)) else 0) := by + exact hs.indicator {h : O | ‖eisEmbedding h‖ ^ 2 ≤ lengthScale} + have hf : Summable (fun h : O => if lengthScale < ‖eisEmbedding h‖ ^ 2 then + (if h = 0 then 0 else paperRadialFourier W (X * ‖eisEmbedding h‖ ^ 2)) else 0) := by + exact hs.indicator {h : O | lengthScale < ‖eisEmbedding h‖ ^ 2} + unfold radialDual dualNear dualFar + rw [← hn.tsum_add hf] + apply tsum_congr + intro h + by_cases hL : ‖eisEmbedding h‖ ^ 2 ≤ lengthScale <;> simp [hL, not_lt_of_ge, lt_of_not_ge] + +theorem sum_small_add_middle {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) + (S : Finset ι) (Y Z : ℝ) (hYZ : Y ≤ Z) (f : Finset ι → ℂ) : + (∑ E ∈ smallDivisors P S Y, f E) + (∑ E ∈ middleDivisors P S Y Z, f E) = + ∑ E ∈ smallDivisors P S Z, f E := by + have hsmall : (smallDivisors P S Z).filter (fun E => subsetNorm P E ≤ Y) = + smallDivisors P S Y := by + ext E + simp only [Finset.mem_filter, smallDivisors] + constructor + · rintro ⟨⟨hE, hEZ⟩, hEY⟩ + exact ⟨hE, hEY⟩ + · rintro ⟨hE, hEY⟩ + exact ⟨⟨hE, hEY.trans hYZ⟩, hEY⟩ + have hs := Finset.sum_filter_add_sum_filter_not (smallDivisors P S Z) + (fun E => subsetNorm P E ≤ Y) f + rw [hsmall] at hs + simpa only [middleDivisors, not_le] using hs + +theorem masked_radialSource_five_pieces {ι : Type*} [DecidableEq ι] + (P : ι → Ideal O) [∀ i, (P i).IsMaximal] (hinj : Function.Injective P) + (S : Finset ι) (W : 𝓢(ℝ, ℂ)) (X Y Z lengthScale : ℝ) (hX : 0 < X) (hYZ : Y ≤ Z) : + (∑' z : O, rowCoprimeMask P S z * + (if z = 0 then 0 else W (‖eisEmbedding z‖ ^ 2 / X))) = + (X : ℂ) * paperRadialFourier W 0 * + (∏ i ∈ S, (1 - (1 : ℂ) / Ideal.absNorm (P i))) - + (X : ℂ) * paperRadialFourier W 0 * + (∑ E ∈ largeDivisors P S Z, subsetMobius P E / (subsetNorm P E : ℂ)) - + W 0 * (∑ E ∈ smallDivisors P S Z, subsetMobius P E) + + (X : ℂ) * (∑ E ∈ middleDivisors P S Y Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * dualNear W (X / subsetNorm P E) lengthScale) + + (X : ℂ) * (∑ E ∈ smallDivisors P S Y, + (subsetMobius P E / (subsetNorm P E : ℂ)) * radialDual W (X / subsetNorm P E)) + + (X : ℂ) * (∑ E ∈ middleDivisors P S Y Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * dualFar W (X / subsetNorm P E) lengthScale) + + (∑ E ∈ largeDivisors P S Z, subsetMobius P E * radialSource W (X / subsetNorm P E)) := by + rw [masked_radialSource_truncated_euler P hinj S W X Z hX] + have hs := sum_small_add_middle P S Y Z hYZ (fun E => + (subsetMobius P E / (subsetNorm P E : ℂ)) * radialDual W (X / subsetNorm P E)) + rw [← hs] + have hm : (∑ E ∈ middleDivisors P S Y Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * radialDual W (X / subsetNorm P E)) = + (∑ E ∈ middleDivisors P S Y Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * dualNear W (X / subsetNorm P E) lengthScale) + + (∑ E ∈ middleDivisors P S Y Z, + (subsetMobius P E / (subsetNorm P E : ℂ)) * dualFar W (X / subsetNorm P E) lengthScale) := by + rw [← Finset.sum_add_distrib] + apply Finset.sum_congr rfl + intro E hE + rw [radialDual_near_add_far W _ lengthScale (div_pos hX (subsetNorm_pos P E)), mul_add] + rw [hm] + ring + +end TruncatedPrincipalPoisson + +namespace EisensteinSchwartzPoisson +open ConcreteTraceCRT + +theorem radial_source_nonzero_lattice_decay (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(ℝ, ℂ)) (K : ℝ), 1 ≤ K → + (∑' h : {h : O // h ≠ 0}, ‖W (K * ‖eisEmbedding h.val‖ ^ 2)‖) ≤ + (C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / (1 + K) ^ A := by + let s : Finset (ℕ × ℕ) := Finset.Iic (A + 2, 0) + let C : ℝ := 2 ^ (A + 2) * (eisensteinCauchyMass + 1) + have hC : 0 < C := by + have hm := eisensteinCauchyMass_nonneg + dsimp [C] + positivity + refine ⟨s, C, hC, ?_⟩ + intro W K hK + have hK0 : 0 < K := lt_of_lt_of_le zero_lt_one hK + let B : ℝ := 2 ^ (A + 2) * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W + have hB : 0 ≤ B := by dsimp [B]; positivity + have hb (q : ℝ) (hq : 0 ≤ q) : (1 + q) ^ (A + 2) * ‖W q‖ ≤ B := by + have hh := SchwartzMap.one_add_le_sup_seminorm_apply (𝕜 := ℝ) + (m := (A + 2, 0)) (k := A + 2) (n := 0) le_rfl le_rfl W q + simp only [norm_iteratedFDeriv_zero, Real.norm_of_nonneg hq] at hh + change (1 + q) ^ (A + 2) * ‖W q‖ ≤ B at hh + exact hh + have hp (h : {h : O // h ≠ 0}) : ‖W (K * ‖eisEmbedding h.val‖ ^ 2)‖ ≤ + (B / (1 + K) ^ A) * ((1 + ‖eisEmbedding h.val‖ ^ 2) ^ 2)⁻¹ := by + have hq : K ≤ K * ‖eisEmbedding h.val‖ ^ 2 := by + nlinarith [one_le_eisenstein_norm_sq h.val h.property] + have hh := polynomial_tail_majorant A K K (‖eisEmbedding h.val‖ ^ 2) B + ‖W (K * ‖eisEmbedding h.val‖ ^ 2)‖ hK0 hK0.le (sq_nonneg _) (norm_nonneg _) hq + (hb _ (by positivity)) + simpa only [min_eq_left hK, one_pow, one_mul] using hh + have hmajor := (eisenstein_cauchy_summable.subtype (fun h => h ≠ 0)).mul_left + (B / (1 + K) ^ A) + have hs : Summable (fun h : {h : O // h ≠ 0} => ‖W (K * ‖eisEmbedding h.val‖ ^ 2)‖) := + Summable.of_nonneg_of_le (fun _ => norm_nonneg _) hp hmajor + calc + _ ≤ ∑' h : {h : O // h ≠ 0}, + (B / (1 + K) ^ A) * ((1 + ‖eisEmbedding h.val‖ ^ 2) ^ 2)⁻¹ := + hs.tsum_le_tsum hp hmajor + _ = (B / (1 + K) ^ A) * ∑' h : {h : O // h ≠ 0}, + ((1 + ‖eisEmbedding h.val‖ ^ 2) ^ 2)⁻¹ := tsum_mul_left + _ ≤ (B / (1 + K) ^ A) * eisensteinCauchyMass := + mul_le_mul_of_nonneg_left (eisensteinCauchyMass_subtype {h : O | h ≠ 0}) (by positivity) + _ ≤ (B / (1 + K) ^ A) * (eisensteinCauchyMass + 1) := by + gcongr + linarith + _ = _ := by dsimp [B, C]; ring + +end EisensteinSchwartzPoisson + +open scoped BigOperators Classical SchwartzMap +namespace TruncatedPrincipalPoisson +local notation "O" => ActualEisensteinCubic.O +open ActualEisensteinCubic ConcreteTraceCRT EisensteinSchwartzPoisson + +private theorem zero_removed_tsum (f : O → ℂ) : + (∑' h : O, if h = 0 then 0 else f h) = ∑' h : {h : O // h ≠ 0}, f h.val := by + rw [← tsum_subtype_eq_of_support_subset (s := {h : O | h ≠ 0}) (by + intro h hh hz + subst h + exact hh (by simp))] + apply tsum_congr + intro h + simp only [ite_eq_right h.property] + +theorem radialSource_inverse_decay (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(ℝ, ℂ)) (K : ℝ), 1 ≤ K → + ‖radialSource W K⁻¹‖ ≤ + (C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / (1 + K) ^ A := by + obtain ⟨s, C, hC, hb⟩ := radial_source_nonzero_lattice_decay A + refine ⟨s, C, hC, ?_⟩ + intro W K hK + have hK0 : 0 < K := lt_of_lt_of_le zero_lt_one hK + have hs : Summable (fun h : O => W (K * ‖eisEmbedding h‖ ^ 2)) := by + simpa only [scaledRadialTest_apply, div_inv_eq_mul, mul_comm] using + (actual_eisenstein_summable_norm (scaledRadialTest W K⁻¹ (inv_pos.mpr hK0))).of_norm + unfold radialSource + rw [zero_removed_tsum] + simp only [div_inv_eq_mul, mul_comm (‖eisEmbedding _‖ ^ 2) K] + exact (norm_tsum_le_tsum_norm (hs.norm.subtype _)).trans (hb W K hK) + +theorem radialDual_decay (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (W : 𝓢(ℝ, ℂ)) (K : ℝ), 1 ≤ K → + ‖radialDual W K‖ ≤ + (C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / (1 + K) ^ A := by + obtain ⟨s, C, hC, hb⟩ := paperRadialFourier_lattice_tail A + refine ⟨s, C, hC, ?_⟩ + intro W K hK + have hK0 : 0 < K := lt_of_lt_of_le zero_lt_one hK + have hs := paperRadialFourier_lattice_summable_norm W K hK0 + let f : {h : O // h ≠ 0} → {h : O // K ≤ K * ‖eisEmbedding h‖ ^ 2} := + fun h => ⟨h.val, by nlinarith [one_le_eisenstein_norm_sq h.val h.property]⟩ + have hf : Function.Injective f := by + intro a b hab + exact Subtype.ext (congrArg (fun z : {h : O // K ≤ K * ‖eisEmbedding h‖ ^ 2} => z.val) hab) + have hi : (∑' h : {h : O // h ≠ 0}, ‖paperRadialFourier W (K * ‖eisEmbedding h.val‖ ^ 2)‖) ≤ + ∑' h : {h : O // K ≤ K * ‖eisEmbedding h‖ ^ 2}, ‖paperRadialFourier W (K * ‖eisEmbedding h.val‖ ^ 2)‖ := + (hs.subtype _).tsum_le_tsum_of_inj f hf (fun _ _ => norm_nonneg _) (fun _ => le_rfl) (hs.subtype _) + have ht := hb W K K hK0 hK0.le + simp only [min_eq_left hK, one_pow, one_mul] at ht + unfold radialDual + rw [zero_removed_tsum] + exact (norm_tsum_le_tsum_norm (hs.subtype _)).trans (hi.trans ht) + +theorem subsetMobius_norm_le_one {ι : Type*} (P : ι → Ideal O) (E : Finset ι) : + ‖subsetMobius P E‖ ≤ 1 := QuadraticInitialBound.norm_ideal_moebius_le_one _ + +private theorem scale_tail_bound (A : ℕ) (B x Y X : ℝ) + (hB : 0 ≤ B) (hx : 0 < x) (hxY : x ≤ Y) (hX : 0 < X) : + (X / x) * (B / (1 + X / x) ^ (A + 1)) ≤ B * (Y / X) ^ A := by + have hu : 0 < X / x := div_pos hX hx + calc + _ ≤ (X / x) * (B / (X / x) ^ (A + 1)) := by + apply mul_le_mul_of_nonneg_left _ hu.le + exact div_le_div_of_nonneg_left hB (pow_pos hu _) (pow_le_pow_left₀ hu.le (by linarith) _) + _ = B * (x / X) ^ A := by + simp only [div_pow, pow_succ] + field_simp + + _ ≤ B * (Y / X) ^ A := by gcongr + +private theorem norm_sum_subsets_le {ι : Type*} [DecidableEq ι] + (S : Finset ι) (T : Finset (Finset ι)) (hT : T ⊆ S.powerset) (f : Finset ι → ℂ) + (B : ℝ) (hB : 0 ≤ B) (hf : ∀ E ∈ T, ‖f E‖ ≤ B) : + ‖∑ E ∈ T, f E‖ ≤ (2 : ℝ) ^ S.card * B := by + calc + _ ≤ ∑ E ∈ T, ‖f E‖ := norm_sum_le _ _ + _ ≤ ∑ E ∈ T, B := Finset.sum_le_sum hf + _ = (T.card : ℝ) * B := by simp + _ ≤ (2 : ℝ) ^ S.card * B := by + apply mul_le_mul_of_nonneg_right _ hB + have hc := Finset.card_le_card hT + rw [Finset.card_powerset] at hc + exact_mod_cast hc + +theorem small_divisor_dual_tail (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (S : Finset ι) (W : 𝓢(ℝ, ℂ)) (X Y : ℝ), 0 < X → 0 ≤ Y → Y ≤ X → + ‖(X : ℂ) * ∑ E ∈ smallDivisors P S Y, + (subsetMobius P E / (subsetNorm P E : ℂ)) * radialDual W (X / subsetNorm P E)‖ ≤ + (2 : ℝ) ^ S.card * (C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) * (Y / X) ^ A := by + obtain ⟨s, C, hC, hb⟩ := radialDual_decay (A + 1) + refine ⟨s, C, hC, ?_⟩ + intro ι _ P _ S W X Y hX hY hYX + let B := C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W + have hB : 0 ≤ B := by dsimp [B]; positivity + rw [Finset.mul_sum] + have hf (E : Finset ι) (hE : E ∈ smallDivisors P S Y) : + ‖(X : ℂ) * ((subsetMobius P E / (subsetNorm P E : ℂ)) * + radialDual W (X / subsetNorm P E))‖ ≤ B * (Y / X) ^ A := by + have hn := subsetNorm_pos P E + have hEY : subsetNorm P E ≤ Y := (Finset.mem_filter.mp hE).2 + have hscale : 1 ≤ X / subsetNorm P E := (le_div_iff₀ hn).mpr (by simpa using hEY.trans hYX) + calc + _ = (X / subsetNorm P E) * ‖subsetMobius P E‖ * ‖radialDual W (X / subsetNorm P E)‖ := by + simp only [norm_mul, norm_div, Complex.norm_real, Real.norm_eq_abs, + abs_of_pos hX, abs_of_pos hn] + ring + _ ≤ (X / subsetNorm P E) * 1 * (B / (1 + X / subsetNorm P E) ^ (A + 1)) := by + gcongr + · exact subsetMobius_norm_le_one P E + · exact hb W _ hscale + _ ≤ B * (Y / X) ^ A := by + simpa only [mul_one] using scale_tail_bound A B (subsetNorm P E) Y X hB hn hEY hX + exact (norm_sum_subsets_le S _ (Finset.filter_subset _ _) _ _ (by positivity) hf).trans_eq (by ring) + +theorem large_divisor_source_tail (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ {ι : Type*} [DecidableEq ι] (P : ι → Ideal O) [∀ i, (P i).IsMaximal] + (S : Finset ι) (W : 𝓢(ℝ, ℂ)) (X Z : ℝ), 0 < X → X ≤ Z → + ‖∑ E ∈ largeDivisors P S Z, + subsetMobius P E * radialSource W (X / subsetNorm P E)‖ ≤ + (2 : ℝ) ^ S.card * (C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) / + (1 + Z / X) ^ A := by + obtain ⟨s, C, hC, hb⟩ := radialSource_inverse_decay A + refine ⟨s, C, hC, ?_⟩ + intro ι _ P _ S W X Z hX hXZ + let B := C * s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W + have hB : 0 ≤ B := by dsimp [B]; positivity + have hZ : 0 < Z := hX.trans_le hXZ + have hf (E : Finset ι) (hE : E ∈ largeDivisors P S Z) : + ‖subsetMobius P E * radialSource W (X / subsetNorm P E)‖ ≤ B / (1 + Z / X) ^ A := by + have hn := subsetNorm_pos P E + have hEZ : Z < subsetNorm P E := (Finset.mem_filter.mp hE).2 + have hscale : 1 ≤ subsetNorm P E / X := (le_div_iff₀ hX).mpr (by simpa using hXZ.trans hEZ.le) + have hh := hb W (subsetNorm P E / X) hscale + rw [inv_div] at hh + calc + _ = ‖subsetMobius P E‖ * ‖radialSource W (X / subsetNorm P E)‖ := norm_mul _ _ + _ ≤ 1 * (B / (1 + subsetNorm P E / X) ^ A) := + mul_le_mul (subsetMobius_norm_le_one P E) hh (norm_nonneg _) (by norm_num) + _ ≤ B / (1 + Z / X) ^ A := by + simp only [one_mul] + apply div_le_div_of_nonneg_left hB (by positivity) + exact pow_le_pow_left₀ (by positivity) (by gcongr) A + exact (norm_sum_subsets_le S _ (Finset.filter_subset _ _) _ _ (by positivity) hf).trans_eq (by ring) + +end TruncatedPrincipalPoisson + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/QuotientTopology.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/QuotientTopology.lean new file mode 100644 index 0000000000000000000000000000000000000000..0cb1d987d6def1945bda2445736007c8c79078d8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/QuotientTopology.lean @@ -0,0 +1,738 @@ +import OAI.NumberTheory.DirichletL.QuadraticSieve.HighKernelGeometry + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open CubicKubota +local notation "O" => ActualEisensteinCubic.O + +instance complexSLTopology : TopologicalSpace (SL(2,ℂ)) := + inferInstanceAs (TopologicalSpace {A : Matrix (Fin 2) (Fin 2) ℂ // A.det=1}) + +lemma continuous_complexSL_coe : + Continuous (fun g : SL(2,ℂ) => (g : Matrix (Fin 2) (Fin 2) ℂ)) := + continuous_subtype_val + +lemma continuous_complexSL_mul (g : SL(2,ℂ)) : + Continuous (fun h : SL(2,ℂ) => g*h) := by + apply Continuous.subtype_mk + change Continuous (fun h : SL(2,ℂ) => + (g : Matrix (Fin 2) (Fin 2) ℂ)*(h : Matrix (Fin 2) (Fin 2) ℂ)) + exact continuous_const.mul continuous_complexSL_coe + +lemma continuous_coordinateSection : Continuous coordinateSection := by + apply Continuous.subtype_mk + apply continuous_pi + intro i + apply continuous_pi + intro j + have hroot : Continuous (fun w : UpperCoordinates => (Real.sqrt w.1.2 : ℂ)) := + Complex.continuous_ofReal.comp (Real.continuous_sqrt.comp + (continuous_snd.comp continuous_subtype_val)) + have hne : ∀w : UpperCoordinates,(Real.sqrt w.1.2 : ℂ)≠0 := fun w => + Complex.ofReal_ne_zero.mpr (Real.sqrt_pos.mpr w.2).ne' + fin_cases i <;> fin_cases j + · exact hroot + · exact (continuous_fst.comp continuous_subtype_val).div hroot hne + · exact continuous_const + · exact hroot.inv₀ hne + +lemma continuous_hyperbolicProjection : + Continuous (fun g : SL(2,ℂ) => (g : HyperbolicSpace)) := + continuous_quotient_mk' + +lemma continuous_upperCoordinates : + Continuous (fun w : UpperCoordinates => upperPoint w.1.1 w.1.2 w.2) := + continuous_hyperbolicProjection.comp continuous_coordinateSection + +lemma continuous_translatedUpperCoordinates (g : SL(2,ℂ)) : + Continuous (fun w : UpperCoordinates => g • upperPoint w.1.1 w.1.2 w.2) := by + exact continuous_hyperbolicProjection.comp + ((continuous_complexSL_mul g).comp continuous_coordinateSection) + +def integralOrbitRel (H : Subgroup (SL(2,O))) : Setoid HyperbolicSpace where + r w w' := ∃h : H, integralComplexMatrix (h:SL(2,O)) • w = w' + iseqv := ⟨by intro w; exact ⟨1,by simp⟩, + by + rintro w w' ⟨h,hh⟩ + refine ⟨h⁻¹,?_⟩ + rw [←hh] + simp [←mul_smul], + by + rintro w w' w'' ⟨h,hh⟩ ⟨k,hk⟩ + refine ⟨k*h,?_⟩ + simpa only [Subgroup.coe_mul,map_mul,mul_smul,hh] using hk⟩ + +abbrev IntegralOrbitQuotient (H : Subgroup (SL(2,O))) := Quotient (integralOrbitRel H) + +def integralOrbitProjection (H : Subgroup (SL(2,O))) : + HyperbolicSpace → IntegralOrbitQuotient H := Quotient.mk _ + +lemma continuous_integralOrbitProjection (H : Subgroup (SL(2,O))) : + Continuous (integralOrbitProjection H) := continuous_quotient_mk' + +lemma integralOrbitProjection_eq (H : Subgroup (SL(2,O))) (h : H) (w : HyperbolicSpace) : + integralOrbitProjection H (integralComplexMatrix (h:SL(2,O)) • w)= + integralOrbitProjection H w := by + apply Eq.symm + exact Quotient.sound ⟨h,rfl⟩ + +end + +open CubicKubota +local notation "O" => ActualEisensteinCubic.O + +def truncatedFordLift (T : ℝ) (p : truncatedFordBox T) : UpperCoordinates := + ⟨p.1,lt_of_lt_of_le (Real.sqrt_pos.mpr (by norm_num : (0:ℝ)<2/3)) p.2.2.1⟩ + +lemma continuous_truncatedFordLift (T : ℝ) : Continuous (truncatedFordLift T) := + continuous_subtype_val.subtype_mk _ + +def fordOrbitChart (H : Subgroup (SL(2,O))) (r : SL(2,O)) (p : UpperCoordinates) : + IntegralOrbitQuotient H := integralOrbitProjection H + (integralComplexMatrix r⁻¹ • upperPoint p.1.1 p.1.2 p.2) + +lemma continuous_fordOrbitChart (H : Subgroup (SL(2,O))) (r : SL(2,O)) : + Continuous (fordOrbitChart H r) := + (continuous_integralOrbitProjection H).comp + (continuous_translatedUpperCoordinates (integralComplexMatrix r⁻¹)) + +def compactFordCore (H : Subgroup (SL(2,O))) (S : Finset (SL(2,O))) (T : ℝ) : + Set (IntegralOrbitQuotient H) := + ⋃r∈S, Set.range (fun p : truncatedFordBox T => fordOrbitChart H r (truncatedFordLift T p)) + +lemma compactFordCore_isCompact (H : Subgroup (SL(2,O))) (S : Finset (SL(2,O))) (T : ℝ) : + IsCompact (compactFordCore H S T) := by + let : CompactSpace (truncatedFordBox T) := + isCompact_iff_compactSpace.mp (truncatedFordBox_isCompact T) + apply S.isCompact_biUnion + intro r hr + exact isCompact_range ((continuous_fordOrbitChart H r).comp (continuous_truncatedFordLift T)) + +def fordCuspTail (H : Subgroup (SL(2,O))) (r : SL(2,O)) (T : ℝ) : + Set (IntegralOrbitQuotient H) := + fordOrbitChart H r '' {p : UpperCoordinates | Complex.normSq p.1.1≤1/3 ∧ + Real.sqrt (2/3)≤p.1.2 ∧ T ⟨compactFordCore_isCompact H S T,?_⟩⟩ + apply Set.Subset.antisymm + · intro q hq + induction q using Quotient.inductionOn with | _ w => + obtain ⟨h,r,hr,z,v,hv,heq,hz,hfloor⟩ := hS w + have hqeq : integralOrbitProjection H w=fordOrbitChart H r ⟨(z,v),hv⟩ := by + rw [←integralOrbitProjection_eq H h w,heq] + rfl + change integralOrbitProjection H w∈_ + rw [hqeq] + by_cases hT : v≤T + · apply Or.inl + apply Set.mem_iUnion.mpr + refine ⟨r,Set.mem_iUnion.mpr ⟨hr,?_⟩⟩ + exact ⟨⟨(z,v),mem_truncatedFordBox z v T hz hfloor hT⟩,rfl⟩ + · apply Or.inr + apply Set.mem_iUnion.mpr + refine ⟨r,Set.mem_iUnion.mpr ⟨hr,?_⟩⟩ + exact ⟨⟨(z,v),hv⟩,⟨hz,hfloor,lt_of_not_ge hT⟩,rfl⟩ + · exact Set.subset_univ _ + +theorem levelThree_compact_core_cusp_cover : + ∃S : Finset (SL(2,O)), ∀T : ℝ, + IsCompact (compactFordCore levelThree S T) ∧ + Set.univ=compactFordCore levelThree S T ∪ ⋃r∈S, fordCuspTail levelThree r T := by + let : levelThree.FiniteIndex := levelThree_finiteIndex + exact finiteIndex_compact_core_cusp_cover levelThree + +theorem globalKubotaKernel_compact_core_cusp_cover : + ∃S : Finset (SL(2,O)), ∀T : ℝ, + IsCompact (compactFordCore globalKubotaKernel S T) ∧ + Set.univ=compactFordCore globalKubotaKernel S T ∪ ⋃r∈S, fordCuspTail globalKubotaKernel r T := by + let : globalKubotaKernel.FiniteIndex := globalKubotaKernel_finiteIndex + exact finiteIndex_compact_core_cusp_cover globalKubotaKernel + +end CubicEisenstein + +namespace SecondPassArithmetic + +section + +open scoped BigOperators Classical SchwartzMap FourierTransform +open MeasureTheory + +section +open ActualEisensteinCubic +open SecondPassFiber (newLabel newRow) +open SecondPassIntegration (tupleSourceSum densityChildEnergy) +open JointLogSeparation (outerWindow) + +local instance {ι : Type*} : Nonempty (GlobalSecondData ι) := + ⟨⟨⟨0,0,∅,∅⟩,∅,∅,∅,⟨∅,∅,∅,0⟩⟩⟩ + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,lambda ∉ Ideal.span {p i}) + +def globalSecondRecover (s : Finset (GlobalSecondData ι)) : SecondPassFiber.OldTuple → GlobalSecondData ι := + Function.invFunOn (globalSecondTuple p) s + +theorem globalSecondRecover_apply + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (s : Finset (GlobalSecondData ι)) (q : Ideal O × Ideal O × Ideal O) + (hs : ∀ x∈s,GlobalSecondAdmissible x) (hq : ∀ x∈s,globalSecondFixedTriple p x=q) + (x : GlobalSecondData ι) (hx : x∈s) : + globalSecondRecover p s (globalSecondTuple p x)=x := by + have hi : Set.InjOn (globalSecondTuple p) s := by + intro x hx y hy h + exact globalSecondEncoding_injective p hinj (hs x hx) (hs y hy) ((hq x hx).trans (hq y hy).symm) h + exact hi.leftInvOn_invFunOn hx + +def globalSecondSource (s : Finset (GlobalSecondData ι)) (w : GlobalSecondData ι → ℂ) + (F : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) (A₁ A₂ W : 𝓢(ℝ,ℂ)) + (V : Fin 7 → ℝ → ℂ) (z ud ue uv kap : GlobalSecondData ι → ℝ) (X₁ X₂ R : ℝ) : ℂ := + ∑ x∈s,w x * postCommonSmoothPair p hp hcop hg F Ψ₁ Ψ₂ m (globalSecondLabel p x) + (newRow (globalSecondTuple p x)) (-newRow (globalSecondTuple p x)) A₁ A₂ W V + (z x) (ud x) (ue x) (uv x) (kap x) X₁ X₂ R + +theorem globalSecondSource_eq_tupleSource + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (s : Finset (GlobalSecondData ι)) (q : Ideal O × Ideal O × Ideal O) + (hs : ∀ x∈s,GlobalSecondAdmissible x) (hq : ∀ x∈s,globalSecondFixedTriple p x=q) + (w : GlobalSecondData ι → ℂ) (F : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) + (A₁ A₂ W : 𝓢(ℝ,ℂ)) (V : Fin 7 → ℝ → ℂ) + (z ud ue uv kap : GlobalSecondData ι → ℝ) (X₁ X₂ R : ℝ) : + globalSecondSource p hp hcop hg s w F Ψ₁ Ψ₂ m A₁ A₂ W V z ud ue uv kap X₁ X₂ R = + tupleSourceSum p hp hcop hg (s.image (globalSecondTuple p)) + (w ∘ globalSecondRecover p s) (globalSecondLabel p ∘ globalSecondRecover p s) + F Ψ₁ Ψ₂ m A₁ A₂ W V (z ∘ globalSecondRecover p s) (ud ∘ globalSecondRecover p s) + (ue ∘ globalSecondRecover p s) (uv ∘ globalSecondRecover p s) (kap ∘ globalSecondRecover p s) X₁ X₂ R := by + unfold globalSecondSource tupleSourceSum + rw [Finset.sum_image] + · apply Finset.sum_congr rfl + intro x hx + simp only [Function.comp_apply,globalSecondRecover_apply p hinj s q hs hq x hx] + · intro x hx y hy he + exact globalSecondEncoding_injective p hinj (hs x hx) (hs y hy) ((hq x hx).trans (hq y hy).symm) he + +theorem globalSecondSource_uniform_transfer + (hinj : Function.Injective (fun i => Ideal.span {p i})) (ε : ℝ) (hε : 0 < ε) + (A₁ A₂ W : 𝓢(ℝ,ℂ)) (V : Fin 7 → ℝ → ℂ) (M : Fin 7 → ℝ) + (hM : ∀ i,0 ≤ M i) (hV : ∀ i x,V i x ≠ 0 → |x| ≤ M i) (A J : ℕ) : + ∃ Cₐ : ℝ,0 < Cₐ ∧ ∃ Cₛ : ℝ,0 ≤ Cₛ ∧ + ∀ (R : ℝ),0 < R → ∀ (s : Finset (GlobalSecondData ι)) (T : Finset (Ideal O × O)) + (q : Ideal O × Ideal O × Ideal O) (w : GlobalSecondData ι → ℂ) (B lengthScale : ℝ) + (F : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) + (z ud ue uv kap : GlobalSecondData ι → ℝ) (X₁ X₂ : ℝ), + q.1 ≠ ⊥ → 0 ≤ B → 0 ≤ lengthScale → + (∀ x∈s,GlobalSecondAdmissible x) → (∀ x∈s,globalSecondFixedTriple p x=q) → + (∀ x∈s,(newLabel (globalSecondTuple p x),newRow (globalSecondTuple p x))∈T) → + (∀ a∈T,a.1 ≠ ⊥) → (∀ a∈T,(Ideal.absNorm a.1 : ℝ) ≤ lengthScale) → + (∀ x∈s,‖w x‖*‖outerWindow V (z x) (ud x) (ue x) (uv x) (kap x)‖ ≤ B) → + ‖globalSecondSource p hp hcop hg s w F Ψ₁ Ψ₂ (fixedTripleMask m q) + A₁ A₂ W V z ud ue uv kap X₁ X₂ R‖ ≤ + (B*Cₐ*(lengthScale*Ideal.absNorm q.1)^ε) * (Cₛ/(1+R)^A) * + densityChildEnergy p hp hcop hg F Ψ₁ Ψ₂ (fixedTripleMask m q) T (V 5) (V 6) X₁ X₂ J := by + obtain ⟨Cₐ,hCₐ,Cₛ,hCₛ,htransfer⟩ := SecondPassIntegration.tupleSource_uniform_transfer p hp hcop hg + ε hε A₁ A₂ W V M hM hV A J + refine ⟨Cₐ,hCₐ,Cₛ,hCₛ,?_⟩ + intro R hR s T q w B lengthScale F Ψ₁ Ψ₂ m z ud ue uv kap X₁ X₂ hq hB hL hs hfixed hmap ht hn hw + obtain ⟨b,hb,htrans⟩ := htransfer R hR + let r := globalSecondRecover p s + have hr (x : GlobalSecondData ι) (hx : x∈s) : r (globalSecondTuple p x)=x := + globalSecondRecover_apply p hinj s q hs hfixed x hx + have hvalid : ∀ y∈s.image (globalSecondTuple p), + SecondPassFiber.Valid y (newLabel y) q.1 (newRow y) := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + have hv := globalSecondTuple_valid p x (hs x hx) + simpa only [hfixed x hx] using hv + have hmap' : ∀ y∈s.image (globalSecondTuple p),(newLabel y,newRow y)∈T := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + exact hmap x hx + have hw' : ∀ y∈s.image (globalSecondTuple p), + ‖(w ∘ r) y‖*‖outerWindow V ((z ∘ r) y) ((ud ∘ r) y) ((ue ∘ r) y) ((uv ∘ r) y) ((kap ∘ r) y)‖ ≤ B := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + simpa only [Function.comp_apply,hr x hx] using hw x hx + have hlabel : ∀ y∈s.image (globalSecondTuple p),Ideal.span {(globalSecondLabel p ∘ r) y}=newLabel y := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + simpa only [Function.comp_apply,hr x hx] using globalSecondLabel_span p x + have hh := htrans (s.image (globalSecondTuple p)) T q.1 (w ∘ r) B lengthScale (globalSecondLabel p ∘ r) + F Ψ₁ Ψ₂ (fixedTripleMask m q) (z ∘ r) (ud ∘ r) (ue ∘ r) (uv ∘ r) (kap ∘ r) X₁ X₂ + hq hB hL hvalid hmap' ht hn hw' hlabel + rw [← globalSecondSource_eq_tupleSource p hp hcop hg hinj s q hs hfixed] at hh + apply hh.trans + have hd := SecondPassIntegration.child_coefficient_density_bound p hp hcop hg F Ψ₁ Ψ₂ + (fixedTripleMask m q) T (V 5) (V 6) X₁ X₂ (𝓕 A₁) (𝓕 A₂) b J ((1+R)^A) Cₛ hb + have hpow : 0 < (1+R)^A := pow_pos (by linarith) _ + have hi := (le_div_iff₀' hpow).mpr hd + have hnn : 0 ≤ B*Cₐ*(lengthScale*Ideal.absNorm q.1)^ε := by positivity + have hbnd := mul_le_mul_of_nonneg_left hi hnn + convert hbnd using 1 ; ring + +end + +open ActualEisensteinCubic +open FirstPassCubeLabels (b0Label) +open SecondPassFiber (newLabel newRow) +open SecondPassIntegration (densityChildEnergy) +open JointLogSeparation (outerWindow) + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i,lambda ∉ Ideal.span {p i}) + +def globalSecondRawPool (F : Finset ι) (x : GlobalSecondData ι) : Finset ι := + (F\(x.cube.support∪x.common))\x.firstCommon + +def globalSecondRawMask (m : O) (x : GlobalSecondData ι) : O := + m*b0Label p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit * + primeSubsetGenerator (fun i => Ideal.span {p i}) (x.source.sourceCommon\x.source.divisor) + +def globalSecondRawSource (s : Finset (GlobalSecondData ι)) (w : GlobalSecondData ι → ℂ) + (F : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) (A₁ A₂ W : 𝓢(ℝ,ℂ)) + (V : Fin 7 → ℝ → ℂ) (z ud ue uv kap : GlobalSecondData ι → ℝ) (X₁ X₂ R : ℝ) : ℂ := + ∑ x∈s,w x * postCommonSmoothPair p hp hcop hg (globalSecondRawPool F x) Ψ₁ Ψ₂ + (globalSecondRawMask p m x) (globalSecondLabel p x) + (newRow (globalSecondTuple p x)) (-newRow (globalSecondTuple p x)) A₁ A₂ W V + (z x) (ud x) (ue x) (uv x) (kap x) X₁ X₂ R + +theorem globalSecondRawSource_eq + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (A₁ A₂ W : 𝓢(ℝ,ℂ)) (V : Fin 7 → ℝ → ℂ) (M : Fin 7 → ℝ) + (hM : ∀ i,0 ≤ M i) (hV : ∀ i x,V i x ≠ 0 → |x| ≤ M i) + (s : Finset (GlobalSecondData ι)) (w : GlobalSecondData ι → ℂ) + (q : Ideal O × Ideal O × Ideal O) (hfixed : ∀ x∈s,globalSecondFixedTriple p x=q) + (F : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) + (z ud ue uv kap : GlobalSecondData ι → ℝ) (X₁ X₂ R : ℝ) (hR : 0 < R) : + globalSecondRawSource p hp hcop hg s w F Ψ₁ Ψ₂ m A₁ A₂ W V z ud ue uv kap X₁ X₂ R = + globalSecondSource p hp hcop hg s w F Ψ₁ Ψ₂ (fixedTripleMask m q) + A₁ A₂ W V z ud ue uv kap X₁ X₂ R := by + obtain ⟨C,hC,hsep⟩ := postCommonSmoothPair_uniform_fixed_tests p hp hcop hg A₁ A₂ W V M hM hV 0 0 + obtain ⟨b,hb,hid⟩ := hsep R hR + unfold globalSecondRawSource globalSecondSource + apply Finset.sum_congr rfl + intro x hx + apply congrArg (fun a : ℂ => w x * a) + rw [hid (globalSecondRawPool F x) Ψ₁ Ψ₂ (globalSecondRawMask p m x) (globalSecondLabel p x) + (newRow (globalSecondTuple p x)) (-newRow (globalSecondTuple p x)) + (z x) (ud x) (ue x) (uv x) (kap x) X₁ X₂, + hid F Ψ₁ Ψ₂ (fixedTripleMask m q) (globalSecondLabel p x) + (newRow (globalSecondTuple p x)) (-newRow (globalSecondTuple p x)) + (z x) (ud x) (ue x) (uv x) (kap x) X₁ X₂] + simp only [separatedPostCommon,globalSecondRawPool,globalSecondRawMask, + globalSecondRawRow_fixed_pool p hp hcop hg hinj,hfixed x hx] + +theorem globalSecondRawSource_uniform_transfer + (hinj : Function.Injective (fun i => Ideal.span {p i})) (ε : ℝ) (hε : 0 < ε) + (A₁ A₂ W : 𝓢(ℝ,ℂ)) (V : Fin 7 → ℝ → ℂ) (M : Fin 7 → ℝ) + (hM : ∀ i,0 ≤ M i) (hV : ∀ i x,V i x ≠ 0 → |x| ≤ M i) (A J : ℕ) : + ∃ Cₐ : ℝ,0 < Cₐ ∧ ∃ Cₛ : ℝ,0 ≤ Cₛ ∧ + ∀ (R : ℝ),0 < R → ∀ (s : Finset (GlobalSecondData ι)) (T : Finset (Ideal O × O)) + (q : Ideal O × Ideal O × Ideal O) (w : GlobalSecondData ι → ℂ) (B lengthScale : ℝ) + (F : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) + (z ud ue uv kap : GlobalSecondData ι → ℝ) (X₁ X₂ : ℝ), + q.1 ≠ ⊥ → 0 ≤ B → 0 ≤ lengthScale → + (∀ x∈s,GlobalSecondAdmissible x) → (∀ x∈s,globalSecondFixedTriple p x=q) → + (∀ x∈s,(newLabel (globalSecondTuple p x),newRow (globalSecondTuple p x))∈T) → + (∀ a∈T,a.1 ≠ ⊥) → (∀ a∈T,(Ideal.absNorm a.1 : ℝ) ≤ lengthScale) → + (∀ x∈s,‖w x‖*‖outerWindow V (z x) (ud x) (ue x) (uv x) (kap x)‖ ≤ B) → + ‖globalSecondRawSource p hp hcop hg s w F Ψ₁ Ψ₂ m + A₁ A₂ W V z ud ue uv kap X₁ X₂ R‖ ≤ + (B*Cₐ*(lengthScale*Ideal.absNorm q.1)^ε) * (Cₛ/(1+R)^A) * + densityChildEnergy p hp hcop hg F Ψ₁ Ψ₂ (fixedTripleMask m q) T (V 5) (V 6) X₁ X₂ J := by + obtain ⟨Cₐ,hCₐ,Cₛ,hCₛ,htrans⟩ := globalSecondSource_uniform_transfer p hp hcop hg hinj + ε hε A₁ A₂ W V M hM hV A J + refine ⟨Cₐ,hCₐ,Cₛ,hCₛ,?_⟩ + intro R hR s T q w B lengthScale F Ψ₁ Ψ₂ m z ud ue uv kap X₁ X₂ hq hB hL hs hfixed hmap ht hn hw + rw [globalSecondRawSource_eq p hp hcop hg hinj A₁ A₂ W V M hM hV s w q hfixed + F Ψ₁ Ψ₂ m z ud ue uv kap X₁ X₂ R hR] + exact htrans R hR s T q w B lengthScale F Ψ₁ Ψ₂ m z ud ue uv kap X₁ X₂ hq hB hL hs hfixed hmap ht hn hw + +end + +section +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm primeProduct jLabel b0Label cubeActiveSupport) +open ConcreteTraceCRT (eisEmbedding) + +namespace CubeCoordinates +def sideDivisor {ι : Type*} (x : CubeCoordinates ι) (side : Bool) : Finset ι := + if side then x.leftDivisor else x.rightDivisor +end CubeCoordinates + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + +def globalCubeJNorm (x : GlobalSecondData ι) : ℝ := + ‖eisEmbedding (jLabel p x.cube.support (fun i => x.cube.leftExponent i+x.cube.rightExponent i) + x.cube.leftBit x.cube.rightBit)‖^2 + +def globalCubeActiveRoot (x : GlobalSecondData ι) : ℝ := + ‖eisEmbedding (∏ i∈cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i)‖ + +def globalFirstColumnScale (ell : ℝ) (x : GlobalSecondData ι) (side : Bool) : ℝ := + ell/(primeProductNorm p (x.cube.sideDivisor side)*primeProductNorm p x.common) + +def globalFirstRowScale (K ell B F : ℝ) (x : GlobalSecondData ι) : ℝ := + ell^2*B^4*F^2*primeProductNorm p x.firstDivisor/ + (K*(primeProductNorm p x.common)^2*globalCubeJNorm p x) + +def globalSecondDelta (B F : ℝ) (x : GlobalSecondData ι) (side : Bool) : ℝ := + B*F*primeProductNorm p (x.cube.sideDivisor side)*primeProductNorm p x.firstCommon* + primeProductNorm p (x.source.sourceCommon\x.source.divisor) + +def globalNominalChildRow (K B F : ℝ) (x : GlobalSecondData ι) (side : Bool) : ℝ := + K*globalCubeJNorm p x/((globalSecondDelta p B F x side)^2*B^2) + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalCubeJNorm_pos (x : GlobalSecondData ι) : 0 < globalCubeJNorm p x := + zero_lt_one.trans_le (element_norm_ge_one _ (primeProduct_ne_zero p hp _ _)) + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalCubeActiveRoot_pos (x : GlobalSecondData ι) : 0 < globalCubeActiveRoot p x := by + have hh := element_norm_ge_one (∏ i∈cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i) + (Finset.prod_ne_zero_iff.mpr (fun i hi => hp i)) + change 0 < ‖eisEmbedding _‖ + nlinarith [norm_nonneg (eisEmbedding (∏ i∈cubeActiveSupport x.cube.support + (fun i => x.cube.leftExponent i+x.cube.rightExponent i) x.cube.leftBit x.cube.rightBit,p i))] + +include hp in +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalFirstColumnScale_pos (ell : ℝ) (hell : 0 < ell) (x : GlobalSecondData ι) (side : Bool) : + 0 < globalFirstColumnScale p ell x side := + div_pos hell (mul_pos (FirstPassCubeLabels.primeProductNorm_pos p hp _) (FirstPassCubeLabels.primeProductNorm_pos p hp _)) + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalSecondDelta_ge (B F : ℝ) (hB : 0 ≤ B) (hF : 1 ≤ F) (x : GlobalSecondData ι) (side : Bool) : + B ≤ globalSecondDelta p B F x side := by + have hA := primeProductNorm_ge_one p hp (x.cube.sideDivisor side) + have ht := primeProductNorm_ge_one p hp x.firstCommon + have hR := primeProductNorm_ge_one p hp (x.source.sourceCommon\x.source.divisor) + unfold globalSecondDelta + calc + B = B*1*1*1*1 := by ring + _ ≤ _ := by gcongr + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalSecondDelta_pos (B F : ℝ) (hB : 0 < B) (hF : 0 < F) (x : GlobalSecondData ι) (side : Bool) : + 0 < globalSecondDelta p B F x side := by + unfold globalSecondDelta + exact mul_pos (mul_pos (mul_pos (mul_pos hB hF) + (FirstPassCubeLabels.primeProductNorm_pos p hp _)) + (FirstPassCubeLabels.primeProductNorm_pos p hp _)) (FirstPassCubeLabels.primeProductNorm_pos p hp _) + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalBaseLabel_norm (x : GlobalSecondData ι) : + ‖eisEmbedding (secondBaseLabel p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit)‖^2 = primeProductNorm p x.common*globalCubeJNorm p x := by + simp only [secondBaseLabel,map_mul,norm_mul,mul_pow,primeSubsetGenerator_norm_eq_productNorm,globalCubeJNorm] + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalSecond_radial_ratio (K ell B F : ℝ) (hK : 0 < K) (hell : 0 < ell) + (hB : 0 < B) (hF : 0 < F) (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) : + globalFirstRowScale p K ell B F x*secondLogK j* + (primeProductNorm p (x.source.sourceCommon\x.source.divisor))^2/ + (primeProductNorm p x.firstDivisor*(globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon)^2) = + secondLogK j/globalNominalChildRow p K B F x side := by + have hC := (FirstPassCubeLabels.primeProductNorm_pos p hp x.common).ne' + have hd := (FirstPassCubeLabels.primeProductNorm_pos p hp x.firstDivisor).ne' + have ha := (FirstPassCubeLabels.primeProductNorm_pos p hp (x.cube.sideDivisor side)).ne' + have ht := (FirstPassCubeLabels.primeProductNorm_pos p hp x.firstCommon).ne' + have hr := (FirstPassCubeLabels.primeProductNorm_pos p hp (x.source.sourceCommon\x.source.divisor)).ne' + have hJ := (globalCubeJNorm_pos p hp x).ne' + unfold globalFirstRowScale globalFirstColumnScale globalNominalChildRow globalSecondDelta + field_simp + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalSecond_child_mass (ell B F : ℝ) (hell : 0 < ell) (hB : 0 < B) (hF : 0 < F) + (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) : + secondLogX p (x.source.sourceCommon\x.source.divisor) + (globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon) j * + secondLogLabelBound p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit j = + Real.exp 2*((ell*B^3)*F*globalCubeJNorm p x/(globalSecondDelta p B F x side*B^2)) := by + rw [secondLogX_label_cost,globalBaseLabel_norm] + have hC := (FirstPassCubeLabels.primeProductNorm_pos p hp x.common).ne' + have ha := (FirstPassCubeLabels.primeProductNorm_pos p hp (x.cube.sideDivisor side)).ne' + have ht := (FirstPassCubeLabels.primeProductNorm_pos p hp x.firstCommon).ne' + have hr := (FirstPassCubeLabels.primeProductNorm_pos p hp (x.source.sourceCommon\x.source.divisor)).ne' + unfold globalFirstColumnScale globalSecondDelta + field_simp + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalSecond_complete_cost (K ell B F : ℝ) (hK : 0 < K) (hell : 0 < ell) + (hB : 0 < B) (hF : 0 < F) (x : GlobalSecondData ι) (side : Bool) : + (K/(primeProductNorm p x.firstDivisor*ell*B^2*F*globalCubeActiveRoot p x)) * + (globalFirstRowScale p K ell B F x * + ‖eisEmbedding (secondBaseLabel p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit)‖^2*Real.exp 2/globalFirstColumnScale p ell x side) * + ((B*globalCubeActiveRoot p x/globalCubeJNorm p x)*primeProductNorm p x.firstCommon* + primeProductNorm p (x.source.sourceCommon\x.source.divisor)) = + Real.exp 2*globalSecondDelta p B F x side*B^2/globalCubeJNorm p x := by + rw [globalBaseLabel_norm] + have hC := (FirstPassCubeLabels.primeProductNorm_pos p hp x.common).ne' + have hd := (FirstPassCubeLabels.primeProductNorm_pos p hp x.firstDivisor).ne' + have ha := (FirstPassCubeLabels.primeProductNorm_pos p hp (x.cube.sideDivisor side)).ne' + have hJ := (globalCubeJNorm_pos p hp x).ne' + have hc := (globalCubeActiveRoot_pos p hp x).ne' + unfold globalFirstRowScale globalFirstColumnScale globalSecondDelta + field_simp + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalNominalChildRow_pos (K B F : ℝ) (hK : 0 < K) (hB : 0 < B) (hF : 0 < F) + (x : GlobalSecondData ι) (side : Bool) : 0 < globalNominalChildRow p K B F x side := by + unfold globalNominalChildRow + exact div_pos (mul_pos hK (globalCubeJNorm_pos p hp x)) + (mul_pos (sq_pos_of_pos (globalSecondDelta_pos p hp B F hB hF x side)) (sq_pos_of_pos hB)) + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalNominalChildRow_bound (K B F : ℝ) (hK : 0 < K) (hB : 0 < B) (hF : 0 < F) + (x : GlobalSecondData ι) (side : Bool) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) : + globalNominalChildRow p K B F x side ≤ K/(globalSecondDelta p B F x side)^2 := by + have hJ := (cube_label_norm_bounds p hp x.cube.support x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit x.cube.support_pos B hB.le hb₁ hb₂).1 + change globalCubeJNorm p x ≤ B^2 at hJ + unfold globalNominalChildRow + have hD := globalSecondDelta_pos p hp B F hB hF x side + calc + _ ≤ K*B^2/((globalSecondDelta p B F x side)^2*B^2) := by gcongr + _ = _ := by field_simp + +end + +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProductNorm primeProduct) +open ConcreteTraceCRT (eisEmbedding) + +section +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + +def globalChildMass (ell : ℝ) (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) : ℝ := + secondLogX p (x.source.sourceCommon\x.source.divisor) + (globalFirstColumnScale p ell x side/primeProductNorm p x.firstCommon) j * + secondLogLabelBound p x.cube.support x.common x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit j + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalChildMass_bound (ell B F : ℝ) (hell : 0 < ell) (hB : 0 < B) (hF : 0 < F) + (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) : + globalChildMass p ell x side j ≤ Real.exp 2*((ell*B^3)*F)/globalSecondDelta p B F x side := by + have hJ := (cube_label_norm_bounds p hp x.cube.support x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit x.cube.support_pos B hB.le hb₁ hb₂).1 + change globalCubeJNorm p x ≤ B^2 at hJ + have hD := globalSecondDelta_pos p hp B F hB hF x side + rw [globalChildMass,globalSecond_child_mass p hp ell B F hell hB hF] + calc + _ ≤ Real.exp 2*((ell*B^3)*F*B^2/(globalSecondDelta p B F x side*B^2)) := by gcongr + _ = _ := by field_simp + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalChildRow_bound (K B F : ℝ) (hK : 0 < K) (hB : 0 < B) (hF : 0 < F) + (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) + (hretained : secondLogK j/globalNominalChildRow p K B F x side ≤ globalSecondDelta p B F x side) : + secondLogK j*Real.exp 1 ≤ Real.exp 1*K/globalSecondDelta p B F x side := by + have hD := globalSecondDelta_pos p hp B F hB hF x side + have hK' := globalNominalChildRow_pos p hp K B F hK hB hF x side + have hk := (div_le_iff₀ hK').mp hretained + have hsmall := globalNominalChildRow_bound p hp K B F hK hB hF x side hb₁ hb₂ + calc + _ ≤ (globalSecondDelta p B F x side*globalNominalChildRow p K B F x side)*Real.exp 1 := by gcongr + _ ≤ (globalSecondDelta p B F x side*(K/(globalSecondDelta p B F x side)^2))*Real.exp 1 := by gcongr + _ = _ := by field_simp + +include hp in + +theorem globalSecondMask_bound (B F : ℝ) (hB : 0 < B) (hF : 1 ≤ F) + (x : GlobalSecondData ι) (side : Bool) (m : O) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) : + ‖eisEmbedding (fixedTripleMask m (globalSecondFixedTriple p x))‖^2 ≤ + ‖eisEmbedding m‖^2*globalSecondDelta p B F x side := by + have hb0 := (cube_label_norm_bounds p hp x.cube.support x.cube.leftExponent x.cube.rightExponent + x.cube.leftBit x.cube.rightBit x.cube.support_pos B hB.le hb₁ hb₂).2.1 + have he : ‖eisEmbedding (fixedTripleMask m (globalSecondFixedTriple p x))‖^2 = + ‖eisEmbedding (globalSecondMask p m x)‖^2 := by + rw [eisEmbedding_norm_sq_eq_absNorm_span,eisEmbedding_norm_sq_eq_absNorm_span,globalSecondMask_span] + rw [he] + have ha := primeProductNorm_ge_one p hp (x.cube.sideDivisor side) + have ht := (FirstPassCubeLabels.primeProductNorm_pos p hp x.firstCommon).le + have hr := (FirstPassCubeLabels.primeProductNorm_pos p hp (x.source.sourceCommon\x.source.divisor)).le + change ‖eisEmbedding ((m*_*_)*∏ i∈x.firstCommon,p i)‖^2 ≤ _ + rw [SecondPassIntegration.restored_child_mask_norm] + unfold globalSecondDelta + calc + _ ≤ ‖eisEmbedding m‖^2*B*primeProductNorm p (x.source.sourceCommon\x.source.divisor)*primeProductNorm p x.firstCommon := by gcongr + _ ≤ ‖eisEmbedding m‖^2*(B*F*primeProductNorm p (x.cube.sideDivisor side)*primeProductNorm p x.firstCommon* + primeProductNorm p (x.source.sourceCommon\x.source.divisor)) := by + have hf : B ≤ B*F*primeProductNorm p (x.cube.sideDivisor side) := by + calc + B = B*1*1 := by ring + _ ≤ _ := by gcongr + nlinarith [mul_le_mul_of_nonneg_left + (mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_right hf ht) hr) (sq_nonneg ‖eisEmbedding m‖)] + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem globalSecond_halving (K ell B F : ℝ) (hK : 0 < K) (hell : 0 < ell) + (hB : 0 < B) (hF : 0 < F) (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) + (hretained : secondLogK j/globalNominalChildRow p K B F x side ≤ globalSecondDelta p B F x side) + (hlarge : 2*Real.exp 2 ≤ globalSecondDelta p B F x side) : + secondLogK j*Real.exp 1 ≤ K/2 ∧ globalChildMass p ell x side j ≤ ((ell*B^3)*F)/2 := by + have hD := globalSecondDelta_pos p hp B F hB hF x side + have he : Real.exp 1 ≤ Real.exp 2 := Real.exp_le_exp.mpr (by norm_num) + have hrow := globalChildRow_bound p hp K B F hK hB hF x side j hb₁ hb₂ hretained + have hmass := globalChildMass_bound p hp ell B F hell hB hF x side j hb₁ hb₂ + constructor + · apply hrow.trans + apply (div_le_iff₀ hD).mpr + nlinarith + · apply hmass.trans + apply (div_le_iff₀ hD).mpr + have hparent : 0 < (ell*B^3)*F := by positivity + nlinarith [mul_le_mul_of_nonneg_right hlarge hparent.le] + +end + +theorem ceil_strict_of_half {a b : ℝ} (hb : 2 ≤ b) (ha : a ≤ b/2) : ⌈a⌉₊ < ⌈b⌉₊ := by + have hc : b ≤ (⌈b⌉₊ : ℝ) := Nat.le_ceil b + have hn : 2 ≤ ⌈b⌉₊ := by exact_mod_cast (hb.trans hc) + have hn1 : 1 ≤ ⌈b⌉₊ := by omega + have hbound : a ≤ ((⌈b⌉₊-1 : ℕ) : ℝ) := by + rw [Nat.cast_sub hn1,Nat.cast_one] + have hh : (2 : ℝ) ≤ ⌈b⌉₊ := by exact_mod_cast hn + linarith + have hf : ⌈a⌉₊ ≤ ⌈b⌉₊-1 := Nat.ceil_le.mpr hbound + omega + +theorem globalSecond_rank_decreases {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i,p i ≠ 0) [∀ i,(Ideal.span {p i}).IsMaximal] + (K ell B F : ℝ) (hK : 0 < K) (hell : 0 < ell) (hB : 0 < B) (hF : 0 < F) + (x : GlobalSecondData ι) (side : Bool) (j : SecondLogIndex) + (hb₁ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.leftExponent)‖^2 ≤ B) + (hb₂ : ‖eisEmbedding (primeProduct p x.cube.support x.cube.rightExponent)‖^2 ≤ B) + (hretained : secondLogK j/globalNominalChildRow p K B F x side ≤ globalSecondDelta p B F x side) + (hlarge : 2*Real.exp 2 ≤ globalSecondDelta p B F x side) : + ⌈max (secondLogK j*Real.exp 1) (globalChildMass p ell x side j)⌉₊ < ⌈max K ((ell*B^3)*F)⌉₊ := by + obtain ⟨hrow,hmass⟩ := globalSecond_halving p hp K ell B F hK hell hB hF x side j hb₁ hb₂ hretained hlarge + have hchild : 1 ≤ secondLogK j*Real.exp 1 := + one_le_mul_of_one_le_of_one_le (normLogScale_ge_one _) (Real.one_le_exp (by norm_num)) + apply ceil_strict_of_half + · have h2 : 2 ≤ K := by linarith + exact h2.trans (le_max_left _ _) + · apply max_le + · exact hrow.trans (div_le_div_of_nonneg_right (le_max_left _ _) (by norm_num)) + · exact hmass.trans (div_le_div_of_nonneg_right (le_max_right _ _) (by norm_num)) + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedGaussSeries.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedGaussSeries.lean new file mode 100644 index 0000000000000000000000000000000000000000..5d3ed3efd6c0db6a72d87586255c902fbf58a129 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedGaussSeries.lean @@ -0,0 +1,595 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.GaussFactorization + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section + +open scoped BigOperators Classical + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma ramifiedElement_ne_zero (u : Eisˣ) (n : ℕ) : u.val*lambda^n≠0 := by + have hl : lambda≠0:=by + intro hh + apply CompletedGauss.embedding_lambda_ne_zero + rw [hh,map_zero] + exact mul_ne_zero u.ne_zero (pow_ne_zero _ hl) + +lemma ramifiedElement_level (u : Eisˣ) (n : ℕ) (hn : 2≤n) : + (3:Eis)∣u.val*lambda^n := + dvd_mul_of_dvd_right (three_dvd_lambda_sq.trans (pow_dvd_pow lambda hn)) _ + +lemma ramified_denominator_condition (u : Eisˣ) (n : ℕ) (d : Eis) + (hd : (3:Eis)∣d-1) : denominatorCondition (u.val*lambda^n) d := by + have hu : IsCoprime u.val d:=⟨u.inv,0,by simp⟩ + have hl3 : lambda∣(3:Eis):=(dvd_pow_self lambda (by decide : (2:ℕ)≠0)).trans lambda_sq_dvd_three + have hld : IsCoprime lambda d:=coprime_of_dvd_sub_one lambda d (hl3.trans hd) + exact ⟨hu.mul_left hld.pow_left,hd⟩ + +lemma ramified_symbol_congr_mod_nine (u : Eisˣ) (n : ℕ) (d e : Eis) + (hd : (3:Eis)∣d-1) (he : (3:Eis)∣e-1) (hde : (9:Eis)∣d-e) : + symbol (u.val*lambda^n) d=symbol (u.val*lambda^n) e := by + have hdp:=lambda_sq_dvd_three.trans hd + have hep:=lambda_sq_dvd_three.trans he + rw [symbol_mul_numerator _ _ d hdp,symbol_mul_numerator _ _ e hep, + symbol_pow_numerator _ d hdp,symbol_pow_numerator _ e hep, + symbol_unit_congr_mod_nine u.val d e u.isUnit hdp hep hde, + CubicRamified.symbol_lambda_congr_mod_nine d e hdp hep hde] + +lemma primary_add_nine (d w : Eis) (hd : (3:Eis)∣d-1) : + (3:Eis)∣d+9*w-1 := by + convert dvd_add hd (show (3:Eis)∣9*w from ⟨3*w,by ring⟩) using 1 ; ring + +def ramifiedResidueAdd (u : Eisˣ) (n : ℕ) (w : Eis) + (r : AdmissibleResidue (u.val*lambda^n)) : AdmissibleResidue (u.val*lambda^n) := + let c:=u.val*lambda^n + let d:=denominatorRep c r.1+9*w + ⟨Ideal.Quotient.mk (Ideal.span {3*c}) d, + (denominatorCondition_congr c _ d (denominatorRep_mk_congr c d)).mpr + (ramified_denominator_condition u n d (primary_add_nine _ _ r.2.2))⟩ + +lemma ramifiedResidueAdd_injective (u : Eisˣ) (n : ℕ) (w : Eis) : + Function.Injective (ramifiedResidueAdd u n w) := by + intro r q heq + have hh:=congrArg Subtype.val heq + change Ideal.Quotient.mk (Ideal.span {3*(u.val*lambda^n)}) (denominatorRep _ r.1+9*w)= + Ideal.Quotient.mk (Ideal.span {3*(u.val*lambda^n)}) (denominatorRep _ q.1+9*w) at hh + simp only [map_add,denominatorRep_spec] at hh + exact Subtype.ext (add_right_cancel hh) + +def ramifiedResidueAddEquiv (u : Eisˣ) (n : ℕ) (w : Eis) : + AdmissibleResidue (u.val*lambda^n) ≃ AdmissibleResidue (u.val*lambda^n) := by + letI : Finite (AdmissibleResidue (u.val*lambda^n)):= + finite_admissibleResidue _ (ramifiedElement_ne_zero u n) + exact Equiv.ofBijective (ramifiedResidueAdd u n w) + ⟨ramifiedResidueAdd_injective u n w, + Finite.surjective_of_injective (ramifiedResidueAdd_injective u n w)⟩ + +lemma residueAdditive_add (h c d e : Eis) : + residueAdditive h c (d+e)=residueAdditive h c d*residueAdditive h c e := by + unfold residueAdditive + rw [map_add,mul_add,add_div,AddChar.map_add_eq_mul] + +theorem ramified_arithmetic_additive_eigen (h : Eis) (u : Eisˣ) (n : ℕ) + (hn : 2≤n) (w : Eis) : + residueAdditive h (u.val*lambda^n) (9*w)*arithmeticResidueSum h (u.val*lambda^n)= + arithmeticResidueSum h (u.val*lambda^n) := by + let c:=u.val*lambda^n + have hc:c≠0:=ramifiedElement_ne_zero u n + have hlevel:(3:Eis)∣c:=ramifiedElement_level u n hn + have heq:=(ramifiedResidueAddEquiv u n w).tsum_eq + (fun r : AdmissibleResidue c=>eisEmbedding (symbol c (denominatorRep c r.1))* + residueAdditive h c (denominatorRep c r.1)) + calc + _ = ∑' r : AdmissibleResidue c,residueAdditive h c (9*w)* + (eisEmbedding (symbol c (denominatorRep c r.1))*residueAdditive h c (denominatorRep c r.1)) := by + rw [tsum_mul_left] + rfl + _ = ∑' r : AdmissibleResidue c, + eisEmbedding (symbol c (denominatorRep c (ramifiedResidueAddEquiv u n w r).1))* + residueAdditive h c (denominatorRep c (ramifiedResidueAddEquiv u n w r).1) := by + apply tsum_congr + intro r + let d:=denominatorRep c r.1 + have hrep : 3*c∣denominatorRep c (ramifiedResidueAdd u n w r).1-(d+9*w):= + denominatorRep_mk_congr c (d+9*w) + have hdp:(3:Eis)∣d+9*w-1:=primary_add_nine d w r.2.2 + have hchar : symbol c (denominatorRep c (ramifiedResidueAdd u n w r).1)=symbol c d := by + rw [row_symbol_congr_modulus c _ (d+9*w) hlevel hdp hrep] + exact ramified_symbol_congr_mod_nine u n (d+9*w) d hdp r.2.2 ⟨w,by ring⟩ + change _=eisEmbedding (symbol c (denominatorRep c (ramifiedResidueAdd u n w r).1))* + residueAdditive h c (denominatorRep c (ramifiedResidueAdd u n w r).1) + rw [hchar,residueAdditive_congr h c _ (d+9*w) hc hrep,residueAdditive_add] + dsimp only [d] + ring + _ = _ := heq + +theorem ramified_arithmetic_support (h : Eis) (u : Eisˣ) (n : ℕ) + (hn : 2≤n) (hA : arithmeticResidueSum h (u.val*lambda^n)≠0) : + u.val*lambda^n∣3*h := by + let c:=u.val*lambda^n + have hc:c≠0:=ramifiedElement_ne_zero u n + have hp : ∀w:Eis,residueAdditive h c (9*w)=1:=by + intro w + apply mul_right_cancel₀ hA + rw [ramified_arithmetic_additive_eigen h u n hn w,one_mul] + let psi:=eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates c hc + have hprimitive:psi.IsPrimitive:=GeneralPrimitiveTrace.eisTraceModChar_breveE_primitive c hc + by_contra hdiv + have hne:Ideal.Quotient.mk (Ideal.span {c}) (3*h)≠0:=by + intro hh + exact hdiv (Ideal.mem_span_singleton.mp (Ideal.Quotient.eq_zero_iff_mem.mp hh)) + apply hprimitive hne + ext x + obtain ⟨w,rfl⟩:=Ideal.Quotient.mk_surjective x + simp only [AddChar.mulShift_apply,←map_mul,psi,eisTraceModChar, + IdealGaussCRT.traceModChar_mk,AddChar.one_apply] + convert hp w using 1 + unfold residueAdditive cuspFrequency + simp only [map_mul,map_ofNat] + congr 1 + field_simp + ; ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma ramified_primary_coprime (u : Eisˣ) (n : ℕ) (b : Eis) + (hb : lambda^2∣b-1) : IsCoprime (3*(u.val*lambda^n)) b := by + have h3:IsCoprime (3:Eis) b:=(primary_coprime_three b hb).symm + have hl:IsCoprime lambda b:=coprime_of_dvd_sub_one lambda b + ((dvd_pow_self lambda (by decide : (2:ℕ)≠0)).trans hb) + have hu:IsCoprime u.val b:=⟨u.inv,0,by simp⟩ + exact h3.mul_left (hu.mul_left hl.pow_left) + +theorem arithmeticResidueSum_ramified_split (h : Eis) (u : Eisˣ) (n : ℕ) + (hn : 2≤n) (b : Eis) (hb : lambda^2∣b-1) : + arithmeticResidueSum h ((u.val*lambda^n)*b)= + eisEmbedding (symbol (u.val*lambda^n) b)* + eisEmbedding (symbol (3*(u.val*lambda^n)) b)* + arithmeticResidueSum h (u.val*lambda^n)*cubicUnitGaussSum h b := + arithmeticResidueSum_coprime_product h _ b (ramifiedElement_ne_zero u n) + (primary_ne_zero b hb) (ramifiedElement_level u n hn) hb (ramified_primary_coprime u n b hb) + +lemma ramifiedElement_absNorm (u : Eisˣ) (n : ℕ) : + Ideal.absNorm (Ideal.span {u.val*lambda^n})=3^n := by + have hu:Ideal.span {u.val}=(1:Ideal Eis):=by + rw [Ideal.one_eq_top] + exact Ideal.span_singleton_eq_top.mpr u.isUnit + rw [←Ideal.span_singleton_mul_span_singleton,map_mul,hu,map_one,one_mul, + ←Ideal.span_singleton_pow,map_pow,absNorm_span_lambda] + +lemma three_absNorm : Ideal.absNorm (Ideal.span {(3:Eis)})=9 := by + rw [←qNat_eq_absNorm_span] + have he:(3:Eis)=ActualEisensteinCoordinates.eval 3 0:=by + simp [ActualEisensteinCoordinates.eval] + rw [he,ShortDraftLatticeCount.qNat,ShortDraftLatticeCount.coords_eval] + norm_num [ShortDraftLatticeCount.q] + +theorem ramified_arithmetic_norm_bound (h : Eis) (hh : h≠0) (u : Eisˣ) + (n : ℕ) (hn : 2≤n) (hA : arithmeticResidueSum h (u.val*lambda^n)≠0) : + 3^n≤9*Ideal.absNorm (Ideal.span {h}) := by + have hI:(Ideal.span {h}:Ideal Eis)≠0:=Ideal.span_singleton_eq_bot.not.mpr hh + have hN:0hI (Ideal.absNorm_eq_zero_iff.mp hz)) + apply Nat.le_of_dvd (by positivity) + obtain ⟨v,hv⟩:=ramified_arithmetic_support h u n hn hA + refine ⟨Ideal.absNorm (Ideal.span {v}),?_⟩ + calc + 9*Ideal.absNorm (Ideal.span {h})=Ideal.absNorm (Ideal.span {(3:Eis)*h}):=by + rw [←Ideal.span_singleton_mul_span_singleton,map_mul,three_absNorm] + _=Ideal.absNorm (Ideal.span {(u.val*lambda^n)*v}):=by rw [hv] + _=3^n*Ideal.absNorm (Ideal.span {v}):=by + rw [←Ideal.span_singleton_mul_span_singleton,map_mul,ramifiedElement_absNorm] + +def ramifiedFrequencyBound (h : Eis) : ℕ:=Nat.log 3 (9*Ideal.absNorm (Ideal.span {h})) + +theorem arithmeticResidueSum_ramified_index_bound (h : Eis) (hh : h≠0) + (u : Eisˣ) (n : ℕ) (hn : 2≤n) (b : Eis) (hb : lambda^2∣b-1) + (hA : arithmeticResidueSum h ((u.val*lambda^n)*b)≠0) : + n≤ramifiedFrequencyBound h := by + have ha:arithmeticResidueSum h (u.val*lambda^n)≠0:=by + intro hz + apply hA + rw [arithmeticResidueSum_ramified_split h u n hn b hb,hz,mul_zero,zero_mul] + exact Nat.le_log_of_pow_le (by decide) (ramified_arithmetic_norm_bound h hh u n hn ha) + +theorem arithmeticDirichletTerm_ramified_vanish (s : ℂ) (h : Eis) (hh : h≠0) + (u : Eisˣ) (n : ℕ) (hn : 2≤n) (b : Eis) (hb : lambda^2∣b-1) + (hout : ramifiedFrequencyBound h ActualEisensteinCubic.O + +abbrev NonzeroLevelLower := {c : LevelLower // c.1≠0} + +def ramifiedLower (u : Eisˣ) (n : ℕ) (I : GoodIdeal) : Eis := + (u.val*lambda^(n+2))*primaryGenerator I.1 + +lemma ramifiedLower_ne_zero (u : Eisˣ) (n : ℕ) (I : GoodIdeal) : + ramifiedLower u n I≠0:=mul_ne_zero (ramifiedElement_ne_zero u (n+2)) I.2 + +lemma ramifiedLower_level (u : Eisˣ) (n : ℕ) (I : GoodIdeal) : + (3:Eis)∣ramifiedLower u n I:= + dvd_mul_of_dvd_left (ramifiedElement_level u (n+2) (by omega)) _ + +lemma ramifiedLower_span (u : Eisˣ) (n : ℕ) (I : GoodIdeal) : + Ideal.span {ramifiedLower u n I}=ramifiedIdeal^(n+2)*I.1 := by + unfold ramifiedLower + rw [mul_assoc,Ideal.span_singleton_mul_left_unit u.isUnit,lambdaFactor_generator_span] + +def ramifiedLowerMap (p : Eisˣ × ℕ × GoodIdeal) : NonzeroLevelLower:= + ⟨⟨ramifiedLower p.1 p.2.1 p.2.2,ramifiedLower_level _ _ _⟩,ramifiedLower_ne_zero _ _ _⟩ + +lemma ramifiedLowerMap_injective : Function.Injective ramifiedLowerMap := by + rintro ⟨u,n,I⟩ ⟨v,m,J⟩ h + have hc : ramifiedLower u n I=ramifiedLower v m J:=congrArg (fun c:NonzeroLevelLower=>c.1.1) h + have hs:=congrArg (fun x:Eis=>Ideal.span {x}) hc + rw [ramifiedLower_span,ramifiedLower_span] at hs + have hh:lambdaFactorMap (n+2,I)=lambdaFactorMap (m+2,J):=Subtype.ext hs + have he:=lambdaFactorMap_bijective.1 hh + have hnm:n=m:=by have ht:=congrArg Prod.fst he; omega + have hIJ:I=J:=congrArg Prod.snd he + subst m + subst J + have huv:u=v:=by + apply Units.ext + apply mul_right_cancel₀ (mul_ne_zero (pow_ne_zero _ PrimaryIdealUnitReindex.lambda_prime_actual.ne_zero) I.2) + simpa only [ramifiedLower,mul_assoc] using hc + subst v + rfl + +lemma ramifiedLowerMap_surjective : Function.Surjective ramifiedLowerMap := by + intro c + let C:NonzeroIdeal:=⟨Ideal.span {c.1.1},Ideal.span_singleton_eq_bot.not.mpr c.2⟩ + obtain ⟨⟨k,I⟩,hCI⟩:=lambdaFactorMap_bijective.2 C + have hfact:ramifiedIdeal^k*I.1=Ideal.span {c.1.1}:=congrArg Subtype.val hCI + have hp2:ramifiedIdeal^2∣ramifiedIdeal^k*I.1:=by + rw [hfact] + change (Ideal.span {lambda}:Ideal Eis)^2∣_ + rw [Ideal.span_singleton_pow,Ideal.dvd_iff_le,Ideal.span_singleton_le_span_singleton] + exact lambda_sq_dvd_three.trans c.1.2 + have hk:2≤k:=by + by_contra hh + have hcases:k=0∨k=1:=by omega + have hnot:=((goodIdeal_iff_not_ramified I.1).mp I.2) + rcases hcases with rfl|rfl + · simp only [pow_zero,one_mul] at hp2 + exact hnot ((dvd_pow_self ramifiedIdeal (by decide : (2:ℕ)≠0)).trans hp2) + · rw [pow_one,pow_two] at hp2 + exact hnot ((mul_dvd_mul_iff_left ramifiedIdeal_prime.ne_zero).mp hp2) + obtain ⟨n,hn⟩:=Nat.exists_eq_add_of_le hk + have hk':k=n+2:=by omega + subst k + have hspan : Ideal.span {lambda^(n+2)*primaryGenerator I.1}=Ideal.span {c.1.1}:= + (lambdaFactor_generator_span (n+2) I).trans (by simpa only [Nat.add_comm] using hfact) + obtain ⟨u,hu⟩:=Ideal.span_singleton_eq_span_singleton.mp hspan + refine ⟨(u,n,I),Subtype.ext (Subtype.ext ?_)⟩ + change ramifiedLower u n I=c.1.1 + simpa only [ramifiedLower,mul_assoc,mul_comm,mul_left_comm] using hu + +def ramifiedLowerEquiv : Eisˣ × ℕ × GoodIdeal ≃ NonzeroLevelLower:= + Equiv.ofBijective ramifiedLowerMap ⟨ramifiedLowerMap_injective,ramifiedLowerMap_surjective⟩ + +lemma arithmeticDirichlet_support_nonzero (s : ℂ) (h : Eis) : + Function.support (arithmeticDirichletTerm s h)⊆{c : LevelLower | c.1≠0} := by + intro c hc + change arithmeticDirichletTerm s h c≠0 at hc + intro hz + exact hc (by simp only [arithmeticDirichletTerm,hz,ite_true]) + +theorem arithmeticDirichletSeries_ramified_reindex (s : ℂ) (hs : 2arithmeticDirichletTerm s h c.1):=hsum.subtype _ + have hp:=ramifiedLowerEquiv.summable_iff.mpr hsub + change Summable (fun p:Eisˣ×ℕ×GoodIdeal=>arithmeticDirichletTerm s h (ramifiedLowerMap p).1) at hp + calc + _=∑'c:NonzeroLevelLower,arithmeticDirichletTerm s h c.1:= + (tsum_subtype_eq_of_support_subset (arithmeticDirichlet_support_nonzero s h)).symm + _=∑'p:Eisˣ×ℕ×GoodIdeal,arithmeticDirichletTerm s h (ramifiedLowerMap p).1:= + (ramifiedLowerEquiv.tsum_eq _).symm + _=_:=by + rw [hp.tsum_prod] + apply tsum_congr + intro u + exact (hp.prod_factor u).tsum_prod + +theorem arithmeticDirichletSeries_finite_ramified (s : ℂ) (hs : 2 ActualEisensteinCubic.O + +theorem cubicUnitGaussSum_phase_shift (h a b : Eis) (hb : b≠0) + (hbprimary : lambda^2∣b-1) (hab : IsCoprime (3*a) b) : + eisEmbedding (symbol a b)*eisEmbedding (symbol (3*a) b)*cubicUnitGaussSum h b= + cubicUnitGaussSum (h*(9*a)) b := by + have hbt : IsCoprime b (9*a):=by + rw [show (9:Eis)*a=3*(3*a) by ring] + exact (primary_coprime_three b hbprimary).mul_right hab.symm + have heig:=cubicUnitGaussSum_frequency_twist h b (9*a) hb hbprimary hbt + have hs : symbol a b*symbol (3*a) b*symbol (9*a) b=1 := by + calc + _=symbol (a*(3*a)*(9*a)) b:=by + symm + calc + _=symbol (a*(3*a)) b*symbol (9*a) b:= + symbol_mul_numerator _ _ b hbprimary + _=_:=by rw [symbol_mul_numerator a (3*a) b hbprimary] + _=symbol ((3*a)^3) b:=by congr 1; ring + _=(symbol (3*a) b)^3:=symbol_pow_numerator _ _ hbprimary 3 + _=1:=symbol_cube_of_isCoprime _ _ hbprimary hab + have he : eisEmbedding (symbol a b)*eisEmbedding (symbol (3*a) b)* + eisEmbedding (symbol (9*a) b)=1:=by + simpa only [map_mul,map_one] using congrArg eisEmbedding hs + calc + _=(eisEmbedding (symbol a b)*eisEmbedding (symbol (3*a) b))* + (eisEmbedding (symbol (9*a) b)*cubicUnitGaussSum (h*(9*a)) b):=by rw [heig] + _=(eisEmbedding (symbol a b)*eisEmbedding (symbol (3*a) b)* + eisEmbedding (symbol (9*a) b))*cubicUnitGaussSum (h*(9*a)) b:=by ring + _=_:=by rw [he,one_mul] + +def unramifiedCubicGaussSeries (s : ℂ) (h : Eis) : ℂ:= + ∑'I:GoodIdeal,(Ideal.absNorm I.1:ℂ)^(-s)*cubicUnitGaussSum h (primaryGenerator I.1) + +theorem arithmeticDirichletSeries_unramified_gauss (s : ℂ) (hs : 2 ActualEisensteinCubic.O + +theorem cubicUnitGaussSum_cube_shift (h b t : Eis) (hb : b≠0) + (hbprimary : lambda^2∣b-1) (hbt : IsCoprime b t) : + cubicUnitGaussSum (h*t^3) b=cubicUnitGaussSum h b := by + have heig:=cubicUnitGaussSum_frequency_twist h b (t^3) hb hbprimary hbt.pow_right + have hs : symbol (t^3) b=1:=by + rw [symbol_pow_numerator t b hbprimary 3] + exact symbol_cube_of_isCoprime t b hbprimary hbt.symm + simpa only [hs,map_one,one_mul] using heig + +theorem unramifiedCubicGaussSeries_neg (s : ℂ) (h : Eis) : + unramifiedCubicGaussSeries s (-h)=unramifiedCubicGaussSeries s h := by + apply tsum_congr + intro I + congr 1 + have hc : IsCoprime (primaryGenerator I.1) (-1:Eis):=⟨0,-1,by ring⟩ + simpa only [show (-1:Eis)^3=-1 by ring,mul_neg_one] using cubicUnitGaussSum_cube_shift h (primaryGenerator I.1) (-1) I.2 + (primaryGenerator_spec I.1 I.2).2 hc + +theorem unramifiedCubicGaussSeries_lambda_pow (s : ℂ) (h : Eis) (n : ℕ) : + unramifiedCubicGaussSeries s (h*lambda^n)= + unramifiedCubicGaussSeries s (h*lambda^(n%3)) := by + apply tsum_congr + intro I + congr 1 + have hp:lambda^2∣primaryGenerator I.1-1:=(primaryGenerator_spec I.1 I.2).2 + have hl:IsCoprime lambda (primaryGenerator I.1):= + coprime_of_dvd_sub_one lambda _ ((show lambda∣lambda^2 from ⟨lambda,by ring⟩).trans hp) + have he:lambda^n=lambda^(n%3)*(lambda^(n/3))^3:=by + rw [←pow_mul,←pow_add] + congr 1 + omega + rw [he,←mul_assoc] + exact cubicUnitGaussSum_cube_shift _ _ _ I.2 hp hl.symm.pow_right + +theorem unramifiedCubicGaussSeries_lambda_cube (s : ℂ) (h : Eis) : + unramifiedCubicGaussSeries s (h*lambda^3)=unramifiedCubicGaussSeries s h := by + simpa using unramifiedCubicGaussSeries_lambda_pow s h 3 + +theorem unit_eq_sign_omega (u : Eisˣ) : + ∃j:Fin 3,(u:Eis)=omega^j.val ∨ (u:Eis)=-(omega^j.val) := by + let ζ:=IsCyclotomicExtension.zeta_spec 3 ℚ K + let η:Eisˣ:=(ζ.toInteger_isPrimitiveRoot.isUnit (by decide)).unit + have hη:(η:Eis)=omega:=rfl + have hlist:u∈([1,-1,η,-η,η^2,-η^2]:List Eisˣ):= + IsCyclotomicExtension.Rat.Three.Units.mem ζ u + simp only [List.mem_cons,List.mem_nil_iff,or_false] at hlist + rcases hlist with h|h|h|h|h|h + · exact ⟨0,Or.inl (by simp [h])⟩ + · exact ⟨0,Or.inr (by simp [h])⟩ + · exact ⟨1,Or.inl (by simp [h,hη])⟩ + · exact ⟨1,Or.inr (by simp [h,hη])⟩ + · exact ⟨2,Or.inl (by simp only [h,Units.val_pow_eq_pow_val,hη];rfl)⟩ + · exact ⟨2,Or.inr (by simp only [h,Units.val_neg,Units.val_pow_eq_pow_val,hη];rfl)⟩ + +theorem unramifiedCubicGaussSeries_nine_family (h : Eis) (u : Eisˣ) (n : ℕ) : + ∃j k:Fin 3,∀s:ℂ, + unramifiedCubicGaussSeries s (h*(9*((u:Eis)*lambda^n)))= + unramifiedCubicGaussSeries s (h*omega^j.val*lambda^k.val) := by + have hl:lambda^2=-3*omega:=by + have hw:omega^2=-omega-1:=by + have h3:omega^3=1:=omega_primitive.pow_eq_one + have h1:omega≠1:=omega_primitive.ne_one (by decide) + have hp:(omega-1)*(omega^2+omega+1)=0:=by linear_combination h3 + have hz:omega^2+omega+1=0:=(mul_eq_zero.mp hp).resolve_left (sub_ne_zero.mpr h1) + linear_combination hz + change (omega-1)^2=-3*omega + linear_combination hw + have h9:(9:Eis)=omega*lambda^4:=by + calc + _=9*omega^3:=by rw [omega_primitive.pow_eq_one];ring + _=omega*((-3*omega)^2):=by ring + _=omega*((lambda^2)^2):=by rw [hl] + _=omega*lambda^4:=by ring + let ζ:=IsCyclotomicExtension.zeta_spec 3 ℚ K + let η:Eisˣ:=(ζ.toInteger_isPrimitiveRoot.isUnit (by decide)).unit + have hη:(η:Eis)=omega:=rfl + obtain ⟨j,hj⟩:=unit_eq_sign_omega (η*u) + refine ⟨j,⟨(n+4)%3,Nat.mod_lt _ (by decide)⟩,?_⟩ + intro s + have he:h*(9*((u:Eis)*lambda^n))=(h*((η*u:Eisˣ):Eis))*lambda^(n+4):=by + rw [h9,Units.val_mul,hη,pow_add] + ring + rw [he,unramifiedCubicGaussSeries_lambda_pow] + rcases hj with hj|hj + · rw [hj] + · rw [hj] + simpa only [mul_neg,neg_mul] using + unramifiedCubicGaussSeries_neg s (h*omega^j.val*lambda^((n+4)%3)) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedNormWeights.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedNormWeights.lean new file mode 100644 index 0000000000000000000000000000000000000000..0252525eaf6fb3c096286f9c8be48261c4b9dd82 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedNormWeights.lean @@ -0,0 +1,644 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.ConjugateProfiles + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +open scoped BigOperators Classical + +namespace CubicEisenstein + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal + +private def predicateFiberEquiv {R S : Type*} (f : R → S) (P : S → Prop) : + {x : R // P (f x)} ≃ Σ y : {y : S // P y}, {x : R // f x=y.1} where + toFun x := ⟨⟨f x.1,x.2⟩,⟨x.1,rfl⟩⟩ + invFun y := ⟨y.2.1,by rw [y.2.2]; exact y.1.2⟩ + left_inv x := rfl + right_inv y := by + rcases y with ⟨⟨y,hy⟩,x,hx⟩ + dsimp at hx + cases hx + rfl + +private def predicateKernelEquiv {R S : Type*} [AddGroup R] [AddGroup S] + (f : R →+ S) (hf : Function.Surjective f) (P : S → Prop) : + {x : R // P (f x)} ≃ {y : S // P y} × f.ker := + (predicateFiberEquiv f P).trans + ((Equiv.sigmaCongrRight (fun y : {y : S // P y} => + AddMonoidHom.fiberEquivKerOfSurjective hf y.1)).trans (Equiv.sigmaEquivProd _ _)) + +lemma card_ring_eq_card_mul_kernel {R S : Type*} [Ring R] [Ring S] + (f : R →+* S) (hf : Function.Surjective f) : + Nat.card R=Nat.card S*Nat.card f.toAddMonoidHom.ker := by + have h := Nat.card_congr (predicateKernelEquiv f.toAddMonoidHom hf (fun _ => True)) + simpa only [Nat.card_prod,Nat.card_congr (Equiv.subtypeUnivEquiv (fun _ => True.intro))] using h + +lemma card_units_eq_card_mul_kernel {R S : Type*} [CommRing R] [CommRing S] + (f : R →+* S) (hf : Function.Surjective f) + (hunit : ∀x, IsUnit (f x) ↔ IsUnit x) : + Nat.card Rˣ=Nat.card Sˣ*Nat.card f.toAddMonoidHom.ker := by + let e : Rˣ ≃ {x : R // IsUnit (f x)} := + (unitsSubtypeEquiv R).trans (Equiv.subtypeEquivRight (fun x => (hunit x).symm)) + calc + _ = Nat.card ({y : S // IsUnit y} × f.toAddMonoidHom.ker) := + Nat.card_congr (e.trans (predicateKernelEquiv f.toAddMonoidHom hf IsUnit)) + _ = Nat.card {y : S // IsUnit y} * Nat.card f.toAddMonoidHom.ker := Nat.card_prod _ _ + _ = _ := by rw [← Nat.card_congr (unitsSubtypeEquiv S)] + +lemma card_units_mul_card_target {R S : Type*} [CommRing R] [CommRing S] + (f : R →+* S) (hf : Function.Surjective f) + (hunit : ∀x, IsUnit (f x) ↔ IsUnit x) : + Nat.card S*Nat.card Rˣ=Nat.card R*Nat.card Sˣ := by + rw [card_units_eq_card_mul_kernel f hf hunit,card_ring_eq_card_mul_kernel f hf] + ring + +theorem idealTotient_pow_succ (I : Ideal O) (hI : I ≠ 0) (n : ℕ) : + idealTotient (I^(n+1))=Ideal.absNorm I^n*idealTotient I := by + let f : (O ⧸ I^(n+1)) →+* (O ⧸ I) := + Ideal.Quotient.factor (Ideal.pow_le_self (Nat.succ_ne_zero n)) + have hf : Function.Surjective f := Ideal.Quotient.factor_surjective _ + have hu (x : O ⧸ I^(n+1)) : IsUnit (f x) ↔ IsUnit x := by + obtain ⟨x,rfl⟩ := Ideal.Quotient.mk_surjective x + exact (Ideal.Quotient.isUnit_mk_pow_iff_isUnit_mk I (Nat.succ_ne_zero n)).symm + have h := card_units_mul_card_target f hf hu + change Ideal.absNorm I*idealTotient (I^(n+1))= + Ideal.absNorm (I^(n+1))*idealTotient I at h + rw [map_pow] at h + have hpos : 0 (MulEquiv.isUnit_map e).symm)).trans + (unitsSubtypeEquiv S).symm) + +theorem idealTotient_mul (I J : Ideal O) (hIJ : IsCoprime I J) : + idealTotient (I*J)=idealTotient I*idealTotient J := by + change Nat.card (O ⧸ I*J)ˣ=Nat.card (O ⧸ I)ˣ*Nat.card (O ⧸ J)ˣ + calc + _ = Nat.card ((O ⧸ I)ˣ × (O ⧸ J)ˣ) := + Nat.card_congr ((unitsRingEquiv + (Ideal.quotientMulEquivQuotientProd I J hIJ).toMulEquiv).trans MulEquiv.prodUnits.toEquiv) + _ = _ := Nat.card_prod _ _ + +theorem card_admissible_cube_product (n : ℕ) (a : O) (ha : a ≠ 0) + (hcop : IsCoprime a (3:O)) : + Nat.card (AdmissibleResidue (lambda^(3*n)*a^3)) = + 3^(3*n)*Ideal.absNorm (Ideal.span {a})^2*idealTotient (Ideal.span {a}) := by + rw [card_admissible_lambda_pow_mul (3*n) (a^3) hcop.pow_left, + ← Ideal.span_singleton_pow,idealTotient_cube _ (Ideal.span_singleton_eq_bot.not.mpr ha)] + ring + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal UniqueFactorizationMonoid +open IdealMobiusDivisorSum (idealDivisors mem_idealDivisors sum_moebius_divisors) + +lemma isUnit_quotient_iff_sup (I : Ideal O) (x : O) : + IsUnit (Ideal.Quotient.mk I x) ↔ I ⊔ Ideal.span {x}=⊤ := by + constructor + · intro hx + obtain ⟨b,hb⟩ := isUnit_iff_exists_inv.mp hx + obtain ⟨b,rfl⟩ := Ideal.Quotient.mk_surjective b + have hI : x*b-1 ∈ I := by + apply Ideal.Quotient.eq_zero_iff_mem.mp + simpa only [map_sub,map_mul,map_one,sub_eq_zero] using hb + apply (Ideal.eq_top_iff_one _).mpr + have hx' : x*b ∈ I ⊔ Ideal.span {x} := + (le_sup_right : Ideal.span {x} ≤ I ⊔ Ideal.span {x}) + ((Ideal.span {x}).mul_mem_right b (Ideal.subset_span (by simp))) + convert (I ⊔ Ideal.span {x}).sub_mem hx' ((le_sup_left : I ≤ I ⊔ Ideal.span {x}) hI) using 1 ; ring + · intro h + have h1 : (1:O) ∈ I ⊔ Ideal.span {x} := by rw [h]; trivial + obtain ⟨a,ha,b,hb,hab⟩ := Submodule.mem_sup.mp h1 + obtain ⟨k,rfl⟩ := Ideal.mem_span_singleton.mp hb + apply isUnit_iff_exists_inv.mpr + refine ⟨Ideal.Quotient.mk I k, ?_⟩ + have ha0 := Ideal.Quotient.eq_zero_iff_mem.mpr ha + have hh := congrArg (Ideal.Quotient.mk I) hab + simpa only [map_add,map_mul,map_one,ha0,zero_add] using hh + +lemma residue_unit_mobius (I : Ideal O) (hI : I ≠ 0) (r : O ⧸ I) : + (if IsUnit r then (1:ℂ) else 0) = + ∑ J ∈ idealDivisors I, if Quotient.out r ∈ J then (moebius J:ℂ) else 0 := by + let G : Ideal O := I ⊔ Ideal.span {Quotient.out r} + have hG : G ≠ 0 := by + intro hG + apply hI + apply le_antisymm _ bot_le + calc + I ≤ G := le_sup_left + _ = ⊥ := hG + have hdiv : (idealDivisors I).filter (fun J => Quotient.out r ∈ J)=idealDivisors G := by + ext J + simp only [Finset.mem_filter,mem_idealDivisors hI,mem_idealDivisors hG, + Ideal.dvd_iff_le,G,sup_le_iff,Ideal.span_le,Set.singleton_subset_iff,SetLike.mem_coe] + rw [← Finset.sum_filter,hdiv,sum_moebius_divisors G hG] + have hu : IsUnit r ↔ G=⊤ := by + rw [← Ideal.Quotient.mk_out r] + exact isUnit_quotient_iff_sup I (Quotient.out r) + simp only [hu] + +lemma sum_indicator_const {R : Type*} [Fintype R] (P : R → Prop) (z : ℂ) : + (∑ r : R, if P r then z else 0)=(Nat.card {r : R // P r}:ℂ)*z := by + rw [← Finset.sum_filter] + simp only [Finset.sum_const,nsmul_eq_mul,Nat.card_eq_fintype_card,Fintype.card_subtype] + +lemma card_quotient_multiples (I J : Ideal O) (hI : I ≠ 0) (hIJ : I ≤ J) : + (Nat.card {r : O ⧸ I // Quotient.out r ∈ J}:ℂ)= + (Ideal.absNorm I:ℂ)/(Ideal.absNorm J:ℂ) := by + let f : (O ⧸ I) →+* (O ⧸ J) := Ideal.Quotient.factor hIJ + have hf : Function.Surjective f := Ideal.Quotient.factor_surjective hIJ + have hpred (r : O ⧸ I) : Quotient.out r ∈ J ↔ f r=0 := by + have hfr : f r=Ideal.Quotient.mk J (Quotient.out r) := by + calc + f r = f (Ideal.Quotient.mk I (Quotient.out r)) := + congrArg f (Ideal.Quotient.mk_out r).symm + _ = _ := Ideal.Quotient.factor_mk hIJ _ + rw [← Ideal.Quotient.eq_zero_iff_mem,hfr] + let e : {r : O ⧸ I // Quotient.out r ∈ J} ≃ f.toAddMonoidHom.ker := + Equiv.subtypeEquivRight hpred + have hcard := card_ring_eq_card_mul_kernel f hf + have hJ : J ≠ 0 := fun h => hI (le_antisymm (h ▸ hIJ) bot_le) + have hnJ : (Ideal.absNorm J:ℂ) ≠ 0 := + Nat.cast_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hJ) + rw [Nat.card_congr e] + apply (eq_div_iff hnJ).mpr + have hh : Nat.card f.toAddMonoidHom.ker * Ideal.absNorm J = Ideal.absNorm I := + (Nat.mul_comm _ _).trans hcard.symm + exact_mod_cast hh + +theorem idealTotient_moebius (I : Ideal O) (hI : I ≠ 0) : + (idealTotient I:ℂ)=(Ideal.absNorm I:ℂ)* + ∑ J ∈ idealDivisors I, (moebius J:ℂ)/(Ideal.absNorm J:ℂ) := by + let : Finite (O ⧸ I) := I.finiteQuotientOfFreeOfNeBot hI + let : Fintype (O ⧸ I) := Fintype.ofFinite _ + classical + have hcount : (idealTotient I:ℂ)=∑ r : O ⧸ I, + @ite ℂ (IsUnit r) (Classical.propDecidable _) 1 0 := by + have h := sum_indicator_const (R := O ⧸ I) IsUnit (1:ℂ) + rw [mul_one] at h + calc + _ = (Nat.card {r : O ⧸ I // IsUnit r}:ℂ) := by + exact_mod_cast Nat.card_congr (unitsSubtypeEquiv (O ⧸ I)) + _ = _ := h.symm + rw [hcount] + have hs : (∑ r : O ⧸ I, @ite ℂ (IsUnit r) (Classical.propDecidable _) 1 0) = + ∑ r : O ⧸ I, ∑ J ∈ idealDivisors I, + if Quotient.out r ∈ J then (moebius J:ℂ) else 0 := by + apply Finset.sum_congr rfl + intro r hr + exact residue_unit_mobius I hI r + rw [hs] + rw [Finset.sum_comm] + rw [Finset.mul_sum] + apply Finset.sum_congr rfl + intro J hJ + rw [sum_indicator_const,card_quotient_multiples I J hI + (Ideal.dvd_iff_le.mp ((mem_idealDivisors hI).mp hJ))] + ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal UniqueFactorizationMonoid CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal) + +def unramifiedNormWeight (s : ℂ) : Ideal O →*₀ ℂ where + toFun I := if primaryGenerator I=0 then 0 else (Ideal.absNorm I:ℂ)^(-s) + map_zero' := by simp + map_one' := by + rw [primaryGenerator_one,ite_eq_right one_ne_zero,map_one,Nat.cast_one,Complex.one_cpow] + map_mul' I J := by + by_cases hI : primaryGenerator I=0 + · simp [primaryGenerator_mul,hI] + by_cases hJ : primaryGenerator J=0 + · simp [primaryGenerator_mul,hJ] + simp only [primaryGenerator_mul,mul_eq_zero,hI,hJ,false_or,ite_false,map_mul,Nat.cast_mul] + exact Complex.natCast_mul_natCast_cpow _ _ _ + +lemma unramifiedNormWeight_of_good (s : ℂ) (I : Ideal O) (hI : primaryGenerator I ≠ 0) : + unramifiedNormWeight s I=(Ideal.absNorm I:ℂ)^(-s) := ite_eq_right hI + +lemma unramifiedNormWeight_of_bad (s : ℂ) (I : Ideal O) (hI : primaryGenerator I=0) : + unramifiedNormWeight s I=0 := ite_eq_left hI + +lemma primaryGenerator_injective_good : + Function.Injective (fun I : GoodIdeal => primaryGenerator I.1) := by + intro I J h + dsimp only at h + apply Subtype.ext + rw [← (primaryGenerator_spec I.1 I.2).1,← (primaryGenerator_spec J.1 J.2).1,h] + +lemma norm_unramifiedNormWeight (s : ℂ) (I : GoodIdeal) : + ‖unramifiedNormWeight s I.1‖=‖eisEmbedding (primaryGenerator I.1)‖^(-2*s.re) := by + rw [unramifiedNormWeight_of_good s I.1 I.2] + have hnorm : ‖eisEmbedding (primaryGenerator I.1)‖^2=(Ideal.absNorm I.1:ℝ) := by + rw [eisEmbedding_norm_sq_eq_absNorm_span,(primaryGenerator_spec I.1 I.2).1] + have hn : 0<‖eisEmbedding (primaryGenerator I.1)‖ := + norm_pos_iff.mpr (eisEmbedding_ne_zero I.2) + have hcast : (Ideal.absNorm I.1:ℂ)=((‖eisEmbedding (primaryGenerator I.1)‖^2:ℝ):ℂ) := by + exact_mod_cast hnorm.symm + rw [hcast,Complex.norm_cpow_eq_rpow_re_of_pos (sq_pos_of_pos hn)] + rw [← Real.rpow_natCast_mul hn.le 2] + congr 1 + simp only [Complex.neg_re,Nat.cast_ofNat] + ring + +theorem unramifiedNormWeight_summable_norm (s : ℂ) (hs : 1 ‖unramifiedNormWeight s I‖) := by + have hlat := (summable_embedding_rpow (-2*s.re) (by linarith)).comp_injective + primaryGenerator_injective_good + have hsub : Summable (fun I : GoodIdeal => ‖unramifiedNormWeight s I.1‖) := by + simpa only [Function.comp_def, norm_unramifiedNormWeight] using hlat + have hind := (summable_subtype_iff_indicator (s := {I : Ideal O | primaryGenerator I ≠ 0}) + (f := fun I => ‖unramifiedNormWeight s I‖)).mp hsub + apply hind.congr + intro I + by_cases hI : primaryGenerator I=0 + · simp [Set.indicator,hI,unramifiedNormWeight_of_bad s I hI] + · simp [Set.indicator,hI] + +lemma norm_ideal_moebius_le_one (I : Ideal O) : ‖(moebius I:ℂ)‖≤1 := by + by_cases hI : Squarefree I + · simp [hI.moebius_eq] + · simp [moebius_of_not_squarefree hI] + +lemma moebius_unramifiedNormWeight_summable_norm (s : ℂ) (hs : 1 ‖(moebius I:ℂ)*unramifiedNormWeight s I‖) := by + apply (unramifiedNormWeight_summable_norm s hs).of_nonneg_of_le (fun _ => norm_nonneg _) + intro I + rw [norm_mul] + exact mul_le_of_le_one_left (norm_nonneg _) (norm_ideal_moebius_le_one I) + +def unramifiedIdealZeta (s : ℂ) : ℂ := ∑' I : Ideal O, unramifiedNormWeight s I + +def unramifiedMobiusSeries (s : ℂ) : ℂ := + ∑' I : Ideal O, (moebius I:ℂ)*unramifiedNormWeight s I + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal UniqueFactorizationMonoid CompletedGauss +open IdealMobiusDivisorSum (idealDivisors mem_idealDivisors sum_moebius_divisors) + +theorem unramifiedMobiusSeries_mul_zeta (s : ℂ) (hs : 1 + (moebius p.1:ℂ)*unramifiedNormWeight s (p.1*p.2) + have hprod := (moebius_unramifiedNormWeight_summable_norm s hs).mul_norm + (unramifiedNormWeight_summable_norm s hs) + have hF : Summable F := by + apply hprod.of_norm.congr + intro p + dsimp only [F] + rw [map_mul] + ring + have hfiber (B : Ideal O) : (∑' p : MulFiber B,F p.1)=if B=1 then 1 else 0 := by + by_cases hB : B=0 + · subst B + have hz (p : MulFiber 0) : F p.1=0 := by simp only [F,p.2,map_zero,mul_zero] + simp only [hz,tsum_zero,zero_ne_one,ite_false] + · calc + _ = (∑' p : MulFiber B,(moebius p.1.1:ℂ))*unramifiedNormWeight s B := by + rw [← tsum_mul_right] + apply tsum_congr + intro p + simp only [F,p.2] + _ = _ := by + rw [mulFiber_moebius_sum B hB] + split_ifs with hB1 + · subst B; simp only [map_one,mul_one] + · simp only [zero_mul] + have hsum := hF.hasSum.tsum_fiberwise (fun p : Ideal O × Ideal O => p.1*p.2) + change HasSum (fun B : Ideal O => ∑' p : MulFiber B,F p.1) (∑' p,F p) at hsum + simp_rw [hfiber] at hsum + have hFone : (∑' p,F p)=1 := by simpa using hsum.tsum_eq.symm + calc + _ = ∑' p : Ideal O × Ideal O, + ((moebius p.1:ℂ)*unramifiedNormWeight s p.1)*unramifiedNormWeight s p.2 := + tsum_mul_tsum_of_summable_norm (moebius_unramifiedNormWeight_summable_norm s hs) + (unramifiedNormWeight_summable_norm s hs) + _ = ∑' p,F p := by + apply tsum_congr + intro p + simp only [F,map_mul] + ring + _ = 1 := hFone + +theorem unramifiedIdealZeta_ne_zero (s : ℂ) (hs : 1 (Ideal.absNorm I:ℂ)) p.2.symm + _ = _ := by rw [map_mul,Nat.cast_mul] + rw [heq] + field_simp + calc + _ = ∑' p : MulFiber B,(Ideal.absNorm B:ℂ)* + ((moebius p.1.1:ℂ)/(Ideal.absNorm p.1.1:ℂ)) := tsum_congr hp + _ = (Ideal.absNorm B:ℂ)* + ∑' D : {D : Ideal O // D ∈ idealDivisors B}, + ((moebius D.1:ℂ)/(Ideal.absNorm D.1:ℂ)) := by + rw [← tsum_mul_left] + exact e.tsum_eq (fun D => (Ideal.absNorm B:ℂ)*((moebius D.1:ℂ)/(Ideal.absNorm D.1:ℂ))) + _ = (Ideal.absNorm B:ℂ)* + ∑ D ∈ idealDivisors B,((moebius D:ℂ)/(Ideal.absNorm D:ℂ)) := by + rw [tsum_fintype] + apply congrArg (fun z : ℂ => (Ideal.absNorm B:ℂ)*z) + exact (Finset.sum_subtype (idealDivisors B) (fun _ => Iff.rfl) + (fun D => (moebius D:ℂ)/(Ideal.absNorm D:ℂ))).symm + _ = _ := (idealTotient_moebius B hB).symm + +def unramifiedTotientSeries (s : ℂ) : ℂ := + ∑' I : Ideal O,(idealTotient I:ℂ)*unramifiedNormWeight s I + +theorem unramifiedTotientSeries_product (s : ℂ) (hs : 2 + (moebius p.1:ℂ)*(Ideal.absNorm p.2:ℂ)*unramifiedNormWeight s (p.1*p.2) + have hprod := (moebius_unramifiedNormWeight_summable_norm s hs1).mul_norm + (unramifiedNormWeight_summable_norm (s-1) hs2) + have heq (p : Ideal O × Ideal O) : + ((moebius p.1:ℂ)*unramifiedNormWeight s p.1)*unramifiedNormWeight (s-1) p.2=F p := by + simp only [F,unramifiedNormWeight_shift,map_mul] + ring + have hF : Summable F := hprod.of_norm.congr heq + have hfiber (B : Ideal O) : (∑' p : MulFiber B,F p.1)= + (idealTotient B:ℂ)*unramifiedNormWeight s B := by + by_cases hB : B=0 + · subst B + have hz (p : MulFiber 0) : F p.1=0 := by simp only [F,p.2,map_zero,mul_zero] + simp only [hz,tsum_zero,map_zero,mul_zero] + · calc + _ = (∑' p : MulFiber B,(moebius p.1.1:ℂ)*(Ideal.absNorm p.1.2:ℂ))* + unramifiedNormWeight s B := by + rw [← tsum_mul_right] + apply tsum_congr + intro p + simp only [F,p.2] + _ = _ := by rw [mulFiber_totient_sum B hB] + have hsum := hF.hasSum.tsum_fiberwise (fun p : Ideal O × Ideal O => p.1*p.2) + change HasSum (fun B : Ideal O => ∑' p : MulFiber B,F p.1) (∑' p,F p) at hsum + simp_rw [hfiber] at hsum + calc + _ = ∑' p,F p := hsum.tsum_eq + _ = _ := by + rw [unramifiedMobiusSeries,unramifiedIdealZeta, + tsum_mul_tsum_of_summable_norm (moebius_unramifiedNormWeight_summable_norm s hs1) + (unramifiedNormWeight_summable_norm (s-1) hs2)] + exact tsum_congr (fun p => (heq p).symm) + +theorem unramifiedTotientSeries_quotient (s : ℂ) (hs : 2 ‖(idealTotient I:ℂ)*unramifiedNormWeight s I‖) := by + have hs1 : 1<(s-1).re := by simp only [Complex.sub_re,Complex.one_re]; linarith + apply (unramifiedNormWeight_summable_norm (s-1) hs1).of_nonneg_of_le + (fun _ => norm_nonneg _) + intro I + by_cases hI : I=0 + · subst I; simp only [map_zero,mul_zero,norm_zero,le_refl] + · rw [norm_mul,Complex.norm_natCast,unramifiedNormWeight_shift,norm_mul,Complex.norm_natCast] + exact mul_le_mul_of_nonneg_right (Nat.cast_le.mpr (idealTotient_le_absNorm I hI)) (norm_nonneg _) + +end CubicEisenstein + +open scoped BigOperators Classical SchwartzMap +namespace CanonicalQuadraticSieve + +section +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss QuadraticSquarefreeKernel + +theorem originalPairLow_squarefree_tsum + (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) + (W : SchwartzMap ℝ ℂ) (M K : ℝ) (hM : 0 < M) : + (∑' lengthScale : Ideal O, originalPairLow I J W M K lengthScale) = + ∑' B : {B : Ideal O // Admissible B}, + if (Ideal.absNorm B.val : ℝ) ≤ K then + (quadraticRow I (primaryGenerator B.val) * quadraticRow J (primaryGenerator B.val)) * + ∑' A : {A : Ideal O // Supported A}, + (idealZeroMask I (primaryGenerator A.val) * idealZeroMask J (primaryGenerator A.val)) * + W (((Ideal.absNorm A.val : ℝ) ^ 2 * (Ideal.absNorm B.val : ℝ)) / M) + else 0 := by + let F : ({A : Ideal O // Supported A} × {B : Ideal O // Admissible B}) → ℂ := fun p => + if (Ideal.absNorm p.2.val : ℝ) ≤ K then + (idealZeroMask I (primaryGenerator p.1.val) * idealZeroMask J (primaryGenerator p.1.val)) * + (quadraticRow I (primaryGenerator p.2.val) * quadraticRow J (primaryGenerator p.2.val)) * + W (((Ideal.absNorm p.1.val : ℝ) ^ 2 * (Ideal.absNorm p.2.val : ℝ)) / M) else 0 + have hterm (p : {A : Ideal O // Supported A} × {B : Ideal O // Admissible B}) : + originalPairLow I J W M K (p.1.val ^ 2 * p.2.val) = F p := by + have hs : Supported (p.1.val ^ 2 * p.2.val) := + (supported_mul_iff _ _).mpr ⟨(supported_sq_iff _).mpr p.1.property, admissible_supported p.2.property⟩ + unfold originalPairLow + rw [(squarePart_mul_squarefree p.1.property.1 p.2.property.2.1).2] + by_cases hk : (Ideal.absNorm p.2.val : ℝ) ≤ K + · rw [ite_eq_left hk] + unfold originalPairSource + rw [ite_eq_left hs, canonical_quadraticRow_star I hI, + canonical_quadraticRow_primary_squarefree I hI, canonical_quadraticRow_primary_squarefree J hJ] + simp only [F, ite_eq_left hk, map_mul, map_pow, Nat.cast_mul, Nat.cast_pow] + ring + · simp only [ite_eq_right hk, F] + have hsub : Summable (fun lengthScale : {lengthScale : Ideal O // Supported lengthScale} => originalPairLow I J W M K lengthScale.val) := + (originalPairLow_summable I J W M K hM).subtype _ + have hp0 : Summable (fun p : {A : Ideal O // Supported A} × {B : Ideal O // Admissible B} => + originalPairLow I J W M K (p.1.val ^ 2 * p.2.val)) := + supportedSquarefreeEquiv.symm.summable_iff.mpr hsub + have hp : Summable F := hp0.congr hterm + have he : (∑' lengthScale : {lengthScale : Ideal O // Supported lengthScale}, originalPairLow I J W M K lengthScale.val) = + ∑' lengthScale : Ideal O, originalPairLow I J W M K lengthScale := by + apply tsum_subtype_eq_of_support_subset + intro lengthScale hL + by_contra hs + change ¬Supported lengthScale at hs + exact hL (by simp [originalPairLow, originalPairSource, hs]) + calc + _ = ∑' lengthScale : {lengthScale : Ideal O // Supported lengthScale}, originalPairLow I J W M K lengthScale.val := he.symm + _ = ∑' p : {A : Ideal O // Supported A} × {B : Ideal O // Admissible B}, + originalPairLow I J W M K (p.1.val ^ 2 * p.2.val) := + (supportedSquarefreeEquiv.symm.tsum_eq (fun lengthScale => originalPairLow I J W M K lengthScale.val)).symm + _ = ∑' p, F p := tsum_congr hterm + _ = ∑' p : {B : Ideal O // Admissible B} × {A : Ideal O // Supported A}, F (p.2, p.1) := + (Equiv.prodComm _ _).tsum_eq (fun p => F (p.2, p.1)) + _ = ∑' B : {B : Ideal O // Admissible B}, ∑' A : {A : Ideal O // Supported A}, F (A, B) := + hp.prod_symm.tsum_prod + _ = _ := by + apply tsum_congr + intro B + by_cases hk : (Ideal.absNorm B.val : ℝ) ≤ K + · rw [ite_eq_left hk, ← tsum_mul_left] + apply tsum_congr + intro A + simp only [F, ite_eq_left hk] + ring + · simp only [F, ite_eq_right hk, tsum_zero] + +end + +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge CompletedGauss + +theorem idealZeroMask_span_eq (D : Ideal O) (x y : O) (hxy : Ideal.span {x} = Ideal.span {y}) : + idealZeroMask D x = idealZeroMask D y := by + have hm (P : Ideal O) : x ∈ P ↔ y ∈ P := by + constructor + · intro h + exact (Ideal.span_singleton_le_iff_mem P).mp (hxy ▸ (Ideal.span_singleton_le_iff_mem P).mpr h) + · intro h + exact (Ideal.span_singleton_le_iff_mem P).mp (hxy.symm ▸ (Ideal.span_singleton_le_iff_mem P).mpr h) + unfold idealZeroMask + simp_rw [hm] + +theorem idealZeroMask_mul (I J : Ideal O) (hI : I ≠ 0) (hJ : J ≠ 0) (z : O) : + idealZeroMask (I * J) z = idealZeroMask I z * idealZeroMask J z := by + have he : (∃ P ∈ UniqueFactorizationMonoid.normalizedFactors (I * J), z ∈ P) ↔ + (∃ P ∈ UniqueFactorizationMonoid.normalizedFactors I, z ∈ P) ∨ + (∃ P ∈ UniqueFactorizationMonoid.normalizedFactors J, z ∈ P) := by + simp only [UniqueFactorizationMonoid.normalizedFactors_mul hI hJ, Multiset.mem_add, + or_and_right, exists_or] + unfold idealZeroMask + simp only [he] + by_cases h₁ : ∃ P ∈ UniqueFactorizationMonoid.normalizedFactors I, z ∈ P <;> + by_cases h₂ : ∃ P ∈ UniqueFactorizationMonoid.normalizedFactors J, z ∈ P <;> simp [h₁, h₂] + +theorem jointMask_generator (I J : Ideal O) (hI : Admissible I) (hJ : Admissible J) (lengthScale : Ideal O) : + rowCoprimeMask (fun P : gcdMaskPrimes (I * J) => P.val) Finset.univ (idealGenerator lengthScale) = + if Supported lengthScale then idealZeroMask I (primaryGenerator lengthScale) * idealZeroMask J (primaryGenerator lengthScale) else 0 := by + rw [gcdMaskPrimes_mask, idealZeroMask_mul I J hI.1 hJ.1, badPrime_mask, span_idealGenerator] + by_cases hL : Supported lengthScale + · rw [ite_eq_left hL, ite_eq_left hL, one_mul] + have hs : Ideal.span {idealGenerator lengthScale} = Ideal.span {primaryGenerator lengthScale} := + (span_idealGenerator lengthScale).trans (primaryGenerator_spec lengthScale (supported_primaryGenerator_ne_zero lengthScale hL)).1.symm + rw [idealZeroMask_span_eq I _ _ hs, idealZeroMask_span_eq J _ _ hs] + · simp only [ite_eq_right hL, zero_mul] + +theorem jointMask_zero (I J : Ideal O) : + rowCoprimeMask (fun P : gcdMaskPrimes (I * J) => P.val) Finset.univ 0 = 0 := by + rw [gcdMaskPrimes_mask, badPrime_mask] + have h : ¬Supported (Ideal.span {(0 : O)}) := by + intro h + exact h.1 (by simp) + rw [ite_eq_right h, zero_mul] + +end CanonicalQuadraticSieve + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedSixBranches.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedSixBranches.lean new file mode 100644 index 0000000000000000000000000000000000000000..b3bef06d8859980e3594c50940754d6e80b8924d --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedSixBranches.lean @@ -0,0 +1,642 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CorrespondencePullback + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +def arbitraryIntervalWhittaker (a b:ℝ) (ρ:BoundedContinuousFunction ℝ ℂ) (freq s:ℂ) :ℂ:= + ∫v in Set.Icc a b,ρ v*(v:ℂ)^(-s-1)*sourceFourierKernel s (freq*v) + +lemma arbitraryIntervalWhittaker_analyticAt (a b:ℝ) (ha:0sourceEisenstein s (M•w)* + arbitraryCuspWeightedPhase ρ (ninthCuspFrequency h) w + have hg:Continuous g:=((sourceProjection_continuous _ (hyperbolicEisenstein_continuous s hs)).comp + (continuous_hyperbolic_action M)).mul (arbitraryCuspWeightedPhase_continuous ρ _) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg)] + rw [arbitraryIntervalWhittaker,←integral_const_mul] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hv0:0 ActualEisensteinCubic.O + +abbrev RamifiedSixBranch := Unit ⊕ (Unit ⊕ (Unit ⊕ Fin 3)) + +def unitCuspUnramifiedIndex (u t:Eisˣ) (h:Eis) :Eis:= + 3*((↑u⁻¹:Eis)^2*(t:Eis))^2*((↑t⁻¹:Eis)*h) + +def ramifiedSixIndex (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) :RamifiedSixBranch→Eis + | .inl _=>unitCuspUnramifiedIndex 1 (ramifiedCuspRoot side) h + | .inr (.inl _)=>unitCuspUnramifiedIndex (-(ramifiedCuspRoot side)) (-(ramifiedCuspRoot side)) h + | .inr (.inr (.inl _))=>unitCuspUnramifiedIndex (-(ramifiedCuspRoot side)) 1 h + | .inr (.inr (.inr l))=>3*((↑(-(ramifiedCuspRoot side))⁻¹:Eis)^2* + (onceCuspScale (ramifiedCuspScaleUnit side)*omega^l.val))^2* + onceCuspFrequencyQuotient (ramifiedCuspScaleUnit side) h hf l + +def ramifiedSixWeight (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) (i:RamifiedSixBranch) (s:ℂ) :ℂ:= + let t:=ramifiedCuspRoot side + let phase:=ShortDraftTrace.breveE (ninthCuspFrequency h*eisEmbedding (↑t⁻¹:Eis)) + match i with + | .inl _=>(4:ℂ)⁻¹*ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding (t:Eis)) + | .inr (.inl _)=>(4:ℂ)⁻¹*phase*ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding ((-t:Eisˣ):Eis)) + | .inr (.inr (.inl _))=>(4:ℂ)⁻¹*phase*ShortDraftTrace.breveE (ninthCuspFrequency h/eisEmbedding ((1:Eisˣ):Eis)) + | .inr (.inr (.inr l))=>(4:ℂ)⁻¹*phase* + (if (3:Eis)∣onceCuspFrequencyQuotient (ramifiedCuspScaleUnit side) h hf l+ + ramifiedAffineParameter (onceCuspRayIndex (-t) (ramifiedCuspScaleUnit side) l).val 1 then + (3:ℂ)*(3:ℂ)^(-s)*ShortDraftTrace.breveE + (ninthCuspFrequency h/eisEmbedding (onceCuspScale (ramifiedCuspScaleUnit side)*omega^l.val)) else 0) + +lemma ramifiedSixWeight_analytic (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) (i:RamifiedSixBranch) (s:ℂ) : + AnalyticAt ℂ (ramifiedSixWeight side h hf i) s := by + rcases i with i|i + · exact analyticAt_const + rcases i with i|i + · exact analyticAt_const + rcases i with i|i + · exact analyticAt_const + unfold ramifiedSixWeight + dsimp only + split_ifs + · apply analyticAt_const.mul + apply AnalyticAt.mul _ analyticAt_const + apply analyticAt_const.mul + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + exact Eventually.of_forall (fun z=>(differentiableAt_id.neg).const_cpow (Or.inl (by norm_num))) + · exact analyticAt_const + +lemma ramifiedCuspGaussSeries_eq_six (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) (s:ℂ) : + ramifiedCuspGaussSeries side h hf s= + ∑i:RamifiedSixBranch,ramifiedSixWeight side h hf i s* + unramifiedCubicGaussSeries s (ramifiedSixIndex side h hf i) := by + simp only [Fintype.sum_sum_type,Fintype.sum_unique,ramifiedSixWeight,ramifiedSixIndex, + ramifiedCuspGaussSeries,unitCuspGaussSeries,unitCuspUnramifiedIndex,onceCuspGaussSeries] + simp only [Fin.sum_univ_three] + split_ifs <;> ring + +def ramifiedArithmeticResidue (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) :ℂ:= + ∑i:RamifiedSixBranch,ramifiedSixWeight side h hf i (4/3)* + unramifiedGaussResidue (ramifiedSixIndex side h hf i) + +end + +open CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +theorem ramifiedSource_height_residue (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) + (a b:ℝ) (ha:0 + ramifiedSixWeight side h hf i s*arbitraryIntervalWhittaker a b ρ (ninthCuspFrequency h) s + have hc:∀i s,1 + (ramifiedSixWeight_analytic side h hf i s).mul + (arbitraryIntervalWhittaker_analyticAt a b ha ρ (ninthCuspFrequency h) s hs) + have he:=finite_unramified_residue (ramifiedSixIndex side h hf) coeff hc + (sourceArbitraryHeightFamily M a b ha ρ (ninthCuspFrequency h)) + (sourceArbitraryHeightFourier M a b ha ρ (ninthCuspFrequency h) cubicEisensteinResidue) + (sourceArbitraryHeightFamily_analyticAt M a b ha ρ (ninthCuspFrequency h)) + (sourceArbitraryHeightFamily_residue_limit M a b ha ρ (ninthCuspFrequency h)) (by + intro s hs hi + rw [sourceArbitraryHeightFamily_initial M a b ha ρ (ninthCuspFrequency h) s hs hi, + ramifiedSource_height_fourier_average side h hf a b ha ρ s (by linarith), + ramifiedCuspGaussSeries_eq_six,Finset.sum_mul] + apply Finset.sum_congr rfl + intro i hi' + dsimp only [coeff] + ring) + refine he.trans ?_ + rw [ramifiedArithmeticResidue,Finset.sum_mul] + apply Finset.sum_congr rfl + intro i hi + dsimp only [coeff] + ring + +theorem ramifiedSource_height_residue_integral (side:Bool) (h:Eis) + (hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side)) + (a b:ℝ) (ha:0 ActualEisensteinCubic.O + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +def kernelCorrespondenceMatrix (q : IntegralCoverCosets H globalKubotaKernel) : SL(2,ℂ) := + g*integralComplexMatrix (((integralCoverRep H globalKubotaKernel q)⁻¹:globalKubotaKernel):SL(2,ActualEisensteinCubic.O)) + +lemma kernelCorrespondenceTest_field (f : kernelSmoothTests) (p : EuclideanSpatial) : + kernelTestField (kernelCorrespondenceTest hHK hJK e g he f) p= + letI : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + ∑q : IntegralCoverCosets H globalKubotaKernel, + kernelTestField f (euclideanAction (kernelCorrespondenceMatrix g q) p) := by + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + change kernelCorrespondenceFunction hJK e g he f.1 + (integralOrbitProjection globalKubotaKernel (euclideanToHyperbolic p))=_ + rw [kernelCorrespondenceFunction_lift] + apply Finset.sum_congr rfl + intro q _ + change f.1 (integralOrbitProjection globalKubotaKernel + (kernelCorrespondenceMatrix g q•euclideanToHyperbolic p))= + f.1 (integralOrbitProjection globalKubotaKernel + (euclideanToHyperbolic (euclideanAction (kernelCorrespondenceMatrix g q) p))) + rw [euclideanAction,euclideanToHyperbolic_coordinates] + +lemma kernelCorrespondenceTest_energyDensity_le (f : kernelSmoothTests) (w : HyperbolicSpace) : + kernelTestEnergyDensity (kernelCorrespondenceTest hHK hJK e g he f) w≤ + (H.relIndex globalKubotaKernel:ℝ)* + (kernelCorrespondenceFunction hJK e g he (fun q=>(kernelQuotientEnergyDensity f q:ℂ)) + (integralOrbitProjection globalKubotaKernel w)).re := by + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + let p := hyperbolicEuclideanCoordinates w + let A := kernelCorrespondenceMatrix (H:=H) g + have hFd (q : IntegralCoverCosets H globalKubotaKernel) : + DifferentiableAt ℝ (kernelTestField f) (euclideanAction (A q) p) := + (kernelTestField_contDiffAt f _ (euclideanAction_positive _ _)).differentiableAt (by simp) + have hcomp (q : IntegralCoverCosets H globalKubotaKernel) : + DifferentiableAt ℝ (kernelTestField f ∘ euclideanAction (A q)) p := by + obtain ⟨der,hder,_⟩ := hyperbolicDifferentialIsometry (A q) p (hyperbolicHeight_pos w) + exact (hFd q).comp p hder.differentiableAt + have hh := coverEnergyDensity_sum_le Finset.univ + (fun q : IntegralCoverCosets H globalKubotaKernel=>kernelTestField f ∘ euclideanAction (A q)) + p (fun q _=>hcomp q) + have hfield : kernelTestField (kernelCorrespondenceTest hHK hJK e g he f)= + fun p=>∑q : IntegralCoverCosets H globalKubotaKernel,kernelTestField f (euclideanAction (A q) p) := + funext (kernelCorrespondenceTest_field hHK hJK e g he f) + rw [kernelTestEnergyDensity_eq_cover,hfield] + change coverEnergyDensity (fun p=>∑q : IntegralCoverCosets H globalKubotaKernel, + kernelTestField f (euclideanAction (A q) p)) p≤_ + calc + _ ≤ (Fintype.card (IntegralCoverCosets H globalKubotaKernel):ℝ)* + ∑q : IntegralCoverCosets H globalKubotaKernel, + coverEnergyDensity (kernelTestField f ∘ euclideanAction (A q)) p := by + simpa only [Finset.card_univ,Function.comp_def] using hh + _ = _ := by + have hcard : Fintype.card (IntegralCoverCosets H globalKubotaKernel)= + H.relIndex globalKubotaKernel := by + rw [Subgroup.relIndex,Subgroup.index,Nat.card_eq_fintype_card] + rw [hcard,kernelCorrespondenceFunction_lift] + simp only [Complex.re_sum,Complex.ofReal_re] + congr 1 + apply Finset.sum_congr rfl + intro q _ + rw [coverEnergyDensity_comp (A q) _ p (hyperbolicHeight_pos w) (hFd q)] + change coverEnergyDensity (kernelTestField f) (euclideanAction (A q) p)= + kernelTestEnergyDensity f (A q•w) + rw [kernelTestEnergyDensity_eq_cover] + congr 1 + dsimp [p,euclideanAction] + rw [euclideanToHyperbolic_coordinates] + +lemma kernelCorrespondenceTest_energy_le (f : kernelSmoothTests) : + kernelDirichletEnergy (kernelCorrespondenceTest hHK hJK e g he f)≤ + (H.relIndex globalKubotaKernel:ℝ)*(J.relIndex globalKubotaKernel:ℝ)*kernelDirichletEnergy f := by + let density : KernelQuotient→ℂ := fun q=>(kernelQuotientEnergyDensity f q:ℂ) + have hdm : Measurable density := Complex.continuous_ofReal.measurable.comp + (kernelQuotientEnergyDensity_continuous f).measurable + have hdi : Integrable density (integralQuotientVolume globalKubotaKernel) := + (kernelQuotientEnergyDensity_integrable f).ofReal + have hTi := kernelCorrespondenceFunction_integrable hHK hJK e g he density hdm hdi + have hint := kernelCorrespondenceFunction_integral hHK hJK e g he density hdm hdi + have hre : (∫q,(kernelCorrespondenceFunction hJK e g he density q).re + ∂integralQuotientVolume globalKubotaKernel)= + (J.relIndex globalKubotaKernel:ℝ)*kernelDirichletEnergy f := by + have htr := integral_re hTi + have hdf := integral_re hdi + simp only [RCLike.re_to_complex] at htr hdf + rw [htr,hint] + simp only [Complex.mul_re,Complex.natCast_re,Complex.natCast_im,zero_mul,sub_zero] + rw [←hdf] + rfl + unfold kernelDirichletEnergy + calc + _ ≤ ∫q,(H.relIndex globalKubotaKernel:ℝ)* + (kernelCorrespondenceFunction hJK e g he density q).re + ∂integralQuotientVolume globalKubotaKernel := by + apply integral_mono (kernelQuotientEnergyDensity_integrable _) (hTi.re.const_mul _) + intro q + induction q using Quotient.inductionOn with + | _ w => exact kernelCorrespondenceTest_energyDensity_le hHK hJK e g he f w + _ = _ := by + rw [integral_const_mul,hre] + exact (mul_assoc _ _ _).symm + +end + +local notation "O" => ActualEisensteinCubic.O + +variable {H J : Subgroup (SL(2,ActualEisensteinCubic.O))} + (hHK : H≤globalKubotaKernel) (hJK : J≤globalKubotaKernel) + [H.IsFiniteRelIndex globalKubotaKernel] [J.IsFiniteRelIndex globalKubotaKernel] + (e : H≃*J) (g : SL(2,ℂ)) (he : IntegralCoverIntertwines e g) + +def kernelCorrespondenceTestLinear : kernelSmoothTests→ₗ[ℂ]kernelSmoothTests where + toFun := kernelCorrespondenceTest hHK hJK e g he + map_add' f h := by + apply Subtype.ext + funext q + induction q using Quotient.inductionOn with + | _ w => + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + change kernelCorrespondenceFunction hJK e g he (f+h).1 + (integralOrbitProjection globalKubotaKernel w)= + kernelCorrespondenceFunction hJK e g he f.1 (integralOrbitProjection globalKubotaKernel w)+ + kernelCorrespondenceFunction hJK e g he h.1 (integralOrbitProjection globalKubotaKernel w) + simp only [kernelCorrespondenceFunction_lift,Submodule.coe_add,Pi.add_apply,Finset.sum_add_distrib] + map_smul' c f := by + apply Subtype.ext + funext q + induction q using Quotient.inductionOn with + | _ w => + let : Fintype (IntegralCoverCosets H globalKubotaKernel) := Fintype.ofFinite _ + change kernelCorrespondenceFunction hJK e g he (c•f).1 + (integralOrbitProjection globalKubotaKernel w)= + c • kernelCorrespondenceFunction hJK e g he f.1 (integralOrbitProjection globalKubotaKernel w) + simp only [kernelCorrespondenceFunction_lift,Submodule.coe_smul,Pi.smul_apply,Finset.smul_sum] + +lemma kernelCorrespondenceL2_norm_le (F : KernelQuotientL2) : + ‖kernelCorrespondenceL2 hHK hJK e g he F‖≤ + Real.sqrt ((H.relIndex globalKubotaKernel:ℝ)*(J.relIndex globalKubotaKernel:ℝ))*‖F‖ := by + let C := integralConjugatePullback e g he + (hHK.trans globalKubotaKernel_le_levelThree) (hJK.trans globalKubotaKernel_le_levelThree) + let P := integralCoverPullback hJK globalKubotaKernel_le_levelThree + let Tr := integralCoverTrace hHK globalKubotaKernel_le_levelThree + have hTr := integralCoverTrace_opNorm_le hHK globalKubotaKernel_le_levelThree + have hP := integralCoverPullback_norm_le hJK globalKubotaKernel_le_levelThree F + rw [←Real.sqrt_eq_rpow] at hTr hP + change ‖Tr (C (P F))‖≤_ + calc + _ ≤ ‖Tr‖*‖C (P F)‖ := Tr.le_opNorm _ + _ ≤ Real.sqrt (H.relIndex globalKubotaKernel:ℝ)*‖C (P F)‖ := + mul_le_mul_of_nonneg_right hTr (norm_nonneg _) + _ = Real.sqrt (H.relIndex globalKubotaKernel:ℝ)*‖P F‖ := by rw [C.norm_map] + _ ≤ Real.sqrt (H.relIndex globalKubotaKernel:ℝ)* + (Real.sqrt (J.relIndex globalKubotaKernel:ℝ)*‖F‖) := + mul_le_mul_of_nonneg_left hP (Real.sqrt_nonneg _) + _ = _ := by rw [Real.sqrt_mul (Nat.cast_nonneg _)]; ring + +lemma kernelCorrespondenceTest_graph_norm (f : kernelSmoothTests) : + ‖kernelEnergyGraphCore (kernelCorrespondenceTest hHK hJK e g he f)‖≤ + Real.sqrt ((H.relIndex globalKubotaKernel:ℝ)*(J.relIndex globalKubotaKernel:ℝ))* + ‖kernelEnergyGraphCore f‖ := by + have hm := kernelCorrespondenceL2_norm_le hHK hJK e g he (kernelSmoothTestsToL2 f) + have hs := (sq_le_sq₀ (norm_nonneg _) (mul_nonneg (Real.sqrt_nonneg _) (norm_nonneg _))).mpr hm + rw [←kernelCorrespondenceTest_mass hHK hJK e g he,mul_pow, + Real.sq_sqrt (mul_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _))] at hs + apply (sq_le_sq₀ (norm_nonneg _) (mul_nonneg (Real.sqrt_nonneg _) (norm_nonneg _))).mp + rw [kernelEnergyGraphCore_norm_sq,mul_pow, + Real.sq_sqrt (mul_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg _)),kernelEnergyGraphCore_norm_sq] + have he := kernelCorrespondenceTest_energy_le hHK hJK e g he f + nlinarith + +def kernelCorrespondenceEnergy : KernelEnergyGraph→L[ℂ]KernelEnergyGraph := + (kernelEnergyGraphCore.comp (kernelCorrespondenceTestLinear hHK hJK e g he)).extendOfNorm + kernelEnergyGraphCore + +lemma kernelCorrespondenceEnergy_core (f : kernelSmoothTests) : + kernelCorrespondenceEnergy hHK hJK e g he (kernelEnergyGraphCore f)= + kernelEnergyGraphCore (kernelCorrespondenceTest hHK hJK e g he f) := + LinearMap.extendOfNorm_eq kernelEnergyGraphCore_dense + ⟨_,kernelCorrespondenceTest_graph_norm hHK hJK e g he⟩ f + +lemma kernelCorrespondenceEnergy_mass (u : KernelEnergyGraph) : + kernelEnergyMass (kernelCorrespondenceEnergy hHK hJK e g he u)= + kernelCorrespondenceL2 hHK hJK e g he (kernelEnergyMass u) := by + apply congrFun (kernelEnergyGraphCore_dense.equalizer + (kernelEnergyMass.continuous.comp (kernelCorrespondenceEnergy hHK hJK e g he).continuous) + ((kernelCorrespondenceL2 hHK hJK e g he).continuous.comp kernelEnergyMass.continuous) ?_) u + funext f + change kernelEnergyMass (kernelCorrespondenceEnergy hHK hJK e g he (kernelEnergyGraphCore f))= + kernelCorrespondenceL2 hHK hJK e g he (kernelEnergyMass (kernelEnergyGraphCore f)) + rw [kernelCorrespondenceEnergy_core,kernelEnergyMass_core,kernelEnergyMass_core, + kernelCorrespondenceTest_mass] + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def ramifiedCuspShiftNumerator (b : Bool) : Eis := + if b then -2-omega else omega-1 + +lemma ramifiedCuspShift_congr (b : Bool) : + (3:Eis)∣ramifiedCuspShiftNumerator b-onceCuspScale (ramifiedCuspScaleUnit b) := by + refine ⟨-1,?_⟩ + cases b + · simp [ramifiedCuspShiftNumerator,ramifiedCuspScaleUnit,onceCuspScale, + Units.val_neg,ramifiedOmegaUnit_val,ramifiedTraceLambda] + linear_combination 2*ramified_omega_relation + · simp only [ramifiedCuspShiftNumerator,ramifiedCuspScaleUnit,ite_true,onceCuspScale, + Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val,ramifiedTraceLambda] + linear_combination -(2*omega-1)*ramified_omega_relation + +lemma ramifiedCuspShift_support (b : Bool) (h : Eis) : + (3:Eis)∣ramifiedCuspShiftNumerator b-h ↔ + (3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b) := by + constructor + · intro hh + convert dvd_sub (ramifiedCuspShift_congr b) hh using 1 ; ring + · intro hh + convert dvd_sub (ramifiedCuspShift_congr b) hh using 1 ; ring + +lemma ramifiedSource_affine_shift (b : Bool) (x : Eis) (z : ℂ) + (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +def ramifiedScaledMode (b : Bool) (h : Eis) (v : ℝ) (hv : 0ramifiedSourceFunction (ramifiedCuspRoot b:Eis) (upperPoint z v hv)) := by + let c : ℂ→UpperCoordinates := fun z=>⟨(z,v),hv⟩ + have hc : Continuous c := by + apply Continuous.subtype_mk + exact continuous_id.prodMk continuous_const + have ht := continuous_upperCoordinates.comp hc + have ht' : Continuous (fun z : ℂ=>upperPoint z v hv) := by + simpa only [Function.comp_def,c] using ht + exact (ramifiedSourceFunction_continuous _).comp ht' + +theorem ramifiedSource_scaled_fourier_active (b : Bool) (h : Eis) + (hh : (3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit b)) (v : ℝ) (hv : 0ShortDraftTrace.breveE (-ninthCuspFrequency h*z)) := by + change Continuous (fun z : ℂ=>Complex.exp (2*Real.pi*Complex.I* + ((-ninthCuspFrequency h*z)+starRingEnd ℂ (-ninthCuspFrequency h*z)))) + fun_prop + have hi := period_integral_eisenstein_mul + (fun z=>ramifiedSourceFunction (ramifiedCuspRoot b:Eis) (upperPoint z v hv)* + ShortDraftTrace.breveE (-ninthCuspFrequency h*z)) + ((ramifiedSource_height_continuous b v hv).mul hphase).measurable + (ramifiedSource_active_weighted_periodic b h hh v hv) (3:Eis) (by norm_num) + simpa only [map_ofNat,he] using hi + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedTransform.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedTransform.lean new file mode 100644 index 0000000000000000000000000000000000000000..dab9ef8644ead0ec1245b3166ef587ee2444f0d6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/RamifiedTransform.lean @@ -0,0 +1,629 @@ +import OAI.NumberTheory.DirichletL.GaussSum.MellinSupport +import OAI.NumberTheory.DirichletL.GaussSum.FiniteTranslations + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def lowRamifiedTransform (F:Eis→ℂ) (h:Eis) :ℂ := + 3*F (9*h)+∑u:Eisˣ,∑k:Fin 5,ramifiedRawWeight h u k.val* + F (h*(9*(u.val*lambda^(k.val+2)))) + +lemma principalArithmeticResidue_low (a r:Fin 3) (n:Eis) (hn:lambda^2∣n-1) : + principalArithmeticResidue (lowRamifiedFrequency a r*n)= + (∑u:Eisˣ,∑k:Fin 5,ramifiedRawWeight (lowRamifiedFrequency a r*n) u k.val* + unramifiedGaussResidue ((lowRamifiedFrequency a r*n)*(9*(u.val*lambda^(k.val+2)))))/ + ((9*Real.sqrt 3/2:ℝ):ℂ) := by + let h:=lowRamifiedFrequency a r*n + have hh:h≠0:=mul_ne_zero (lowRamifiedFrequency_ne_zero a r) (primary_ne_zero n hn) + let N:=max (ramifiedFrequencyBound h+1) 5 + rw [principalArithmeticResidue_eq_sum h hh N (le_max_left _ _)] + apply congrArg (fun z:ℂ=>z/((9*Real.sqrt 3/2:ℝ):ℂ)) + apply Finset.sum_congr rfl + intro u hu + change (∑k∈Finset.range N,principalResidueTerm h u k)= + ∑k:Fin 5,principalResidueTerm h u k.val + rw [Fin.sum_univ_eq_sum_range] + symm + apply Finset.sum_subset (Finset.range_mono (le_max_right _ _)) + intro k hk hk5 + have hz:=lowRamifiedFrequency_primary_vanish a r n hn u k + (by simpa only [Finset.mem_range,not_lt] using hk5) + simp only [principalResidueTerm,h,hz,mul_zero,zero_mul] + +lemma sourceRayPhase_of_three_dvd (h:Eis) (hh:(3:Eis)∣h) : + ShortDraftTrace.breveE (cuspFrequency h)=1 := by + obtain ⟨z,rfl⟩:=hh + have he:cuspFrequency ((3:Eis)*z)=eisEmbedding z/eisLam:=by + simp only [cuspFrequency,map_mul,map_ofNat] + ring + rw [he] + exact breveE_embedding_div_traceLambda z + +lemma lowRamifiedFrequency_three_dvd (a r:Fin 3) : (3:Eis)∣lowRamifiedFrequency a r := by + simpa only [lowRamifiedFrequency,←ramifiedOmegaUnit_val,←Units.val_pow_eq_pow_val] using + ramifiedElement_level (ramifiedOmegaUnit^a.val) (r.val+2) (by omega) + +theorem lowRamifiedTransform_actual (a r:Fin 3) (n:Eis) (hn:lambda^2∣n-1) : + lowRamifiedTransform unramifiedGaussResidue (lowRamifiedFrequency a r*n)= + (4*((9*Real.sqrt 3/2:ℝ):ℂ))*sourceArithmeticResidue (lowRamifiedFrequency a r*n) := by + rw [sourceArithmeticResidue,ite_eq_left (sourceRayPhase_of_three_dvd _ + (dvd_mul_of_dvd_left (lowRamifiedFrequency_three_dvd a r) n)), + principalArithmeticResidue_low a r n hn] + unfold lowRamifiedTransform + field_simp [show ((9*Real.sqrt 3/2:ℝ):ℂ)≠0 by exact_mod_cast (show (9*Real.sqrt 3/2:ℝ)≠0 by positivity)] + ; ring + +lemma lowRamifiedTransform_sub (F G:Eis→ℂ) (h:Eis) : + lowRamifiedTransform (fun x=>F x-G x) h= + lowRamifiedTransform F h-lowRamifiedTransform G h := by + simp only [lowRamifiedTransform,mul_sub,Finset.sum_sub_distrib] + ring + +lemma ramifiedRawWeight_frequency_cube (h p:Eis) (hp:lambda^2∣p-1) (u:Eisˣ) (k:ℕ) : + ramifiedRawWeight (h*p^3) u k=ramifiedRawWeight h u k := by + rw [ramifiedRawWeight,ramifiedRawWeight,arithmeticResidueSum_frequency_cube h _ p + (ramifiedElement_ne_zero u (k+2)) (ramifiedElement_level u (k+2) (by omega)) hp + (ramified_primary_coprime u (k+2) p hp).of_mul_left_right] + +lemma lowRamifiedTransform_cube_comp (F:Eis→ℂ) (h p:Eis) (hp:lambda^2∣p-1) : + lowRamifiedTransform (fun x=>F (x*p^3)) h=lowRamifiedTransform F (h*p^3) := by + simp only [lowRamifiedTransform,ramifiedRawWeight_frequency_cube h p hp] + have he:9*h*p^3=9*(h*p^3):=by ring + rw [he] + congr 1 + apply Finset.sum_congr rfl + intro u hu + apply Finset.sum_congr rfl + intro k hk + congr 1 + ring_nf + +theorem lowRamifiedTransform_cube_difference (p:Eis) (hp:Prime p) (hpp:lambda^2∣p-1) + (a r:Fin 3) (n:Eis) (hn:lambda^2∣n-1) : + lowRamifiedTransform (fun x=>unramifiedGaussResidue (x*p^3)-unramifiedGaussResidue x) + (lowRamifiedFrequency a r*n)=0 := by + rw [lowRamifiedTransform_sub,lowRamifiedTransform_cube_comp _ _ p hpp] + have hnp:lambda^2∣n*p^3-1:=primary_mul n (p^3) hn (primary_pow_congruence p hpp 3) + rw [mul_assoc,lowRamifiedTransform_actual a r (n*p^3) hnp, + lowRamifiedTransform_actual a r n hn] + rw [←mul_assoc,sourceArithmeticResidue_prime_cube p hp hpp _ + (mul_ne_zero (lowRamifiedFrequency_ne_zero a r) (primary_ne_zero n hn)),sub_self] + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +lemma ramifiedFunction_reduce (F:Eis→ℂ) (hneg:∀x,F (-x)=F x) + (hpow:∀x m,F (x*lambda^m)=F (x*lambda^(m%3))) (n:Eis) (u:Eisˣ) (m:ℕ) : + ∃j k:Fin 3,F (n*((u:Eis)*lambda^m))=F (n*omega^j.val*lambda^k.val) := by + obtain ⟨j,hj|hj⟩:=unit_eq_sign_omega u + · refine ⟨j,⟨m%3,Nat.mod_lt _ (by decide)⟩,?_⟩ + rw [hj,←mul_assoc,hpow] + · refine ⟨j,⟨m%3,Nat.mod_lt _ (by decide)⟩,?_⟩ + rw [hj,neg_mul,mul_neg,hneg,←mul_assoc,hpow] + +lemma ramifiedFunction_family_bound (F:Eis→ℂ) (hneg:∀x,F (-x)=F x) + (hpow:∀x m,F (x*lambda^m)=F (x*lambda^(m%3))) (n:Eis) (M:ℝ) + (hM:∀j k:Fin 3,‖F (n*omega^j.val*lambda^k.val)‖≤M) (u:Eisˣ) (m:ℕ) : + ‖F (n*((u:Eis)*lambda^m))‖≤M := by + obtain ⟨j,k,hjk⟩:=ramifiedFunction_reduce F hneg hpow n u m + rw [hjk] + exact hM j k + +lemma ramifiedNine_eq : (9:Eis)=omega*lambda^4 := by + have hw:omega^2=-omega-1:=by linear_combination ramified_omega_relation + have hl:lambda^2=-3*omega:=by + change (omega-1)^2=-3*omega + linear_combination hw + calc + (9:Eis)=9*omega^3:=by rw [omega_primitive.pow_eq_one]; ring + _=omega*((-3*omega)^2):=by ring + _=omega*((lambda^2)^2):=by rw [hl] + _=omega*lambda^4:=by ring + +lemma lowRamified_inner_family (a r:Fin 3) (n:Eis) (u:Eisˣ) (k:ℕ) : + (lowRamifiedFrequency a r*n)*(9*(u.val*lambda^(k+2)))= + n*((↑(ramifiedOmegaUnit^(a.val+1)*u):Eis)*lambda^(r.val+k+8)) := by + simp only [lowRamifiedFrequency,ramifiedNine_eq,Units.val_mul,Units.val_pow_eq_pow_val, + ramifiedOmegaUnit_val] + rw [show r.val+k+8=(r.val+2)+(4+(k+2)) by omega] + simp only [pow_add,pow_one] + ring + +lemma lowRamifiedLeading (F:Eis→ℂ) + (hpow:∀x m,F (x*lambda^m)=F (x*lambda^(m%3))) (n:Eis) (j k:Fin 3) : + F (9*(lowRamifiedFrequency ⟨(j.val+2)%3,Nat.mod_lt _ (by decide)⟩ k*n))= + F (n*omega^j.val*lambda^k.val) := by + have ho:omega^((j.val+2)%3+1)=omega^j.val:=by + fin_cases j <;> norm_num [omega_primitive.pow_eq_one] + have he:9*(lowRamifiedFrequency ⟨(j.val+2)%3,Nat.mod_lt _ (by decide)⟩ k*n)= + (n*omega^j.val)*lambda^(k.val+6):=by + simp only [lowRamifiedFrequency,ramifiedNine_eq] + rw [show k.val+6=4+(k.val+2) by omega,pow_add,←ho,pow_succ] + ring + rw [he,hpow,show (k.val+6)%3=k.val by omega] + +lemma lowRamified_remainder_bound (F:Eis→ℂ) (hneg:∀x,F (-x)=F x) + (hpow:∀x m,F (x*lambda^m)=F (x*lambda^(m%3))) (n:Eis) (hn:lambda^2∣n-1) + (M:ℝ) (hM0:0≤M) (hM:∀j k:Fin 3,‖F (n*omega^j.val*lambda^k.val)‖≤M) + (a r:Fin 3) : + ‖∑u:Eisˣ,∑k:Fin 5,ramifiedRawWeight (lowRamifiedFrequency a r*n) u k.val* + F ((lowRamifiedFrequency a r*n)*(9*(u.val*lambda^(k.val+2))))‖≤(5/3)*M := by + calc + _≤∑u:Eisˣ,∑k:Fin 5,‖ramifiedRawWeight (lowRamifiedFrequency a r*n) u k.val* + F ((lowRamifiedFrequency a r*n)*(9*(u.val*lambda^(k.val+2))))‖:=by + exact (norm_sum_le _ _).trans (Finset.sum_le_sum (fun u hu=>norm_sum_le _ _)) + _≤∑u:Eisˣ,∑k:Fin 5,‖ramifiedRawWeight (lowRamifiedFrequency a r*n) u k.val‖*M:=by + apply Finset.sum_le_sum + intro u hu + apply Finset.sum_le_sum + intro k hk + rw [norm_mul,lowRamified_inner_family] + exact mul_le_mul_of_nonneg_left (ramifiedFunction_family_bound F hneg hpow n M hM _ _) (norm_nonneg _) + _=(∑u:Eisˣ,∑k:Fin 5,‖ramifiedRawWeight (lowRamifiedFrequency a r*n) u k.val‖)*M:=by + simp only [Finset.sum_mul] + _≤(5/3)*M:=mul_le_mul_of_nonneg_right (lowRamifiedRawWeight_sum a r n hn) hM0 + +theorem lowRamifiedTransform_injective (F:Eis→ℂ) (hneg:∀x,F (-x)=F x) + (hpow:∀x m,F (x*lambda^m)=F (x*lambda^(m%3))) (n:Eis) (hn:lambda^2∣n-1) + (hz:∀a r:Fin 3,lowRamifiedTransform F (lowRamifiedFrequency a r*n)=0) : + ∀j k:Fin 3,F (n*omega^j.val*lambda^k.val)=0 := by + obtain ⟨i,hi,himax⟩:=Finset.exists_max_image (Finset.univ:Finset (Fin 3×Fin 3)) + (fun i=>‖F (n*omega^i.1.val*lambda^i.2.val)‖) Finset.univ_nonempty + let M:=‖F (n*omega^i.1.val*lambda^i.2.val)‖ + have hM:∀j k:Fin 3,‖F (n*omega^j.val*lambda^k.val)‖≤M:=by + intro j k + exact himax (j,k) (Finset.mem_univ _) + let a:Fin 3:=⟨(i.1.val+2)%3,Nat.mod_lt _ (by decide)⟩ + have hb:=lowRamified_remainder_bound F hneg hpow n hn M (norm_nonneg _) hM a i.2 + have he:=hz a i.2 + unfold lowRamifiedTransform at he + have hlead:F (9*(lowRamifiedFrequency a i.2*n))=F (n*omega^i.1.val*lambda^i.2.val):= + lowRamifiedLeading F hpow n i.1 i.2 + rw [hlead] at he + have hnorm:3*M≤(5/3)*M:=by + have heq:3*F (n*omega^i.1.val*lambda^i.2.val)= + -(∑u:Eisˣ,∑k:Fin 5,ramifiedRawWeight (lowRamifiedFrequency a i.2*n) u k.val* + F ((lowRamifiedFrequency a i.2*n)*(9*(u.val*lambda^(k.val+2))))):=by + linear_combination he + have hh:=congrArg norm heq + rw [norm_mul,Complex.norm_ofNat,norm_neg] at hh + exact hh.le.trans hb + have hmzero:M=0:=by have hm0:0≤M:=norm_nonneg _; nlinarith + intro j k + exact norm_eq_zero.mp (le_antisymm (hmzero ▸ hM j k) (norm_nonneg _)) + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma exists_primary_unit_lambda_factor (h:Eis) (hh:h≠0) : + ∃n:Eis,∃u:Eisˣ,∃m:ℕ,lambda^2∣n-1 ∧ h=n*((u:Eis)*lambda^m) := by + obtain ⟨⟨m,J⟩,hm⟩:=lambdaFactorMap_bijective.2 + ⟨Ideal.span {h},Ideal.span_singleton_eq_bot.not.mpr hh⟩ + have hi:ramifiedIdeal^m*J.val=Ideal.span {h}:=congrArg Subtype.val hm + have hs:Ideal.span {lambda^m*primaryGenerator J.val}=Ideal.span {h}:=by + rw [lambdaFactor_generator_span,hi] + obtain ⟨u,hu⟩:=Ideal.span_singleton_eq_span_singleton.mp hs + refine ⟨primaryGenerator J.val,u,m,(primaryGenerator_spec J.val J.property).2,?_⟩ + linear_combination -hu + +theorem unramifiedGaussResidue_prime_cube (p:Eis) (hp:Prime p) + (hpp:lambda^2∣p-1) (h:Eis) : + unramifiedGaussResidue (h*p^3)=unramifiedGaussResidue h := by + by_cases hh:h=0 + · simp only [hh,zero_mul] + obtain ⟨n,u,m,hn,hfactor⟩:=exists_primary_unit_lambda_factor h hh + let F:Eis→ℂ:=fun x=>unramifiedGaussResidue (x*p^3)-unramifiedGaussResidue x + have hneg:∀x,F (-x)=F x:=by + intro x + dsimp only [F] + rw [neg_mul,unramifiedGaussResidue_neg,unramifiedGaussResidue_neg] + have hpow:∀x k,F (x*lambda^k)=F (x*lambda^(k%3)):=by + intro x k + dsimp only [F] + have h1:unramifiedGaussResidue ((x*lambda^k)*p^3)= + unramifiedGaussResidue ((x*lambda^(k%3))*p^3):=by + rw [show (x*lambda^k)*p^3=(x*p^3)*lambda^k by ring, + show (x*lambda^(k%3))*p^3=(x*p^3)*lambda^(k%3) by ring] + exact unramifiedGaussResidue_lambda_pow (x*p^3) k + exact congrArg₂ (fun a b:ℂ=>a-b) h1 (unramifiedGaussResidue_lambda_pow x k) + have hz:∀j k:Fin 3,F (n*omega^j.val*lambda^k.val)=0:= + lowRamifiedTransform_injective F hneg hpow n hn + (fun a r=>lowRamifiedTransform_cube_difference p hp hpp a r n hn) + obtain ⟨j,k,hjk⟩:=ramifiedFunction_reduce F hneg hpow n u m + have hF:F h=0:=by rw [hfactor,hjk,hz] + exact sub_eq_zero.mp hF + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma unramifiedGaussResidue_prime_pow_mod (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (_hh:h≠0) (n:ℕ) : + unramifiedGaussResidue (h*p^n)=unramifiedGaussResidue (h*p^(n%3)) := by + induction n using Nat.strong_induction_on with + | h n ih=> + by_cases hn:n<3 + · rw [Nat.mod_eq_of_lt hn] + · have hn3:3≤n:=by omega + have he:h*p^n=(h*p^(n-3))*p^3:=by rw [mul_assoc,←pow_add,Nat.sub_add_cancel hn3] + rw [he,unramifiedGaussResidue_prime_cube p hp hprimary _, + ih (n-3) (by omega)] + have hm:(n-3)%3=n%3:=by omega + rw [hm] + +theorem unramifiedGaussResidue_prime_square (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + unramifiedGaussResidue (h*p^2)=0 := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + have he:=unramifiedGaussResidue_square_cube p hp hprimary h hph + rw [show h*p^5=(h*p^2)*p^3 by ring, + unramifiedGaussResidue_prime_cube p hp hprimary _] at he + have hq:(Ideal.absNorm (Ideal.span {p}):ℂ)≠0:=Nat.cast_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + have hz:(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*unramifiedGaussResidue (h*p^2)=0:=by + linear_combination -he + exact (mul_eq_zero.mp hz).resolve_left (inv_ne_zero hq) + +theorem unramifiedGaussResidue_prime_factor (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + unramifiedGaussResidue (h*p)= + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ))* + primeCubicGauss p hp hprimary 2 h*unramifiedGaussResidue h := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + have hrec:=unramifiedGaussResidue_prime_recurrence p hp hprimary h hph + rw [unramifiedGaussResidue_prime_cube p hp hprimary h] at hrec + have hrel:(Ideal.absNorm (Ideal.span {p}):ℂ)^(-(4/3:ℂ))* + primeCubicGauss p hp hprimary 1 h*unramifiedGaussResidue (h*p)= + (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*unramifiedGaussResidue h:=by + linear_combination hrec + have hG:=primeCubicGauss_one_mul_two p hp hprimary h hph + let q:ℂ:=(Ideal.absNorm (Ideal.span {p}):ℂ) + have hq:q≠0:=Nat.cast_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero)) + have hpower:q^(-(2/3:ℂ))*q^(-(4/3:ℂ))*q^2=1:=by + rw [←Complex.cpow_add _ _ hq,←Complex.cpow_natCast q 2, + ←Complex.cpow_add _ _ hq] + norm_num + calc + unramifiedGaussResidue (h*p)= + (q^(-(2/3:ℂ))*q^(-(4/3:ℂ))*q^2)*unramifiedGaussResidue (h*p):=by rw [hpower,one_mul] + _=q^(-(2/3:ℂ))*q*primeCubicGauss p hp hprimary 2 h* + (q^(-(4/3:ℂ))*primeCubicGauss p hp hprimary 1 h*unramifiedGaussResidue (h*p)):=by + calc + _=q^(-(2/3:ℂ))*q^(-(4/3:ℂ))*q* + (primeCubicGauss p hp hprimary 1 h*primeCubicGauss p hp hprimary 2 h)* + unramifiedGaussResidue (h*p):=by rw [hG];ring + _=_:=by ring + _=q^(-(2/3:ℂ))*q*primeCubicGauss p hp hprimary 2 h*(q⁻¹*unramifiedGaussResidue h):=by rw [hrel] + _=_:=by + change q^(-(2/3:ℂ))*q*primeCubicGauss p hp hprimary 2 h*(q⁻¹*unramifiedGaussResidue h)= + q^(-(2/3:ℂ))*primeCubicGauss p hp hprimary 2 h*unramifiedGaussResidue h + field_simp [hq] + +theorem unramifiedGaussResidue_prime_power_table (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (n:ℕ) : + unramifiedGaussResidue (h*p^n)= + if n%3=0 then unramifiedGaussResidue h + else if n%3=1 then + (Ideal.absNorm (Ideal.span {p}):ℂ)^(-(2/3:ℂ))* + primeCubicGauss p hp hprimary 2 h*unramifiedGaussResidue h + else 0 := by + have hh:h≠0:=fun he=>hph (he▸dvd_zero p) + rw [unramifiedGaussResidue_prime_pow_mod p hp hprimary h hh n] + split_ifs with h0 h1 + · simp only [h0,pow_zero,mul_one] + · simp only [h1,pow_one] + exact unramifiedGaussResidue_prime_factor p hp hprimary h hph + · have hn:n%3=2:=by omega + rw [hn,unramifiedGaussResidue_prime_square p hp hprimary h hph] + +end + +section +open scoped BigOperators Classical +open MeasureTheory +open Finset AddChar MulChar EisensteinEmbedding + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def thetaFrequencyScale : ℂ := 1/((3:ℂ)*eisLam) +def thetaBesselScale : ℝ := ‖thetaFrequencyScale‖ +def thetaDerivativeScalar : ℂ := + (-2*Real.pi*Complex.I)*star thetaFrequencyScale*infinityCoefficientScalar + +lemma thetaFrequencyScale_ne_zero : thetaFrequencyScale≠0 := by + exact one_div_ne_zero (mul_ne_zero (by norm_num) eisLam_ne_zero) + +lemma thetaBesselScale_pos : 0infinityCoefficientScalar*z) he + simp only [←mul_assoc,mul_inv_cancel₀ infinityCoefficientScalar_ne_zero,one_mul] at he' + rw [completedCoefficient_mul_length Ψ I J hI hJ hsq,cuspFrequency_eq_thetaFrequencyScale,star_mul] + unfold thetaDerivativeScalar + calc + _ = (-2*Real.pi*Complex.I*star thetaFrequencyScale)* + star (eisEmbedding (primaryGenerator I.val*(primaryGenerator J.val)^3))* + (star (sourceResidualFourierCoefficient (primaryGenerator I.val*(primaryGenerator J.val)^3))* + fixedThetaTwist Ψ (primaryGenerator I.val*(primaryGenerator J.val)^3)) := by ring + _ = _ := by rw [he'];ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def thetaTwistedSource (Ψ : Eis→*ℂ) (c : Eis) (hc : c≠0) + [Fintype (Eis⧸Ideal.span {c})] (v : ℝ) (hv : 0(-2*Real.pi*Complex.I*star (cuspFrequency h))* + fixedThetaTwist Ψ h*(v:ℂ)*schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v) + have hw : ∀h:Eis,w h≠0→lambda^2∣h-1 := by + intro h hwh + by_contra hh + exact hwh (by simp only [w,fixedThetaTwist_not_primary Ψ h hh,mul_zero,zero_mul]) + calc + _ = ∑'h:Eis,w h*star (sourceResidualFourierCoefficient h) := by + apply tsum_congr + intro h + dsimp only [w] + ring + _ = ∑'p:({I:Ideal Eis // Squarefree I ∧ primaryGenerator I≠0} × + {J:Ideal Eis // primaryGenerator J≠0}), + w (primaryGenerator p.1.val*(primaryGenerator p.2.val)^3)* + star (sourceResidualFourierCoefficient + (primaryGenerator p.1.val*(primaryGenerator p.2.val)^3)) := + sourceFourier_tsum_primary_pairs w hw + _ = thetaDerivativeScalar*completedBesselProfile Ψ thetaBesselScale v := by + rw [completedBesselProfile_primary_pairs,←tsum_mul_left] + apply tsum_congr + intro p + let ip := primaryCubePairToMellinIndex p + have he := thetaPair_derivative_coefficient Ψ ip.1 ip.2 p.1.property.2 p.2.property p.1.property.1 + have hn := thetaPair_frequency_norm ip.1 ip.2 p.1.property.2 p.2.property + change (-2*Real.pi*Complex.I*star (cuspFrequency (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)))* + fixedThetaTwist Ψ (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)*(v:ℂ)* + schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)‖*v)* + star (sourceResidualFourierCoefficient (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)) = + thetaDerivativeScalar*((completedMellinCoefficient Ψ ip*(completedMellinLength ip:ℂ))*(v:ℂ)* + schlafliBesselK (1/3) (4*Real.pi*thetaBesselScale*Real.sqrt (completedMellinLength ip)*v)) + rw [hn,show 4*Real.pi*(thetaBesselScale*Real.sqrt (completedMellinLength ip))*v= + 4*Real.pi*thetaBesselScale*Real.sqrt (completedMellinLength ip)*v by ring] + calc + _ = ((-2*Real.pi*Complex.I*star (cuspFrequency (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)))* + fixedThetaTwist Ψ (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)* + star (sourceResidualFourierCoefficient (primaryGenerator ip.1.val*(primaryGenerator ip.2.val)^3)))* + (v:ℂ)*schlafliBesselK (1/3) (4*Real.pi*thetaBesselScale*Real.sqrt (completedMellinLength ip)*v) := by ring + _ = _ := by rw [he];ring + +end + +open scoped BigOperators Classical +open MeasureTheory +open Finset AddChar MulChar EisensteinEmbedding + +open ActualEisensteinCubic ConcreteTraceCRT CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma horizontalWirtingerBar_finite_sum {ι : Type*} [Fintype ι] + (f : ι→ℂ→ℂ) (weight : ι→ℂ) (z : ℂ) + (h1 : ∀i,DifferentiableAt ℝ (fun t:ℝ=>f i (z+(t:ℂ))) 0) + (hI : ∀i,DifferentiableAt ℝ (fun t:ℝ=>f i (z+(t:ℂ)*Complex.I)) 0) : + horizontalWirtingerBar (fun w=>∑i,weight i*f i w) z= + ∑i,weight i*horizontalWirtingerBar (f i) z := by + unfold horizontalWirtingerBar + rw [deriv_fun_sum (fun i hi=>(h1 i).const_mul (weight i)), + deriv_fun_sum (fun i hi=>(hI i).const_mul (weight i))] + simp only [deriv_const_mul_field,Finset.mul_sum,←Finset.sum_add_distrib] + apply Finset.sum_congr rfl + intro i hi + ring + +lemma finiteConjugateSource_wirtingerBar_sum {ι : Type*} [Fintype ι] + (shift weight : ι→ℂ) (v : ℝ) (hv : 0cubicSourceConjugateFunction (upperPoint (((t:ℂ)*direction)+shift i) v hv)) 0 := by + have he : (fun t:ℝ=>cubicSourceConjugateFunction (upperPoint (((t:ℂ)*direction)+shift i) v hv))= + fun t:ℝ=>star (sourceBesselCoefficients.fullFunction ((3*(Real.pi:ℂ))*constantArithmeticResidue) + (upperPoint (shift i+(t:ℂ)*direction) v hv)) := by + funext t + simp only [cubicSourceConjugateFunction,cubicSourceResidualFunction_eq_bessel,sourceBesselFunction,add_comm] + rw [he] + exact (sourceBesselCoefficients.fullFunction_horizontal_hasDerivAt _ v hv (shift i) direction 0).differentiableAt.star + rw [show finiteConjugateSource shift weight v hv= + fun w=>∑i,weight i*cubicSourceConjugateFunction (upperPoint (w+shift i) v hv) from rfl] + rw [horizontalWirtingerBar_finite_sum _ weight 0 + (fun i=>by simpa only [zero_add,mul_one] using hd i 1) + (fun i=>by simpa only [zero_add] using hd i Complex.I)] + apply Finset.sum_congr rfl + intro i hi + rw [cuspBarProfile_positive _ _ _ hv] + apply congrArg (fun z : ℂ => weight i * z) + exact horizontalWirtingerBar_translate (fun z=>cubicSourceConjugateFunction (upperPoint z v hv)) (shift i) + +def thetaTwistedCuspProfile (Ψ : Eis→*ℂ) (c : Eis) (hc : c≠0) + [Fintype (Eis⧸Ideal.span {c})] (v : ℝ) : ℂ := + ∑h:Eis⧸Ideal.span {c},finiteAdditiveFourierCoeff (quotientTrace c hc) + (fixedThetaQuotient Ψ c) h*cuspBarProfile cubicSourceConjugateFunction (thetaFourierTranslation c h) v + +theorem thetaTwistedCuspProfile_eq_completedBesselProfile + (Ψ : Eis→*ℂ) (Q : Ideal Eis) (hΨ : CanonicalCoefficientClass.FactorsModulo Q Ψ) + (c : Eis) (hc : c≠0) [Fintype (Eis⧸Ideal.span {c})] + (hcQ : Ideal.span {c}≤Ideal.span {(9:Eis)}*Q) (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +lemma ramifiedFunction_valuation_ne_two (F:Eis→ℂ) + (hzero:∀(p:Eis),Prime p→lambda^2∣p-1→∀h:Eis,¬p∣h→∀k:ℕ,k%3=2→F (h*p^k)=0) + (I P:Ideal Eis) (hI:primaryGenerator I≠0) (hP:P∈normalizedFactors I) + (u:Eisˣ) (m:ℕ) (hF:F ((u.val*lambda^m)*primaryGenerator I)≠0) : + (normalizedFactors I).count P%3≠2 := by + have hI0:=primaryGenerator_ne_zero_ideal I hI + have hprime:=prime_of_normalized_factor P hP + let p:=primaryPrime P + have hp0:p≠0:=primaryPrime_factor_ne_zero I P hI hP + have hps:=primaryPrime_spec P hp0 + have hp:Prime p:=primaryPrime_isPrime_of_mem I P hI (Multiset.mem_toFinset.mpr hP) + obtain ⟨J,hJ,hnot⟩:=(FiniteMultiplicity.of_prime_left hprime hI0).exists_eq_pow_mul_and_not_dvd + have hgen:primaryGenerator I=p^(multiplicity P I)*primaryGenerator J:=by + calc + _=primaryGenerator (P^(multiplicity P I)*J):=congrArg primaryGenerator hJ + _=p^(multiplicity P I)*primaryGenerator J:=by + rw [primaryGenerator_mul,primaryGenerator_pow] + have he:primaryGenerator P=p:=by + rw [←hps.2.2.1,primaryGenerator_span p hp0 hps.2.2.2] + rw [he] + have hgJ:primaryGenerator J≠0:=by + intro hz + exact hI (by rw [hgen,hz,mul_zero]) + have hpd:¬p∣primaryGenerator J:=by + intro hd + apply hnot + rw [Ideal.dvd_iff_le,←hps.2.2.1,←(primaryGenerator_spec J hgJ).1, + Ideal.span_singleton_le_span_singleton] + exact hd + have hbase:¬p∣(u.val*lambda^m)*primaryGenerator J:=by + intro hd + rcases hp.dvd_mul.mp hd with hd|hd + · exact hp.not_isUnit (((ramified_primary_coprime u m p hps.2.2.2).of_mul_left_right).symm.isUnit_of_dvd hd) + · exact hpd hd + have hcount:=multiplicity_eq_count_normalizedFactors hprime.irreducible hI0 + rw [normalize_normalized_factor P hP] at hcount + intro hc + have hm:(multiplicity P I)%3=2:=by rwa [hcount] + apply hF + rw [hgen,show (u.val*lambda^m)*(p^(multiplicity P I)*primaryGenerator J)= + ((u.val*lambda^m)*primaryGenerator J)*p^(multiplicity P I) by ring] + exact hzero p hp hps.2.2.2 _ hbase _ hm + +theorem ramifiedBesselValue_squarefree_cube_support (side:Bool) (h:Eis) (hh:h≠0) + (hB:ramifiedBesselValue side h≠0) : + ∃(u:Eisˣ) (m:ℕ) (I J:Ideal Eis),Squarefree I ∧ + primaryGenerator I≠0 ∧ primaryGenerator J≠0 ∧ + h=(u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3 := by + obtain ⟨n,u,m,hn,he⟩:=exists_primary_unit_lambda_factor h hh + let T:Ideal Eis:=Ideal.span {n} + have hT:primaryGenerator T=n:=primaryGenerator_span n (primary_ne_zero n hn) hn + have hT0:primaryGenerator T≠0:=by rw [hT]; exact primary_ne_zero n hn + have hFT:ramifiedBesselValue side ((u.val*lambda^m)*primaryGenerator T)≠0:=by + rw [hT,mul_comm] + rwa [←he] + have hv:∀P∈normalizedFactors T,(normalizedFactors T).count P%3≠2:=by + intro P hP + exact ramifiedFunction_valuation_ne_two (ramifiedBesselValue side) + (fun p hp hpp h hph k hk=>ramifiedBesselValue_prime_power_vanish side p hp hpp h hph k hk) + T P hT0 hP u m hFT + have hparts:=thetaParts_mul_cube T (primaryGenerator_ne_zero_ideal T hT0) hv + have hgen:primaryGenerator T=primaryGenerator (thetaSquarefreePart T)* + (primaryGenerator (thetaCubePart T))^3:=by + calc + _=primaryGenerator (thetaSquarefreePart T*thetaCubePart T^3):=congrArg primaryGenerator hparts.symm + _=_:=by rw [primaryGenerator_mul,primaryGenerator_pow] + have hA:primaryGenerator (thetaSquarefreePart T)≠0:=by + intro hz + exact hT0 (by rw [hgen,hz,zero_mul]) + have hC:primaryGenerator (thetaCubePart T)≠0:=by + intro hz + exact hT0 (by rw [hgen,hz,zero_pow (by decide : (3:ℕ)≠0),mul_zero]) + refine ⟨u,m,thetaSquarefreePart T,thetaCubePart T,thetaSquarefreePart_squarefree T,hA,hC,?_⟩ + rw [he,←hT,hgen] + ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma onceCuspScale_not_three_dvd (t:Eisˣ) : ¬(3:Eis)∣onceCuspScale t := by + rintro ⟨z,hz⟩ + have hq:Ideal.absNorm (Ideal.span {onceCuspScale t})=3:=by + simpa only [Fin.val_zero,pow_zero,mul_one] using onceCusp_q_absNorm t 0 + have he:=congrArg (fun x:Eis=>Ideal.absNorm (Ideal.span {x})) hz + rw [hq,←Ideal.span_singleton_mul_span_singleton,map_mul,three_absNorm] at he + omega + +lemma onceCuspScale_lambda_dvd (t:Eisˣ) : lambda∣onceCuspScale t := by + refine ⟨(t:Eis)*(traceRamifiedUnit:Eis),?_⟩ + rw [onceCuspScale,trace_eq_ramifiedUnit] + ring + +theorem ramifiedBesselValue_exact_lambda_valuation (side:Bool) (h:Eis) + (hb:ramifiedBesselValue side h≠0) : lambda∣h ∧ ¬lambda^2∣h := by + have hf:(3:Eis)∣h-onceCuspScale (ramifiedCuspScaleUnit side):=by + by_contra hnot + exact hb (by simp only [ramifiedBesselValue,dite_eq_right hnot]) + have hl3:lambda∣(3:Eis):= + (dvd_pow_self lambda (by decide : (2:ℕ)≠0)).trans lambda_sq_dvd_three + constructor + · have hd:=hl3.trans hf + simpa only [sub_add_cancel] using dvd_add hd + (onceCuspScale_lambda_dvd (ramifiedCuspScaleUnit side)) + · intro h2 + have h3:(3:Eis)∣h:=three_dvd_lambda_sq.trans h2 + have hq:(3:Eis)∣onceCuspScale (ramifiedCuspScaleUnit side):=by + convert dvd_sub h3 hf using 1 ; ring + exact onceCuspScale_not_three_dvd _ hq + +theorem ramifiedBesselValue_once_squarefree_cube_support (side:Bool) (h:Eis) + (hb:ramifiedBesselValue side h≠0) : + ∃(u:Eisˣ) (I J:Ideal Eis),Squarefree I ∧ + primaryGenerator I≠0 ∧ primaryGenerator J≠0 ∧ + h=(u.val*lambda)*primaryGenerator I*(primaryGenerator J)^3 := by + obtain ⟨hl,hnot⟩:=ramifiedBesselValue_exact_lambda_valuation side h hb + have hh:h≠0:=by intro hz; exact hnot (hz▸dvd_zero _) + obtain ⟨u,m,I,J,hsq,hI,hJ,hfactor⟩:=ramifiedBesselValue_squarefree_cube_support side h hh hb + have hm2:¬2≤m:=by + intro hm + apply hnot + rw [hfactor] + exact dvd_mul_of_dvd_left (dvd_mul_of_dvd_left + (dvd_mul_of_dvd_right (pow_dvd_pow lambda hm) _) _) _ + have hm0:m≠0:=by + intro hm + subst m + rw [pow_zero,mul_one] at hfactor + have hu:IsCoprime lambda (u:Eis):=⟨0,(↑u⁻¹:Eis),by simp⟩ + have hni:IsCoprime lambda (primaryGenerator I):=coprime_of_dvd_sub_one lambda _ + ((dvd_pow_self lambda (by decide : (2:ℕ)≠0)).trans (primaryGenerator_spec I hI).2) + have hnj:IsCoprime lambda (primaryGenerator J):=coprime_of_dvd_sub_one lambda _ + ((dvd_pow_self lambda (by decide : (2:ℕ)≠0)).trans (primaryGenerator_spec J hJ).2) + have hc:IsCoprime lambda h:=by rw [hfactor]; exact (hu.mul_right hni).mul_right hnj.pow_right + exact residue_lambda_prime.not_isUnit (hc.isUnit_of_dvd hl) + have hm:m=1:=by omega + exact ⟨u,I,J,hsq,hI,hJ,by simpa only [hm,pow_one] using hfactor⟩ + +theorem ramifiedBesselValue_once_squarefree_cube_bound : + ∃C:ℝ,0 ActualEisensteinCubic.O + +lemma sourceResidualFourierCoefficient_prime_norm (p:Eis) (hp:Prime p) + (hpp:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) : + ‖sourceResidualFourierCoefficient (h*p)‖=‖sourceResidualFourierCoefficient h‖ := by + have hp9:¬p∣9*h:=by + have ht:=ramified_prime_frequency_not_dvd h p hp hpp hph (1:Eisˣ) 0 + simpa only [Units.val_one,pow_zero,one_mul,mul_one,mul_comm 9 h] using ht + rw [sourceResidualFourierCoefficient_prime_factor p hp hpp h hph,norm_mul,norm_div, + primeCubicGauss_two_norm p hp hpp (9*h) hp9,Complex.norm_real, + Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _), + div_self (norm_ne_zero_iff.mpr (eisEmbedding_ne_zero hp.ne_zero)),one_mul] + +theorem sourceResidualFourierCoefficient_prime_product_norm {ι:Type*} + (s:Finset ι) (p:ι→Eis) (hp:∀i∈s,Prime (p i)) + (hprimary:∀i∈s,lambda^2∣p i-1) + (hpair:∀i∈s,∀j∈s,i≠j→IsCoprime (p i) (p j)) + (h:Eis) (hph:∀i∈s,¬p i∣h) : + ‖sourceResidualFourierCoefficient (h*(∏i∈s,p i))‖=‖sourceResidualFourierCoefficient h‖ := by + classical + induction s using Finset.induction_on with + | empty=>simp + | @insert i s hi ih=> + have hpi:=hp i (Finset.mem_insert_self _ _) + have hpri:=hprimary i (Finset.mem_insert_self _ _) + have hps:∀j∈s,Prime (p j):=fun j hj=>hp j (Finset.mem_insert_of_mem hj) + have hprs:∀j∈s,lambda^2∣p j-1:=fun j hj=>hprimary j (Finset.mem_insert_of_mem hj) + have hcpi:IsCoprime (p i) (∏j∈s,p j):=IsCoprime.prod_right (fun j hj=> + hpair i (Finset.mem_insert_self _ _) j (Finset.mem_insert_of_mem hj) (by intro he;subst j;exact hi hj)) + have hpb:¬p i∣h*(∏j∈s,p j):=by + intro hd + rcases hpi.dvd_mul.mp hd with hd|hd + · exact hph i (Finset.mem_insert_self _ _) hd + · exact hpi.not_isUnit (hcpi.isUnit_of_dvd hd) + rw [Finset.prod_insert hi,show h*(p i*(∏j∈s,p j))=(h*(∏j∈s,p j))*p i by ring, + sourceResidualFourierCoefficient_prime_norm (p i) hpi hpri _ hpb] + exact ih hps hprs (fun j hj k hk hjk=>hpair j (Finset.mem_insert_of_mem hj) k (Finset.mem_insert_of_mem hk) hjk) + (fun j hj=>hph j (Finset.mem_insert_of_mem hj)) + +lemma sourceResidualFourierCoefficient_ramified_bound (u:Eisˣ) (m:ℕ) : + ‖sourceResidualFourierCoefficient (u.val*lambda^m)‖≤ + (‖cubicBesselNormalizer 1‖*(9*ramifiedSourceFamilyConstant*ramifiedResidueFamilyMass 1))* + (3:ℝ)^((m:ℝ)/6) := by + have hc:‖cubicBesselNormalizer (u.val*lambda^m)‖= + ‖cubicBesselNormalizer 1‖*(3:ℝ)^((m:ℝ)/6):=by + simpa only [one_mul] using cubicBesselNormalizer_ramified_mul_norm 1 u m + rw [sourceResidualFourierCoefficient,norm_mul,hc] + exact (mul_le_mul_of_nonneg_left (sourceArithmeticResidue_unit_lambda_bound u m) + (mul_nonneg (norm_nonneg _) (Real.rpow_nonneg (show (0:ℝ)≤3 by norm_num) ((m:ℝ)/6)))).trans_eq (by ring) + +lemma sourceResidualFourierCoefficient_squarefree_cube_norm (I J:Ideal Eis) + (hI:primaryGenerator I≠0) (hJ:primaryGenerator J≠0) (hsq:Squarefree I) + (u:Eisˣ) (m:ℕ) : + ‖sourceResidualFourierCoefficient ((u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3)‖= + ‖eisEmbedding (primaryGenerator J)‖*‖sourceResidualFourierCoefficient (u.val*lambda^m)‖ := by + rw [sourceResidualFourierCoefficient_primary_cube _ hJ (primaryGenerator_spec J hJ).2 _ + (mul_ne_zero (ramifiedElement_ne_zero u m) hI),norm_mul, + Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _)] + congr 1 + rw [primaryGenerator_squarefree_support I hI hsq] + apply sourceResidualFourierCoefficient_prime_product_norm + · exact fun P hP=>primaryPrime_isPrime_of_mem I P hI hP + · exact fun P hP=>(primaryPrime_spec P (primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP))).2.2.2 + · exact primaryPrime_support_coprime I hI + · intro P hP hd + have hp:=primaryPrime_isPrime_of_mem I P hI hP + have hpp:lambda^2∣primaryPrime P-1:= + (primaryPrime_spec P (primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP))).2.2.2 + have hc:IsCoprime (u.val*lambda^m) (primaryPrime P):= + (ramified_primary_coprime u m _ hpp).of_mul_left_right + exact hp.not_isUnit (hc.symm.isUnit_of_dvd hd) + +theorem sourceResidualFourierCoefficient_squarefree_cube_bound : + ∃C:ℝ,0 ActualEisensteinCubic.O + +lemma sourceResidualFourierCoefficient_prime_power_vanish (p:Eis) (hp:Prime p) + (hpp:lambda^2∣p-1) (h:Eis) (hph:¬p∣h) (k:ℕ) (hk:k%3=2) : + sourceResidualFourierCoefficient (h*p^k)=0 := by + rw [sourceResidualFourierCoefficient,sourceArithmeticResidue_prime_power_table p hp hpp h hph k,hk] + norm_num + +theorem sourceResidualFourierCoefficient_full_squarefree_cube_support (h:Eis) (hh:h≠0) + (hB:sourceResidualFourierCoefficient h≠0) : + ∃(u:Eisˣ) (m:ℕ) (I J:Ideal Eis),Squarefree I ∧ + primaryGenerator I≠0 ∧ primaryGenerator J≠0 ∧ + h=(u.val*lambda^m)*primaryGenerator I*(primaryGenerator J)^3 := by + obtain ⟨n,u,m,hn,he⟩:=exists_primary_unit_lambda_factor h hh + let T:Ideal Eis:=Ideal.span {n} + have hT:primaryGenerator T=n:=primaryGenerator_span n (primary_ne_zero n hn) hn + have hT0:primaryGenerator T≠0:=by rw [hT]; exact primary_ne_zero n hn + have hFT:sourceResidualFourierCoefficient ((u.val*lambda^m)*primaryGenerator T)≠0:=by + rw [hT,mul_comm] + rwa [←he] + have hv:∀P∈normalizedFactors T,(normalizedFactors T).count P%3≠2:=by + intro P hP + exact ramifiedFunction_valuation_ne_two (sourceResidualFourierCoefficient) + (fun p hp hpp h hph k hk=>sourceResidualFourierCoefficient_prime_power_vanish p hp hpp h hph k hk) + T P hT0 hP u m hFT + have hparts:=thetaParts_mul_cube T (primaryGenerator_ne_zero_ideal T hT0) hv + have hgen:primaryGenerator T=primaryGenerator (thetaSquarefreePart T)* + (primaryGenerator (thetaCubePart T))^3:=by + calc + _=primaryGenerator (thetaSquarefreePart T*thetaCubePart T^3):=congrArg primaryGenerator hparts.symm + _=_:=by rw [primaryGenerator_mul,primaryGenerator_pow] + have hA:primaryGenerator (thetaSquarefreePart T)≠0:=by + intro hz + exact hT0 (by rw [hgen,hz,zero_mul]) + have hC:primaryGenerator (thetaCubePart T)≠0:=by + intro hz + exact hT0 (by rw [hgen,hz,zero_pow (by decide : (3:ℕ)≠0),mul_zero]) + refine ⟨u,m,thetaSquarefreePart T,thetaCubePart T,thetaSquarefreePart_squarefree T,hA,hC,?_⟩ + rw [he,←hT,hgen] + ring + +end + +section +open scoped Classical BigOperators + +open ActualEisensteinCubic CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal) +local notation "Eis" => ActualEisensteinCubic.O + +abbrev ThetaPrimaryCubePair := + {I:Ideal Eis // Squarefree I ∧ primaryGenerator I≠0} × + {J:Ideal Eis // primaryGenerator J≠0} + +def thetaPrimaryProduct (p : ThetaPrimaryCubePair) : GoodIdeal := + ⟨p.1.val*p.2.val^3,by + rw [primaryGenerator_mul,primaryGenerator_pow] + exact mul_ne_zero p.1.property.2 (pow_ne_zero 3 p.2.property)⟩ + +lemma thetaPrimaryProduct_injective : Function.Injective thetaPrimaryProduct := by + intro p q he + have hprod : p.1.val*p.2.val^3=q.1.val*q.2.val^3 := congrArg Subtype.val he + have h := squarefree_cube_decomposition_unique + (primaryGenerator_ne_zero_ideal _ p.2.property) + (primaryGenerator_ne_zero_ideal _ q.2.property) p.1.property.1 q.1.property.1 hprod + exact Prod.ext (Subtype.ext h.1) (Subtype.ext h.2) + +abbrev ThetaFullIndex := Eisˣ × ℕ × ThetaPrimaryCubePair + +def thetaFullFrequency (p : ThetaFullIndex) : Eis := + (p.1.val*lambda^p.2.1)*primaryGenerator p.2.2.1.val* + (primaryGenerator p.2.2.2.val)^3 + +lemma thetaFullFrequency_product (p : ThetaFullIndex) : + thetaFullFrequency p=p.1.val*(lambda^p.2.1*primaryGenerator (thetaPrimaryProduct p.2.2).val) := by + simp only [thetaFullFrequency,thetaPrimaryProduct,primaryGenerator_mul,primaryGenerator_pow] + ring + +lemma thetaFullFrequency_ne_zero (p : ThetaFullIndex) : thetaFullFrequency p≠0 := by + rw [thetaFullFrequency_product] + exact mul_ne_zero p.1.ne_zero + (mul_ne_zero (pow_ne_zero _ PrimaryIdealUnitReindex.lambda_prime_actual.ne_zero) + (thetaPrimaryProduct p.2.2).property) + +lemma thetaFullFrequency_span (p : ThetaFullIndex) : + Ideal.span {thetaFullFrequency p}=ramifiedIdeal^p.2.1*(thetaPrimaryProduct p.2.2).val := by + rw [thetaFullFrequency_product,Ideal.span_singleton_mul_left_unit p.1.isUnit, + lambdaFactor_generator_span] + +theorem thetaFullFrequency_injective : Function.Injective thetaFullFrequency := by + rintro ⟨u,m,p⟩ ⟨v,n,q⟩ he + have hs := congrArg (fun x:Eis=>Ideal.span {x}) he + rw [thetaFullFrequency_span,thetaFullFrequency_span] at hs + have hmap : lambdaFactorMap (m,thetaPrimaryProduct p)=lambdaFactorMap (n,thetaPrimaryProduct q) := + Subtype.ext hs + have hij := lambdaFactorMap_bijective.1 hmap + have hmn : m=n := congrArg Prod.fst hij + have hpq : p=q := thetaPrimaryProduct_injective (congrArg Prod.snd hij) + subst n + subst q + have huv : u=v := by + apply Units.ext + have hh : lambda^m*primaryGenerator (thetaPrimaryProduct p).val≠0 := + mul_ne_zero (pow_ne_zero _ PrimaryIdealUnitReindex.lambda_prime_actual.ne_zero) + (thetaPrimaryProduct p).property + apply mul_right_cancel₀ hh + simpa only [thetaFullFrequency_product] using he + subst v + rfl + +end + +section +open scoped BigOperators Classical MatrixGroups +open MeasureTheory +open Finset AddChar MulChar EisensteinEmbedding + +open CubicKubota EisensteinCuspModThree ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +structure SourceCuspDatum where + gamma : levelTwo + index : Fin 3 + lower_ne_zero : + (integralComplexMatrix (gamma:SL(2,Eis))*integralComplexMatrix (cuspRepresentative index)) 1 0≠0 + +namespace SourceCuspDatum + +def matrix (d : SourceCuspDatum) : SL(2,ℂ) := + integralComplexMatrix (d.gamma:SL(2,Eis))*integralComplexMatrix (cuspRepresentative d.index) +def point (d : SourceCuspDatum) : ℂ := d.matrix 0 0/d.matrix 1 0 +def dualPoint (d : SourceCuspDatum) : ℂ := -d.matrix 1 1/d.matrix 1 0 +def heightScale (d : SourceCuspDatum) : ℝ := ‖d.matrix 1 0‖^2 +def multiplier (d : SourceCuspDatum) : ℂ := -star (levelTwoComplexCharacter d.gamma)/(d.matrix 1 0)^2 + +lemma heightScale_pos (d : SourceCuspDatum) : 0cubicSourceConjugateFunction (integralComplexMatrix (cuspRepresentative j) • w)) z + +theorem SourceCuspDatum.reflection (d : SourceCuspDatum) (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +lemma horizontalPhaseMultiplier_scaled_bar (freq : ℂ) (r : ℝ) : + (1/2:ℂ)*(horizontalPhaseMultiplier freq (1/(r:ℂ))+ + Complex.I*horizontalPhaseMultiplier freq (Complex.I/(r:ℂ)))= + 2*Real.pi*Complex.I*star freq/(r:ℂ) := by + simp only [horizontalPhaseMultiplier,star_mul, + Complex.star_def,map_div₀,map_one,Complex.conj_ofReal,Complex.conj_I] + ring_nf + norm_num [Complex.I_sq,Complex.I_pow_three] + ; ring + +namespace SubexponentialBesselCoefficients + +lemma scaled_fullFunction_horizontal_hasDerivAt (coeff : SubexponentialBesselCoefficients) + (constant : ℂ) (r : ℝ) (hr : 0coeff.fullFunction constant + (upperPoint ((z+(t:ℂ)*direction)/(r:ℂ)) (v/r) (div_pos hv hr))) + (∑'h:Eis,coeff.directionalTerm h (v/r) (z/(r:ℂ)) (direction/(r:ℂ))) 0 := by + have h:=coeff.fullFunction_horizontal_hasDerivAt constant (v/r) (div_pos hv hr) + (z/(r:ℂ)) (direction/(r:ℂ)) 0 + simp only [Complex.ofReal_zero,zero_mul,add_zero] at h + convert h using 1 + funext t + congr 2 + ring + +lemma scaled_fullFunction_wirtingerBar (coeff : SubexponentialBesselCoefficients) + (constant : ℂ) (r : ℝ) (hr : 0coeff.fullFunction constant + (upperPoint (w/(r:ℂ)) (v/r) (div_pos hv hr))) z= + ∑'h:Eis,(2*Real.pi*Complex.I*star (cuspFrequency h)/(r:ℂ))*coeff.term h (v/r,z/(r:ℂ)) := by + have h1:=(coeff.scaled_fullFunction_horizontal_hasDerivAt constant r hr v hv z 1).deriv + have hI:=(coeff.scaled_fullFunction_horizontal_hasDerivAt constant r hr v hv z Complex.I).deriv + simp only [mul_one] at h1 + rw [horizontalWirtingerBar,h1,hI] + have hs1:=coeff.directionalTerm_summable (v/r) (div_pos hv hr) (z/(r:ℂ)) (1/(r:ℂ)) + have hsI:=(coeff.directionalTerm_summable (v/r) (div_pos hv hr) (z/(r:ℂ)) (Complex.I/(r:ℂ))).mul_left Complex.I + rw [←tsum_mul_left,←hs1.tsum_add hsI,←tsum_mul_left] + apply tsum_congr + intro h + unfold directionalTerm + linear_combination coeff.term h (v/r,z/(r:ℂ))*horizontalPhaseMultiplier_scaled_bar (cuspFrequency h) r + +def scaledConjugateZTerm (coeff : SubexponentialBesselCoefficients) + (r v : ℝ) (z : ℂ) (h : Eis) : ℂ := + (-2*Real.pi*Complex.I*cuspFrequency h/(r:ℂ))*star (coeff.term h (v/r,z/(r:ℂ))) + +theorem scaledConjugate_wirtingerZ (coeff : SubexponentialBesselCoefficients) + (constant : ℂ) (r : ℝ) (hr : 0star (coeff.fullFunction constant + (upperPoint (w/(r:ℂ)) (v/r) (div_pos hv hr)))) z= + ∑'h:Eis,coeff.scaledConjugateZTerm r v z h := by + rw [horizontalWirtingerZ_star,coeff.scaled_fullFunction_wirtingerBar constant r hr v hv z,tsum_star] + apply tsum_congr + intro h + unfold scaledConjugateZTerm + simp only [star_mul,Complex.star_def,map_div₀,map_mul, + map_ofNat,Complex.conj_ofReal,Complex.conj_I,starRingEnd_self_apply] + ring + +theorem scaledConjugateZTerm_summable (coeff : SubexponentialBesselCoefficients) + (r : ℝ) (hr : 0 ActualEisensteinCubic.O + +def rationalComplex : SL(2,ℤ) →* SL(2,ℂ) := integralComplexMatrix.comp rationalEmbedding + +lemma rationalUnipotent_nat (n : ℕ) : rationalUnipotent (n:ℤ)=ModularGroup.T^n := by + induction n with + | zero => simpa using rationalUnipotent_zero + | succ n ih => rw [Nat.cast_add,Nat.cast_one,rationalUnipotent_add,ih,rationalUnipotent_one,pow_succ] + +lemma rationalComplex_S_sq_row (v : Fin 2→ℂ) : + rowOperator (rationalComplex (ModularGroup.S^2)) v = -v := by + have hS : ((ModularGroup.S ^ 2 : SL(2,ℤ)) : Matrix (Fin 2) (Fin 2) ℤ) = + !![-1,0;0,-1] := by decide + have hC : (rationalComplex (ModularGroup.S ^ 2) : Matrix (Fin 2) (Fin 2) ℂ) = + !![-1,0;0,-1] := by + apply Matrix.ext + intro i j + change eisEmbedding ((Int.castRingHom O) ((ModularGroup.S ^ 2 : SL(2,ℤ)) i j)) = _ + rw [congrFun (congrFun hS i) j] + fin_cases i <;> fin_cases j <;> simp + rw [rowOperator_apply,hC] + funext j + fin_cases j <;> simp [Matrix.vecMul,dotProduct,Fin.sum_univ_two] + +lemma hyperbolicEisenstein_S_sq (s : ℂ) (w : HyperbolicSpace) : + hyperbolicEisenstein s (rationalComplex (ModularGroup.S^2) • w)=hyperbolicEisenstein s w := by + induction w using Quotient.inductionOn with + | _ g => + change eisenstein (rationalComplex (ModularGroup.S^2)*g) s=eisenstein g s + apply tsum_congr + intro x + unfold summand + rw [←rowOperator_mul,rationalComplex_S_sq_row,map_neg] + simp [rowEnergy] + +lemma hyperbolicEisenstein_T_pow (s : ℂ) (n : ℕ) (w : HyperbolicSpace) : + hyperbolicEisenstein s (rationalComplex (ModularGroup.T^n) • w)=hyperbolicEisenstein s w := by + simpa only [rationalUnipotent_nat,rationalComplex,MonoidHom.comp_apply] using hyperbolicEisenstein_unipotent (n:ℤ) s w + +lemma hyperbolicEisenstein_S_even (s : ℂ) (e : Fin 2) (w : HyperbolicSpace) : + hyperbolicEisenstein s (rationalComplex (ModularGroup.S^(2*e.val)) • w)=hyperbolicEisenstein s w := by + fin_cases e + · simp + · exact hyperbolicEisenstein_S_sq s w + +lemma hyperbolicEisenstein_bruhat (s : ℂ) (e : Fin 2) (a : Fin 3⊕(Fin 3×Fin 3)) (w : HyperbolicSpace) : + hyperbolicEisenstein s (rationalComplex (rationalBruhatRep (e,a)) • w)= + match a with + | Sum.inl _ => hyperbolicEisenstein s w + | Sum.inr ab => hyperbolicEisenstein s + (rationalComplex ModularGroup.S • (rationalComplex (ModularGroup.T^ab.2.val) • w)) := by + simp only [rationalBruhatRep,map_mul,mul_smul,hyperbolicEisenstein_S_even] + cases a with + | inl a => exact hyperbolicEisenstein_T_pow s a.val w + | inr ab => simp only [map_mul,mul_smul,hyperbolicEisenstein_T_pow] + +theorem sourceEisenstein_four_cusps (s : ℂ) (w : HyperbolicSpace) : + sourceEisenstein s w = (4:ℂ)⁻¹ * (hyperbolicEisenstein s w + + ∑ b : Fin 3, hyperbolicEisenstein s + (rationalComplex ModularGroup.S • (rationalComplex (ModularGroup.T^b.val) • w))) := by + rw [sourceEisenstein,sourceProjection_eq_twentyFour] + change (24:ℂ)⁻¹ * (∑ i : RationalBruhatIndex, + hyperbolicEisenstein s (rationalComplex (rationalBruhatRep i) • w)) = _ + rw [Fintype.sum_prod_type] + simp_rw [hyperbolicEisenstein_bruhat] + simp only [Fintype.sum_sum_type,Fintype.sum_prod_type,Finset.sum_const,Finset.card_univ, + Fintype.card_fin,nsmul_eq_mul] + ring + +end + +section + +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace MatrixGroups +open CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +def translatedCuspCompact (M:levelTwo):Set KernelQuotient:= + kernelSourceAction M '' kernelCuspAverageCompact + +lemma translatedCuspCompact_isCompact (M:levelTwo):IsCompact (translatedCuspCompact M):= + kernelCuspAverageCompact_isCompact.image (kernelSourceAction_continuous M) + +def translatedCuspFourier (h:Eis) (M:levelTwo):KernelQuotientL2→L[ℂ]ℂ:= + (kernelCuspFourier h).comp (kernelSourcePullback M).toContinuousLinearMap + +lemma translatedCuspFourier_integral (h:Eis) (M:levelTwo) (F:KernelQuotientL2): + translatedCuspFourier h M F=∫w in cuspPeriodStrip 5 6, + F (kernelSourceAction M (integralOrbitProjection globalKubotaKernel w))* + cuspFourierPhase h w∂hyperbolicVolume:=by + rw [translatedCuspFourier,ContinuousLinearMap.comp_apply,kernelCuspFourier_integral] + have hm:=kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have he:=hm.quasiMeasurePreserving.ae_eq_comp (ae_restrict_of_ae + (kernelSourcePullback_ae_eq M F) (s:=kernelCuspStripSet)) + apply integral_congr_ae + filter_upwards [he] with w hw + exact congrArg (fun z:ℂ=>z*cuspFourierPhase h w) hw + +lemma translatedCuspFourier_restrict (h:Eis) (M:levelTwo) (F:KernelQuotientL2): + translatedCuspFourier h M + (kernelMassRestrictionCLM (translatedCuspCompact M) + (translatedCuspCompact_isCompact M).measurableSet F)=translatedCuspFourier h M F:=by + rw [translatedCuspFourier_integral,translatedCuspFourier_integral] + have hsource:=(kernelSourceAction_measurePreserving M).quasiMeasurePreserving.ae_eq_comp + (kernelMassRestriction_coe (translatedCuspCompact M) + (translatedCuspCompact_isCompact M).measurableSet F) + have hm:=kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have he:=hm.quasiMeasurePreserving.ae_eq_comp (ae_restrict_of_ae hsource (s:=kernelCuspStripSet)) + apply integral_congr_ae + filter_upwards [he,ae_restrict_mem (cuspPeriodStrip_measurable 5 6)] with w hw hwm + have hmem:kernelSourceAction M (integralOrbitProjection globalKubotaKernel w)∈translatedCuspCompact M:= + ⟨_,kernelCuspStripSet_subset_compact ⟨w,hwm,rfl⟩,rfl⟩ + exact congrArg (fun z:ℂ=>z*cuspFourierPhase h w) + (hw.trans (Set.indicator_of_mem hmem _)) + +def translatedCuspFamily (h:Eis) (M:levelTwo) (a b:ℝ) (ha:0(s-4/3)*translatedCuspFamily h M a b ha hab s) + (𝓝[≠] (4/3:ℂ)) + (𝓝 (translatedCuspFourier h M (kernelEisensteinResidueVector a b ha hab))):=by + have hh:=(translatedCuspFourier h M).continuous.continuousAt.tendsto.comp + (kernelLocalCorrectedSeed_residue_limit _ (translatedCuspCompact_isCompact M) a b ha hab) + simpa only [Function.comp_def,map_smul,smul_eq_mul,translatedCuspFourier_restrict, + translatedCuspFamily] using hh + +lemma translatedCuspFamily_actual_integral (h:Eis) (M:levelTwo) + (a b:ℝ) (ha:0z*cuspFourierPhase h w) + (hw.trans (Set.indicator_of_mem hmem _)) + +theorem translatedCuspFamily_initial (h:Eis) (M:levelTwo) + (a b:ℝ) (ha:0z*cuspFourierPhase h w) + (hw.trans (by dsimp only [Function.comp_def];rw [kernelSourceAction_mk,kernelQuotientEisenstein_mk])) + +end + +section + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Matrix +open CubicKubota ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def oppositeSource:levelTwo:=rationalLift ModularGroup.S + +lemma oppositeSource_matrix:sourceComplexMatrix oppositeSource=oppositeMatrix:=by + apply Subtype.ext + ext i j + fin_cases i <;> fin_cases j <;> + simp [oppositeSource,sourceComplexMatrix,rationalLift,rationalEmbedding, + integralComplexMatrix,Matrix.SpecialLinearGroup.map_apply_coe,ModularGroup.coe_S,oppositeMatrix] + +lemma hyperbolicEisenstein_opposite_upper (s:ℂ) (z:ℂ) (v:ℝ) (hv:0 + hyperbolicEisenstein s (sourceComplexMatrix oppositeSource • w)*cuspFourierPhase h w + have hg:Continuous g:=((hyperbolicEisenstein_continuous s hs).comp + (continuous_hyperbolic_action _)).mul (cuspFourierPhase_continuous h) + rw [cuspPeriodStrip_integral_coordinates g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable g hg)] + have heq:(∫v in Set.Icc (5:ℝ) 6, + (∫z in periodDomain,g (cuspCoordinateLift (v,z)))/(v:ℂ)^3)= + ∫v in Set.Icc (5:ℝ) 6,unramifiedCubicGaussSeries s (9*h)* + ((v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v)):=by + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hv0:0(s-4/3)*continuedUnramifiedGauss h s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (unramifiedGaussResidue h)):=by + have hd:Tendsto (fun s:ℂ=>cuspWhittakerHeightFactor s (3*h)) + (𝓝[≠] (4/3:ℂ)) (𝓝 (cuspWhittakerHeightFactor (4/3:ℂ) (3*h))):= + (cuspWhittakerHeightFactor_analyticAt (3*h) (4/3) (by norm_num)).continuousAt.tendsto.mono_left + nhdsWithin_le_nhds + have hh:=(translatedCuspFamily_residue_limit (3*h) oppositeSource 2 3 + (by norm_num) (by norm_num)).div hd (cuspWhittakerHeightFactor_center_ne_zero (3*h)) + convert hh using 1 + · funext s + simp only [continuedUnramifiedGauss,Pi.div_apply] + ring + · rfl + +theorem continuedUnramifiedGauss_initial (h:Eis) (s:ℂ) + (hs:4unramifiedCubicGaussSeries s h) U:=by + obtain ⟨ε,hε,hball⟩:=Metric.eventually_nhds_iff.mp (cuspWhittakerHeightFactor_ne_zero_near_five (3*h)) + let z:ℂ:=5+(ε/2:ℝ)*Complex.I + have hz:dist z (5:ℂ)<ε:=by + have he:dist z (5:ℂ)=ε/2:=by simp [z,dist_eq_norm,hε.le] + rw [he] + linarith + have hzim:0 ActualEisensteinCubic.O + +lemma gaussRep_mk_congr (c d : Eis) : + c ∣ GaussianShiftedPartition.representative c (Ideal.Quotient.mk (Ideal.span {c}) d)-d := by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + exact GaussianShiftedPartition.representative_spec c _ + +def cubicUnitCRTMap (a b : Eis) (r : CubicUnitResidue (a*b)) : + CubicUnitResidue a × CubicUnitResidue b := + let d:=GaussianShiftedPartition.representative (a*b) r.1 + let hd:IsCoprime (a*b) d:=by + apply (isUnit_quotient_span_iff (a*b) d).mp + simpa only [d,GaussianShiftedPartition.representative_spec] using r.2 + (⟨Ideal.Quotient.mk (Ideal.span {a}) d, + (isUnit_quotient_span_iff a d).mpr hd.of_mul_left_left⟩, + ⟨Ideal.Quotient.mk (Ideal.span {b}) d, + (isUnit_quotient_span_iff b d).mpr hd.of_mul_left_right⟩) + +lemma cubicUnitCRTMap_injective (a b : Eis) (hab : IsCoprime a b) : + Function.Injective (cubicUnitCRTMap a b) := by + intro r t he + have h1:=congrArg (fun z : CubicUnitResidue a × CubicUnitResidue b=>z.1.1) he + have h2:=congrArg (fun z : CubicUnitResidue a × CubicUnitResidue b=>z.2.1) he + change Ideal.Quotient.mk (Ideal.span {a}) (GaussianShiftedPartition.representative (a*b) r.1)= + Ideal.Quotient.mk (Ideal.span {a}) (GaussianShiftedPartition.representative (a*b) t.1) at h1 + change Ideal.Quotient.mk (Ideal.span {b}) (GaussianShiftedPartition.representative (a*b) r.1)= + Ideal.Quotient.mk (Ideal.span {b}) (GaussianShiftedPartition.representative (a*b) t.1) at h2 + have hdiv : a*b ∣ GaussianShiftedPartition.representative (a*b) r.1- + GaussianShiftedPartition.representative (a*b) t.1 := + hab.mul_dvd + (Ideal.mem_span_singleton.mp ((Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp h1)) + (Ideal.mem_span_singleton.mp ((Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp h2)) + apply Subtype.ext + rw [←GaussianShiftedPartition.representative_spec (a*b) r.1, + ←GaussianShiftedPartition.representative_spec (a*b) t.1] + exact (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr (Ideal.mem_span_singleton.mpr hdiv) + +lemma cubicUnitCRTMap_surjective (a b : Eis) (hab : IsCoprime a b) : + Function.Surjective (cubicUnitCRTMap a b) := by + rintro ⟨r,t⟩ + obtain ⟨u,v,huv⟩:=hab + let delta:=GaussianShiftedPartition.representative a r.1 + let xi:=GaussianShiftedPartition.representative b t.1 + let d:=v*b*delta+u*a*xi + have hda:a∣d-delta:=⟨u*(xi-delta),by dsimp [d];linear_combination delta*huv⟩ + have hdb:b∣d-xi:=⟨v*(delta-xi),by dsimp [d];linear_combination xi*huv⟩ + have had:IsCoprime a delta:=by + apply (isUnit_quotient_span_iff a delta).mp + simpa only [delta,GaussianShiftedPartition.representative_spec] using r.2 + have hbd:IsCoprime b xi:=by + apply (isUnit_quotient_span_iff b xi).mp + simpa only [xi,GaussianShiftedPartition.representative_spec] using t.2 + have hd:IsCoprime (a*b) d:= + ((isCoprime_right_congr_of_dvd a d delta hda).mpr had).mul_left + ((isCoprime_right_congr_of_dvd b d xi hdb).mpr hbd) + let q:CubicUnitResidue (a*b):=⟨Ideal.Quotient.mk (Ideal.span {a*b}) d, + (isUnit_quotient_span_iff (a*b) d).mpr hd⟩ + refine ⟨q,Prod.ext (Subtype.ext ?_) (Subtype.ext ?_)⟩ + · change Ideal.Quotient.mk (Ideal.span {a}) (GaussianShiftedPartition.representative (a*b) q.1)=r.1 + rw [←GaussianShiftedPartition.representative_spec a r.1] + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + apply Ideal.mem_span_singleton.mpr + have hh:a∣GaussianShiftedPartition.representative (a*b) q.1-d:= + (dvd_mul_right a b).trans (gaussRep_mk_congr (a*b) d) + simpa only [sub_add_sub_cancel] using dvd_add hh hda + · change Ideal.Quotient.mk (Ideal.span {b}) (GaussianShiftedPartition.representative (a*b) q.1)=t.1 + rw [←GaussianShiftedPartition.representative_spec b t.1] + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mpr + apply Ideal.mem_span_singleton.mpr + have hh:b∣GaussianShiftedPartition.representative (a*b) q.1-d:= + (dvd_mul_left b a).trans (gaussRep_mk_congr (a*b) d) + simpa only [sub_add_sub_cancel] using dvd_add hh hdb + +def cubicUnitCRTEquiv (a b:Eis) (hab:IsCoprime a b): + CubicUnitResidue (a*b)≃CubicUnitResidue a×CubicUnitResidue b:= + Equiv.ofBijective (cubicUnitCRTMap a b) + ⟨cubicUnitCRTMap_injective a b hab,cubicUnitCRTMap_surjective a b hab⟩ + +lemma residueAdditive_unit_crt (h a b alpha beta d:Eis) (ha:a≠0) (hb:b≠0) + (hbez:alpha*b+beta*a=1): + residueAdditive (3*h) (a*b) d= + residueAdditive (3*(h*alpha)) a d*residueAdditive (3*(h*beta)) b d:=by + unfold residueAdditive + rw [←AddChar.map_add_eq_mul] + congr 1 + have hae:=eisEmbedding_ne_zero ha + have hbe:=eisEmbedding_ne_zero hb + have hbeq:=congrArg eisEmbedding hbez + simp only [map_add,map_mul,map_one] at hbeq + simp only [cuspFrequency,map_mul,map_ofNat] + field_simp [hae,hbe,eisLam_ne_zero] + linear_combination -(eisEmbedding h*eisEmbedding d)*hbeq + +lemma cubicUnitCRT_summand (h a b alpha beta:Eis) (ha:a≠0) (hb:b≠0) + (hbez:alpha*b+beta*a=1) (r:CubicUnitResidue (a*b)): + eisEmbedding (symbol (GaussianShiftedPartition.representative (a*b) r.1) (a*b))* + residueAdditive (3*h) (a*b) (GaussianShiftedPartition.representative (a*b) r.1)= + (eisEmbedding (symbol (GaussianShiftedPartition.representative a (cubicUnitCRTMap a b r).1.1) a)* + residueAdditive (3*(h*alpha)) a (GaussianShiftedPartition.representative a (cubicUnitCRTMap a b r).1.1))* + (eisEmbedding (symbol (GaussianShiftedPartition.representative b (cubicUnitCRTMap a b r).2.1) b)* + residueAdditive (3*(h*beta)) b (GaussianShiftedPartition.representative b (cubicUnitCRTMap a b r).2.1)):=by + let d:=GaussianShiftedPartition.representative (a*b) r.1 + let delta:=GaussianShiftedPartition.representative a (cubicUnitCRTMap a b r).1.1 + let xi:=GaussianShiftedPartition.representative b (cubicUnitCRTMap a b r).2.1 + have hdelta:a∣delta-d:=gaussRep_mk_congr a d + have hxi:b∣xi-d:=gaussRep_mk_congr b d + change eisEmbedding (symbol d (a*b))*residueAdditive (3*h) (a*b) d= + (eisEmbedding (symbol delta a)*residueAdditive (3*(h*alpha)) a delta)* + (eisEmbedding (symbol xi b)*residueAdditive (3*(h*beta)) b xi) + rw [symbol_mul_denominator,map_mul,symbol_congr hdelta,symbol_congr hxi, + residueAdditive_unit_crt h a b alpha beta d ha hb hbez, + residueAdditive_three_congr (h*alpha) a delta d ha hdelta, + residueAdditive_three_congr (h*beta) b xi d hb hxi] + ring + +theorem cubicUnitGaussSum_crt (h a b alpha beta:Eis) (ha:a≠0) (hb:b≠0) + (hbez:alpha*b+beta*a=1): + cubicUnitGaussSum h (a*b)= + cubicUnitGaussSum (h*alpha) a*cubicUnitGaussSum (h*beta) b:=by + have hab:IsCoprime a b:=⟨beta,alpha,by linear_combination hbez⟩ + let f:CubicUnitResidue a→ℂ:=fun r=>eisEmbedding + (symbol (GaussianShiftedPartition.representative a r.1) a)* + residueAdditive (3*(h*alpha)) a (GaussianShiftedPartition.representative a r.1) + let g:CubicUnitResidue b→ℂ:=fun r=>eisEmbedding + (symbol (GaussianShiftedPartition.representative b r.1) b)* + residueAdditive (3*(h*beta)) b (GaussianShiftedPartition.representative b r.1) + have he:cubicUnitGaussSum h (a*b)=∑'r:CubicUnitResidue (a*b), + f (cubicUnitCRTEquiv a b hab r).1*g (cubicUnitCRTEquiv a b hab r).2:=by + unfold cubicUnitGaussSum + apply tsum_congr + intro r + exact cubicUnitCRT_summand h a b alpha beta ha hb hbez r + rw [he,(cubicUnitCRTEquiv a b hab).tsum_eq (fun r=>f r.1*g r.2)] + let:Finite (Eis⧸Ideal.span {a}):=finite_quotient_span ha + let:Finite (Eis⧸Ideal.span {b}):=finite_quotient_span hb + let:Fintype (CubicUnitResidue a):=Fintype.ofFinite _ + let:Fintype (CubicUnitResidue b):=Fintype.ofFinite _ + change (∑'r:CubicUnitResidue a×CubicUnitResidue b,f r.1*g r.2)= + (∑'r:CubicUnitResidue a,f r)*(∑'r:CubicUnitResidue b,g r) + simp only [tsum_fintype,Fintype.sum_prod_type,Finset.mul_sum,Finset.sum_mul] + exact Finset.sum_comm + +theorem cubicUnitGaussSum_coprime_product (h a b:Eis) (ha:a≠0) (hb:b≠0) + (hap:lambda^2∣a-1) (hbp:lambda^2∣b-1) (hab:IsCoprime a b): + cubicUnitGaussSum h (a*b)=cubicUnitGaussSum h a*cubicUnitGaussSum (h*a) b:=by + obtain ⟨beta,alpha,hbez⟩:=hab + have hbez':alpha*b+beta*a=1:=by linear_combination hbez + have hab':IsCoprime a b:=⟨beta,alpha,hbez⟩ + have hA:=cubicUnitGaussSum_frequency_twist (h*alpha) a b ha hap hab' + rw [cubicUnitGaussSum_frequency_congr _ h a ha + (show a∣(h*alpha)*b-h from ⟨-h*beta,by linear_combination h*hbez'⟩)] at hA + have hB:=cubicUnitGaussSum_frequency_twist (h*beta) b a hb hbp hab'.symm + rw [cubicUnitGaussSum_frequency_congr _ h b hb + (show b∣(h*beta)*a-h from ⟨-h*alpha,by linear_combination h*hbez'⟩)] at hB + rw [cubicUnitGaussSum_crt h a b alpha beta ha hb hbez',←hA,←hB, + symbol_reciprocity b a hb ha hbp hap] + have hshift:=cubicUnitGaussSum_frequency_twist h b a hb hbp hab'.symm + have hc:(eisEmbedding (symbol a b))^3=1:=by + rw [←map_pow,symbol_cube_of_isCoprime a b hbp hab',map_one] + rw [←hshift] + calc + _=(eisEmbedding (symbol a b))^3*cubicUnitGaussSum h a*cubicUnitGaussSum (h*a) b:=by ring + _=_:=by rw [hc,one_mul] + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal) +local notation "Eis" => ActualEisensteinCubic.O + +lemma ramifiedCongruence_zero (j : Fin 3) (n : ℕ) : + ramifiedCongruence (0:Eis) j.val n ↔ j=0 ∧ 3∣n := by + have hz : ActualEisensteinCoordinates.coords (0:Eis)=(0,0) := by + have hh:=ShortDraftLatticeCount.coords_eval 0 0 + simpa [ActualEisensteinCoordinates.eval] using hh + simp only [ramifiedCongruence,hz,add_zero,sub_zero] + rw [←Int.natCast_dvd_natCast] + constructor + · rintro ⟨h1,h2⟩ + have hj : j.val=0 := by omega + exact ⟨Fin.ext hj,by simpa only [hj,Nat.cast_zero,Nat.cast_ofNat,mul_zero,zero_add] using h1⟩ + · rintro ⟨rfl,hn⟩ + simpa using And.intro hn (dvd_zero (3:ℤ)) + +lemma arithmeticResidueSum_zero_ramified (u : Eisˣ) (n : ℕ) : + arithmeticResidueSum 0 (u.val*lambda^(n+2))= + if u=1 ∨ u= -1 then if 3∣n+2 then ((3^(n+2):ℕ):ℂ) else 0 else 0 := by + have hp : residueAdditive (0:Eis) 3 1=1 := by + simp [residueAdditive,cuspFrequency] + by_cases hu : u=1 ∨ u= -1 + · have hs : (u:Eis)=omega^0 ∨ (u:Eis)=-(omega^0) := by + rcases hu with rfl|rfl <;> simp + rw [ramified_arithmetic_explicit_table 0 0 u (n+2) 0 (by omega) hs (by simp), + show ramifiedCongruence (0:Eis) 0 (n+2) ↔ 3∣n+2 by + simpa using ramifiedCongruence_zero (0:Fin 3) (n+2),hp,mul_one,ite_eq_left hu] + simp only [Nat.cast_pow,Nat.cast_ofNat] + · obtain ⟨j,hj⟩:=unit_eq_sign_omega u + have hj0 : j≠0 := by + intro he + subst j + apply hu + rcases hj with hj|hj + · left; apply Units.ext; simpa using hj + · right; apply Units.ext; simpa using hj + rw [ramified_arithmetic_explicit_table 0 0 u (n+2) j.val (by omega) hj (by simp), + ramifiedCongruence_zero,ite_eq_right (by simp [hj0]),ite_eq_right hu] + +lemma arithmeticDirichletSeries_zero_separate (s : ℂ) (hs : 2⟨3*k+1,by use k+1;omega⟩) ⟨by + intro a b h + have hh:=congrArg Subtype.val h + dsimp at hh + omega,by + rintro ⟨n,k,hk⟩ + refine ⟨k-1,Subtype.ext ?_⟩ + dsimp + omega⟩ + +lemma zero_ramified_geometric (s : ℂ) (hs : 1((3^(n+2):ℕ):ℂ)^(-s)* + (if 3∣n+2 then ((3^(n+2):ℕ):ℂ) else 0) + have hsup:Function.support F⊆{n:ℕ|3∣n+2} := by + intro n hn + by_contra h + change ¬3∣n+2 at h + exact hn (by simp [F,h]) + change (∑'n,F n)=_ + rw [←tsum_subtype_eq_of_support_subset hsup] + change (∑'n : {n:ℕ // 3∣n+2},F n.val)=_ + rw [←ramifiedCubeExponent.tsum_eq] + have he (k:ℕ) : F (ramifiedCubeExponent k).val=ramifiedRatio s^(k+1) := by + change ((3^(3*k+1+2):ℕ):ℂ)^(-s)*(if 3∣3*k+1+2 then ((3^(3*k+1+2):ℕ):ℂ) else 0)=_ + rw [ite_eq_left (by use k+1;omega),show 3*k+1+2=3*(k+1) by omega] + simpa using cube_norm_weight_algebra s k 1 (by decide) + simp_rw [he] + exact ramified_geometric_sum s hs + +lemma zero_ramified_factor (s : ℂ) (hs : 1by + have hn : ¬(u=1 ∨ u= -1):=by simpa using hu + simp [arithmeticResidueSum_zero_ramified,hn])] + simp only [Finset.sum_insert,Finset.mem_singleton,hne,not_false_eq_true,Finset.sum_singleton] + simp only [arithmeticResidueSum_zero_ramified,true_or,or_true,ite_true] + rw [zero_ramified_geometric s hs] + ring + +theorem arithmeticDirichletSeries_zero_unramified (s : ℂ) (hs : 2g t⁻¹) (s-2) := by + have hh := (MellinConvergent.comp_rpow (f := g) (s := s-2) + (a := -1) (by norm_num : (-1:ℝ)≠0)).mpr + (show MellinConvergent g ((s-2)/(-1:ℝ)) by + simpa only [show ((s-2)/(-1:ℝ):ℂ)=2-s by push_cast;ring] using hg) + simpa only [Real.rpow_neg_one] using hh + have hscale := (MellinConvergent.comp_mul_left (f := fun t : ℝ=>g t⁻¹) + (s := s-2) hQ).mpr hinv + have hpow := (MellinConvergent.cpow_smul (f := fun t : ℝ=>g (Q*t)⁻¹) + (s := s) (a := -2)).mpr (by simpa only [sub_eq_add_neg] using hscale) + simpa only [reflectedCuspProfile,smul_eq_mul] using hpow.const_smul A + +lemma cusp_truncation_reflection_ae (f g : ℝ→ℂ) (A : ℂ) (Q : ℝ) (hQ : 0truncatedCuspProfile 1 f v+ + reflectedCuspProfile A Q (truncatedCuspProfile (1/Q) g) v) := by + have hne : ∀ᵐv : ℝ ∂volume.restrict (Set.Ioi 0),v≠1 := + ae_restrict_of_ae (Measure.ae_ne volume 1) + filter_upwards [ae_restrict_mem measurableSet_Ioi,hne] with v hv hv1 + have hrel : 1/Q<(Q*v)⁻¹ ↔ v<1 := by + rw [inv_eq_one_div,div_lt_div_iff₀ hQ (mul_pos hQ hv)] + constructor <;> intro hh <;> nlinarith + by_cases hhi : 1not_lt_of_ge hhi.le (hrel.mp hh) + simp only [truncatedCuspProfile,ite_eq_left hhi,reflectedCuspProfile,ite_eq_right hlo, + mul_zero,add_zero] + · have hlo : 1/Q<(Q*v)⁻¹ := hrel.mpr (lt_of_le_of_ne (le_of_not_gt hhi) hv1) + simp only [truncatedCuspProfile,ite_eq_right hhi,reflectedCuspProfile,ite_eq_left hlo,zero_add] + exact hfg v hv + +theorem cusp_mellin_entire (f g : ℝ→ℂ) (A : ℂ) (Q decayF decayG : ℝ) + (hQ : 0Real.exp (-decayF*v))) + (hgbound : g =O[atTop] (fun v : ℝ=>Real.exp (-decayG*v))) + (hfg : ∀v : ℝ,0(v:ℂ)^(s-1) • z) hv.symm + · have he : mellin f s=mellin (fun v=>truncatedCuspProfile 1 f v+ + reflectedCuspProfile A Q (truncatedCuspProfile (1/Q) g) v) s := by + unfold mellin + apply integral_congr_ae + filter_upwards [hae] with v hv + rw [hv] + rw [he,hsum.2,reflectedCuspProfile_mellin _ _ _ _ hQ] + refine ⟨fun s=>(hresult s).1,?_⟩ + have he : mellin f=(fun s : ℂ=>mellin (truncatedCuspProfile 1 f) s+ + A*(Q:ℂ)^(2-s)*mellin (truncatedCuspProfile (1/Q) g) (2-s)) := + funext (fun s=>(hresult s).2) + rw [he] + let : NeZero (Q:ℂ) := ⟨Complex.ofReal_ne_zero.mpr hQ.ne'⟩ + have hp := (differentiable_const_cpow_of_neZero (Q:ℂ)).comp + ((differentiable_const (2:ℂ)).sub differentiable_id) + exact hfd.add (((differentiable_const A).mul hp).mul + (hgd.comp ((differentiable_const (2:ℂ)).sub differentiable_id))) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +section +local notation "O" => ActualEisensteinCubic.O +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +def directionalTerm (h : ActualEisensteinCubic.O) (v : ℝ) (z direction : ℂ) : ℂ := + horizontalPhaseMultiplier (cuspFrequency h) direction*coeff.term h (v,z) + +lemma term_horizontal_hasDerivAt (h : ActualEisensteinCubic.O) (v : ℝ) (hv : 0 coeff.term h (v,z+(x:ℂ)*direction)) + (coeff.directionalTerm h v (z+(t:ℂ)*direction) direction) t := by + have hh := (brevePhase_hasDerivAt (cuspFrequency h) z direction t).const_mul + (coeff.amplitude v h) + have hf : (fun x : ℝ => coeff.term h (v,z+(x:ℂ)*direction))= + (fun x : ℝ => coeff.amplitude v h* + ShortDraftTrace.breveE (cuspFrequency h*(z+(x:ℂ)*direction))) := by + funext x + exact coeff.term_eq_amplitude v hv h _ + rw [hf] + convert hh using 1 + rw [directionalTerm,coeff.term_eq_amplitude v hv h] + ring + +lemma directionalTerm_slab_bound (a b : ℝ) (ha : 0 coeff.directionalTerm h v z direction) := by + obtain ⟨C,hC,hbound⟩ := coeff.directionalTerm_slab_bound v v hv le_rfl direction + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun h => norm_nonneg _) (fun h => hbound h v z ⟨le_rfl,le_rfl⟩) + exact (summable_norm_mul_exp_neg_cuspFrequency (Real.pi*v) (mul_pos Real.pi_pos hv)).mul_left C + +lemma series_horizontal_hasDerivAt (v : ℝ) (hv : 0 coeff.series (v,z+(x:ℂ)*direction)) + (∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v (z+(t:ℂ)*direction) direction) t := by + obtain ⟨C,hC,hbound⟩ := coeff.directionalTerm_slab_bound v v hv le_rfl direction + have hs := (summable_norm_mul_exp_neg_cuspFrequency (Real.pi*v) (mul_pos Real.pi_pos hv)).mul_left C + have hz : Summable (fun h : ActualEisensteinCubic.O => coeff.term h (v,z+(0:ℂ)*direction)) := by + simpa only [zero_mul,add_zero] using coeff.summable (v,z) hv + exact hasDerivAt_tsum hs (fun h x => coeff.term_horizontal_hasDerivAt h v hv z direction x) + (fun h x => hbound h v (z+(x:ℂ)*direction) ⟨le_rfl,le_rfl⟩) hz t + +lemma fullFunction_horizontal_hasDerivAt (constant : ℂ) (v : ℝ) (hv : 0 coeff.fullFunction constant (upperPoint (z+(x:ℂ)*direction) v hv)) + (∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v (z+(t:ℂ)*direction) direction) t := by + have hh := (coeff.series_horizontal_hasDerivAt v hv z direction t).const_add + (constant*(v:ℂ)^(2/3:ℂ)) + simpa only [fullFunction,function, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] using hh + +theorem fullFunction_wirtingerBar (constant : ℂ) (v : ℝ) (hv : 0 coeff.fullFunction constant (upperPoint w v hv)) z= + ∑'h : ActualEisensteinCubic.O,(2*Real.pi*Complex.I*star (cuspFrequency h))*coeff.term h (v,z) := by + have h1 := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z 1 0).deriv + have hI := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerBar,h1,hI] + have hs1 := coeff.directionalTerm_summable v hv z 1 + have hsI := (coeff.directionalTerm_summable v hv z Complex.I).mul_left Complex.I + rw [←tsum_mul_left,←hs1.tsum_add hsI,←tsum_mul_left] + apply tsum_congr + intro h + unfold directionalTerm + linear_combination coeff.term h (v,z)*horizontalPhaseMultiplier_wirtinger (cuspFrequency h) + +lemma fullFunction_wirtingerBar_summable (v : ℝ) (hv : 0 (2*Real.pi*Complex.I*star (cuspFrequency h))*coeff.term h (v,z)) := by + have hs := ((coeff.directionalTerm_summable v hv z 1).add + ((coeff.directionalTerm_summable v hv z Complex.I).mul_left Complex.I)).mul_left (1/2:ℂ) + apply hs.congr + intro h + unfold directionalTerm + linear_combination coeff.term h (v,z)*horizontalPhaseMultiplier_wirtinger (cuspFrequency h) + +end SubexponentialBesselCoefficients +end + +local notation "O" => ActualEisensteinCubic.O +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma term_cusp_bound (a : ℝ) (ha : 0 mul_nonneg (norm_nonneg _) (Real.exp_pos _).le) + have hs := summable_norm_mul_exp_neg_cuspFrequency (Real.pi*a/2) (by positivity) + refine ⟨D*S*(2/(2*residualCuspDecayRate)),by positivity,?_⟩ + intro v z hav + have hsum := tsum_of_norm_bounded + (hs.hasSum.mul_left (D*v*Real.exp (-(2*residualCuspDecayRate)*v))) + (fun h => hbound h v z hav) + calc + _ ≤ (D*v*Real.exp (-(2*residualCuspDecayRate)*v))*S := hsum + _ = (D*S)*(v*Real.exp (-(2*residualCuspDecayRate)*v)) := by ring + _ ≤ (D*S)*((2/(2*residualCuspDecayRate))* + Real.exp (-((2*residualCuspDecayRate)/2)*v)) := + mul_le_mul_of_nonneg_left (norm_mul_exp_neg_bound (2*residualCuspDecayRate) v + (mul_pos (by norm_num) residualCuspDecayRate_pos)) (mul_nonneg hD hS) + _ = _ := by + rw [show -((2*residualCuspDecayRate)/2)*v=-residualCuspDecayRate*v by ring] + ring + +theorem fullFunction_wirtingerBar_cusp_decay (constant : ℂ) (a : ℝ) (ha : 0 coeff.fullFunction constant (upperPoint w v hv)) z‖≤ + C*Real.exp (-residualCuspDecayRate*v) := by + obtain ⟨C1,hC1,hbound1⟩ := coeff.directionalSeries_cusp_decay a ha 1 + obtain ⟨CI,hCI,hboundI⟩ := coeff.directionalSeries_cusp_decay a ha Complex.I + refine ⟨(C1+CI)/2,by positivity,?_⟩ + intro v hv z hav + have h1 := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z 1 0).deriv + have hI := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerBar,h1,hI,norm_mul] + have hhalf : ‖(1/2:ℂ)‖=(1/2:ℝ) := by norm_num + rw [hhalf] + calc + _ ≤ (1/2:ℝ)*(‖∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z 1‖+ + ‖Complex.I*(∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z Complex.I)‖) := + mul_le_mul_of_nonneg_left (norm_add_le _ _) (by norm_num) + _ = (1/2:ℝ)*(‖∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z 1‖+ + ‖∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z Complex.I‖) := by + rw [norm_mul,Complex.norm_I,one_mul] + _ ≤ (1/2:ℝ)*(C1*Real.exp (-residualCuspDecayRate*v)+CI*Real.exp (-residualCuspDecayRate*v)) := by + apply mul_le_mul_of_nonneg_left _ (by norm_num) + exact add_le_add (hbound1 v z hav) (hboundI v z hav) + _ = _ := by ring + +end SubexponentialBesselCoefficients +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +section +local notation "O" => ActualEisensteinCubic.O + +lemma spatialComplexSplit_differentiable : Differentiable ℝ spatialComplexSplit := by + change Differentiable ℝ (fun p : EuclideanSpatial => (p 2,(p 0:ℂ)+(p 1:ℂ)*Complex.I)) + fun_prop + +lemma spatialComplexSplit_symm_differentiable : Differentiable ℝ spatialComplexSplit.symm := by + change Differentiable ℝ (fun q : ℝ × ℂ => spatialComplexSplit.symm q) + simp_rw [spatialComplexSplit_symm_eq] + have hlin := (WithLp.linearEquiv 2 ℝ (Fin 3→ℝ)).symm.toContinuousLinearMap.differentiable + have hcoords : Differentiable ℝ (fun q : ℝ × ℂ => ![q.2.re,q.2.im,q.1]) := by + apply differentiable_pi.mpr + intro j + fin_cases j + · change Differentiable ℝ (fun q : ℝ × ℂ => q.2.re) + fun_prop + · change Differentiable ℝ (fun q : ℝ × ℂ => q.2.im) + fun_prop + · change Differentiable ℝ (fun q : ℝ × ℂ => q.1) + fun_prop + exact hlin.comp hcoords + +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma fullFunction_euclidean_differentiableAt (constant : ℂ) (p : EuclideanSpatial) (hp : 0

coeff.fullFunction constant (euclideanToHyperbolic q)) p := by + have hh := (coeff.fullFunction_cusp_differentiableAt constant (spatialComplexSplit p) hp).comp p + spatialComplexSplit_differentiable.differentiableAt + simpa only [Function.comp_def,cuspCoordinateLift,spatialComplexSplit.symm_apply_apply] using hh + +lemma fullFunction_translate_cusp_differentiableAt (constant : ℂ) (g : SL(2,ℂ)) + (p : ℝ × ℂ) (hp : 0 coeff.fullFunction constant (g • cuspCoordinateLift q)) p := by + have hx : 0<(spatialComplexSplit.symm p) 2 := by + rw [spatialComplexSplit_symm_eq] + exact hp + obtain ⟨A,hA,hAn⟩ := hyperbolicDifferentialIsometry g (spatialComplexSplit.symm p) hx + have hh := ((coeff.fullFunction_euclidean_differentiableAt constant + (euclideanAction g (spatialComplexSplit.symm p)) (euclideanAction_positive _ _)).comp _ + hA.differentiableAt).comp p spatialComplexSplit_symm_differentiable.differentiableAt + simpa only [Function.comp_def,euclideanAction,euclideanToHyperbolic_coordinates,cuspCoordinateLift] using hh + +lemma fullFunction_translate_split_differentiableAt (constant : ℂ) (g : SL(2,ℂ)) + (p : ℂ × ℝ) (hp : 0 coeff.fullFunction constant (g • cuspCoordinateLift (q.2,q.1))) p := by + have hswap : DifferentiableAt ℝ (fun q : ℂ × ℝ => (q.2,q.1)) p := + differentiableAt_snd.prodMk differentiableAt_fst + exact (coeff.fullFunction_translate_cusp_differentiableAt constant g (p.2,p.1) hp).comp p hswap + +end SubexponentialBesselCoefficients + +lemma cubicSourceResidualFunction_translate_split_differentiableAt (g : SL(2,ℂ)) + (p : ℂ × ℝ) (hp : 0 cubicSourceResidualFunction (g • cuspCoordinateLift (q.2,q.1))) p := by + rw [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselCoefficients.fullFunction_translate_split_differentiableAt + ((3*(Real.pi:ℂ))*constantArithmeticResidue) g p hp + +lemma cubicSourceResidualFunction_split_differentiableAt (p : ℂ × ℝ) (hp : 0 cubicSourceResidualFunction (cuspCoordinateLift (q.2,q.1))) p := by + simpa only [one_smul] using cubicSourceResidualFunction_translate_split_differentiableAt 1 p hp + +lemma cubicSourceResidualFunction_wirtingerBar (v : ℝ) (hv : 0 cubicSourceResidualFunction (upperPoint w v hv)) z= + ∑'h : ActualEisensteinCubic.O,(2*Real.pi*Complex.I*star (cuspFrequency h))*sourceBesselCoefficients.term h (v,z) := by + rw [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselCoefficients.fullFunction_wirtingerBar _ v hv z + +lemma cubicSourceResidualFunction_wirtingerBar_cusp_decay (a : ℝ) (ha : 0 cubicSourceResidualFunction (upperPoint w v hv)) z‖≤ + C*Real.exp (-residualCuspDecayRate*v) := by + rw [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselCoefficients.fullFunction_wirtingerBar_cusp_decay _ a ha + +end + +local notation "O" => ActualEisensteinCubic.O + +lemma horizontalPhaseMultiplier_wirtingerZ (freq : ℂ) : + (1/2:ℂ)*(horizontalPhaseMultiplier freq 1- + Complex.I*horizontalPhaseMultiplier freq Complex.I)=2*Real.pi*Complex.I*freq := by + simp only [horizontalPhaseMultiplier,mul_one,star_mul,Complex.star_def, + Complex.conj_I] + ring_nf + norm_num [Complex.I_sq,Complex.I_pow_three] + ring + +lemma horizontalWirtingerBar_star (f : ℂ→ℂ) (z : ℂ) : + horizontalWirtingerBar (fun w => star (f w)) z=star (horizontalWirtingerZ f z) := by + unfold horizontalWirtingerBar horizontalWirtingerZ + rw [deriv.star,deriv.star] + simp [] + +namespace SubexponentialBesselCoefficients +variable (coeff : SubexponentialBesselCoefficients) + +lemma fullFunction_wirtingerZ (constant : ℂ) (v : ℝ) (hv : 0 coeff.fullFunction constant (upperPoint w v hv)) z= + ∑'h : ActualEisensteinCubic.O,(2*Real.pi*Complex.I*cuspFrequency h)*coeff.term h (v,z) := by + have h1 := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z 1 0).deriv + have hI := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerZ,h1,hI] + have hs1 := coeff.directionalTerm_summable v hv z 1 + have hsI := (coeff.directionalTerm_summable v hv z Complex.I).mul_left Complex.I + rw [←tsum_mul_left,←hs1.tsum_sub hsI,←tsum_mul_left] + apply tsum_congr + intro h + unfold directionalTerm + linear_combination coeff.term h (v,z)*horizontalPhaseMultiplier_wirtingerZ (cuspFrequency h) + +lemma fullFunction_wirtingerZ_cusp_decay (constant : ℂ) (a : ℝ) (ha : 0 coeff.fullFunction constant (upperPoint w v hv)) z‖≤ + C*Real.exp (-residualCuspDecayRate*v) := by + obtain ⟨C1,hC1,hbound1⟩ := coeff.directionalSeries_cusp_decay a ha 1 + obtain ⟨CI,hCI,hboundI⟩ := coeff.directionalSeries_cusp_decay a ha Complex.I + refine ⟨(C1+CI)/2,by positivity,?_⟩ + intro v hv z hav + have h1 := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z 1 0).deriv + have hI := (coeff.fullFunction_horizontal_hasDerivAt constant v hv z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerZ,h1,hI,norm_mul] + have hhalf : ‖(1/2:ℂ)‖=(1/2:ℝ) := by norm_num + rw [hhalf] + calc + _ ≤ (1/2:ℝ)*(‖∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z 1‖+ + ‖Complex.I*(∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z Complex.I)‖) := + mul_le_mul_of_nonneg_left (norm_sub_le _ _) (by norm_num) + _ = (1/2:ℝ)*(‖∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z 1‖+ + ‖∑'h : ActualEisensteinCubic.O,coeff.directionalTerm h v z Complex.I‖) := by + rw [norm_mul,Complex.norm_I,one_mul] + _ ≤ (1/2:ℝ)*(C1*Real.exp (-residualCuspDecayRate*v)+CI*Real.exp (-residualCuspDecayRate*v)) := by + apply mul_le_mul_of_nonneg_left _ (by norm_num) + exact add_le_add (hbound1 v z hav) (hboundI v z hav) + _ = _ := by ring + +end SubexponentialBesselCoefficients + +lemma cubicSourceResidualFunction_wirtingerZ (v : ℝ) (hv : 0 cubicSourceResidualFunction (upperPoint w v hv)) z= + ∑'h : ActualEisensteinCubic.O,(2*Real.pi*Complex.I*cuspFrequency h)*sourceBesselCoefficients.term h (v,z) := by + rw [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselCoefficients.fullFunction_wirtingerZ _ v hv z + +lemma cubicSourceResidualFunction_wirtingerZ_cusp_decay (a : ℝ) (ha : 0 cubicSourceResidualFunction (upperPoint w v hv)) z‖≤ + C*Real.exp (-residualCuspDecayRate*v) := by + rw [cubicSourceResidualFunction_eq_bessel] + exact sourceBesselCoefficients.fullFunction_wirtingerZ_cusp_decay _ a ha + +def cubicSourceConjugateFunction (w : HyperbolicSpace) : ℂ := star (cubicSourceResidualFunction w) + +lemma cubicSourceConjugateFunction_translate_split_differentiableAt (g : SL(2,ℂ)) + (p : ℂ × ℝ) (hp : 0 cubicSourceConjugateFunction (g • cuspCoordinateLift (q.2,q.1))) p := + (cubicSourceResidualFunction_translate_split_differentiableAt g p hp).star + +lemma cubicSourceConjugateFunction_wirtingerBar_cusp_decay (a : ℝ) (ha : 0 cubicSourceConjugateFunction (upperPoint w v hv)) z‖≤ + C*Real.exp (-residualCuspDecayRate*v) := by + obtain ⟨C,hC,hbound⟩ := cubicSourceResidualFunction_wirtingerZ_cusp_decay a ha + refine ⟨C,hC,?_⟩ + intro v hv z hav + simpa only [cubicSourceConjugateFunction,horizontalWirtingerBar_star,norm_star] using hbound v hv z hav + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +lemma horizontalWirtingerBar_translate (f : ℂ→ℂ) (a : ℂ) : + horizontalWirtingerBar (fun z=>f (z+a)) 0=horizontalWirtingerBar f a := by + unfold horizontalWirtingerBar + simp only [zero_add] + have h1 : (fun t : ℝ=>f ((t:ℂ)+a))=(fun t : ℝ=>f (a+(t:ℂ))) := by + funext t + rw [add_comm] + have hI : (fun t : ℝ=>f ((t:ℂ)*Complex.I+a))=(fun t : ℝ=>f (a+(t:ℂ)*Complex.I)) := by + funext t + rw [add_comm] + rw [h1,hI] + +lemma cuspDerivative_of_transform (f : HyperbolicSpace→ℂ) (g H : SL(2,ℂ)) + (κ : ℂ) (htransform : ∀w,f (g•w)=κ*f (H•w)) (hc : g 1 0≠0) + (v : ℝ) (hv : 0f (H•cuspCoordinateLift (q.2,q.1))) + (-g 1 1/g 1 0,1/(‖g 1 0‖^2*v))) : + horizontalWirtingerBar (fun z=>f (upperPoint z v hv)) (g 0 0/g 1 0)= + (κ*(-1/((g 1 0)^2*(v:ℂ)^2)))* + horizontalWirtingerZ + (fun z=>f (H•upperPoint z (1/(‖g 1 0‖^2*v)) (by positivity))) + (-g 1 1/g 1 0) := by + let FH : ℂ × ℝ→ℂ := fun q=>f (H•cuspCoordinateLift (q.2,q.1)) + let base : ℂ × ℝ := (-g 1 1/g 1 0,1/(‖g 1 0‖^2*v)) + let D := fderiv ℝ FH base + have hF : HasFDerivAt FH D base := hD.hasFDerivAt + have hscaled : HasFDerivAt (fun q=>κ*FH q) (κ • D) base := hF.const_mul κ + have he := inverse_cusp_wirtingerBar (g 1 0) (g 1 1) v hc hv + (fun q=>κ*FH q) (κ • D) hscaled + have hline : (fun z=>κ*FH (inverseCuspCoordinates (g 1 0) (g 1 1) v z))= + (fun z=>f (upperPoint (z+g 0 0/g 1 0) v hv)) := by + funext z + have ht := htransform (g⁻¹•upperPoint (z+g 0 0/g 1 0) v hv) + rw [smul_inv_smul,inverse_cusp_action g hc v hv z] at ht + change κ*f (H•cuspCoordinateLift + ((inverseCuspCoordinates (g 1 0) (g 1 1) v z).2, + (inverseCuspCoordinates (g 1 0) (g 1 1) v z).1))=_ + rw [cuspCoordinateLift_positive _ _ (inverseCuspCoordinates_height_pos _ _ _ _ hc hv)] + exact ht.symm + rw [hline] at he + have hshift := horizontalWirtingerBar_translate (fun z=>f (upperPoint z v hv)) (g 0 0/g 1 0) + rw [hshift] at he + have hz := horizontalWirtingerZ_eq_fderiv FH D (-g 1 1/g 1 0) (1/(‖g 1 0‖^2*v)) hF + have hFH : (fun z=>FH (z,1/(‖g 1 0‖^2*v)))= + (fun z=>f (H•upperPoint z (1/(‖g 1 0‖^2*v)) (by positivity))) := by + funext z + exact congrArg (fun w=>f (H•w)) (cuspCoordinateLift_positive _ _ (by positivity)) + rw [hFH] at hz + rw [hz] + rw [he] + simp only [_root_.smul_apply,smul_eq_mul] + ring + +lemma cubicSourceResidualFunction_levelThree (G : CubicKubota.levelThree) (w : HyperbolicSpace) : + cubicSourceResidualFunction (complexMatrix G•w)= + CubicKubota.complexCharacter G*cubicSourceResidualFunction w := by + have hh := cubicSourceResidualFunction_automorphy (CubicKubota.sourceLevelInclusion G) w + change cubicSourceResidualFunction (complexMatrix G•w)= + CubicKubota.levelTwoComplexCharacter ⟨G.val,CubicKubota.levelThree_le_levelTwo G.property⟩* + cubicSourceResidualFunction w at hh + rw [CubicKubota.levelTwoComplexCharacter_restrict] at hh + exact hh + +lemma cubicSourceConjugateFunction_levelThree (G : CubicKubota.levelThree) (w : HyperbolicSpace) : + cubicSourceConjugateFunction (complexMatrix G•w)= + star (CubicKubota.complexCharacter G)*cubicSourceConjugateFunction w := by + simp only [cubicSourceConjugateFunction,cubicSourceResidualFunction_levelThree,star_mul] + ring + +theorem cubicSourceResidualFunction_cuspDerivative (G : CubicKubota.levelThree) + (g H : SL(2,ℂ)) (hfactor : g=complexMatrix G*H) (hc : g 1 0≠0) + (v : ℝ) (hv : 0cubicSourceResidualFunction (upperPoint z v hv)) (g 0 0/g 1 0)= + (CubicKubota.complexCharacter G*(-1/((g 1 0)^2*(v:ℂ)^2)))* + horizontalWirtingerZ + (fun z=>cubicSourceResidualFunction (H•upperPoint z (1/(‖g 1 0‖^2*v)) (by positivity))) + (-g 1 1/g 1 0) := by + refine cuspDerivative_of_transform cubicSourceResidualFunction g H + (CubicKubota.complexCharacter G) ?_ hc v hv ?_ + · intro w + rw [hfactor,mul_smul,cubicSourceResidualFunction_levelThree] + · exact cubicSourceResidualFunction_translate_split_differentiableAt H _ (by positivity) + +theorem cubicSourceConjugateFunction_cuspDerivative (G : CubicKubota.levelThree) + (g H : SL(2,ℂ)) (hfactor : g=complexMatrix G*H) (hc : g 1 0≠0) + (v : ℝ) (hv : 0cubicSourceConjugateFunction (upperPoint z v hv)) (g 0 0/g 1 0)= + (star (CubicKubota.complexCharacter G)*(-1/((g 1 0)^2*(v:ℂ)^2)))* + horizontalWirtingerZ + (fun z=>cubicSourceConjugateFunction (H•upperPoint z (1/(‖g 1 0‖^2*v)) (by positivity))) + (-g 1 1/g 1 0) := by + refine cuspDerivative_of_transform cubicSourceConjugateFunction g H + (star (CubicKubota.complexCharacter G)) ?_ hc v hv ?_ + · intro w + rw [hfactor,mul_smul,cubicSourceConjugateFunction_levelThree] + · exact cubicSourceConjugateFunction_translate_split_differentiableAt H _ (by positivity) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ReflectionFibers.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ReflectionFibers.lean new file mode 100644 index 0000000000000000000000000000000000000000..f3f7149c99ae9991dd0e607381a1dbd44301f2e9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ReflectionFibers.lean @@ -0,0 +1,615 @@ +import OAI.NumberTheory.DirichletL.GaussSum.FixedRayFibers + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open scoped BigOperators Classical ContDiff MatrixGroups + +open ActualEisensteinCubic CompletedGauss CompletedDyadic CubicKubota CubicJacobiGlobal ConcreteTraceCRT +open LocalReflectionBrackets ShortDraftCusp +local notation "Eis" => ActualEisensteinCubic.O +namespace FixedFourierGeometry +variable {c:Eis} {h:Eis⧸Ideal.span {c}} (G:FixedFourierGeometry c h) +variable {ι:Type*} [Fintype ι] {p:ι→Eis} {N:Eis} + +lemma stratum_model_coefficient (D:ControlledStratumArithmetic p N G.a0 G.c0 G.mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hp:∀i,p i≠0) (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) + (u:Eisˣ) (m:ℕ) (I J:Ideal Eis) : + G.shape.amplitude u m I J* + (star D.fixedFactor*A4BadPhase G.c0 G.denominator_ne_zero (D.matrix (fun _=>1) 1 1) D.U + (G.dualNumerator u m I J))*D.bracketProduct hp hg j (G.dualNumerator u m I J)= + D.modelRowPhase G.shape hp hg j u m* + ∑e:ι→Fin 3,G.array (Ideal.Quotient.mk _ (-(D.matrix (fun _=>1) 1 1)*D.U)) u m I J* + reflectedBranch (fun i=>Ideal.span {p i}) hg j e (primaryGenerator I) (primaryGenerator J) := + D.model_coefficient G.shape hp G.denominator_ne_zero hg j u m I J + +theorem reflectedValue_eq_model_series (D:ControlledStratumArithmetic p N G.a0 G.c0 G.mode) + [∀i,(Ideal.span {p i}).IsMaximal] + (hp:∀i,p i≠0) (hg:∀i,lambda∉Ideal.span {p i}) (j:ι→ℕ) (W:ℝ→ℂ) (X:ℝ) : + D.reflectedValue G.shape hp G.denominator_ne_zero hg j W X= + fixedRadialCoefficientScalar*G.shape.stratumShapeFactor (G.c0*∏i,p i)* + ∑'t:ThetaFullIndex, + (D.modelRowPhase G.shape hp hg j t.1 t.2.1* + ∑e:ι→Fin 3, + G.array (Ideal.Quotient.mk _ (-(D.matrix (fun _=>1) 1 1)*D.U)) + t.1 t.2.1 t.2.2.1.val t.2.2.2.val* + reflectedBranch (fun i=>Ideal.span {p i}) hg j e + (primaryGenerator t.2.2.1.val) (primaryGenerator t.2.2.2.val)) / + ((ramifiedScale 1 completedRamifiedStep t.2.1* + Real.sqrt (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ):ℝ):ℂ)* + CubicReflectionKernel.paperKernel (Vstar W) + ((X/(G.levelScale*(Ideal.absNorm (Ideal.span {∏i,p i}):ℝ)^2))* + (ramifiedScale 1 completedRamifiedStep t.2.1)^3* + (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ)^3) := by + unfold ControlledStratumArithmetic.reflectedValue + apply congrArg (fun z:ℂ=>fixedRadialCoefficientScalar*G.shape.stratumShapeFactor (G.c0*∏i,p i)*z) + apply tsum_congr + intro t + rw [fixed_stratum_kernel_scale] + have he:=G.stratum_model_coefficient D hp hg j t.1 t.2.1 t.2.2.1.val t.2.2.2.val + have hx:sourceCuspPhaseNumerator G.shape.index (G.shape.upper 0 0) (thetaFullFrequency t)= + G.dualNumerator t.1 t.2.1 t.2.2.1.val t.2.2.2.val := by + rw [thetaFullFrequency_eq_fixedCuspArrayIndex] + rfl + rw [hx] + let denominator:ℂ:=((ramifiedScale 1 completedRamifiedStep t.2.1* + Real.sqrt (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ):ℝ):ℂ) + let kernel:ℂ:=CubicReflectionKernel.paperKernel (Vstar W) + ((X/(G.levelScale*(Ideal.absNorm (Ideal.span {∏i,p i}):ℝ)^2))* + (ramifiedScale 1 completedRamifiedStep t.2.1)^3* + (Ideal.absNorm t.2.2.1.val:ℝ)*(Ideal.absNorm t.2.2.2.val:ℝ)^3) + change _/denominator*kernel*_=_/denominator*kernel + calc + _=(G.shape.amplitude t.1 t.2.1 t.2.2.1.val t.2.2.2.val* + (star D.fixedFactor*A4BadPhase G.c0 G.denominator_ne_zero (D.matrix (fun _=>1) 1 1) D.U + (G.dualNumerator t.1 t.2.1 t.2.2.1.val t.2.2.2.val))* + D.bracketProduct hp hg j (G.dualNumerator t.1 t.2.1 t.2.2.1.val t.2.2.2.val))/denominator*kernel := by ring + _=_:=by rw [he] + +end FixedFourierGeometry +end + +open ActualEisensteinCubic CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +abbrev CuspIdealIndex := Eisˣ×ℕ×NonzeroDualIdeal×NonzeroDualIdeal + +def thetaFullToIdealIndex (t:ThetaFullIndex) : CuspIdealIndex := + (t.1,t.2.1,primaryCubePairToMellinIndex t.2.2) + +lemma thetaFullToIdealIndex_injective : Function.Injective thetaFullToIdealIndex := by + intro t v h + apply Prod.ext + · exact congrArg (fun x:CuspIdealIndex=>x.1) h + · apply Prod.ext + · exact congrArg (fun x:CuspIdealIndex=>x.2.1) h + · apply primaryCubePairToMellinIndex_injective + exact congrArg (fun x:CuspIdealIndex=>x.2.2) h + +lemma fixedCuspArrayWithPhase_eligible (j:Fin 3) (u:Eisˣ) + (φ:ℕ→Ideal Eis→Ideal Eis→ℂ) (m:ℕ) (I J:Ideal Eis) + (h:fixedCuspArrayWithPhase j u φ m I J≠0) : fixedCuspArrayEligible I J := by + by_contra he + exact h (fixedCuspArrayWithPhase_zero j u φ m I J he) + +theorem fixedCuspArrayWithPhase_tsum_primary_pairs (j:Fin 3) (u:Eisˣ) + (φ:ℕ→Ideal Eis→Ideal Eis→ℂ) (m:ℕ) (w:CompletedMellinIndex→ℂ) : + (∑'t:CompletedMellinIndex,fixedCuspArrayWithPhase j u φ m t.1.val t.2.val*w t)= + ∑'t:ThetaPrimaryCubePair,fixedCuspArrayWithPhase j u φ m t.1.val t.2.val* + w (primaryCubePairToMellinIndex t) := by + apply tsum_eq_tsum_of_ne_zero_bij + (fun t=>primaryCubePairToMellinIndex t.val) + · exact primaryCubePairToMellinIndex_injective.comp Subtype.val_injective + · intro t ht + change fixedCuspArrayWithPhase j u φ m t.1.val t.2.val*w t≠0 at ht + have ha:fixedCuspArrayWithPhase j u φ m t.1.val t.2.val≠0:=by + intro hz + exact ht (by rw [hz,zero_mul]) + obtain ⟨hs,hI,hJ⟩:=fixedCuspArrayWithPhase_eligible j u φ m t.1.val t.2.val ha + let v:ThetaPrimaryCubePair:=(⟨t.1.val,hs,hI⟩,⟨t.2.val,hJ⟩) + have hv:primaryCubePairToMellinIndex v=t:=Prod.ext (Subtype.ext rfl) (Subtype.ext rfl) + refine ⟨⟨v,?_⟩,hv⟩ + change fixedCuspArrayWithPhase j u φ m (primaryCubePairToMellinIndex v).1.val + (primaryCubePairToMellinIndex v).2.val*w (primaryCubePairToMellinIndex v)≠0 + rwa [hv] + · intro t + rfl + +theorem fixedCuspArrayWithPhase_tsum_full_index + (j:Eisˣ→Fin 3) (φ:Eisˣ→ℕ→Ideal Eis→Ideal Eis→ℂ) (w:CuspIdealIndex→ℂ) : + (∑'t:CuspIdealIndex,fixedCuspArrayWithPhase (j t.1) t.1 (φ t.1) + t.2.1 t.2.2.1.val t.2.2.2.val*w t)= + ∑'t:ThetaFullIndex,fixedCuspArrayWithPhase (j t.1) t.1 (φ t.1) + t.2.1 t.2.2.1.val t.2.2.2.val*w (thetaFullToIdealIndex t) := by + apply tsum_eq_tsum_of_ne_zero_bij (fun t=>thetaFullToIdealIndex t.val) + · exact thetaFullToIdealIndex_injective.comp Subtype.val_injective + · intro t ht + change fixedCuspArrayWithPhase (j t.1) t.1 (φ t.1) t.2.1 t.2.2.1.val t.2.2.2.val*w t≠0 at ht + have ha:fixedCuspArrayWithPhase (j t.1) t.1 (φ t.1) t.2.1 t.2.2.1.val t.2.2.2.val≠0:=by + intro hz + exact ht (by rw [hz,zero_mul]) + obtain ⟨hs,hI,hJ⟩:=fixedCuspArrayWithPhase_eligible _ _ _ _ _ _ ha + let v:ThetaFullIndex:=(t.1,t.2.1,⟨t.2.2.1.val,hs,hI⟩,⟨t.2.2.2.val,hJ⟩) + have hv:thetaFullToIdealIndex v=t:= + Prod.ext rfl (Prod.ext rfl (Prod.ext (Subtype.ext rfl) (Subtype.ext rfl))) + refine ⟨⟨v,?_⟩,hv⟩ + change fixedCuspArrayWithPhase (j (thetaFullToIdealIndex v).1) (thetaFullToIdealIndex v).1 + (φ (thetaFullToIdealIndex v).1) (thetaFullToIdealIndex v).2.1 + (thetaFullToIdealIndex v).2.2.1.val (thetaFullToIdealIndex v).2.2.2.val* + w (thetaFullToIdealIndex v)≠0 + rwa [hv] + · intro t + rfl + +end CubicEisenstein + +open scoped Classical BigOperators + +namespace CompletedGauss +variable {ι:Type*} [Fintype ι] [DecidableEq ι] + +def mandatoryActiveEquiv (R:Finset ι) : + {A:Finset ι // R⊆A}≃Finset {i:ι // i∉R} where + toFun A:=A.val.subtype (fun i=>i∉R) + invFun B:=⟨R∪B.image Subtype.val,Finset.subset_union_left⟩ + left_inv A:=by + apply Subtype.ext + ext i + simp only [Finset.mem_union,Finset.mem_image,Finset.mem_subtype] + constructor + · rintro (hi|⟨j,hj,rfl⟩) + · exact A.property hi + · exact hj + · intro hi + by_cases hr:i∈R + · exact Or.inl hr + · exact Or.inr ⟨⟨i,hr⟩,hi,rfl⟩ + right_inv B:=by + ext i + simp only [Finset.mem_subtype,Finset.mem_union,Finset.mem_image] + constructor + · rintro (hi|⟨j,hj,hji⟩) + · exact False.elim (i.property hi) + · have he:j=i:=Subtype.ext hji + simpa only [he] using hj + · intro hi + exact Or.inr ⟨i,hi,rfl⟩ + +lemma sum_mandatory_active {V:Type*} [AddCommMonoid V] + (R:Finset ι) (F:Finset ι→V) (hz:∀A,¬R⊆A→F A=0) : + (∑A:Finset ι,F A)= + ∑B:Finset {i:ι // i∉R},F (R∪B.image Subtype.val) := by + calc + _=∑A:Finset ι,if R⊆A then F A else 0:=by + apply Finset.sum_congr rfl + intro A hA + by_cases h:R⊆A + · simp only [ite_eq_left h] + · simp only [ite_eq_right h,hz A h] + _=∑A:{A:Finset ι // R⊆A},F A.val:=by + rw [←Finset.sum_filter] + exact Finset.sum_subtype (Finset.univ.filter (fun A:Finset ι=>R⊆A)) (by simp) F + _=_:=by + apply Fintype.sum_equiv (mandatoryActiveEquiv R) + intro A + exact congrArg F (congrArg Subtype.val ((mandatoryActiveEquiv R).left_inv A)).symm + +theorem inactive_weight_mandatory_active (R:Finset ι) (z:ι→ℂ) + (hz:∀i∈R,z i=0) (F:Finset ι→ℂ) : + (∑A:Finset ι,(∏i∈(Finset.univ:Finset ι)\A,z i)*F A)= + ∑B:Finset {i:ι // i∉R}, + (∏i∈(Finset.univ:Finset ι)\(R∪B.image Subtype.val),z i)* + F (R∪B.image Subtype.val) := by + apply sum_mandatory_active R + intro A hA + have hex:∃i∈R,i∉A:=by + by_contra! hn + exact hA hn + obtain ⟨i,hi,hni⟩:=hex + have hm:i∈(Finset.univ:Finset ι)\A:=by simp [hni] + rw [Finset.prod_eq_zero hm (hz i hi),zero_mul] + +lemma inactive_product_complement (R:Finset ι) (z:ι→ℂ) + (B:Finset {i:ι // i∉R}) : + (∏i∈(Finset.univ:Finset ι)\(R∪B.image Subtype.val),z i)= + ∏i∈(Finset.univ:Finset {i:ι // i∉R})\B,z i.val := by + symm + apply Finset.prod_bij (fun i _=>i.val) + · intro i hi + simp only [Finset.mem_sdiff,Finset.mem_univ,true_and] at hi ⊢ + intro hmem + rcases Finset.mem_union.mp hmem with hr|hb + · exact i.property hr + · obtain ⟨j,hj,hji⟩:=Finset.mem_image.mp hb + exact hi ((Subtype.ext hji) ▸ hj) + · intro i hi j hj he + exact Subtype.ext he + · intro i hi + have hnot:i∉R∪B.image Subtype.val:=(Finset.mem_sdiff.mp hi).2 + have hr:i∉R:=fun h=>hnot (Finset.mem_union_left _ h) + refine ⟨⟨i,hr⟩,?_,rfl⟩ + simp only [Finset.mem_sdiff,Finset.mem_univ,true_and] + intro hb + exact hnot (Finset.mem_union_right _ (Finset.mem_image.mpr ⟨⟨i,hr⟩,hb,rfl⟩)) + · intro i hi + rfl + +theorem inactive_weight_optional_active (R:Finset ι) (z:ι→ℂ) + (hz:∀i∈R,z i=0) (F:Finset ι→ℂ) : + (∑A:Finset ι,(∏i∈(Finset.univ:Finset ι)\A,z i)*F A)= + ∑B:Finset {i:ι // i∉R}, + (∏i∈(Finset.univ:Finset {i:ι // i∉R})\B,z i.val)* + F (R∪B.image Subtype.val) := by + rw [inactive_weight_mandatory_active R z hz F] + apply Finset.sum_congr rfl + intro B hB + rw [inactive_product_complement] + +end CompletedGauss + +namespace CanonicalRowCompletion +open ActualEisensteinCubic CanonicalQuadraticSieve CompletedGauss IdealMobiusDivisorSum +local notation "Eis" => ActualEisensteinCubic.O + +lemma excluded_prime_dvd_row_mask (q:ℕ) (m:Eis) (F P:Ideal Eis) + (hP:P∈reflectionExcludedPrimes q) : + P∣Ideal.span {m*excludedGenerator (reflectionExcludedPrimes q)}*F := by + apply dvd_mul_of_dvd_left + apply Ideal.dvd_iff_le.mpr + apply Ideal.span_le.mpr + exact Set.singleton_subset_iff.mpr (P.mul_mem_left m (excludedGenerator_mem _ hP)) + +lemma residual_prime_not_excluded (q:ℕ) (m:Eis) (F I P:Ideal Eis) (hP:Prime P) + (hres:P∣rowResidualPart I (Ideal.span {m*excludedGenerator (reflectionExcludedPrimes q)}*F)) : + P∉reflectionExcludedPrimes q := by + intro hmem + have hn:¬P∣Ideal.span {m*excludedGenerator (reflectionExcludedPrimes q)}*F:= + ((prime_dvd_rowResidualPart_iff _ _ P hP).mp hres).2 + exact hn (excluded_prime_dvd_row_mask q m F P hmem) + +lemma residual_coprime_fixed_conductor (q:ℕ) (hq:q≠0) (m:Eis) (F I:Ideal Eis) : + IsCoprime (Ideal.span {reflectionConductor q}) + (rowResidualPart I (Ideal.span {m*excludedGenerator (reflectionExcludedPrimes q)}*F)) := by + let Q:=Ideal.span {m*excludedGenerator (reflectionExcludedPrimes q)}*F + apply (IdealCoprimeSieveOperator.primeSupport_disjoint_iff + (Ideal.span_singleton_eq_bot.not.mpr (reflectionConductor_ne_zero q hq)) + (squarefreeResidualPart_ne_zero (rowSimplePart I) Q)).mp + apply Finset.disjoint_left.mpr + intro P hfixed hres + have hp:Prime P:=support_prime hfixed + have hd:P∣Ideal.span {reflectionConductor q}:= + UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors (Multiset.mem_toFinset.mp hfixed) + have hr:P∣rowResidualPart I Q:= + UniqueFactorizationMonoid.dvd_of_mem_normalizedFactors (Multiset.mem_toFinset.mp hres) + exact residual_prime_not_excluded q m F I P hp hr (reflectionConductor_prime_mem q hq P hp hd) + +end CanonicalRowCompletion + +open scoped BigOperators Classical + +namespace CompletedGauss + +section +open ActualEisensteinCubic CanonicalQuadraticSieve +local notation "Eis" => ActualEisensteinCubic.O + +def representativeRowFiber (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) : Finset (Ideal Eis) := + completedRowFiber rows Q (rowPowerfulPart I) (rowMaskPart I Q) + +def reconstructFiberRow (I Q k:Ideal Eis) : Ideal Eis := + rowPowerfulPart I*rowMaskPart I Q*k + +lemma reconstructFiberRow_ne_zero (I Q k:Ideal Eis) (hk:k≠0) : reconstructFiberRow I Q k≠0 := + mul_ne_zero (mul_ne_zero (rowPowerfulPart_ne_zero I) + (squarefreeMaskPart_ne_zero (rowSimplePart I) Q)) hk + +lemma reconstructFiberRow_of_original (rows:Finset (Ideal Eis)) (I Q J:Ideal Eis) + (hJ:J∈representativeRowFiber rows I Q) (hJ0:J≠0) : + reconstructFiberRow I Q (rowResidualPart J Q)=J := by + obtain ⟨_,hA,hT⟩:=Finset.mem_filter.mp hJ + rw [reconstructFiberRow,←hA,←hT] + exact row_powerful_mask_residual_product J Q hJ0 + +lemma residual_reconstructFiberRow (rows:Finset (Ideal Eis)) (I Q k:Ideal Eis) + (hk:k≠0) (hmem:reconstructFiberRow I Q k∈representativeRowFiber rows I Q) : + rowResidualPart (reconstructFiberRow I Q k) Q=k := by + have he:=reconstructFiberRow_of_original rows I Q _ hmem (reconstructFiberRow_ne_zero I Q k hk) + exact mul_left_cancel₀ (mul_ne_zero (rowPowerfulPart_ne_zero I) + (squarefreeMaskPart_ne_zero (rowSimplePart I) Q)) he + +lemma representativeRowFiber_injective (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) + (hrows:∀J∈rows,J≠0) : + Set.InjOn (fun J=>rowResidualPart J Q) (representativeRowFiber rows I Q) := + rowResidualPart_injective_on_fiber rows Q (rowPowerfulPart I) (rowMaskPart I Q) hrows + +def fiberResidualIndex (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (hbad:∀P∈fixedBadPrimes,P∣Q) + (hrows:∀J∈rows,J≠0 ∧ (Ideal.absNorm J:ℝ)≤K) + (J:representativeRowFiber rows I Q) : idealRange (completedResidualScale K I Q) := + ⟨rowResidualPart J.val Q,completedRowFiber_residual_range rows Q + (rowPowerfulPart I) (rowMaskPart I Q) hbad K hrows J.val J.property⟩ + +lemma fiberResidualIndex_injective (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (hbad:∀P∈fixedBadPrimes,P∣Q) + (hrows:∀J∈rows,J≠0 ∧ (Ideal.absNorm J:ℝ)≤K) : + Function.Injective (fiberResidualIndex rows I Q K hbad hrows) := by + intro J lengthScale he + apply Subtype.ext + apply representativeRowFiber_injective rows I Q (fun J hJ=>(hrows J hJ).1) J.property lengthScale.property + exact congrArg Subtype.val he + +def extendFiberRowScalar {α:Type*} (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (a:α) + (k:idealRange (completedResidualScale K I Q)) : ℂ := + if h:reconstructFiberRow I Q k.val∈representativeRowFiber rows I Q then + scalar a ⟨reconstructFiberRow I Q k.val,h⟩ else 0 + +lemma extendFiberRowScalar_norm_le_one {α:Type*} (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (hscalar:∀a J,‖scalar a J‖≤1) + (a:α) (k:idealRange (completedResidualScale K I Q)) : + ‖extendFiberRowScalar rows I Q K scalar a k‖≤1 := by + unfold extendFiberRowScalar + split_ifs + · exact hscalar _ _ + · simp + +lemma extendFiberRowScalar_zero {α:Type*} (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (a:α) + (k:idealRange (completedResidualScale K I Q)) + (hk:reconstructFiberRow I Q k.val∉representativeRowFiber rows I Q) : + extendFiberRowScalar rows I Q K scalar a k=0 := by + simp only [extendFiberRowScalar,dite_eq_right hk] + +lemma extendFiberRowScalar_at_original {α:Type*} (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (hbad:∀P∈fixedBadPrimes,P∣Q) + (hrows:∀J∈rows,J≠0 ∧ (Ideal.absNorm J:ℝ)≤K) + (scalar:α → representativeRowFiber rows I Q → ℂ) (a:α) + (J:representativeRowFiber rows I Q) : + extendFiberRowScalar rows I Q K scalar a (fiberResidualIndex rows I Q K hbad hrows J)=scalar a J := by + have hJ0:J.val≠0:=(hrows J.val (Finset.mem_filter.mp J.property).1).1 + have he:=reconstructFiberRow_of_original rows I Q J.val J.property hJ0 + simp only [extendFiberRowScalar,fiberResidualIndex,he,dite_eq_left J.property] + +def extendSelectedFiberRowScalar {α τ:Type*} [DecidableEq τ] + (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (selector:α → representativeRowFiber rows I Q → τ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (t:τ) (a:α) + (k:idealRange (completedResidualScale K I Q)) : ℂ := + extendFiberRowScalar rows I Q K (fun a J=>if selector a J=t then scalar a J else 0) a k + +lemma extendSelectedFiberRowScalar_norm_le_one {α τ:Type*} [DecidableEq τ] + (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (selector:α → representativeRowFiber rows I Q → τ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (hscalar:∀a J,‖scalar a J‖≤1) + (t:τ) (a:α) (k:idealRange (completedResidualScale K I Q)) : + ‖extendSelectedFiberRowScalar rows I Q K selector scalar t a k‖≤1 := by + apply extendFiberRowScalar_norm_le_one + intro a J + split_ifs + · exact hscalar a J + · simp + +lemma extendSelectedFiberRowScalar_at_original {α τ:Type*} [DecidableEq τ] + (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (hbad:∀P∈fixedBadPrimes,P∣Q) + (hrows:∀J∈rows,J≠0 ∧ (Ideal.absNorm J:ℝ)≤K) + (selector:α → representativeRowFiber rows I Q → τ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (t:τ) (a:α) + (J:representativeRowFiber rows I Q) : + extendSelectedFiberRowScalar rows I Q K selector scalar t a + (fiberResidualIndex rows I Q K hbad hrows J)= + if selector a J=t then scalar a J else 0 := + extendFiberRowScalar_at_original rows I Q K hbad hrows _ a J + +lemma sum_extendSelectedFiberRowScalar {α τ:Type*} [Fintype τ] [DecidableEq τ] + (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (selector:α → representativeRowFiber rows I Q → τ) + (scalar:α → representativeRowFiber rows I Q → ℂ) (a:α) + (k:idealRange (completedResidualScale K I Q)) : + (∑t:τ,extendSelectedFiberRowScalar rows I Q K selector scalar t a k)= + extendFiberRowScalar rows I Q K scalar a k := by + by_cases hk:reconstructFiberRow I Q k.val∈representativeRowFiber rows I Q + · simp [extendSelectedFiberRowScalar,extendFiberRowScalar,hk] + · simp only [extendSelectedFiberRowScalar,extendFiberRowScalar,dite_eq_right hk,Finset.sum_const_zero] + +end + +open ActualEisensteinCubic CanonicalQuadraticSieve +local notation "Eis" => ActualEisensteinCubic.O + +theorem reconstructFiberRow_valid_iff (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) (K:ℝ) + (hbad:∀P∈fixedBadPrimes,P∣Q) + (hrows:∀J∈rows,J≠0 ∧ (Ideal.absNorm J:ℝ)≤K) + (k:idealRange (completedResidualScale K I Q)) : + reconstructFiberRow I Q k.val∈representativeRowFiber rows I Q ↔ + ∃J:representativeRowFiber rows I Q,fiberResidualIndex rows I Q K hbad hrows J=k := by + constructor + · intro hk + refine ⟨⟨reconstructFiberRow I Q k.val,hk⟩,?_⟩ + apply Subtype.ext + exact residual_reconstructFiberRow rows I Q k.val (mem_idealRange.mp k.property).1.1 hk + · rintro ⟨J,rfl⟩ + have hJ0:J.val≠0:=(hrows J.val (Finset.mem_filter.mp J.property).1).1 + change reconstructFiberRow I Q (rowResidualPart J.val Q)∈representativeRowFiber rows I Q + rw [reconstructFiberRow_of_original rows I Q J.val J.property hJ0] + exact J.property + +lemma representativeFiber_parts (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) + (J:representativeRowFiber rows I Q) : + rowPowerfulPart J.val=rowPowerfulPart I ∧ rowMaskPart J.val Q=rowMaskPart I Q := + (Finset.mem_filter.mp J.property).2 + +lemma representativeFiber_pool (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) + (hI:I≠0) (hQ:Q≠0) (hrows:∀J∈rows,J≠0) + (J:representativeRowFiber rows I Q) : + completedReflectionPool J.val Q=completedReflectionPool I Q := by + have hs:=representativeFiber_parts rows I Q J + exact completedReflectionPool_eq_on_fiber J.val I Q + (hrows J.val (Finset.mem_filter.mp J.property).1) hI hQ hs.1 hs.2 + +lemma representativeFiber_filtered_pool (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) + (hI:I≠0) (hQ:Q≠0) (hrows:∀J∈rows,J≠0) + (J:representativeRowFiber rows I Q) (free:Ideal Eis → Prop) [DecidablePred free] : + (completedReflectionPool J.val Q).filter free=(completedReflectionPool I Q).filter free := by + rw [representativeFiber_pool rows I Q hI hQ hrows J] + +lemma representativeFiber_exponent (rows:Finset (Ideal Eis)) (I F Q:Ideal Eis) + (hI:I≠0) (hQ:Q≠0) (hrows:∀J∈rows,J≠0) + (J:representativeRowFiber rows I Q) (P:completedReflectionPool I Q) : + completedLocalExponent J.val F P.val=completedLocalExponent I F P.val := by + have hs:=representativeFiber_parts rows I Q J + exact (completedReflectionPool_exponent_eq I J.val F Q hI + (hrows J.val (Finset.mem_filter.mp J.property).1) hQ hs.1.symm hs.2.symm P).symm + +lemma representativeFiber_extractedDivisor {ι:Type*} [Fintype ι] + (rows:Finset (Ideal Eis)) (I F Q:Ideal Eis) + (hI:I≠0) (hQ:Q≠0) (hrows:∀J∈rows,J≠0) + (J:representativeRowFiber rows I Q) + (P:ι → Ideal Eis) (hP:∀i,P i∈completedReflectionPool I Q) (e:ι → Fin 3) (v:Fin 3) : + reflectionExtractedDivisor P (fun i=>completedLocalExponent J.val F (P i)) e v= + reflectionExtractedDivisor P (fun i=>completedLocalExponent I F (P i)) e v := by + have he:(fun i=>completedLocalExponent J.val F (P i))= + (fun i=>completedLocalExponent I F (P i)):=by + funext i + exact representativeFiber_exponent rows I F Q hI hQ hrows J ⟨P i,hP i⟩ + rw [he] + +lemma representativeFiber_residualScale (rows:Finset (Ideal Eis)) (I Q:Ideal Eis) + (J:representativeRowFiber rows I Q) (K:ℝ) : + completedResidualScale K J.val Q=completedResidualScale K I Q := by + have hs:=representativeFiber_parts rows I Q J + exact completedResidualScale_eq_on_fiber K J.val I Q hs.1 hs.2 + +lemma representativeFiber_branchScale {ι:Type*} [Fintype ι] + (rows:Finset (Ideal Eis)) (I F Q:Ideal Eis) + (hI:I≠0) (hQ:Q≠0) (hrows:∀J∈rows,J≠0) + (J:representativeRowFiber rows I Q) + (P:ι → Ideal Eis) (hP:∀i,P i∈completedReflectionPool I Q) (e:ι → Fin 3) (K X:ℝ) : + completedBranchScale K X J.val F Q P e=completedBranchScale K X I F Q P e := by + have hs:=representativeFiber_parts rows I Q J + exact (completedBranchScale_eq_on_fiber K X I J.val F Q hI + (hrows J.val (Finset.mem_filter.mp J.property).1) hQ hs.1.symm hs.2.symm P hP e).symm + +end CompletedGauss + +open scoped Classical BigOperators + +namespace CompletedGauss.FreeReflection +open ActualEisensteinCubic CubicEisenstein CanonicalQuadraticSieve +local notation "Eis" => ActualEisensteinCubic.O + +def fixedRayFiberFromRows (c:Eis) (hc:c≠0) (rows:Finset (Ideal Eis)) + (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) (K:ℝ) + (scalar:(FixedBranchIndex c hc I Q Q0×ℕ)→ representativeRowFiber rows I Q→ℂ) + (hscalar:∀a J,‖scalar a J‖≤1) : + ReflectedFiberData (fixedReflectionRayCount c hc) (fixedCuspLevelBound c) K I F Q := + fixedRayFiber c hc I F Q Q0 hI hQ K (fun _=>1) (by intro x;simp) + (fun x m=>extendFiberRowScalar rows I Q K scalar (x,m)) + (fun x m=>extendFiberRowScalar_norm_le_one rows I Q K scalar hscalar (x,m)) + +lemma fixedRayFiberFromRows_rowPhase (c:Eis) (hc:c≠0) (rows:Finset (Ideal Eis)) + (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) (K:ℝ) + (scalar:(FixedBranchIndex c hc I Q Q0×ℕ)→ representativeRowFiber rows I Q→ℂ) + (hscalar:∀a J,‖scalar a J‖≤1) + (hbad:∀P∈fixedBadPrimes,P∣Q) + (hrows:∀J∈rows,J≠0 ∧ (Ideal.absNorm J:ℝ)≤K) + (J:representativeRowFiber rows I Q) (r:FixedReflectionRay c hc) + (e:pool I Q Q0→Fin 6) (i:ℕ×ℕ×ℕ) : + ((fixedRayFiberFromRows c hc rows I F Q Q0 hI hQ K scalar hscalar).branch + (fixedReflectionRayEquiv c hc r,e)).rowPhase i + (fiberResidualIndex rows I Q K hbad hrows J)=scalar ((r,e),i.1) J := by + change extendFiberRowScalar rows I Q K scalar + ((((fixedReflectionRayEquiv c hc).symm (fixedReflectionRayEquiv c hc r)),e),i.1) + (fiberResidualIndex rows I Q K hbad hrows J)=_ + rw [Equiv.symm_apply_apply] + exact extendFiberRowScalar_at_original rows I Q K hbad hrows scalar ((r,e),i.1) J + +lemma fixedRayFiberFromRows_weight (c:Eis) (hc:c≠0) (rows:Finset (Ideal Eis)) + (I F Q Q0:Ideal Eis) (hI:I≠0) (hQ:Q≠0) (K:ℝ) + (scalar:(FixedBranchIndex c hc I Q Q0×ℕ)→ representativeRowFiber rows I Q→ℂ) + (hscalar:∀a J,‖scalar a J‖≤1) + (r:FixedReflectionRay c hc) (e:pool I Q Q0→Fin 6) : + (fixedRayFiberFromRows c hc rows I F Q Q0 hI hQ K scalar hscalar).weight + (fixedReflectionRayEquiv c hc r,e)=reflectionSixInactiveWeight I F Q Q0 e := by + change 1*reflectionSixInactiveWeight I F Q Q0 e=_ + exact one_mul _ + +end CompletedGauss.FreeReflection + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualCuspDecay.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualCuspDecay.lean new file mode 100644 index 0000000000000000000000000000000000000000..e3d49b15a939410bc31868d19426ef96a7b64763 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualCuspDecay.lean @@ -0,0 +1,681 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.BesselMellinTransform +import OAI.NumberTheory.DirichletL.Eisenstein.TranslatedFourierResidues + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +def residualCuspDecayRate : ℝ := Real.pi*‖(3:ℂ)*ConcreteTraceCRT.eisLam‖⁻¹/4 + +lemma residualCuspDecayRate_pos : 0 mul_nonneg (norm_nonneg _) (Real.exp_pos _).le) + have hs := summable_norm_mul_exp_neg_cuspFrequency (Real.pi*a/2) (by positivity) + refine ⟨D*S*(2/(2*residualCuspDecayRate)),by positivity,?_⟩ + intro v z hav + have hsum := tsum_of_norm_bounded + (hs.hasSum.mul_left (D*v*Real.exp (-(2*residualCuspDecayRate)*v))) + (fun h => hbound h v z hav) + calc + _ ≤ (D*v*Real.exp (-(2*residualCuspDecayRate)*v))*S := hsum + _ = (D*S)*(v*Real.exp (-(2*residualCuspDecayRate)*v)) := by ring + _ ≤ (D*S)*((2/(2*residualCuspDecayRate))* + Real.exp (-((2*residualCuspDecayRate)/2)*v)) := + mul_le_mul_of_nonneg_left (norm_mul_exp_neg_bound (2*residualCuspDecayRate) v + (mul_pos (by norm_num) residualCuspDecayRate_pos)) (mul_nonneg hD hS) + _ = _ := by + rw [show -((2*residualCuspDecayRate)/2)*v=-residualCuspDecayRate*v by ring] + ring + +theorem cubicResidualFunction_wirtingerBar_cusp_decay (a : ℝ) (ha : 0 cubicResidualFunction (upperPoint w v hv)) z‖≤ + C*Real.exp (-residualCuspDecayRate*v) := by + obtain ⟨C1,hC1,hbound1⟩ := cubicResidualDirectionalSeries_cusp_decay a ha 1 + obtain ⟨CI,hCI,hboundI⟩ := cubicResidualDirectionalSeries_cusp_decay a ha Complex.I + refine ⟨(C1+CI)/2,by positivity,?_⟩ + intro v hv z hav + have h1 := (cubicResidualFunction_horizontal_hasDerivAt v hv z 1 0).deriv + have hI := (cubicResidualFunction_horizontal_hasDerivAt v hv z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerBar,h1,hI,norm_mul] + have hhalf : ‖(1/2:ℂ)‖=(1/2:ℝ) := by norm_num + rw [hhalf] + calc + _ ≤ (1/2:ℝ)*(‖∑'h : ActualEisensteinCubic.O,cubicResidualDirectionalTerm h v z 1‖+ + ‖Complex.I*(∑'h : ActualEisensteinCubic.O,cubicResidualDirectionalTerm h v z Complex.I)‖) := + mul_le_mul_of_nonneg_left (norm_add_le _ _) (by norm_num) + _ = (1/2:ℝ)*(‖∑'h : ActualEisensteinCubic.O,cubicResidualDirectionalTerm h v z 1‖+ + ‖∑'h : ActualEisensteinCubic.O,cubicResidualDirectionalTerm h v z Complex.I‖) := by + rw [norm_mul,Complex.norm_I,one_mul] + _ ≤ (1/2:ℝ)*(C1*Real.exp (-residualCuspDecayRate*v)+CI*Real.exp (-residualCuspDecayRate*v)) := by + apply mul_le_mul_of_nonneg_left _ (by norm_num) + exact add_le_add (hbound1 v z hav) (hboundI v z hav) + _ = _ := by ring + +end CubicEisenstein + +namespace ShortDraftCRT +open scoped BigOperators Classical Matrix + +section +variable {R : Type*} [CommRing R] + +theorem exists_frequency_lift (N p h : R) (hcop : IsCoprime N p) : + ∃k : R, N∣k ∧ p∣k-h := by + obtain ⟨u,v,huv⟩ := hcop + refine ⟨h*u*N,⟨h*u,by ring⟩,⟨-h*v,?_⟩⟩ + linear_combination h*huv + +theorem crossNum_congr_of_lift_dvd (N a c : R) (rows : List (R×R)) + (hlift : ∀ph∈rows,N∣ph.2) : + N∣crossNum a c rows-a*(rows.map Prod.fst).prod := by + induction rows with + | nil => simp [crossNum] + | cons ph rows ih => + rcases ph with ⟨p,h⟩ + have ht := ih (fun ph hm=>hlift ph (List.mem_cons_of_mem _ hm)) + have hh := hlift (p,h) (List.mem_cons_self ..) + have h1 := dvd_mul_of_dvd_left ht p + have h2 := dvd_mul_of_dvd_left hh (crossDen c rows) + convert dvd_add h1 h2 using 1 ; + simp only [crossNum,List.map_cons,List.prod_cons] ; ring + +theorem crossNum_fixed_sector_congr (M a c : R) (rows rows0 : List (R×R)) + (hc : c∣M) + (hlift : ∀ph∈rows,M^2∣ph.2) (hlift0 : ∀ph∈rows0,M^2∣ph.2) + (hsector : M^2∣(rows.map Prod.fst).prod-(rows0.map Prod.fst).prod) : + M*c∣crossNum a c rows-crossNum a c rows0 := by + have hmc : M*c∣M^2 := by simpa only [pow_two] using mul_dvd_mul_left M hc + have h1 := crossNum_congr_of_lift_dvd (M^2) a c rows hlift + have h0 := crossNum_congr_of_lift_dvd (M^2) a c rows0 hlift0 + have h2 := dvd_mul_of_dvd_right hsector a + apply hmc.trans + convert dvd_sub (dvd_add h1 h2) h0 using 1 ; ring + +variable [IsDomain R] + +theorem fixed_ray_completion_in_sector (M a c : R) (rows rows0 : List (R×R)) + (b0 d0 : R) (hc0 : c≠0) (hc : c∣M) + (hbase : IsCoprime a c) (hrows : GoodRows c rows) + (hr : IsCoprime (rows.map Prod.fst).prod (M*c)) + (hlift : ∀ph∈rows,M^2∣ph.2) (hlift0 : ∀ph∈rows0,M^2∣ph.2) + (hsector : M^2∣(rows.map Prod.fst).prod-(rows0.map Prod.fst).prod) + (hdet0 : crossNum a c rows0*d0-b0*crossDen c rows0=1) : + ∃b d : R, crossNum a c rows*d-b*crossDen c rows=1 ∧ M*c∣d-d0 ∧ + (!![crossNum a c rows,b;crossDen c rows,d] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M})) = + (!![crossNum a c rows0,b0;crossDen c rows0,d0] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M})) := by + have hn := crossNum_fixed_sector_congr M a c rows rows0 hc hlift hlift0 hsector + have hrmod : M∣(rows.map Prod.fst).prod-(rows0.map Prod.fst).prod := + (show M∣M^2 by simpa only [pow_two] using (dvd_mul_right M M)).trans hsector + have hcop := coprime_cross_num_list a c rows hbase hrows + rw [crossDen_eq_product] at hcop hdet0 ⊢ + obtain ⟨b,d,hd,hdd,hmat⟩ := exists_fixed_matrix_completion M c + (crossNum a c rows0) (rows0.map Prod.fst).prod d0 b0 hc0 hdet0 + (crossNum a c rows) (rows.map Prod.fst).prod hn hrmod hr hcop.of_mul_right_right + refine ⟨b,d,hd,hdd,?_⟩ + simpa only [crossDen_eq_product] using hmat + +end + +variable {R : Type*} [CommRing R] [IsDomain R] + +theorem exists_sectorwise_completions {ι Q : Type*} (M c : R) (hc : c≠0) + (sector : ι→Q) (a r : ι→R) + (hcop : ∀i,IsCoprime (a i) (c*r i)) + (hr : ∀i,IsCoprime (r i) (M*c)) + (ha : ∀i j,sector i=sector j → M*c∣a i-a j) + (hrr : ∀i j,sector i=sector j → M∣r i-r j) : + ∃(b d : ι→R) (C : Q→Matrix (Fin 2) (Fin 2) (R⧸Ideal.span {M})), + (∀i,a i*d i-b i*(c*r i)=1) ∧ + ∀i,(!![a i,b i;c*r i,d i] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M}))=C (sector i) := by + have hlocal (q : Q) : + ∃C : Matrix (Fin 2) (Fin 2) (R⧸Ideal.span {M}), + ∀i,sector i=q → ∃b d : R,a i*d-b*(c*r i)=1 ∧ + (!![a i,b;c*r i,d] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M}))=C := by + by_cases hq : ∃i,sector i=q + · obtain ⟨j,hj⟩ := hq + obtain ⟨x,y,hxy⟩ := hcop j + have hdet : a j*x-(-y)*(c*r j)=1 := by linear_combination hxy + refine ⟨(!![a j,-y;c*r j,x] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M})),?_⟩ + intro i hi + have hs : sector i=sector j := hi.trans hj.symm + obtain ⟨b,d,hd,_,he⟩ := exists_fixed_matrix_completion M c (a j) (r j) x (-y) + hc hdet (a i) (r i) (ha i j hs) (hrr i j hs) (hr i) (hcop i).of_mul_right_right + exact ⟨b,d,hd,he⟩ + · refine ⟨0,?_⟩ + intro i hi + exact False.elim (hq ⟨i,hi⟩) + choose C hC using hlocal + have hi (i : ι) := hC (sector i) i rfl + choose b d hd he using hi + exact ⟨b,d,C,hd,he⟩ + +def LiftedRows (M c : R) := + {rows : List (R×R) // GoodRows c rows ∧ (∀ph∈rows,M^2∣ph.2) ∧ + IsCoprime (rows.map Prod.fst).prod (M*c)} + +theorem exists_uniform_cusp_completions (M a c : R) (hc0 : c≠0) + (hc : c∣M) (hbase : IsCoprime a c) : + ∃(b d : LiftedRows M c→R) + (C : (R⧸Ideal.span {M^2})→Matrix (Fin 2) (Fin 2) (R⧸Ideal.span {M})), + (∀i,crossNum a c i.val*d i-b i*crossDen c i.val=1) ∧ + ∀i,(!![crossNum a c i.val,b i;crossDen c i.val,d i] : Matrix (Fin 2) (Fin 2) R).map + (Ideal.Quotient.mk (Ideal.span {M}))= + C (Ideal.Quotient.mk (Ideal.span {M^2}) (i.val.map Prod.fst).prod) := by + let sector : LiftedRows M c→R⧸Ideal.span {M^2} := + fun i=>Ideal.Quotient.mk (Ideal.span {M^2}) (i.val.map Prod.fst).prod + have hsector (i j : LiftedRows M c) (hs : sector i=sector j) : + M^2∣(i.val.map Prod.fst).prod-(j.val.map Prod.fst).prod := + Ideal.mem_span_singleton.mp (Ideal.Quotient.eq.mp hs) + obtain ⟨b,d,C,hd,he⟩ := exists_sectorwise_completions M c hc0 sector + (fun i=>crossNum a c i.val) (fun i=>(i.val.map Prod.fst).prod) + (fun i=>by + simpa only [←crossDen_eq_product] using coprime_cross_num_list a c i.val hbase i.property.1) + (fun i=>i.property.2.2) + (fun i j hs=>crossNum_fixed_sector_congr M a c i.val j.val hc + i.property.2.1 j.property.2.1 (hsector i j hs)) + (fun i j hs=>(show M∣M^2 by simpa only [pow_two] using dvd_mul_right M M).trans + (hsector i j hs)) + refine ⟨b,d,C,?_,?_⟩ + · intro i + simpa only [crossDen_eq_product] using hd i + · intro i + simpa only [crossDen_eq_product,sector] using he i + +theorem eisenstein_uniform_cusp_completions + (M a c : ActualEisensteinCubic.O) (hM : M≠0) (hc0 : c≠0) + (hc : c∣M) (hbase : IsCoprime a c) : + ∃(b d : LiftedRows M c→ActualEisensteinCubic.O) + (S : Set (Matrix (Fin 2) (Fin 2) (ActualEisensteinCubic.O⧸Ideal.span {M}))), + S.Finite ∧ S.ncard≤Ideal.absNorm (Ideal.span {M^2}) ∧ + (∀i,crossNum a c i.val*d i-b i*crossDen c i.val=1) ∧ + ∀i,(!![crossNum a c i.val,b i;crossDen c i.val,d i] : + Matrix (Fin 2) (Fin 2) ActualEisensteinCubic.O).map + (Ideal.Quotient.mk (Ideal.span {M}))∈S := by + let : Finite (ActualEisensteinCubic.O⧸Ideal.span {M^2}) := + ConcreteTraceCRT.finite_quotient_span (pow_ne_zero _ hM) + obtain ⟨b,d,C,hd,he⟩ := exists_uniform_cusp_completions M a c hc0 hc hbase + refine ⟨b,d,Set.range C,Set.finite_range C,?_,hd,?_⟩ + · have hh := Set.ncard_image_le (s := Set.univ) (f := C) + simpa only [Set.image_univ,Set.ncard_univ,Ideal.absNorm_apply, + Submodule.cardQuot_apply] using hh + · intro i + exact ⟨_,(he i).symm⟩ + +end ShortDraftCRT + +open scoped BigOperators Classical + +namespace ShortDraftCusp + +section +open ActualEisensteinCubic CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +theorem A3_principal_global (a c0 r : Eis) + (ha : lambda^2∣a-1) (hr : lambda^2∣r-1) : + symbol (c0*r) a=symbol c0 a*symbol a r := by + rw [symbol_mul_numerator _ _ a ha, + symbol_reciprocity r a (primary_ne_zero r hr) (primary_ne_zero a ha) hr ha] + +theorem A3_ramified_global (a b cprime d u : Eis) + (hdet : a*d-b*(u*cprime)=1) + (ha : lambda^2∣a-1) (hA : lambda^2∣(a-u*b)-1) : + symbol (u*cprime-u*d) (a-u*b)=symbol (-u) (a-u*b)*symbol cprime a := by + have h1 : symbol a (a-u*b)*symbol (u*cprime-u*d) (a-u*b)=symbol (-u) (a-u*b) := by + rw [←symbol_mul_numerator _ _ _ hA] + apply symbol_congr + refine ⟨u*cprime,?_⟩ + linear_combination -u*hdet + have h2 : symbol (a-u*b) a*symbol cprime a=1 := by + rw [←symbol_mul_numerator _ _ _ ha,←symbol_one_numerator a ha] + apply symbol_congr + refine ⟨cprime-d,?_⟩ + linear_combination hdet + rw [symbol_reciprocity a (a-u*b) (primary_ne_zero a ha) + (primary_ne_zero _ hA) ha hA] at h1 + calc + _ = (symbol (a-u*b) a*symbol cprime a)*symbol (u*cprime-u*d) (a-u*b) := by rw [h2,one_mul] + _ = (symbol (a-u*b) a*symbol (u*cprime-u*d) (a-u*b))*symbol cprime a := by ring + _ = _ := by rw [h1] + +theorem A3_ramified_global_factor (a b c0 r d u : Eis) + (hdet : a*d-b*(u*(c0*r))=1) + (ha : lambda^2∣a-1) (hA : lambda^2∣(a-u*b)-1) (hr : lambda^2∣r-1) : + symbol (u*(c0*r)-u*d) (a-u*b)= + (symbol (-u) (a-u*b)*symbol c0 a)*symbol a r := by + rw [A3_ramified_global a b (c0*r) d u hdet ha hA, + A3_principal_global a c0 r ha hr] + ring + +theorem A3_unramified_global (a b c d : Eis) + (hdet : a*d-b*c=1) (hb : lambda^2∣(-b)-1) (hc : lambda^2∣c-1) + (h9 : (9:Eis)∣a*d) : + symbol (-d) (-b)=symbol a c := by + have hp : lambda^2∣((-b)*c)-1 := primary_mul (-b) c hb hc + have hprod : symbol d (-b)*symbol d c=1 := by + rw [←symbol_mul_denominator] + have hnine : (9:Eis)∣(-b)*c-1 := by + convert dvd_neg.mpr h9 using 1 + linear_combination hdet + have hd : d∣(-b)*c-1 := by + refine ⟨-a,?_⟩ + linear_combination hdet + rw [symbol_denominator_congr d ((-b)*c) 1 hp (by simp) hnine hd,symbol_one] + have hother : symbol a c*symbol d c=1 := by + rw [←symbol_mul_numerator _ _ _ hc,←symbol_one_numerator c hc] + apply symbol_congr + refine ⟨b,?_⟩ + linear_combination hdet + rw [symbol_neg_numerator _ _ hb] + calc + symbol d (-b) = symbol d (-b)*(symbol a c*symbol d c) := by rw [hother,mul_one] + _ = (symbol d (-b)*symbol d c)*symbol a c := by ring + _ = symbol a c := by rw [hprod,one_mul] + +theorem A3_unramified_global_factor (a b c0 r d : Eis) + (hdet : a*d-b*(c0*r)=1) (hb : lambda^2∣(-b)-1) + (hc : lambda^2∣c0*r-1) (h9 : (9:Eis)∣a*d) : + symbol (-d) (-b)=symbol a c0*symbol a r := by + rw [A3_unramified_global a b (c0*r) d hdet hb hc h9,symbol_mul_denominator] + +theorem A3_fixed_factor_congr (M c0 a a0 : Eis) + (h9M : (9:Eis)∣M) (ha : lambda^2∣a-1) (ha0 : lambda^2∣a0-1) + (hsector : M*c0∣a-a0) : symbol c0 a=symbol c0 a0 := by + apply symbol_denominator_congr c0 a a0 ha ha0 + · exact (h9M.trans (dvd_mul_right M c0)).trans hsector + · exact (dvd_mul_left c0 M).trans hsector + +end + +open ActualEisensteinCubic CubicJacobiGlobal CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +theorem A3_ramified_fixed_factor_congr (M c0 u a a0 b b0 : Eis) + (h9M : (9:Eis)∣M) (hcM : c0∣M) (huM : u∣M) + (ha : lambda^2∣a-1) (ha0 : lambda^2∣a0-1) + (hA : lambda^2∣a-u*b-1) (hA0 : lambda^2∣a0-u*b0-1) + (hma : M∣a-a0) (hmb : M∣b-b0) : + symbol (-u) (a-u*b)*symbol c0 a= + symbol (-u) (a0-u*b0)*symbol c0 a0 := by + have hdiff : M∣(a-u*b)-(a0-u*b0) := by + convert dvd_sub hma (dvd_mul_of_dvd_right hmb u) using 1 ; ring + have hfirst : symbol (-u) (a-u*b)=symbol (-u) (a0-u*b0) := by + apply symbol_denominator_congr _ _ _ hA hA0 (h9M.trans hdiff) + exact neg_dvd.mpr (huM.trans hdiff) + have hsecond := symbol_denominator_congr c0 a a0 ha ha0 (h9M.trans hma) (hcM.trans hma) + rw [hfirst,hsecond] + +theorem A3_unramified_fixed_factor_congr (M c0 a a0 : Eis) + (hcM : c0∣M) (hma : M∣a-a0) : symbol a c0=symbol a0 c0 := + symbol_congr (hcM.trans hma) + +theorem norm_embedded_cubic_symbol (x a : Eis) + (ha : lambda^2∣a-1) (hcop : IsCoprime x a) : + ‖ConcreteTraceCRT.eisEmbedding (symbol x a)‖=1 := by + have hcube : ConcreteTraceCRT.eisEmbedding (symbol x a)^3=1 := by + rw [←map_pow,symbol_cube_of_isCoprime x a ha hcop,map_one] + apply (pow_eq_one_iff_of_nonneg (norm_nonneg _) (by decide : (3:ℕ)≠0)).mp + simpa only [norm_pow,norm_one] using congrArg norm hcube + +theorem norm_A3_principal_fixed_factor (a b c0 r d : Eis) + (hdet : a*d-b*(c0*r)=1) (ha : lambda^2∣a-1) : + ‖ConcreteTraceCRT.eisEmbedding (symbol c0 a)‖=1 := by + apply norm_embedded_cubic_symbol _ _ ha + refine ⟨-b*r,d,?_⟩ + linear_combination hdet + +theorem norm_A3_ramified_fixed_factor (a b c0 r d u : Eis) + (hdet : a*d-b*(u*(c0*r))=1) + (ha : lambda^2∣a-1) (hA : lambda^2∣a-u*b-1) : + ‖ConcreteTraceCRT.eisEmbedding (symbol (-u) (a-u*b)*symbol c0 a)‖=1 := by + have hfirst : ‖ConcreteTraceCRT.eisEmbedding (symbol (-u) (a-u*b))‖=1 := by + apply norm_embedded_cubic_symbol _ _ hA + refine ⟨b*(c0*r-d),d,?_⟩ + linear_combination hdet + have hsecond : ‖ConcreteTraceCRT.eisEmbedding (symbol c0 a)‖=1 := by + apply norm_embedded_cubic_symbol _ _ ha + refine ⟨-b*u*r,d,?_⟩ + linear_combination hdet + rw [map_mul,norm_mul,hfirst,hsecond,one_mul] + +theorem norm_A3_unramified_fixed_factor (a b c0 r d : Eis) + (hdet : a*d-b*(c0*r)=1) (hc : lambda^2∣c0-1) : + ‖ConcreteTraceCRT.eisEmbedding (symbol a c0)‖=1 := by + apply norm_embedded_cubic_symbol _ _ hc + refine ⟨d,-b*r,?_⟩ + linear_combination hdet + +end ShortDraftCusp + +open scoped BigOperators Classical +namespace CubicEisenstein +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +open PrimaryIdealUnitReindex (GoodIdeal) +local notation "Eis" => ActualEisensteinCubic.O + +lemma cubicUnitGaussSum_norm_le (h c:Eis) (hc:c≠0) (hp:lambda^2∣c-1): + ‖cubicUnitGaussSum h c‖≤Ideal.absNorm (Ideal.span {c}):=by + let:Finite (Eis⧸Ideal.span {c}):=finite_quotient_span hc + let:Fintype (Eis⧸Ideal.span {c}):=Fintype.ofFinite _ + let:Fintype (CubicUnitResidue c):=Fintype.ofFinite _ + have hs (r:CubicUnitResidue c): + ‖eisEmbedding (symbol (GaussianShiftedPartition.representative c r.val) c)‖=1:=by + apply Complex.norm_eq_one_of_pow_eq_one (n:=3) _ (by decide) + rw [←map_pow,symbol_cube_of_isCoprime _ c hp _ ,map_one] + apply IsCoprime.symm + apply (isUnit_quotient_span_iff c _).mp + simpa only [GaussianShiftedPartition.representative_spec] using r.2 + rw [cubicUnitGaussSum,tsum_fintype] + calc + _≤∑r:CubicUnitResidue c,‖eisEmbedding (symbol (GaussianShiftedPartition.representative c r.val) c)* + residueAdditive (3*h) c (GaussianShiftedPartition.representative c r.val)‖:=norm_sum_le _ _ + _=(Fintype.card (CubicUnitResidue c):ℝ):=by + simp only [norm_mul,hs,residueAdditive,breveE_norm, + Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] + _≤(Fintype.card (Eis⧸Ideal.span {c}):ℝ):=by + exact_mod_cast Fintype.card_subtype_le (fun r=>IsUnit r) + _=Ideal.absNorm (Ideal.span {c}):=by + simp only [Ideal.absNorm_apply,Submodule.cardQuot_apply,Nat.card_eq_fintype_card] + +theorem unramifiedCubicGaussSeries_summable_norm (s:ℂ) (hs:2‖(Ideal.absNorm I.val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator I.val)‖):=by + have hs':1<(s-1).re:=by simp only [Complex.sub_re,Complex.one_re];linarith + apply ((unramifiedNormWeight_summable_norm (s-1) hs').subtype + (fun I:Ideal Eis=>primaryGenerator I≠0)).of_nonneg_of_le (fun _=>norm_nonneg _) + intro I + dsimp only [Function.comp_def] + simp only [unramifiedNormWeight_shift,norm_mul,Complex.norm_natCast, + unramifiedNormWeight_of_good s I.val I.2] + have hg:=cubicUnitGaussSum_norm_le h (primaryGenerator I.val) I.2 + (primaryGenerator_spec I.val I.2).2 + rw [(primaryGenerator_spec I.val I.2).1] at hg + nlinarith [norm_nonneg ((Ideal.absNorm I.val:ℂ)^(-s))] + +abbrev PrimeDeletedIdeal (p:Eis):={I:GoodIdeal//¬(Ideal.span {p}:Ideal Eis)∣I.val} + +def unramifiedPrimeDeletedSeries (p:Eis) (s:ℂ) (h:Eis):ℂ:= + ∑'I:PrimeDeletedIdeal p,(Ideal.absNorm I.val.val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator I.val.val) + +lemma primaryGenerator_pow (I:Ideal Eis) (n:ℕ): + primaryGenerator (I^n)=primaryGenerator I^n:= + map_pow primaryGeneratorHom I n + +lemma gaussPrimeIdeal_prime (p:Eis) (hp:Prime p):Prime (Ideal.span {p}:Ideal Eis):= + Ideal.prime_of_isPrime (Ideal.span_singleton_eq_bot.not.mpr hp.ne_zero) + ((Ideal.span_singleton_prime hp.ne_zero).mpr hp) + +def gaussPrimeFactorMap (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (q:ℕ×PrimeDeletedIdeal p):GoodIdeal:= + ⟨(Ideal.span {p})^q.1*q.2.val.val,by + rw [primaryGenerator_mul,primaryGenerator_pow,primaryGenerator_span p hp.ne_zero hprimary] + exact mul_ne_zero (pow_ne_zero _ hp.ne_zero) q.2.val.2⟩ + +lemma gaussPrimeFactorMap_bijective (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1): + Function.Bijective (gaussPrimeFactorMap p hp hprimary):=by + let P:Ideal Eis:=Ideal.span {p} + have hP:Prime P:=gaussPrimeIdeal_prime p hp + constructor + · rintro ⟨n,I⟩ ⟨m,J⟩ heq + have hh:P^n*I.val.val=P^m*J.val.val:=congrArg Subtype.val heq + have hn:n=m:=by + have hm:=congrArg (multiplicity P) hh + rw [prime_power_remainder_multiplicity hP I.2, + prime_power_remainder_multiplicity hP J.2] at hm + exact hm + subst m + have hIJ:I=J:=Subtype.ext (Subtype.ext + (mul_left_cancel₀ (pow_ne_zero n hP.ne_zero) hh)) + subst J + rfl + · intro I + obtain ⟨J,hJ,hnot⟩:=(FiniteMultiplicity.of_prime_left hP + (primaryGenerator_ne_zero_ideal I.val I.2)).exists_eq_pow_mul_and_not_dvd + have hgood:primaryGenerator J≠0:=by + intro hzero + apply I.2 + rw [hJ,primaryGenerator_mul,hzero,mul_zero] + refine ⟨(multiplicity P I.val,⟨⟨J,hgood⟩,hnot⟩),?_⟩ + exact Subtype.ext hJ.symm + +def gaussPrimeFactorEquiv (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1): + ℕ×PrimeDeletedIdeal p≃GoodIdeal:= + Equiv.ofBijective (gaussPrimeFactorMap p hp hprimary) + (gaussPrimeFactorMap_bijective p hp hprimary) + +lemma primeDeleted_generator_coprime (p:Eis) (hp:Prime p) (I:PrimeDeletedIdeal p): + IsCoprime p (primaryGenerator I.val.val):=by + apply hp.coprime_iff_not_dvd.mpr + intro hd + apply I.2 + rw [Ideal.dvd_iff_le,←(primaryGenerator_spec I.val.val I.val.2).1, + Ideal.span_singleton_le_span_singleton] + exact hd + +lemma primary_pow_congruence (p:Eis) (hprimary:lambda^2∣p-1) (n:ℕ): + lambda^2∣p^n-1:=by + simpa only [one_pow] using hprimary.trans (sub_dvd_pow_sub_pow p 1 n) + +lemma gaussPrimeFactor_term (p:Eis) (hp:Prime p) (hprimary:lambda^2∣p-1) + (s:ℂ) (h:Eis) (n:ℕ) (I:PrimeDeletedIdeal p): + (Ideal.absNorm (gaussPrimeFactorMap p hp hprimary (n,I)).val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator (gaussPrimeFactorMap p hp hprimary (n,I)).val)= + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^n*cubicUnitGaussSum h (p^n)* + ((Ideal.absNorm I.val.val:ℂ)^(-s)*cubicUnitGaussSum (h*p^n) (primaryGenerator I.val.val)):=by + change (Ideal.absNorm ((Ideal.span {p})^n*I.val.val):ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator ((Ideal.span {p})^n*I.val.val))=_ + rw [primaryGenerator_mul,primaryGenerator_pow,primaryGenerator_span p hp.ne_zero hprimary, + cubicUnitGaussSum_coprime_product h (p^n) (primaryGenerator I.val.val) + (pow_ne_zero _ hp.ne_zero) I.val.2 (primary_pow_congruence p hprimary n) + (primaryGenerator_spec I.val.val I.val.2).2 (primeDeleted_generator_coprime p hp I).pow_left, + map_mul,map_pow,Nat.cast_mul,Complex.natCast_mul_natCast_cpow] + have he:((Ideal.absNorm (Ideal.span {p})^n:ℕ):ℂ)^(-s)= + ((Ideal.absNorm (Ideal.span {p}):ℂ)^(-s))^n:=by + rw [Nat.cast_pow,←Complex.natCast_cpow_natCast_mul,Complex.cpow_nat_mul] + rw [he] + ring + +theorem unramifiedCubicGaussSeries_prime_reindex (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) (s:ℂ) (hs:2(Ideal.absNorm I.val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator I.val)):= + (unramifiedCubicGaussSeries_summable_norm s hs h).of_norm + have hpull:=(gaussPrimeFactorEquiv p hp hprimary).summable_iff.mpr hsum + change Summable (fun q:ℕ×PrimeDeletedIdeal p=> + (Ideal.absNorm (gaussPrimeFactorMap p hp hprimary q).val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator (gaussPrimeFactorMap p hp hprimary q).val)) at hpull + rw [unramifiedCubicGaussSeries,←(gaussPrimeFactorEquiv p hp hprimary).tsum_eq] + change (∑'q:ℕ×PrimeDeletedIdeal p, + (Ideal.absNorm (gaussPrimeFactorMap p hp hprimary q).val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator (gaussPrimeFactorMap p hp hprimary q).val))=_ + rw [hpull.tsum_prod] + apply tsum_congr + intro n + change (∑'I:PrimeDeletedIdeal p,(Ideal.absNorm (gaussPrimeFactorMap p hp hprimary (n,I)).val:ℂ)^(-s)* + cubicUnitGaussSum h (primaryGenerator (gaussPrimeFactorMap p hp hprimary (n,I)).val))=_ + simp_rw [gaussPrimeFactor_term p hp hprimary s h n] + exact tsum_mul_left + +lemma unramifiedPrimeDeletedSeries_cube_shift (p:Eis) (hp:Prime p) (s:ℂ) (h:Eis): + unramifiedPrimeDeletedSeries p s (h*p^3)=unramifiedPrimeDeletedSeries p s h:=by + apply tsum_congr + intro I + congr 1 + exact cubicUnitGaussSum_cube_shift h _ p I.val.2 + (primaryGenerator_spec I.val.val I.val.2).2 (primeDeleted_generator_coprime p hp I).symm + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualFourierBounds.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualFourierBounds.lean new file mode 100644 index 0000000000000000000000000000000000000000..2341067c18e36021aeefc66a1262fc40deee312f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualFourierBounds.lean @@ -0,0 +1,710 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.GaussFactorization +import OAI.NumberTheory.DirichletL.Reciprocity.KubotaCharacter + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace ComplexConjugate MatrixGroups ENNReal +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma cuspHeightFourierTest_memLp (a b : ℝ) (ha : 0 star (cuspWeightedFourierPhase ρ h w)) 2 + (hyperbolicVolume.restrict (cuspPeriodStrip a b)) := by + let := cuspPeriodStripFiniteVolume a b ha + apply MemLp.of_bound (cuspWeightedFourierPhase_continuous ρ h).star.aestronglyMeasurable ‖ρ‖ + exact Eventually.of_forall (fun w => by rw [norm_star]; exact cuspWeightedFourierPhase_bound ρ h w) + +def cuspHeightFourierTestL2 (a b : ℝ) (ha : 0 star (cuspWeightedFourierPhase ρ h w)) + +def kernelCuspHeightFourier (a b : ℝ) (ha : 0 z*cuspWeightedFourierPhase ρ h w) + (hw.trans (Set.indicator_of_mem (cuspPeriodStrip_image_subset a b ha ⟨w,hwm,rfl⟩) _)) + +def kernelCuspHeightFourierFamily (a b : ℝ) (ha : 0 (s-4/3)*kernelCuspHeightFourierFamily a b ha ρ h s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (kernelCuspHeightFourier a b ha ρ h cubicEisensteinResidue)) := by + have hh := (kernelCuspHeightFourier a b ha ρ h).continuous.continuousAt.tendsto.comp + (cubicEisensteinResidue_local_limit (cuspHeightQuotientCompact a b) (cuspHeightQuotientCompact_isCompact a b ha)) + simpa only [Function.comp_def,map_smul,smul_eq_mul,kernelCuspHeightFourier_restrict, + kernelCuspHeightFourierFamily] using hh + +lemma kernelCuspHeightFourierFamily_initial (a b : ℝ) (ha : 0 hyperbolicEisenstein s w*cuspWeightedFourierPhase ρ h w + have hg : Continuous g := (hyperbolicEisenstein_continuous s hs).mul (cuspWeightedFourierPhase_continuous ρ h) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg)] + have hexp : ∀v∈Set.Icc a b, + ((∫z in periodDomain,g (cuspCoordinateLift (v,z)))/(v:ℂ)^3)= + (((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h)* + (ρ v*((v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v))) := by + intro v hv + have hpos : 0 by ring) + rw [hrearr,eisensteinFourierCoefficient] + congr 1 + exact (div_mul_cancel₀ _ cusp_volume_ne_zero).symm + rw [hinner,eisensteinFourierCoefficient_formula v hpos s hs h,ite_eq_right hh,zero_add] + have hv0 : (v:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hpos.ne' + have hp : (v:ℂ)^(-s-1)=(v:ℂ)^(2-s)/(v:ℂ)^3 := by + rw [show -s-1=(2-s)-3 by ring,Complex.cpow_sub _ _ hv0] + congr 1 + exact Complex.cpow_natCast _ 3 + rw [hp] + ring + calc + _ = ∫v in Set.Icc a b,(((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h)* + (ρ v*((v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v))) := + setIntegral_congr_fun measurableSet_Icc hexp + _ = _ := integral_const_mul _ _ + +lemma kernelCuspHeightFourierFamily_initial_factor (a b : ℝ) (ha : 0 cuspIntervalWhittakerHeightFactor a b ρ w h) s := by + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + have hopen : IsOpen {w : ℂ | 1 cuspIntervalWhittakerHeightFactor a b ρ s h)= + (fun s => ∫v in Set.Icc a b,ρ v*(v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v)) := by + funext s + apply integral_congr_ae + exact Eventually.of_forall (fun v => (mul_assoc _ _ _).symm) + rw [heq] + exact cuspWeightedWhittakerInterval_differentiableAt ρ a b ha (cuspFrequency h) w hw + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma kernelCuspHeightFourierFamily_cross_identity (a b : ℝ) (ha : 0 kernelCuspHeightFourierFamily a b ha ρ h s*cuspWhittakerHeightFactor s h) + (fun s => kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s* + cuspIntervalWhittakerHeightFactor a b ρ s h) {s : ℂ | 1 kernelCuspHeightFourierFamily a b ha ρ h s*cuspWhittakerHeightFactor s h) domain := by + intro s hs + exact (kernelCuspHeightFourierFamily_analyticAt_nonreal a b ha ρ h s hs.1.ne' hs.2.ne').mul + (cuspWhittakerHeightFactor_analyticAt h s hs.1) + have hright : AnalyticOnNhd ℂ + (fun s => kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s* + cuspIntervalWhittakerHeightFactor a b ρ s h) domain := by + intro s hs + exact (kernelCuspFourierFamily_analyticAt_nonreal h 2 3 (by norm_num) (by norm_num) + s hs.1.ne' hs.2.ne').mul (cuspIntervalWhittakerHeightFactor_analyticAt a b ha ρ h s hs.1) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s : ℂ | 4 kernelCuspHeightFourierFamily a b ha ρ h s*cuspWhittakerHeightFactor s h) + =ᶠ[𝓝 (5+Complex.I:ℂ)] + (fun s => kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s* + cuspIntervalWhittakerHeightFactor a b ρ s h) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + rw [kernelCuspHeightFourierFamily_initial_factor a b ha ρ h hh s hs.1 hs.2, + kernelCuspFourierFamily_eq_upper h hh ⟨by linarith [hs.1],hs.2⟩] + ring + exact hleft.eqOn_of_preconnected_of_eventuallyEq hright hconvex.isPreconnected hstart hevent + +lemma kernelCuspHeightFourier_residue_factor (a b : ℝ) (ha : 0 cuspWhittakerHeightFactor s h) + (𝓝[≠] (4/3:ℂ)) (𝓝 (cuspWhittakerHeightFactor (4/3:ℂ) h)) := + (cuspWhittakerHeightFactor_analyticAt h (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds + have hweight : Tendsto (fun s : ℂ => cuspIntervalWhittakerHeightFactor a b ρ s h) + (𝓝[≠] (4/3:ℂ)) (𝓝 (cuspIntervalWhittakerHeightFactor a b ρ (4/3:ℂ) h)) := + (cuspIntervalWhittakerHeightFactor_analyticAt a b ha ρ h (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds + have hleft := ((kernelCuspHeightFourierFamily_residue_limit a b ha ρ h).mul hbase).comp + upperVertical_tendsto_cubic_punctured + have hright := ((kernelCuspFourierFamily_residue_limit h 2 3 (by norm_num) (by norm_num)).mul hweight).comp + upperVertical_tendsto_cubic_punctured + have hevent : (fun t : ℝ => + (((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*kernelCuspHeightFourierFamily a b ha ρ h ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspWhittakerHeightFactor ((4/3:ℂ)+(t:ℂ)*Complex.I) h) + =ᶠ[𝓝[>] (0:ℝ)] (fun t : ℝ => + (((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) + ((4/3:ℂ)+(t:ℂ)*Complex.I))*cuspIntervalWhittakerHeightFactor a b ρ ((4/3:ℂ)+(t:ℂ)*Complex.I) h) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 ActualEisensteinCubic.O + +lemma kernelCuspHeightFourier_uniform_bound (a b : ℝ) (ha : 0 t^(-(2:ℝ)/3)*Real.exp (-t/2)) (Set.Ioi 0) := by + have h := integrableOn_rpow_mul_exp_neg_mul_rpow + (s := -(2:ℝ)/3) (p := (1:ℝ)) (b := (1/2:ℝ)) (by norm_num) (by norm_num) (by norm_num) + simpa only [Real.rpow_one,show ∀t : ℝ,-(1/2)*t=-t/2 by intro t;ring] using h + have hb := setIntegral_mono_on (cubicBesselDensity_integrable x) + (hi.const_mul (Real.exp (-x/2))) measurableSet_Ioi (fun t ht => cubicBesselDensity_upper x t ht) + rw [integral_const_mul] at hb + have he : (∫t in Set.Ioi (0:ℝ),t^(-(2:ℝ)/3)*Real.exp (-t/2))= + (2:ℝ)^(1/3:ℝ)*Real.Gamma (1/3) := by + have hh := Real.integral_rpow_mul_exp_neg_mul_Ioi + (a := (1/3:ℝ)) (r := (1/2:ℝ)) (by norm_num) (by norm_num) + convert hh using 1 <;> norm_num ; congr 2 ; funext t ; ring_nf + rw [he] at hb + exact hb + +def cubicBesselUpperConstant : ℝ := + (1/2:ℝ)*(1/2:ℝ)^(-(1:ℝ)/3)*((2:ℝ)^(1/3:ℝ)*Real.Gamma (1/3)) + +lemma cubicBesselUpperConstant_pos : 0 hx.trans_le ht.1 + have hi := cubicBesselDensity_integrable x + have hr := hi.mono_set hsub + have hconstant : IntegrableOn (fun _ : ℝ => (2*x)^(-(2:ℝ)/3)*Real.exp (-9*x/4)) + (Set.Icc x (2*x)) := integrableOn_const (hs := isCompact_Icc.measure_ne_top) + have hmono := setIntegral_mono_on hconstant hr measurableSet_Icc + (fun t ht => cubicBesselDensity_lower x t hx ht) + have hextend : (∫t in Set.Icc x (2*x),cubicBesselDensity x t)≤ + ∫t in Set.Ioi (0:ℝ),cubicBesselDensity x t := by + apply setIntegral_mono_set hi + · filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + exact cubicBesselDensity_nonneg x t ht.le + · exact Eventually.of_forall hsub + rw [setIntegral_const,Real.volume_real_Icc_of_le (by linarith),smul_eq_mul, + show 2*x-x=x by ring] at hmono + exact hmono.trans hextend + +def cubicBesselLowerConstant : ℝ := + (1/2:ℝ)*(1/2:ℝ)^(-(1:ℝ)/3)*(2:ℝ)^(-(2:ℝ)/3) + +lemma cubicBesselLowerConstant_pos : 0 ActualEisensteinCubic.O + +lemma exp_neg_mul_le_inverse_cube (ε r : ℝ) (hε : 0<ε) (hr : 0 Real.exp (-ε*‖ConcreteTraceCRT.eisEmbedding h‖)) := by + have hs := (summable_embedding_rpow (-3) (by norm_num)).mul_left (6/ε^3) + have hz : Summable (fun h : ActualEisensteinCubic.O => if h=0 then (1:ℝ) else 0) := + (hasSum_ite_eq 0 (1:ℝ)).summable + apply Summable.of_nonneg_of_le (fun h => (Real.exp_pos _).le) _ (hz.add hs) + intro h + by_cases hh : h=0 + · subst h + norm_num [Pi.add_apply] + · have hp : 0<‖ConcreteTraceCRT.eisEmbedding h‖ := + norm_pos_iff.mpr (ConcreteTraceCRT.eisEmbedding_ne_zero hh) + simpa only [Pi.add_apply,ite_eq_right hh,zero_add] using exp_neg_mul_le_inverse_cube ε _ hε hp + +lemma summable_exp_neg_cuspFrequency_norm (ε : ℝ) (hε : 0<ε) : + Summable (fun h : ActualEisensteinCubic.O => Real.exp (-ε*‖cuspFrequency h‖)) := by + have hd : 0<‖(3:ℂ)*ConcreteTraceCRT.eisLam‖ := by + apply norm_pos_iff.mpr + exact mul_ne_zero (by norm_num) ConcreteTraceCRT.eisLam_ne_zero + have hs := summable_exp_neg_embedding_norm (ε/‖(3:ℂ)*ConcreteTraceCRT.eisLam‖) (div_pos hε hd) + apply hs.congr + intro h + congr 1 + rw [cuspFrequency,norm_div] + ring + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma cubicBesselNormalizer_ne_zero (h : ActualEisensteinCubic.O) (hh : h≠0) : cubicBesselNormalizer h≠0 := by + unfold cubicBesselNormalizer + apply mul_ne_zero + · exact div_ne_zero (mul_ne_zero (by norm_num) (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero)) + (Complex.Gamma_ne_zero_of_re_pos (by norm_num)) + · apply Complex.cpow_ne_zero_iff.mpr + left + exact mul_ne_zero (mul_ne_zero (by norm_num) (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero)) + (Complex.ofReal_ne_zero.mpr (norm_ne_zero_iff.mpr (cuspFrequency_ne_zero h hh))) + +lemma cubicBesselHeight_integrable (a b : ℝ) (ha : 0 schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v)/(v:ℂ)^2) + (Set.Icc a b) volume := by + have hsource : IntegrableOn (fun v : ℝ => (v:ℂ)^(-(4/3:ℂ)-1)* + sourceFourierKernel (4/3) (cuspFrequency h*v)) (Set.Icc a b) volume := by + apply ContinuousOn.integrableOn_Icc + intro v hv + have hpos := ha.trans_le hv.1 + exact ((Complex.continuousAt_ofReal_cpow_const v (-(4/3:ℂ)-1) (Or.inr hpos.ne')).mul + ((sourceFourierKernel_continuous_freq (4/3) (by norm_num)).continuousAt.comp + ((Complex.continuous_ofReal.const_mul (cuspFrequency h)).continuousAt))).continuousWithinAt + apply (hsource.div_const (cubicBesselNormalizer h)).congr + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + apply (div_eq_iff (cubicBesselNormalizer_ne_zero h hh)).mpr + simpa only [mul_comm] using sourceFourierKernel_cubic_height h hh v (ha.trans_le hv.1) + +lemma cubicBesselHeight_average_lower (a b : ℝ) (ha : 0.mpr hv.2 + change lower≤Complex.re (_/(v:ℂ)^2) + rw [←Complex.ofReal_pow,Complex.div_ofReal_re] + calc + lower = (cubicBesselLowerConstant*Real.exp (-9*Real.pi*b*‖cuspFrequency h‖))/b^2 := by dsimp [lower]; ring + _ ≤ (cubicBesselLowerConstant*Real.exp (-9*Real.pi*b*‖cuspFrequency h‖))/v^2 := + div_le_div_of_nonneg_left (mul_nonneg cubicBesselLowerConstant_pos.le (Real.exp_pos _).le) + (sq_pos_of_pos hvp) hden + _ ≤ _ := div_le_div_of_nonneg_right hnum (sq_nonneg v) + have hmono := setIntegral_mono_on + (integrableOn_const (hs := isCompact_Icc.measure_ne_top) : IntegrableOn (fun _ : ℝ => lower) (Set.Icc a b)) + hi.re measurableSet_Icc hpoint + rw [setIntegral_const,Real.volume_real_Icc_of_le hab.le,smul_eq_mul] at hmono + have hreal : (∫v in Set.Icc a b,RCLike.re + (schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v)/(v:ℂ)^2))= + Complex.re (∫v in Set.Icc a b,schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v)/(v:ℂ)^2) := + integral_re hi + rw [hreal] at hmono + have hfinal := hmono.trans (Complex.re_le_norm _) + convert hfinal using 1 ; dsimp [lower] ; ring + +lemma cubicResidualFourierCoefficient_subexponential (ε : ℝ) (hε : 0<ε) : + ∃C : ℝ,0≤C ∧ ∀h : ActualEisensteinCubic.O,h≠0 → + ‖cubicResidualFourierCoefficient h‖≤C*Real.exp (ε*‖cuspFrequency h‖) := by + let b : ℝ := ε/(9*Real.pi) + let a : ℝ := b/2 + have hb : 0 ActualEisensteinCubic.O + +lemma cubicResidualFullMode_density_integrable (a b : ℝ) (ha : 0 cubicResidualFullModeAmplitude v h/(v:ℂ)^3) + (Set.Icc a b) volume := by + by_cases hh : h=0 + · subst h + have hi : IntegrableOn (fun v : ℝ => + (3*(Real.pi:ℂ))*constantArithmeticResidue*(v:ℂ)^(-(7/3:ℂ))) + (Set.Icc a b) volume := by + apply ContinuousOn.integrableOn_Icc + intro v hv + exact (continuousAt_const.mul (Complex.continuousAt_ofReal_cpow_const v + (-(7/3:ℂ)) (Or.inr (ha.trans_le hv.1).ne'))).continuousWithinAt + apply hi.congr + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + exact (cubicResidualFullModeAmplitude_zero_density v (ha.trans_le hv.1)).symm + · apply ((cubicBesselHeight_integrable a b ha h hh).const_mul + (cubicResidualFourierCoefficient h)).congr + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + exact (cubicResidualFullModeAmplitude_nonzero_density v (ha.trans_le hv.1) h hh).symm + +lemma cubicEisensteinResidue_slice_coefficient_ae (a b : ℝ) (ha : 0 ((9*Real.sqrt 3/2:ℝ):ℂ)*(cubicResidualFullModeAmplitude v h/(v:ℂ)^3)) := by + apply interval_ae_eq_of_boundedContinuous_height_tests a b _ _ + (kernelCuspSliceCoefficient_integrable a b ha h cubicEisensteinResidue) + ((cubicResidualFullMode_density_integrable a b ha h).const_mul _) + intro ρ + rw [←kernelCuspHeightFourier_eq_slice_integral a b ha ρ h cubicEisensteinResidue, + kernelCuspHeightFourier_residue_full a b ha ρ h,←integral_const_mul] + apply integral_congr_ae + exact Eventually.of_forall (fun v => by ring) + +lemma cubicEisensteinResidue_all_slice_coefficients_ae (a b : ℝ) (ha : 0 cubicEisensteinResidue_slice_coefficient_ae a b ha h) + +lemma cubicEisensteinResidue_all_fourier_integrals_ae (a b : ℝ) (ha : 0 ActualEisensteinCubic.O + +lemma cubicResidualFunction_fourier_full (v : ℝ) (hv : 0 cubicResidualFunction (upperPoint z v hv)) := by + have hc := cubicResidualNonzeroSeries_height_continuous v hv + simp only [cubicResidualFunction,cubicResidualNonzeroFunction, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + fun_prop + +lemma cubicResidualFunction_height_memLp (v : ℝ) (hv : 0 cubicResidualFunction (cuspCoordinateLift (v,z))) 2 + (volume.restrict periodDomain) := by + simp_rw [cuspCoordinateLift_positive v _ hv] + have hc := cubicResidualFunction_height_continuous v hv + apply (memLp_two_iff_integrable_sq_norm hc.aestronglyMeasurable).mpr + have hn : Continuous (fun z : ℂ => ‖cubicResidualFunction (upperPoint z v hv)‖^2) := by + fun_prop + apply (hn.continuousOn.integrableOn_compact + (isCompact_closedBall (0:ℂ) (∑i,‖periodBasis i‖))).mono_set + intro z hz + simpa only [Metric.mem_closedBall,dist_zero_right] using norm_mem_periodDomain z hz + +theorem cubicEisensteinResidue_cell_slices_ae (a b : ℝ) (ha : 0 cubicEisensteinResidue + (integralOrbitProjection globalKubotaKernel (cuspCoordinateLift (v,z)))) + =ᵐ[volume.restrict periodDomain] + (fun z => cubicResidualFunction (cuspCoordinateLift (v,z))) := by + filter_upwards [cubicEisensteinResidue_all_fourier_integrals_ae a b ha, + kernelCuspSections_memLp a b ha cubicEisensteinResidue, + ae_restrict_mem measurableSet_Icc] with v hfour hL hv + have hpos : 0 cubicEisensteinResidue + (integralOrbitProjection globalKubotaKernel (cuspCoordinateLift q))) + =ᵐ[(volume.restrict (Set.Icc a b)).prod (volume.restrict periodDomain)] + (fun q => cubicResidualFunction (cuspCoordinateLift q)) := by + apply (Measure.ae_prod_iff_ae_ae ?_).mpr + · exact cubicEisensteinResidue_cell_slices_ae a b ha + · exact measurableSet_eq_fun + ((MeasureTheory.Lp.stronglyMeasurable cubicEisensteinResidue).measurable.comp + ((measurable_integralOrbitProjection _).comp cuspCoordinateLift_measurable)) + (cubicResidualFunction_continuous.measurable.comp cuspCoordinateLift_measurable) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ENNReal Pointwise MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota + +lemma periodDomain_memLp_of_continuous (f : ℂ→ℂ) (hf : Continuous f) : + MemLp f 2 (volume.restrict periodDomain) := by + apply (memLp_two_iff_integrable_sq_norm hf.aestronglyMeasurable.restrict).mpr + apply (((hf.norm.pow 2).continuousOn).integrableOn_compact + (isCompact_closedBall (0:ℂ) (∑i,‖periodBasis i‖))).mono_set + intro z hz + simpa only [Metric.mem_closedBall,dist_zero_right] using norm_mem_periodDomain z hz + +lemma upperTranslation_mem_kernel (n : ActualEisensteinCubic.O) : + (upperTranslation n : SL(2,ActualEisensteinCubic.O))∈globalKubotaKernel := by + exact (globalKubotaKernel_mem _).mpr + ⟨(upperTranslation n).property,complexCharacter_upperTranslation n⟩ + +lemma kernelProjection_upper_period (v : ℝ) (hv : 0 f (cuspCoordinateLift (v,z)))=ᵐ[volume.restrict periodDomain] + (fun z => g (cuspCoordinateLift (v,z)))) : f=ᵐ[hyperbolicVolume]g := by + have hplanes (a b : ℝ) (ha : 0 cubicEisensteinResidue (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] cubicResidualFunction := by + apply hyperbolic_eq_ae_of_period_cells _ _ + ((MeasureTheory.Lp.stronglyMeasurable cubicEisensteinResidue).measurable.comp + (measurable_integralOrbitProjection _)) cubicResidualFunction_continuous.measurable + · intro v hv z n + exact congrArg cubicEisensteinResidue (kernelProjection_upper_period v hv z n) + · exact cubicResidualFunction_period + · exact cubicEisensteinResidue_cell_slices_ae + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Pointwise +open Finset AddChar MulChar EisensteinEmbedding + +lemma kernelProjection_quasiMeasurePreserving : + Measure.QuasiMeasurePreserving (integralOrbitProjection globalKubotaKernel) + hyperbolicVolume (integralQuotientVolume globalKubotaKernel) := by + let proj := integralOrbitProjection globalKubotaKernel + have hp : Measurable proj := measurable_integralOrbitProjection _ + refine ⟨hp,Measure.AbsolutelyContinuous.mk fun S hS hzero => ?_⟩ + rw [Measure.map_apply hp hS] + have hd : hyperbolicVolume ((proj ⁻¹' S)∩hyperbolicFundamentalSet globalKubotaKernel)=0 := by + simpa only [integralQuotientVolume,proj, + Measure.map_apply (measurable_integralOrbitProjection _) hS, + Measure.restrict_apply ((measurable_integralOrbitProjection _) hS)] using hzero + have hinv : ∀M : globalKubotaKernel,M • (proj ⁻¹' S)=proj ⁻¹' S := by + intro M + ext w + constructor + · rintro ⟨u,hu,rfl⟩ + change proj (M • u)∈S + change proj u∈S at hu + rwa [show proj (M • u)=proj u from integralOrbitProjection_eq _ M u] + · intro hw + refine ⟨M⁻¹ • w,?_,smul_inv_smul M w⟩ + change proj (M⁻¹ • w)∈S + rwa [show proj (M⁻¹ • w)=proj w from integralOrbitProjection_eq _ M⁻¹ w] + exact globalKubotaKernel_isFundamentalDomain.measure_zero_of_invariant (proj ⁻¹' S) hinv hd + +lemma kernelLevel_character_ae_on_hyperbolic (F : KernelQuotientL2) + (M : CubicKubota.levelThree) + (hchar : kernelLevelPullback M F=CubicKubota.complexCharacter M • F) : + (fun w : HyperbolicSpace => F (integralOrbitProjection globalKubotaKernel + (complexMatrix M • w))) =ᵐ[hyperbolicVolume] + (fun w => CubicKubota.complexCharacter M* + F (integralOrbitProjection globalKubotaKernel w)) := by + have he : (fun q => F (kernelLevelAction M q)) + =ᵐ[integralQuotientVolume globalKubotaKernel] + (fun q => CubicKubota.complexCharacter M*F q) := by + filter_upwards [kernelLevelPullback_ae_eq M F, + Lp.coeFn_smul (CubicKubota.complexCharacter M) F] with q hq hs + rw [hchar] at hq + exact hq.symm.trans hs + have hl := kernelProjection_quasiMeasurePreserving.ae_eq_comp he + simpa only [Function.comp_def,kernelLevelAction_mk] using hl + +lemma kernelLevel_character_continuous_representative (F : KernelQuotientL2) + (f : HyperbolicSpace→ℂ) (hf : Continuous f) + (hrep : (fun w => F (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] f) + (M : CubicKubota.levelThree) + (hchar : kernelLevelPullback M F=CubicKubota.complexCharacter M • F) + (w : HyperbolicSpace) : + f (complexMatrix M • w)=CubicKubota.complexCharacter M*f w := by + have hcomp := (measurePreserving_smul (complexMatrix M) + hyperbolicVolume).quasiMeasurePreserving.ae_eq_comp hrep + have he : (fun p : HyperbolicSpace => f (complexMatrix M • p)) + =ᵐ[hyperbolicVolume] (fun p => CubicKubota.complexCharacter M*f p) := by + filter_upwards [hcomp,kernelLevel_character_ae_on_hyperbolic F M hchar,hrep] with p hp hc hr + exact hp.symm.trans (hc.trans (congrArg (fun z => CubicKubota.complexCharacter M*z) hr)) + have hfun := Measure.eq_of_ae_eq he + (hf.comp (continuous_hyperbolic_action (complexMatrix M))) + (continuous_const.mul hf) + exact congrFun hfun w + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups +open Finset AddChar MulChar EisensteinEmbedding + +theorem cubicResidualFunction_automorphy (M : CubicKubota.levelThree) (w : HyperbolicSpace) : + cubicResidualFunction (complexMatrix M • w)= + CubicKubota.complexCharacter M*cubicResidualFunction w := + kernelLevel_character_continuous_representative cubicEisensteinResidue + cubicResidualFunction cubicResidualFunction_continuous + cubicEisensteinResidue_continuous_representative M (cubicEisensteinResidue_character M) w + +lemma cubicResidualFunction_ne_zero : cubicResidualFunction≠0 := by + intro hz + have he := cubicResidualFunction_fourier_full 1 (by norm_num) 0 + have hconst : (((9*Real.sqrt 3/2:ℝ):ℂ)* + ((3*(Real.pi:ℂ))*constantArithmeticResidue))≠0 := by + apply mul_ne_zero + · exact Complex.ofReal_ne_zero.mpr (by positivity) + · exact mul_ne_zero (mul_ne_zero (by norm_num) (Complex.ofReal_ne_zero.mpr Real.pi_ne_zero)) + constantArithmeticResidue_ne_zero + apply hconst + simpa only [hz,Pi.zero_apply,zero_mul,integral_zero, + cubicResidualFullModeAmplitude_zero,Complex.ofReal_one,Complex.one_cpow,mul_one] using he.symm + +lemma cubicResidualFunction_exists_ne_zero : ∃w : HyperbolicSpace,cubicResidualFunction w≠0 := by + by_contra h + apply cubicResidualFunction_ne_zero + funext w + exact not_not.mp (not_exists.mp h w) + +open CubicKubota + +lemma sourceProjection_continuous (f : HyperbolicSpace→ℂ) (hf : Continuous f) : + Continuous (sourceProjection f) := by + unfold sourceProjection + apply continuous_const.mul + apply continuous_finsetSum + intro q hq + exact hf.comp (continuous_hyperbolic_action _) + +lemma sourceProjection_congr_ae (f g : HyperbolicSpace→ℂ) + (h : f=ᵐ[hyperbolicVolume]g) : sourceProjection f=ᵐ[hyperbolicVolume]sourceProjection g := by + have htrans (q : levelTwo ⧸ levelThreeInTwo) : + (fun w => f (integralComplexMatrix (rationalEmbedding (sourceRationalSection q)) • w)) + =ᵐ[hyperbolicVolume] + (fun w => g (integralComplexMatrix (rationalEmbedding (sourceRationalSection q)) • w)) := + (measurePreserving_smul _ hyperbolicVolume).quasiMeasurePreserving.ae_eq_comp h + filter_upwards [ae_all_iff.mpr htrans] with w hw + unfold sourceProjection + congr 1 + exact Finset.sum_congr rfl (fun q _ => hw q) + +lemma kernelSourceProjection_hyperbolic_representative (F : KernelQuotientL2) + (f : HyperbolicSpace→ℂ) + (hrep : (fun w => F (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] f) : + (fun w => kernelSourceProjection F (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] sourceProjection f := by + have he := kernelProjection_quasiMeasurePreserving.ae_eq_comp + (kernelSourceProjection_ae_eq F) + change (fun w => kernelSourceProjection F (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] + sourceProjection (fun w => F (integralOrbitProjection globalKubotaKernel w)) at he + exact he.trans (sourceProjection_congr_ae _ _ hrep) + +def cubicSourceResidualFunction : HyperbolicSpace→ℂ := sourceProjection cubicResidualFunction + +lemma cubicSourceResidualFunction_continuous : Continuous cubicSourceResidualFunction := + sourceProjection_continuous cubicResidualFunction cubicResidualFunction_continuous + +theorem cubicSourceResidualFunction_automorphy (M : levelTwo) (w : HyperbolicSpace) : + cubicSourceResidualFunction (integralComplexMatrix (M:SL(2,ActualEisensteinCubic.O)) • w)= + levelTwoComplexCharacter M*cubicSourceResidualFunction w := + sourceProjection_automorphy cubicResidualFunction cubicResidualFunction_automorphy M w + +lemma cubicSourceResidualFunction_rational_invariant (M : SL(2,ℤ)) (w : HyperbolicSpace) : + cubicSourceResidualFunction (integralComplexMatrix (rationalEmbedding M) • w)= + cubicSourceResidualFunction w := by + have he := cubicSourceResidualFunction_automorphy (rationalLift M) w + rw [levelTwoComplexCharacter_rationalLift,one_mul] at he + exact he + +theorem cubicSourceResidualFunction_represents_projection : + (fun w => kernelSourceProjection cubicEisensteinResidue + (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] cubicSourceResidualFunction := + kernelSourceProjection_hyperbolic_representative cubicEisensteinResidue + cubicResidualFunction cubicEisensteinResidue_continuous_representative + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open CubicKubota ActualEisensteinCubic ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +def rationalUnipotent (t : ℤ) : SL(2,ℤ) := + ⟨!![1,t;0,1],by simp [Matrix.det_fin_two]⟩ + +lemma rationalUnipotent_add (a b : ℤ) : + rationalUnipotent (a+b)=rationalUnipotent a*rationalUnipotent b := by + apply Subtype.ext + change (!![1,a+b;0,1] : Matrix (Fin 2) (Fin 2) ℤ) = + (!![1,a;0,1] : Matrix (Fin 2) (Fin 2) ℤ) * !![1,b;0,1] + ext i j + fin_cases i <;> fin_cases j <;> + simp [Matrix.mul_apply,Fin.sum_univ_two,add_comm] + +lemma rationalUnipotent_zero : rationalUnipotent 0=1 := by + apply Matrix.SpecialLinearGroup.ext + intro i j + fin_cases i <;> fin_cases j <;> simp [rationalUnipotent] + +lemma rationalUnipotent_neg (a : ℤ) : rationalUnipotent (-a)=(rationalUnipotent a)⁻¹ := by + apply eq_inv_of_mul_eq_one_left + rw [←rationalUnipotent_add,neg_add_cancel,rationalUnipotent_zero] + +lemma rationalUnipotent_one : rationalUnipotent 1=ModularGroup.T := rfl + +lemma row_unipotent_conjugate (t : ℤ) (M : levelThree) : + row (levelThreeConjugate (rationalEmbedding (rationalUnipotent (-t))) M)= + Matrix.vecMul (row M) (rationalEmbedding (rationalUnipotent t):SL(2,ActualEisensteinCubic.O)) := by + have hmap (u : ℤ) : + (rationalEmbedding (rationalUnipotent u) : Matrix (Fin 2) (Fin 2) O) = + !![1,(u : O);0,1] := by + apply Matrix.ext + intro i j + change (Int.castRingHom O) ((!![1,u;0,1] : Matrix (Fin 2) (Fin 2) ℤ) i j) = _ + fin_cases i <;> fin_cases j <;> simp + change ((rationalEmbedding (rationalUnipotent (-t)) * (M : SL(2,O)) * + (rationalEmbedding (rationalUnipotent (-t)))⁻¹ : SL(2,O)) : Matrix (Fin 2) (Fin 2) O) 1 = + Matrix.vecMul ((M : SL(2,O)) 1) + (rationalEmbedding (rationalUnipotent t) : Matrix (Fin 2) (Fin 2) O) + simp only [Matrix.SpecialLinearGroup.coe_mul, Matrix.SpecialLinearGroup.coe_inv, + hmap, Matrix.adjugate_fin_two] + funext j + fin_cases j <;> simp [Matrix.mul_apply,Matrix.vecMul,dotProduct,Fin.sum_univ_two] + +def cuspUnipotentTranslate (t : ℤ) : CuspCosets→CuspCosets := + Quotient.map (fun M => levelThreeConjugate (rationalEmbedding (rationalUnipotent (-t))) M) (by + intro M N h + change row (levelThreeConjugate _ M)=row (levelThreeConjugate _ N) + rw [row_unipotent_conjugate,row_unipotent_conjugate,show row M=row N from h]) + +lemma cuspUnipotentTranslate_inverse (t : ℤ) (x : CuspCosets) : + cuspUnipotentTranslate (-t) (cuspUnipotentTranslate t x)=x := by + induction x using Quotient.inductionOn with + | _ M => + change cosetOf (levelThreeConjugate (rationalEmbedding (rationalUnipotent (- -t))) + (levelThreeConjugate (rationalEmbedding (rationalUnipotent (-t))) M))=cosetOf M + rw [←levelThreeConjugate_mul,←map_mul,←rationalUnipotent_add] + simp only [neg_neg,add_neg_cancel,rationalUnipotent_zero,map_one,levelThreeConjugate_one] + +def cuspUnipotentEquiv (t : ℤ) : CuspCosets≃CuspCosets where + toFun := cuspUnipotentTranslate t + invFun := cuspUnipotentTranslate (-t) + left_inv := cuspUnipotentTranslate_inverse t + right_inv x := by simpa only [neg_neg] using cuspUnipotentTranslate_inverse (-t) x + +lemma cosetRow_cuspUnipotentEquiv (t : ℤ) (x : CuspCosets) : + cosetRow (cuspUnipotentEquiv t x)= + Matrix.vecMul (cosetRow x) (rationalEmbedding (rationalUnipotent t):SL(2,ActualEisensteinCubic.O)) := by + induction x using Quotient.inductionOn with + | _ M => exact row_unipotent_conjugate t M + +lemma cosetCharacter_cuspUnipotentEquiv (t : ℤ) (x : CuspCosets) : + cosetCharacter (cuspUnipotentEquiv t x)=cosetCharacter x := by + induction x using Quotient.inductionOn with + | _ M => exact complexCharacter_conjugate_rational (rationalUnipotent (-t)) M + +lemma embeddedRow_cuspUnipotentEquiv (t : ℤ) (x : CuspCosets) : + embeddedRow (cuspUnipotentEquiv t x)= + Matrix.vecMul (embeddedRow x) (integralComplexMatrix (rationalEmbedding (rationalUnipotent t)):SL(2,ℂ)) := by + funext j + simp only [embeddedRow,Function.comp_def,cosetRow_cuspUnipotentEquiv, + Matrix.vecMul,dotProduct,map_sum,map_mul,integralComplexMatrix_apply] + +lemma summand_unipotent (t : ℤ) (g : SL(2,ℂ)) (s : ℂ) (x : CuspCosets) : + summand (integralComplexMatrix (rationalEmbedding (rationalUnipotent t))*g) s x= + summand g s (cuspUnipotentEquiv t x) := by + rw [summand,summand,cosetCharacter_cuspUnipotentEquiv, + embeddedRow_cuspUnipotentEquiv,←rowOperator_apply,rowOperator_mul] + +theorem eisenstein_unipotent (t : ℤ) (g : SL(2,ℂ)) (s : ℂ) : + eisenstein (integralComplexMatrix (rationalEmbedding (rationalUnipotent t))*g) s=eisenstein g s := by + unfold eisenstein + simp_rw [summand_unipotent] + exact (cuspUnipotentEquiv t).tsum_eq _ + +theorem hyperbolicEisenstein_unipotent (t : ℤ) (s : ℂ) (w : HyperbolicSpace) : + hyperbolicEisenstein s (integralComplexMatrix (rationalEmbedding (rationalUnipotent t)) • w)= + hyperbolicEisenstein s w := by + induction w using Quotient.inductionOn with + | _ g => exact eisenstein_unipotent t g s + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualFourierSeries.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualFourierSeries.lean new file mode 100644 index 0000000000000000000000000000000000000000..e6601ddd0e564954537dcd0b58acc2968ab479b9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualFourierSeries.lean @@ -0,0 +1,631 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.ResidualFourierBounds + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma cuspFrequency_norm_lower (h : ActualEisensteinCubic.O) (hh : h≠0) : + ‖(3:ℂ)*ConcreteTraceCRT.eisLam‖⁻¹≤‖cuspFrequency h‖ := by + have hn : 1≤‖ConcreteTraceCRT.eisEmbedding h‖^2 := by + rw [ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span] + exact_mod_cast Nat.one_le_iff_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hh)) + have hnorm : 1≤‖ConcreteTraceCRT.eisEmbedding h‖ := by nlinarith [norm_nonneg (ConcreteTraceCRT.eisEmbedding h)] + rw [cuspFrequency,norm_div,inv_eq_one_div] + exact div_le_div_of_nonneg_right hnorm (norm_nonneg _) + +def cubicBesselUpperAway (deltaLoss : ℝ) : ℝ := + (1/2:ℝ)*(deltaLoss/2)^(-(1:ℝ)/3)*((2:ℝ)^(1/3:ℝ)*Real.Gamma (1/3)) + +lemma cubicBesselUpperAway_pos (deltaLoss : ℝ) (hδ : 0 (q.1:ℂ)^(2/3:ℂ)) p := + (Complex.continuousAt_ofReal_cpow_const p.1 (2/3:ℂ) (Or.inr hp.ne')).comp continuousAt_fst + have hsource : ContinuousAt (fun q : ℝ × ℂ => sourceFourierKernel (4/3) (cuspFrequency h*q.1)) p := + (sourceFourierKernel_continuous_freq (4/3) (by norm_num)).continuousAt.comp (by fun_prop) + have hphase : Continuous (fun q : ℝ × ℂ => ShortDraftTrace.breveE (cuspFrequency h*q.2)) := by + change Continuous (fun q : ℝ × ℂ => Complex.exp (2*Real.pi*Complex.I* + ((cuspFrequency h*q.2)+starRingEnd ℂ (cuspFrequency h*q.2)))) + fun_prop + exact (((continuousAt_const.mul hpow).mul hsource).mul hphase.continuousAt).continuousWithinAt + +lemma cubicResidualNonzeroTerm_slab_bound (a b : ℝ) (ha : 0 cubicResidualNonzeroTerm h p) := by + obtain ⟨C,hC,hbound⟩ := cubicResidualNonzeroTerm_slab_bound p.1 p.1 hp le_rfl + apply Summable.of_norm + exact Summable.of_nonneg_of_le (fun h => norm_nonneg _) (fun h => hbound h p ⟨le_rfl,le_rfl⟩) + ((summable_exp_neg_cuspFrequency_norm (Real.pi*p.1) (mul_pos Real.pi_pos hp)).mul_left C) + +def cubicResidualNonzeroSeries (p : ℝ × ℂ) : ℂ := ∑'h : ActualEisensteinCubic.O,cubicResidualNonzeroTerm h p + +lemma cubicResidualNonzeroSeries_continuousOn_slab (a b : ℝ) (ha : 0 C*Real.exp (-(Real.pi*a)*‖cuspFrequency h‖)) + · intro h + exact (cubicResidualNonzeroTerm_continuousOn h).mono (fun p hp => ha.trans_le hp.1) + · exact (summable_exp_neg_cuspFrequency_norm (Real.pi*a) (mul_pos Real.pi_pos ha)).mul_left C + · exact hbound + +lemma cubicResidualNonzeroSeries_continuousOn : + ContinuousOn cubicResidualNonzeroSeries {p : ℝ × ℂ | 0 fun p : ℝ × ℂ => ∑h∈t,cubicResidualNonzeroTerm h p) + cubicResidualNonzeroSeries atTop {p : ℝ × ℂ | p.1∈Set.Icc a b} := by + obtain ⟨C,hC,hbound⟩ := cubicResidualNonzeroTerm_slab_bound a b ha hab + exact tendstoUniformlyOn_tsum + ((summable_exp_neg_cuspFrequency_norm (Real.pi*a) (mul_pos Real.pi_pos ha)).mul_left C) hbound + +lemma cubicResidualNonzeroSeries_bessel (v : ℝ) (hv : 0 (hyperbolicHeight u,hyperbolicHorizontal u)) + (hyperbolicHeight_continuous.prodMk hyperbolicHorizontal_continuous).continuousAt + +lemma cubicResidualNonzeroSeries_period (v : ℝ) (z : ℂ) (n : ActualEisensteinCubic.O) : + cubicResidualNonzeroSeries (v,z+3*ConcreteTraceCRT.eisEmbedding n)=cubicResidualNonzeroSeries (v,z) := by + apply tsum_congr + intro h + by_cases hh : h=0 + · simp only [cubicResidualNonzeroTerm,ite_eq_left hh] + simp only [cubicResidualNonzeroTerm,ite_eq_right hh] + rw [mul_add,AddChar.map_add_eq_mul,cuspFrequency_period,mul_one] + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ENNReal +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +def cubicResidualModeAmplitude (v : ℝ) (h : ActualEisensteinCubic.O) : ℂ := + if h=0 then 0 else cubicResidualFourierCoefficient h*(v:ℂ)* + schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v) + +lemma cubicResidualNonzeroTerm_eq_amplitude (v : ℝ) (hv : 0 cubicResidualModeAmplitude v h*ShortDraftTrace.breveE (cuspFrequency h*z)* + ShortDraftTrace.breveE (-cuspFrequency k*z) + have hc (h : ActualEisensteinCubic.O) : Continuous (f h) := by + change Continuous (fun z : ℂ => cubicResidualModeAmplitude v h* + Complex.exp (2*Real.pi*Complex.I*((cuspFrequency h*z)+starRingEnd ℂ (cuspFrequency h*z)))* + Complex.exp (2*Real.pi*Complex.I*((-cuspFrequency k*z)+starRingEnd ℂ (-cuspFrequency k*z)))) + fun_prop + obtain ⟨C,hC,hbound⟩ := cubicResidualNonzeroTerm_slab_bound v v hv le_rfl + have hfbound (h : ActualEisensteinCubic.O) (z : ℂ) : ‖f h z‖≤C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖) := by + change ‖(cubicResidualModeAmplitude v h*ShortDraftTrace.breveE (cuspFrequency h*z))* + ShortDraftTrace.breveE (-cuspFrequency k*z)‖≤_ + rw [←cubicResidualNonzeroTerm_eq_amplitude v hv h z,norm_mul,breveE_norm,mul_one] + exact hbound h (v,z) ⟨le_rfl,le_rfl⟩ + have hi (h : ActualEisensteinCubic.O) : IntegrableOn (f h) periodDomain volume := + (integrable_const (C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖))).mono' + (hc h).aestronglyMeasurable (Eventually.of_forall (hfbound h)) + have hnorm (h : ActualEisensteinCubic.O) : (∫z in periodDomain,‖f h z‖)≤ + volume.real periodDomain*(C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖)) := by + have hh := integral_mono_ae (hi h).norm (integrable_const (C*Real.exp (-(Real.pi*v)*‖cuspFrequency h‖))) + (Eventually.of_forall (hfbound h)) + simpa only [setIntegral_const,smul_eq_mul] using hh + have hs : Summable (fun h : ActualEisensteinCubic.O => ∫z in periodDomain,‖f h z‖) := by + apply Summable.of_nonneg_of_le (fun h => integral_nonneg (fun z => norm_nonneg _)) hnorm + exact ((summable_exp_neg_cuspFrequency_norm (Real.pi*v) (mul_pos Real.pi_pos hv)).mul_left C).mul_left + (volume.real periodDomain) + have hterm (h : ActualEisensteinCubic.O) : (∫z in periodDomain,f h z)= + if h=k then ((9*Real.sqrt 3/2:ℝ):ℂ)*cubicResidualModeAmplitude v h else 0 := by + change (∫z in periodDomain,cubicResidualModeAmplitude v h*ShortDraftTrace.breveE (cuspFrequency h*z)* + ShortDraftTrace.breveE (-cuspFrequency k*z))=_ + simp_rw [mul_assoc] + rw [integral_const_mul,integral_cusp_character_product] + split_ifs <;> ring + calc + _ = ∫z in periodDomain,∑'h : ActualEisensteinCubic.O,f h z := by + apply integral_congr_ae + exact Eventually.of_forall (fun z => by + change (∑'h : ActualEisensteinCubic.O,cubicResidualNonzeroTerm h (v,z))*ShortDraftTrace.breveE (-cuspFrequency k*z)=_ + rw [←tsum_mul_right] + apply tsum_congr + intro h + rw [cubicResidualNonzeroTerm_eq_amplitude v hv h z]) + _ = ∑'h : ActualEisensteinCubic.O,∫z in periodDomain,f h z := (integral_tsum_of_summable_integral_norm hi hs).symm + _ = ∑'h : ActualEisensteinCubic.O,if h=k then ((9*Real.sqrt 3/2:ℝ):ℂ)*cubicResidualModeAmplitude v h else 0 := tsum_congr hterm + _ = _ := by simp + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma cubicResidualNonzeroFunction_heightFourier (a b : ℝ) (ha : 0 cubicResidualNonzeroFunction w*cuspWeightedFourierPhase ρ h w + have hg : Continuous g := cubicResidualNonzeroFunction_continuous.mul (cuspWeightedFourierPhase_continuous ρ h) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg)] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hpos := ha.trans_le hv.1 + have hinner : (∫z in periodDomain,g (cuspCoordinateLift (v,z)))= + ρ v*(((9*Real.sqrt 3/2:ℝ):ℂ)*cubicResidualModeAmplitude v h) := by + simp_rw [g,cuspCoordinateLift_positive v _ hpos,cubicResidualNonzeroFunction, + cuspWeightedFourierPhase,hyperbolicHeight_upperPoint,cuspFourierPhase,hyperbolicHorizontal_upperPoint] + calc + _ = ρ v*(∫z in periodDomain,cubicResidualNonzeroSeries (v,z)*ShortDraftTrace.breveE (-cuspFrequency h*z)) := by + rw [←integral_const_mul] + apply integral_congr_ae + exact Eventually.of_forall (fun z => by ring) + _ = _ := by rw [cubicResidualNonzeroSeries_fourier v hpos h] + dsimp only + rw [hinner] + +lemma cubicResidualNonzeroFunction_zero_heightFourier (a b : ℝ) (ha : 0 (test x:ℂ)) + (Complex.continuous_ofReal.comp htest.continuous) C (fun x => by + simpa only [Complex.norm_real,Real.norm_eq_abs] using hC x) + have hh := heq ρ + change (∫x,(test x:ℂ)*f x∂«μ»)=(∫x,(test x:ℂ)*g x∂«μ») at hh + simpa only [Complex.real_smul] using hh + +lemma interval_ae_eq_of_boundedContinuous_height_tests (a b : ℝ) (f g : ℝ→ℂ) + (hf : IntegrableOn f (Set.Icc a b)) (hg : IntegrableOn g (Set.Icc a b)) + (heq : ∀ρ : BoundedContinuousFunction ℝ ℂ, + (∫x in Set.Icc a b,ρ x*f x)=(∫x in Set.Icc a b,ρ x*g x)) : + f=ᵐ[volume.restrict (Set.Icc a b)]g := + ae_eq_of_boundedContinuous_height_tests (volume.restrict (Set.Icc a b)) f g hf hg heq + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +def compactHeightMellin (a b : ℝ) (ρ : BoundedContinuousFunction ℝ ℂ) (s : ℂ) : ℂ := + ∫v in Set.Icc a b,ρ v*(v:ℂ)^s + +lemma compactHeightMellin_integrable (a b : ℝ) (ha : 0 ρ v*(v:ℂ)^s) (Set.Icc a b) := by + apply ContinuousOn.integrableOn_Icc + apply ρ.continuous.continuousOn.mul + intro v hv + exact (Complex.continuousAt_ofReal_cpow_const v s + (Or.inr (ha.trans_le hv.1).ne')).continuousWithinAt + +theorem compactHeightMellin_differentiable (a b : ℝ) (ha : 0 (Real.log (max a v):ℂ) + have hl : Continuous heightLog := Complex.continuous_ofReal.comp + ((continuous_const.max continuous_id).log (fun v => (ha.trans_le (le_max_left a v)).ne')) + let F : ℂ→ℝ→ℂ := fun s v => ρ v*Complex.exp (heightLog v*s) + let F' : ℂ→ℝ→ℂ := fun s v => ρ v*(Complex.exp (heightLog v*s)*heightLog v) + have hF : ∀s,Continuous (F s) := fun s => ρ.continuous.mul ((hl.mul_const s).cexp) + have hF' : Continuous (fun p : ℂ×ℝ => F' p.1 p.2) := by + exact (ρ.continuous.comp continuous_snd).mul + ((((hl.comp continuous_snd).mul continuous_fst).cexp).mul (hl.comp continuous_snd)) + have hder : ∀s v,HasDerivAt (fun w => F w v) (F' s v) s := by + intro s v + simpa only [F,F',id_eq,mul_one] using + (((hasDerivAt_id s).const_mul (heightLog v)).cexp).const_mul (ρ v) + have heq : compactHeightMellin a b ρ=(fun s => ∫v in Set.Icc a b,F s v) := by + funext s + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + dsimp only [compactHeightMellin,F,heightLog] + rw [max_eq_right hv.1,Complex.ofReal_log (ha.trans_le hv.1).le, + Complex.cpow_def_of_ne_zero (Complex.ofReal_ne_zero.mpr (ha.trans_le hv.1).ne')] + rw [heq] + intro s + obtain ⟨C,hC⟩ := ((isCompact_closedBall s (1:ℝ)).prod (isCompact_Icc : IsCompact (Set.Icc a b))).exists_bound_of_continuousOn hF'.continuousOn + have hd := hasDerivAt_integral_of_dominated_loc_of_deriv_le + («μ»:=volume.restrict (Set.Icc a b)) (F:=F) (F':=F') + (bound:=fun _ => C) (Metric.ball_mem_nhds s (by norm_num : (0:ℝ)<1)) + (Eventually.of_forall (fun w => (hF w).aestronglyMeasurable)) + ((hF s).continuousOn.integrableOn_Icc) + ((hF'.comp (continuous_const.prodMk continuous_id)).aestronglyMeasurable) + (by + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv w hw + exact hC (w,v) ⟨Metric.ball_subset_closedBall hw,hv⟩) + (integrable_const C) + (Eventually.of_forall (fun v w _ => hder w v)) + exact hd.2.differentiableAt + +lemma compactHeightMellin_analyticAt (a b : ℝ) (ha : 0 ActualEisensteinCubic.O + +def cuspHeightConstantAverage (a b : ℝ) (ρ : BoundedContinuousFunction ℝ ℂ) (s : ℂ) : ℂ := + ((9*Real.sqrt 3/2:ℝ):ℂ)*(compactHeightMellin a b ρ (s-3)+ + ((Real.pi:ℂ)/(s-1))*scatteringCoefficient s 0*compactHeightMellin a b ρ (-s-1)) + +lemma hyperbolicEisenstein_cusp_height_fourier_zero (a b : ℝ) (ha : 0 hyperbolicEisenstein s w*cuspWeightedFourierPhase ρ 0 w + have hg : Continuous g := (hyperbolicEisenstein_continuous s hs).mul (cuspWeightedFourierPhase_continuous ρ 0) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg)] + have hexp : ∀v∈Set.Icc a b, + ((∫z in periodDomain,g (cuspCoordinateLift (v,z)))/(v:ℂ)^3)= + ((9*Real.sqrt 3/2:ℝ):ℂ)* + (ρ v*(v:ℂ)^(s-3)+(((Real.pi:ℂ)/(s-1))*scatteringCoefficient s 0)* + (ρ v*(v:ℂ)^(-s-1))) := by + intro v hv + have hpos : 0 by ring) + rw [hrearr,eisensteinFourierCoefficient] + congr 1 + exact (div_mul_cancel₀ _ cusp_volume_ne_zero).symm + rw [hinner,eisensteinConstantCoefficient_formula v hpos s hs] + have hv0 : (v:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hpos.ne' + have hp : (v:ℂ)^(-s-1)=(v:ℂ)^(2-s)/(v:ℂ)^3 := by + rw [show -s-1=(2-s)-3 by ring,Complex.cpow_sub _ _ hv0] + congr 1 + exact Complex.cpow_natCast _ 3 + have hm : (v:ℂ)^(s-3)=(v:ℂ)^s/(v:ℂ)^3 := by + rw [Complex.cpow_sub _ _ hv0] + congr 1 + exact Complex.cpow_natCast _ 3 + rw [hp,hm] + ring + rw [setIntegral_congr_fun measurableSet_Icc hexp,integral_const_mul, + integral_add (compactHeightMellin_integrable a b ha ρ _) + ((compactHeightMellin_integrable a b ha ρ _).const_mul _),integral_const_mul] + rfl + +lemma kernelCuspHeightFourierFamily_zero_initial (a b : ℝ) (ha : 0 weightedOutgoingConstant a b ha ρ s*cuspScatterHeightFactor s) + (fun s => baseOutgoingConstant s*compactHeightMellin a b ρ (-s-1)) + {s : ℂ | 1 weightedOutgoingConstant a b ha ρ s*cuspScatterHeightFactor s) domain := by + intro s hs + exact (weightedOutgoingConstant_analyticAt a b ha ρ s hs.1 hs.2).mul + (cuspScatterHeightFactor_analyticAt s hs.1) + have hright : AnalyticOnNhd ℂ + (fun s => baseOutgoingConstant s*compactHeightMellin a b ρ (-s-1)) domain := by + intro s hs + exact (baseOutgoingConstant_analyticAt s hs.1 hs.2).mul + ((compactHeightMellin_analyticAt a b ha ρ _).comp_of_eq + (analyticAt_id.neg.sub analyticAt_const) rfl) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s : ℂ | 4 weightedOutgoingConstant a b ha ρ s*cuspScatterHeightFactor s) + =ᶠ[𝓝 (5+Complex.I:ℂ)] + (fun s => baseOutgoingConstant s*compactHeightMellin a b ρ (-s-1)) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + have hb : kernelCuspAverageFamily 2 3 (by norm_num) (by norm_num) s=cuspConstantAverage s := by + apply (kernelCuspAverageFamily_eq_of_initial_overlap 2 3 (by norm_num) (by norm_num) + s (by linarith [hs.1]) + (kernelEisensteinL2Correction_initial_overlap 2 3 (by norm_num) (by norm_num) s hs.1 hs.2)).trans + exact hyperbolicEisenstein_cusp_average_eq s (by linarith [hs.1]) + rw [weightedOutgoingConstant,baseOutgoingConstant, + kernelCuspHeightFourierFamily_zero_initial a b ha ρ s hs.1 hs.2,hb, + cuspHeightConstantAverage,cuspConstantAverage] + ring + exact hleft.eqOn_of_preconnected_of_eventuallyEq hright hconvex.isPreconnected hstart hevent + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualOrthogonality.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualOrthogonality.lean new file mode 100644 index 0000000000000000000000000000000000000000..a233624476ff3035ea52c004761276cdb6a0b7e0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ResidualOrthogonality.lean @@ -0,0 +1,598 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CubeEigenrelation + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped Classical MatrixGroups BigOperators + +namespace CubicEisenstein +open CubicKubota +local notation "O" => ActualEisensteinCubic.O + +lemma cubicSourceResidualFunction_kernel_invariant (M : globalKubotaKernel) + (w : HyperbolicSpace) : + cubicSourceResidualFunction (integralComplexMatrix (M:SL(2,ActualEisensteinCubic.O)) • w)= + cubicSourceResidualFunction w := by + obtain ⟨hM,hchar⟩ := (globalKubotaKernel_mem (M:SL(2,ActualEisensteinCubic.O))).mp M.property + have h := cubicSourceResidualFunction_automorphy + ⟨(M:SL(2,ActualEisensteinCubic.O)),levelThree_le_levelTwo hM⟩ w + rw [levelTwoComplexCharacter_restrict ⟨(M:SL(2,ActualEisensteinCubic.O)),hM⟩,hchar,one_mul] at h + exact h + +def cubicSourceQuotientFunction : KernelQuotient→ℂ := + Quotient.lift cubicSourceResidualFunction (by + rintro w u ⟨h,rfl⟩ + exact (cubicSourceResidualFunction_kernel_invariant h w).symm) + +lemma cubicSourceQuotientFunction_projection (w : HyperbolicSpace) : + cubicSourceQuotientFunction (integralOrbitProjection globalKubotaKernel w)= + cubicSourceResidualFunction w := rfl + +lemma cubicSourceQuotientFunction_measurable : Measurable cubicSourceQuotientFunction := by + apply measurable_from_quotient.mpr + exact cubicSourceResidualFunction_continuous.measurable + +lemma cubicSourceQuotientFunction_represents : + kernelSourceProjection cubicEisensteinResidue=ᵐ[integralQuotientVolume globalKubotaKernel] + cubicSourceQuotientFunction := by + unfold integralQuotientVolume + apply (ae_map_iff (measurable_integralOrbitProjection _).aemeasurable + (measurableSet_eq_fun (Lp.stronglyMeasurable _).measurable + cubicSourceQuotientFunction_measurable)).mpr + exact ae_restrict_of_ae cubicSourceResidualFunction_represents_projection + +end CubicEisenstein + +namespace CubicKubota +open CubicEisenstein ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +abbrev CubeLegIndex (p : ActualEisensteinCubic.O) := Option (CubeResidues p) + +def cubeLegTarget (p : ActualEisensteinCubic.O) (hp : p≠0) : CubeLegIndex p→Subgroup (SL(2,ActualEisensteinCubic.O)) + | none => cubeCommonCover p hp + | some r => cubeCommonTarget p hp r + +lemma cubeLegTarget_le (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + cubeLegTarget p hp i≤globalKubotaKernel := by + cases i with + | none => exact cubeCommonCover_le p hp + | some r => exact cubeCommonTarget_le p hp r + +lemma cubeLegTarget_finiteIndex (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + (cubeLegTarget p hp i).FiniteIndex := by + cases i with + | none => exact cubeCommonCover_finiteIndex p hp + | some r => exact cubeCommonTarget_finiteIndex p hp r + +def cubeLegEquiv (p : ActualEisensteinCubic.O) (hp : p≠0) : (i : CubeLegIndex p)→ + cubeCommonCover p hp≃*cubeLegTarget p hp i + | none => MulEquiv.refl _ + | some r => cubeCommonEquiv p hp r + +def cubeLegMatrix (p : ActualEisensteinCubic.O) (hp : p≠0) : CubeLegIndex p→SL(2,ℂ) + | none => 1 + | some r => cubeAverageMatrix p hp (GaussianShiftedPartition.representative (p^3) r) + +lemma cubeLeg_intertwines (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + IntegralCoverIntertwines (cubeLegEquiv p hp i) (cubeLegMatrix p hp i) := by + cases i with + | none => + intro h + change 1*integralComplexMatrix (h:SL(2,ActualEisensteinCubic.O))=integralComplexMatrix (h:SL(2,ActualEisensteinCubic.O))*1 + simp only [one_mul,mul_one] + | some r => exact cubeCommon_intertwines p hp r + +def cubeLeg (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + KernelQuotientL2→L[ℂ]IntegralQuotientL2 (cubeCommonCover p hp) := by + letI := cubeLegTarget_finiteIndex p hp i + letI : (cubeLegTarget p hp i).IsFiniteRelIndex globalKubotaKernel := + Subgroup.isFiniteRelIndex_of_finiteIndex + exact kernelCoverLeg (cubeCommonCover_le p hp) (cubeLegTarget_le p hp i) + (cubeLegEquiv p hp i) (cubeLegMatrix p hp i) (cubeLeg_intertwines p hp i) + +def cubeLegCoefficient (p : ActualEisensteinCubic.O) : CubeLegIndex p→ℂ + | none => -(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹ + | some _ => (Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹^3 + +def cubeLegQuotientFunction (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + IntegralOrbitQuotient (cubeCommonCover p hp)→ℂ := + fun q=>cubicSourceQuotientFunction + (integralCoverMap (cubeLegTarget_le p hp i) + (integralConjugateMap (cubeLegEquiv p hp i) (cubeLegMatrix p hp i) + (cubeLeg_intertwines p hp i) q)) + +lemma cubeLegQuotientFunction_projection (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) + (w : HyperbolicSpace) : + cubeLegQuotientFunction p hp i (integralOrbitProjection (cubeCommonCover p hp) w)= + cubicSourceResidualFunction (cubeLegMatrix p hp i • w) := rfl + +lemma cubeLegQuotientFunction_measurable (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + Measurable (cubeLegQuotientFunction p hp i) := + cubicSourceQuotientFunction_measurable.comp + ((integralCoverMap_measurable (cubeLegTarget_le p hp i)).comp + (integralConjugateMap_measurable _ _ _)) + +lemma cubeLeg_representative (p : ActualEisensteinCubic.O) (hp : p≠0) (i : CubeLegIndex p) : + cubeLeg p hp i (kernelSourceProjection cubicEisensteinResidue) + =ᵐ[integralQuotientVolume (cubeCommonCover p hp)]cubeLegQuotientFunction p hp i := by + let := cubeLegTarget_finiteIndex p hp i + let : (cubeLegTarget p hp i).IsFiniteRelIndex globalKubotaKernel := + Subgroup.isFiniteRelIndex_of_finiteIndex + exact kernelCoverLeg_representative (cubeCommonCover_le p hp) (cubeLegTarget_le p hp i) + (cubeLegEquiv p hp i) (cubeLegMatrix p hp i) (cubeLeg_intertwines p hp i) + _ _ cubicSourceQuotientFunction_represents + +def cubeDifferenceL2 (p : ActualEisensteinCubic.O) (hp : p≠0) : IntegralQuotientL2 (cubeCommonCover p hp) := + ∑' i:CubeLegIndex p,cubeLegCoefficient p i • + cubeLeg p hp i (kernelSourceProjection cubicEisensteinResidue) + +def cubeDifferenceQuotientFunction (p : ActualEisensteinCubic.O) (hp : p≠0) : + IntegralOrbitQuotient (cubeCommonCover p hp)→ℂ := + fun q=>∑' i:CubeLegIndex p,cubeLegCoefficient p i*cubeLegQuotientFunction p hp i q + +lemma cubeDifferenceQuotientFunction_projection (p : ActualEisensteinCubic.O) (hp : p≠0) + (w : HyperbolicSpace) : + cubeDifferenceQuotientFunction p hp (integralOrbitProjection (cubeCommonCover p hp) w)= + cubeSourceDifference p hp w := by + let : Finite (CubeResidues p) := finite_quotient_span (pow_ne_zero 3 hp) + let : Fintype (CubeResidues p) := Fintype.ofFinite _ + simp only [cubeDifferenceQuotientFunction,tsum_fintype,Fintype.sum_option, + cubeLegCoefficient,cubeLegQuotientFunction_projection,cubeLegMatrix,one_smul, + cubeSourceDifference,cubeAverage,Finset.mul_sum] + ring + +lemma cubeDifferenceQuotientFunction_measurable (p : ActualEisensteinCubic.O) (hp : p≠0) : + Measurable (cubeDifferenceQuotientFunction p hp) := by + let : Finite (CubeResidues p) := finite_quotient_span (pow_ne_zero 3 hp) + let : Fintype (CubeResidues p) := Fintype.ofFinite _ + unfold cubeDifferenceQuotientFunction + simp only [tsum_fintype] + exact Finset.measurable_sum _ (fun i _=>measurable_const.mul (cubeLegQuotientFunction_measurable p hp i)) + +lemma cubeDifferenceL2_representative (p : ActualEisensteinCubic.O) (hp : p≠0) : + cubeDifferenceL2 p hp=ᵐ[integralQuotientVolume (cubeCommonCover p hp)] + cubeDifferenceQuotientFunction p hp := by + let : Finite (CubeResidues p) := finite_quotient_span (pow_ne_zero 3 hp) + let : Fintype (CubeResidues p) := Fintype.ofFinite _ + unfold cubeDifferenceL2 cubeDifferenceQuotientFunction + simp only [tsum_fintype] + apply (Lp.coeFn_finsetSum _ _).trans + have hh (i : CubeLegIndex p) : + ((cubeLegCoefficient p i • cubeLeg p hp i (kernelSourceProjection cubicEisensteinResidue) : + IntegralQuotientL2 (cubeCommonCover p hp)) : IntegralOrbitQuotient (cubeCommonCover p hp)→ℂ) + =ᵐ[integralQuotientVolume (cubeCommonCover p hp)] + (fun q=>cubeLegCoefficient p i*cubeLegQuotientFunction p hp i q) := + by + filter_upwards [Lp.coeFn_smul (cubeLegCoefficient p i) + (cubeLeg p hp i (kernelSourceProjection cubicEisensteinResidue)), + cubeLeg_representative p hp i] with q hq hr + simpa only [Pi.smul_apply,smul_eq_mul,hr] using hq + filter_upwards [eventuallyEq_sum (fun i (_ : i∈Finset.univ)=>hh i)] with q hq + simpa only [Finset.sum_apply] using hq + +end CubicKubota +end + +namespace CubicEisenstein + +open MeasureTheory +open scoped Classical MatrixGroups BigOperators + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota EisensteinCuspModThree +local notation "Eis" => ActualEisensteinCubic.O + +lemma sourceCuspLeadingCoefficient_ramified (j:Fin 3) (hj:j≠0) : + sourceCuspLeadingCoefficient (cuspRepresentative j)=0 := by + unfold sourceCuspLeadingCoefficient sourceCuspConstant + rw [sourceCuspRepresentative_average] + simp only [ite_eq_right hj,zero_mul,zero_div] + +theorem sourceCuspRemainder_representatives_decay (a:ℝ) (ha:0 ActualEisensteinCubic.O + +lemma cubeCuspTriangular_norm_sq_le {M:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData M p q) (hp:p≠0) : + ‖cubeCuspTriangular d hp 1 1‖^2≤‖eisEmbedding p‖^3 := by + rw [cubeCuspTriangular_norm_sq d hp,←Real.rpow_natCast ‖eisEmbedding p‖ 3] + apply Real.rpow_le_rpow_of_exponent_le (cubePrime_norm_ge_one p hp) + norm_num only [Nat.cast_ofNat] + have hj:0≤(d.exponent.val:ℝ):=Nat.cast_nonneg _ + linarith + +lemma cubeReducedRemainder_bound_from_height {M:SL(2,Eis)} {p q:Eis} + (d:CubeCuspData M p q) (hp:p≠0) (a K:ℝ) (ha:0cubeReducedRemainder (d r) hp.ne_zero z v hv) (K*‖eisEmbedding p‖^9/v^3) + (by positivity) (fun r=>cubeReducedRemainder_bound_from_height (d r) hp.ne_zero a K ha hK hrep z v hv hav) + have hrest:‖(Ideal.absNorm (Ideal.span {p}):ℂ)⁻¹*sourceCuspRemainder M z v hv‖≤ + (Ideal.absNorm (Ideal.span {p}):ℝ)⁻¹*(K/v^3):=by + rw [norm_mul,norm_inv,Complex.norm_natCast] + exact mul_le_mul_of_nonneg_left hbase (inv_nonneg.mpr (Nat.cast_nonneg _)) + unfold cubeSourceDifference + rw [cubeSource_difference_eq_remainders M p hp hprimary z v hv] + refine (norm_sub_le _ _).trans ?_ + calc + _≤K*‖eisEmbedding p‖^9/v^3+(Ideal.absNorm (Ideal.span {p}):ℝ)⁻¹*(K/v^3):= + add_le_add hsum hrest + _=_:=by ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota EisensteinCuspModThree +local notation "Eis" => ActualEisensteinCubic.O + +def cubeInverseLeftMatrix (q:Eis) : SL(2,Eis) := + ⟨!![3*q,1;-1,0],by simp⟩ + +lemma cubeAverageMatrix_inverse_factor (p:Eis) (hp:p≠0) (q:Eis) : + (cubeAverageMatrix p hp q)⁻¹= + integralComplexMatrix (cubeInverseLeftMatrix q)*cubeAverageMatrix p hp 0* + integralComplexMatrix (rationalEmbedding ModularGroup.S) := by + apply Subtype.ext + simp only [Matrix.SpecialLinearGroup.coe_inv, Matrix.SpecialLinearGroup.coe_mul, + cubeAverageMatrix_entries] + apply Matrix.ext + intro i j + simp only [Matrix.adjugate_fin_two, Matrix.mul_apply, Fin.sum_univ_two, + integralComplexMatrix_apply, rationalEmbedding, Matrix.SpecialLinearGroup.map_apply_coe] + fin_cases i <;> fin_cases j <;> + simp [cubeInverseLeftMatrix, ModularGroup.S, map_ofNat] + ring + +lemma cubeAverageMatrix_inverse_cusp_factor (M:SL(2,Eis)) (p q:Eis) + (hp:Prime p) (hprimary:lambda^2∣p-1) : + let d:=actualCubeCuspData (rationalEmbedding ModularGroup.S*M) p 0 hp hprimary + (cubeAverageMatrix p hp.ne_zero q)⁻¹*integralComplexMatrix M= + integralComplexMatrix (cubeInverseLeftMatrix q*d.matrix)*cubeCuspTriangular d hp.ne_zero := by + dsimp only + let d:=actualCubeCuspData (rationalEmbedding ModularGroup.S*M) p 0 hp hprimary + calc + _=integralComplexMatrix (cubeInverseLeftMatrix q)* + (cubeAverageMatrix p hp.ne_zero 0*integralComplexMatrix (rationalEmbedding ModularGroup.S*M)):=by + rw [cubeAverageMatrix_inverse_factor,map_mul] + group + _=integralComplexMatrix (cubeInverseLeftMatrix q)* + (integralComplexMatrix d.matrix*cubeCuspTriangular d hp.ne_zero):=by + rw [cubeCuspTriangular_factor d hp.ne_zero] + _=integralComplexMatrix (cubeInverseLeftMatrix q*d.matrix)*cubeCuspTriangular d hp.ne_zero:=by + rw [map_mul,mul_assoc] + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CubicKubota EisensteinCuspModThree +local notation "Eis" => ActualEisensteinCubic.O + +theorem cubeSourceDifference_inverse_cubic_decay (p:Eis) (hp:Prime p) + (hprimary:lambda^2∣p-1) : + ∃C:ℝ,0≤C∧∀q:Eis,∀M:SL(2,Eis),∀z:ℂ,∀v:ℝ,∀hv:0 ActualEisensteinCubic.O + +lemma kernelSourcePullback_pairing_inverse (M : CubicKubota.levelTwo) (F G : KernelQuotientL2) : + inner ℂ F (kernelSourcePullback M G)=inner ℂ (kernelSourcePullback M⁻¹ F) G := by + calc + _ = inner ℂ (kernelSourcePullback M (kernelSourcePullback M⁻¹ F)) (kernelSourcePullback M G) := by + rw [kernelSourcePullback_comp,inv_mul_cancel,kernelSourcePullback_one] + _ = _ := LinearIsometry.inner_map_map _ _ _ + +lemma kernelSourcePullback_integral_cusp_decay (M : CubicKubota.levelTwo) + (f : KernelQuotient→ℂ) (C : ℝ) + (hdec : ∀N : SL(2,ActualEisensteinCubic.O),∀z : ℂ,∀v : ℝ,∀hv : 0f (kernelSourceAction M⁻¹ q) := + (kernelSourcePullback_ae_eq M⁻¹ F).trans + ((kernelSourceAction_measurePreserving M⁻¹).quasiMeasurePreserving.ae_eq_comp hrep) + apply cubicEisensteinResidue_orthogonal_of_cusp_chart_decay _ + (kernelSource_eigenvector M⁻¹ F (8/9:ℂ) hF) _ hrepM C hC + intro N z v hv hlarge + exact kernelSourcePullback_integral_cusp_decay M⁻¹ f C hdec (N:SL(2,ActualEisensteinCubic.O)) z v hv hlarge + +theorem cubicSourceResidue_orthogonal_of_integral_cusp_decay + (F : KernelQuotientL2) (hF : (F,(8/9:ℂ)•F)∈kernelEnergyLaplacian.graph) + (f : KernelQuotient→ℂ) (hrep : F=ᵐ[integralQuotientVolume globalKubotaKernel]f) + (C : ℝ) (hC : 0≤C) + (hdec : ∀N : SL(2,ActualEisensteinCubic.O),∀z : ℂ,∀v : ℝ,∀hv : 0 ActualEisensteinCubic.O + +theorem kernelCoverLeg_adjoint_sum_eigenvector + {H : Subgroup (SL(2,ActualEisensteinCubic.O))} {ι : Type*} [Fintype ι] + (J : ι→Subgroup (SL(2,ActualEisensteinCubic.O))) + (hHK : H≤globalKubotaKernel) (hJK : ∀i,J i≤globalKubotaKernel) + [∀i,(J i).IsFiniteRelIndex globalKubotaKernel] + (e : ∀i,H≃*J i) (g : ι→SL(2,ℂ)) (he : ∀i,IntegralCoverIntertwines (e i) (g i)) + (F : KernelQuotientL2) (eigenvalue : ℂ) + (hF : (F,eigenvalue • F)∈kernelEnergyLaplacian.graph) + (c : ι→ℂ) (j : ι) : + let D := ∑i,c i • kernelCoverLeg hHK (hJK i) (e i) (g i) (he i) F + (ContinuousLinearMap.adjoint (kernelCoverLeg hHK (hJK j) (e j) (g j) (he j)) D, + eigenvalue • ContinuousLinearMap.adjoint (kernelCoverLeg hHK (hJK j) (e j) (g j) (he j)) D) + ∈kernelEnergyLaplacian.graph := by + let traced (i : ι) := + ContinuousLinearMap.adjoint (kernelCoverLeg hHK (hJK j) (e j) (g j) (he j)) + (kernelCoverLeg hHK (hJK i) (e i) (g i) (he i) F) + have hi (i : ι) : (traced i,eigenvalue • traced i)∈kernelEnergyLaplacian.graph := by + change (((ContinuousLinearMap.adjoint (kernelCoverLeg hHK (hJK j) (e j) (g j) (he j))).comp + (kernelCoverLeg hHK (hJK i) (e i) (g i) (he i))) F, + eigenvalue • ((ContinuousLinearMap.adjoint (kernelCoverLeg hHK (hJK j) (e j) (g j) (he j))).comp + (kernelCoverLeg hHK (hJK i) (e i) (g i) (he i))) F)∈kernelEnergyLaplacian.graph + rw [kernelCoverLeg_adjoint_comp] + exact kernelCorrespondence_eigenvector _ _ _ _ _ F eigenvalue hF + have hsum : (∑i,c i • (traced i,eigenvalue • traced i))∈kernelEnergyLaplacian.graph := + kernelEnergyLaplacian.graph.sum_mem (fun i _=>kernelEnergyLaplacian.graph.smul_mem (c i) (hi i)) + have hEq : (∑i,c i • (traced i,eigenvalue • traced i))= + (∑i,c i • traced i,eigenvalue • ∑i,c i • traced i) := by + apply Prod.ext <;> simp [Prod.fst_sum,Prod.snd_sum,Finset.smul_sum,smul_smul,mul_comm] + rw [hEq] at hsum + simpa only [map_sum,map_smul] using hsum + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/Rows.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/Rows.lean new file mode 100644 index 0000000000000000000000000000000000000000..cb1a46b0b38b5a7f00c5131f3556d50c208f0420 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/Rows.lean @@ -0,0 +1,625 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.RayCoefficients + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid + +section +open scoped BigOperators Classical MatrixGroups + +section +abbrev K := ActualEisensteinCubic.K +abbrev O := ActualEisensteinCubic.O +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT + +def row (M : levelThree) : Fin 2 → O := (M : SL(2,O)) 1 + +lemma row_mul (M N : levelThree) : + row (M*N) = Matrix.vecMul (row M) (N : SL(2,O)) := by + funext j + simp only [row, Subgroup.coe_mul, Matrix.SpecialLinearGroup.coe_mul, + Matrix.mul_apply, Matrix.vecMul, dotProduct] + +lemma row_ne_zero (M : levelThree) : row M ≠ 0 := by + intro hz + have hc : (M : SL(2,O)) 1 0 = 0 := congrFun hz 0 + have hd : (M : SL(2,O)) 1 1 = 0 := congrFun hz 1 + have h : (M : SL(2,O)) 0 0 * (M : SL(2,O)) 1 1 - + (M : SL(2,O)) 0 1 * (M : SL(2,O)) 1 0 = 1 := by + simpa only [Matrix.det_fin_two] using (M : SL(2,O)).property + simp only [hc, hd, mul_zero, sub_zero] at h + exact zero_ne_one h + +lemma character_eq_of_row_eq (M N : levelThree) (hr : row M = row N) : + complexCharacter M = complexCharacter N := by + have hrow : row (M*N⁻¹) = row 1 := by + rw [row_mul, hr, ← row_mul] + simp + have hc : ((M*N⁻¹ : levelThree) : SL(2,O)) 1 0 = 0 := by + simpa [row, Matrix.one_apply] using congrFun hrow 0 + have hchar : complexCharacter (M*N⁻¹) = 1 := by + change eisEmbedding (value (M*N⁻¹)) = 1 + rw [value_zero_lower_left _ hc, map_one] + calc + complexCharacter M = complexCharacter ((M*N⁻¹)*N) := by congr 1; group + _ = complexCharacter (M*N⁻¹) * complexCharacter N := map_mul _ _ _ + _ = complexCharacter N := by rw [hchar, one_mul] + +lemma row_eq_one_of_lower_left_zero (M : levelThree) + (hc : (M : SL(2,O)) 1 0 = 0) : row M = row 1 := by + have hdet : (M : SL(2,O)) 0 0 * (M : SL(2,O)) 1 1 = 1 := by + have hd : (M : SL(2,O)) 0 0 * (M : SL(2,O)) 1 1 - + (M : SL(2,O)) 0 1 * (M : SL(2,O)) 1 0 = 1 := by + simpa only [Matrix.det_fin_two] using (M : SL(2,O)).property + simpa only [hc, mul_zero, sub_zero] using hd + have ha := A3_primary_unit_eq_one _ (IsUnit.of_mul_eq_one _ hdet) + (levelThree_primary M) + have hd : (M : SL(2,O)) 1 1 = 1 := by simpa only [ha, one_mul] using hdet + funext j + fin_cases j <;> simp [row, hc, hd] + +def cuspStabilizer : Subgroup levelThree where + carrier := {M | row M = row 1} + one_mem' := rfl + mul_mem' := by + intro M N hM hN + change row (M*N) = row 1 + rw [row_mul, hM, ← row_mul] + simpa using hN + inv_mem' := by + intro M hM + have h : row (M*M⁻¹) = row 1 := by simp + rw [row_mul, hM, ← row_mul] at h + simpa using h + +lemma mem_cuspStabilizer_iff (M : levelThree) : + M ∈ cuspStabilizer ↔ (M : SL(2,O)) 1 0 = 0 := by + constructor + · intro h + simpa [row, Matrix.one_apply] using congrFun h 0 + · exact row_eq_one_of_lower_left_zero M + +lemma row_eq_iff_left_cusp (M N : levelThree) : row M = row N ↔ + ∃ T : levelThree, T ∈ cuspStabilizer ∧ M = T*N := by + constructor + · intro h + refine ⟨M*N⁻¹, ?_, by group⟩ + change row (M*N⁻¹) = row 1 + rw [row_mul, h, ← row_mul] + simp + · rintro ⟨T,hT,rfl⟩ + change row T = row 1 at hT + rw [row_mul, hT, ← row_mul, one_mul] + +def cuspRelation : Setoid levelThree := Setoid.ker row + +abbrev CuspCosets := Quotient cuspRelation + +def cosetOf (M : levelThree) : CuspCosets := Quotient.mk _ M + +lemma cosetOf_eq_iff (M N : levelThree) : cosetOf M = cosetOf N ↔ + ∃ T : levelThree, T ∈ cuspStabilizer ∧ M = T*N := by + rw [← row_eq_iff_left_cusp] + exact Quotient.eq + +def cosetRow : CuspCosets → (Fin 2 → O) := + Quotient.lift row (fun _ _ h => h) + +@[simp] lemma cosetRow_cosetOf (M : levelThree) : cosetRow (cosetOf M) = row M := rfl + +lemma cosetRow_injective : Function.Injective cosetRow := by + intro x y + induction x using Quotient.inductionOn with | _ M => + induction y using Quotient.inductionOn with | _ N => + intro h + exact Quotient.sound h + +lemma cosetRow_ne_zero (x : CuspCosets) : cosetRow x ≠ 0 := by + induction x using Quotient.inductionOn with | _ M => exact row_ne_zero M + +def cosetCharacter : CuspCosets → ℂ := + Quotient.lift complexCharacter (fun M N h => character_eq_of_row_eq M N h) + +@[simp] lemma cosetCharacter_cosetOf (M : levelThree) : + cosetCharacter (cosetOf M) = complexCharacter M := rfl + +lemma norm_cosetCharacter (x : CuspCosets) : ‖cosetCharacter x‖ = 1 := by + induction x using Quotient.inductionOn with | _ M => exact norm_complexCharacter M + +def rightTranslate (M : levelThree) : CuspCosets → CuspCosets := + Quotient.map (fun N => N*M) (by + intro A B h + change row (A*M) = row (B*M) + rw [row_mul, row_mul, show row A = row B from h]) + +@[simp] lemma rightTranslate_cosetOf (M N : levelThree) : + rightTranslate M (cosetOf N) = cosetOf (N*M) := rfl + +lemma rightTranslate_mul (M N : levelThree) (x : CuspCosets) : + rightTranslate N (rightTranslate M x) = rightTranslate (M*N) x := by + induction x using Quotient.inductionOn with | _ A => + change cosetOf ((A*M)*N) = cosetOf (A*(M*N)) + rw [mul_assoc] + +@[simp] lemma rightTranslate_one (x : CuspCosets) : rightTranslate 1 x = x := by + induction x using Quotient.inductionOn with | _ A => + change cosetOf (A*1) = cosetOf A + rw [mul_one] + +def rightEquiv (M : levelThree) : CuspCosets ≃ CuspCosets where + toFun := rightTranslate M + invFun := rightTranslate M⁻¹ + left_inv x := by rw [rightTranslate_mul]; simp + right_inv x := by rw [rightTranslate_mul]; simp + +lemma cosetRow_rightEquiv (M : levelThree) (x : CuspCosets) : + cosetRow (rightEquiv M x) = Matrix.vecMul (cosetRow x) (M : SL(2,O)) := by + induction x using Quotient.inductionOn with | _ N => exact row_mul N M + +lemma cosetCharacter_rightEquiv (M : levelThree) (x : CuspCosets) : + cosetCharacter (rightEquiv M x) = cosetCharacter x * complexCharacter M := by + induction x using Quotient.inductionOn with | _ N => exact map_mul _ _ _ + +def complexMatrix : levelThree →* SL(2,ℂ) := + (Matrix.SpecialLinearGroup.map (n := Fin 2) eisEmbedding).comp levelThree.subtype + +lemma complexMatrix_apply (M : levelThree) (i j : Fin 2) : + complexMatrix M i j = eisEmbedding ((M : SL(2,O)) i j) := rfl + +def embeddedRow (x : CuspCosets) : Fin 2 → ℂ := eisEmbedding ∘ cosetRow x + +lemma embeddedRow_ne_zero (x : CuspCosets) : embeddedRow x ≠ 0 := by + intro hz + apply cosetRow_ne_zero x + funext i + apply eisEmbedding_injective + simpa only [embeddedRow, Function.comp_apply, Pi.zero_apply, map_zero] using congrFun hz i + +lemma embeddedRow_rightEquiv (M : levelThree) (x : CuspCosets) : + embeddedRow (rightEquiv M x) = Matrix.vecMul (embeddedRow x) (complexMatrix M : SL(2,ℂ)) := by + funext j + simp only [embeddedRow, Function.comp_apply, cosetRow_rightEquiv, + Matrix.vecMul, dotProduct, map_sum, map_mul, complexMatrix_apply] + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT + +def integerLattice : Submodule ℤ ((Fin 2 × Fin 2) → ℝ) := + Submodule.span ℤ (Set.range (Pi.basisFun ℝ (Fin 2 × Fin 2))) + +instance : DiscreteTopology integerLattice := by + unfold integerLattice + infer_instance + +instance : IsZLattice ℝ integerLattice := by + unfold integerLattice + infer_instance + +def integerPoint (n : (Fin 2 × Fin 2) → ℤ) : integerLattice := + ⟨fun i => (n i : ℝ), by + rw [integerLattice, (Pi.basisFun ℝ (Fin 2 × Fin 2)).mem_span_iff_repr_mem ℤ] + intro i + exact ⟨n i, by simp⟩⟩ + +lemma integerPoint_injective : Function.Injective integerPoint := by + intro a b hab + funext i + have h := congrArg (fun x : integerLattice => (x : (Fin 2 × Fin 2) → ℝ) i) hab + change (a i : ℝ) = (b i : ℝ) at h + exact_mod_cast h + +lemma integerPoint_norm (n : (Fin 2 × Fin 2) → ℤ) : ‖integerPoint n‖ = ‖n‖ := by + change ‖fun i => (n i : ℝ)‖ = ‖n‖ + apply le_antisymm + · apply (pi_norm_le_iff_of_nonneg (norm_nonneg _)).mpr + intro i + simpa only [Real.norm_eq_abs, ← Int.norm_eq_abs] using norm_le_pi_norm n i + · apply (pi_norm_le_iff_of_nonneg (norm_nonneg _)).mpr + intro i + simpa only [Real.norm_eq_abs, ← Int.norm_eq_abs] using norm_le_pi_norm (fun i => (n i : ℝ)) i + +lemma summable_integer_four_rpow (k : ℝ) (hk : 4 < k) : + Summable (fun n : (Fin 2 × Fin 2) → ℤ => ‖n‖ ^ (-k)) := by + have hf : Module.finrank ℤ integerLattice = 4 := by + rw [ZLattice.rank ℝ integerLattice] + simp + have hs := ZLattice.summable_norm_rpow integerLattice (-k) (by rw [hf]; norm_num; linarith) + apply (hs.comp_injective integerPoint_injective).congr + intro n + change ‖integerPoint n‖ ^ (-k) = ‖n‖ ^ (-k) + rw [integerPoint_norm] + +def rowCoordinates (v : Fin 2 → O) : (Fin 2 × Fin 2) → ℤ := + fun i => if i.2 = 0 then (ActualEisensteinCoordinates.coords (v i.1)).1 + else (ActualEisensteinCoordinates.coords (v i.1)).2 + +lemma rowCoordinates_injective : Function.Injective rowCoordinates := by + intro v w hvw + funext i + apply latticeCoordEquiv.injective + apply Prod.ext + · exact congrFun hvw (i,0) + · exact congrFun hvw (i,1) + +lemma coordinates_norm_bound (v : Fin 2 → O) : + ‖rowCoordinates v‖ ≤ 2 * ‖fun i => eisEmbedding (v i)‖ := by + apply (pi_norm_le_iff_of_nonneg (by positivity)).mpr + intro i + have hi := norm_le_pi_norm (fun j => eisEmbedding (v j)) i.1 + have hq := eisEmbedding_eval_norm_sq + (ActualEisensteinCoordinates.coords (v i.1)).1 + (ActualEisensteinCoordinates.coords (v i.1)).2 + rw [ActualEisensteinCoordinates.eval_coords] at hq + push_cast at hq + have hcoord (a b : ℝ) (t : ℝ) (ht : 0 ≤ t) + (heq : t ^ 2 = a*a-a*b+b*b) : |a| ≤ 2*t ∧ |b| ≤ 2*t := by + constructor <;> apply (abs_le).mpr <;> constructor <;> + nlinarith [sq_nonneg (a-b), sq_nonneg (a+b), sq_nonneg (a-2*b), sq_nonneg (b-2*a)] + have hh := hcoord _ _ ‖eisEmbedding (v i.1)‖ (norm_nonneg _) hq + dsimp only [rowCoordinates] + split_ifs + · simpa only [Int.norm_eq_abs] using hh.1.trans (mul_le_mul_of_nonneg_left hi (by norm_num)) + · simpa only [Int.norm_eq_abs] using hh.2.trans (mul_le_mul_of_nonneg_left hi (by norm_num)) + +end + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT + +def rowEnergy (v : Fin 2 → ℂ) : ℝ := ‖v 0‖ ^ 2 + ‖v 1‖ ^ 2 + +lemma rowEnergy_nonneg (v : Fin 2 → ℂ) : 0 ≤ rowEnergy v := by + unfold rowEnergy; positivity + +lemma norm_le_sqrt_rowEnergy (v : Fin 2 → ℂ) : ‖v‖ ≤ Real.sqrt (rowEnergy v) := by + apply (pi_norm_le_iff_of_nonneg (Real.sqrt_nonneg _)).mpr + intro i + apply Real.le_sqrt_of_sq_le + fin_cases i <;> dsimp [rowEnergy] <;> nlinarith [sq_nonneg ‖v 0‖, sq_nonneg ‖v 1‖] + +lemma rowEnergy_pos (v : Fin 2 → ℂ) (hv : v ≠ 0) : 0 < rowEnergy v := by + have h := norm_le_sqrt_rowEnergy v + have hn := norm_pos_iff.mpr hv + exact Real.sqrt_pos.mp (lt_of_lt_of_le hn h) + +def rowOperator (g : SL(2,ℂ)) : (Fin 2 → ℂ) →L[ℂ] (Fin 2 → ℂ) := + (Matrix.toLinearMapRight' (g : Matrix (Fin 2) (Fin 2) ℂ)).toContinuousLinearMap + +@[simp] lemma rowOperator_apply (g : SL(2,ℂ)) (v : Fin 2 → ℂ) : + rowOperator g v = Matrix.vecMul v (g : Matrix (Fin 2) (Fin 2) ℂ) := rfl + +lemma rowOperator_mul (g h : SL(2,ℂ)) (v : Fin 2 → ℂ) : + rowOperator h (rowOperator g v) = rowOperator (g*h) v := by + simp only [rowOperator_apply, Matrix.vecMul_vecMul, Matrix.SpecialLinearGroup.coe_mul] + +@[simp] lemma rowOperator_one (v : Fin 2 → ℂ) : rowOperator 1 v = v := by + simp only [rowOperator_apply, Matrix.SpecialLinearGroup.coe_one, Matrix.vecMul_one] + +lemma rowOperator_ne_zero (g : SL(2,ℂ)) (v : Fin 2 → ℂ) (hv : v ≠ 0) : + rowOperator g v ≠ 0 := by + intro hz + have h := congrArg (rowOperator g⁻¹) hz + rw [rowOperator_mul, mul_inv_cancel, rowOperator_one, map_zero] at h + exact hv h + +def rowBound (g : SL(2,ℂ)) : ℝ := 2 * (1 + ‖rowOperator g⁻¹‖) + +lemma rowBound_pos (g : SL(2,ℂ)) : 0 < rowBound g := by unfold rowBound; positivity + +lemma coordinates_le_transformed_energy (g : SL(2,ℂ)) (v : Fin 2 → O) : + ‖rowCoordinates v‖ ≤ rowBound g * + Real.sqrt (rowEnergy (rowOperator g (fun i => eisEmbedding (v i)))) := by + have hi := (rowOperator g⁻¹).le_opNorm (rowOperator g (fun i => eisEmbedding (v i))) + rw [rowOperator_mul, mul_inv_cancel, rowOperator_one] at hi + have hb := coordinates_norm_bound v + have he := norm_le_sqrt_rowEnergy (rowOperator g (fun i => eisEmbedding (v i))) + have hm := mul_le_mul_of_nonneg_left he (norm_nonneg (rowOperator g⁻¹)) + dsimp only [rowBound] + nlinarith [Real.sqrt_nonneg (rowEnergy (rowOperator g (fun i => eisEmbedding (v i))))] + +lemma norm_coordinates_ne_zero (x : CuspCosets) : 0 < ‖rowCoordinates (cosetRow x)‖ := by + apply norm_pos_iff.mpr + intro hz + apply cosetRow_ne_zero x + apply rowCoordinates_injective + have hz0 : rowCoordinates (0 : Fin 2 → O) = 0 := by + apply norm_le_zero_iff.mp + have he : (fun i : Fin 2 => eisEmbedding ((0 : Fin 2 → O) i)) = + (0 : Fin 2 → ℂ) := by + funext i + exact map_zero _ + have hh := coordinates_norm_bound (0 : Fin 2 → O) + rw [he, norm_zero, mul_zero] at hh + exact hh + rw [hz0] + exact hz + +def summand (g : SL(2,ℂ)) (s : ℂ) (x : CuspCosets) : ℂ := + (cosetCharacter x)⁻¹ * + (rowEnergy (rowOperator g (embeddedRow x)) : ℂ) ^ (-s) + +lemma norm_summand (g : SL(2,ℂ)) (s : ℂ) (x : CuspCosets) : + ‖summand g s x‖ = rowEnergy (rowOperator g (embeddedRow x)) ^ (-s.re) := by + rw [summand, norm_mul, norm_inv, norm_cosetCharacter, inv_one, one_mul, + Complex.norm_cpow_eq_rpow_re_of_pos + (rowEnergy_pos _ (rowOperator_ne_zero g _ (embeddedRow_ne_zero x)))] + rfl + +lemma norm_summand_bound (g : SL(2,ℂ)) (s : ℂ) (hs : 0 < s.re) (x : CuspCosets) : + ‖summand g s x‖ ≤ (rowBound g) ^ (2*s.re) * + ‖rowCoordinates (cosetRow x)‖ ^ (-(2*s.re)) := by + rw [norm_summand] + have hn := norm_coordinates_ne_zero x + have hb := rowBound_pos g + have he := rowEnergy_pos _ (rowOperator_ne_zero g _ (embeddedRow_ne_zero x)) + have hbd := coordinates_le_transformed_energy g (cosetRow x) + change ‖rowCoordinates (cosetRow x)‖ ≤ rowBound g * + Real.sqrt (rowEnergy (rowOperator g (embeddedRow x))) at hbd + have hle : (‖rowCoordinates (cosetRow x)‖ / rowBound g) ^ 2 ≤ + rowEnergy (rowOperator g (embeddedRow x)) := by + have hd : ‖rowCoordinates (cosetRow x)‖ / rowBound g ≤ + Real.sqrt (rowEnergy (rowOperator g (embeddedRow x))) := + (div_le_iff₀ hb).mpr (by simpa only [mul_comm] using hbd) + have hsq := Real.sq_sqrt he.le + nlinarith [div_pos hn hb, Real.sqrt_nonneg (rowEnergy (rowOperator g (embeddedRow x)))] + have hp := Real.rpow_le_rpow_of_nonpos (sq_pos_of_pos (div_pos hn hb)) hle (by linarith : -s.re ≤ 0) + convert hp using 1 + rw [← Real.rpow_natCast_mul (div_nonneg hn.le hb.le) 2 (-s.re), + Real.div_rpow hn.le hb.le] + simp only [Nat.cast_ofNat, mul_neg, Real.rpow_neg hb.le, div_eq_mul_inv, inv_inv] + exact mul_comm _ _ + +theorem summable_norm_summand (g : SL(2,ℂ)) (s : ℂ) (hs : 2 < s.re) : + Summable (fun x : CuspCosets => ‖summand g s x‖) := by + have hsum := summable_integer_four_rpow (2*s.re) (by linarith) + have hinj : Function.Injective (fun x : CuspCosets => rowCoordinates (cosetRow x)) := + rowCoordinates_injective.comp cosetRow_injective + have hcomp : Summable (fun x : CuspCosets => ‖rowCoordinates (cosetRow x)‖ ^ (-(2*s.re))) := by + apply (hsum.comp_injective hinj).congr + intro x + rfl + exact (hcomp.mul_left ((rowBound g) ^ (2*s.re))).of_nonneg_of_le + (fun _ => norm_nonneg _) (fun x => norm_summand_bound g s (by linarith) x) + +theorem summable_summand (g : SL(2,ℂ)) (s : ℂ) (hs : 2 < s.re) : + Summable (summand g s) := (summable_norm_summand g s hs).of_norm + +def eisenstein (g : SL(2,ℂ)) (s : ℂ) : ℂ := ∑' x : CuspCosets, summand g s x + +lemma transformedRow_rightEquiv (M : levelThree) (g : SL(2,ℂ)) (x : CuspCosets) : + rowOperator g (embeddedRow (rightEquiv M x)) = + rowOperator (complexMatrix M * g) (embeddedRow x) := by + rw [embeddedRow_rightEquiv, ← rowOperator_apply, rowOperator_mul] + +lemma summand_automorphy (M : levelThree) (g : SL(2,ℂ)) (s : ℂ) (x : CuspCosets) : + summand (complexMatrix M * g) s x = + complexCharacter M * summand g s (rightEquiv M x) := by + have hM : complexCharacter M ≠ 0 := by + intro h + have hn := norm_complexCharacter M + rw [h, norm_zero] at hn + exact zero_ne_one hn + simp only [summand, cosetCharacter_rightEquiv, transformedRow_rightEquiv, + mul_inv_rev] + rw [← mul_assoc, ← mul_assoc, mul_inv_cancel₀ hM, one_mul] + +theorem eisenstein_automorphy (M : levelThree) (g : SL(2,ℂ)) (s : ℂ) (hs : 2 < s.re) : + eisenstein (complexMatrix M * g) s = complexCharacter M * eisenstein g s := by + have hleft := summable_summand (complexMatrix M * g) s hs + have hright := summable_summand g s hs + have hreindex : HasSum (fun x : CuspCosets => summand g s (rightEquiv M x)) + (eisenstein g s) := (rightEquiv M).hasSum_iff.mpr hright.hasSum + have hscale := hreindex.mul_left (complexCharacter M) + exact hleft.hasSum.unique (hscale.congr_fun (fun x => summand_automorphy M g s x)) + +lemma summand_differentiable (g : SL(2,ℂ)) (x : CuspCosets) : + Differentiable ℂ (fun s : ℂ => summand g s x) := by + have hq : (rowEnergy (rowOperator g (embeddedRow x)) : ℂ) ≠ 0 := + Complex.ofReal_ne_zero.mpr + (rowEnergy_pos _ (rowOperator_ne_zero g _ (embeddedRow_ne_zero x))).ne' + exact ((differentiable_id.neg).const_cpow (Or.inl hq)).const_mul _ + +lemma norm_summand_strip (g : SL(2,ℂ)) (a b : ℝ) (s : ℂ) + (ha : a ≤ s.re) (hb : s.re ≤ b) (x : CuspCosets) : + ‖summand g s x‖ ≤ ‖summand g (a : ℂ) x‖ + ‖summand g (b : ℂ) x‖ := by + simp only [norm_summand, Complex.ofReal_re] + have hq := rowEnergy_pos _ (rowOperator_ne_zero g _ (embeddedRow_ne_zero x)) + by_cases hq1 : 1 ≤ rowEnergy (rowOperator g (embeddedRow x)) + · exact (Real.rpow_le_rpow_of_exponent_le hq1 (neg_le_neg ha)).trans + (le_add_of_nonneg_right (Real.rpow_nonneg hq.le _)) + · exact (Real.rpow_le_rpow_of_exponent_ge hq (le_of_not_ge hq1) + (neg_le_neg hb)).trans + (le_add_of_nonneg_left (Real.rpow_nonneg hq.le _)) + +theorem eisenstein_differentiableOn_strip (g : SL(2,ℂ)) (a b : ℝ) + (ha : 2 < a) (hab : a < b) : + DifferentiableOn ℂ (eisenstein g) {s : ℂ | a < s.re ∧ s.re < b} := by + have hsa := summable_norm_summand g (a : ℂ) (by simpa using ha) + have hsb := summable_norm_summand g (b : ℂ) (by simpa using lt_trans ha hab) + apply Complex.differentiableOn_tsum_of_summable_norm (hsa.add hsb) + (fun x => (summand_differentiable g x).differentiableOn) + · exact (isOpen_lt continuous_const Complex.continuous_re).inter + (isOpen_lt Complex.continuous_re continuous_const) + · intro x s hs + exact norm_summand_strip g a b s hs.1.le hs.2.le x + +theorem eisenstein_differentiableAt (g : SL(2,ℂ)) (s : ℂ) (hs : 2 < s.re) : + DifferentiableAt ℂ (eisenstein g) s := by + let a := (2+s.re)/2 + let b := s.re+1 + have ha : 2 < a := by dsimp [a]; linarith + have hab : a < b := by dsimp [a,b]; linarith + have hsU : s ∈ {z : ℂ | a < z.re ∧ z.re < b} := by + constructor <;> dsimp [a,b] <;> linarith + exact (eisenstein_differentiableOn_strip g a b ha hab s hsU).differentiableAt + (((isOpen_lt continuous_const Complex.continuous_re).inter + (isOpen_lt Complex.continuous_re continuous_const)).mem_nhds hsU) + +theorem eisenstein_differentiableOn (g : SL(2,ℂ)) : + DifferentiableOn ℂ (eisenstein g) {s : ℂ | 2 < s.re} := by + intro s hs + exact (eisenstein_differentiableAt g s hs).differentiableWithinAt + +end + +open scoped BigOperators Classical MatrixGroups Matrix + +open ActualEisensteinCubic CubicKubota ConcreteTraceCRT + +def upperSection (z : ℂ) (v : ℝ) (hv : 0 < v) : SL(2,ℂ) := + ⟨!![(Real.sqrt v : ℂ), z / (Real.sqrt v : ℂ); 0, (Real.sqrt v : ℂ)⁻¹], by + have hr : (Real.sqrt v : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr (Real.sqrt_pos.mpr hv).ne' + simp [Matrix.det_fin_two, hr]⟩ + +lemma rowOperator_upperSection_zero (z : ℂ) (v : ℝ) (hv : 0 < v) (u : Fin 2 → ℂ) : + rowOperator (upperSection z v hv) u 0 = u 0 * (Real.sqrt v : ℂ) := by + change Matrix.vecMul u (!![(Real.sqrt v : ℂ), z / (Real.sqrt v : ℂ); 0, (Real.sqrt v : ℂ)⁻¹]) _ = _ + simp [Matrix.vecMul, dotProduct, Fin.sum_univ_two] + +lemma rowOperator_upperSection_one (z : ℂ) (v : ℝ) (hv : 0 < v) (u : Fin 2 → ℂ) : + rowOperator (upperSection z v hv) u 1 = (u 0*z + u 1) / (Real.sqrt v : ℂ) := by + change Matrix.vecMul u (!![(Real.sqrt v : ℂ), z / (Real.sqrt v : ℂ); 0, (Real.sqrt v : ℂ)⁻¹]) _ = _ + simp [Matrix.vecMul, dotProduct, Fin.sum_univ_two] + ring + +def heightDenominator (z : ℂ) (v : ℝ) (u : Fin 2 → ℂ) : ℝ := + ‖u 0*z + u 1‖ ^ 2 + ‖u 0‖ ^ 2 * v ^ 2 + +lemma rowEnergy_upperSection (z : ℂ) (v : ℝ) (hv : 0 < v) (u : Fin 2 → ℂ) : + rowEnergy (rowOperator (upperSection z v hv) u) = heightDenominator z v u / v := by + rw [rowEnergy, rowOperator_upperSection_zero, rowOperator_upperSection_one, + norm_mul, norm_div, Complex.norm_real, Real.norm_of_nonneg (Real.sqrt_nonneg v), + mul_pow, div_pow, Real.sq_sqrt hv.le] + unfold heightDenominator + field_simp + ring + +lemma heightDenominator_pos (z : ℂ) (v : ℝ) (hv : 0 < v) + (u : Fin 2 → ℂ) (hu : u ≠ 0) : 0 < heightDenominator z v u := by + have h := rowEnergy_pos _ (rowOperator_ne_zero (upperSection z v hv) u hu) + rw [rowEnergy_upperSection] at h + exact ((div_pos_iff.mp h).resolve_right (by rintro ⟨_,hneg⟩; linarith)).1 + +def transformedHeight (z : ℂ) (v : ℝ) (u : Fin 2 → ℂ) : ℝ := + v / heightDenominator z v u + +lemma summand_upperSection (z : ℂ) (v : ℝ) (hv : 0 < v) (s : ℂ) (x : CuspCosets) : + summand (upperSection z v hv) s x = (cosetCharacter x)⁻¹ * + (transformedHeight z v (embeddedRow x) : ℂ) ^ s := by + rw [summand, rowEnergy_upperSection] + congr 1 + have hq := heightDenominator_pos z v hv (embeddedRow x) (embeddedRow_ne_zero x) + have hinv : (transformedHeight z v (embeddedRow x) : ℂ) = + ((heightDenominator z v (embeddedRow x) / v : ℝ) : ℂ)⁻¹ := by + simp only [transformedHeight, Complex.ofReal_div, inv_div] + rw [hinv, Complex.inv_cpow_ofReal_nonneg (div_nonneg hq.le hv.le), Complex.cpow_neg] + +def upperEisenstein (z : ℂ) (v : ℝ) (hv : 0 < v) (s : ℂ) : ℂ := + eisenstein (upperSection z v hv) s + +theorem upperEisenstein_eq_source_series (z : ℂ) (v : ℝ) (hv : 0 < v) (s : ℂ) : + upperEisenstein z v hv s = ∑' x : CuspCosets, (cosetCharacter x)⁻¹ * + (transformedHeight z v (embeddedRow x) : ℂ) ^ s := + tsum_congr (summand_upperSection z v hv s) + +theorem source_series_summable (z : ℂ) (v : ℝ) (hv : 0 < v) (s : ℂ) (hs : 2 < s.re) : + Summable (fun x : CuspCosets => (cosetCharacter x)⁻¹ * + (transformedHeight z v (embeddedRow x) : ℂ) ^ s) := + (summable_summand (upperSection z v hv) s hs).congr (summand_upperSection z v hv s) + +lemma ofReal_rowEnergy (u : Fin 2 → ℂ) : + (rowEnergy u : ℂ) = dotProduct u (star u) := by + simp only [rowEnergy, Complex.ofReal_add, ← Complex.normSq_eq_norm_sq, dotProduct, + Fin.sum_univ_two, Pi.star_apply, Complex.star_def, Complex.mul_conj] + +lemma rowEnergy_unitary (k : SL(2,ℂ)) + (hk : (k : Matrix (Fin 2) (Fin 2) ℂ) ∈ Matrix.unitaryGroup (Fin 2) ℂ) + (u : Fin 2 → ℂ) : rowEnergy (rowOperator k u) = rowEnergy u := by + apply Complex.ofReal_injective + rw [ofReal_rowEnergy, ofReal_rowEnergy, rowOperator_apply, Matrix.star_vecMul, + Matrix.dotProduct_mulVec, Matrix.vecMul_vecMul] + have hu := Matrix.mem_unitaryGroup_iff.mp hk + change (k : Matrix (Fin 2) (Fin 2) ℂ) * + Matrix.conjTranspose (k : Matrix (Fin 2) (Fin 2) ℂ) = 1 at hu + rw [hu, Matrix.vecMul_one] + +theorem eisenstein_right_unitary (g k : SL(2,ℂ)) (s : ℂ) + (hk : (k : Matrix (Fin 2) (Fin 2) ℂ) ∈ Matrix.unitaryGroup (Fin 2) ℂ) : + eisenstein (g*k) s = eisenstein g s := by + apply tsum_congr + intro x + simp only [summand, ← rowOperator_mul, rowEnergy_unitary k hk] + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ScatteringCoefficients.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ScatteringCoefficients.lean new file mode 100644 index 0000000000000000000000000000000000000000..0b5312bd91bbd1f046ac9734917c5bcdc6fe3908 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ScatteringCoefficients.lean @@ -0,0 +1,738 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CutoffApproximation +import OAI.NumberTheory.DirichletL.Eisenstein.ConjugateLevelAction + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +def cubicEisensteinResidue : KernelQuotientL2 := + kernelEisensteinResidueVector 2 3 (by norm_num) (by norm_num) + +lemma cubicEisensteinResidue_nonzero_character : + cubicEisensteinResidue≠0 ∧ + ∀M : CubicKubota.levelThree,kernelLevelPullback M cubicEisensteinResidue= + CubicKubota.complexCharacter M • cubicEisensteinResidue := by + apply kernelEisensteinResidueVector_nonzero_character_of_initial_overlap 2 3 (by norm_num) (by norm_num) + intro s hs hi + exact kernelEisensteinL2Correction_initial_overlap 2 3 (by norm_num) (by norm_num) s hs hi + +lemma cubicEisensteinResidue_ne_zero : cubicEisensteinResidue≠0 := + cubicEisensteinResidue_nonzero_character.1 + +lemma cubicEisensteinResidue_character (M : CubicKubota.levelThree) : + kernelLevelPullback M cubicEisensteinResidue= + CubicKubota.complexCharacter M • cubicEisensteinResidue := + cubicEisensteinResidue_nonzero_character.2 M + +lemma cubicEisensteinResidue_eigenvector : + (cubicEisensteinResidue,(8/9:ℂ) • cubicEisensteinResidue)∈kernelEnergyLaplacian.graph := + kernelEisensteinResidueVector_graph 2 3 (by norm_num) (by norm_num) + +lemma cubicEisensteinResidue_limit : + Tendsto (fun s : ℂ => (s-4/3) • kernelEisensteinL2Correction 2 3 (by norm_num) (by norm_num) s) + (𝓝[≠] (4/3:ℂ)) (𝓝 cubicEisensteinResidue) := + kernelEisensteinResidueVector_limit 2 3 (by norm_num) (by norm_num) + +lemma cubicEisensteinResidue_cusp_average : + kernelCuspStripAverage cubicEisensteinResidue=cuspConstantAverageResidue := by + apply kernelEisensteinResidueVector_average_of_overlap 2 3 (by norm_num) (by norm_num) + intro s hs hi + apply kernelCuspAverageFamily_eq_of_initial_overlap 2 3 (by norm_num) (by norm_num) s (by linarith) + exact kernelEisensteinL2Correction_initial_overlap 2 3 (by norm_num) (by norm_num) s hs hi + +lemma cubicEisensteinCorrection_not_continuousAt : + ¬ContinuousAt (kernelEisensteinL2Correction 2 3 (by norm_num) (by norm_num)) (4/3:ℂ) := by + intro hc + have hh := ((tendsto_id.sub_const (4/3:ℂ)).smul hc.tendsto).mono_left + (show 𝓝[≠] (4/3:ℂ)≤𝓝 (4/3:ℂ) from nhdsWithin_le_nhds) + simp only [sub_self,zero_smul] at hh + exact cubicEisensteinResidue_ne_zero (tendsto_nhds_unique cubicEisensteinResidue_limit hh) + +lemma cubicEisensteinResidue_local_limit (S : Set KernelQuotient) (hS : IsCompact S) : + Tendsto (fun s : ℂ => (s-4/3) • + kernelLocalCorrectedSeed S hS 2 3 (by norm_num) (by norm_num) s) + (𝓝[≠] (4/3:ℂ)) + (𝓝 (kernelMassRestrictionCLM S hS.measurableSet cubicEisensteinResidue)) := + kernelLocalCorrectedSeed_residue_limit S hS 2 3 (by norm_num) (by norm_num) + +lemma cubicEisensteinLocalFamily_initial_ae (S : Set KernelQuotient) (hS : IsCompact S) + (s : ℂ) (hs : 4 whittakerHeight p.1) := by + unfold whittakerHeight + fun_prop + have hb : Continuous whittakerBase := by unfold whittakerBase; fun_prop + have hp : Continuous (fun p : ℝ × ℂ => (whittakerBase p:ℂ)^(-s)) := + (Complex.continuous_ofReal.comp hb).cpow continuous_const + (fun p => Complex.ofReal_mem_slitPlane.mpr (whittakerBase_pos p)) + have hi : Continuous (fun p : ℝ × ℂ => (whittakerHeight p.1:ℂ)⁻¹) := + (Complex.continuous_ofReal.comp hv).inv₀ (fun p => by + change (whittakerHeight p.1:ℂ)≠0 + exact_mod_cast (zero_lt_one.trans_le (whittakerHeight_ge_one p.1)).ne') + have hc : Continuous (fun p : ℝ × ℂ => + ShortDraftTrace.breveE (-(freq*whittakerHeight p.1)*p.2)) := by + change Continuous (fun p : ℝ × ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-(freq*whittakerHeight p.1)*p.2)+starRingEnd ℂ (-(freq*whittakerHeight p.1)*p.2)))) + fun_prop + exact (hi.mul hp).mul hc + +lemma whittakerIntegrandDeriv_continuous (freq s : ℂ) : Continuous (whittakerIntegrandDeriv freq s) := by + have hb : Continuous whittakerBase := by unfold whittakerBase whittakerHeight; fun_prop + have hl : Continuous (fun p => Real.log (whittakerBase p)) := + hb.log (fun p => (whittakerBase_pos p).ne') + exact (Complex.continuous_ofReal.comp hl).neg.mul (whittakerIntegrand_continuous freq s) + +lemma whittakerIntegrand_hasDerivAt (freq s : ℂ) (p : ℝ × ℂ) : + HasDerivAt (fun w => whittakerIntegrand freq w p) (whittakerIntegrandDeriv freq s p) s := by + have hn : (whittakerBase p:ℂ)≠0 := by exact_mod_cast (whittakerBase_pos p).ne' + have hh := (((hasDerivAt_id s).neg.const_cpow (Or.inl hn)).const_mul + ((whittakerHeight p.1:ℂ)⁻¹)).mul_const + (ShortDraftTrace.breveE (-(freq*whittakerHeight p.1)*p.2)) + convert hh using 1 + · rfl + · rw [←Complex.ofReal_log (whittakerBase_pos p).le] + unfold whittakerIntegrandDeriv whittakerIntegrand + simp only [Pi.neg_apply,id_eq] + ring + +lemma whittakerIntegrand_norm (freq s : ℂ) (p : ℝ × ℂ) : + ‖whittakerIntegrand freq s p‖=(whittakerHeight p.1)⁻¹*(whittakerBase p)^(-s.re) := by + unfold whittakerIntegrand + rw [norm_mul,norm_mul,breveE_norm,mul_one,norm_inv, + Complex.norm_of_nonneg (zero_lt_one.trans_le (whittakerHeight_ge_one p.1)).le, + Complex.norm_cpow_eq_rpow_re_of_pos (whittakerBase_pos p)] + rfl + +lemma whittakerIntegrand_norm_bound (freq s : ℂ) (p : ℝ × ℂ) + (b : ℝ) (hb : 0≤b) (hs : b≤s.re) : + ‖whittakerIntegrand freq s p‖≤(1+‖p.2‖^2)^(-b) := by + rw [whittakerIntegrand_norm] + calc + _ ≤ (whittakerBase p)^(-s.re) := by + exact mul_le_of_le_one_left (Real.rpow_nonneg (whittakerBase_pos p).le _) + (inv_le_one_of_one_le₀ (whittakerHeight_ge_one p.1)) + _ ≤ (whittakerBase p)^(-b) := + Real.rpow_le_rpow_of_exponent_le (whittakerBase_ge_one p) (by linarith) + _ ≤ (1+‖p.2‖^2)^(-b) := + Real.rpow_le_rpow_of_nonpos (by positivity) (whittakerBase_ge p) (by linarith) + +lemma whittakerIntegrandDeriv_norm_bound (freq s : ℂ) (p : ℝ × ℂ) + (b ε : ℝ) (hb : 0≤b) (hε : 0<ε) (hs : b+ε≤s.re) : + ‖whittakerIntegrandDeriv freq s p‖≤ε⁻¹*(1+‖p.2‖^2)^(-b) := by + have hlog := Real.log_nonneg (whittakerBase_ge_one p) + unfold whittakerIntegrandDeriv + rw [norm_mul,norm_neg,Complex.norm_of_nonneg hlog,whittakerIntegrand_norm] + calc + _ ≤ Real.log (whittakerBase p)*(whittakerBase p)^(-s.re) := by + exact mul_le_mul_of_nonneg_left + (mul_le_of_le_one_left (Real.rpow_nonneg (whittakerBase_pos p).le _) + (inv_le_one_of_one_le₀ (whittakerHeight_ge_one p.1))) hlog + _ ≤ ((whittakerBase p)^ε/ε)*(whittakerBase p)^(-s.re) := by + exact mul_le_mul_of_nonneg_right (Real.log_le_rpow_div (whittakerBase_pos p).le hε) + (Real.rpow_nonneg (whittakerBase_pos p).le _) + _ = ε⁻¹*(whittakerBase p)^(ε-s.re) := by + rw [Real.rpow_sub (whittakerBase_pos p),Real.rpow_neg (whittakerBase_pos p).le] + ring + _ ≤ ε⁻¹*(whittakerBase p)^(-b) := by + exact mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow_of_exponent_le (whittakerBase_ge_one p) (by linarith)) (by positivity) + _ ≤ ε⁻¹*(1+‖p.2‖^2)^(-b) := by + exact mul_le_mul_of_nonneg_left + (Real.rpow_le_rpow_of_nonpos (by positivity) (whittakerBase_ge p) (by linarith)) (by positivity) + +lemma whittaker_bound_integrable (b : ℝ) (hb : 1 (1+‖p.2‖^2)^(-b)) whittakerProductVolume := by + have hk : Integrable (fun z : ℂ => (1+‖z‖^2)^(-b)) := by + convert (hyperbolicKernel_integrable (b:ℂ) hb).norm using 1 + funext z + simp only [hyperbolicKernel,Complex.norm_cpow_eq_rpow_re_of_pos + (by positivity : 0<1+‖z‖^2),Complex.neg_re,Complex.ofReal_re] + have hv : Integrable (fun _ : ℝ => (1:ℝ)) (volume.restrict (Set.Icc (5:ℝ) 6)) := integrable_const _ + unfold whittakerProductVolume + simpa only [one_mul] using hv.mul_prod hk + +lemma whittakerIntegrand_integrable (freq s : ℂ) (hs : 1 whittakerIntegrand_norm_bound freq s p s.re (by linarith) le_rfl)) + +lemma whittakerProduct_differentiableAt (freq s : ℂ) (hs : 1 ∫p,whittakerIntegrand freq w p∂whittakerProductVolume) s := by + let b : ℝ := (s.re+1)/2 + let ε : ℝ := (s.re-1)/4 + have hb : 1 ε⁻¹*(1+‖p.2‖^2)^(-b)) hU + (Eventually.of_forall (fun w => (whittakerIntegrand_continuous freq w).aestronglyMeasurable)) + (whittakerIntegrand_integrable freq s hs) + (whittakerIntegrandDeriv_continuous freq s).aestronglyMeasurable + (Eventually.of_forall (fun p w hw => whittakerIntegrandDeriv_norm_bound freq w p b ε (by linarith) hε hw.le)) + ((whittaker_bound_integrable b hb).const_mul ε⁻¹) + (Eventually.of_forall (fun p w _ => whittakerIntegrand_hasDerivAt freq w p)) + exact h.2.differentiableAt + +lemma whittakerIntegrand_eq (freq s : ℂ) (v : ℝ) (hv : 5≤v) (z : ℂ) : + whittakerIntegrand freq s (v,z)= + (v:ℂ)^(-s-1)*(hyperbolicKernel s z*ShortDraftTrace.breveE (-(freq*v)*z)) := by + have hvp : 0 whittakerIntegrand_eq freq s v hv.1 z) + _ = _ := integral_const_mul _ _ + +theorem cuspWhittakerAverage_differentiableAt (freq s : ℂ) (hs : 1 ∫v in Set.Icc (5:ℝ) 6,(v:ℂ)^(-w-1)*sourceFourierKernel w (freq*v)) s := by + have he : (fun w => ∫v in Set.Icc (5:ℝ) 6,(v:ℂ)^(-w-1)*sourceFourierKernel w (freq*v)) + =ᶠ[𝓝 s](fun w => ∫p,whittakerIntegrand freq w p∂whittakerProductVolume) := by + filter_upwards [(isOpen_lt continuous_const Complex.continuous_re).mem_nhds hs] with w hw + exact (whittakerProduct_eq_average freq w hw).symm + exact (whittakerProduct_differentiableAt freq s hs).congr_of_eventuallyEq he + +end + +section +open scoped BigOperators Classical + +open ActualEisensteinCubic ConcreteTraceCRT + +lemma arithmeticDirichletTerm_differentiable (h : ActualEisensteinCubic.O) (c : LevelLower) : + Differentiable ℂ (fun s : ℂ => arithmeticDirichletTerm s h c) := by + by_cases hc : c.1=0 + · simp only [arithmeticDirichletTerm,ite_eq_left hc] + exact differentiable_const _ + · have hq : ((‖eisEmbedding c.1‖^2:ℝ):ℂ)≠0 := + Complex.ofReal_ne_zero.mpr (pow_ne_zero 2 (norm_ne_zero_iff.mpr (eisEmbedding_ne_zero hc))) + simp only [arithmeticDirichletTerm,ite_eq_right hc] + exact (differentiable_id.neg.const_cpow (Or.inl hq)).mul_const _ + +lemma arithmeticDirichletTerm_norm_mono (h : ActualEisensteinCubic.O) + (a : ℝ) (s : ℂ) (ha : a≤s.re) (c : LevelLower) : + ‖arithmeticDirichletTerm s h c‖≤‖arithmeticDirichletTerm (a:ℂ) h c‖ := by + by_cases hc : c.1=0 + · simp only [arithmeticDirichletTerm,ite_eq_left hc,norm_zero,le_refl] + · have hpos : 0<‖eisEmbedding c.1‖^2 := sq_pos_of_pos + (norm_pos_iff.mpr (eisEmbedding_ne_zero hc)) + have hq : 1≤‖eisEmbedding c.1‖^2 := by + rw [eisEmbedding_norm_sq_eq_absNorm_span] + exact_mod_cast Nat.one_le_iff_ne_zero.mpr + (Ideal.absNorm_eq_zero_iff.not.mpr (Ideal.span_singleton_eq_bot.not.mpr hc)) + simp only [arithmeticDirichletTerm,ite_eq_right hc,norm_mul, + Complex.norm_cpow_eq_rpow_re_of_pos hpos,Complex.neg_re,Complex.ofReal_re] + exact mul_le_mul_of_nonneg_right (Real.rpow_le_rpow_of_exponent_le hq (neg_le_neg ha)) + (norm_nonneg _) + +theorem arithmeticDirichletSeries_differentiableAt (h : ActualEisensteinCubic.O) + (s : ℂ) (hs : 2 arithmeticDirichletSeries z h) s := by + let a : ℝ := (2+s.re)/2 + have ha : 2 arithmeticDirichletSeries z h) {z : ℂ | a (arithmeticDirichletTerm_differentiable h c).differentiableOn) hopen + intro c z hz + exact arithmeticDirichletTerm_norm_mono h a z hz.le c + exact (hd s has).differentiableAt (hopen.mem_nhds has) + +theorem scatteringCoefficient_differentiableAt (h : ActualEisensteinCubic.O) + (s : ℂ) (hs : 2 scatteringCoefficient z h) s := + (arithmeticDirichletSeries_differentiableAt h s hs).div_const _ + +theorem scatteringCoefficient_analyticOnNhd (h : ActualEisensteinCubic.O) : + AnalyticOnNhd ℂ (fun z => scatteringCoefficient z h) {z : ℂ | 2 ActualEisensteinCubic.O + +lemma cuspPeriodStrip_measure_ne_top : hyperbolicVolume (cuspPeriodStrip 5 6)≠(⊤:ℝ≥0∞) := by + have hm := kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have hh := hm.measure_preimage (s := Set.univ) MeasurableSet.univ.nullMeasurableSet + simp only [Set.preimage_univ,Measure.restrict_apply_univ] at hh + rw [hh] + exact measure_ne_top _ _ + +instance cuspStripFiniteVolume : IsFiniteMeasure (hyperbolicVolume.restrict (cuspPeriodStrip 5 6)) := + isFiniteMeasure_restrict.mpr cuspPeriodStrip_measure_ne_top + +abbrev CuspStripL2 := Lp ℂ 2 (hyperbolicVolume.restrict (cuspPeriodStrip 5 6)) + +def kernelCuspPullback : KernelQuotientL2→L[ℂ]CuspStripL2 := + (Lp.compMeasurePreservingₗᵢ ℂ (integralOrbitProjection globalKubotaKernel) + (kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num))).toContinuousLinearMap.comp + (LpToLpRestrictCLM KernelQuotient ℂ ℂ (integralQuotientVolume globalKubotaKernel) 2 kernelCuspStripSet) + +lemma kernelCuspPullback_ae_eq (F : KernelQuotientL2) : + kernelCuspPullback F=ᵐ[hyperbolicVolume.restrict (cuspPeriodStrip 5 6)] + fun w => F (integralOrbitProjection globalKubotaKernel w) := by + have hm := kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have hr := LpToLpRestrictCLM_coeFn ℂ kernelCuspStripSet F + have hc := hm.quasiMeasurePreserving.ae_eq_comp hr + have hp := Lp.coeFn_compMeasurePreserving + (LpToLpRestrictCLM KernelQuotient ℂ ℂ (integralQuotientVolume globalKubotaKernel) 2 kernelCuspStripSet F) hm + filter_upwards [hp,hc] with w hw hc + exact hw.trans hc + +def cuspFourierPhase (h : ActualEisensteinCubic.O) (w : HyperbolicSpace) : ℂ := + ShortDraftTrace.breveE (-cuspFrequency h*hyperbolicHorizontal w) + +lemma cuspFourierPhase_continuous (h : ActualEisensteinCubic.O) : Continuous (cuspFourierPhase h) := by + have hc : Continuous (fun z : ℂ => ShortDraftTrace.breveE (-cuspFrequency h*z)) := by + change Continuous (fun z : ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-cuspFrequency h*z)+starRingEnd ℂ (-cuspFrequency h*z)))) + fun_prop + exact hc.comp hyperbolicHorizontal_continuous + +lemma cuspFourierPhase_norm (h : ActualEisensteinCubic.O) (w : HyperbolicSpace) : ‖cuspFourierPhase h w‖=1 := + breveE_norm _ + +lemma cuspFourierTest_memLp (h : ActualEisensteinCubic.O) : + MemLp (fun w => star (cuspFourierPhase h w)) 2 + (hyperbolicVolume.restrict (cuspPeriodStrip 5 6)) := by + apply MemLp.of_bound (cuspFourierPhase_continuous h).star.aestronglyMeasurable 1 + exact Eventually.of_forall (fun w => by rw [norm_star,cuspFourierPhase_norm]) + +def cuspFourierTestL2 (h : ActualEisensteinCubic.O) : CuspStripL2 := + (cuspFourierTest_memLp h).toLp (fun w => star (cuspFourierPhase h w)) + +def kernelCuspFourier (h : ActualEisensteinCubic.O) : KernelQuotientL2→L[ℂ]ℂ := + (innerSL ℂ (cuspFourierTestL2 h)).comp kernelCuspPullback + +lemma kernelCuspFourier_integral (h : ActualEisensteinCubic.O) (F : KernelQuotientL2) : + kernelCuspFourier h F=∫w in cuspPeriodStrip 5 6, + F (integralOrbitProjection globalKubotaKernel w)*cuspFourierPhase h w∂hyperbolicVolume := by + change inner ℂ (cuspFourierTestL2 h) (kernelCuspPullback F)=_ + rw [L2.inner_def] + apply integral_congr_ae + filter_upwards [MemLp.coeFn_toLp (cuspFourierTest_memLp h),kernelCuspPullback_ae_eq F] with w hw hp + rw [RCLike.inner_apply,cuspFourierTestL2,hw,hp] + simp only [starRingEnd_apply,star_star] + +lemma kernelCuspFourier_restrict (h : ActualEisensteinCubic.O) (F : KernelQuotientL2) : + kernelCuspFourier h (kernelMassRestrictionCLM kernelCuspAverageCompact + kernelCuspAverageCompact_isCompact.measurableSet F)=kernelCuspFourier h F := by + rw [kernelCuspFourier_integral,kernelCuspFourier_integral] + have hm := kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have he := hm.quasiMeasurePreserving.ae_eq_comp (ae_restrict_of_ae + (kernelMassRestriction_coe kernelCuspAverageCompact kernelCuspAverageCompact_isCompact.measurableSet F) + (s := kernelCuspStripSet)) + apply integral_congr_ae + filter_upwards [he,ae_restrict_mem (cuspPeriodStrip_measurable 5 6)] with w hw hwm + exact congrArg (fun z : ℂ => z*cuspFourierPhase h w) + (hw.trans (Set.indicator_of_mem (kernelCuspStripSet_subset_compact ⟨w,hwm,rfl⟩) _)) + +def kernelCuspFourierFamily (h : ActualEisensteinCubic.O) (a b : ℝ) (ha : 0 (s-4/3)*kernelCuspFourierFamily h a b ha hab s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (kernelCuspFourier h (kernelEisensteinResidueVector a b ha hab))) := by + have hh := (kernelCuspFourier h).continuous.continuousAt.tendsto.comp + (kernelLocalCorrectedSeed_residue_limit kernelCuspAverageCompact kernelCuspAverageCompact_isCompact a b ha hab) + simpa only [Function.comp_def,map_smul,smul_eq_mul,kernelCuspFourier_restrict,kernelCuspFourierFamily] using hh + +lemma kernelCuspFourierFamily_actual_integral (h : ActualEisensteinCubic.O) (a b : ℝ) (ha : 0 z*cuspFourierPhase h w) + (hw.trans (Set.indicator_of_mem (kernelCuspStripSet_subset_compact ⟨w,hwm,rfl⟩) _)) + +lemma kernelCuspFourierFamily_of_initial_overlap (h : ActualEisensteinCubic.O) (a b : ℝ) (ha : 0 kernelQuotientEisenstein s hs q-kernelQuotientSeed a b s q) : + kernelCuspFourierFamily h a b ha hab s=∫w in cuspPeriodStrip 5 6, + hyperbolicEisenstein s w*cuspFourierPhase h w∂hyperbolicVolume := by + have hcorrected : kernelCorrectedSeed a b ha hab s=ᵐ[integralQuotientVolume globalKubotaKernel] + kernelQuotientEisenstein s hs := by + filter_upwards [hoverlap] with q hq + change kernelQuotientSeed a b s q+kernelEisensteinL2Correction a b ha hab s q=_ + rw [hq] + ring + have hm := kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have hp := hm.quasiMeasurePreserving.ae_eq_comp (ae_restrict_of_ae hcorrected (s := kernelCuspStripSet)) + rw [kernelCuspFourierFamily_actual_integral] + apply integral_congr_ae + filter_upwards [hp] with w hw + exact congrArg (fun z : ℂ => z*cuspFourierPhase h w) + (hw.trans (kernelQuotientEisenstein_mk s hs w)) + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +local notation "O" => ActualEisensteinCubic.O + +lemma hyperbolicEisenstein_cusp_fourier_average (s : ℂ) (hs : 2 hyperbolicEisenstein s w*cuspFourierPhase h w + have hg : Continuous g := (hyperbolicEisenstein_continuous s hs).mul (cuspFourierPhase_continuous h) + rw [cuspPeriodStrip_integral_coordinates g hg.aestronglyMeasurable (cuspCoordinateLift_weighted_integrable g hg)] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hpos : 0 kernelQuotientEisenstein s hs q-kernelQuotientSeed a b s q) : + kernelCuspFourierFamily h a b ha hab s= + ((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h*cuspWhittakerHeightFactor s h := by + rw [kernelCuspFourierFamily_of_initial_overlap h a b ha hab s hs hoverlap, + hyperbolicEisenstein_cusp_fourier_nonzero s hs h hh] + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +local notation "O" => ActualEisensteinCubic.O + +lemma sourceFourierKernel_continuous_freq (s : ℂ) (hs : 1 ∫z : ℂ,hyperbolicKernel s z*ShortDraftTrace.breveE (-freq*z)) + apply continuous_of_dominated (bound := fun z => ‖hyperbolicKernel s z‖) + · exact fun freq => (sourceFourierKernel_integrable s freq hs).aestronglyMeasurable + · exact fun freq => Eventually.of_forall (fun z => by rw [norm_mul,breveE_norm,mul_one]) + · exact (hyperbolicKernel_integrable s hs).norm + · filter_upwards with z + change Continuous (fun freq : ℂ => hyperbolicKernel s z* + Complex.exp (2*Real.pi*Complex.I*((-freq*z)+starRingEnd ℂ (-freq*z)))) + fun_prop + +lemma schlafliIntegrand_real (nu x t : ℝ) (ht : 0 (t:ℂ)^((nu:ℂ)-1)*Complex.exp (-(t:ℂ)-(x:ℂ)^2/(4*t)) + have hi : IntegrableOn f (Set.Ioi (0:ℝ)) volume := schlafliIntegral_integrable (nu:ℂ) x hnu + have hp (t : ℝ) (ht : 0 RCLike.re (f t))=ᵐ[volume.restrict (Set.Ioi (0:ℝ))] Set.univ := by + filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + apply propext + simp only [Function.mem_support,Set.mem_univ,iff_true] + exact (hp t ht).ne' + rw [measure_congr heq,Measure.restrict_apply_univ] + simp + · filter_upwards [ae_restrict_mem measurableSet_Ioi] with t ht + exact (hp t ht).le + +lemma sourceFourierKernel_real_re_pos (sigma : ℝ) (hsigma : 1 (v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v)) + (Set.Icc (5:ℝ) 6) volume := by + apply ContinuousOn.integrableOn_Icc + intro v hv + have hpos : 0 (v:ℂ)^(-(sigma:ℂ)-1)*sourceFourierKernel (sigma:ℂ) (cuspFrequency h*v) + have hi : IntegrableOn f (Set.Icc (5:ℝ) 6) volume := + cuspWhittakerHeightFactor_integrable (sigma:ℂ) hsigma h + have hp (v : ℝ) (hv : v∈Set.Icc (5:ℝ) 6) : 0<(f v).re := by + have hpos : 0 RCLike.re (f v))=ᵐ[volume.restrict (Set.Icc (5:ℝ) 6)] Set.univ := by + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + apply propext + simp only [Function.mem_support,Set.mem_univ,iff_true] + exact (hp v hv).ne' + rw [measure_congr heq,Measure.restrict_apply_univ] + norm_num + · filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + exact (hp v hv).le + +lemma cuspWhittakerHeightFactor_center_ne_zero (h : ActualEisensteinCubic.O) : + cuspWhittakerHeightFactor (4/3:ℂ) h≠0 := by + intro he + have hh := cuspWhittakerHeightFactor_real_re_pos (4/3:ℝ) (by norm_num) h + norm_num only [Complex.ofReal_div,Complex.ofReal_ofNat] at hh + rw [he,Complex.zero_re] at hh + exact lt_irrefl 0 hh + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/ScatteringResidues.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ScatteringResidues.lean new file mode 100644 index 0000000000000000000000000000000000000000..53a983eace8db0e441793856410babfc65940168 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/ScatteringResidues.lean @@ -0,0 +1,659 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.SourceProjection +import OAI.NumberTheory.DirichletL.Eisenstein.ResidualFourierSeries + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +section + +lemma scalar_residue_sub_continuous (f g : ℂ→ℂ) (z r : ℂ) + (hf : Tendsto (fun s => (s-z)*f s) (𝓝[≠] z) (𝓝 r)) (hg : ContinuousAt g z) : + Tendsto (fun s => (s-z)*(f s-g s)) (𝓝[≠] z) (𝓝 r) := by + have hlin : Tendsto (fun s : ℂ => s-z) (𝓝[≠] z) (𝓝 (0:ℂ)) := by + simpa only [id_eq,sub_self] using (tendsto_id.sub_const z).mono_left + (show 𝓝[≠] z≤𝓝 z from nhdsWithin_le_nhds) + have hz : Tendsto (fun s => (s-z)*g s) (𝓝[≠] z) (𝓝 (0:ℂ)) := by + simpa only [zero_mul] using hlin.mul (hg.tendsto.mono_left nhdsWithin_le_nhds) + simpa only [mul_sub,sub_zero] using hf.sub hz + +lemma weightedOutgoingConstant_residue_limit (a b : ℝ) (ha : 0 (s-4/3)*weightedOutgoingConstant a b ha ρ s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (kernelCuspHeightFourier a b ha ρ 0 cubicEisensteinResidue)) := by + apply scalar_residue_sub_continuous _ _ _ _ (kernelCuspHeightFourierFamily_residue_limit a b ha ρ 0) + exact continuousAt_const.mul + ((compactHeightMellin_differentiable a b ha ρ).continuous.continuousAt.comp + (continuousAt_id.sub_const 3)) + +lemma baseOutgoingConstant_residue_limit : + Tendsto (fun s : ℂ => (s-4/3)*baseOutgoingConstant s) + (𝓝[≠] (4/3:ℂ)) (𝓝 cuspConstantAverageResidue) := by + have hf := kernelCuspAverageFamily_residue_limit 2 3 (by norm_num) (by norm_num) + change Tendsto _ _ (𝓝 (kernelCuspStripAverage cubicEisensteinResidue)) at hf + rw [cubicEisensteinResidue_cusp_average] at hf + apply scalar_residue_sub_continuous _ _ _ _ hf + exact continuousAt_const.mul + (cuspMainHeightFactor_differentiableAt (4/3:ℂ) (by norm_num)).continuousAt + +theorem kernelCuspHeightFourier_zero_residue (a b : ℝ) (ha : 0 compactHeightMellin a b ρ (-s-1)) (𝓝[≠] (4/3:ℂ)) + (𝓝 (compactHeightMellin a b ρ (-(4/3:ℂ)-1))) := + ((compactHeightMellin_differentiable a b ha ρ).continuous.continuousAt.comp + (continuousAt_id.neg.sub_const 1)).tendsto.mono_left nhdsWithin_le_nhds + have hleft := ((weightedOutgoingConstant_residue_limit a b ha ρ).mul hbase).comp + upperVertical_tendsto_cubic_punctured + have hright := (baseOutgoingConstant_residue_limit.mul hweight).comp + upperVertical_tendsto_cubic_punctured + have hevent : (fun t : ℝ => + (((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*weightedOutgoingConstant a b ha ρ ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspScatterHeightFactor ((4/3:ℂ)+(t:ℂ)*Complex.I)) + =ᶠ[𝓝[>] (0:ℝ)] (fun t : ℝ => + (((4/3:ℂ)+(t:ℂ)*Complex.I-4/3)*baseOutgoingConstant ((4/3:ℂ)+(t:ℂ)*Complex.I))* + compactHeightMellin a b ρ (-((4/3:ℂ)+(t:ℂ)*Complex.I)-1)) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 ActualEisensteinCubic.O + +def cubicResidualFullModeAmplitude (v : ℝ) (h : ActualEisensteinCubic.O) : ℂ := + if h=0 then (3*(Real.pi:ℂ))*constantArithmeticResidue*(v:ℂ)^(2/3:ℂ) + else cubicResidualFourierCoefficient h*(v:ℂ)* + schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v) + +lemma cubicResidualFullModeAmplitude_zero (v : ℝ) : + cubicResidualFullModeAmplitude v 0= + (3*(Real.pi:ℂ))*constantArithmeticResidue*(v:ℂ)^(2/3:ℂ) := by + simp only [cubicResidualFullModeAmplitude,ite_true] + +lemma cubicResidualFullModeAmplitude_nonzero (v : ℝ) (h : ActualEisensteinCubic.O) (hh : h≠0) : + cubicResidualFullModeAmplitude v h=cubicResidualFourierCoefficient h*(v:ℂ)* + schlafliBesselK (1/3) (4*Real.pi*‖cuspFrequency h‖*v) := by + rw [cubicResidualFullModeAmplitude,ite_eq_right hh] + +lemma cubicResidualFullModeAmplitude_zero_density (v : ℝ) (hv : 0 ActualEisensteinCubic.O + +def cubicResidualFunction (w : HyperbolicSpace) : ℂ := + (3*Real.pi:ℂ)*constantArithmeticResidue*(hyperbolicHeight w:ℂ)^(2/3:ℂ)+ + cubicResidualNonzeroFunction w + +lemma cubicResidualFunction_continuous : Continuous cubicResidualFunction := by + have hp : Continuous (fun w : HyperbolicSpace => (hyperbolicHeight w:ℂ)^(2/3:ℂ)) := by + apply continuous_iff_continuousAt.mpr + intro w + exact (Complex.continuousAt_ofReal_cpow_const (hyperbolicHeight w) (2/3:ℂ) + (Or.inr (hyperbolicHeight_pos w).ne')).comp (f := hyperbolicHeight) hyperbolicHeight_continuous.continuousAt + exact (continuous_const.mul hp).add cubicResidualNonzeroFunction_continuous + +lemma cubicResidualNonzeroSeries_height_continuous (v : ℝ) (hv : 0 cubicResidualNonzeroSeries (v,z)) := by + apply continuous_iff_continuousAt.mpr + intro z + have hopen : IsOpen {p : ℝ × ℂ | 0 (v,z)) (by fun_prop) + +lemma periodDomain_integrable_of_continuous (f : ℂ→ℂ) (hf : Continuous f) : + IntegrableOn f periodDomain volume := by + apply (hf.continuousOn.integrableOn_compact + (isCompact_closedBall (0:ℂ) (∑i,‖periodBasis i‖))).mono_set + intro z hz + simpa only [Metric.mem_closedBall,dist_zero_right] using norm_mem_periodDomain z hz + +lemma cubicResidualFunction_fourier (v : ℝ) (hv : 0 ShortDraftTrace.breveE (-cuspFrequency k*z)) := by + change Continuous (fun z : ℂ => Complex.exp (2*Real.pi*Complex.I* + ((-cuspFrequency k*z)+starRingEnd ℂ (-cuspFrequency k*z)))) + fun_prop + have hc0 := periodDomain_integrable_of_continuous + (fun z => ((3*Real.pi:ℂ)*constantArithmeticResidue*(v:ℂ)^(2/3:ℂ))* + ShortDraftTrace.breveE (-cuspFrequency k*z)) (continuous_const.mul hphase) + have hcn := periodDomain_integrable_of_continuous + (fun z => cubicResidualNonzeroSeries (v,z)*ShortDraftTrace.breveE (-cuspFrequency k*z)) + ((cubicResidualNonzeroSeries_height_continuous v hv).mul hphase) + simp_rw [cubicResidualFunction,cubicResidualNonzeroFunction, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint,add_mul] + rw [integral_add hc0 hcn,integral_const_mul,integral_cusp_character,cubicResidualNonzeroSeries_fourier v hv k] + by_cases hk : k=0 + · simp only [ite_eq_left hk,cubicResidualModeAmplitude,mul_zero] + ring + · simp only [ite_eq_right hk,mul_zero,zero_add] + +lemma cubicResidualFunction_heightFourier (a b : ℝ) (ha : 0 cubicResidualFunction w*cuspWeightedFourierPhase ρ h w + have hg : Continuous g := cubicResidualFunction_continuous.mul (cuspWeightedFourierPhase_continuous ρ h) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg),←integral_const_mul] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hpos := ha.trans_le hv.1 + have hinner : (∫z in periodDomain,g (cuspCoordinateLift (v,z)))= + ρ v*(((9*Real.sqrt 3/2:ℝ):ℂ)*(if h=0 then + (3*Real.pi:ℂ)*constantArithmeticResidue*(v:ℂ)^(2/3:ℂ) else cubicResidualModeAmplitude v h)) := by + simp_rw [g,cuspCoordinateLift_positive v _ hpos,cuspWeightedFourierPhase, + hyperbolicHeight_upperPoint,cuspFourierPhase,hyperbolicHorizontal_upperPoint] + calc + _ = ρ v*(∫z in periodDomain,cubicResidualFunction (upperPoint z v hpos)* + ShortDraftTrace.breveE (-cuspFrequency h*z)) := by + rw [←integral_const_mul] + apply integral_congr_ae + exact Eventually.of_forall (fun z => by ring) + _ = _ := by rw [cubicResidualFunction_fourier v hpos h] + dsimp only + rw [hinner] + ring + +lemma cubicResidualFunction_period (v : ℝ) (hv : 0 F (integralOrbitProjection globalKubotaKernel w)) 2 + (hyperbolicVolume.restrict (cuspPeriodStrip a b)) := + MemLp.ae_eq (kernelCuspHeightPullback_ae a b ha F) + (MeasureTheory.Lp.memLp (kernelCuspHeightPullback a b ha F)) + +lemma kernelCuspCoordinates_memLp (a b : ℝ) (ha : 0 F (integralOrbitProjection globalKubotaKernel (cuspCoordinateLift q))) 2 + ((volume.restrict (Set.Icc a b)).prod (volume.restrict periodDomain)) := by + have hm := euclideanToHyperbolic_measurePreserving_on (positiveEuclideanStrip a b) + (positiveEuclideanStrip_measurable a b) (positiveEuclideanStrip_positive a b ha) + rw [positiveEuclideanStrip_preimage] at hm + have hF := (kernelCuspHeightPullback_memLp a b ha F).comp_measurePreserving hm + have hvol := euclideanVolume_le_heightCube_hyperbolic (positiveEuclideanStrip a b) + (positiveEuclideanStrip_measurable a b) (positiveEuclideanStrip_positive a b ha) + (max 1 b) (by positivity) (fun p hp => hp.1.2.trans (le_max_right 1 b)) + have hFE := (hF.smul_measure (c := ENNReal.ofReal ((max 1 b)^3)) ENNReal.ofReal_ne_top).mono_measure hvol + have hsplit := spatialComplexSplit_preserves_volume.restrict_preimage (s := Set.Icc a b ×ˢ periodDomain) + (measurableSet_Icc.prod periodDomain_measurable) + have hback := hsplit.symm + have hpull := hFE.comp_measurePreserving hback + simpa only [Measure.prod_restrict, Measure.volume_eq_prod, Function.comp_def, + positiveEuclideanStrip, cuspCoordinateLift] using hpull + +section ProductSections +variable {α β : Type*} [MeasurableSpace α] [MeasurableSpace β] + {«μ» : Measure α} {ν : Measure β} [SFinite «μ»] [SFinite ν] + +lemma complex_memLp_two_sections {f : α × β → ℂ} (hf : MemLp f 2 («μ».prod ν)) : + ∀ᵐx ∂«μ», MemLp (fun y => f (x,y)) 2 ν := by + filter_upwards [hf.aestronglyMeasurable.prodMk_left, + hf.norm.integrable_sq.prod_right_ae] with x hx hi + exact (memLp_two_iff_integrable_sq_norm hx).mpr hi + +end ProductSections + +lemma kernelCuspSections_memLp (a b : ℝ) (ha : 0 F (integralOrbitProjection globalKubotaKernel (cuspCoordinateLift (v,z)))) 2 + (volume.restrict periodDomain) := + complex_memLp_two_sections (kernelCuspCoordinates_memLp a b ha F) + +lemma cuspCoordinateLift_measurable : Measurable cuspCoordinateLift := + euclideanToHyperbolic_measurable.comp spatialComplexSplit.symm.measurable + +lemma kernelCuspFourierCoordinate_integrable (a b : ℝ) (ha : 0 + (F (integralOrbitProjection globalKubotaKernel (cuspCoordinateLift q))* + cuspWeightedFourierPhase ρ h (cuspCoordinateLift q))/(q.1:ℂ)^3) + (Set.Icc a b ×ˢ periodDomain) volume := by + let := periodDomain_finiteMeasure + have hF := (kernelCuspCoordinates_memLp a b ha F).integrable (by norm_num : (1:ℝ≥0∞)≤2) + have hm : Measurable (fun q : ℝ × ℂ => + cuspWeightedFourierPhase ρ h (cuspCoordinateLift q)/(q.1:ℂ)^3) := + ((cuspWeightedFourierPhase_continuous ρ h).measurable.comp cuspCoordinateLift_measurable).div + (by fun_prop) + have hb : ∀ᵐq ∂((volume.restrict (Set.Icc a b)).prod (volume.restrict periodDomain)), + ‖cuspWeightedFourierPhase ρ h (cuspCoordinateLift q)/(q.1:ℂ)^3‖≤‖ρ‖/a^3 := by + rw [Measure.prod_restrict, ←Measure.volume_eq_prod] + filter_upwards [ae_restrict_mem (measurableSet_Icc.prod periodDomain_measurable)] with q hq + have hpos : 0 + F (integralOrbitProjection globalKubotaKernel w)*cuspWeightedFourierPhase ρ h w) := + ((MeasureTheory.Lp.stronglyMeasurable F).comp_measurable (measurable_integralOrbitProjection _)).mul + (cuspWeightedFourierPhase_continuous ρ h).stronglyMeasurable + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha _ hg.aestronglyMeasurable + (kernelCuspFourierCoordinate_integrable a b ha ρ h F)] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hpos : 0 by + dsimp only + rw [cuspWeightedFourierPhase,cuspFourierPhase,cuspCoordinateLift_positive v z hpos, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + ring) + +lemma kernelCuspSliceCoefficient_integrable (a b : ℝ) (ha : 0 c/(v:ℂ)^3) + apply integral_congr_ae + exact Eventually.of_forall (fun z => by + dsimp only [kernelCuspSliceCoefficient] + rw [cuspWeightedFourierPhase,cuspFourierPhase,cuspCoordinateLift_positive v z hpos, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] + simp) + +end + +section + +open scoped BigOperators Classical +open EisensteinEmbedding (omega3) +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma third_character_eq_one_iff_basis (ψ:AddChar (Eis⧸Ideal.span {(3:Eis)}) ℂ) : + ψ=1 ↔ ψ (Ideal.Quotient.mk _ (1:Eis))=1 ∧ + ψ (Ideal.Quotient.mk _ omega)=1 := by + constructor + · rintro rfl + simp + · rintro ⟨h1,hw⟩ + ext x + obtain ⟨z,rfl⟩:=Ideal.Quotient.mk_surjective x + rw [←ActualEisensteinCoordinates.eval_coords z] + change ψ (Ideal.Quotient.mk _ + (((ActualEisensteinCoordinates.coords z).1:Eis)+ + ((ActualEisensteinCoordinates.coords z).2:Eis)*omega))=1 + rw [map_add,AddChar.map_add_eq_mul] + have hA:Ideal.Quotient.mk (Ideal.span {(3:Eis)}) + ((ActualEisensteinCoordinates.coords z).1:Eis)= + (ActualEisensteinCoordinates.coords z).1 • Ideal.Quotient.mk _ (1:Eis):=by + rw [←map_zsmul] + simp + have hB:Ideal.Quotient.mk (Ideal.span {(3:Eis)}) + (((ActualEisensteinCoordinates.coords z).2:Eis)*omega)= + (ActualEisensteinCoordinates.coords z).2 • Ideal.Quotient.mk _ omega:=by + rw [←map_zsmul] + simp only [zsmul_eq_mul] + rw [hA,hB,AddChar.map_zsmul_eq_zpow,AddChar.map_zsmul_eq_zpow,h1,hw] + simp + +lemma omega3_pow_exp_eq_one_iff (t:ℕ) (b:ℤ) : + omega3^t*Complex.exp (2*Real.pi*Complex.I*(b:ℂ)/3)=1 ↔ + (3:ℤ)∣(t:ℤ)+b := by + have hω:omega3=Complex.exp (2*Real.pi*Complex.I/3):=by + rw [←TraceLambdaPhase.exp_minus_four_pi_div_three] + apply Complex.exp_eq_exp_iff_exists_int.mpr + refine ⟨-1,?_⟩ + push_cast + ring + rw [hω,←Complex.exp_nat_mul,←Complex.exp_add] + have he:(t:ℂ)*(2*Real.pi*Complex.I/3)+2*Real.pi*Complex.I*(b:ℂ)/3= + 2*Real.pi*Complex.I*(((t:ℤ)+b:ℤ):ℂ)/3:=by push_cast;ring + rw [he] + constructor + · intro hh + have hh':Complex.exp (2*Real.pi*Complex.I*((((t:ℤ)+b:ℤ):ℂ)/3))=1:=by + convert hh using 1 ;ring_nf + obtain ⟨v,hv⟩:=GeneralPrimitiveTrace.complex_exp_trace_integer hh' + have hc:(((t:ℤ)+b:ℤ):ℂ)=3*(v:ℂ):=by linear_combination 3*hv + have hi:(t:ℤ)+b=3*v:=by exact_mod_cast hc + exact ⟨v,hi⟩ + · rintro ⟨v,hv⟩ + rw [hv] + apply Complex.exp_eq_one_iff.mpr + refine ⟨v,?_⟩ + push_cast + ring + +lemma eisEmbedding_omega_actual : eisEmbedding omega=omega3 := by + have hω:omega=ActualEisensteinCoordinates.eval 0 1:=by + simp only [ActualEisensteinCoordinates.eval,Int.cast_zero,Int.cast_one,zero_add,one_mul] + rfl + rw [hω,eisEmbedding_eval] + norm_num + +lemma trace_third_coordinate (k:Eis) : + eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates + 3 (by norm_num) (Ideal.Quotient.mk _ k)= + Complex.exp (2*Real.pi*Complex.I*((ActualEisensteinCoordinates.coords k).2:ℂ)/3) := by + rw [eisTraceModChar,IdealGaussCRT.traceModChar_mk] + have hh:=breveE_real_trace_of_O 3 k + norm_num at hh + convert hh using 1 ;simp only [map_ofNat] ;congr 1 ;ring + +end + +open scoped BigOperators Classical +open EisensteinEmbedding (omega3) +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss CubicRamified +local notation "Eis" => ActualEisensteinCubic.O + +lemma ramified_symbol_primaryCoord (u:Eisˣ) (n j:ℕ) + (hu:(u:Eis)=omega^j ∨ (u:Eis)=-(omega^j)) (A B:ℤ) : + symbol (u.val*lambda^n) (primaryCoord A B)= + (cubicExp (2*A-B))^j*(cubicExp A)^n := by + have hp:=primaryCoord_primary A B + rw [symbol_mul_numerator _ _ _ hp,symbol_pow_numerator _ _ hp, + symbol_lambda_eq_linearRay _ hp,linearRay_primaryCoord] + norm_num only [one_mul,zero_mul,add_zero] + congr 1 + rcases hu with hu|hu + · rw [hu,symbol_pow_numerator _ _ hp,symbol_omega_eq_linearRay _ hp, + linearRay_primaryCoord] + ring_nf + · rw [hu,symbol_neg_numerator _ _ hp,symbol_pow_numerator _ _ hp, + symbol_omega_eq_linearRay _ hp,linearRay_primaryCoord] + ring_nf + +lemma ramified_symbol_at_one (u:Eisˣ) (n j:ℕ) + (hu:(u:Eis)=omega^j ∨ (u:Eis)=-(omega^j)) : + symbol (u.val*lambda^n) (1+3*(1:Eis))=omega^(2*j+n) := by + have he:(1+3*(1:Eis))=primaryCoord 1 0:=by rw [primaryCoord_eq];norm_num + rw [he,ramified_symbol_primaryCoord u n j hu] + norm_num [cubicExp] + rw [←pow_mul,←pow_add] + +lemma ramified_symbol_at_omega (u:Eisˣ) (n j:ℕ) + (hu:(u:Eis)=omega^j ∨ (u:Eis)=-(omega^j)) : + symbol (u.val*lambda^n) (1+3*omega)=omega^(2*j) := by + have he:(1+3*omega)=primaryCoord 0 1:=by rw [primaryCoord_eq];norm_num + rw [he,ramified_symbol_primaryCoord u n j hu] + norm_num [cubicExp] + rw [←pow_mul] + +lemma ramifiedFrequencyChar_mk (k:Eis) (u:Eisˣ) (n:ℕ) (x:Eis) : + ramifiedFrequencyChar k u n (Ideal.Quotient.mk _ x)= + eisEmbedding (symbol (u.val*lambda^n) (1+3*x))* + eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates + 3 (by norm_num) (Ideal.Quotient.mk _ (k*x)) := by + rw [ramifiedFrequencyChar,AddChar.mul_apply,ramifiedQuotientChar, + IdealGaussCRT.quotientAddChar_mk,AddChar.mulShift_apply,←map_mul] + rfl + +lemma coords_mul_omega_second (k:Eis) : + (ActualEisensteinCoordinates.coords (k*omega)).2= + (ActualEisensteinCoordinates.coords k).1-(ActualEisensteinCoordinates.coords k).2 := by + conv_lhs => rw [←ActualEisensteinCoordinates.eval_coords k] + have hw:omega=ActualEisensteinCoordinates.eval 0 1:=by + simp only [ActualEisensteinCoordinates.eval,Int.cast_zero,Int.cast_one,zero_add,one_mul] + rfl + rw [hw,ActualEisensteinCoordinates.eval_mul,ShortDraftLatticeCount.coords_eval] + ring + +def ramifiedCongruence (k:Eis) (j n:ℕ):Prop:= + (3:ℤ)∣(2*(j:ℤ)+(n:ℤ)+(ActualEisensteinCoordinates.coords k).2) ∧ + (3:ℤ)∣(2*(j:ℤ)+(ActualEisensteinCoordinates.coords k).1- + (ActualEisensteinCoordinates.coords k).2) + +lemma ramifiedFrequencyChar_eq_one_iff (k:Eis) (u:Eisˣ) (n j:ℕ) + (hu:(u:Eis)=omega^j ∨ (u:Eis)=-(omega^j)) : + ramifiedFrequencyChar k u n=1 ↔ ramifiedCongruence k j n := by + rw [third_character_eq_one_iff_basis,ramifiedFrequencyChar_mk, + ramifiedFrequencyChar_mk,ramified_symbol_at_one u n j hu, + ramified_symbol_at_omega u n j hu,map_pow,map_pow,eisEmbedding_omega_actual, + mul_one,trace_third_coordinate,trace_third_coordinate,coords_mul_omega_second, + omega3_pow_exp_eq_one_iff,omega3_pow_exp_eq_one_iff] + unfold ramifiedCongruence + push_cast + simp only [add_sub_assoc] + +theorem ramified_arithmetic_explicit_table (h k:Eis) (u:Eisˣ) (n j:ℕ) + (hn:2≤n) (hu:(u:Eis)=omega^j ∨ (u:Eis)=-(omega^j)) + (hk:3*h=(u.val*lambda^n)*k) : + arithmeticResidueSum h (u.val*lambda^n)= + if ramifiedCongruence k j n then ((3^n:ℕ):ℂ)*residueAdditive k 3 1 else 0 := by + rw [ramified_arithmetic_character_test h k u n hn hk] + simp only [ramifiedFrequencyChar_eq_one_iff k u n j hu] + +def ramifiedUnitIndex (u:Eisˣ):Fin 3:=Classical.choose (unit_eq_sign_omega u) + +lemma ramifiedUnitIndex_spec (u:Eisˣ) : + (u:Eis)=omega^(ramifiedUnitIndex u).val ∨ + (u:Eis)=-(omega^(ramifiedUnitIndex u).val):= + Classical.choose_spec (unit_eq_sign_omega u) + +def explicitRamifiedCoefficient (h:Eis) (u:Eisˣ) (n:ℕ):ℂ:= + if hd:u.val*lambda^n∣3*h then + let k:=Classical.choose hd + if ramifiedCongruence k (ramifiedUnitIndex u).val n then + ((3^n:ℕ):ℂ)*residueAdditive k 3 1 else 0 + else 0 + +theorem arithmeticResidueSum_eq_explicitRamifiedCoefficient (h:Eis) (u:Eisˣ) + (n:ℕ) (hn:2≤n) : + arithmeticResidueSum h (u.val*lambda^n)=explicitRamifiedCoefficient h u n := by + unfold explicitRamifiedCoefficient + split_ifs with hd + · exact ramified_arithmetic_explicit_table h (Classical.choose hd) u n + (ramifiedUnitIndex u).val hn (ramifiedUnitIndex_spec u) (Classical.choose_spec hd) + · by_contra hne + exact hd (ramified_arithmetic_support h u n hn hne) + +theorem scatteringCoefficient_explicit_ramified (s:ℂ) (hs:2 c*cuspSeedProfile a b s (rowHeight u q)) p- + s*(s-2)*(c*cuspSeedProfile a b s (rowHeight u p))= + c*cuspSeedDefectProfile a b s (rowHeight u p) := by + rw [axisLaplacian_const_mul,rowProfile_laplacian _ (cuspSeedProfile_contDiffAt a b s) u hu p hp] + have h := cuspSeedProfile_laplace_defect a b s (rowHeight u p) (rowHeight_pos u hu p hp).ne' + linear_combination c*h + +theorem heightPoincare_cuspSeed_laplace_defect (a b : ℝ) (s : ℂ) (ha : 1 (cosetCharacter r)⁻¹*cuspSeedProfile a b s (rowHeight (embeddedRow r) q) + have heq : heightPoincareField (cuspSeedProfile a b s) =ᶠ[𝓝 p] (fun q => ∑r∈S,f r q) := by + filter_upwards [hU.mem_nhds hpU] with q hq + apply tsum_eq_sum + intro r hr + rw [cuspSeedProfile_zero a b s _ hab (le_trans ((hrows q hq).2 r hr).le ha.le),mul_zero] + have hD : heightPoincareField (cuspSeedDefectProfile a b s) p= + ∑r∈S,(cosetCharacter r)⁻¹*cuspSeedDefectProfile a b s (rowHeight (embeddedRow r) p) := by + apply tsum_eq_sum + intro r hr + rw [cuspSeedDefectProfile_zero a b s _ hab (Or.inl (((hrows p hpU).2 r hr).trans ha)),mul_zero] + have hreg : ∀r∈S,∀q,0 (cosetCharacter r)⁻¹*cuspSeedProfile a b s v) v := + fun v hv => contDiffAt_const.mul (cuspSeedProfile_contDiffAt a b s v hv) + have h := rowProfile_axis_derivatives _ hc (embeddedRow r) (embeddedRow_ne_zero r) q hq j + exact ⟨h.1.differentiableAt,h.2.differentiableAt⟩ + rw [axisLaplacian_congr_eventuallyEq _ _ p heq,axisLaplacian_finset_sum S f hreg p hp, + heq.eq_of_nhds,hD,Finset.mul_sum,← Finset.sum_sub_distrib] + apply Finset.sum_congr rfl + intro r hr + exact cuspSeed_row_defect a b s (cosetCharacter r)⁻¹ (embeddedRow r) (embeddedRow_ne_zero r) p hp + +def smoothCuspSeedField (a b : ℝ) (s : ℂ) (p : SpatialCoordinates) : ℂ := + if hp : 0

smoothCuspSeedField_eq a b s ha hab q hq) p hp, + smoothCuspSeedField_eq a b s ha hab p hp,smoothCuspSeedDefectField_eq a b s ha hab p hp] + exact heightPoincare_cuspSeed_laplace_defect a b s ha hab p hp + +lemma cuspSeedProfile_entire (a b v : ℝ) : Differentiable ℂ (fun s => cuspSeedProfile a b s v) := by + unfold cuspSeedProfile positiveHeightPower logRatioPower + fun_prop +lemma cuspSeedDefectProfile_entire (a b v : ℝ) : Differentiable ℂ (fun s => cuspSeedDefectProfile a b s v) := by + unfold cuspSeedDefectProfile positiveHeightPower logRatioPower + fun_prop + +lemma cuspCutoffCorrection_parameter_entire (F : ℂ → ℝ → ℂ) + (hF : ∀v,Differentiable ℂ (fun s => F s v)) (w : HyperbolicSpace) : + Differentiable ℂ (fun s => cuspCutoffCorrection 1 (F s) w) := by + let S := (high_cosets_finite 1 le_rfl w).toFinset + have heq : (fun s => cuspCutoffCorrection 1 (F s) w)= + (fun s => ∑r∈S,cuspCutoffTerm 1 (F s) r w) := by + funext s + apply tsum_eq_sum + intro r hr + have hh : ¬1 smoothCuspSeed a b s w) := + cuspCutoffCorrection_parameter_entire _ (cuspSeedProfile_entire a b) w + +theorem smoothCuspSeedDefect_entire (a b : ℝ) (w : HyperbolicSpace) : + Differentiable ℂ (fun s => smoothCuspSeedDefect a b s w) := + cuspCutoffCorrection_parameter_entire _ (cuspSeedDefectProfile_entire a b) w + +end CubicEisenstein + +open scoped BigOperators Classical SchwartzMap +namespace CanonicalQuadraticSieve + +section +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge EisensteinSchwartzPoisson CompletedGauss +open TruncatedPrincipalPoisson IdealMobiusDivisorSum + +def sectorBadIdeal (E : fixedBadPrimes.powerset) : Ideal O := ∏ P ∈ E.val, P + +theorem sector_bad_good_product (I : Ideal O) (hI : Squarefree I) + (E : fixedBadPrimes.powerset) (hE : badPrimeSector I = E) : + sectorBadIdeal E * goodSquarefreePart I = I := by + have hs : badPrimeSupport I = E.val := congrArg Subtype.val hE + simpa only [hs, sectorBadIdeal] using squarefree_bad_good_product I hI + +theorem sectorBadIdeal_ne_zero_of_row (I : Ideal O) (hI : Squarefree I) + (E : fixedBadPrimes.powerset) (hE : badPrimeSector I = E) : sectorBadIdeal E ≠ 0 := by + intro hz + have hp := sector_bad_good_product I hI E hE + rw [hz, zero_mul] at hp + exact hI.ne_zero hp.symm + +variable {m n p : Type} [Fintype m] [Fintype n] [Fintype p] + [DecidableEq m] [DecidableEq n] [DecidableEq p] + +def unrestrictedPairTerm (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (i : m) (j : n) (k : p) : ℂ := + if IsCoprime (left j) (right k) then + star (a j) * b k * unrestrictedPairCharacter (left j) (right k) (rows i) else 0 + +omit [Fintype m] [Fintype n] [Fintype p] [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem unrestrictedPairTerm_sector (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) + (hrows : ∀ i, Squarefree (rows i)) (hleft : ∀ j, Admissible (left j)) (hright : ∀ k, Admissible (right k)) + (hray : ∀ j k, columnRay (left j) = columnRay (right k)) + (E : fixedBadPrimes.powerset) (hE : ∀ i, badPrimeSector (rows i) = E) (i : m) (j : n) (k : p) : + unrestrictedPairTerm rows left right a b i j k = + originalTerm (fun i => goodSquarefreePart (rows i)) left right + (fun j => a j * quadraticRow (left j) (idealGenerator (sectorBadIdeal E))) + (fun k => b k * quadraticRow (right k) (idealGenerator (sectorBadIdeal E))) 1 1 i j k := by + classical + by_cases hc : IsCoprime (left j) (right k) + · simp only [unrestrictedPairTerm, originalTerm, hc, ite_true, one_dvd] + have hp := unrestrictedPairCharacter_squarefree_bad_split (left j) (right k) (rows i) + (hleft j) (hright k) (hray j k) (hrows i) + have hs : badPrimeSupport (rows i) = E.val := congrArg Subtype.val (hE i) + rw [hp, hs] + simp only [sectorBadIdeal, unrestrictedPairCharacter, star_mul, + canonical_quadraticRow_star _ (hleft j)] + ring + · simp only [unrestrictedPairTerm, originalTerm, hc, ite_false] + +def unrestrictedDualTruncatedMiddle (W : 𝓢(ℝ, ℂ)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (M F : ℝ) (Y Z : m → ℝ) (lengthScale : ℝ) : ℂ := + ∑ i, ∑ j, ∑ k, unrestrictedPairTerm rows left right a b i j k * + (((M / (Real.sqrt ((Ideal.absNorm (left j) : ℝ) * (Ideal.absNorm (right k) : ℝ)) * F) : ℝ) : ℂ) * + middleTruncation (fun P : primePool {left j * right k} => P.val) Finset.univ W + (Real.sqrt (F * (Ideal.absNorm (left j) : ℝ) * (Ideal.absNorm (right k) : ℝ) / + (M * (Ideal.absNorm (rows i) : ℝ)))) (Y i) (Z i) lengthScale) + +omit [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem unrestrictedDualTruncatedMiddle_sector + (W : 𝓢(ℝ, ℂ)) (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (M F : ℝ) (Y Z : m → ℝ) (lengthScale : ℝ) + (hrows : ∀ i, Squarefree (rows i)) (hleft : ∀ j, Admissible (left j)) (hright : ∀ k, Admissible (right k)) + (hray : ∀ j k, columnRay (left j) = columnRay (right k)) + (E : fixedBadPrimes.powerset) (hE : ∀ i, badPrimeSector (rows i) = E) + (hQ : sectorBadIdeal E ≠ 0) : + unrestrictedDualTruncatedMiddle W rows left right a b M F Y Z lengthScale = + ((1 / (Ideal.absNorm (sectorBadIdeal E) : ℝ) : ℝ) : ℂ) * + dualTruncatedMiddle W (fun i => goodSquarefreePart (rows i)) left right + (fun j => a j * quadraticRow (left j) (idealGenerator (sectorBadIdeal E))) + (fun k => b k * quadraticRow (right k) (idealGenerator (sectorBadIdeal E))) + (M * (Ideal.absNorm (sectorBadIdeal E) : ℝ)) F Y Z lengthScale := by + classical + have hQn : (Ideal.absNorm (sectorBadIdeal E) : ℝ) ≠ 0 := by + exact_mod_cast (show Ideal.absNorm (sectorBadIdeal E) ≠ 0 from fun h => hQ (Ideal.absNorm_eq_zero_iff.mp h)) + unfold unrestrictedDualTruncatedMiddle dualTruncatedMiddle + simp only [Finset.mul_sum] + apply Finset.sum_congr rfl + intro i hi + apply Finset.sum_congr rfl + intro j hj + apply Finset.sum_congr rfl + intro k hk + rw [unrestrictedPairTerm_sector rows left right a b hrows hleft hright hray E hE i j k] + have hn : (Ideal.absNorm (rows i) : ℝ) = + (Ideal.absNorm (sectorBadIdeal E) : ℝ) * (Ideal.absNorm (goodSquarefreePart (rows i)) : ℝ) := by + calc + (Ideal.absNorm (rows i) : ℝ) = + (Ideal.absNorm (sectorBadIdeal E * goodSquarefreePart (rows i)) : ℝ) := + congrArg (fun I : Ideal O => (Ideal.absNorm I : ℝ)) + (sector_bad_good_product (rows i) (hrows i) E (hE i)).symm + _ = _ := by rw [map_mul, Nat.cast_mul] + rw [hn] + have harg : F * (Ideal.absNorm (left j) : ℝ) * (Ideal.absNorm (right k) : ℝ) / + (M * ((Ideal.absNorm (sectorBadIdeal E) : ℝ) * (Ideal.absNorm (goodSquarefreePart (rows i)) : ℝ))) = + F * (Ideal.absNorm (left j) : ℝ) * (Ideal.absNorm (right k) : ℝ) / + ((M * (Ideal.absNorm (sectorBadIdeal E) : ℝ)) * (Ideal.absNorm (goodSquarefreePart (rows i)) : ℝ)) := by ring + rw [harg] + have hs : (M / (Real.sqrt ((Ideal.absNorm (left j) : ℝ) * (Ideal.absNorm (right k) : ℝ)) * F) : ℝ) = + (1 / (Ideal.absNorm (sectorBadIdeal E) : ℝ)) * + ((M * (Ideal.absNorm (sectorBadIdeal E) : ℝ)) / + (Real.sqrt ((Ideal.absNorm (left j) : ℝ) * (Ideal.absNorm (right k) : ℝ)) * F)) := by + field_simp [hQn] + rw [hs, Complex.ofReal_mul] + ring + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge EisensteinSchwartzPoisson CompletedGauss + +lemma divisorEnergyFactor_mono_coefficients {n p : Type*} [Fintype n] [Fintype p] + (ε : ℝ) (hε : 0 < ε) (N : ℝ) (a a' : n → ℂ) (b b' : p → ℂ) + (ha : ∀ j, ‖a' j‖ ≤ ‖a j‖) (hb : ∀ k, ‖b' k‖ ≤ ‖b k‖) : + divisorEnergyFactor ε hε N a' b' ≤ divisorEnergyFactor ε hε N a b := by + have hA : (∑ j, ‖a' j‖ ^ 2) ≤ ∑ j, ‖a j‖ ^ 2 := + Finset.sum_le_sum (fun j _ => pow_le_pow_left₀ (norm_nonneg _) (ha j) _) + have hB : (∑ k, ‖b' k‖ ^ 2) ≤ ∑ k, ‖b k‖ ^ 2 := + Finset.sum_le_sum (fun k _ => pow_le_pow_left₀ (norm_nonneg _) (hb k) _) + have hs := (IdealCoprimeSieveOperator.supportConstant_pos ε hε).le + have hd := (DivisorBlockCauchy.divisorConstant_pos ε hε).le + unfold divisorEnergyFactor + gcongr + +lemma dual_bad_sector_scale (M F B Q U α : ℝ) + (hM : 0 < M) (hF : 0 < F) (hB : 0 ≤ B) (hQ : 1 ≤ Q) + (hU : 0 ≤ U) (hα : 1 / 2 ≤ α) : + (1 / Q) * (M * Q / F + (2 * U) * Real.sqrt (M * Q / F) * (B / Q) ^ (α - 1 / 2)) ≤ + M / F + (2 * U) * Real.sqrt (M / F) * B ^ (α - 1 / 2) := by + have hQp : 0 < Q := by linarith + have hpow : (B / Q) ^ (α - 1 / 2) ≤ B ^ (α - 1 / 2) := + Real.rpow_le_rpow (by positivity) (div_le_self hB hQ) (by linarith) + have hsQ : Real.sqrt Q ≤ Q := Real.sqrt_le_self_iff.mpr (Or.inr hQ) + have hs : (1 / Q) * Real.sqrt (M * Q / F) ≤ Real.sqrt (M / F) := by + have he : M * Q / F = (M / F) * Q := by ring + rw [he, Real.sqrt_mul (by positivity)] + have ht : Real.sqrt Q / Q ≤ 1 := (div_le_one hQp).mpr hsQ + calc + _ = Real.sqrt (M / F) * (Real.sqrt Q / Q) := by ring + _ ≤ Real.sqrt (M / F) * 1 := mul_le_mul_of_nonneg_left ht (Real.sqrt_nonneg _) + _ = _ := mul_one _ + calc + _ = M / F + (2 * U) * ((1 / Q) * Real.sqrt (M * Q / F)) * (B / Q) ^ (α - 1 / 2) := by + field_simp + + _ ≤ _ := by gcongr + +def dualMiddleMajorant {n p : Type} [Fintype n] [Fintype p] + {α : ℝ} (hexp : HasSieveExponent α) (deltaLoss : ℝ) (hδ : 0 < deltaLoss) + (ε : ℝ) (hε : 0 < ε) (B N M F U : ℝ) (a : n → ℂ) (b : p → ℂ) (W : 𝓢(ℝ, ℂ)) : ℝ := + ((columnDyadicLength N + 1 : ℕ) : ℝ) ^ 2 * + ((2 * nonzeroLatticeEnvelopeConstant * dualMiddleDecayConstant W) * + divisorEnergyFactor ε hε N a b * (divisorExponentConstant hexp deltaLoss hδ * (B * N) ^ deltaLoss) * + (M / F + (2 * U) * Real.sqrt (M / F) * B ^ (α - 1 / 2))) + +lemma dualMiddleMajorant_nonneg {n p : Type} [Fintype n] [Fintype p] + {α : ℝ} (hexp : HasSieveExponent α) (deltaLoss : ℝ) (hδ : 0 < deltaLoss) + (ε : ℝ) (hε : 0 < ε) (B N M F U : ℝ) (a : n → ℂ) (b : p → ℂ) (W : 𝓢(ℝ, ℂ)) + (hB : 0 ≤ B) (hN : 0 ≤ N) (hM : 0 ≤ M) (hF : 0 ≤ F) (hU : 0 ≤ U) : + 0 ≤ dualMiddleMajorant hexp deltaLoss hδ ε hε B N M F U a b W := by + have hc := nonzeroLatticeEnvelopeConstant_nonneg + have hW := dualMiddleDecayConstant_nonneg W + have he := divisorEnergyFactor_nonneg ε hε N a b + have hd := (divisorExponentConstant_pos hexp deltaLoss hδ).le + unfold dualMiddleMajorant + positivity + +variable {m n p : Type} [Fintype m] [Fintype n] [Fintype p] + [DecidableEq m] [DecidableEq n] [DecidableEq p] + +theorem HasSieveExponent.dual_truncated_middle_sector {α : ℝ} (hexp : HasSieveExponent α) + (hα : 1 / 2 ≤ α) (deltaLoss : ℝ) (hδ : 0 < deltaLoss) (ε : ℝ) (hε : 0 < ε) + (B N M F U : ℝ) (hB : 1 ≤ B) (hN : 1 ≤ N) (hM : 0 < M) (hF : 0 < F) (hU : 0 ≤ U) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (hr : Function.Injective rows) (hl : Function.Injective left) (hri : Function.Injective right) + (hrows : ∀ i, Squarefree (rows i) ∧ B / 2 ≤ (Ideal.absNorm (rows i) : ℝ) ∧ (Ideal.absNorm (rows i) : ℝ) ≤ B) + (a : n → ℂ) (b : p → ℂ) (W : 𝓢(ℝ, ℂ)) (Y Z : m → ℝ) (lengthScale : ℝ) + (hleft : ∀ j, Admissible (left j) ∧ N / 2 ≤ (Ideal.absNorm (left j) : ℝ) ∧ (Ideal.absNorm (left j) : ℝ) ≤ N) + (hright : ∀ k, Admissible (right k) ∧ N / 2 ≤ (Ideal.absNorm (right k) : ℝ) ∧ (Ideal.absNorm (right k) : ℝ) ≤ N) + (hray : ∀ j k, columnRay (left j) = columnRay (right k)) + (hZ : ∀ i, Z i ≤ U * (N * Real.sqrt (F / (M * (Ideal.absNorm (rows i) : ℝ))))) + (E : fixedBadPrimes.powerset) (hE : ∀ i, badPrimeSector (rows i) = E) : + ‖unrestrictedDualTruncatedMiddle W rows left right a b M F Y Z lengthScale‖ ≤ + dualMiddleMajorant hexp deltaLoss hδ ε hε B N M F U a b W := by + classical + cases isEmpty_or_nonempty m with + | inl hempty => + let := hempty + simp only [unrestrictedDualTruncatedMiddle, Finset.univ_eq_empty, Finset.sum_empty, norm_zero] + exact dualMiddleMajorant_nonneg hexp deltaLoss hδ ε hε B N M F U a b W (by linarith) (by linarith) hM.le hF.le hU + | inr hnonempty => + let := hnonempty + let i₀ : m := Classical.choice hnonempty + let Q : ℝ := Ideal.absNorm (sectorBadIdeal E) + let good := fun i => goodSquarefreePart (rows i) + let a' := fun j => a j * quadraticRow (left j) (idealGenerator (sectorBadIdeal E)) + let b' := fun k => b k * quadraticRow (right k) (idealGenerator (sectorBadIdeal E)) + have hQnz := sectorBadIdeal_ne_zero_of_row (rows i₀) (hrows i₀).1 E (hE i₀) + have hQ : 1 ≤ Q := by + dsimp only [Q] + exact_mod_cast (Nat.one_le_iff_ne_zero.mpr (fun h => hQnz (Ideal.absNorm_eq_zero_iff.mp h))) + have hQp : 0 < Q := by linarith + have hn (i : m) : (Ideal.absNorm (rows i) : ℝ) = Q * (Ideal.absNorm (good i) : ℝ) := by + have hi := congrArg (fun I : Ideal O => (Ideal.absNorm I : ℝ)) + (sector_bad_good_product (rows i) (hrows i).1 E (hE i)) + simpa only [map_mul, Nat.cast_mul] using hi.symm + have hgr : Function.Injective good := by + intro i k h + exact hr (goodSquarefreePart_injective_on_sector _ _ (hrows i).1 (hrows k).1 + ((hE i).trans (hE k).symm) h) + have hg (i : m) : Admissible (good i) ∧ (B / Q) / 2 ≤ (Ideal.absNorm (good i) : ℝ) ∧ + (Ideal.absNorm (good i) : ℝ) ≤ B / Q := by + refine ⟨goodSquarefreePart_admissible _, ?_, ?_⟩ + · rw [show B / Q / 2 = (B / 2) / Q by ring] + apply (div_le_iff₀ hQp).2 + have hx := (hrows i).2.1 + rw [hn i] at hx + nlinarith + · exact (le_div_iff₀ hQp).2 (by simpa only [mul_comm] using (hn i).symm.trans_le (hrows i).2.2) + have hBQ : 1 ≤ B / Q := by + have hh : 1 ≤ (Ideal.absNorm (good i₀) : ℝ) := by + exact_mod_cast (Nat.one_le_iff_ne_zero.mpr (fun h => (hg i₀).1.1 (Ideal.absNorm_eq_zero_iff.mp h))) + exact hh.trans (hg i₀).2.2 + have hZa (i : m) : Z i ≤ U * (N * Real.sqrt (F / ((M * Q) * (Ideal.absNorm (good i) : ℝ)))) := by + simpa only [hn i, mul_assoc] using hZ i + have hbnd := hexp.dual_truncated_middle deltaLoss hδ ε hε (B / Q) N (M * Q) F U hBQ hN + (by positivity) hF hU good left right hgr hl hri hg a' b' W Y Z lengthScale hleft hright hZa + change ‖dualTruncatedMiddle W good left right a' b' (M * Q) F Y Z lengthScale‖ ≤ + dualMiddleMajorant hexp deltaLoss hδ ε hε (B / Q) N (M * Q) F U a' b' W at hbnd + have htr := unrestrictedDualTruncatedMiddle_sector W rows left right a b M F Y Z lengthScale + (fun i => (hrows i).1) (fun j => (hleft j).1) (fun k => (hright k).1) hray E hE hQnz + change unrestrictedDualTruncatedMiddle W rows left right a b M F Y Z lengthScale = + ((1 / Q : ℝ) : ℂ) * dualTruncatedMiddle W good left right a' b' (M * Q) F Y Z lengthScale at htr + rw [htr, norm_mul, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≤ 1 / Q)] + apply (mul_le_mul_of_nonneg_left hbnd (by positivity)).trans + have hae (j : n) : ‖a' j‖ ≤ ‖a j‖ := by + dsimp only [a']; rw [norm_mul] + exact mul_le_of_le_one_right (norm_nonneg _) (quadraticRow_norm_le_one _ _) + have hbe (k : p) : ‖b' k‖ ≤ ‖b k‖ := by + dsimp only [b']; rw [norm_mul] + exact mul_le_of_le_one_right (norm_nonneg _) (quadraticRow_norm_le_one _ _) + have he := divisorEnergyFactor_mono_coefficients ε hε N a a' b b' hae hbe + have hp : ((B / Q) * N) ^ deltaLoss ≤ (B * N) ^ deltaLoss := by + apply Real.rpow_le_rpow (by positivity) _ hδ.le + exact mul_le_mul_of_nonneg_right (div_le_self (by linarith) hQ) (by linarith) + have hs := dual_bad_sector_scale M F B Q U α hM hF (by linarith) hQ hU hα + have hc := nonzeroLatticeEnvelopeConstant_nonneg + have hW := dualMiddleDecayConstant_nonneg W + have hea := divisorEnergyFactor_nonneg ε hε N a' b' + have heb := divisorEnergyFactor_nonneg ε hε N a b + have hd := (divisorExponentConstant_pos hexp deltaLoss hδ).le + unfold dualMiddleMajorant + calc + _ = ((columnDyadicLength N + 1 : ℕ) : ℝ) ^ 2 * + ((2 * nonzeroLatticeEnvelopeConstant * dualMiddleDecayConstant W) * + divisorEnergyFactor ε hε N a' b' * (divisorExponentConstant hexp deltaLoss hδ * ((B / Q) * N) ^ deltaLoss) * + ((1 / Q) * (M * Q / F + (2 * U) * Real.sqrt (M * Q / F) * (B / Q) ^ (α - 1 / 2)))) := by ring + _ ≤ _ := by gcongr + +end + +open ActualEisensteinCubic ConcreteTraceCRT ConcretePrimeRowBridge EisensteinSchwartzPoisson CompletedGauss + +variable {m n p : Type} [Fintype m] [Fintype n] [Fintype p] + [DecidableEq m] [DecidableEq n] [DecidableEq p] + +theorem HasSieveExponent.unrestricted_dual_truncated_middle {α : ℝ} (hexp : HasSieveExponent α) + (hα : 1 / 2 ≤ α) (deltaLoss : ℝ) (hδ : 0 < deltaLoss) (ε : ℝ) (hε : 0 < ε) + (B N M F U : ℝ) (hB : 1 ≤ B) (hN : 1 ≤ N) (hM : 0 < M) (hF : 0 < F) (hU : 0 ≤ U) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (hr : Function.Injective rows) (hl : Function.Injective left) (hri : Function.Injective right) + (hrows : ∀ i, Squarefree (rows i) ∧ B / 2 ≤ (Ideal.absNorm (rows i) : ℝ) ∧ (Ideal.absNorm (rows i) : ℝ) ≤ B) + (a : n → ℂ) (b : p → ℂ) (W : 𝓢(ℝ, ℂ)) (Y Z : m → ℝ) (lengthScale : ℝ) + (hleft : ∀ j, Admissible (left j) ∧ N / 2 ≤ (Ideal.absNorm (left j) : ℝ) ∧ (Ideal.absNorm (left j) : ℝ) ≤ N) + (hright : ∀ k, Admissible (right k) ∧ N / 2 ≤ (Ideal.absNorm (right k) : ℝ) ∧ (Ideal.absNorm (right k) : ℝ) ≤ N) + (hray : ∀ j k, columnRay (left j) = columnRay (right k)) + (hZ : ∀ i, Z i ≤ U * (N * Real.sqrt (F / (M * (Ideal.absNorm (rows i) : ℝ))))) : + ‖unrestrictedDualTruncatedMiddle W rows left right a b M F Y Z lengthScale‖ ≤ + 4 * dualMiddleMajorant hexp deltaLoss hδ ε hε B N M F U a b W := by + classical + let σ := fun i => badPrimeSector (rows i) + have hs : unrestrictedDualTruncatedMiddle W rows left right a b M F Y Z lengthScale = + ∑ E : fixedBadPrimes.powerset, + unrestrictedDualTruncatedMiddle W (fun i : {i // σ i = E} => rows i.val) + left right a b M F (fun i => Y i.val) (fun i => Z i.val) lengthScale := by + unfold unrestrictedDualTruncatedMiddle + exact (Fintype.sum_fiberwise σ _).symm + have hb (E : fixedBadPrimes.powerset) : + ‖unrestrictedDualTruncatedMiddle W (fun i : {i // σ i = E} => rows i.val) + left right a b M F (fun i => Y i.val) (fun i => Z i.val) lengthScale‖ ≤ + dualMiddleMajorant hexp deltaLoss hδ ε hε B N M F U a b W := by + apply hexp.dual_truncated_middle_sector hα deltaLoss hδ ε hε B N M F U hB hN hM hF hU + (fun i : {i // σ i = E} => rows i.val) left right + (fun i k h => Subtype.ext (hr h)) hl hri (fun i => hrows i.val) a b W + (fun i => Y i.val) (fun i => Z i.val) lengthScale hleft hright hray (fun i => hZ i.val) E + exact fun i => i.property + rw [hs] + calc + _ ≤ ∑ E : fixedBadPrimes.powerset, + ‖unrestrictedDualTruncatedMiddle W (fun i : {i // σ i = E} => rows i.val) + left right a b M F (fun i => Y i.val) (fun i => Z i.val) lengthScale‖ := norm_sum_le _ _ + _ ≤ ∑ _E : fixedBadPrimes.powerset, dualMiddleMajorant hexp deltaLoss hδ ε hε B N M F U a b W := + Finset.sum_le_sum (fun E _ => hb E) + _ = _ := by + simp only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul, Fintype.card_coe, + fixedBadPrimes_powerset_card] + norm_num + +end CanonicalQuadraticSieve + +open scoped BigOperators Classical +namespace SecondPassArithmetic +open ActualEisensteinCubic + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + +theorem secondChildColumn_fixed_mask (Ψ : O →* ℂ) (m g f y : O) + (H : Finset ι → ℂ) (U : Finset ι) : + secondChildColumn p hp hcop hg Ψ (m*g) f y H U = + rowCoprimeMask (fun i => Ideal.span {p i}) U g * secondChildColumn p hp hcop hg Ψ m f y H U := by + simp only [secondChildColumn,FirstPassCubeLabels.mask_mul _ hg U m g] + ring + +theorem fixedChildRow_fixed_pool + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (F A : Finset ι) (Ψ : O →* ℂ) (m : O) (H : Finset ι → ℂ) (f y : O) : + fixedChildRow p hp hcop hg (F\A) Ψ m H f y = + fixedChildRow p hp hcop hg F Ψ (m*∏ i ∈ A,p i) H f y := by + unfold fixedChildRow + rw [sum_remove_common_pool p hg hinj F A] + apply Finset.sum_congr rfl + intro U hU + exact (secondChildColumn_fixed_mask p hp hcop hg Ψ m _ f y H U).symm + +end SecondPassArithmetic + +namespace SecondPassIntegration +open ActualEisensteinCubic SecondPassArithmetic +section +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) +include hinj + +theorem childEnergy_fixed_pool (F A : Finset ι) (Ψ : O →* ℂ) (m : O) + (T : Finset (Ideal O × O)) (V : ℝ → ℂ) (X : ℝ) (negative rowNegative : Bool) (a b : ℝ) : + childEnergy p hp hcop hg (F\A) Ψ m T V X negative rowNegative a b = + childEnergy p hp hcop hg F Ψ (m*∏ i ∈ A,p i) T V X negative rowNegative a b := by + simp only [childEnergy,idealChildRow,fixedChildRow_fixed_pool p hp hcop hg hinj] + +theorem childGeometricMean_fixed_pool (F A : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) + (T : Finset (Ideal O × O)) (V₁ V₂ : ℝ → ℂ) (X₁ X₂ : ℝ) (q : JointLogSeparation.Frequency) : + childGeometricMean p hp hcop hg (F\A) Ψ₁ Ψ₂ m T V₁ V₂ X₁ X₂ q = + childGeometricMean p hp hcop hg F Ψ₁ Ψ₂ (m*∏ i ∈ A,p i) T V₁ V₂ X₁ X₂ q := by + simp only [childGeometricMean,childEnergy_fixed_pool p hp hcop hg hinj] + +theorem densityChildEnergy_fixed_pool (F A : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m : O) + (T : Finset (Ideal O × O)) (V₁ V₂ : ℝ → ℂ) (X₁ X₂ : ℝ) (J : ℕ) : + densityChildEnergy p hp hcop hg (F\A) Ψ₁ Ψ₂ m T V₁ V₂ X₁ X₂ J = + densityChildEnergy p hp hcop hg F Ψ₁ Ψ₂ (m*∏ i ∈ A,p i) T V₁ V₂ X₁ X₂ J := by + simp only [densityChildEnergy,childGeometricMean_fixed_pool p hp hcop hg hinj] + +end + +open ConcreteTraceCRT (eisEmbedding) +open FirstPassCubeLabels (primeProductNorm) + +theorem restored_child_mask_norm {ι : Type*} [DecidableEq ι] + (p : ι → O) [∀ i, (Ideal.span {p i}).IsMaximal] + (m b0 : O) (R A : Finset ι) : + ‖eisEmbedding ((m*b0*primeSubsetGenerator (fun i => Ideal.span {p i}) R)*∏ i ∈ A,p i)‖^2 = + ‖eisEmbedding m‖^2*‖eisEmbedding b0‖^2*primeProductNorm p R*primeProductNorm p A := by + simp only [map_mul,norm_mul,mul_pow,SecondPassArithmetic.primeSubsetGenerator_norm_eq_productNorm, + primeProductNorm] + +end SecondPassIntegration + +open scoped BigOperators Classical +namespace SecondPassArithmetic +open ActualEisensteinCubic +open FirstPassCubeLabels (primeProduct primeProductNorm squarefreeLabel jLabel j2Label b0Label + bit parity conductorExponent cubeActiveSupport) +open ConcreteTraceCRT (eisEmbedding) + +lemma element_norm_le_of_dvd {a b : O} (hb : b ≠ 0) (h : a ∣ b) : + ‖eisEmbedding a‖^2 ≤ ‖eisEmbedding b‖^2 := by + obtain ⟨c,rfl⟩ := h + have hc : c ≠ 0 := (mul_ne_zero_iff.mp hb).2 + rw [map_mul, norm_mul, mul_pow] + exact le_mul_of_one_le_right (sq_nonneg _) (element_norm_ge_one c hc) + +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + +include hp in +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +lemma primeProduct_ne_zero (B : Finset ι) (v : ι → ℕ) : primeProduct p B v ≠ 0 := + Finset.prod_ne_zero_iff.mpr (fun i _hi => pow_ne_zero _ (hp i)) + +include hp in +omit [∀ (i : ι), (span {p i}).IsMaximal] in +lemma squarefreeLabel_active_bound (B : Finset ι) (v : ι → ℕ) (ε₁ ε₂ : ι → Bool) : + ‖eisEmbedding (squarefreeLabel p B v)‖^2 ≤ primeProductNorm p (cubeActiveSupport B v ε₁ ε₂) := by + let S := B.filter (fun i => parity (v i)) + have he : squarefreeLabel p B v = ∏ i ∈ S, p i := by + unfold squarefreeLabel primeProduct S + rw [Finset.prod_filter] + apply Finset.prod_congr rfl + intro i hi + cases hb : parity (v i) <;> simp [bit,hb] + have hsub : S ⊆ cubeActiveSupport B v ε₁ ε₂ := by + intro i hi + obtain ⟨hi,hpi⟩ := Finset.mem_filter.mp hi + apply Finset.mem_filter.mpr + refine ⟨hi,?_⟩ + change parity (v i) = true at hpi + rw [hpi] + cases h1 : ε₁ i <;> cases h2 : ε₂ i <;> decide + rw [he] + exact primeProductNorm_mono p hp hsub + +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +lemma jLabel_dvd_cube_product (B : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) : + jLabel p B (fun i => v₁ i+v₂ i) ε₁ ε₂ ∣ primeProduct p B v₁ * primeProduct p B v₂ := by + rw [← primeProduct_add] + apply Finset.prod_dvd_prod_of_dvd + intro i hi + apply pow_dvd_pow + dsimp only + unfold bit + split <;> have h := hv i hi <;> omega + +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +lemma b0_square_dvd_cube_product (B : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) : + b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂ ^ 2 ∣ primeProduct p B v₁ * primeProduct p B v₂ := by + rw [FirstPassCubeLabels.cube_pair_product_decomposition p B v₁ v₂ ε₁ ε₂ hv] + exact dvd_mul_of_dvd_left (dvd_mul_right _ _) _ + +omit [DecidableEq ι] [∀ (i : ι), (span {p i}).IsMaximal] in +lemma b0_jLabel_square (B : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) : + (b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂ * jLabel p B (fun i => v₁ i+v₂ i) ε₁ ε₂)^2 = + primeProduct p B v₁ * primeProduct p B v₂ * squarefreeLabel p B (fun i => v₁ i+v₂ i) := by + rw [FirstPassCubeLabels.jLabel_eq_squarefree_mul_j2, + FirstPassCubeLabels.cube_pair_product_decomposition p B v₁ v₂ ε₁ ε₂ hv] + ring + +include hp in + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem cube_label_norm_bounds (B : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (hv : ∀ i ∈ B, 0 < v₁ i+v₂ i) (B₀ : ℝ) (hB : 0 ≤ B₀) + (hb₁ : ‖eisEmbedding (primeProduct p B v₁)‖^2 ≤ B₀) + (hb₂ : ‖eisEmbedding (primeProduct p B v₂)‖^2 ≤ B₀) : + let v := fun i => v₁ i+v₂ i + ‖eisEmbedding (jLabel p B v ε₁ ε₂)‖^2 ≤ B₀^2 ∧ + ‖eisEmbedding (b0Label p B v ε₁ ε₂)‖^2 ≤ B₀ ∧ + ‖eisEmbedding (b0Label p B v ε₁ ε₂)‖^2 ≤ + B₀*‖eisEmbedding (∏ i ∈ cubeActiveSupport B v ε₁ ε₂,p i)‖ / + ‖eisEmbedding (jLabel p B v ε₁ ε₂)‖^2 := by + dsimp only + have hbb : ‖eisEmbedding (primeProduct p B v₁ * primeProduct p B v₂)‖^2 ≤ B₀^2 := by + rw [map_mul,norm_mul,mul_pow] + simpa only [pow_two] using mul_le_mul hb₁ hb₂ (sq_nonneg _) hB + have hbb0 := mul_ne_zero (primeProduct_ne_zero p hp B v₁) (primeProduct_ne_zero p hp B v₂) + have hJ := (element_norm_le_of_dvd hbb0 (jLabel_dvd_cube_product p B v₁ v₂ ε₁ ε₂ hv)).trans hbb + have hb0sq := (element_norm_le_of_dvd hbb0 (b0_square_dvd_cube_product p B v₁ v₂ ε₁ ε₂ hv)).trans hbb + simp only [map_pow,norm_pow] at hb0sq + have hb0 : ‖eisEmbedding (b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂)‖^2 ≤ B₀ := by + nlinarith [sq_nonneg ‖eisEmbedding (b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂)‖] + refine ⟨hJ,hb0,?_⟩ + have heq := congrArg (fun a : O => ‖eisEmbedding a‖^2) (b0_jLabel_square p B v₁ v₂ ε₁ ε₂ hv) + simp only [map_pow,map_mul,norm_pow,norm_mul,mul_pow] at heq + have hs := squarefreeLabel_active_bound p hp B (fun i => v₁ i+v₂ i) ε₁ ε₂ + have hNprod : ‖eisEmbedding (primeProduct p B v₁)‖^2 * ‖eisEmbedding (primeProduct p B v₂)‖^2 ≤ B₀^2 := by + simpa only [map_mul,norm_mul,mul_pow] using hbb + have hmul := mul_le_mul hNprod hs (sq_nonneg _) (sq_nonneg B₀) + change _ ≤ B₀^2*‖eisEmbedding (∏ i ∈ cubeActiveSupport B (fun i => v₁ i+v₂ i) ε₁ ε₂,p i)‖^2 at hmul + have hjpos : 0 < ‖eisEmbedding (jLabel p B (fun i => v₁ i+v₂ i) ε₁ ε₂)‖^2 := by + exact zero_lt_one.trans_le (element_norm_ge_one _ (primeProduct_ne_zero p hp B _)) + apply (le_div_iff₀ hjpos).mpr + apply (sq_le_sq₀ (mul_nonneg (sq_nonneg _) (sq_nonneg _)) + (mul_nonneg hB (norm_nonneg _))).mp + simp only [mul_pow] + exact heq.trans_le hmul + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SeedHeight.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SeedHeight.lean new file mode 100644 index 0000000000000000000000000000000000000000..306e4ed4548a4ffdffecaf1da82c247ff553df8f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SeedHeight.lean @@ -0,0 +1,610 @@ +import OAI.NumberTheory.DirichletL.RowCompletion.CubicReopening +import OAI.NumberTheory.DirichletL.Eisenstein.MeromorphicResolvent + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace MatrixGroups + +lemma fullCuspHeight_le_barrier (x : FullCuspClasses) (w : HyperbolicSpace) : + fullCuspHeight x w≤max 3 (cuspBarrier 2 3 w) := by + by_cases hx : fullCuspHeight x w≤3 + · exact hx.trans (le_max_left _ _) + · have he : cuspBarrier 2 3 w=fullCuspHeight x w := by + rw [cuspBarrier,fullCuspProfileSum_eq_single _ + (fun v hv => cuspBarrierProfile_zero 2 3 (by norm_num) v (by linarith)) w x (by linarith), + cuspBarrierProfile,cuspTransition_one 2 3 _ (by norm_num) (by linarith),one_mul] + ring + exact he ▸ le_max_right _ _ + +lemma cosetHeight_le_barrier (r : CuspCosets) (w : HyperbolicSpace) : + cosetHeight r w≤max 3 (cuspBarrier 2 3 w) := by + induction r using Quotient.inductionOn with + | _ M => + change cosetHeight (cosetOf M) w≤max 3 (cuspBarrier 2 3 w) + rw [cosetHeight_cosetOf] + exact fullCuspHeight_le_barrier (fullCuspOf M.1) w + +lemma kernel_compact_seed_height_bound (a : ℝ) (S : Set KernelQuotient) (hS : IsCompact S) : + ∃B : ℝ,a≤B ∧ 3≤B ∧ ∀q∈S,kernelQuotientBarrier 2 3 q≤B := by + obtain ⟨B,hB⟩ := (hS.image (kernelQuotientBarrier_contMDiff 2 3 (by norm_num) (by norm_num)).continuous).bddAbove + refine ⟨max a (max 3 B),le_max_left _ _,(le_max_left 3 B).trans (le_max_right _ _),?_⟩ + intro q hq + exact (hB (Set.mem_image_of_mem _ hq)).trans ((le_max_right 3 B).trans (le_max_right _ _)) + +def kernelSeedHeightBound (a : ℝ) (S : Set KernelQuotient) (hS : IsCompact S) : ℝ := + Classical.choose (kernel_compact_seed_height_bound a S hS) + +lemma kernelSeedHeightBound_spec (a : ℝ) (S : Set KernelQuotient) (hS : IsCompact S) : + a≤kernelSeedHeightBound a S hS ∧ 3≤kernelSeedHeightBound a S hS ∧ + ∀q∈S,kernelQuotientBarrier 2 3 q≤kernelSeedHeightBound a S hS := + Classical.choose_spec (kernel_compact_seed_height_bound a S hS) + +def compactSeedTransition (a b B : ℝ) : C(Set.Icc a B,ℂ) := + ⟨fun v => (cuspTransition a b (v:ℝ):ℂ),Complex.continuous_ofReal.comp + ((cuspTransition_contDiff a b).continuous.comp continuous_subtype_val)⟩ + +def compactSeedProfile (a b B : ℝ) (ha : 0 + change cuspCutoffCorrection 1 (compactHeightProfile a B hB (compactSeedProfile a b B ha s)) w= + cuspCutoffCorrection 1 (cuspSeedProfile a b s) w + unfold cuspCutoffCorrection + apply tsum_congr + intro r + unfold cuspCutoffTerm + rw [compactHeightProfile_seed a b B ha hab hB s _ + ((cosetHeight_le_barrier r w).trans (max_le hthree hq))] + +def kernelLocalSeedL2 (S : Set KernelQuotient) (hS : IsCompact S) + (a b : ℝ) (ha : 0 kernelQuotientSeed a b s q+kernelEisensteinL2Correction a b ha hab s q + +def kernelLocalCorrectedSeed (S : Set KernelQuotient) (hS : IsCompact S) + (a b : ℝ) (ha : 0 (s-4/3)•kernelLocalCorrectedSeed S hS a b ha hab s) + (𝓝[≠] (4/3:ℂ)) + (𝓝 (kernelMassRestrictionCLM S hS.measurableSet (kernelEisensteinResidueVector a b ha hab))) := by + have hseed : Tendsto (fun s : ℂ => (s-4/3)•kernelLocalSeedL2 S hS a b ha s) + (𝓝[≠] (4/3:ℂ)) (𝓝 0) := by + have hh : ContinuousAt (fun s : ℂ => (s-4/3)•kernelLocalSeedL2 S hS a b ha s) (4/3:ℂ) := + (continuousAt_id.sub continuousAt_const).smul + ((kernelLocalSeedL2_entire S hS a b ha).continuous.continuousAt) + simpa only [sub_self,zero_smul] using hh.tendsto.mono_left + (show 𝓝[≠] (4/3:ℂ)≤𝓝 (4/3:ℂ) from nhdsWithin_le_nhds) + have hcor := (kernelMassRestrictionCLM S hS.measurableSet).continuous.continuousAt.tendsto.comp + (kernelEisensteinResidueVector_limit a b ha hab) + have hh := hseed.add hcor + simpa only [kernelLocalCorrectedSeed,smul_add,map_smul,Function.comp_def,zero_add] using hh + +end + +section +open Filter +open scoped BigOperators Classical Topology ContDiff + +section PartialDerivatives +variable {A E G : Type*} + [NormedAddCommGroup A] [NormedSpace ℝ A] + [NormedAddCommGroup E] [NormedSpace ℝ E] + [NormedAddCommGroup G] [NormedSpace ℝ G] + +lemma partial_iteratedFDeriv_contDiffAt (F : A→E→G) (a : A) (x : E) + (hF : ContDiffAt ℝ ∞ (Function.uncurry F) (a,x)) (k : ℕ) : + ContDiffAt ℝ ∞ (fun p : A×E => iteratedFDeriv ℝ k (F p.1) p.2) (a,x) := by + induction k with + | zero => + exact hF.continuousLinearMap_comp + ((continuousMultilinearCurryFin0 ℝ E G).symm : G→L[ℝ] E [×0]→L[ℝ]G) + | succ k ih => + have hpair : ContDiffAt ℝ ∞ + (fun p : (A×E)×E => (p.1.1,p.2)) ((a,x),x) := + (contDiffAt_fst.fst).prodMk contDiffAt_snd + have hp := ih.comp ((a,x),x) hpair + have hd : ContDiffAt ℝ ∞ + (fun p : A×E => fderiv ℝ (fun y => iteratedFDeriv ℝ k (F p.1) y) p.2) (a,x) := + hp.fderiv contDiffAt_snd (by simp) + exact hd.continuousLinearMap_comp + ((continuousMultilinearCurryLeftEquiv ℝ (fun _ : Fin (k+1) => E) G).symm : + (E→L[ℝ] E [×k]→L[ℝ]G)→L[ℝ] E [×(k+1)]→L[ℝ]G) + +lemma compact_family_derivative_bound (F : A→E→G) + (K : Set A) (P : Set E) (hK : IsCompact K) (hP : IsCompact P) + (hF : ∀a∈K,∀x,ContDiffAt ℝ ∞ (Function.uncurry F) (a,x)) + (hsupp : ∀a∈K,tsupport (F a)⊆P) (k : ℕ) : + ∃C : ℝ,0≤C ∧ ∀a∈K,∀x,‖iteratedFDeriv ℝ k (F a) x‖≤C := by + have hc : ContinuousOn (fun p : A×E => iteratedFDeriv ℝ k (F p.1) p.2) (K×ˢP) := by + intro p hp + exact (partial_iteratedFDeriv_contDiffAt F p.1 p.2 (hF p.1 hp.1 p.2) k).continuousAt.continuousWithinAt + obtain ⟨C,hC⟩ := (hK.prod hP).bddAbove_image hc.norm + refine ⟨max C 0,le_max_right _ _,?_⟩ + intro a ha x + by_cases hx : x∈P + · exact (hC ⟨(a,x),⟨ha,hx⟩,rfl⟩).trans (le_max_left _ _) + · have hz : iteratedFDeriv ℝ k (F a) x=0 := by + by_contra hn + exact hx (hsupp a ha (support_iteratedFDeriv_subset k hn)) + rw [hz,norm_zero] + exact le_max_right _ _ + +end PartialDerivatives +section + +variable {A E ι : Type*} + [NormedAddCommGroup A] [NormedSpace ℝ A] + [NormedAddCommGroup E] [NormedSpace ℝ E] + +theorem compact_smooth_family_tsum (F : A→E→ℂ) + (K : Set A) (P : Set E) (hK : IsCompact K) (hP : IsCompact P) + (hF : ∀a∈K,∀x,ContDiffAt ℝ ∞ (Function.uncurry F) (a,x)) + (hsupp : ∀a∈K,tsupport (F a)⊆P) + (a : ι→A) (ha : ∀i,a i∈K) (b : ι→ℂ) (hb : Summable (fun i => ‖b i‖)) : + ContDiff ℝ ∞ (fun x => ∑'i,b i*F (a i) x) := by + choose C hC hbound using compact_family_derivative_bound F K P hK hP hF hsupp + have hf (i : ι) : ContDiff ℝ ∞ (F (a i)) := by + apply contDiff_iff_contDiffAt.mpr + intro x + exact (hF (a i) (ha i) x).comp x (contDiffAt_const.prodMk contDiffAt_id) + have hprod (i : ι) : ContDiff ℝ ∞ (fun x => b i*F (a i) x) := + contDiff_const.mul (hf i) + apply contDiff_tsum (v := fun k i => ‖b i‖*C k) hprod + · intro k hk + exact hb.mul_right (C k) + · intro k i x hk + have he : iteratedFDeriv ℝ k (fun x => b i*F (a i) x) x= + b i • iteratedFDeriv ℝ k (F (a i)) x := + by simpa only [smul_eq_mul] using + (iteratedFDeriv_const_smul_apply' (a := b i) (i := k) (x := x) + ((hf i).contDiffAt.of_le (by simp))) + rw [he,norm_smul] + exact mul_le_mul_of_nonneg_left (hbound k (a i) (ha i) x) (norm_nonneg _) + +end + +lemma rowEnergy_real_smul (r : ℝ) (u : Fin 2→ℂ) : + rowEnergy (r • u)=r^2*rowEnergy u := by + simp only [rowEnergy,Pi.smul_apply,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs] + ring + +def normalizedComplexRow (u : Fin 2→ℂ) : Fin 2→ℂ := (Real.sqrt (rowEnergy u))⁻¹ • u + +lemma normalizedComplexRow_energy (u : Fin 2→ℂ) (hu : u≠0) : + rowEnergy (normalizedComplexRow u)=1 := by + rw [normalizedComplexRow,rowEnergy_real_smul,inv_pow, + Real.sq_sqrt (rowEnergy_nonneg u),inv_mul_cancel₀ (rowEnergy_pos u hu).ne'] + +lemma rowEnergy_continuous : Continuous rowEnergy := by + unfold rowEnergy + fun_prop + +lemma rowEnergy_unit_isCompact : IsCompact {u : Fin 2→ℂ | rowEnergy u=1} := by + apply (isCompact_closedBall (0 : Fin 2→ℂ) 1).of_isClosed_subset + (isClosed_eq rowEnergy_continuous continuous_const) + intro u hu + change rowEnergy u=1 at hu + rw [Metric.mem_closedBall,dist_zero_right] + simpa only [hu,Real.sqrt_one] using norm_le_sqrt_rowEnergy u + +lemma rowEnergy_unit_ne_zero (u : Fin 2→ℂ) (hu : rowEnergy u=1) : u≠0 := by + intro h + simp [h,rowEnergy] at hu + +def regularSpatialHeight (deltaLoss : ℝ) (p : SpatialCoordinates) : ℝ := + deltaLoss*ConcreteCompactWeight.positiveExtension (p 2/deltaLoss) + +lemma regularSpatialHeight_pos (deltaLoss : ℝ) (hδ : 0 + heightDenominator (spatialHorizontal p.2) (regularSpatialHeight deltaLoss p.2) p.1) := by + have hc (j : Fin 2) : ContDiff ℝ ∞ (fun p : (Fin 2→ℂ)×SpatialCoordinates => p.1 j) := + (contDiff_apply ℝ ℂ j).comp contDiff_fst + have hz := spatialHorizontal_contDiff.comp (contDiff_snd (E := Fin 2→ℂ)) + have hv := (regularSpatialHeight_contDiff deltaLoss).comp (contDiff_snd (E := Fin 2→ℂ)) + have hw := ((hc 0).mul hz).add (hc 1) + simp only [heightDenominator,←Complex.normSq_eq_norm_sq,Complex.normSq_apply] + exact (((Complex.reCLM.contDiff.comp hw).mul (Complex.reCLM.contDiff.comp hw)).add + ((Complex.imCLM.contDiff.comp hw).mul (Complex.imCLM.contDiff.comp hw))).add + ((((Complex.reCLM.contDiff.comp (hc 0)).mul (Complex.reCLM.contDiff.comp (hc 0))).add + ((Complex.imCLM.contDiff.comp (hc 0)).mul (Complex.imCLM.contDiff.comp (hc 0)))).mul (hv.pow 2)) + +lemma regularRowKernel_contDiffAt (s : ℂ) (deltaLoss : ℝ) (hδ : 0 regularSpatialHeight deltaLoss q.2) := + (regularSpatialHeight_contDiff deltaLoss).comp contDiff_snd + have hD := (regularRowDenominator_contDiff deltaLoss).contDiffAt (x := (u,p)) + have hv0 := regularSpatialHeight_pos deltaLoss hδ p + have hD0 := heightDenominator_pos (spatialHorizontal p) (regularSpatialHeight deltaLoss p) hv0 u hu + have hl := (hv.contDiffAt.log hv0.ne').sub (hD.log hD0.ne') + exact (contDiffAt_const.mul (Complex.ofRealCLM.contDiff.contDiffAt.comp (u,p) hl)).cexp + +lemma heightDenominator_real_smul (z : ℂ) (v r : ℝ) (u : Fin 2→ℂ) : + heightDenominator z v (r•u)=r^2*heightDenominator z v u := by + unfold heightDenominator + have he : (r•u) 0*z+(r•u) 1=r•(u 0*z+u 1) := by + simp only [Pi.smul_apply,smul_add,smul_mul_assoc] + rw [he] + simp only [Pi.smul_apply,norm_smul,Real.norm_eq_abs,mul_pow,sq_abs] + ring + +lemma heightDenominator_normalized (z : ℂ) (v : ℝ) (u : Fin 2→ℂ) : + heightDenominator z v (normalizedComplexRow u)=heightDenominator z v u/rowEnergy u := by + rw [normalizedComplexRow,heightDenominator_real_smul,inv_pow,Real.sq_sqrt (rowEnergy_nonneg u)] + ring + +lemma regularRowKernel_eq (s : ℂ) (deltaLoss : ℝ) (hδ : 0 ∑'r : CuspCosets, + summand 1 s r*(ψ p*regularRowKernel s deltaLoss (normalizedComplexRow (embeddedRow r)) p)) := by + apply compact_smooth_family_tsum (fun u p => ψ p*regularRowKernel s deltaLoss u p) + {u : Fin 2→ℂ | rowEnergy u=1} (tsupport ψ) rowEnergy_unit_isCompact hcψ + · intro u hu p + have hψp : ContDiffAt ℝ ∞ (fun q : (Fin 2→ℂ)×SpatialCoordinates => ψ q.2) (u,p) := + hψ.contDiffAt.comp (u,p) contDiffAt_snd + exact hψp.mul (regularRowKernel_contDiffAt s deltaLoss hδ u (rowEnergy_unit_ne_zero u hu) p) + · intro u hu + exact tsupport_mul_subset_left + · intro r + exact normalizedComplexRow_energy _ (embeddedRow_ne_zero r) + · exact summable_norm_summand 1 s hs + +theorem smoothEisenstein_contDiffAt (s : ℂ) (hs : 2 (χ q:ℂ) + have hψ : ContDiff ℝ ∞ ψ := Complex.ofRealCLM.contDiff.comp χ.contDiff + have hcψ : HasCompactSupport ψ := by + have he : Function.support ψ=Function.support (fun q => χ q) := by + ext q + simp [Function.mem_support,ψ] + change IsCompact (closure (Function.support ψ)) + rw [he] + exact χ.hasCompactSupport + have hsum := regular_eisenstein_compact_smooth s hs deltaLoss hδ ψ hψ hcψ + apply hsum.contDiffAt.congr_of_eventuallyEq + have hn : ∀ᶠq in 𝓝 p, deltaLoss F (kernelQuotientChart q t)) := by + filter_upwards [(kernelQuotientChart q).open_source.mem_nhds hq] with t ht + rw [←hcoord q _ ((kernelQuotientChart q).map_source ht).1, + (kernelQuotientChart q).left_inv ht] + rw [contMDiffAt_iff] + refine ⟨((hF _ (hyperbolicSpatialChart_target_positive hp)).continuousAt.comp hc).congr heq.symm,?_⟩ + have he : (fun p => f ((kernelQuotientChart q).symm p))=ᶠ[𝓝 (kernelQuotientChart q q)] F := by + filter_upwards [hyperbolicSpatialChart.open_target.mem_nhds hp] with p hp + exact hcoord q p hp + have hh := (hF _ (hyperbolicSpatialChart_target_positive hp)).congr_of_eventuallyEq he + have hh' := hh.contDiffWithinAt (s := Set.univ) + simpa only [extChartAt_coe,extChartAt_coe_symm,modelWithCornersSelf_coe, + modelWithCornersSelf_coe_symm,Function.id_comp,Function.comp_id,Set.range_id, + chartAt_self_eq,kernelSpatial_chartAt,OpenPartialHomeomorph.refl_apply,Function.comp_def,id_eq] using hh' + +lemma kernelQuotientEisenstein_coordinate (s : ℂ) (hs : 2 (kernelExhaustionCutoff n q:ℂ)* + (kernelQuotientEisenstein s hs q-kernelQuotientSeed a b s q) + refine ⟨f,?_,?_⟩ + · have hm : ContDiff ℝ ∞ (fun z : ℂ × ℂ => z.1*z.2) := contDiff_fst.mul contDiff_snd + exact hm.contMDiff.comp + ((Complex.ofRealCLM.contDiff.contMDiff.comp (kernelExhaustionCutoff_smooth n)).prodMk_space + ((kernelQuotientEisenstein_contMDiff s hs).sub (kernelQuotientSeed_contMDiff a b s ha hab))) + · apply HasCompactSupport.of_support_subset_isCompact (kernelExhaustionCutoff_hasCompactSupport n) + intro q hq + by_contra hn + have hz : kernelExhaustionCutoff n q=0 := by + by_contra hne + exact hn (subset_closure hne) + exact hq (by simp [f,hz]) + +lemma kernelCutoffRemainderTest_apply (n : ℕ) (a b : ℝ) (ha : 1 (0:ℝ)) := by + filter_upwards [Iio_mem_nhds hv] with x hx + exact cuspTransition_zero a b x hab hx.le + exact ⟨heq.deriv_eq.trans (deriv_const _ _),heq.deriv.deriv_eq.trans (by simp)⟩ + · have heq : cuspTransition a b =ᶠ[𝓝 v] (fun _ => (1:ℝ)) := by + filter_upwards [Ioi_mem_nhds hv] with x hx + exact cuspTransition_one a b x hab hx.le + exact ⟨heq.deriv_eq.trans (deriv_const _ _),heq.deriv.deriv_eq.trans (by simp)⟩ + +def positiveHeightPower (s : ℂ) (v : ℝ) : ℂ := logRatioPower s v 1 +lemma positiveHeightPower_eq_cpow (s : ℂ) (v : ℝ) (hv : 0 1) (fun _ => 1) (fun _ => 0) v 0 0 + (fun x => hasDerivAt_id x) (fun x => hasDerivAt_const x (1:ℝ)) + (hasDerivAt_const v (1:ℝ)) (hasDerivAt_const v (0:ℝ)) hv one_ne_zero using 1 + · rfl + · simp only [id_eq,zero_mul,mul_one,sub_self,sub_zero,one_pow,div_one, + Complex.ofReal_sub,Complex.ofReal_div,Complex.ofReal_one,Complex.ofReal_pow, + Complex.ofReal_zero,positiveHeightPower] + field_simp [Complex.ofReal_ne_zero.mpr hv] + ; ring + +def cuspSeedProfile (a b : ℝ) (s : ℂ) (v : ℝ) : ℂ := + (cuspTransition a b v:ℂ)*positiveHeightPower s v + +lemma cuspSeedProfile_zero (a b : ℝ) (s : ℂ) (v : ℝ) (hab : a ((deriv (cuspTransition a b) x:ℝ):ℂ)*positiveHeightPower s x+ + (cuspTransition a b x:ℂ)*deriv (positiveHeightPower s) x) := by + filter_upwards [eventually_ne_nhds hv] with x hx + rw [(cuspSeedProfile_hasDerivAt a b s x hx).deriv,(positiveHeightPower_hasDerivAt s x hx).deriv] + apply HasDerivAt.congr_of_eventuallyEq _ heq + convert (hdχ.mul hH).add (hχ.mul hdH) using 1 + · rw [hH.deriv] + ring + +def cuspSeedDefectProfile (a b : ℝ) (s : ℂ) (v : ℝ) : ℂ := + positiveHeightPower s v*((v:ℂ)^2*((deriv (deriv (cuspTransition a b)) v:ℝ):ℂ)+ + (2*s-1)*(v:ℂ)*((deriv (cuspTransition a b) v:ℝ):ℂ)) + +lemma cuspSeedProfile_laplace_defect (a b : ℝ) (s : ℂ) (v : ℝ) (hv : v≠0) : + (v:ℂ)^2*deriv (deriv (cuspSeedProfile a b s)) v- + (v:ℂ)*deriv (cuspSeedProfile a b s) v-s*(s-2)*cuspSeedProfile a b s v= + cuspSeedDefectProfile a b s v := by + rw [(cuspSeedProfile_hasDerivAt a b s v hv).deriv,(cuspSeedProfile_hasDerivAt_deriv a b s v hv).deriv] + unfold cuspSeedDefectProfile cuspSeedProfile + field_simp [Complex.ofReal_ne_zero.mpr hv] + ; ring + +lemma cuspSeedDefectProfile_zero (a b : ℝ) (s : ℂ) (v : ℝ) (hab : a quadraticHeightDenominator (Complex.normSq (u 0)) + (u 0*star (u 1)).re (-(u 0*star (u 1)).im) (Complex.normSq (u 1)) (q 0) (q 1) (q 2)) p := by + unfold quadraticHeightDenominator + fun_prop + exact (show ContDiffAt ℝ ∞ (fun q : SpatialCoordinates => q 2) p by fun_prop).div hq + (row_denominator_pos u hu p hp).ne' + +lemma rowSmoothPower_eq_height (s : ℂ) (u : Fin 2 → ℂ) (hu : u≠0) + (p : SpatialCoordinates) (hp : 0

∑r∈S,(cosetCharacter r)⁻¹*F (rowHeight (embeddedRow r) q)) := by + obtain ⟨U,hU,hpU,S,hrows⟩ := locally_finite_high_rows p hp + refine ⟨S,?_⟩ + filter_upwards [hU.mem_nhds hpU] with q hq + apply tsum_eq_sum + intro r hr + rw [hF _ ((hrows q hq).2 r hr).le,mul_zero] + +lemma heightPoincareField_contDiffAt (F : ℝ → ℂ) (hzero : ∀v≤1,F v=0) + (hF : ∀v,0 (Real.log x:ℂ)) v := + Complex.ofRealCLM.contDiff.contDiffAt.comp v (Real.contDiffAt_log.mpr hv) + have hs : ContDiffAt ℝ ∞ (fun x : ℝ => s*(Real.log x:ℂ)) v := contDiffAt_const.mul hlog + unfold positiveHeightPower logRatioPower + simpa only [Real.log_one,sub_zero] using hs.cexp + +lemma cuspSeedProfile_contDiffAt (a b : ℝ) (s : ℂ) (v : ℝ) (hv : 0 (x:ℂ)) v := Complex.ofRealCLM.contDiff.contDiffAt + exact (positiveHeightPower_contDiffAt s v hv.ne').mul + (((hid.pow 2).mul hd₂).add ((contDiffAt_const.mul hid).mul hd₁)) + +lemma cuspSeedDefectProfile_continuous (a b : ℝ) (s : ℂ) (ha : 0 (0:ℂ)) := by + filter_upwards [Iio_mem_nhds hv] with x hx + exact cuspSeedDefectProfile_zero a b s x hab (Or.inl hx) + exact continuousAt_const.congr heq.symm + · exact (cuspSeedDefectProfile_contDiffAt a b s v (lt_of_lt_of_le ha (le_of_not_gt hv))).continuousAt + +lemma cuspSeedDefectProfile_integrable (a b : ℝ) (s : ℂ) (ha : 0 cuspSeedProfile_zero a b s v hab (hv.trans ha.le)) p hp).symm +lemma smoothCuspSeedDefect_coordinate (a b : ℝ) (s : ℂ) (ha : 1 cuspSeedDefectProfile_zero a b s v hab (Or.inl (lt_of_le_of_lt hv ha))) p hp).symm + +lemma smoothCuspSeed_contDiffAt (a b : ℝ) (s : ℂ) (ha : 1 cuspSeedProfile_zero a b s v hab (hv.trans ha.le)) + (cuspSeedProfile_contDiffAt a b s) p hp +lemma smoothCuspSeedDefect_contDiffAt (a b : ℝ) (s : ℂ) (ha : 1 cuspSeedDefectProfile_zero a b s v hab (Or.inl (lt_of_le_of_lt hv ha))) + (cuspSeedDefectProfile_contDiffAt a b s) p hp + +lemma cuspCutoffCorrection_upperPoint (F : ℝ → ℂ) (z : ℂ) (v : ℝ) (hv : 0 Real.log (f t)-Real.log (g t))) + ((ddf*f x-df x*df x)/(f x)^2-(ddg*g x-dg x*dg x)/(g x)^2) x := by + have heq : deriv (fun t => Real.log (f t)-Real.log (g t)) =ᶠ[𝓝 x] + (fun t => df t/f t-dg t/g t) := by + filter_upwards [((hf x).continuousAt.eventually_ne hf0).and ((hg x).continuousAt.eventually_ne hg0)] with t ht + exact (((hf t).log ht.1).sub ((hg t).log ht.2)).deriv + exact ((hdf.div (hf x) hf0).sub (hdg.div (hg x) hg0)).congr_of_eventuallyEq heq + +lemma rowLogHeight_hasDerivAt (u : Fin 2 → ℂ) (hu : u≠0) + (p : SpatialCoordinates) (hp : 0

rowLogHeight u (Function.update p j t)) (rowLogD u p j) (p j) := by + let A := Complex.normSq (u 0) + let B := (u 0*star (u 1)).re + let C := -(u 0*star (u 1)).im + let D := Complex.normSq (u 1) + have hq := (row_denominator_pos u hu p hp).ne' + fin_cases j + · have h := ((hasDerivAt_const (p 0) (p 2)).log hp.ne').sub + ((quadraticHeightDenominator_hasDerivAt_x A B C D (p 0) (p 1) (p 2)).log hq) + simpa [rowLogHeight,rowLogD,spatialLogD,heightLogDx,Function.update,A,B,C,D,Pi.sub_def] using! h + · have h := ((hasDerivAt_const (p 1) (p 2)).log hp.ne').sub + ((quadraticHeightDenominator_hasDerivAt_y A B C D (p 0) (p 1) (p 2)).log hq) + simpa [rowLogHeight,rowLogD,spatialLogD,heightLogDy,Function.update,A,B,C,D,Pi.sub_def] using! h + · have h := ((hasDerivAt_id (p 2)).log hp.ne').sub + ((quadraticHeightDenominator_hasDerivAt_v A B C D (p 0) (p 1) (p 2)).log hq) + simpa [rowLogHeight,rowLogD,spatialLogD,heightLogDv,Function.update,A,B,C,D,Pi.sub_def] using! h + +lemma rowLogHeight_hasDerivAt_deriv (u : Fin 2 → ℂ) (hu : u≠0) + (p : SpatialCoordinates) (hp : 0

rowLogHeight u (Function.update p j t))) (rowLogDD u p j) (p j) := by + let A := Complex.normSq (u 0) + let B := (u 0*star (u 1)).re + let C := -(u 0*star (u 1)).im + let D := Complex.normSq (u 1) + have hq := (row_denominator_pos u hu p hp).ne' + fin_cases j + · have h := hasDerivAt_deriv_log_ratio (fun _ => p 2) + (fun t => quadraticHeightDenominator A B C D t (p 1) (p 2)) (fun _ => 0) + (fun t => 2*(A*t+B)) (p 0) 0 (2*A) + (fun t => hasDerivAt_const t (p 2)) + (fun t => quadraticHeightDenominator_hasDerivAt_x A B C D t (p 1) (p 2)) + (hasDerivAt_const (p 0) 0) + (by simpa only [id_eq,mul_one] using ((hasDerivAt_id (p 0)).const_mul A |>.add_const B).const_mul 2) + hp.ne' hq + simpa [rowLogHeight,rowLogDD,spatialLogDD,heightLogDxx,Function.update,A,B,C,D,Pi.sub_def] using! h + · have h := hasDerivAt_deriv_log_ratio (fun _ => p 2) + (fun t => quadraticHeightDenominator A B C D (p 0) t (p 2)) (fun _ => 0) + (fun t => 2*(A*t+C)) (p 1) 0 (2*A) + (fun t => hasDerivAt_const t (p 2)) + (fun t => quadraticHeightDenominator_hasDerivAt_y A B C D (p 0) t (p 2)) + (hasDerivAt_const (p 1) 0) + (by simpa only [id_eq,mul_one] using ((hasDerivAt_id (p 1)).const_mul A |>.add_const C).const_mul 2) + hp.ne' hq + simpa [rowLogHeight,rowLogDD,spatialLogDD,heightLogDyy,Function.update,A,B,C,D,Pi.sub_def] using! h + · have h := hasDerivAt_deriv_log_ratio id + (fun t => quadraticHeightDenominator A B C D (p 0) (p 1) t) (fun _ => 1) + (fun t => 2*A*t) (p 2) 0 (2*A) + (fun t => hasDerivAt_id t) + (fun t => quadraticHeightDenominator_hasDerivAt_v A B C D (p 0) (p 1) t) + (hasDerivAt_const (p 2) 1) + (by simpa only [id_eq,mul_one] using (hasDerivAt_id (p 2)).const_mul (2*A)) + hp.ne' hq + simpa [rowLogHeight,rowLogDD,spatialLogDD,heightLogDvv,Function.update,A,B,C,D,div_eq_mul_inv] using h + +lemma complex_profile_second_chain (F : ℝ → ℂ) (g : ℝ → ℝ) (x dg ddg : ℝ) (dF ddF : ℂ) + (hg : HasDerivAt g dg x) (hdg : HasDerivAt (deriv g) ddg x) + (hF : HasDerivAt F dF (g x)) (hdF : HasDerivAt (deriv F) ddF (g x)) + (hlocal : ∀ᶠy in 𝓝 x,DifferentiableAt ℝ g y ∧ DifferentiableAt ℝ F (g y)) : + HasDerivAt (deriv (fun y => F (g y))) (ddF*(dg:ℂ)^2+dF*(ddg:ℂ)) x := by + have heq : deriv (fun y => F (g y)) =ᶠ[𝓝 x] + (fun y => (deriv g y:ℝ) • deriv F (g y)) := by + filter_upwards [hlocal] with y hy + exact (hy.2.hasDerivAt.scomp y hy.1.hasDerivAt).deriv + apply HasDerivAt.congr_of_eventuallyEq _ heq + convert hdg.smul (hdF.scomp x hg) using 1 + · rfl + · simp only [Function.comp_apply,hg.deriv,hF.deriv,Complex.real_smul] + ring + +lemma positiveProfile_differentiable (F : ℝ → ℂ) + (hF : ∀v,0 F (Real.exp y)) + (deriv F (Real.exp t)*(Real.exp t:ℂ)) t ∧ + HasDerivAt (deriv (fun y => F (Real.exp y))) + (deriv (deriv F) (Real.exp t)*(Real.exp t:ℂ)^2+ + deriv F (Real.exp t)*(Real.exp t:ℂ)) t := by + have hdf := positiveProfile_differentiable F hF (Real.exp t) (Real.exp_pos t) + constructor + · simpa only [Complex.real_smul,mul_comm,Function.comp_def] using! hdf.1.hasDerivAt.scomp t (Real.hasDerivAt_exp t) + · apply complex_profile_second_chain F Real.exp t (Real.exp t) (Real.exp t) + (deriv F (Real.exp t)) (deriv (deriv F) (Real.exp t)) (Real.hasDerivAt_exp t) + (by simpa only [Real.deriv_exp] using Real.hasDerivAt_exp t) hdf.1.hasDerivAt hdf.2.hasDerivAt + exact Filter.Eventually.of_forall (fun y => + ⟨Real.differentiable_exp y,(positiveProfile_differentiable F hF _ (Real.exp_pos y)).1⟩) + +lemma rowProfile_axis_derivatives (F : ℝ → ℂ) + (hF : ∀v,0 F (rowHeight u q)) p j) + (deriv F (rowHeight u p)*(rowHeight u p:ℂ)*(rowLogD u p j:ℂ)) (p j) ∧ + HasDerivAt (deriv (axisSlice (fun q => F (rowHeight u q)) p j)) + (deriv (deriv F) (rowHeight u p)*(rowHeight u p:ℂ)^2*(rowLogD u p j:ℂ)^2+ + deriv F (rowHeight u p)*(rowHeight u p:ℂ)* + ((rowLogD u p j:ℂ)^2+(rowLogDD u p j:ℂ))) (p j) := by + let g : ℝ → ℝ := fun t => rowLogHeight u (Function.update p j t) + let G : ℝ → ℂ := fun t => F (Real.exp t) + have hg : HasDerivAt g (rowLogD u p j) (p j) := rowLogHeight_hasDerivAt u hu p hp j + have hdg : HasDerivAt (deriv g) (rowLogDD u p j) (p j) := rowLogHeight_hasDerivAt_deriv u hu p hp j + have hgval : g (p j)=rowLogHeight u p := by simp [g,Function.update_eq_self] + have hexp : Real.exp (g (p j))=rowHeight u p := by rw [hgval,exp_rowLogHeight u hu p hp] + have hG := positiveProfile_exp_derivatives F hF (g (p j)) + have hnear : ∀ᶠt in 𝓝 (p j),0<(Function.update p j t) 2 := + ((continuous_apply 2).comp (continuous_axis_update p j)).continuousAt.eventually_const_lt + (by simpa only [Function.comp_apply,Function.update_eq_self] using hp) + have heq : axisSlice (fun q => F (rowHeight u q)) p j =ᶠ[𝓝 (p j)] (fun t => G (g t)) := by + filter_upwards [hnear] with t ht + change F (rowHeight u (Function.update p j t))=F (Real.exp (rowLogHeight u (Function.update p j t))) + rw [exp_rowLogHeight u hu _ ht] + constructor + · have hh := hG.1.scomp (p j) hg + apply HasDerivAt.congr_of_eventuallyEq _ heq + convert hh using 1 + · rfl + · simp only [Complex.real_smul,hexp] + ring + · have hlocal : ∀ᶠy in 𝓝 (p j),DifferentiableAt ℝ g y ∧ DifferentiableAt ℝ G (g y) := by + filter_upwards [hnear] with y hy + constructor + · have h := rowLogHeight_hasDerivAt u hu (Function.update p j y) hy j + simpa only [Function.update_idem,Function.update_self] using h.differentiableAt + · exact (positiveProfile_exp_derivatives F hF (g y)).1.differentiableAt + have hh := complex_profile_second_chain G g (p j) (rowLogD u p j) (rowLogDD u p j) + _ _ hg hdg hG.1 hG.2 hlocal + apply HasDerivAt.congr_of_eventuallyEq _ heq.deriv + convert hh using 1 + · rw [hexp] + ring + +lemma rowLog_eikonal (u : Fin 2 → ℂ) (hu : u≠0) (p : SpatialCoordinates) (hp : 0

F (rowHeight u q)) p= + (rowHeight u p:ℂ)^2*deriv (deriv F) (rowHeight u p)-(rowHeight u p:ℂ)*deriv F (rowHeight u p) := by + have hp0 := rowProfile_axis_derivatives F hF u hu p hp 0 + have hp1 := rowProfile_axis_derivatives F hF u hu p hp 1 + have hp2 := rowProfile_axis_derivatives F hF u hu p hp 2 + unfold axisLaplacian + rw [Fin.sum_univ_three,hp0.2.deriv,hp1.2.deriv,hp2.2.deriv,hp2.1.deriv] + have hE := congrArg (fun r : ℝ => (r:ℂ)) (rowLog_eikonal u hu p hp) + have hD := congrArg (fun r : ℝ => (r:ℂ)) (rowLog_laplacian u hu p hp) + push_cast at hE hD + linear_combination + (deriv (deriv F) (rowHeight u p)*(rowHeight u p:ℂ)^2+ + deriv F (rowHeight u p)*(rowHeight u p:ℂ))*hE+ + (deriv F (rowHeight u p)*(rowHeight u p:ℂ))*hD + +open Filter +open scoped BigOperators Classical Topology ContDiff + +lemma axisLaplacian_congr_eventuallyEq (f g : SpatialCoordinates → ℂ) (p : SpatialCoordinates) + (heq : f =ᶠ[𝓝 p] g) : axisLaplacian f p=axisLaplacian g p := by + have haxis (j : Fin 3) : axisSlice f p j =ᶠ[𝓝 (p j)] axisSlice g p j := by + have ht : Tendsto (fun x => Function.update p j x) (𝓝 (p j)) (𝓝 p) := by + have h : Tendsto (fun x => Function.update p j x) (𝓝 (p j)) (𝓝 (Function.update p j (p j))) := + (continuous_axis_update p j).continuousAt + simpa only [Function.update_eq_self] using h + exact heq.comp_tendsto ht + unfold axisLaplacian + congr 1 + · congr 1 + exact Finset.sum_congr rfl (fun j _ => (haxis j).deriv.deriv_eq) + · rw [(haxis 2).deriv_eq] + +lemma axisLaplacian_const_mul (c : ℂ) (f : SpatialCoordinates → ℂ) (p : SpatialCoordinates) : + axisLaplacian (fun q => c*f q) p=c*axisLaplacian f p := by + unfold axisLaplacian + simp only [Fin.sum_univ_three] + unfold axisSlice + simp only [deriv_const_mul_field',deriv_const_mul_field] + ring + +lemma axisLaplacian_finset_sum {ι : Type*} (S : Finset ι) (f : ι → SpatialCoordinates → ℂ) + (hreg : ∀i∈S,∀q,0 ∑i∈S,f i q) p=∑i∈S,axisLaplacian (f i) p := by + have hpair (j : Fin 3) : + deriv (axisSlice (fun q => ∑i∈S,f i q) p j) (p j)=∑i∈S,deriv (axisSlice (f i) p j) (p j) ∧ + deriv (deriv (axisSlice (fun q => ∑i∈S,f i q) p j)) (p j)= + ∑i∈S,deriv (deriv (axisSlice (f i) p j)) (p j) := by + have hfirst (x : ℝ) (hx : 0<(Function.update p j x) 2) : + HasDerivAt (axisSlice (fun q => ∑i∈S,f i q) p j) + (∑i∈S,deriv (axisSlice (f i) p j) x) x := by + have hi (i : ι) (hiS : i∈S) : DifferentiableAt ℝ (axisSlice (f i) p j) x := by + simpa only [axisSlice_update,Function.update_self] using (hreg i hiS (Function.update p j x) hx j).1 + convert HasDerivAt.sum (fun i hiS => (hi i hiS).hasDerivAt) using 1 + ext y + simp only [axisSlice,Finset.sum_apply] + have hnear : ∀ᶠx in 𝓝 (p j),0<(Function.update p j x) 2 := + ((continuous_apply 2).comp (continuous_axis_update p j)).continuousAt.eventually_const_lt + (by simpa only [Function.comp_apply,Function.update_eq_self] using hp) + have heq : deriv (axisSlice (fun q => ∑i∈S,f i q) p j) =ᶠ[𝓝 (p j)] + (fun x => ∑i∈S,deriv (axisSlice (f i) p j) x) := by + filter_upwards [hnear] with x hx + exact (hfirst x hx).deriv + have hsecond : HasDerivAt (deriv (axisSlice (fun q => ∑i∈S,f i q) p j)) + (∑i∈S,deriv (deriv (axisSlice (f i) p j)) (p j)) (p j) := by + apply (HasDerivAt.sum (fun i hiS => (hreg i hiS p hp j).2.hasDerivAt)).congr_of_eventuallyEq + filter_upwards [heq] with x hx + simpa only [Finset.sum_apply] using hx + exact ⟨(hfirst (p j) (by simpa only [Function.comp_apply,Function.update_eq_self] using hp)).deriv,hsecond.deriv⟩ + unfold axisLaplacian + simp_rw [(hpair _).1,(hpair _).2] + rw [Finset.sum_comm] + simp only [Finset.mul_sum,Finset.sum_sub_distrib] + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SmoothSummands.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SmoothSummands.lean new file mode 100644 index 0000000000000000000000000000000000000000..41000c6798a2ac607b2e1781f3e15ddd0d61105b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SmoothSummands.lean @@ -0,0 +1,718 @@ +import OAI.NumberTheory.DirichletL.QuadraticSieve.SpatialDerivatives +import OAI.NumberTheory.DirichletL.CubicSieve.FirstCoreCutoff + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein +open Filter +open scoped BigOperators Classical Topology Matrix + +def smoothEisenstein (s : ℂ) (p : SpatialCoordinates) : ℂ := ∑'r, smoothSummand s r p + +lemma smoothEisenstein_eq_actual (s : ℂ) (p : SpatialCoordinates) (hv : 0

smoothSummand_eq_actual s r p hv) + +lemma summable_smoothSummand (s : ℂ) (hs : 2 smoothSummand s r p) := + (summable_summand (upperSection ((p 0:ℂ)+(p 1:ℂ)*Complex.I) (p 2) hv) s hs).congr + (fun r => (smoothSummand_eq_actual s r p hv).symm) + +theorem eisenstein_axis_termwise (s : ℂ) (hs : 2 deriv (axisSlice (smoothSummand s r) p j) (p j)) ∧ + Summable (fun r => deriv (deriv (axisSlice (smoothSummand s r) p j)) (p j)) ∧ + HasDerivAt (axisSlice (smoothEisenstein s) p j) + (∑'r,deriv (axisSlice (smoothSummand s r) p j) (p j)) (p j) ∧ + HasDerivAt (deriv (axisSlice (smoothEisenstein s) p j)) + (∑'r,deriv (deriv (axisSlice (smoothSummand s r) p j)) (p j)) (p j) := by + obtain ⟨ε,hε,M₀,M₁,M₂,hM₀,hM₁,hM₂,hbound⟩ := axis_summable_derivative_bounds s hs p hv j + have hx : p j ∈ Metric.ball (p j) ε := Metric.mem_ball_self hε + have hs₀ : Summable (fun r => axisSlice (smoothSummand s r) p j (p j)) := + Summable.of_norm_bounded hM₀ (fun r => ((hbound (p j) hx).2 r).1) + have hs₁ : Summable (fun r => deriv (axisSlice (smoothSummand s r) p j) (p j)) := + Summable.of_norm_bounded hM₁ (fun r => ((hbound (p j) hx).2 r).2.1) + have hs₂ : Summable (fun r => deriv (deriv (axisSlice (smoothSummand s r) p j)) (p j)) := + Summable.of_norm_bounded hM₂ (fun r => ((hbound (p j) hx).2 r).2.2) + have hd₁ (r : CuspCosets) (t : ℝ) (ht : t∈Metric.ball (p j) ε) : + DifferentiableAt ℝ (axisSlice (smoothSummand s r) p j) t := + smooth_axis_differentiable_at s r p j t (hbound t ht).1 + have hd₂ (r : CuspCosets) (t : ℝ) (ht : t∈Metric.ball (p j) ε) : + DifferentiableAt ℝ (deriv (axisSlice (smoothSummand s r) p j)) t := + smooth_axis_deriv_differentiable_at s r p j t (hbound t ht).1 + refine ⟨hs₁,hs₂,?_,?_⟩ + · exact hasDerivAt_tsum_of_isPreconnected hM₁ Metric.isOpen_ball Metric.isPreconnected_ball + (fun r t ht => (hd₁ r t ht).hasDerivAt) (fun r t ht => ((hbound t ht).2 r).2.1) hx hs₀ hx + · exact hasDerivAt_deriv_tsum_of_bounds (fun r => axisSlice (smoothSummand s r) p j) + M₁ M₂ _ (p j) Metric.isOpen_ball Metric.isPreconnected_ball hx hM₁ hM₂ hd₁ hd₂ + (fun r t ht => ((hbound t ht).2 r).2.1) (fun r t ht => ((hbound t ht).2 r).2.2) hs₀ + +def axisLaplacian (f : SpatialCoordinates → ℂ) (p : SpatialCoordinates) : ℂ := + (p 2:ℂ)^2 * (∑ j : Fin 3, deriv (deriv (axisSlice f p j)) (p j)) - + (p 2:ℂ)*deriv (axisSlice f p 2) (p 2) + +lemma axisSlice_zero (f : ℝ → ℝ → ℝ → ℂ) (p : SpatialCoordinates) : + axisSlice (fun q => f (q 0) (q 1) (q 2)) p 0 = fun t => f t (p 1) (p 2) := by + funext t + simp [axisSlice,Function.update] +lemma axisSlice_one (f : ℝ → ℝ → ℝ → ℂ) (p : SpatialCoordinates) : + axisSlice (fun q => f (q 0) (q 1) (q 2)) p 1 = fun t => f (p 0) t (p 2) := by + funext t + simp [axisSlice,Function.update] +lemma axisSlice_two (f : ℝ → ℝ → ℝ → ℂ) (p : SpatialCoordinates) : + axisSlice (fun q => f (q 0) (q 1) (q 2)) p 2 = fun t => f (p 0) (p 1) t := by + funext t + simp [axisSlice,Function.update] + +lemma axisLaplacian_eq_hyperbolicLaplacian (f : ℝ → ℝ → ℝ → ℂ) (p : SpatialCoordinates) : + axisLaplacian (fun q => f (q 0) (q 1) (q 2)) p = + hyperbolicLaplacian f (p 0) (p 1) (p 2) := by + simp only [axisLaplacian,Fin.sum_univ_three,axisSlice_zero,axisSlice_one,axisSlice_two, + hyperbolicLaplacian] + +lemma smoothSummand_axisLaplacian (s : ℂ) (r : CuspCosets) (p : SpatialCoordinates) (hv : 0

(cosetCharacter r)⁻¹ * + spatialHeightPower s (Complex.normSq (embeddedRow r 0)) + ((embeddedRow r 0*star (embeddedRow r 1)).re) + (-(embeddedRow r 0*star (embeddedRow r 1)).im) + (Complex.normSq (embeddedRow r 1)) x y v) p, + hyperbolicLaplacian_const_mul,spatialHeightPower_eigenfunction] + · ring + · exact complex_row_quadratic_relation _ _ + · exact hv.ne' + · exact (row_denominator_pos _ (embeddedRow_ne_zero r) p hv).ne' + +theorem smoothEisenstein_eigenfunction (s : ℂ) (hs : 2 + deriv (deriv (axisSlice (smoothSummand s r) p j)) (p j) + let first := fun r : CuspCosets => deriv (axisSlice (smoothSummand s r) p 2) (p 2) + have hsecond (j : Fin 3) : Summable (second j) := (hterms j).2.1 + have hfirst : Summable first := (hterms 2).1 + have hsum : Summable (fun r => ∑ j : Fin 3, second j r) := by + simpa only [Fin.sum_univ_three] using ((hsecond 0).add (hsecond 1)).add (hsecond 2) + have hcomm : (∑ j : Fin 3, ∑'r,second j r) = ∑'r,∑ j : Fin 3,second j r := by + exact (Summable.tsum_finsetSum (fun j _ => hsecond j)).symm + unfold axisLaplacian + simp_rw [fun j => (hterms j).2.2.2.deriv] + rw [(hterms 2).2.2.1.deriv] + change (p 2:ℂ)^2*(∑j : Fin 3,∑'r,second j r) - (p 2:ℂ)*(∑'r,first r) = _ + rw [hcomm,← tsum_mul_left,← tsum_mul_left,← (hsum.mul_left _).tsum_sub (hfirst.mul_left _)] + change (∑'r,axisLaplacian (smoothSummand s r) p) = _ + simp_rw [smoothSummand_axisLaplacian s _ p hv] + rw [tsum_mul_left] + rfl + +lemma axisSlice_eventuallyEq_of_positive (f g : SpatialCoordinates → ℂ) + (heq : ∀ q, 0 upperEisensteinField_eq_smooth s q hq) p hv, + smoothEisenstein_eigenfunction s hs p hv,upperEisensteinField_eq_smooth s p hv] + +end CubicEisenstein + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace SecondPassArithmetic + +section +open ActualEisensteinCubic +open FirstPassCubeLabels (columnLog normalizedColumn primeProductNorm b0Label jLabel) +open ConcreteTraceCRT (eisEmbedding) +open EisensteinSchwartzPoisson (paperRadialFourier) +open RayFourExpansion (RayCharacter) +open SecondPassIntegration (densityChildEnergy) + +lemma firstCoreModeHeight_norm (negative : Bool) (t : ℝ) : + ‖firstCoreModeHeight negative t‖ = ‖t‖ := by + cases negative <;> simp [firstCoreModeHeight] + +theorem firstCoreInputRow_finite_second_transfer + {ι κ : Type*} [DecidableEq ι] [DecidableEq κ] [Fintype κ] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) + (hpr : ∀ i, lambda ^ 2 ∣ p i - 1) + (U : ℝ → ℂ) (hUc : HasCompactSupport U) (hUs : ContDiff ℝ ∞ U) + (g V : 𝓢(ℝ, ℂ)) (negative : Bool) (hU : ∀ t, g t ≠ 0 → U t = 1) + (M H : ℝ) (hM : 0 ≤ M) (hH : 0 ≤ H) (hgM : ∀ t, g t ≠ 0 → |t| ≤ M) + (ε : ℝ) (hε : 0 < ε) (decayOrder J : ℕ) : + ∃ (windows : Fin 7 → ℝ → ℂ) (Cₐ Cₛ Cw : ℝ), + 0 < Cₐ ∧ 0 ≤ Cₛ ∧ 0 ≤ Cw ∧ + ∀ (D₀ E₀ V₀ X₀ K₀ : Finset ι → κ → ℝ) (Y : ℝ), + (∀ R j, 0 < D₀ R j) → (∀ R j, 0 < E₀ R j) → (∀ R j, 0 < V₀ R j) → + (∀ R j, 0 < X₀ R j) → (∀ R j, 0 < K₀ R j) → 0 < Y → + ∀ (A₀ B C D F : Finset ι) (v₁ v₂ : ι → ℕ) (ε₁ ε₂ : ι → Bool) + (χ : RayCharacter) (Ψ : O →* ℂ) (m : O) (r₁ : FirstCoreIndex) + (X Z t : ℝ) (Srows : Finset O) + (label : Finset ι → SecondExpansionData ι → κ) + (T : Finset ι → κ → Finset (Ideal O × O)) (lengthScale : Finset ι → κ → ℝ), + (∀ i ∈ B, 0 < v₁ i + v₂ i) → Disjoint C B → D ⊆ C ∪ B → + (∀ a : O, ‖Ψ a‖ ≤ 1) → 0 < X → 0 ≤ Z → + (∀ z ∈ Srows, (Ideal.absNorm (Ideal.span {z}) : ℝ) ≤ Y) → + (∀ z ∈ Srows, z ≠ 0) → + (∀ R ∈ (F\A₀).powerset, ∀ j, 0 ≤ lengthScale R j) → + (∀ R ∈ (F\A₀).powerset, ∀ j, + ∀ x ∈ secondDyadicSector (F\A₀) (firstCoreSecondCutoff p A₀ X Y M Z) R label j, + |secondSectorZ p + (secondExpansionScale p (X / primeProductNorm p A₀) + (primeSubsetGenerator (fun i => Ideal.span {p i}) R) (expansionSupportData C D x)) + (X₀ R j) (expansionSupportData C D x)| ≤ H) → + (∀ R ∈ (F\A₀).powerset, ∀ j, + ∀ x ∈ secondDyadicSector (F\A₀) (firstCoreSecondCutoff p A₀ X Y M Z) R label j, + |secondSectorUd p (D₀ R j) (expansionSupportData C D x)| ≤ H) → + (∀ R ∈ (F\A₀).powerset, ∀ j, + ∀ x ∈ secondDyadicSector (F\A₀) (firstCoreSecondCutoff p A₀ X Y M Z) R label j, + |secondSectorUe p (E₀ R j) (expansionSupportData C D x)| ≤ H) → + (∀ R ∈ (F\A₀).powerset, ∀ j, + ∀ x ∈ secondDyadicSector (F\A₀) (firstCoreSecondCutoff p A₀ X Y M Z) R label j, + |secondSectorUv p (V₀ R j) (expansionSupportData C D x)| ≤ H) → + (∀ R ∈ (F\A₀).powerset, ∀ j, + ∀ x ∈ secondDyadicSector (F\A₀) (firstCoreSecondCutoff p A₀ X Y M Z) R label j, + |secondSectorKap p (K₀ R j) (expansionSupportData C D x)| ≤ H) → + (∀ R ∈ (F\A₀).powerset, ∀ j, + ∀ x ∈ secondDyadicSector (F\A₀) (firstCoreSecondCutoff p A₀ X Y M Z) R label j, + (secondSupportNewLabel p B v₁ v₂ ε₁ ε₂ (expansionSupportData C D x), + secondSupportRow p (expansionSupportData C D x)) ∈ T R j) → + (∀ R ∈ (F\A₀).powerset, ∀ j, ∀ q ∈ T R j, q.1 ≠ ⊥) → + (∀ R ∈ (F\A₀).powerset, ∀ j, ∀ q ∈ T R j, (Ideal.absNorm q.1 : ℝ) ≤ lengthScale R j) → + let v := fun i => v₁ i + v₂ i + let c := primeSubsetGenerator (fun i => Ideal.span {p i}) C + let d := primeSubsetGenerator (fun i => Ideal.span {p i}) D + let Ψ' := firstCoreTwist negative χ Ψ r₁ + let m' := m * b0Label p B v ε₁ ε₂ + let c' := c * jLabel p B v ε₁ ε₂ + let X' := X / primeProductNorm p A₀ + let Hbase := normalizedColumn p (fun S => firstCoreBaseProfile g V negative (columnLog p X' S)) + let Hmode := normalizedColumn p (fun S => firstCoreModeProfile g V negative t (columnLog p X' S)) + (∑ z ∈ Srows, ‖firstCoreInputRow p hg F A₀ B v ε₁ ε₂ negative χ Ψ m + (normalizedColumn p (fun S => g (columnLog p X S))) V (columnLog p X) c d r₁ t z‖ ^ 2) + + ‖firstCoreTest (normalizedColumn p (fun S => g (columnLog p X S))) V (columnLog p X) + negative t A₀ ∅‖ ^ 2 ≤ + (primeProductNorm p A₀)⁻¹ * + (|Y| * ‖paperRadialFourier rowMajorant 0‖ * + (∑ G ∈ (F\A₀).powerset, ‖secondInputCoefficient p hg Ψ' m' c' d Hbase G‖ ^ 2) + + (∑ z : SecondRayIndex, ∑ R ∈ (F\A₀).powerset, ∑ j : κ, + (Y * ‖eisEmbedding (primeSubsetGenerator (fun i => Ideal.span {p i}) R)‖ ^ 2 / + X' ^ 2 * ‖secondRayCoefficient z‖ * Cw * Cₐ * + (lengthScale R j * Ideal.absNorm (Ideal.span {b0Label p B v ε₁ ε₂}))^ε) * + (Cₛ*(1+‖t‖)^(J+2)*(1+‖t‖)^(J+2) / + (1+Y*K₀ R j/(D₀ R j*(E₀ R j)^2*(V₀ R j)^2*(X₀ R j)^2))^decayOrder) * + densityChildEnergy p hp hcop hg (F\A₀) (secondRayMinus Ψ' z) (secondRayPlus Ψ' z) + (m' * primeSubsetGenerator (fun i => Ideal.span {p i}) R) (T R j) + (windows 5) (windows 6) (X₀ R j) (X₀ R j) J) + + ‖secondSourceTail p hp hg hinj (F\A₀) Ψ' m' c' d Hmode rowMajorant Y + (firstCoreSecondCutoff p A₀ X Y M Z)‖) := by + have hUbase : ∀ s, firstCoreBaseProfile g V negative s ≠ 0 → U s = 1 := by + intro s hs + apply hU s + intro hz + apply hs + simp only [firstCoreBaseProfile_apply, hz, zero_mul] + have hMbase : ∀ s, firstCoreBaseProfile g V negative s ≠ 0 → |s| ≤ M := by + intro s hs + apply hgM s + intro hz + apply hs + simp only [firstCoreBaseProfile_apply, hz, zero_mul] + obtain ⟨windows,Cₐ,Cₛ,Cw,hCₐ,hCₛ,hCw,htrans⟩ := + normalized_truncated_second_density_transfer (κ := κ) p hp hcop hg hinj hc hpr U hUc hUs + (firstCoreBaseProfile g V negative) rowMajorant hUbase M H hM hH hMbase ε hε decayOrder J + refine ⟨windows,Cₐ,Cₛ,Cw,hCₐ,hCₛ,hCw,?_⟩ + intro D₀ E₀ V₀ X₀ K₀ Y hD₀ hE₀ hV₀ hX₀ hK₀ hY + A₀ B C D F v₁ v₂ ε₁ ε₂ χ Ψ m r₁ X Z t Srows label T lengthScale hv hCB hD hΨ hX hZ hSrows hSrows0 + hL hz hud hue huv hkap hmap hT hnorm + dsimp only + have hX' : 0 < X / primeProductNorm p A₀ := + div_pos hX (FirstPassCubeLabels.primeProductNorm_pos p hp A₀) + have hΨ' : ∀ a : O, ‖firstCoreTwist negative χ Ψ r₁ a‖ ≤ 1 := + fun a => (firstCoreTwist_norm_le negative χ Ψ r₁ a).trans (hΨ a) + have hcut : ∀ G ∈ (F\A₀).powerset, ∀ E ∈ G.powerset, + (0 : O) ∈ firstCoreSecondCutoff p A₀ X Y M Z G E := by + intro G hG E hE + exact firstCoreSecondCutoff_zero p A₀ X Y M Z G E + have hb := htrans D₀ E₀ V₀ X₀ K₀ Y hD₀ hE₀ hV₀ hX₀ hK₀ hY (firstCoreModeHeight negative t) + B C D (F\A₀) v₁ v₂ ε₁ ε₂ (firstCoreTwist negative χ Ψ r₁) + (m * b0Label p B (fun i => v₁ i+v₂ i) ε₁ ε₂) (X / primeProductNorm p A₀) + (firstCoreSecondCutoff p A₀ X Y M Z) label T lengthScale hv hCB hD hΨ' hX' hcut hL + hz hud hue huv hkap hmap hT hnorm + simp only [firstCoreModeHeight_norm] at hb + have hf := firstCoreInputRow_finite_le_truncated_tail p hp hg hinj hc F A₀ B + (fun i => v₁ i+v₂ i) ε₁ ε₂ negative χ Ψ m g V X hX Y hY + (primeSubsetGenerator (fun i => Ideal.span {p i}) C) + (primeSubsetGenerator (fun i => Ideal.span {p i}) D) r₁ t Srows hSrows hSrows0 + (firstCoreSecondCutoff p A₀ X Y M Z) + simp only [firstCoreModeProfile] at hf ⊢ + apply hf.trans + apply mul_le_mul_of_nonneg_left + · apply add_le_add + · exact hb + · exact le_rfl + · exact inv_nonneg.mpr (FirstPassCubeLabels.primeProductNorm_pos p hp A₀).le + +end + +open ActualEisensteinCubic +open FirstPassCubeLabels (columnLog normalizedColumn primeProductNorm) +open ConcreteTraceCRT (eisEmbedding) +open JointLogSeparation (frequencyTwist frequencyTwist_apply) + +section +variable {ι : Type*} [DecidableEq ι] + (p : ι → O) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + +omit [DecidableEq ι] in +lemma residualPairWeight_test_ne_zero + (Ψ₁ Ψ₂ : O →* ℂ) (m c d : O) (H₁ H₂ : Finset ι → ℂ) (S T : Finset ι) + (hw : residualPairWeight p hg Ψ₁ Ψ₂ m c d H₁ H₂ S T ≠ 0) : + H₁ S ≠ 0 ∧ H₂ T ≠ 0 := by + constructor + · intro hz + apply hw + simp only [residualPairWeight, secondInputCoefficient, hz, mul_zero, star_zero, zero_mul] + · intro hz + apply hw + simp only [residualPairWeight, secondInputCoefficient, hz, mul_zero] + +theorem residualTailCost_frequencyTwist + (F G : Finset ι) (Ψ₁ Ψ₂ : O →* ℂ) (m c d e : O) + (g : 𝓢(ℝ, ℂ)) (θ X Y H : ℝ) (A : ℕ) (P : ℝ) : + residualTailCost p hg F G Ψ₁ Ψ₂ m c d + (fun S => normalizedColumn p (fun U => (frequencyTwist g θ) (columnLog p X U)) (G∪S)) + (fun S => normalizedColumn p (fun U => (frequencyTwist g θ) (columnLog p X U)) (G∪S)) e Y H A P = + residualTailCost p hg F G Ψ₁ Ψ₂ m c d + (fun S => normalizedColumn p (fun U => g (columnLog p X U)) (G∪S)) + (fun S => normalizedColumn p (fun U => g (columnLog p X U)) (G∪S)) e Y H A P := by + simp only [residualTailCost, residualPairWeight, secondInputCoefficient, normalizedColumn, + frequencyTwist_apply, norm_mul, norm_star, norm_div, FourierBridge.logPhase_norm, one_mul] + +end + +theorem firstCoreSecondCutoff_tail_bound + {ι : Type*} [DecidableEq ι] + (p : ι → O) (hp : ∀ i, p i ≠ 0) [∀ i, (Ideal.span {p i}).IsMaximal] + (hg : ∀ i, lambda ∉ Ideal.span {p i}) + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀ i, ringChar (O ⧸ Ideal.span {p i}) ≠ 2) (A : ℕ) : + ∃ (s : Finset (ℕ × ℕ)) (C : ℝ), 0 < C ∧ + ∀ (F D : Finset ι) (Ψ : O →* ℂ) (m c d : O) (g V W : 𝓢(ℝ, ℂ)) + (negative : Bool) (t X Y M H : ℝ), + 0 < X → 0 < Y → 0 ≤ H → (∀ u, g u ≠ 0 → |u| ≤ M) → + let X' := X / primeProductNorm p D + let Hbase := normalizedColumn p (fun S => firstCoreBaseProfile g V negative (columnLog p X' S)) + let Hmode := normalizedColumn p (fun S => firstCoreModeProfile g V negative t (columnLog p X' S)) + ‖secondSourceTail p hp hg hinj (F\D) Ψ m c d Hmode W Y (firstCoreSecondCutoff p D X Y M H)‖ ≤ + ∑ G ∈ (F\D).powerset, ∑ E : G.powerset, + ‖secondSourceCommonCoefficient p hg Ψ m c d G E.val‖ * + residualTailCost p hg (F\D) G Ψ Ψ m c d (fun S => Hbase (G∪S)) (fun S => Hbase (G∪S)) + (primeSubsetGenerator (fun i => Ideal.span {p i}) E.val) Y H A + (C*s.sup (schwartzSeminormFamily ℝ ℝ ℂ) W) := by + obtain ⟨s,C,hC,hb⟩ := secondSourceTail_bound p hp hg hinj hc A + refine ⟨s,C,hC,?_⟩ + intro F D Ψ m c d g V W negative t X Y M H hX hY hH hgM + dsimp only + have hcut : ∀ G ∈ (F\D).powerset, ∀ E : G.powerset, + ∀ S ∈ ((F\D)\G).powerset, ∀ T ∈ ((F\D)\G).powerset, Disjoint S T → + residualPairWeight p hg Ψ Ψ m c d + (fun U => normalizedColumn p (fun R => firstCoreModeProfile g V negative t + (columnLog p (X / primeProductNorm p D) R)) (G∪U)) + (fun U => normalizedColumn p (fun R => firstCoreModeProfile g V negative t + (columnLog p (X / primeProductNorm p D) R)) (G∪U)) S T ≠ 0 → + ∀ k : O, k ∉ firstCoreSecondCutoff p D X Y M H G E.val → + H ≤ (Y / (‖eisEmbedding (primeSubsetGenerator (fun i => Ideal.span {p i}) E.val)‖^2 * + ‖eisEmbedding (∏ i : activeSupport T S, p i.val)‖^2)) * ‖eisEmbedding k‖^2 := by + intro G hG E S hS T hT hST hw k hk + have hGS : Disjoint G S := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hS) disjoint_sdiff_self_right + have hGT : Disjoint G T := Finset.disjoint_of_subset_right + (Finset.mem_powerset.mp hT) disjoint_sdiff_self_right + obtain ⟨hs,ht⟩ := residualPairWeight_test_ne_zero p hg Ψ Ψ m c d _ _ S T hw + exact firstCoreSecondCutoff_uniform p hp g V negative t M hgM D G E.val S T hGS hGT hST + X Y H hX hY hs ht k hk + have h := hb (F\D) Ψ m c d + (normalizedColumn p (fun S => firstCoreModeProfile g V negative t + (columnLog p (X / primeProductNorm p D) S))) W Y H hY hH + (firstCoreSecondCutoff p D X Y M H) hcut + simpa only [firstCoreModeProfile, residualTailCost_frequencyTwist] using h + +end SecondPassArithmetic + +open scoped BigOperators Classical +namespace CanonicalQuadraticSieve + +section +open ActualEisensteinCubic IdealMobiusDivisorSum IdealCoprimeSieveOperator + +lemma divisorPool_filter (S : Finset (Ideal O)) (B : Ideal O) (hB : B ≠ 0) + (hS : ∀ D, D ∣ B → D ∈ S) : + S.filter (fun D => D ∣ B) = idealDivisors B := by + ext D + simp only [Finset.mem_filter, mem_idealDivisors hB] + exact ⟨And.right, fun h => ⟨hS D h,h⟩⟩ + +lemma divisor_product_delta (S T : Finset (Ideal O)) (B C d : Ideal O) + (hB : B ≠ 0) (hC : C ≠ 0) (hBC : IsCoprime B C) + (hS : ∀ D, D ∣ B → D ∈ S) (hT : ∀ E, E ∣ C → E ∈ T) + (f : Ideal O → ℂ) : + (∑ D ∈ S, if D ∣ B then + ∑ E ∈ T, if E ∣ C then (if D*E=d then f (D*E) else 0) else 0 else 0) = + if d ∣ B*C then f d else 0 := by + have hs := QuadraticDivisorSplit.sum_divisors_coprime_product B C hB hC hBC + (fun q => if q=d then f q else 0) + have hleft : (∑ q ∈ idealDivisors (B*C), if q=d then f q else 0) = + if d ∣ B*C then f d else 0 := by + simp [mem_idealDivisors (mul_ne_zero hB hC)] + rw [hleft] at hs + rw [← divisorPool_filter S B hB hS, ← divisorPool_filter T C hC hT] at hs + simpa only [Finset.sum_filter] using hs.symm + +private lemma four_sums_exchange {α β γ deltaLoss : Type*} + (S : Finset α) (T : Finset β) (U : Finset γ) (V : Finset deltaLoss) + (f : α → β → γ → deltaLoss → ℂ) : + (∑ a ∈ S, ∑ b ∈ T, ∑ c ∈ U, ∑ d ∈ V, f a b c d) = + ∑ c ∈ U, ∑ d ∈ V, ∑ a ∈ S, ∑ b ∈ T, f a b c d := by + have h : (∑ ab ∈ S ×ˢ T, ∑ cd ∈ U ×ˢ V, f ab.1 ab.2 cd.1 cd.2) = + ∑ cd ∈ U ×ˢ V, ∑ ab ∈ S ×ˢ T, f ab.1 ab.2 cd.1 cd.2 := Finset.sum_comm + simpa only [Finset.sum_product] using h + +private lemma three_sums_exchange {α β γ : Type*} + (S : Finset α) (T : Finset β) (U : Finset γ) (f : α → β → γ → ℝ) : + (∑ a ∈ S, ∑ b ∈ T, ∑ c ∈ U, f a b c) = + ∑ b ∈ T, ∑ c ∈ U, ∑ a ∈ S, f a b c := by + have h : (∑ a ∈ S, ∑ bc ∈ T ×ˢ U, f a bc.1 bc.2) = + ∑ bc ∈ T ×ˢ U, ∑ a ∈ S, f a bc.1 bc.2 := Finset.sum_comm + simpa only [Finset.sum_product] using h + +variable {m n p : Type*} [Fintype m] [Fintype n] [Fintype p] + [DecidableEq m] [DecidableEq n] [DecidableEq p] + +omit [Fintype m] [Fintype n] [Fintype p] [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem originalTerm_product_divisor (S T : Finset (Ideal O)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (d : Ideal O) (i : m) (j : n) (k : p) + (hleft : ∀ j, left j ≠ 0) (hright : ∀ k, right k ≠ 0) + (hS : ∀ j D, D ∣ left j → D ∈ S) (hT : ∀ k E, E ∣ right k → E ∈ T) + (F : Ideal O → m → n → p → ℂ) : + (∑ D ∈ S, ∑ E ∈ T, if D*E=d then + originalTerm rows left right a b D E i j k * F (D*E) i j k else 0) = + (if d ∣ left j*right k then + originalTerm rows left right a b 1 1 i j k * F d i j k else 0) := by + by_cases hc : IsCoprime (left j) (right k) + · have hd := divisor_product_delta S T (left j) (right k) d (hleft j) (hright k) hc + (hS j) (hT k) (fun q => + star (quadraticRow (left j) (CompletedGauss.primaryGenerator (rows i)) * a j) * + (quadraticRow (right k) (CompletedGauss.primaryGenerator (rows i)) * b k) * F q i j k) + calc + _ = (∑ D ∈ S, if D ∣ left j then ∑ E ∈ T, if E ∣ right k then + (if D*E=d then + star (quadraticRow (left j) (CompletedGauss.primaryGenerator (rows i)) * a j) * + (quadraticRow (right k) (CompletedGauss.primaryGenerator (rows i)) * b k) * F (D*E) i j k + else 0) else 0 else 0) := by + apply Finset.sum_congr rfl + intro D hD + by_cases hd : D ∣ left j + · simp only [ite_eq_left hd] + apply Finset.sum_congr rfl + intro E hE + by_cases he : E ∣ right k <;> by_cases hde : D*E=d <;> + simp [originalTerm,hc,hd,he,hde] + · simp [originalTerm,hc,hd] + _ = _ := by simpa [originalTerm,hc] using hd + · simp [originalTerm,hc] + +omit [Fintype m] [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem originalColumnSum_product_divisor (S T : Finset (Ideal O)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (d : Ideal O) (i : m) + (hleft : ∀ j, left j ≠ 0) (hright : ∀ k, right k ≠ 0) + (hS : ∀ j D, D ∣ left j → D ∈ S) (hT : ∀ k E, E ∣ right k → E ∈ T) + (F : Ideal O → m → n → p → ℂ) : + (∑ j, ∑ k, if d ∣ left j*right k then + originalTerm rows left right a b 1 1 i j k * F d i j k else 0) = + ∑ D ∈ S, ∑ E ∈ T, if D*E=d then + (∑ j, ∑ k, originalTerm rows left right a b D E i j k * F (D*E) i j k) else 0 := by + calc + _ = ∑ j, ∑ k, ∑ D ∈ S, ∑ E ∈ T, if D*E=d then + originalTerm rows left right a b D E i j k * F (D*E) i j k else 0 := by + apply Finset.sum_congr rfl + intro j hj + apply Finset.sum_congr rfl + intro k hk + exact (originalTerm_product_divisor S T rows left right a b d i j k hleft hright hS hT F).symm + _ = ∑ D ∈ S, ∑ E ∈ T, ∑ j, ∑ k, if D*E=d then + originalTerm rows left right a b D E i j k * F (D*E) i j k else 0 := + four_sums_exchange Finset.univ Finset.univ S T _ + _ = _ := by + apply Finset.sum_congr rfl + intro D hD + apply Finset.sum_congr rfl + intro E hE + by_cases h : D*E=d <;> simp [h] + +omit [Fintype m] [DecidableEq m] [DecidableEq n] [DecidableEq p] in +theorem originalColumnSum_divisor_rectangles (K S T : Finset (Ideal O)) + (rows : m → Ideal O) (left : n → Ideal O) (right : p → Ideal O) + (a : n → ℂ) (b : p → ℂ) (i : m) + (hleft : ∀ j, left j ≠ 0) (hright : ∀ k, right k ≠ 0) + (hS : ∀ j D, D ∣ left j → D ∈ S) (hT : ∀ k E, E ∣ right k → E ∈ T) + (P : Ideal O → m → Prop) [DecidablePred (fun d => P d i)] + (F : Ideal O → m → n → p → ℂ) : + (∑ d ∈ K, if P d i then ‖∑ j, ∑ k, if d ∣ left j*right k then + originalTerm rows left right a b 1 1 i j k * F d i j k else 0‖ else 0) ≤ + ∑ D ∈ S, ∑ E ∈ T, if D*E ∈ K then if P (D*E) i then + ‖∑ j, ∑ k, originalTerm rows left right a b D E i j k * F (D*E) i j k‖ else 0 else 0 := by + let B := fun D E => ∑ j, ∑ k, originalTerm rows left right a b D E i j k * F (D*E) i j k + have hpoint (d : Ideal O) : + (if P d i then ‖∑ j, ∑ k, if d ∣ left j*right k then + originalTerm rows left right a b 1 1 i j k * F d i j k else 0‖ else 0) ≤ + ∑ D ∈ S, ∑ E ∈ T, if D*E=d ∧ P d i then ‖B D E‖ else 0 := by + by_cases hp : P d i + · simp only [hp, and_true] + rw [originalColumnSum_product_divisor S T rows left right a b d i hleft hright hS hT F] + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro D hD + apply (norm_sum_le _ _).trans + apply Finset.sum_le_sum + intro E hE + by_cases h : D*E=d <;> simp [h,B] + · simp [hp] + calc + _ ≤ ∑ d ∈ K, ∑ D ∈ S, ∑ E ∈ T, if D*E=d ∧ P d i then ‖B D E‖ else 0 := + Finset.sum_le_sum (fun d hd => hpoint d) + _ = ∑ D ∈ S, ∑ E ∈ T, ∑ d ∈ K, if D*E=d ∧ P d i then ‖B D E‖ else 0 := + three_sums_exchange K S T _ + _ = _ := by + apply Finset.sum_congr rfl + intro D hD + apply Finset.sum_congr rfl + intro E hE + have heq (d : Ideal O) : (if D*E=d ∧ P d i then ‖B D E‖ else 0) = + if d=D*E then (if P (D*E) i then ‖B D E‖ else 0) else 0 := by + by_cases h : d=D*E + · subst d + simp + · simp [h,Ne.symm h] + simp_rw [heq] + simp only [Finset.sum_ite_eq', B] + +end + +open ActualEisensteinCubic + +lemma positive_ideal_dyadic_exists (N : ℝ) (D : Ideal O) + (hD : 1 ≤ (Ideal.absNorm D : ℝ)) (hDN : (Ideal.absNorm D : ℝ) ≤ N) : + ∃ j ∈ Finset.range (columnDyadicLength N + 1), + (2 : ℝ)^j/2 < (Ideal.absNorm D : ℝ) ∧ (Ideal.absNorm D : ℝ) ≤ (2 : ℝ)^j := by + have hp : 1 ≤ Ideal.absNorm D := by exact_mod_cast hD + exact exists_dyadic_shell (Ideal.absNorm D) (columnDyadicLength N) hp + (hDN.trans (columnDyadicLength_cover N)) + +def divisorDyadicLabel (N : ℝ) (D : Ideal O) : Fin (columnDyadicLength N+1) := + if h : 1 ≤ (Ideal.absNorm D : ℝ) ∧ (Ideal.absNorm D : ℝ) ≤ N then + ⟨(positive_ideal_dyadic_exists N D h.1 h.2).choose, + Finset.mem_range.mp (positive_ideal_dyadic_exists N D h.1 h.2).choose_spec.1⟩ + else ⟨0,by omega⟩ + +def divisorDyadicBin (S : Finset (Ideal O)) (N : ℝ) + (j : Fin (columnDyadicLength N+1)) : Finset (Ideal O) := + S.filter (fun D => divisorDyadicLabel N D = j) + +def divisorDyadicScale (j : ℕ) : ℝ := max 1 ((2 : ℝ)^j/2) + +lemma divisorDyadicLabel_bounds (N : ℝ) (D : Ideal O) + (hD : 1 ≤ (Ideal.absNorm D : ℝ)) (hDN : (Ideal.absNorm D : ℝ) ≤ N) : + (2 : ℝ)^(divisorDyadicLabel N D).val/2 < (Ideal.absNorm D : ℝ) ∧ + (Ideal.absNorm D : ℝ) ≤ (2 : ℝ)^(divisorDyadicLabel N D).val := by + unfold divisorDyadicLabel + rw [dite_eq_left ⟨hD,hDN⟩] + exact (positive_ideal_dyadic_exists N D hD hDN).choose_spec.2 + +lemma divisorDyadicScale_ge_one (j : ℕ) : 1 ≤ divisorDyadicScale j := le_max_left _ _ + +theorem divisorDyadicBin_bounds (S : Finset (Ideal O)) (N : ℝ) + (hS : ∀ D ∈ S, 1 ≤ (Ideal.absNorm D : ℝ) ∧ (Ideal.absNorm D : ℝ) ≤ N) + (j : Fin (columnDyadicLength N+1)) (D : Ideal O) (hD : D ∈ divisorDyadicBin S N j) : + divisorDyadicScale j.val ≤ (Ideal.absNorm D : ℝ) ∧ + (Ideal.absNorm D : ℝ) ≤ 2 * divisorDyadicScale j.val := by + obtain ⟨hDS,hj⟩ := Finset.mem_filter.mp hD + have hd := hS D hDS + have hb := divisorDyadicLabel_bounds N D hd.1 hd.2 + rw [hj] at hb + refine ⟨max_le hd.1 hb.1.le, ?_⟩ + have hm : (2 : ℝ)^j.val/2 ≤ divisorDyadicScale j.val := le_max_right _ _ + linarith [hb.2] + +theorem divisorDyadicBin_scale_le (S : Finset (Ideal O)) (N : ℝ) + (hS : ∀ D ∈ S, 1 ≤ (Ideal.absNorm D : ℝ) ∧ (Ideal.absNorm D : ℝ) ≤ N) + (j : Fin (columnDyadicLength N+1)) (hj : (divisorDyadicBin S N j).Nonempty) : + divisorDyadicScale j.val ≤ N := by + obtain ⟨D,hD⟩ := hj + exact (divisorDyadicBin_bounds S N hS j D hD).1.trans (hS D (Finset.mem_filter.mp hD).1).2 + +theorem sum_divisorDyadicBins {A : Type*} [AddCommMonoid A] + (S : Finset (Ideal O)) (N : ℝ) (f : Ideal O → A) : + (∑ D ∈ S, f D) = ∑ j : Fin (columnDyadicLength N+1), ∑ D ∈ divisorDyadicBin S N j, f D := by + simp only [divisorDyadicBin,Finset.sum_filter] + rw [Finset.sum_comm] + apply Finset.sum_congr rfl + intro D hD + simp + +theorem sum_divisorDyadicRectangles {A : Type*} [AddCommMonoid A] + (S T : Finset (Ideal O)) (N : ℝ) (f : Ideal O → Ideal O → A) : + (∑ D ∈ S, ∑ E ∈ T, f D E) = + ∑ j : Fin (columnDyadicLength N+1), ∑ k : Fin (columnDyadicLength N+1), + ∑ D ∈ divisorDyadicBin S N j, ∑ E ∈ divisorDyadicBin T N k, f D E := by + calc + _ = ∑ j : Fin (columnDyadicLength N+1), ∑ D ∈ divisorDyadicBin S N j, + ∑ E ∈ T, f D E := sum_divisorDyadicBins S N _ + _ = ∑ j : Fin (columnDyadicLength N+1), ∑ D ∈ divisorDyadicBin S N j, + ∑ k : Fin (columnDyadicLength N+1), ∑ E ∈ divisorDyadicBin T N k, f D E := by + apply Finset.sum_congr rfl + intro j hj + apply Finset.sum_congr rfl + intro D hD + exact sum_divisorDyadicBins T N (f D) + _ = _ := by + apply Finset.sum_congr rfl + intro j hj + exact Finset.sum_comm + +def columnDivisorPool {n : Type*} [Fintype n] (left : n → Ideal O) : Finset (Ideal O) := + Finset.univ.biUnion (fun j => IdealMobiusDivisorSum.idealDivisors (left j)) + +theorem mem_columnDivisorPool_of_dvd {n : Type*} [Fintype n] + (left : n → Ideal O) (hleft : ∀ j, left j ≠ 0) (j : n) (D : Ideal O) + (hD : D ∣ left j) : D ∈ columnDivisorPool left := by + apply Finset.mem_biUnion.mpr + exact ⟨j,Finset.mem_univ j,(IdealMobiusDivisorSum.mem_idealDivisors (hleft j)).mpr hD⟩ + +theorem columnDivisorPool_norm_bounds {n : Type*} [Fintype n] + (left : n → Ideal O) (hleft : ∀ j, left j ≠ 0) (N : ℝ) + (hN : ∀ j, (Ideal.absNorm (left j) : ℝ) ≤ N) + (D : Ideal O) (hD : D ∈ columnDivisorPool left) : + 1 ≤ (Ideal.absNorm D : ℝ) ∧ (Ideal.absNorm D : ℝ) ≤ N := by + obtain ⟨j,hj,hDj⟩ := Finset.mem_biUnion.mp hD + have hd := (IdealMobiusDivisorSum.mem_idealDivisors (hleft j)).mp hDj + have hDz : D ≠ 0 := by + intro hz + rw [hz,zero_dvd_iff] at hd + exact hleft j hd + have hDN : Ideal.absNorm D ≤ Ideal.absNorm (left j) := + Nat.le_of_dvd (Nat.pos_iff_ne_zero.mpr (fun h => hleft j (Ideal.absNorm_eq_zero_iff.mp h))) + (map_dvd Ideal.absNorm hd) + refine ⟨?_,(Nat.cast_le.mpr hDN).trans (hN j)⟩ + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (fun h => hDz (Ideal.absNorm_eq_zero_iff.mp h)) + +end CanonicalQuadraticSieve + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SmoothTests.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SmoothTests.lean new file mode 100644 index 0000000000000000000000000000000000000000..134db6c6372afc799390b6fd13de7b01b6543733 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SmoothTests.lean @@ -0,0 +1,651 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.RowCaps + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators + +namespace CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Matrix ContDiff Manifold + +instance hyperbolicSpatialChartedSpace : ChartedSpace SpatialCoordinates HyperbolicSpace := + hyperbolicSpatialChart.singletonChartedSpace hyperbolicSpatialChart_source + +instance hyperbolicSpatialIsManifold : IsManifold 𝓘(ℝ,SpatialCoordinates) ∞ HyperbolicSpace := + hyperbolicSpatialChart.isManifold_singleton hyperbolicSpatialChart_source + +lemma kernelLocalLift_source_out (q : KernelQuotient) : q∈(kernelLocalLift q.out).source := by + have h := kernelQuotient_localHomeomorph.apply_self_mem_localInverseAt_source (x := q.out) + change integralOrbitProjection globalKubotaKernel q.out∈(kernelLocalLift q.out).source at h + rwa [show integralOrbitProjection globalKubotaKernel q.out=q from Quotient.out_eq q] at h + +instance kernelSpatialChartedSpace : ChartedSpace SpatialCoordinates KernelQuotient where + atlas := Set.range kernelQuotientChart + chartAt := kernelQuotientChart + mem_chart_source q := ⟨kernelLocalLift_source_out q,Set.mem_univ _⟩ + chart_mem_atlas q := ⟨q,rfl⟩ + +instance kernelSpatialIsManifold : IsManifold 𝓘(ℝ,SpatialCoordinates) ∞ KernelQuotient := by + apply isManifold_of_contDiffOn + rintro e e' ⟨q,rfl⟩ ⟨r,rfl⟩ + simpa only [modelWithCornersSelf_coe,modelWithCornersSelf_coe_symm,Function.id_comp, + Function.comp_id,Set.preimage_id_eq,Set.range_id,Set.inter_univ,id_eq] using + kernelQuotientChart_contDiffOn q r + +@[simp] lemma hyperbolicSpatial_chartAt (w : HyperbolicSpace) : + chartAt SpatialCoordinates w=hyperbolicSpatialChart := rfl + +@[simp] lemma kernelSpatial_chartAt (q : KernelQuotient) : + chartAt SpatialCoordinates q=kernelQuotientChart q := rfl + +lemma kernelProjection_contMDiff : ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,SpatialCoordinates) ∞ + (integralOrbitProjection globalKubotaKernel) := by + intro w + rw [contMDiffAt_iff] + refine ⟨(continuous_integralOrbitProjection globalKubotaKernel).continuousAt,?_⟩ + have hp : hyperbolicSpatialCoordinates w∈hyperbolicSpatialChart.target := + hyperbolicSpatialChart.map_source (Set.mem_univ _) + have hq : integralOrbitProjection globalKubotaKernel + (hyperbolicSpatialChart.symm (hyperbolicSpatialCoordinates w))∈ + (kernelLocalLift (integralOrbitProjection globalKubotaKernel w).out).source := by + have hleft := hyperbolicSpatialChart.left_inv (Set.mem_univ w) + change hyperbolicSpatialChart.symm (hyperbolicSpatialCoordinates w)=w at hleft + rw [hleft] + exact kernelLocalLift_source_out _ + have h : ContDiffWithinAt ℝ ∞ + (kernelCoordinateTransition (integralOrbitProjection globalKubotaKernel w).out) Set.univ + (hyperbolicSpatialCoordinates w) := + (kernelCoordinateTransition_contDiffAt _ _ hp hq).contDiffWithinAt + unfold kernelCoordinateTransition at h + simpa only [extChartAt_coe,extChartAt_coe_symm,modelWithCornersSelf_coe, + modelWithCornersSelf_coe_symm,Function.id_comp,Function.comp_id,Set.range_id, + kernelSpatial_chartAt,hyperbolicSpatial_chartAt,kernelCoordinateTransition, + kernelQuotientChart,OpenPartialHomeomorph.trans_apply,Function.comp_def, + hyperbolicSpatialChart_apply,id_eq] using h + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold ENNReal NNReal + +def kernelSmoothTests : Submodule ℂ (KernelQuotient→ℂ) where + carrier f := ContMDiff 𝓘(ℝ,SpatialCoordinates) 𝓘(ℝ,ℂ) ∞ f ∧ HasCompactSupport f + zero_mem' := ⟨contMDiff_const,HasCompactSupport.zero⟩ + add_mem' hf hg := ⟨hf.1.add hg.1,hf.2.add hg.2⟩ + smul_mem' c f hf := by + have hc : ContDiff ℝ ∞ (fun z : ℂ => c*z) := contDiff_const.mul contDiff_id + exact ⟨hc.contMDiff.comp hf.1,hf.2.smul_left⟩ + +lemma kernelSmoothTests_memLp (f : kernelSmoothTests) : + MemLp f.1 2 (integralQuotientVolume globalKubotaKernel) := + f.2.1.continuous.memLp_of_hasCompactSupport f.2.2 + +def kernelSmoothTestsToL2 : kernelSmoothTests→ₗ[ℂ]KernelQuotientL2 where + toFun f := (kernelSmoothTests_memLp f).toLp f.1 + map_add' _ _ := rfl + map_smul' _ _ := rfl + +lemma kernelSmoothTestsToL2_injective : Function.Injective kernelSmoothTestsToL2 := by + intro f g hfg + apply Subtype.ext + apply kernel_continuous_eq_of_ae_eq _ _ f.2.1.continuous g.2.1.continuous + exact ((kernelSmoothTests_memLp f).toLp_eq_toLp_iff (kernelSmoothTests_memLp g)).mp hfg + +lemma kernelL2_smooth_compact_approx (f : KernelQuotientL2) (ε : ℝ) (hε : 0<ε) : + ∃g : kernelSmoothTests, + eLpNorm ((f : KernelQuotient→ℂ)-g.1) 2 (integralQuotientVolume globalKubotaKernel)≤ + ENNReal.ofReal ε := by + obtain ⟨g,hgK,hfg,hgc,hgLp⟩ := kernelL2_continuous_compact_approx f + (ENNReal.ofReal (ε/2)) (by positivity) + let mass : ℝ≥0∞ := (integralQuotientVolume globalKubotaKernel Set.univ)^((2:ℝ≥0∞).toReal⁻¹) + have hm : mass≠(∞:ℝ≥0∞) := ENNReal.rpow_ne_top_of_nonneg (by norm_num) (measure_ne_top _ _) + let deltaLoss : ℝ := ε/(2*(mass.toReal+1)) + have hδ : 0 deltaLoss) continuous_const (fun _ => hδ) + have hkK : HasCompactSupport (k : KernelQuotient→ℂ) := + HasCompactSupport.of_support_subset_isCompact hgK (hksupp.trans (subset_tsupport g)) + let kt : kernelSmoothTests := ⟨k,k.contMDiff,hkK⟩ + have hkgLp : eLpNorm (g-(k : KernelQuotient→ℂ)) 2 (integralQuotientVolume globalKubotaKernel)≤ + ENNReal.ofReal (ε/2) := by + have hb : ∀ᵐ q ∂integralQuotientVolume globalKubotaKernel,‖g q-k q‖≤deltaLoss := + Filter.Eventually.of_forall fun q => by + simpa only [dist_eq_norm,norm_sub_rev] using (hkg q).le + have hmul : mass.toReal*deltaLoss≤ε/2 := by + have he : deltaLoss*(2*(mass.toReal+1))=ε := div_mul_cancel₀ _ (by positivity) + have hp := ENNReal.toReal_nonneg (a := mass) + nlinarith [mul_nonneg hp hδ.le] + calc + _ ≤ mass*ENNReal.ofReal deltaLoss := eLpNorm_le_of_ae_bound (hgc.sub k.contMDiff.continuous).aestronglyMeasurable hb + _ = ENNReal.ofReal (mass.toReal*deltaLoss) := by + rw [ENNReal.ofReal_mul ENNReal.toReal_nonneg,ENNReal.ofReal_toReal hm] + _ ≤ ENNReal.ofReal (ε/2) := ENNReal.ofReal_le_ofReal hmul + refine ⟨kt,?_⟩ + have he : (f : KernelQuotient→ℂ)-kt.1=((f : KernelQuotient→ℂ)-g)+(g-(k : KernelQuotient→ℂ)) := by + funext q + change f q-k q=(f q-g q)+(g q-k q) + ring + rw [he] + calc + _ ≤ eLpNorm ((f : KernelQuotient→ℂ)-g) 2 (integralQuotientVolume globalKubotaKernel)+ + eLpNorm (g-(k : KernelQuotient→ℂ)) 2 (integralQuotientVolume globalKubotaKernel) := + eLpNorm_add_le (by norm_num) + _ ≤ ENNReal.ofReal (ε/2)+ENNReal.ofReal (ε/2) := add_le_add hfg hkgLp + _ = ENNReal.ofReal ε := by rw [← ENNReal.ofReal_add (by positivity) (by positivity)]; congr 1; ring + +lemma kernelSmoothTestsToL2_dense : DenseRange kernelSmoothTestsToL2 := by + apply Metric.denseRange_iff.mpr + intro f ε hε + obtain ⟨g,hg⟩ := kernelL2_smooth_compact_approx f (ε/2) (by positivity) + refine ⟨g,?_⟩ + have he : ‖f-kernelSmoothTestsToL2 g‖= + (eLpNorm ((f : KernelQuotient→ℂ)-g.1) 2 (integralQuotientVolume globalKubotaKernel)).toReal := by + rw [Lp.norm_def] + congr 1 + apply eLpNorm_congr_ae + exact (Lp.coeFn_sub _ _).trans ((Filter.EventuallyEq.refl _ _).sub + (kernelSmoothTests_memLp g).coeFn_toLp) + rw [dist_eq_norm,he] + exact lt_of_le_of_lt ((ENNReal.toReal_mono (by simp) hg).trans_eq (ENNReal.toReal_ofReal (by positivity))) + (by linarith) + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff Manifold ENNReal + +lemma hyperbolicSpatialChart_symm_eq {p : SpatialCoordinates} + (hp : p∈hyperbolicSpatialChart.target) : + hyperbolicSpatialChart.symm p=upperPoint (spatialHorizontal p) (p 2) + (hyperbolicSpatialChart_target_positive hp) := by + have h := hyperbolicSpatialCoordinates_reconstruct (hyperbolicSpatialChart.symm p) + have he : hyperbolicSpatialCoordinates (hyperbolicSpatialChart.symm p)=p := + hyperbolicSpatialChart.right_inv hp + simpa only [he,spatialHorizontal] using h.symm + +lemma kernelQuotientDefect_coordinate (a b : ℝ) (s : ℂ) (q : KernelQuotient) + {p : SpatialCoordinates} (hp : p∈hyperbolicSpatialChart.target) : + kernelQuotientDefect a b s ((kernelQuotientChart q).symm p)=smoothCuspSeedDefectField a b s p := by + rw [kernelQuotientChart_symm,hyperbolicSpatialChart_symm_eq hp] + change smoothCuspSeedDefect a b s _=smoothCuspSeedDefectField a b s p + rw [smoothCuspSeedDefectField,dite_eq_left (hyperbolicSpatialChart_target_positive hp)] + rfl + +lemma kernelQuotientDefect_contMDiff (a b : ℝ) (s : ℂ) (ha : 1 kernelQuotientDefect a b s ((kernelQuotientChart q).symm p))=ᶠ[𝓝 (kernelQuotientChart q q)] + smoothCuspSeedDefectField a b s := by + filter_upwards [hyperbolicSpatialChart.open_target.mem_nhds hp] with p hp + exact kernelQuotientDefect_coordinate a b s q hp + have hh := hF.congr_of_eventuallyEq he + have hh' := hh.contDiffWithinAt (s := Set.univ) + simpa only [extChartAt_coe,extChartAt_coe_symm,modelWithCornersSelf_coe, + modelWithCornersSelf_coe_symm,Function.id_comp,Function.comp_id,Set.range_id, + chartAt_self_eq,kernelSpatial_chartAt,OpenPartialHomeomorph.refl_apply,Function.comp_def,id_eq] using hh' + +def kernelDefectSmoothTest (a b : ℝ) (ha : 1 Ideal.span {p i}) x.divisor)*elementNorm r) := by + rw [residualScale,quotient_norm_fixed p r x hx] + +variable (hp : ∀i,p i≠0) + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + +theorem postCommonSmoothPair_fixed_mask (F : Finset ι) (Ψ₁ Ψ₂ : O→*ℂ) (m r f y₁ y₂ : O) + (x : SecondExpansionData ι) (hx : InSecondQuotientSector p r x) + (A₁ A₂ W : 𝓢(ℝ,ℂ)) (V : Fin 7→ℝ→ℂ) (z ud ue uv kap X₁ X₂ R : ℝ) : + postCommonSmoothPair p hp hcop hg F Ψ₁ Ψ₂ (m*secondExpansionQuotient p x) f y₁ y₂ + A₁ A₂ W V z ud ue uv kap X₁ X₂ R= + postCommonSmoothPair p hp hcop hg F Ψ₁ Ψ₂ (m*r) f y₁ y₂ + A₁ A₂ W V z ud ue uv kap X₁ X₂ R := by + have hm : Ideal.span {m*secondExpansionQuotient p x}=Ideal.span {m*r} := by + rw [←Ideal.span_singleton_mul_span_singleton,←Ideal.span_singleton_mul_span_singleton, + quotient_span_fixed p r x hx] + simp only [postCommonSmoothPair,secondChildColumn,rowCoprimeMask_congr_span p _ hm] + +theorem sourceWeight_norm_fixed + (hinj : Function.Injective (fun i => Ideal.span {p i})) + (hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (Ψ : O→*ℂ) (m r : O) (ray : SecondRayIndex) (Z H : ℝ) (x : SecondExpansionData ι) + (hx : InSecondQuotientSector p r x) (hZ : 0 Ideal.span {p i}) x.divisor)/E) +def sourceLogV (V : ℝ) (x : SecondExpansionData ι) : ℝ := + Real.log (primeProductNorm p x.overlap/V) +def sourceLogK (K : ℝ) (x : SecondExpansionData ι) : ℝ := + Real.log (elementNorm (sourceObservation p x).1/K) +end + +theorem initial_sector_fixed_profiles + (U : ℝ→ℂ) (hUc : HasCompactSupport U) (hUs : ContDiff ℝ ∞ U) + (g₁ g₂ W : 𝓢(ℝ,ℂ)) (A : ℝ) (hA : 0≤A) + (hU₁ : ∀t,g₁ t≠0→U t=1) (hU₂ : ∀t,g₂ t≠0→U t=1) + (hg₁ : ∀t,g₁ t≠0→|t|≤A) (hg₂ : ∀t,g₂ t≠0→|t|≤A) : + ∃ (A₁ A₂ : 𝓢(ℝ,ℂ)) (windows : Fin 7→ℝ→ℂ), + (∀i,HasCompactSupport (windows i)) ∧ (∀i,ContDiff ℝ ∞ (windows i)) ∧ + (∀i t,windows i t≠0→|t|≤A+2+1) ∧ + ∀ {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hpr : ∀i,lambda^2∣p i-1) + (F : Finset ι) (Ψ : O→*ℂ) (m r : O) (ray : SecondRayIndex) + (s : Finset (SecondExpansionData ι)) (Z H E V X K : ℝ), + 0 normalizedColumn p (fun T => g₁ (columnLog p Z T)) S) + (fun S => normalizedColumn p (fun T => g₂ (columnLog p Z T)) S) W H = + initialSourceSum p hp hcop hg s (sourceWeight p hp hcop hg Ψ m ray Z H) + F (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) (m*r) A₁ A₂ W windows + (sourceLogZ p Z X) (fun _ => 0) (sourceLogE p E) (sourceLogV p V) (sourceLogK p K) + X X (H*K/(E^2*V^2*X^2)) := by + obtain ⟨A₁,A₂,windows,hwc,hws,hwb,hid⟩ := initial_source_fixed_profiles + U hUc hUs g₁ g₂ W A 2 hA (by norm_num) hU₁ hU₂ hg₁ hg₂ + refine ⟨A₁,A₂,windows,hwc,hws,hwb,?_⟩ + intro ι _ p hp _ hcop hg hinj hpr F Ψ m r ray s Z H E V X K hZ hE hV hX hK hs hk hz he hv hkap + calc + _ = ∑x∈s,secondExpansionSource p hp hcop hg F Ψ m 1 1 ray {x} + (fun S => normalizedColumn p (fun T => g₁ (columnLog p Z T)) S) + (fun S => normalizedColumn p (fun T => g₂ (columnLog p Z T)) S) W H := by + simp only [secondExpansionSource,Finset.sum_singleton] + _ = _ := by + unfold initialSourceSum + apply Finset.sum_congr rfl + intro x hx + obtain ⟨hsubset,_⟩ := hs x hx + have hh := hid p hp hcop hg hinj hpr F Ψ m ray x Z H E V X K + hsubset (hk x hx) hZ hE hV hX hK (hz x hx) (he x hx) (hv x hx) (hkap x hx) + rw [hh] + rw [postCommonSmoothPair_fixed_mask p hp hcop hg F (secondRayMinus Ψ ray) + (secondRayPlus Ψ ray) m r _ _ _ x (hs x hx)] + rfl + +end + +open MeasureTheory +open scoped BigOperators Classical SchwartzMap ContDiff FourierTransform +open ActualEisensteinCubic SecondPassArithmetic SecondPassIntegration JointLogSeparation +open FirstPassCubeLabels (normalizedColumn columnLog firstLogDensity) + +theorem initial_sector_transfer + (U : ℝ→ℂ) (hUc : HasCompactSupport U) (hUs : ContDiff ℝ ∞ U) + (g W : 𝓢(ℝ,ℂ)) (A : ℝ) (hA : 0≤A) + (hU : ∀t,g t≠0→U t=1) (hgA : ∀t,g t≠0→|t|≤A) + (ε : ℝ) (hε : 0<ε) (N J : ℕ) : + ∃ (windows : Fin 7→ℝ→ℂ) (C Cₛ : ℝ),0≤C ∧ 0≤Cₛ ∧ + (∀i,HasCompactSupport (windows i)) ∧ (∀i,ContDiff ℝ ∞ (windows i)) ∧ + ∀ {ι : Type*} [DecidableEq ι] (p : ι→O) (hp : ∀i,p i≠0) + [∀i,(Ideal.span {p i}).IsMaximal] + (hcop : Pairwise (Function.onFun IsCoprime (fun i => Ideal.span {p i}))) + (hg : ∀i,lambda∉Ideal.span {p i}) + (_hinj : Function.Injective (fun i => Ideal.span {p i})) + (_hc : ∀i,ringChar (O⧸Ideal.span {p i})≠2) + (_hpr : ∀i,lambda^2∣p i-1) + (F : Finset ι) (Ψ : O→*ℂ) (m r : O) (ray : SecondRayIndex) + (s : Finset (SecondExpansionData ι)) (Z H E V X K : ℝ), + 0 normalizedColumn p (fun T => g (columnLog p Z T)) S) + (fun S => normalizedColumn p (fun T => g (columnLog p Z T)) S) W H‖≤ + (C*H*elementNorm r/Z^2*‖secondRayCoefficient ray‖*(K*Real.exp 2)^ε)* + (∫t₁:ℝ,∫t₂:ℝ,∫t₃:ℝ,B (t₁,t₂,t₃)* + sourceGeometricMean p hp hcop hg F (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) + (m*r) (s.image (sourceObservation p)) (windows 5) (windows 6) X X (t₁,t₂,t₃)) := by + obtain ⟨A₁,A₂,windows,hwc,hws,hwb,hid⟩ := initial_sector_fixed_profiles + U hUc hUs g g W A hA hU hU hgA hgA + obtain ⟨Cw,hCw,hwbound⟩ := outerWindow_global_bound windows hwc (fun i => (hws i).continuous) + have hM : 0≤A+2+1 := by linarith + obtain ⟨Cₐ,hCₐ,Cₛ,hCₛ,htrans⟩ := initial_source_uniform_transfer ε hε A₁ A₂ W windows + (fun _ => A+2+1) (fun _ => hM) hwb N J + refine ⟨windows,Cw*Cₐ,Cₛ,mul_nonneg hCw hCₐ.le,hCₛ,hwc,hws,?_⟩ + intro ι _ p hp _ hcop hg hinj hc hpr F Ψ m r ray s Z H E V X K hZ hH hE hV hX hK hΨ hs hk hz he hv hkap + let R := H*K/(E^2*V^2*X^2) + have hR : 0 ‖tripleCoefficient (𝓕 A₁) (𝓕 A₂) b q‖ + refine ⟨B,fun q => norm_nonneg _,?_,?_⟩ + · intro q + simpa only [B,R,tripleCoefficient,mul_assoc] using hpoint q.1 q.2.1 q.2.2 + · let T := s.image (sourceObservation p) + have hT0 : ∀y∈T,y.1≠0 := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + exact sourceRow_nonzero p x (hk x hx) + have hTK : ∀y∈T,(Ideal.absNorm (Ideal.span {y.1}):ℝ)≤K*Real.exp 2 := by + intro y hy + obtain ⟨x,hx,rfl⟩ := Finset.mem_image.mp hy + have hpos := elementNorm_pos _ (sourceRow_nonzero p x (hk x hx)) + have hl : Real.log (elementNorm (sourceObservation p x).1/K)≤2 := + (le_abs_self _).trans (hkap x hx) + have hh := Real.exp_le_exp.mpr hl + rw [Real.exp_log (div_pos hpos hK)] at hh + have hh' := (div_le_iff₀ hK).mp hh + simpa only [elementNorm,eisEmbedding_norm_sq_eq_absNorm_span,mul_comm] using hh' + let D := H*elementNorm r/Z^2*‖secondRayCoefficient ray‖ + have hD : 0≤D := by dsimp [D,elementNorm]; positivity + have hweights : ∀x∈s,‖sourceWeight p hp hcop hg Ψ m ray Z H x‖* + ‖outerWindow windows (sourceLogZ p Z X x) 0 (sourceLogE p E x) (sourceLogV p V x) (sourceLogK p K x)‖≤D*Cw := by + intro x hx + exact mul_le_mul (sourceWeight_norm_fixed p hp hcop hg hinj hc Ψ m r ray Z H x + (hs x hx) hZ hH.le (hΨ _) (hΨ _)) (hwbound _ _ _ _ _) (norm_nonneg _) hD + have hh := hbound p hp hcop hg hinj r s T (sourceWeight p hp hcop hg Ψ m ray Z H) (D*Cw) + (K*Real.exp 2) F (secondRayMinus Ψ ray) (secondRayPlus Ψ ray) (m*r) + (sourceLogZ p Z X) (fun _ => 0) (sourceLogE p E) (sourceLogV p V) (sourceLogK p K) X X + (mul_nonneg hD hCw) (by positivity) hs (fun x hx => Finset.mem_image.mpr ⟨x,hx,rfl⟩) hT0 hTK hweights + rw [hid p hp hcop hg hinj hpr F Ψ m r ray s Z H E V X K hZ hE hV hX hK hs hk hz he hv hkap] + convert hh using 1 ; dsimp [D,B,R,T] ; ring + +end InitialMeanSquare + +open scoped BigOperators Classical +namespace SecondPassArithmetic +open ActualEisensteinCubic + +theorem descent_ideal_inverse_sum (S : Finset (Ideal O)) (H : ℝ) + (hS : ∀ I∈S,I≠0) (hH : ∀ I∈S,(Ideal.absNorm I : ℝ)≤H) : + (∑ I∈S,1/(Ideal.absNorm I : ℝ))≤128*Real.exp 1*(normLogBin H+1 : ℝ) := by + have hpos (I : Ideal O) (hI : I∈S) : 1≤(Ideal.absNorm I : ℝ) := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (fun hz => hS I hI (Ideal.absNorm_eq_zero_iff.mp hz)) + let T := Finset.range (normLogBin H+1) + let bin (j : ℕ) := S.filter (fun I => normLogBin (Ideal.absNorm I)=j) + have hmap : ∀ I∈S,normLogBin (Ideal.absNorm I : ℝ)∈T := by + intro I hI + exact Finset.mem_range.mpr (Nat.lt_succ_of_le (normLogBin_mono (by linarith [hpos I hI]) (hH I hI))) + have hbin (j : ℕ) : (∑ I∈bin j,1/(Ideal.absNorm I : ℝ))≤128*Real.exp 1 := by + have hp := normLogScale_pos j + have hone := normLogScale_ge_one j + have he := Real.one_le_exp (show (0 : ℝ)≤1 by norm_num) + have hc : ((bin j).card : ℝ)≤128*(normLogScale j*Real.exp 1) := by + apply DescentFiberCost.finite_ideal_count_real _ _ (by nlinarith) + · intro I hI + exact hS I (Finset.mem_filter.mp hI).1 + · intro I hI + obtain ⟨hIS,hj⟩ := Finset.mem_filter.mp hI + simpa only [hj] using (normLogBin_scale_bounds (Ideal.absNorm I : ℝ) (hpos I hIS)).2 + have ht (I : Ideal O) (hI : I∈bin j) : 1/(Ideal.absNorm I : ℝ)≤1/normLogScale j := by + obtain ⟨hIS,hj⟩ := Finset.mem_filter.mp hI + have hb := (normLogBin_scale_bounds (Ideal.absNorm I : ℝ) (hpos I hIS)).1 + rw [hj] at hb + exact one_div_le_one_div_of_le hp hb + calc + _ ≤ ∑ _I∈bin j,1/normLogScale j := Finset.sum_le_sum ht + _ = ((bin j).card : ℝ)/normLogScale j := by simp [div_eq_mul_inv] + _ ≤ (128*(normLogScale j*Real.exp 1))/normLogScale j := div_le_div_of_nonneg_right hc hp.le + _ = _ := by field_simp + rw [← Finset.sum_fiberwise_of_maps_to hmap] + calc + _ ≤ ∑ _j∈T,128*Real.exp 1 := Finset.sum_le_sum (fun j _ => hbin j) + _ = _ := by simp [T]; ring + +theorem descent_normLogBin_small_power (ε : ℝ) (hε : 0<ε) (H : ℝ) (hH : 1≤H) : + (normLogBin H+1 : ℝ)≤(1+1/ε)*H^ε := by + have hH0 : 0 x.leftExponent i+x.rightExponent i)}, + Ideal.span {b0Label p x.support (fun i => x.leftExponent i+x.rightExponent i) x.leftBit x.rightBit* + j2Label p x.support (fun i => x.leftExponent i+x.rightExponent i) x.leftBit x.rightBit}) + +def cubeDivisorKey (x : CubeCoordinates ι) : Fin 3 → Ideal O := + ![Ideal.span {primeProduct p x.support x.leftExponent}, + Ideal.span {aLabel p x.support x.leftBit},Ideal.span {aLabel p x.support x.rightBit}] + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem cubeParityKey_product (x : CubeCoordinates ι) : + cubeProductIdeal p x=(cubeParityKey p x).2^2*(cubeParityKey p x).1 := by + have h := FirstPassCubeLabels.cube_pair_product_decomposition p x.support + x.leftExponent x.rightExponent x.leftBit x.rightBit x.support_pos + have h' := congrArg (fun z : O => (Ideal.span {z} : Ideal O)) h + simp only [cubeProductIdeal,cubeParityKey,pow_two,←Ideal.span_singleton_mul_span_singleton] at h' ⊢ + convert h' using 1 ; congr 1 ; ring + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem cubeDivisorKey_dvd (x : CubeCoordinates ι) (i : Fin 3) : + cubeDivisorKey p x i ∣ cubeProductIdeal p x := by + have hA1 := span_dvd_of_element_dvd + (aLabel_dvd_primeProduct p x.support (fun i => x.leftExponent i+x.rightExponent i) x.leftBit x.support_pos) + have hA2 := span_dvd_of_element_dvd + (aLabel_dvd_primeProduct p x.support (fun i => x.leftExponent i+x.rightExponent i) x.rightBit x.support_pos) + rw [primeProduct_add,←Ideal.span_singleton_mul_span_singleton] at hA1 hA2 + fin_cases i + · exact dvd_mul_right _ _ + · exact hA1 + · exact hA2 + +variable (hp : ∀ i,p i≠0) +include hp + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem cubeParityKey_ne_zero (x : CubeCoordinates ι) : + (cubeParityKey p x).1≠0 ∧ (cubeParityKey p x).2≠0 := by + constructor + · exact (Ideal.span_singleton_eq_bot.not).mpr (primeProduct_ne_zero p hp _ _) + · exact (Ideal.span_singleton_eq_bot.not).mpr + (mul_ne_zero (primeProduct_ne_zero p hp _ _) (primeProduct_ne_zero p hp _ _)) + +omit [∀ (i : ι), (span {p i}).IsMaximal] in +theorem cubeProductIdeal_ne_zero (x : CubeCoordinates ι) : cubeProductIdeal p x≠0 := by + rw [cubeParityKey_product] + exact mul_ne_zero (pow_ne_zero _ (cubeParityKey_ne_zero p hp x).2) (cubeParityKey_ne_zero p hp x).1 + +variable (hinj : Function.Injective (fun i => Ideal.span {p i})) +include hinj + +theorem cubeDivisorKey_injective_on_product {x y : CubeCoordinates ι} + (hx : x.Admissible) (hy : y.Admissible) + (hprod : cubeProductIdeal p x=cubeProductIdeal p y) + (hk : cubeDivisorKey p x=cubeDivisorKey p y) : x=y := by + have h1 := congrFun hk 0 + have hA1 := congrFun hk 1 + have hA2 := congrFun hk 2 + change Ideal.span {primeProduct p x.support x.leftExponent}= + Ideal.span {primeProduct p y.support y.leftExponent} at h1 + have h2 : Ideal.span {primeProduct p x.support x.rightExponent}= + Ideal.span {primeProduct p y.support y.rightExponent} := by + apply mul_left_cancel₀ ((Ideal.span_singleton_eq_bot.not).mpr (primeProduct_ne_zero p hp x.support x.leftExponent)) + simpa only [cubeProductIdeal,h1] using hprod + have hv1 := primeProduct_span_exponents_eq p hinj x.support y.support + x.leftExponent y.leftExponent x.left_off y.left_off h1 + have hv2 := primeProduct_span_exponents_eq p hinj x.support y.support + x.rightExponent y.rightExponent x.right_off y.right_off h2 + change Ideal.span {aLabel p x.support x.leftBit}=Ideal.span {aLabel p y.support y.leftBit} at hA1 + change Ideal.span {aLabel p x.support x.rightBit}=Ideal.span {aLabel p y.support y.rightBit} at hA2 + rw [CubeCoordinates.aLabel_left p x hx,CubeCoordinates.aLabel_left p y hy, + FiniteGaussPhase.span_finset_prod,FiniteGaussPhase.span_finset_prod] at hA1 + rw [CubeCoordinates.aLabel_right p x hx,CubeCoordinates.aLabel_right p y hy, + FiniteGaussPhase.span_finset_prod,FiniteGaussPhase.span_finset_prod] at hA2 + exact CubeCoordinates.ext (Finsupp.ext (congrFun hv1)) (Finsupp.ext (congrFun hv2)) + (FirstCauchyArithmetic.family_product_injective _ hinj hA1) + (FirstCauchyArithmetic.family_product_injective _ hinj hA2) + +theorem cubeParityKey_fiber_card (s : Finset (CubeCoordinates ι)) (q : Ideal O × Ideal O) + (hq1 : q.1≠0) (hq2 : q.2≠0) (hs : ∀ x∈s,x.Admissible) + (hk : ∀ x∈s,cubeParityKey p x=q) : + s.card≤(idealDivisors (q.2^2*q.1)).card^3 := by + let D := idealDivisors (q.2^2*q.1) + have hprod0 : q.2^2*q.1≠0 := mul_ne_zero (pow_ne_zero _ hq2) hq1 + let encode (x : s) : Fin 3 → D := fun i => ⟨cubeDivisorKey p x.val i,by + apply (mem_idealDivisors hprod0).mpr + have h := cubeDivisorKey_dvd p x.val i + simpa only [cubeParityKey_product,hk x.val x.property] using h⟩ + have hi : Function.Injective encode := by + intro x y he + apply Subtype.ext + apply cubeDivisorKey_injective_on_product p hp hinj (hs _ x.property) (hs _ y.property) + · simp only [cubeParityKey_product,hk _ x.property,hk _ y.property] + · funext i + exact congrArg Subtype.val (congrFun he i) + simpa only [Fintype.card_coe,Fintype.card_fun,Fintype.card_fin,D] using Fintype.card_le_of_injective encode hi + +end SecondPassArithmetic + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceBesselExpansion.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceBesselExpansion.lean new file mode 100644 index 0000000000000000000000000000000000000000..97af5d5713a76f4b7141a4b6f908870325d20050 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceBesselExpansion.lean @@ -0,0 +1,623 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.PrimePowerGaussSums + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +local notation "Eis" => ActualEisensteinCubic.O + +lemma opposite_height_fourier_average (a b:ℝ) (ha:0hyperbolicEisenstein s (sourceComplexMatrix oppositeSource • w)* + cuspWeightedFourierPhase ρ h w + have hg:Continuous g := ((hyperbolicEisenstein_continuous s hs).comp + (continuous_hyperbolic_action _)).mul (cuspWeightedFourierPhase_continuous ρ h) + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg)] + rw [cuspIntervalWhittakerHeightFactor,←integral_const_mul] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hv0:0translatedHeightFamily a b ha ρ h oppositeSource s*cuspWhittakerHeightFactor s h) + (fun s=>translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspIntervalWhittakerHeightFactor a b ρ s h) {s:ℂ|1translatedHeightFamily a b ha ρ h oppositeSource s* + cuspWhittakerHeightFactor s h) domain := fun s hs=> + (translatedHeightFamily_analyticAt a b ha ρ h oppositeSource s hs.1.ne' hs.2.ne').mul + (cuspWhittakerHeightFactor_analyticAt h s hs.1) + have hg : AnalyticOnNhd ℂ (fun s=>translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspIntervalWhittakerHeightFactor a b ρ s h) domain := fun s hs=> + (translatedCuspFamily_analyticAt_nonreal h oppositeSource 2 3 (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne').mul + (cuspIntervalWhittakerHeightFactor_analyticAt a b ha ρ h s hs.1) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s:ℂ | 4translatedHeightFamily a b ha ρ h oppositeSource s*cuspWhittakerHeightFactor s h) + =ᶠ[𝓝 (5+Complex.I:ℂ)] (fun s=>translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspIntervalWhittakerHeightFactor a b ρ s h) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + rw [translatedHeightFamily_initial a b ha ρ h oppositeSource s hs.1 hs.2, + opposite_height_fourier_average a b ha ρ h s (by linarith [hs.1]), + translatedCuspFamily_initial h oppositeSource 2 3 (by norm_num) (by norm_num) (by norm_num) s hs.1 hs.2, + opposite_cusp_fourier_average s (by linarith [hs.1])] + ring + exact hf.eqOn_of_preconnected_of_eventuallyEq hg hconvex.isPreconnected hstart hev + +theorem translatedHeightFourier_opposite_residue (a b:ℝ) (ha:0((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)* + translatedHeightFamily a b ha ρ h oppositeSource ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspWhittakerHeightFactor ((4/3:ℂ)+(t:ℂ)*Complex.I) h) + =ᶠ[𝓝[>] (0:ℝ)] (fun t:ℝ=>((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)* + translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspIntervalWhittakerHeightFactor a b ρ ((4/3:ℂ)+(t:ℂ)*Complex.I) h) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0 ActualEisensteinCubic.O + +lemma rational_height_fourier_right_T (a b:ℝ) (ha:0hyperbolicEisenstein s + (rationalComplex (r*ModularGroup.T^n) • w)*cuspWeightedFourierPhase ρ h w + let g : HyperbolicSpace→ℂ := fun w=>hyperbolicEisenstein s + (rationalComplex r • w)*cuspWeightedFourierPhase ρ h w + have hf : Continuous f := ((hyperbolicEisenstein_continuous s hs).comp + (continuous_hyperbolic_action _)).mul (cuspWeightedFourierPhase_continuous ρ h) + have hg : Continuous g := ((hyperbolicEisenstein_continuous s hs).comp + (continuous_hyperbolic_action _)).mul (cuspWeightedFourierPhase_continuous ρ h) + change (∫w in cuspPeriodStrip a b,f w∂hyperbolicVolume)= + ShortDraftTrace.breveE (cuspFrequency h*(n:ℂ))*∫w in cuspPeriodStrip a b,g w∂hyperbolicVolume + rw [cuspPeriodStrip_integral_coordinates_of_pos a b ha f hf.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha f hf), + cuspPeriodStrip_integral_coordinates_of_pos a b ha g hg.aestronglyMeasurable + (cuspCoordinateLift_weighted_integrable_of_pos a b ha g hg),←integral_const_mul] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hv0:0hyperbolicEisenstein s (rationalComplex r • upperPoint z v hv0)*ρ v) + (fun m z=>congrArg (fun q:ℂ=>q*ρ v) (hyperbolicEisenstein_rational_periodic r m s hs z v hv0)) h (n:ℂ) + dsimp only + rw [hslice] + ring + +lemma translatedHeightFourier_residue_scaled_of_initial (a b:ℝ) (ha:0c*translatedHeightFamily a b ha ρ h N s + let domain : Set ℂ := {s | 1 + translatedHeightFamily_analyticAt a b ha ρ h M s hs.1.ne' hs.2.ne' + have hg : AnalyticOnNhd ℂ g domain := fun s hs=>analyticAt_const.mul + (translatedHeightFamily_analyticAt a b ha ρ h N s hs.1.ne' hs.2.ne') + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s:ℂ | 4kernelCuspHeightFourier a b ha ρ h cubicEisensteinResidue + | Sum.inr ab=>ShortDraftTrace.breveE (cuspFrequency h*(ab.2.val:ℂ))* + translatedHeightFourier a b ha ρ h oppositeSource cubicEisensteinResidue := by + cases sector with + | inl index => + rw [←one_mul (kernelCuspHeightFourier a b ha ρ h cubicEisensteinResidue),←translatedHeightFourier_one a b ha ρ h] + apply translatedHeightFourier_residue_scaled_of_initial + intro s hs hi + simp_rw [sourceComplexMatrix_rationalLift,hyperbolicEisenstein_bruhat] + simp only [map_one,one_smul,one_mul] + | inr ab => + apply translatedHeightFourier_residue_scaled_of_initial + intro s hs hi + simp_rw [sourceComplexMatrix_rationalLift,hyperbolicEisenstein_bruhat] + change (∫w in cuspPeriodStrip a b, + hyperbolicEisenstein s (rationalComplex ModularGroup.S • + (rationalComplex (ModularGroup.T^ab.2.val) • w))*cuspWeightedFourierPhase ρ h w∂hyperbolicVolume)= + ShortDraftTrace.breveE (cuspFrequency h*(ab.2.val:ℂ))* + ∫w in cuspPeriodStrip a b,hyperbolicEisenstein s (rationalComplex ModularGroup.S • w)* + cuspWeightedFourierPhase ρ h w∂hyperbolicVolume + simpa only [map_mul,mul_smul] using + rational_height_fourier_right_T a b ha ρ ModularGroup.S ab.2.val h s (by linarith) + +theorem kernelSourceProjection_height_fourier (a b:ℝ) (ha:0 ActualEisensteinCubic.O + +lemma cuspIntervalWhittakerHeightFactor_zero_center (a b:ℝ) (_ha:0 ActualEisensteinCubic.O + +lemma sourceResidualFourierCoefficient_interval_bound (a b : ℝ) (ha : 0sourceBesselFunction (cuspCoordinateLift (v,z))) 2 (volume.restrict periodDomain) := + sourceBesselCoefficients.fullFunction_height_memLp _ v hv + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +local notation "O" => ActualEisensteinCubic.O + +lemma sourceResidualFullMode_density_integrable (a b : ℝ) (ha : 0 sourceResidualFullModeAmplitude v h/(v:ℂ)^3) + (Set.Icc a b) volume := by + by_cases hh : h=0 + · subst h + have hi : IntegrableOn (fun v : ℝ => + (3*(Real.pi:ℂ))*constantArithmeticResidue*(v:ℂ)^(-(7/3:ℂ))) + (Set.Icc a b) volume := by + apply ContinuousOn.integrableOn_Icc + intro v hv + exact (continuousAt_const.mul (Complex.continuousAt_ofReal_cpow_const v + (-(7/3:ℂ)) (Or.inr (ha.trans_le hv.1).ne'))).continuousWithinAt + apply hi.congr + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + exact (sourceResidualFullModeAmplitude_zero_density v (ha.trans_le hv.1)).symm + · apply ((cubicBesselHeight_integrable a b ha h hh).const_mul + (sourceResidualFourierCoefficient h)).congr + filter_upwards [ae_restrict_mem measurableSet_Icc] with v hv + exact (sourceResidualFullModeAmplitude_nonzero_density v (ha.trans_le hv.1) h hh).symm + +lemma projectedResidue_slice_coefficient_ae (a b : ℝ) (ha : 0 ((9*Real.sqrt 3/2:ℝ):ℂ)*(sourceResidualFullModeAmplitude v h/(v:ℂ)^3)) := by + apply interval_ae_eq_of_boundedContinuous_height_tests a b _ _ + (kernelCuspSliceCoefficient_integrable a b ha h (kernelSourceProjection cubicEisensteinResidue)) + ((sourceResidualFullMode_density_integrable a b ha h).const_mul _) + intro ρ + rw [←kernelCuspHeightFourier_eq_slice_integral a b ha ρ h (kernelSourceProjection cubicEisensteinResidue), + kernelSourceProjection_height_full a b ha ρ h,←integral_const_mul] + apply integral_congr_ae + exact Eventually.of_forall (fun v => by ring) + +lemma projectedResidue_all_slice_coefficients_ae (a b : ℝ) (ha : 0 projectedResidue_slice_coefficient_ae a b ha h) + +lemma projectedResidue_all_fourier_integrals_ae (a b : ℝ) (ha : 0kernelSourceProjection cubicEisensteinResidue + (integralOrbitProjection globalKubotaKernel (cuspCoordinateLift (v,z)))) + =ᵐ[volume.restrict periodDomain] (fun z=>sourceBesselFunction (cuspCoordinateLift (v,z))) := by + filter_upwards [projectedResidue_all_fourier_integrals_ae a b ha, + kernelCuspSections_memLp a b ha (kernelSourceProjection cubicEisensteinResidue), + ae_restrict_mem measurableSet_Icc] with v hfour hL hv + have hpos:0kernelSourceProjection cubicEisensteinResidue (integralOrbitProjection globalKubotaKernel w)) + =ᵐ[hyperbolicVolume] sourceBesselFunction := by + apply hyperbolic_eq_ae_of_period_cells _ _ + ((MeasureTheory.Lp.stronglyMeasurable (kernelSourceProjection cubicEisensteinResidue)).measurable.comp + (measurable_integralOrbitProjection _)) sourceBesselFunction_continuous.measurable + · intro v hv z n + exact congrArg (kernelSourceProjection cubicEisensteinResidue) (kernelProjection_upper_period v hv z n) + · exact sourceBesselFunction_period + · exact projectedResidue_cell_slices_ae + +theorem cubicSourceResidualFunction_eq_bessel : cubicSourceResidualFunction=sourceBesselFunction := by + have he : cubicSourceResidualFunction=ᵐ[hyperbolicVolume]sourceBesselFunction := by + filter_upwards [cubicSourceResidualFunction_represents_projection,sourceBesselFunction_represents_projection] + with w hw hs + exact hw.symm.trans hs + exact Measure.eq_of_ae_eq he cubicSourceResidualFunction_continuous sourceBesselFunction_continuous + +theorem cubicSourceResidualFunction_fourier_full (v:ℝ) (hv:0 fun p : ℝ × ℂ => ∑ h ∈ t, sourceBesselCoefficients.term h p) + sourceBesselCoefficients.series atTop {p : ℝ × ℂ | p.1 ∈ Set.Icc a b} := + sourceBesselCoefficients.series_uniform a b ha hab + +theorem sourceResidual_bessel_normal (a b:ℝ) (ha:0C*Real.exp (-(Real.pi*a)*‖cuspFrequency h‖), + (summable_exp_neg_cuspFrequency_norm (Real.pi*a) (mul_pos Real.pi_pos ha)).mul_left C,?_⟩ + intro h v hv z + have he:=hbound h (v,z) hv + rw [sourceBesselCoefficients.term_eq_amplitude v (ha.trans_le hv.1) h z] at he + exact he + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceCuspKernels.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceCuspKernels.lean new file mode 100644 index 0000000000000000000000000000000000000000..906a678f81520e0d9313d590dde112f23dd9c9e1 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceCuspKernels.lean @@ -0,0 +1,630 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.RamifiedValuation + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein + +section +open scoped BigOperators Classical MatrixGroups +open MeasureTheory +open Finset AddChar MulChar EisensteinEmbedding + +open CubicKubota EisensteinCuspModThree ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def sourceCuspCoefficients (j : Fin 3) : SubexponentialBesselCoefficients := + ![sourceBesselCoefficients,ramifiedBesselCoefficients false,ramifiedBesselCoefficients true] j + +def sourceCuspScale (j : Fin 3) : ℝ := ![1,3,3] j +def sourceCuspBesselConstant (j : Fin 3) : ℂ := ![(3*Real.pi)*constantArithmeticResidue,0,0] j + +lemma sourceCuspScale_pos (j : Fin 3) : 0 norm_num [sourceCuspScale] + +lemma ramifiedSource_scaled_fullFunction (side : Bool) (v : ℝ) (hv : 0cubicSourceConjugateFunction (integralComplexMatrix (cuspRepresentative j) • upperPoint w v hv))= + fun w=>star ((sourceCuspCoefficients j).fullFunction (sourceCuspBesselConstant j) + (upperPoint (w/(sourceCuspScale j:ℂ)) (v/sourceCuspScale j) (div_pos hv (sourceCuspScale_pos j)))) := by + funext w + exact congrArg star (sourceCusp_bessel_expansion j v hv w) + rw [he] + exact (sourceCuspCoefficients j).scaledConjugate_wirtingerZ (sourceCuspBesselConstant j) + (sourceCuspScale j) (sourceCuspScale_pos j) v hv z + +theorem sourceCuspZTerm_summable (j : Fin 3) (z : ℂ) (v : ℝ) (hv : 0finiteReflectedSourceTerm_summable Ψ c hc d v hv h)] + apply Finset.sum_congr rfl + intro h hh + simp only [finiteReflectedSourceTerm,tsum_mul_left] + +end + +open scoped BigOperators Classical +open MeasureTheory +open Finset AddChar MulChar EisensteinEmbedding + +open ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +def sourceCuspRadialLength (h : Eis) : ℝ := if h=0 then 1 else ‖eisEmbedding h‖^2 +def sourceCuspRadialScale (j : Fin 3) : ℝ := thetaBesselScale/sourceCuspScale j + +def sourceCuspRadialBaseCoefficient (j : Fin 3) (h : Eis) : ℂ := + (-2*Real.pi*Complex.I*cuspFrequency h)*star ((sourceCuspCoefficients j).value h)/ + ((sourceCuspScale j:ℂ)^2*(sourceCuspRadialLength h:ℂ)) + +def sourceCuspRadialCoefficient (j : Fin 3) (z : ℂ) (h : Eis) : ℂ := + sourceCuspRadialBaseCoefficient j h* + ShortDraftTrace.breveE (-cuspFrequency h*(z/(sourceCuspScale j:ℂ))) + +lemma sourceCuspRadialLength_pos (h : Eis) : 0 simp + | succ n hn => + rw [pow_succ,Complex.ofReal_mul,Complex.mul_cpow_ofReal_nonneg (pow_nonneg hx n) hx, + hn,pow_succ] + +lemma positive_reflection_powers (Q u d X r:ℝ) + (hQ:0mellin V (-s)*gammaMultiplier s) := by + funext s + simp only [mellinEulerData,pow_zero,one_mul,mellinData] + rw [hf] + rfl + rw [hl] at he + simpa only [mellinInv,smul_eq_mul,Complex.real_smul,Complex.ofReal_div, + Complex.ofReal_one,Complex.ofReal_mul,Complex.ofReal_ofNat] using he + +lemma paperKernel_three_halves_bound (V:ℝ→ℂ) (v0 v1:ℝ) (hv0:0mellin V (-s)*gammaMultiplier s) := by + funext s + simp only [mellinEulerData,pow_zero,one_mul,mellinData] + rw [hf] + rfl + rw [hl] at he + rw [he] + exact hb (3/2) (by norm_num) (paperScale*x) (mul_pos paperScale_pos hx) + +end CubicReflectionKernel +namespace CompletedGauss + +section +open CubicReflectionKernel + +lemma paperKernel_weighted_summable {α:Type*} + (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (V:ℝ→ℂ) (v0 v1:ℝ) (hv0:0a i*paperKernel V (c*r i)) := by + obtain ⟨C,hC,hb⟩:=paperKernel_three_halves_bound V v0 v1 hv0 hVs hV + apply Summable.of_norm + apply (has.mul_left (C*(paperScale*c)^(-(3/2:ℝ)))).of_nonneg_of_le (fun i=>norm_nonneg _) + intro i + rw [norm_mul] + calc + _≤‖a i‖*(C*(paperScale*(c*r i))^(-(3/2:ℝ))):= + mul_le_mul_of_nonneg_left (hb _ (mul_pos hc (hr i))) (norm_nonneg _) + _=(C*(paperScale*c)^(-(3/2:ℝ)))*(‖a i‖*(r i)^(-(3/2:ℝ))):=by + rw [show paperScale*(c*r i)=(paperScale*c)*r i by ring, + Real.mul_rpow (mul_pos paperScale_pos hc).le (hr i).le] + ring + +theorem paperKernel_weighted_mellin {α:Type*} [Countable α] + (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (V:ℝ→ℂ) (v0 v1:ℝ) (hv0:0((paperScale*c:ℝ):ℂ)^(-((3/2:ℂ)+t*Complex.I))* + mellinEulerData V 0 ((3/2:ℂ)+t*Complex.I) + have hM:Integrable M:=by + simpa only [M,inverseMellinIntegrand,Complex.ofReal_div,Complex.ofReal_ofNat] using + inverseMellinIntegrand_vertical_integrable V v0 v1 hv0 hVs hV 2 0 (3/2) + (by norm_num) (paperScale*c) (mul_pos paperScale_pos hc) + have hi (i:α) : a i*paperKernel V (c*r i)=(1/(2*Real.pi):ℂ)*∫t:ℝ, + a i*(r i:ℂ)^(-((3/2:ℂ)+t*Complex.I))*M t := by + rw [paperKernel_three_halves V v0 v1 hv0 hVs hV _ (mul_pos hc (hr i))] + rw [←mul_assoc,mul_comm (a i),mul_assoc,←integral_const_mul] + congr 1 + apply integral_congr_ae + filter_upwards with t + rw [show paperScale*(c*r i)=(paperScale*c)*r i by ring, + Complex.ofReal_mul,Complex.mul_cpow_ofReal_nonneg (mul_pos paperScale_pos hc).le (hr i).le] + dsimp only [M] + ring + simp_rw [hi] + rw [tsum_mul_left] + congr 1 + simpa only [M,Complex.ofReal_div,Complex.ofReal_ofNat] using + weighted_vertical_sum_integral r hr a (3/2) has M hM + +end + +open CubicEisenstein CubicReflectionKernel + +lemma besselSmoothingIntegrand_reflected_kernel_line {α:Type*} [Countable α] + (F:ℝ→ℂ) (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (V:ℝ→ℂ) (X:ℝ) (hX:0‖a i‖*(r i)^(s.re-1/2)):=by simpa only [hs] using has + have hsw:1/2-w=s:=by dsimp [s,w];ring + have hw:1/2-s=w:=by rw [←hsw];ring + have hsw':s-1/2=-w:=by rw [←hsw];ring + have hp:=bessel_reflection_scale q d Q X 1 hq hd hQ hX (by norm_num) w + simp only [hsw,Complex.ofReal_one,Complex.one_cpow,mul_one] at hp + have he:=continuedBesselDirichlet_reflection F r hr a q d Q hd hQ A hreflect s hslt hsum + change besselSmoothingIntegrand F q V X s=_ + rw [besselSmoothingIntegrand,he,hw,hsw'] + change _=(A*((Q*(q/d)^2:ℝ):ℂ))* + ((∑'i,a i*(r i:ℂ)^(-w))* + (((paperScale*(27*q^2*d^2*X/Q^2):ℝ):ℂ)^(-w)*mellinEulerData V 0 w)) + rw [mellinEulerData,pow_zero,one_mul,mellinData] + calc + _=(A*mellin V (-w)*gammaMultiplier w*(∑'i,a i*(r i:ℂ)^(-w)))* + ((Q:ℂ)^(2-2*s)*besselReflectionFactor q d s*(X:ℂ)^(-w)):=by ring + _=_:=by rw [hp];ring + +theorem completedT_smoothed_reflection {α:Type*} [Countable α] + (Ψ:ActualEisensteinCubic.O→*ℂ) (hΨ:∀x,‖Ψ x‖≤1) + (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (W:ℝ→ℂ) (v0 v1:ℝ) (hv0:0 + besselSmoothingIntegrand (completedBesselProfile Ψ q) q (Vstar W) X + (((-1:ℝ):ℂ)+t*Complex.I)) := by + simpa only [Complex.ofReal_neg,Complex.ofReal_one] using hl + have hshift:=completedT_mellin_shift Ψ hΨ q hq hF hFe W v0 v1 hv0 hWs hW X hX + (-1) (by norm_num) hlreal + let c:ℝ:=27*q^2*d^2*X/Q^2 + have hc:0(∑'i,a i*(r i:ℂ)^(-((3/2:ℂ)+t*Complex.I)))* + (((paperScale*c:ℝ):ℂ)^(-((3/2:ℂ)+t*Complex.I))* + mellinEulerData (Vstar W) 0 ((3/2:ℂ)+t*Complex.I)) + have hk:=paperKernel_weighted_mellin r hr a has (Vstar W) v0 v1 hv0 hVs hV c hc + have hpoint (t:ℝ) : + besselSmoothingIntegrand (completedBesselProfile Ψ q) q (Vstar W) X ((-1:ℂ)+(-t)*Complex.I)= + (A*((Q*(q/d)^2:ℝ):ℂ))*M t := + besselSmoothingIntegrand_reflected_kernel_line (completedBesselProfile Ψ q) + r hr a q d Q hq hd hQ A hreflect has (Vstar W) X hX t + calc + completedT Ψ W X=(1/(2*Real.pi):ℂ)*∫t:ℝ, + besselSmoothingIntegrand (completedBesselProfile Ψ q) q (Vstar W) X ((-1:ℂ)+t*Complex.I):=by + simpa only [Complex.ofReal_neg,Complex.ofReal_one] using hshift + _=(1/(2*Real.pi):ℂ)*∫t:ℝ, + besselSmoothingIntegrand (completedBesselProfile Ψ q) q (Vstar W) X ((-1:ℂ)+(-t)*Complex.I):=by + congr 1 + simpa only [Complex.ofReal_neg] using + (integral_neg_eq_self (fun t:ℝ=> + besselSmoothingIntegrand (completedBesselProfile Ψ q) q (Vstar W) X + ((-1:ℂ)+t*Complex.I)) volume).symm + _=(A*((Q*(q/d)^2:ℝ):ℂ))*((1/(2*Real.pi):ℂ)*∫t:ℝ,M t):=by + simp_rw [hpoint] + rw [integral_const_mul] + ring + _=(A*((Q*(q/d)^2:ℝ):ℂ))*(∑'i,a i*paperKernel (Vstar W) (c*r i)):=by rw [hk] + _=_:=by + push_cast + congr 1 + · ring + · apply tsum_congr + intro i + congr 2 + dsimp [c] + ring + +theorem reflected_paperKernel_summable {α:Type*} + (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (q d Q X:ℝ) (hq:0a i*paperKernel (Vstar W) (27*q^2*d^2*X*r i/Q^2)) := by + have h:=paperKernel_weighted_summable r hr a has (Vstar W) v0 v1 hv0 + (Vstar_support W v0 v1 hWs) (Vstar_contDiff W v0 v1 hv0 hWs hW) + (27*q^2*d^2*X/Q^2) (by positivity) + apply h.congr + intro i + congr 2 + ring + +end CompletedGauss + +open Filter MeasureTheory +open scoped Classical BigOperators Topology ContDiff + +namespace CompletedGauss +open CubicEisenstein CubicReflectionKernel + +theorem besselSmoothingIntegral_reflected_kernel {α:Type*} [Countable α] + (F:ℝ→ℂ) (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (V:ℝ→ℂ) (v0 v1:ℝ) (hv0:0(∑'i,a i*(r i:ℂ)^(-((3/2:ℂ)+t*Complex.I)))* + (((paperScale*c:ℝ):ℂ)^(-((3/2:ℂ)+t*Complex.I))* + mellinEulerData V 0 ((3/2:ℂ)+t*Complex.I)) + have hk:=paperKernel_weighted_mellin r hr a has V v0 v1 hv0 hVs hV c hc + have hpoint (t:ℝ) : + besselSmoothingIntegrand F q V X ((-1:ℂ)+(-t)*Complex.I)= + (A*((Q*(q/d)^2:ℝ):ℂ))*M t := + besselSmoothingIntegrand_reflected_kernel_line F + r hr a q d Q hq hd hQ A hreflect has V X hX t + calc + _=(1/(2*Real.pi):ℂ)*∫t:ℝ, + besselSmoothingIntegrand F q V X ((-1:ℂ)+(-t)*Complex.I):=by + congr 1 + simpa only [Complex.ofReal_neg] using + (integral_neg_eq_self (fun t:ℝ=> + besselSmoothingIntegrand F q V X ((-1:ℂ)+t*Complex.I)) volume).symm + _=(A*((Q*(q/d)^2:ℝ):ℂ))*((1/(2*Real.pi):ℂ)*∫t:ℝ,M t):=by + simp_rw [hpoint] + rw [integral_const_mul] + ring + _=(A*((Q*(q/d)^2:ℝ):ℂ))*(∑'i,a i*paperKernel V (c*r i)):=by rw [hk] + _=_:=by + push_cast + congr 1 + · ring + · apply tsum_congr + intro i + congr 2 + dsimp [c] + ring + +theorem paperKernel_weighted_norm_summable {α:Type*} + (r:α→ℝ) (hr:∀i,0‖a i‖*(r i)^(-(3/2:ℝ)))) + (V:ℝ→ℂ) (v0 v1:ℝ) (hv0:0‖a i*paperKernel V (c*r i)‖) := by + obtain ⟨C,hC,hb⟩:=paperKernel_three_halves_bound V v0 v1 hv0 hVs hV + apply (has.mul_left (C*(paperScale*c)^(-(3/2:ℝ)))).of_nonneg_of_le (fun i=>norm_nonneg _) + intro i + rw [norm_mul] + calc + _≤‖a i‖*(C*(paperScale*(c*r i))^(-(3/2:ℝ))):= + mul_le_mul_of_nonneg_left (hb _ (mul_pos hc (hr i))) (norm_nonneg _) + _=(C*(paperScale*c)^(-(3/2:ℝ)))*(‖a i‖*(r i)^(-(3/2:ℝ))):=by + rw [show paperScale*(c*r i)=(paperScale*c)*r i by ring, + Real.mul_rpow (mul_pos paperScale_pos hc).le (hr i).le] + ring + +end CompletedGauss + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceMellinInversion.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceMellinInversion.lean new file mode 100644 index 0000000000000000000000000000000000000000..7830dfe17fd39e4b462832d6ff6a2fa786b37080 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceMellinInversion.lean @@ -0,0 +1,645 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.SquarefreeCoefficients + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma source_period_of_three_supported + (hs:∀h:Eis,¬(3:Eis)∣h→sourceResidualFourierCoefficient h=0) + (a:Eis) (z:ℂ) (v:ℝ) (hv:0(3*(Real.pi:ℂ))*constantArithmeticResidue*(v:ℂ)^(2/3:ℂ)+t) + apply tsum_congr + intro h + by_cases hd:(3:Eis)∣h + · obtain ⟨b,rfl⟩:=hd + have hp:ShortDraftTrace.breveE (cuspFrequency (3*b)*eisEmbedding a)=1:=by + have he:cuspFrequency (3*b)*eisEmbedding a=cuspFrequency b*(3*eisEmbedding a):=by + unfold cuspFrequency + rw [map_mul,map_ofNat] + ring + rw [he,cuspFrequency_period] + rw [mul_add,AddChar.map_add_eq_mul,hp,mul_one] + · rw [hs h hd] + by_cases hh:h=0 <;> simp [hh] + +theorem exists_source_coefficient_not_three : + ∃h:Eis,¬(3:Eis)∣h ∧ sourceResidualFourierCoefficient h≠0 := by + by_contra hn + have hs:∀h:Eis,¬(3:Eis)∣h→sourceResidualFourierCoefficient h=0:=by + intro h hh + by_contra hne + exact hn ⟨h,hh,hne⟩ + apply cubicSource_not_eisenstein_periodic + intro a w + obtain ⟨z,v,hv,rfl⟩:=upperPoint_surjective w + rw [complexTranslation_action] + exact source_period_of_three_supported hs a z v hv + +theorem exists_sourceArithmeticResidue_not_three : + ∃h:Eis,¬(3:Eis)∣h ∧ sourceArithmeticResidue h≠0 := by + obtain ⟨h,hh,ht⟩:=exists_source_coefficient_not_three + refine ⟨h,hh,?_⟩ + intro hz + apply ht + simp only [sourceResidualFourierCoefficient,hz,mul_zero] + +end CubicEisenstein + +namespace CompletedGauss + +section +open Filter MeasureTheory +open scoped Classical BigOperators Topology FourierTransform SchwartzMap ContDiff + +lemma compactMellin_vertical_integrable (V : ℝ→ℂ) (a b : ℝ) (ha : 0(𝓕 f) (t/(2*Real.pi))) := by + simpa only [div_eq_mul_inv] using + (𝓕 f).integrable.comp_mul_right' (inv_ne_zero (mul_ne_zero (by norm_num) Real.pi_ne_zero)) + change Integrable (fun t : ℝ=>mellin V ((σ:ℂ)+t*Complex.I)) + have hfcoe : (f:ℝ→ℂ)=CubicReflectionKernel.mellinLogFamily V σ := rfl + simpa only [CubicReflectionKernel.mellin_eq_logFamily_fourier, + SchwartzMap.fourier_coe,hfcoe] using hf + +theorem compactMellin_inversion (V : ℝ→ℂ) (a b : ℝ) (ha : 0(r:ℂ)^((σ:ℂ)+t*Complex.I)) := by + let : NeZero (r:ℂ) := ⟨Complex.ofReal_ne_zero.mpr hr.ne'⟩ + exact (_root_.continuous_const_cpow (r:ℂ)).comp (by fun_prop) + +lemma positive_cpow_negative_vertical_continuous (r σ : ℝ) (hr : 0(r:ℂ)^(-((σ:ℂ)+t*Complex.I))) := by + let : NeZero (r:ℂ) := ⟨Complex.ofReal_ne_zero.mpr hr.ne'⟩ + exact (_root_.continuous_const_cpow (r:ℂ)).comp (by fun_prop) + +lemma vertical_power_mul_integrable (M : ℝ→ℂ) (hM : Integrable M) + (r σ : ℝ) (hr : 0(r:ℂ)^((σ:ℂ)+t*Complex.I)*M t) := by + apply (hM.norm.const_mul (r^σ)).mono' + ((positive_cpow_vertical_continuous r σ hr).aestronglyMeasurable.mul hM.aestronglyMeasurable) + exact Filter.Eventually.of_forall (fun t=>by simp only [Pi.mul_apply,norm_mul,positive_cpow_vertical_norm r σ t hr,le_refl]) + +lemma weighted_vertical_power_integrable (M : ℝ→ℂ) (hM : Integrable M) + (r σ : ℝ) (hr : 0c*(r:ℂ)^(-((σ:ℂ)+t*Complex.I))*M t) := by + apply (hM.norm.const_mul (‖c‖*r^(-σ))).mono' + ((continuous_const.mul (positive_cpow_negative_vertical_continuous r σ hr)).aestronglyMeasurable.mul hM.aestronglyMeasurable) + exact Filter.Eventually.of_forall (fun t=>by + simp only [Pi.mul_apply,norm_mul,positive_cpow_negative_vertical_norm r σ t hr,le_refl]) + +lemma weighted_vertical_power_integral_norm (M : ℝ→ℂ) (r σ : ℝ) (hr : 0‖c i‖*(r i)^(-σ))) + (M : ℝ→ℂ) (hM : Integrable M) : + (∑' i,∫t : ℝ,c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))*M t)= + ∫t : ℝ,(∑' i,c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I)))*M t := by + have hi (i : α) := weighted_vertical_power_integrable M hM (r i) σ (hr i) (c i) + have hs : Summable (fun i=>∫t : ℝ,‖c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))*M t‖) := by + simp only [weighted_vertical_power_integral_norm M _ σ (hr _) _] + exact hc.mul_right _ + rw [integral_tsum_of_summable_integral_norm hi hs] + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun t=>tsum_mul_right) + +lemma positive_quotient_cpow_neg (r X : ℝ) (hr : 0‖c i‖*(r i)^(-σ))) + (V : ℝ→ℂ) (a b : ℝ) (ha : 0(X:ℂ)^((σ:ℂ)+t*Complex.I)*mellin V ((σ:ℂ)+t*Complex.I) + have hM : Integrable M := vertical_power_mul_integrable _ + (compactMellin_vertical_integrable V a b ha hsupp hV σ) X σ hX + have hi (i : α) : c i*V (r i/X)=(1/(2*Real.pi):ℂ)* + ∫t : ℝ,c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))*M t := by + rw [compactMellin_inversion V a b ha hsupp hV σ _ (div_pos (hr i) hX)] + rw [←mul_assoc,mul_comm (c i),mul_assoc,←integral_const_mul] + congr 1 + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun t=>by + dsimp only + rw [positive_quotient_cpow_neg _ _ (hr i) hX] + dsimp only [M] + ring) + simp_rw [hi] + rw [tsum_mul_left,weighted_vertical_sum_integral r hr c σ hc M hM] + congr 1 + apply integral_congr_ae + exact Filter.Eventually.of_forall (fun t=>by dsimp only [M];ring) + +end CompletedGauss + +open Filter MeasureTheory +open scoped Classical BigOperators Topology + +namespace CompletedGauss + +section +open ActualEisensteinCubic ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +lemma angularFactor_norm_le_one (a : ActualEisensteinCubic.O) : ‖FiniteGaussPhase.angularFactor a‖≤1 := by + by_cases ha : a=0 + · subst a; simp [FiniteGaussPhase.angularFactor] + · exact (FiniteGaussPhase.norm_angularFactor a ha).le + +lemma cubicRow_norm_le_one (I : Ideal ActualEisensteinCubic.O) (hI : primaryGenerator I≠0) (x : ActualEisensteinCubic.O⧸I) : + ‖cubicRow I hI x‖≤1 := by + unfold cubicRow + rw [norm_prod] + apply Finset.prod_le_one₀ + · intro i hi; exact norm_nonneg _ + · intro i hi + exact FiniteRayExpansion.norm_char_le_one _ _ + +lemma gaussTwo_norm_le_sqrt (I : Ideal ActualEisensteinCubic.O) (hI : primaryGenerator I≠0) : + ‖gaussTwo I hI‖≤Real.sqrt (Ideal.absNorm I:ℝ) := by + let n := primaryGenerator I + let : Finite (ActualEisensteinCubic.O⧸Ideal.span {n}) := finite_quotient_span hI + let : Fintype (ActualEisensteinCubic.O⧸Ideal.span {n}) := Fintype.ofFinite _ + let e := Ideal.quotEquivOfEq (primaryGenerator_spec I hI).1 + let ψ := eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates n hI + have hN : 0<(Ideal.absNorm I:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun h=>primaryGenerator_ne_zero_ideal I hI (Ideal.absNorm_eq_zero_iff.mp h)) + have hn : ‖eisEmbedding n‖=Real.sqrt (Ideal.absNorm I:ℝ) := primaryGenerator_norm I hI + have hsum : ‖∑x : ActualEisensteinCubic.O⧸Ideal.span {n},cubicRow I hI (e x)*ψ x‖≤(Ideal.absNorm I:ℝ) := by + calc + _≤∑x : ActualEisensteinCubic.O⧸Ideal.span {n},‖cubicRow I hI (e x)*ψ x‖ := norm_sum_le _ _ + _≤∑_x : ActualEisensteinCubic.O⧸Ideal.span {n},(1:ℝ) := by + apply Finset.sum_le_sum + intro x hx + rw [norm_mul,AddChar.norm_apply,mul_one] + exact cubicRow_norm_le_one I hI (e x) + _=(Ideal.absNorm I:ℝ) := by + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] + congr 1 + rw [←Nat.card_eq_fintype_card,←Submodule.cardQuot_apply,←Ideal.absNorm_apply, + (primaryGenerator_spec I hI).1] + change ‖(∑x : ActualEisensteinCubic.O⧸Ideal.span {n},cubicRow I hI (e x)*ψ x)/(‖eisEmbedding n‖:ℂ)‖≤_ + rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg _),hn] + apply (div_le_iff₀ (Real.sqrt_pos.mpr hN)).mpr + simpa only [Real.mul_self_sqrt hN.le] using hsum + +lemma columnWeight_div_sqrt_norm_le_one (Ψ : ActualEisensteinCubic.O→*ℂ) (hΨ : ∀a,‖Ψ a‖≤1) (I : Ideal ActualEisensteinCubic.O) : + ‖columnWeight Ψ I/(Real.sqrt (Ideal.absNorm I:ℝ):ℂ)‖≤1 := by + by_cases hI : Squarefree I ∧ primaryGenerator I≠0 + · have hN : 0<(Ideal.absNorm I:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun h=>primaryGenerator_ne_zero_ideal I hI.2 (Ideal.absNorm_eq_zero_iff.mp h)) + rw [columnWeight_eq Ψ I hI.1 hI.2,norm_div,norm_mul,norm_mul,norm_star, + FiniteGaussPhase.norm_angularFactor _ hI.2,one_mul, + Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (Real.sqrt_nonneg _)] + apply (div_le_one (Real.sqrt_pos.mpr hN)).mpr + exact (mul_le_of_le_one_right (norm_nonneg _) (hΨ _)).trans (gaussTwo_norm_le_sqrt I hI.2) + · simp only [columnWeight,squarefreeGaussCoefficient,dite_eq_right hI,zero_mul,zero_div,norm_zero,zero_le_one] + +lemma cubeWeight_norm_le_one (Ψ : ActualEisensteinCubic.O→*ℂ) (hΨ : ∀a,‖Ψ a‖≤1) (I : Ideal ActualEisensteinCubic.O) : + ‖cubeWeight Ψ I‖≤1 := by + by_cases hI : I=0 + · subst I; simp + have hN : (1:ℝ)≤(Ideal.absNorm I:ℝ) := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (fun h=>hI (Ideal.absNorm_eq_zero_iff.mp h)) + have hn : 0<(Ideal.absNorm I:ℝ) := lt_of_lt_of_le zero_lt_one hN + change ‖star (FiniteGaussPhase.angularFactor (primaryGenerator I))^3* + Ψ (primaryGenerator I)^3/(Ideal.absNorm I:ℂ)‖≤1 + rw [norm_div,norm_mul,norm_pow,norm_star,norm_pow,Complex.norm_natCast] + apply (div_le_one hn).mpr + apply le_trans _ hN + calc + _≤(1:ℝ)*1 := mul_le_mul + (pow_le_one₀ (norm_nonneg _) (angularFactor_norm_le_one _)) + (pow_le_one₀ (norm_nonneg _) (hΨ _)) (pow_nonneg (norm_nonneg _) _) zero_le_one + _=1 := one_mul _ + +end + +open Filter MeasureTheory +open scoped Classical BigOperators Topology ContDiff + +section +open ActualEisensteinCubic CubicEisenstein +local notation "O" => ActualEisensteinCubic.O + +abbrev CompletedMellinIndex := NonzeroIdeal×NonzeroIdeal + +def completedMellinLength (p : CompletedMellinIndex) : ℝ := + (Ideal.absNorm p.1.1:ℝ)*(Ideal.absNorm p.2.1:ℝ)^3 + +def completedMellinCoefficient (Ψ : ActualEisensteinCubic.O→*ℂ) (p : CompletedMellinIndex) : ℂ := + columnWeight Ψ p.1.1/(Real.sqrt (Ideal.absNorm p.1.1:ℝ):ℂ)*cubeWeight Ψ p.2.1 + +lemma nonzeroIdeal_norm_pos (I : NonzeroIdeal) : 0<(Ideal.absNorm I.1:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun h=>I.2 (Ideal.absNorm_eq_zero_iff.mp h)) + +lemma completedMellinLength_pos (p : CompletedMellinIndex) : 0(Ideal.absNorm I.1:ℝ)^(-σ)) := by + have h := (fullIdealWeight_summable_norm (σ:ℂ) (by simpa using hσ)).subtype (fun I=>I≠0) + apply h.congr + intro I + change ‖fullIdealWeight (σ:ℂ) I.1‖=(Ideal.absNorm I.1:ℝ)^(-σ) + rw [fullIdealWeight,ite_eq_right I.2] + simpa only [Complex.neg_re,Complex.ofReal_re,Complex.ofReal_natCast] using + (Complex.norm_cpow_eq_rpow_re_of_pos (nonzeroIdeal_norm_pos I) (-(σ:ℂ))) + +lemma completedMellinLength_rpow (p : CompletedMellinIndex) (σ : ℝ) : + (completedMellinLength p)^(-σ)= + (Ideal.absNorm p.1.1:ℝ)^(-σ)*(Ideal.absNorm p.2.1:ℝ)^(-(3*σ)) := by + rw [completedMellinLength,Real.mul_rpow (nonzeroIdeal_norm_pos p.1).le + (pow_nonneg (nonzeroIdeal_norm_pos p.2).le _),←Real.rpow_natCast_mul (nonzeroIdeal_norm_pos p.2).le] + congr 1 + congr 1 + ring + +theorem completedMellinCoefficient_summable (Ψ : ActualEisensteinCubic.O→*ℂ) (hΨ : ∀a,‖Ψ a‖≤1) + (σ : ℝ) (hσ : 1<σ) : + Summable (fun p=>‖completedMellinCoefficient Ψ p‖*(completedMellinLength p)^(-σ)) := by + have hI := nonzeroIdeal_norm_rpow_summable σ hσ + have hJ := nonzeroIdeal_norm_rpow_summable (3*σ) (by linarith) + have hp := hI.mul_of_nonneg hJ (fun I=>Real.rpow_nonneg (nonzeroIdeal_norm_pos I).le _) + (fun J=>Real.rpow_nonneg (nonzeroIdeal_norm_pos J).le _) + apply hp.of_nonneg_of_le + · intro p; exact mul_nonneg (norm_nonneg _) (Real.rpow_nonneg (completedMellinLength_pos p).le _) + · intro p + rw [←completedMellinLength_rpow] + exact mul_le_of_le_one_left (Real.rpow_nonneg (completedMellinLength_pos p).le _) + (completedMellinCoefficient_norm_le_one Ψ hΨ p) + +def completedDirichletSeries (Ψ : ActualEisensteinCubic.O→*ℂ) (s : ℂ) : ℂ := + ∑'p : CompletedMellinIndex,completedMellinCoefficient Ψ p* + (completedMellinLength p:ℂ)^(1/2-s) + +theorem completedT_eq_mellin_index (Ψ : ActualEisensteinCubic.O→*ℂ) (W : ℝ→ℂ) + (hW : HasCompactSupport W) (X : ℝ) (hX : 0(p.1.1,p.2.1)) := by + intro p q h + apply Prod.ext <;> apply Subtype.ext + · exact congrArg Prod.fst h + · exact congrArg Prod.snd h + have hsub := hfull.comp_injective hinj + calc + completedT Ψ W X=∑'I : NonzeroIdeal,∑'J : Ideal ActualEisensteinCubic.O,summand Ψ W X I.1 J := by + symm + unfold completedT + apply tsum_subtype_eq_of_support_subset + (s:={I:Ideal ActualEisensteinCubic.O|I≠0}) (f:=fun I:Ideal ActualEisensteinCubic.O=>∑'J:Ideal ActualEisensteinCubic.O,summand Ψ W X I J) + intro I hI hz + subst I + exact hI (by simp only [summand_zero_left,tsum_zero]) + _=∑'I : NonzeroIdeal,∑'J : NonzeroIdeal,summand Ψ W X I.1 J.1 := by + apply tsum_congr + intro I + symm + apply tsum_subtype_eq_of_support_subset + (s:={J:Ideal ActualEisensteinCubic.O|J≠0}) (f:=fun J:Ideal ActualEisensteinCubic.O=>summand Ψ W X I.1 J) + intro J hJ hz + subst J + exact hJ (summand_zero_right Ψ W X I.1) + _=∑'p : CompletedMellinIndex,summand Ψ W X p.1.1 p.2.1 := hsub.tsum_prod.symm + _=_ := rfl + +theorem completedT_initial_mellin (Ψ : ActualEisensteinCubic.O→*ℂ) (hΨ : ∀a,‖Ψ a‖≤1) + (W : ℝ→ℂ) (a b : ℝ) (ha : 0 ActualEisensteinCubic.O + +lemma nat_sqrt_cpow_half (a : ℕ) : + (Real.sqrt (a:ℝ):ℂ)=(a:ℂ)^(1/2:ℂ) := by + simpa only [Real.sqrt_eq_rpow,Complex.ofReal_natCast,Complex.ofReal_div, + Complex.ofReal_one,Complex.ofReal_ofNat] using + (Complex.ofReal_cpow (Nat.cast_nonneg a) (1/2:ℝ)) + +lemma nat_half_shift_product (a b : ℕ) (ha : a≠0) (hb : b≠0) (C D s : ℂ) : + (C/(Real.sqrt (a:ℝ):ℂ)*(D/(b:ℂ)))*((a:ℂ)*(b:ℂ)^3)^(1/2-s)= + C*D*(b:ℂ)^(1/2-3*s)*(a:ℂ)^(-s) := by + have ha0 : (a:ℂ)≠0 := Nat.cast_ne_zero.mpr ha + have hb0 : (b:ℂ)≠0 := Nat.cast_ne_zero.mpr hb + have hhalf : (a:ℂ)^(1/2:ℂ)≠0 := (Complex.cpow_ne_zero_iff).mpr (Or.inl ha0) + rw [nat_sqrt_cpow_half] + have hmul : ((a:ℂ)*(b:ℂ)^3)^(1/2-s)= + (a:ℂ)^(1/2-s)*(b:ℂ)^(3*(1/2-s)) := by + rw [←Nat.cast_pow,Complex.natCast_mul_natCast_cpow,Nat.cast_pow, + ←Complex.natCast_cpow_natCast_mul] + norm_num + rw [hmul] + have hA : (a:ℂ)^(1/2-s)=(a:ℂ)^(1/2:ℂ)*(a:ℂ)^(-s) := by + rw [sub_eq_add_neg,Complex.cpow_add _ _ ha0] + have hB : (b:ℂ)^(3*(1/2-s))=(b:ℂ)*(b:ℂ)^(1/2-3*s) := by + rw [show (3:ℂ)*(1/2-s)=1+(1/2-3*s) by ring, + Complex.cpow_add _ _ hb0,Complex.cpow_one] + rw [hA,hB] + field_simp + +lemma completedDirichletTerm_expanded (Ψ : ActualEisensteinCubic.O→*ℂ) (s : ℂ) (p : CompletedMellinIndex) : + completedMellinCoefficient Ψ p*(completedMellinLength p:ℂ)^(1/2-s)= + columnWeight Ψ p.1.1*star (FiniteGaussPhase.angularFactor (primaryGenerator p.2.1))^3* + Ψ (primaryGenerator p.2.1)^3*(Ideal.absNorm p.2.1:ℂ)^(1/2-3*s)* + (Ideal.absNorm p.1.1:ℂ)^(-s) := by + have ha : Ideal.absNorm p.1.1≠0 := fun h=>p.1.2 (Ideal.absNorm_eq_zero_iff.mp h) + have hb : Ideal.absNorm p.2.1≠0 := fun h=>p.2.2 (Ideal.absNorm_eq_zero_iff.mp h) + unfold completedMellinCoefficient completedMellinLength + change (columnWeight Ψ p.1.1/(Real.sqrt (Ideal.absNorm p.1.1:ℝ):ℂ)* + (star (FiniteGaussPhase.angularFactor (primaryGenerator p.2.1))^3* + Ψ (primaryGenerator p.2.1)^3/(Ideal.absNorm p.2.1:ℂ)))* + (((Ideal.absNorm p.1.1:ℝ)*(Ideal.absNorm p.2.1:ℝ)^3:ℝ):ℂ)^(1/2-s)=_ + rw [Complex.ofReal_mul,Complex.ofReal_pow,Complex.ofReal_natCast,Complex.ofReal_natCast] + rw [nat_half_shift_product _ _ ha hb] + ring + +theorem completedDirichletSeries_expanded (Ψ : ActualEisensteinCubic.O→*ℂ) (s : ℂ) : + completedDirichletSeries Ψ s=∑'p : CompletedMellinIndex, + columnWeight Ψ p.1.1*star (FiniteGaussPhase.angularFactor (primaryGenerator p.2.1))^3* + Ψ (primaryGenerator p.2.1)^3*(Ideal.absNorm p.2.1:ℂ)^(1/2-3*s)* + (Ideal.absNorm p.1.1:ℂ)^(-s) := by + unfold completedDirichletSeries + exact tsum_congr (completedDirichletTerm_expanded Ψ s) + +end + +open ActualEisensteinCubic +local notation "O" => ActualEisensteinCubic.O + +lemma weighted_vertical_series_continuous {α : Type*} + (r : α→ℝ) (hr : ∀i,0‖c i‖*(r i)^(-σ))) : + Continuous (fun t : ℝ=>∑'i,c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))) := by + apply continuous_tsum + (fun i=>continuous_const.mul (positive_cpow_negative_vertical_continuous (r i) σ (hr i))) hc + intro i t + change ‖c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))‖≤‖c i‖*(r i)^(-σ) + rw [norm_mul,positive_cpow_negative_vertical_norm _ _ _ (hr i)] + +lemma weighted_vertical_series_norm {α : Type*} + (r : α→ℝ) (hr : ∀i,0‖c i‖*(r i)^(-σ))) (t : ℝ) : + ‖∑'i,c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))‖≤∑'i,‖c i‖*(r i)^(-σ) := by + have he (i : α) : ‖c i*(r i:ℂ)^(-((σ:ℂ)+t*Complex.I))‖=‖c i‖*(r i)^(-σ) := by + rw [norm_mul,positive_cpow_negative_vertical_norm _ _ _ (hr i)] + simpa only [he] using norm_tsum_le_tsum_norm (hc.congr (fun i=>(he i).symm)) + +lemma completedDirichletSeries_initial (Ψ : ActualEisensteinCubic.O→*ℂ) (t : ℝ) : + completedDirichletSeries Ψ ((2:ℂ)+t*Complex.I)= + ∑'p : CompletedMellinIndex,completedMellinCoefficient Ψ p* + (completedMellinLength p:ℂ)^(-((3/2:ℂ)+t*Complex.I)) := by + unfold completedDirichletSeries + apply tsum_congr + intro p + congr 2 + ring + +theorem completedT_initial_mellin_integrable (Ψ : ActualEisensteinCubic.O→*ℂ) (hΨ : ∀a,‖Ψ a‖≤1) + (W : ℝ→ℂ) (a b : ℝ) (ha : 0mellin (Vstar W) ((3/2:ℂ)+t*Complex.I)* + (X:ℂ)^((3/2:ℂ)+t*Complex.I)*completedDirichletSeries Ψ ((2:ℂ)+t*Complex.I)) := by + have hsum := completedMellinCoefficient_summable Ψ hΨ (3/2) (by norm_num) + have hc := weighted_vertical_series_continuous completedMellinLength completedMellinLength_pos + (completedMellinCoefficient Ψ) (3/2) hsum + have hb := weighted_vertical_series_norm completedMellinLength completedMellinLength_pos + (completedMellinCoefficient Ψ) (3/2) hsum + have hmi : Integrable (fun t : ℝ=>mellin (Vstar W) ((3/2:ℂ)+t*Complex.I)) := by + simpa only [Complex.VerticalIntegrable,Complex.ofReal_div,Complex.ofReal_ofNat] using + (compactMellin_vertical_integrable (Vstar W) a b ha (Vstar_support W a b hsupp) + (Vstar_contDiff W a b ha hsupp hW) (3/2)) + have hbase := vertical_power_mul_integrable _ hmi X (3/2) hX + have hi := hbase.mul_bdd hc.aestronglyMeasurable (Filter.Eventually.of_forall hb) + simpa only [Complex.ofReal_div,Complex.ofReal_ofNat,completedDirichletSeries_initial, + mul_comm (mellin (Vstar W) _)] using hi + +end CompletedGauss + +open scoped BigOperators Classical +open Finset AddChar MulChar EisensteinEmbedding + +namespace CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def dualIdealDyad (j : ℕ) : Finset (Ideal Eis) := + (ConcretePrimeRowBridge.idealsUpTo (2^j)).filter + (fun I => Nat.clog 2 (Ideal.absNorm I)=j) + +lemma mem_dualIdealDyad (I : Ideal Eis) (j : ℕ) : + I∈dualIdealDyad j ↔ I≠0 ∧ Nat.clog 2 (Ideal.absNorm I)=j := by + simp only [dualIdealDyad,Finset.mem_filter,ConcretePrimeRowBridge.mem_idealsUpTo] + constructor + · rintro ⟨⟨hI,_⟩,hj⟩ + exact ⟨fun h => by simp [h] at hI, hj⟩ + · rintro ⟨hI,hj⟩ + refine ⟨⟨Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hI),?_⟩,hj⟩ + simpa only [hj] using Nat.le_pow_clog (by norm_num : 1<2) (Ideal.absNorm I) + +lemma dualIdealDyad_bounds (j : ℕ) (I : Ideal Eis) (hI : I∈dualIdealDyad j) : + I≠0 ∧ (2:ℝ)^j/2≤(Ideal.absNorm I:ℝ) ∧ (Ideal.absNorm I:ℝ)≤(2:ℝ)^j := by + obtain ⟨hn,hj⟩:= (mem_dualIdealDyad I j).mp hI + have hu:=Nat.le_pow_clog (by norm_num : 1<2) (Ideal.absNorm I) + have hl:=two_pow_clog_le_double (Ideal.absNorm I) + (Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hn)) + rw [hj] at hu hl + refine ⟨hn,?_,by exact_mod_cast hu⟩ + have he : (2:ℝ)^j≤2*(Ideal.absNorm I:ℝ):=by exact_mod_cast hl + linarith + +abbrev NonzeroDualIdeal := {I : Ideal Eis // I≠0} + +def dualDyadicIndexEquiv : + (ℕ×NonzeroDualIdeal×NonzeroDualIdeal) ≃ + (Σ i : ℕ×ℕ×ℕ, (dualIdealDyad i.2.2)×(dualIdealDyad i.2.1)) where + toFun x := ⟨(x.1,Nat.clog 2 (Ideal.absNorm x.2.2.val),Nat.clog 2 (Ideal.absNorm x.2.1.val)), + ⟨⟨x.2.1.val,(mem_dualIdealDyad _ _).mpr ⟨x.2.1.property,rfl⟩⟩, + ⟨x.2.2.val,(mem_dualIdealDyad _ _).mpr ⟨x.2.2.property,rfl⟩⟩⟩⟩ + invFun x := ⟨x.1.1,⟨x.2.1.val,((mem_dualIdealDyad _ _).mp x.2.1.property).1⟩, + ⟨x.2.2.val,((mem_dualIdealDyad _ _).mp x.2.2.property).1⟩⟩ + left_inv x := by cases x; rfl + right_inv x := by + rcases x with ⟨⟨m,j,k⟩,⟨⟨I,hI⟩,⟨J,hJ⟩⟩⟩ + have hi:=((mem_dualIdealDyad I k).mp hI).2 + have hj:=((mem_dualIdealDyad J j).mp hJ).2 + dsimp only + subst k + subst j + rfl + +theorem tsum_dualIdealDyads + (f : ℕ×NonzeroDualIdeal×NonzeroDualIdeal → ℂ) (hf : Summable f) : + (∑'x, f x) = ∑'i : ℕ×ℕ×ℕ, + ∑n : dualIdealDyad i.2.2, ∑b : dualIdealDyad i.2.1, + f (i.1,⟨n.val,((mem_dualIdealDyad _ _).mp n.property).1⟩, + ⟨b.val,((mem_dualIdealDyad _ _).mp b.property).1⟩) := by + let g := f ∘ dualDyadicIndexEquiv.symm + have hg : Summable g := dualDyadicIndexEquiv.symm.summable_iff.mpr hf + calc + _ = ∑'x,g x := (dualDyadicIndexEquiv.symm.tsum_eq f).symm + _ = ∑'i,∑'x,g ⟨i,x⟩ := Summable.tsum_sigma' (fun _=>hasSum_fintype _ |>.summable) hg + _ = _ := by + apply tsum_congr + intro i + rw [tsum_fintype,Fintype.sum_prod_type] + rfl + +end CompletedGauss + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceProjection.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceProjection.lean new file mode 100644 index 0000000000000000000000000000000000000000..f6a97c47a404f41f8ccfb90ed7d01fc60a305948 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceProjection.lean @@ -0,0 +1,646 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.RamifiedGaussSeries +import OAI.NumberTheory.DirichletL.Reciprocity.KubotaCharacter + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open scoped BigOperators Classical +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +private theorem finite_tsum_comp_addHom {R S : Type*} [AddGroup R] [AddGroup S] + [Finite R] [Finite S] (f:R→+S) (hf:Function.Surjective f) (F:S→ℂ) : + (∑'x:R,F (f x))=(Nat.card f.ker:ℂ)*∑'y:S,F y := by + let:Fintype R:=Fintype.ofFinite _ + let:Fintype S:=Fintype.ofFinite _ + let:Fintype f.ker:=Fintype.ofFinite _ + rw [tsum_fintype,tsum_fintype,←Fintype.sum_fiberwise' f F] + have hc (y:S):Fintype.card {x:R//f x=y}=Fintype.card f.ker:= + Fintype.card_congr (AddMonoidHom.fiberEquivKerOfSurjective hf y) + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,hc,Nat.card_eq_fintype_card] + rw [Finset.mul_sum] + +lemma ramified_affine_isUnit (u:Eisˣ) (n:ℕ) + (x:Eis⧸Ideal.span {u.val*lambda^n}) : IsUnit (1+3*x) := by + obtain ⟨d,rfl⟩:=Ideal.Quotient.mk_surjective x + have hh:denominatorCondition (u.val*lambda^n) (1+3*d):= + ramified_denominator_condition u n _ ⟨d,by ring⟩ + simpa only [map_add,map_one,map_mul,map_ofNat] using + (isUnit_quotient_span_iff _ _).mpr hh.1 + +def ramifiedAffineEquiv (u:Eisˣ) (n:ℕ) : + (Eis⧸Ideal.span {u.val*lambda^n})≃AdmissibleResidue (u.val*lambda^n):= + (Equiv.subtypeUnivEquiv (ramified_affine_isUnit u n)).symm.trans (affineResidueEquiv _) + +theorem ramified_arithmetic_affine (h:Eis) (u:Eisˣ) (n:ℕ) (hn:2≤n) : + arithmeticResidueSum h (u.val*lambda^n)= + ∑'x:Eis⧸Ideal.span {u.val*lambda^n}, + eisEmbedding (symbol (u.val*lambda^n) + (1+3*GaussianShiftedPartition.representative (u.val*lambda^n) x))* + residueAdditive h (u.val*lambda^n) + (1+3*GaussianShiftedPartition.representative (u.val*lambda^n) x) := by + rw [arithmeticResidueSum,←(ramifiedAffineEquiv u n).tsum_eq] + apply tsum_congr + intro x + let a:=u.val*lambda^n + let d:=1+3*GaussianShiftedPartition.representative a x + have hd:(3:Eis)∣d-1:=⟨_,by dsimp [d];ring⟩ + have hrep:3*a∣denominatorRep a ((ramifiedAffineEquiv u n) x).val-d:= + denominatorRep_mk_congr a d + change eisEmbedding (symbol a (denominatorRep a ((ramifiedAffineEquiv u n) x).val))* + residueAdditive h a (denominatorRep a ((ramifiedAffineEquiv u n) x).val)=_ + rw [row_symbol_congr_modulus a _ d (ramifiedElement_level u n hn) hd hrep, + residueAdditive_congr h a _ d (ramifiedElement_ne_zero u n) hrep] + +def ramifiedReduction (u:Eisˣ) (n:ℕ) (hn:2≤n) : + (Eis⧸Ideal.span {u.val*lambda^n})→+*(Eis⧸Ideal.span {(3:Eis)}):= + Ideal.Quotient.factor (Ideal.span_singleton_le_span_singleton.mpr + (ramifiedElement_level u n hn)) + +lemma ramifiedReduction_surjective (u:Eisˣ) (n:ℕ) (hn:2≤n) : + Function.Surjective (ramifiedReduction u n hn):= + Ideal.Quotient.factor_surjective _ + +lemma ramifiedReduction_rep (u:Eisˣ) (n:ℕ) (hn:2≤n) + (x:Eis⧸Ideal.span {u.val*lambda^n}) : + (3:Eis)∣GaussianShiftedPartition.representative (u.val*lambda^n) x- + GaussianShiftedPartition.representative 3 (ramifiedReduction u n hn x) := by + apply Ideal.mem_span_singleton.mp + apply (Ideal.Quotient.mk_eq_mk_iff_sub_mem _ _).mp + rw [GaussianShiftedPartition.representative_spec] + have hh:=congrArg (ramifiedReduction u n hn) + (GaussianShiftedPartition.representative_spec (u.val*lambda^n) x) + exact hh + +lemma residueAdditive_ramified_scale (h k a d:Eis) (ha:a≠0) (hk:3*h=a*k) : + residueAdditive h a d=residueAdditive k 3 d := by + unfold residueAdditive cuspFrequency + congr 1 + have he:=congrArg eisEmbedding hk + simp only [map_mul,map_ofNat] at he + have ha':eisEmbedding a≠0:=eisEmbedding_ne_zero ha + simp only [map_ofNat] + field_simp + linear_combination eisLam⁻¹*eisEmbedding d*he + +def ramifiedNineSum (k:Eis) (u:Eisˣ) (n:ℕ):ℂ:= + ∑'x:Eis⧸Ideal.span {(3:Eis)}, + eisEmbedding (symbol (u.val*lambda^n) + (1+3*GaussianShiftedPartition.representative 3 x))* + residueAdditive k 3 (1+3*GaussianShiftedPartition.representative 3 x) + +lemma ramifiedReduction_kernel_card (u:Eisˣ) (n:ℕ) (hn:2≤n) : + Nat.card (ramifiedReduction u n hn).toAddMonoidHom.ker=3^(n-2) := by + have hc:=card_ring_eq_card_mul_kernel (ramifiedReduction u n hn) + (ramifiedReduction_surjective u n hn) + change Ideal.absNorm (Ideal.span {u.val*lambda^n})= + Ideal.absNorm (Ideal.span {(3:Eis)})*Nat.card (ramifiedReduction u n hn).toAddMonoidHom.ker at hc + rw [ramifiedElement_absNorm,three_absNorm] at hc + have hn':n=2+(n-2):=by omega + have hp:(3:ℕ)^n=9*3^(n-2):=by + conv_lhs => rw [hn'] + rw [pow_add] + norm_num + omega + +theorem ramified_arithmetic_nine_sum (h k:Eis) (u:Eisˣ) (n:ℕ) (hn:2≤n) + (hk:3*h=(u.val*lambda^n)*k) : + arithmeticResidueSum h (u.val*lambda^n)= + ((3^(n-2):ℕ):ℂ)*ramifiedNineSum k u n := by + let a:=u.val*lambda^n + let f:=ramifiedReduction u n hn + let F:Eis⧸Ideal.span {(3:Eis)}→ℂ:=fun x=> + eisEmbedding (symbol a (1+3*GaussianShiftedPartition.representative 3 x))* + residueAdditive k 3 (1+3*GaussianShiftedPartition.representative 3 x) + have hpoint (x:Eis⧸Ideal.span {a}): + eisEmbedding (symbol a (1+3*GaussianShiftedPartition.representative a x))* + residueAdditive h a (1+3*GaussianShiftedPartition.representative a x)=F (f x):=by + let d:=1+3*GaussianShiftedPartition.representative a x + let e:=1+3*GaussianShiftedPartition.representative 3 (f x) + have hd:(3:Eis)∣d-1:=⟨_,by dsimp [d];ring⟩ + have he:(3:Eis)∣e-1:=⟨_,by dsimp [e];ring⟩ + have h9:(9:Eis)∣d-e:=by + obtain ⟨w,hw⟩:=ramifiedReduction_rep u n hn x + exact ⟨w,by dsimp [d,e,f,a] at *;linear_combination 3*hw⟩ + change eisEmbedding (symbol a d)*residueAdditive h a d=F (f x) + rw [ramified_symbol_congr_mod_nine u n d e hd he h9, + residueAdditive_ramified_scale h k a d (ramifiedElement_ne_zero u n) hk, + residueAdditive_congr k 3 d e (by norm_num) (by convert h9 using 1 ;norm_num)] + let:Finite (Eis⧸Ideal.span {a}):=finite_quotient_span (ramifiedElement_ne_zero u n) + let:Finite (Eis⧸Ideal.span {(3:Eis)}):=finite_quotient_span (by norm_num) + rw [ramified_arithmetic_affine h u n hn] + calc + _=∑'x:Eis⧸Ideal.span {a},F (f x):=tsum_congr hpoint + _=(Nat.card f.toAddMonoidHom.ker:ℂ)*∑'x,F x:= + finite_tsum_comp_addHom f.toAddMonoidHom (ramifiedReduction_surjective u n hn) F + _=_:=by rw [ramifiedReduction_kernel_card u n hn];rfl + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +def ramifiedLinearChar (u:Eisˣ) (n:ℕ):AddChar Eis ℂ where + toFun x:=eisEmbedding (symbol (u.val*lambda^n) (1+3*x)) + map_zero_eq_one':=by simp + map_add_eq_mul':=by + intro x y + have hp (z:Eis):(3:Eis)∣1+3*z-1:=⟨z,by ring⟩ + have hprod:(3:Eis)∣(1+3*x)*(1+3*y)-1:=⟨x+y+3*x*y,by ring⟩ + rw [ramified_symbol_congr_mod_nine u n (1+3*(x+y)) + ((1+3*x)*(1+3*y)) (hp _) hprod ⟨-x*y,by ring⟩, + symbol_mul_denominator,map_mul] + +lemma ramifiedLinearChar_period (u:Eisˣ) (n:ℕ) (x:Eis) + (hx:x∈Ideal.span {(3:Eis)}) : ramifiedLinearChar u n x=1 := by + obtain ⟨w,rfl⟩:=Ideal.mem_span_singleton.mp hx + change eisEmbedding (symbol (u.val*lambda^n) (1+3*(3*w)))=1 + rw [ramified_symbol_congr_mod_nine u n _ 1 ⟨3*w,by ring⟩ (by simp) ⟨w,by ring⟩] + simp + +def ramifiedQuotientChar (u:Eisˣ) (n:ℕ):AddChar (Eis⧸Ideal.span {(3:Eis)}) ℂ:= + IdealGaussCRT.quotientAddChar _ (ramifiedLinearChar u n) (ramifiedLinearChar_period u n) + +lemma ramifiedQuotientChar_rep (u:Eisˣ) (n:ℕ) (x:Eis⧸Ideal.span {(3:Eis)}) : + ramifiedQuotientChar u n x= + eisEmbedding (symbol (u.val*lambda^n) + (1+3*GaussianShiftedPartition.representative 3 x)) := by + conv_lhs => rw [←GaussianShiftedPartition.representative_spec 3 x] + rfl + +def ramifiedFrequencyChar (k:Eis) (u:Eisˣ) (n:ℕ): + AddChar (Eis⧸Ideal.span {(3:Eis)}) ℂ:= + ramifiedQuotientChar u n * + (eisTraceModChar ShortDraftTrace.breveE ConcreteBreveE.breveE_period_coordinates + 3 (by norm_num)).mulShift (Ideal.Quotient.mk _ k) + +lemma ramifiedFrequencyChar_rep (k:Eis) (u:Eisˣ) (n:ℕ) + (x:Eis⧸Ideal.span {(3:Eis)}) : + ramifiedFrequencyChar k u n x= + eisEmbedding (symbol (u.val*lambda^n) + (1+3*GaussianShiftedPartition.representative 3 x))* + residueAdditive k 3 (3*GaussianShiftedPartition.representative 3 x) := by + rw [ramifiedFrequencyChar,AddChar.mul_apply,ramifiedQuotientChar_rep] + congr 1 + conv_lhs => rw [←GaussianShiftedPartition.representative_spec 3 x] + simp only [AddChar.mulShift_apply,←map_mul,eisTraceModChar,IdealGaussCRT.traceModChar_mk] + unfold residueAdditive cuspFrequency + simp only [map_mul,map_ofNat] + congr 1 + field_simp + +theorem ramifiedNineSum_eq_character_test (k:Eis) (u:Eisˣ) (n:ℕ) : + ramifiedNineSum k u n= + if ramifiedFrequencyChar k u n=1 then 9*residueAdditive k 3 1 else 0 := by + let:Finite (Eis⧸Ideal.span {(3:Eis)}):=finite_quotient_span (by norm_num) + let:Fintype (Eis⧸Ideal.span {(3:Eis)}):=Fintype.ofFinite _ + have hcard:(Fintype.card (Eis⧸Ideal.span {(3:Eis)}):ℂ)=9:=by + have hh:=three_absNorm + change Nat.card (Eis⧸Ideal.span {(3:Eis)})=9 at hh + exact_mod_cast (show Fintype.card (Eis⧸Ideal.span {(3:Eis)})=9 by + simpa only [Nat.card_eq_fintype_card] using hh) + have he:ramifiedNineSum k u n=residueAdditive k 3 1* + ∑'x:Eis⧸Ideal.span {(3:Eis)},ramifiedFrequencyChar k u n x:=by + rw [ramifiedNineSum,←tsum_mul_left] + apply tsum_congr + intro x + rw [ramifiedFrequencyChar_rep,residueAdditive_add] + ring + rw [he,tsum_fintype] + split_ifs with hchar + · rw [AddChar.sum_eq_card_of_eq_one hchar,hcard] + ring + · rw [AddChar.sum_eq_zero_of_ne_one hchar,mul_zero] + +theorem ramified_arithmetic_character_test (h k:Eis) (u:Eisˣ) (n:ℕ) (hn:2≤n) + (hk:3*h=(u.val*lambda^n)*k) : + arithmeticResidueSum h (u.val*lambda^n)= + if ramifiedFrequencyChar k u n=1 then ((3^n:ℕ):ℂ)*residueAdditive k 3 1 else 0 := by + rw [ramified_arithmetic_nine_sum h k u n hn hk,ramifiedNineSum_eq_character_test] + have hp:(3:ℕ)^n=3^(n-2)*9:=by + have hn':n=(n-2)+2:=by omega + conv_lhs => rw [hn'] + rw [pow_add] + norm_num + split_ifs + · rw [hp,Nat.cast_mul] + norm_num + ring + · ring + +end CubicEisenstein + +namespace CubicKubota + +open scoped Classical MatrixGroups + +section +open ActualEisensteinCubic +open CubicEisenstein + +def levelThreeInTwo : Subgroup levelTwo := levelThree.comap levelTwo.subtype + +instance levelThreeInTwo_normal : levelThreeInTwo.Normal := by + constructor + intro n hn g + exact (levelThreeConjugate (g:SL(2,ActualEisensteinCubic.O)) ⟨(n:SL(2,ActualEisensteinCubic.O)),hn⟩).property + +instance levelThreeInTwo_finiteIndex : levelThreeInTwo.FiniteIndex := by + let : levelThree.FiniteIndex := levelThree_finiteIndex + change (levelThree.comap levelTwo.subtype).FiniteIndex + infer_instance + +def rationalLift : SL(2,ℤ)→*levelTwo where + toFun r := ⟨rationalEmbedding r,rational_mem_levelTwo r⟩ + map_one' := Subtype.ext (map_one _) + map_mul' _ _ := Subtype.ext (map_mul _ _ _) + +def rationalQuotient : SL(2,ℤ)→*(levelTwo ⧸ levelThreeInTwo) := + (QuotientGroup.mk' levelThreeInTwo).comp rationalLift + +theorem rationalQuotient_surjective : Function.Surjective rationalQuotient := by + intro q + obtain ⟨g,rfl⟩ := QuotientGroup.mk'_surjective levelThreeInTwo q + obtain ⟨n,r,hr⟩ := g.property + refine ⟨r,?_⟩ + let n2 : levelTwo := ⟨(n:SL(2,ActualEisensteinCubic.O)),levelThree_le_levelTwo n.property⟩ + have he : g=n2*rationalLift r := Subtype.ext hr.symm + have hn : QuotientGroup.mk' levelThreeInTwo n2=1 := + (QuotientGroup.eq_one_iff n2).mpr n.property + change QuotientGroup.mk' levelThreeInTwo (rationalLift r)=_ + rw [he,map_mul,hn,one_mul] + +def rationalCongruenceThree : Subgroup (SL(2,ℤ)) := rationalQuotient.ker + +instance rationalCongruenceThree_normal : rationalCongruenceThree.Normal := by + unfold rationalCongruenceThree + infer_instance + +theorem mem_rationalCongruenceThree (r : SL(2,ℤ)) : + r∈rationalCongruenceThree ↔ rationalEmbedding r∈levelThree := by + change QuotientGroup.mk' levelThreeInTwo (rationalLift r)=1 ↔ _ + exact QuotientGroup.eq_one_iff _ + +def rationalQuotientEquiv : (SL(2,ℤ) ⧸ rationalCongruenceThree) ≃* + (levelTwo ⧸ levelThreeInTwo) := + QuotientGroup.quotientKerEquivOfSurjective rationalQuotient rationalQuotient_surjective + +instance rationalCongruenceThree_finiteIndex : rationalCongruenceThree.FiniteIndex := by + have he : rationalCongruenceThree=levelThree.comap rationalEmbedding := by + ext r + exact mem_rationalCongruenceThree r + rw [he] + let : levelThree.FiniteIndex := levelThree_finiteIndex + infer_instance + +theorem finite_rational_representatives : ∃R : Finset (SL(2,ℤ)), + ∀g : levelTwo,∃r∈R,(g:SL(2,ActualEisensteinCubic.O))*(rationalEmbedding r)⁻¹∈levelThree := by + let : Fintype (levelTwo ⧸ levelThreeInTwo) := Fintype.ofFinite _ + let sectionMap : (levelTwo ⧸ levelThreeInTwo)→SL(2,ℤ) := + fun q => (rationalQuotient_surjective q).choose + have hsection : ∀q,rationalQuotient (sectionMap q)=q := + fun q => (rationalQuotient_surjective q).choose_spec + refine ⟨Finset.univ.image sectionMap,fun g => ?_⟩ + let q := QuotientGroup.mk' levelThreeInTwo g + refine ⟨sectionMap q,Finset.mem_image.mpr ⟨q,Finset.mem_univ _,rfl⟩,?_⟩ + have he : QuotientGroup.mk' levelThreeInTwo (g*(rationalLift (sectionMap q))⁻¹)=1 := by + rw [map_mul,map_inv] + change q*(rationalQuotient (sectionMap q))⁻¹=1 + rw [hsection,mul_inv_cancel] + exact (QuotientGroup.eq_one_iff (N:=levelThreeInTwo) + (g*(rationalLift (sectionMap q))⁻¹)).mp he + +end + +open ActualEisensteinCubic + +lemma three_dvd_intCast_iff (a : ℤ) : (3:ActualEisensteinCubic.O)∣(a:ActualEisensteinCubic.O) ↔ (3:ℤ)∣a := by + constructor + · rintro ⟨x,hx⟩ + obtain ⟨u,v,huv⟩ := ActualEisensteinCoordinates.exists_coordinates x + have he : ActualEisensteinCoordinates.eval a 0= + ActualEisensteinCoordinates.eval (3*u) (3*v) := by + dsimp [ActualEisensteinCoordinates.eval] + rw [hx,huv] + push_cast + ring + exact ⟨u,(ActualEisensteinCoordinates.unique_coordinates he).1⟩ + · rintro ⟨b,hb⟩ + refine ⟨(b:ActualEisensteinCubic.O),?_⟩ + simpa only [Int.cast_mul,Int.cast_ofNat] using congrArg (fun z : ℤ => (z:ActualEisensteinCubic.O)) hb + +lemma mem_levelThree_iff_entries (g : SL(2,ActualEisensteinCubic.O)) : g∈levelThree ↔ + ∀i j,(3:ActualEisensteinCubic.O)∣g i j-(if i=j then 1 else 0) := by + constructor + · intro hg i j + exact levelThree_entry ⟨g,hg⟩ i j + · intro h + change Matrix.SpecialLinearGroup.map (n:=Fin 2) + (Ideal.Quotient.mk (Ideal.span {(3:ActualEisensteinCubic.O)})) g=1 + apply Matrix.SpecialLinearGroup.ext + intro i j + change Ideal.Quotient.mk (Ideal.span {(3:ActualEisensteinCubic.O)}) (g i j)= + (1:Matrix (Fin 2) (Fin 2) (ActualEisensteinCubic.O ⧸ Ideal.span {(3:ActualEisensteinCubic.O)})) i j + rw [Matrix.one_apply] + have he := (Ideal.Quotient.mk_eq_mk_iff_sub_mem (g i j) (if i=j then 1 else 0)).mpr + (Ideal.mem_span_singleton.mpr (h i j)) + simpa only [apply_ite,map_one,map_zero] using he + +def rationalReductionThree : SL(2,ℤ)→*SL(2,ZMod 3) := + Matrix.SpecialLinearGroup.map (Int.castRingHom (ZMod 3)) + +lemma rationalReductionThree_eq_one_iff (g : SL(2,ℤ)) : + rationalReductionThree g=1 ↔ g∈rationalCongruenceThree := by + rw [mem_rationalCongruenceThree,mem_levelThree_iff_entries] + constructor + · intro hg i j + have he := congrArg (fun h : SL(2,ZMod 3) => h i j) hg + change (g i j:ZMod 3)=(1:Matrix (Fin 2) (Fin 2) (ZMod 3)) i j at he + rw [Matrix.one_apply] at he + have hd : (3:ℤ)∣g i j-(if i=j then 1 else 0) := by + apply (ZMod.intCast_zmod_eq_zero_iff_dvd _ 3).mp + simpa only [Int.cast_sub,Int.cast_ite,Int.cast_one,Int.cast_zero] using sub_eq_zero.mpr he + have hO := (three_dvd_intCast_iff (g i j-(if i=j then 1 else 0))).mpr hd + simpa only [rationalEmbedding,Matrix.SpecialLinearGroup.map_apply_coe, + RingHom.mapMatrix_apply,Matrix.map_apply,Int.coe_castRingHom, + Int.cast_sub,Int.cast_ite,Int.cast_one,Int.cast_zero] using hO + · intro hg + apply Matrix.SpecialLinearGroup.ext + intro i j + change (g i j:ZMod 3)=(1:Matrix (Fin 2) (Fin 2) (ZMod 3)) i j + rw [Matrix.one_apply] + apply sub_eq_zero.mp + have hd : (3:ℤ)∣g i j-(if i=j then 1 else 0) := by + apply (three_dvd_intCast_iff _).mp + simpa only [rationalEmbedding,Matrix.SpecialLinearGroup.map_apply_coe, + RingHom.mapMatrix_apply,Matrix.map_apply,Int.coe_castRingHom, + Int.cast_sub,Int.cast_ite,Int.cast_one,Int.cast_zero] using hg i j + have hz := (ZMod.intCast_zmod_eq_zero_iff_dvd _ 3).mpr hd + simpa only [Int.cast_sub,Int.cast_ite,Int.cast_one,Int.cast_zero] using hz + +abbrev RationalBruhatIndex := Fin 2 × (Fin 3 ⊕ (Fin 3 × Fin 3)) + +def rationalBruhatRep (i : RationalBruhatIndex) : SL(2,ℤ) := + ModularGroup.S^(2*i.1.val) * match i.2 with + | Sum.inl a => ModularGroup.T^a.val + | Sum.inr ab => ModularGroup.T^ab.1.val*ModularGroup.S*ModularGroup.T^ab.2.val + +lemma rationalBruhat_complete : ∀g : SL(2,ZMod 3), + ∃i : RationalBruhatIndex,rationalReductionThree (rationalBruhatRep i)=g := by + decide +kernel + +lemma rationalReductionThree_surjective : Function.Surjective rationalReductionThree := by + intro g + obtain ⟨i,hi⟩ := rationalBruhat_complete g + exact ⟨rationalBruhatRep i,hi⟩ + +lemma rationalBruhat_injective : Function.Injective + (fun i : RationalBruhatIndex => rationalReductionThree (rationalBruhatRep i)) := by + decide +kernel + +def rationalBruhatEquiv : RationalBruhatIndex ≃ SL(2,ZMod 3) := + Equiv.ofBijective (fun i => rationalReductionThree (rationalBruhatRep i)) + ⟨rationalBruhat_injective,rationalBruhat_complete⟩ + +lemma card_SLThree : Fintype.card (SL(2,ZMod 3))=24 := by + rw [←Fintype.card_congr rationalBruhatEquiv] + decide + +lemma rationalCongruenceThree_eq_ker : rationalCongruenceThree=rationalReductionThree.ker := by + ext g + exact (rationalReductionThree_eq_one_iff g).symm + +def rationalCongruenceEquivSLThree : (SL(2,ℤ) ⧸ rationalCongruenceThree) ≃* SL(2,ZMod 3) := + (QuotientGroup.quotientMulEquivOfEq rationalCongruenceThree_eq_ker).trans + (QuotientGroup.quotientKerEquivOfSurjective rationalReductionThree rationalReductionThree_surjective) + +def sourceQuotientEquivSLThree : (levelTwo ⧸ levelThreeInTwo) ≃* SL(2,ZMod 3) := + rationalQuotientEquiv.symm.trans rationalCongruenceEquivSLThree + +lemma sourceQuotient_card : Nat.card (levelTwo ⧸ levelThreeInTwo)=24 := by + rw [Nat.card_congr sourceQuotientEquivSLThree.toEquiv,Nat.card_eq_fintype_card,card_SLThree] + +lemma levelThreeInTwo_index : levelThreeInTwo.index=24 := sourceQuotient_card + +theorem twentyFour_rational_representatives (g : levelTwo) : + ∃i : RationalBruhatIndex, + (g:SL(2,ActualEisensteinCubic.O))*(rationalEmbedding (rationalBruhatRep i))⁻¹∈levelThree := by + obtain ⟨r,hr⟩ := rationalQuotient_surjective (QuotientGroup.mk' levelThreeInTwo g) + obtain ⟨i,hi⟩ := rationalBruhat_complete (rationalReductionThree r) + refine ⟨i,?_⟩ + have hred : rationalReductionThree (r*(rationalBruhatRep i)⁻¹)=1 := by + rw [map_mul,map_inv,hi,mul_inv_cancel] + have hker := (rationalReductionThree_eq_one_iff _).mp hred + have hquot : rationalQuotient r=rationalQuotient (rationalBruhatRep i) := by + have hz : rationalQuotient (r*(rationalBruhatRep i)⁻¹)=1 := hker + rw [map_mul,map_inv,mul_inv_eq_one] at hz + exact hz + have he : QuotientGroup.mk' levelThreeInTwo + (g*(rationalLift (rationalBruhatRep i))⁻¹)=1 := by + rw [map_mul,map_inv,←hr,hquot] + exact mul_inv_cancel _ + exact (QuotientGroup.eq_one_iff (N:=levelThreeInTwo) + (g*(rationalLift (rationalBruhatRep i))⁻¹)).mp he + +end CubicKubota + +open scoped BigOperators Classical MatrixGroups +namespace CubicKubota +open ActualEisensteinCubic +open CubicEisenstein + +lemma rationalQuotient_eq_iff_reduction (r s : SL(2,ℤ)) : + rationalQuotient r=rationalQuotient s ↔ + rationalReductionThree r=rationalReductionThree s := by + have hleft : rationalQuotient r=rationalQuotient s ↔ r*s⁻¹∈rationalCongruenceThree := by + change _ ↔ rationalQuotient (r*s⁻¹)=1 + rw [map_mul,map_inv,mul_inv_eq_one] + rw [hleft,←rationalReductionThree_eq_one_iff,map_mul,map_inv,mul_inv_eq_one] + +lemma levelTwoComplexCharacter_rationalLift (r : SL(2,ℤ)) : + levelTwoComplexCharacter (rationalLift r)=1 := levelTwoComplexCharacter_rational r + +def rationalCosetEquiv : RationalBruhatIndex ≃ (levelTwo ⧸ levelThreeInTwo) := + Equiv.ofBijective (fun i => rationalQuotient (rationalBruhatRep i)) ⟨by + intro i j h + exact rationalBruhat_injective ((rationalQuotient_eq_iff_reduction _ _).mp h),by + intro q + obtain ⟨r,hr⟩ := rationalQuotient_surjective q + obtain ⟨i,hi⟩ := rationalBruhat_complete (rationalReductionThree r) + exact ⟨i,((rationalQuotient_eq_iff_reduction _ _).mpr hi).trans hr⟩⟩ + +instance sourceQuotientFintype : Fintype (levelTwo ⧸ levelThreeInTwo) := Fintype.ofFinite _ + +def sourceRationalSection (q : levelTwo ⧸ levelThreeInTwo) : SL(2,ℤ) := + rationalBruhatRep (rationalCosetEquiv.symm q) + +lemma sourceRationalSection_spec (q : levelTwo ⧸ levelThreeInTwo) : + rationalQuotient (sourceRationalSection q)=q := rationalCosetEquiv.apply_symm_apply q + +def sourceProjection (f : HyperbolicSpace→ℂ) (w : HyperbolicSpace) : ℂ := + (24:ℂ)⁻¹ * ∑q : levelTwo ⧸ levelThreeInTwo, + f (integralComplexMatrix (rationalEmbedding (sourceRationalSection q)) • w) + +lemma sourceProjection_eq_twentyFour (f : HyperbolicSpace→ℂ) (w : HyperbolicSpace) : + sourceProjection f w=(24:ℂ)⁻¹ * ∑i : RationalBruhatIndex, + f (integralComplexMatrix (rationalEmbedding (rationalBruhatRep i)) • w) := by + unfold sourceProjection + congr 1 + rw [←rationalCosetEquiv.sum_comp] + simp only [sourceRationalSection,Equiv.symm_apply_apply] + +lemma sourceSection_translate (f : HyperbolicSpace→ℂ) + (hf : ∀n : levelThree,∀w,f (complexMatrix n • w)=complexCharacter n*f w) + (q : levelTwo ⧸ levelThreeInTwo) (g : levelTwo) (w : HyperbolicSpace) : + f (integralComplexMatrix (rationalEmbedding (sourceRationalSection q)) • + (integralComplexMatrix (g:SL(2,ActualEisensteinCubic.O)) • w)) = + levelTwoComplexCharacter g * + f (integralComplexMatrix (rationalEmbedding (sourceRationalSection + (q*QuotientGroup.mk' levelThreeInTwo g))) • w) := by + let r := sourceRationalSection q + let s := sourceRationalSection (q*QuotientGroup.mk' levelThreeInTwo g) + let n2 : levelTwo := rationalLift r*g*(rationalLift s)⁻¹ + have hn2 : n2∈levelThreeInTwo := by + apply (QuotientGroup.eq_one_iff (N:=levelThreeInTwo) n2).mp + change QuotientGroup.mk' levelThreeInTwo (rationalLift r*g*(rationalLift s)⁻¹)=1 + rw [map_mul,map_mul,map_inv] + change rationalQuotient r * QuotientGroup.mk' levelThreeInTwo g * + (rationalQuotient s)⁻¹=1 + rw [sourceRationalSection_spec,sourceRationalSection_spec,mul_inv_cancel] + let n : levelThree := ⟨(n2:SL(2,ActualEisensteinCubic.O)),hn2⟩ + have hc : complexCharacter n=levelTwoComplexCharacter g := by + rw [←levelTwoComplexCharacter_restrict n] + change levelTwoComplexCharacter (rationalLift r*g*(rationalLift s)⁻¹)=_ + rw [map_mul,map_mul,←map_inv rationalLift] + change levelTwoComplexCharacter (rationalLift r)*levelTwoComplexCharacter g* + levelTwoComplexCharacter (rationalLift s⁻¹)=_ + rw [levelTwoComplexCharacter_rationalLift,levelTwoComplexCharacter_rationalLift,one_mul,mul_one] + have he : rationalEmbedding r*(g:SL(2,ActualEisensteinCubic.O))=(n:SL(2,ActualEisensteinCubic.O))*rationalEmbedding s := by + change _=(rationalEmbedding r*(g:SL(2,ActualEisensteinCubic.O))*(rationalEmbedding s)⁻¹)*rationalEmbedding s + group + change f (integralComplexMatrix (rationalEmbedding r) • + (integralComplexMatrix (g:SL(2,ActualEisensteinCubic.O)) • w))= + levelTwoComplexCharacter g*f (integralComplexMatrix (rationalEmbedding s) • w) + rw [←mul_smul,←map_mul,he,map_mul,integralComplexMatrix_levelThree,mul_smul,hf,hc] + +theorem sourceProjection_automorphy (f : HyperbolicSpace→ℂ) + (hf : ∀n : levelThree,∀w,f (complexMatrix n • w)=complexCharacter n*f w) + (g : levelTwo) (w : HyperbolicSpace) : + sourceProjection f (integralComplexMatrix (g:SL(2,ActualEisensteinCubic.O)) • w)= + levelTwoComplexCharacter g * sourceProjection f w := by + unfold sourceProjection + simp_rw [sourceSection_translate f hf] + rw [←Finset.mul_sum] + rw [Function.Bijective.sum_comp + (Group.mulRight_bijective (QuotientGroup.mk' levelThreeInTwo g)) + (fun q => f (integralComplexMatrix (rationalEmbedding (sourceRationalSection q)) • w))] + ring + +theorem sourceProjection_fixed (f : HyperbolicSpace→ℂ) + (hf : ∀g : levelTwo,∀w,f (integralComplexMatrix (g:SL(2,ActualEisensteinCubic.O)) • w)= + levelTwoComplexCharacter g*f w) (w : HyperbolicSpace) : sourceProjection f w=f w := by + unfold sourceProjection + have he : ∀q : levelTwo ⧸ levelThreeInTwo, + f (integralComplexMatrix (rationalEmbedding (sourceRationalSection q)) • w)=f w := by + intro q + have hh := hf (rationalLift (sourceRationalSection q)) w + rw [levelTwoComplexCharacter_rationalLift,one_mul] at hh + exact hh + simp only [he,Finset.sum_const,Finset.card_univ,nsmul_eq_mul] + have hc : Fintype.card (levelTwo ⧸ levelThreeInTwo)=24 := by + simpa only [Nat.card_eq_fintype_card] using sourceQuotient_card + rw [hc] + push_cast + ring + +lemma sourceProjection_idempotent (f : HyperbolicSpace→ℂ) + (hf : ∀n : levelThree,∀w,f (complexMatrix n • w)=complexCharacter n*f w) : + sourceProjection (sourceProjection f)=sourceProjection f := by + funext w + exact sourceProjection_fixed _ (sourceProjection_automorphy f hf) w + +def sourceEisenstein (s : ℂ) : HyperbolicSpace→ℂ := sourceProjection (hyperbolicEisenstein s) + +theorem sourceEisenstein_automorphy (s : ℂ) (hs : 2 hyperbolicEisenstein_automorphy n s hs w) g w + +end CubicKubota + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceQuotient.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceQuotient.lean new file mode 100644 index 0000000000000000000000000000000000000000..aa871ed605cc6e83051acb2361797c7bf2ae79b0 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SourceQuotient.lean @@ -0,0 +1,618 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.SourceProjection + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +namespace CubicEisenstein +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups Matrix Pointwise + +open CubicKubota +local notation "O" => ActualEisensteinCubic.O + +abbrev SourceKernelQuotient := IntegralOrbitQuotient globalKubotaKernel + +def sourceComplexMatrix : levelTwo→*SL(2,ℂ) := + integralComplexMatrix.comp levelTwo.subtype + +lemma globalKubotaKernel_source_conjugate_mem (M : levelTwo) (N : globalKubotaKernel) : + (M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹∈globalKubotaKernel := + CubicKubota.globalKubotaKernel_conjugate M N N.property + +def kernelSourceConjugate (M : levelTwo) : globalKubotaKernel ≃* globalKubotaKernel where + toFun N := ⟨(M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹,globalKubotaKernel_source_conjugate_mem M N⟩ + invFun N := ⟨(M⁻¹:levelTwo)*(N:SL(2,ActualEisensteinCubic.O))*(M⁻¹:levelTwo)⁻¹,globalKubotaKernel_source_conjugate_mem M⁻¹ N⟩ + left_inv N := by apply Subtype.ext; simp [mul_assoc] + right_inv N := by apply Subtype.ext; simp [mul_assoc] + map_mul' N P := by apply Subtype.ext; simp [mul_assoc] + +lemma kernelSourceConjugate_coe (M : levelTwo) (N : globalKubotaKernel) : + (kernelSourceConjugate M N : SL(2,ActualEisensteinCubic.O))=(M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹ := rfl + +lemma source_action_respects_kernel (M : levelTwo) (u v : HyperbolicSpace) + (h : (integralOrbitRel globalKubotaKernel).r u v) : + (integralOrbitRel globalKubotaKernel).r (sourceComplexMatrix M • u) (sourceComplexMatrix M • v) := by + obtain ⟨N,hN⟩ := h + refine ⟨kernelSourceConjugate M N,?_⟩ + change integralComplexMatrix ((M:SL(2,ActualEisensteinCubic.O))*(N:SL(2,ActualEisensteinCubic.O))*(M:SL(2,ActualEisensteinCubic.O))⁻¹) • + (sourceComplexMatrix M • u)=sourceComplexMatrix M • v + rw [map_mul,map_mul,map_inv,mul_smul,mul_smul] + change sourceComplexMatrix M • (integralComplexMatrix (N:SL(2,ActualEisensteinCubic.O)) • + ((sourceComplexMatrix M)⁻¹ • (sourceComplexMatrix M • u)))=_ + rw [inv_smul_smul,hN] + +def kernelSourceAction (M : levelTwo) : SourceKernelQuotient→SourceKernelQuotient := + Quotient.map' (fun w => sourceComplexMatrix M • w) (source_action_respects_kernel M) + +lemma kernelSourceAction_mk (M : levelTwo) (w : HyperbolicSpace) : + kernelSourceAction M (integralOrbitProjection globalKubotaKernel w)= + integralOrbitProjection globalKubotaKernel (sourceComplexMatrix M • w) := rfl + +lemma kernelSourceAction_one (q : SourceKernelQuotient) : kernelSourceAction 1 q=q := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection globalKubotaKernel (sourceComplexMatrix 1 • w)=integralOrbitProjection globalKubotaKernel w + rw [map_one,one_smul] + +lemma kernelSourceAction_mul (M N : levelTwo) (q : SourceKernelQuotient) : + kernelSourceAction (M*N) q=kernelSourceAction M (kernelSourceAction N q) := by + induction q using Quotient.inductionOn with + | _ w => + change integralOrbitProjection globalKubotaKernel (sourceComplexMatrix (M*N) • w)= + integralOrbitProjection globalKubotaKernel (sourceComplexMatrix M • (sourceComplexMatrix N • w)) + rw [map_mul,mul_smul] + +lemma kernelSourceAction_continuous (M : levelTwo) : Continuous (kernelSourceAction M) := + (continuous_hyperbolic_action (sourceComplexMatrix M)).quotient_map' (source_action_respects_kernel M) + +def kernelSourceHomeomorph (M : levelTwo) : SourceKernelQuotient ≃ₜ SourceKernelQuotient where + toFun := kernelSourceAction M + invFun := kernelSourceAction M⁻¹ + left_inv q := by rw [←kernelSourceAction_mul,inv_mul_cancel,kernelSourceAction_one] + right_inv q := by rw [←kernelSourceAction_mul,mul_inv_cancel,kernelSourceAction_one] + continuous_toFun := kernelSourceAction_continuous M + continuous_invFun := kernelSourceAction_continuous M⁻¹ + +lemma kernelSourceAction_fundamentalDomain (M : levelTwo) : + IsFundamentalDomain globalKubotaKernel + ((fun w : HyperbolicSpace => sourceComplexMatrix M • w) '' hyperbolicFundamentalSet globalKubotaKernel) + hyperbolicVolume := by + apply (hyperbolicFundamentalSet_isFundamentalDomain globalKubotaKernel + globalKubotaKernel_le_levelThree).image_of_equiv (MulAction.toPerm (sourceComplexMatrix M)) + (show Measure.QuasiMeasurePreserving (MulAction.toPerm (sourceComplexMatrix M)).symm hyperbolicVolume hyperbolicVolume from by + exact (measurePreserving_smul (sourceComplexMatrix M)⁻¹ hyperbolicVolume).quasiMeasurePreserving) + (kernelSourceConjugate M⁻¹).toEquiv + intro N w + change sourceComplexMatrix M • (integralComplexMatrix + ((M⁻¹:levelTwo)*(N:SL(2,ActualEisensteinCubic.O))*(M⁻¹:levelTwo)⁻¹) • w)= + integralComplexMatrix (N:SL(2,ActualEisensteinCubic.O)) • (sourceComplexMatrix M • w) + simp only [Subgroup.coe_inv,map_mul,map_inv] + change sourceComplexMatrix M • (((sourceComplexMatrix M)⁻¹*integralComplexMatrix (N:SL(2,ActualEisensteinCubic.O))* + ((sourceComplexMatrix M)⁻¹)⁻¹) • w)=_ + simp only [inv_inv,mul_smul,smul_inv_smul] + +lemma kernelSourceAction_measurePreserving (M : levelTwo) : + MeasurePreserving (kernelSourceAction M) (integralQuotientVolume globalKubotaKernel) + (integralQuotientVolume globalKubotaKernel) := by + refine ⟨(kernelSourceAction_continuous M).measurable,?_⟩ + let act : HyperbolicSpace→HyperbolicSpace := fun w => sourceComplexMatrix M • w + have hmap := (measurePreserving_smul (sourceComplexMatrix M) hyperbolicVolume).restrict_image_emb + (measurableEmbedding_const_smul (sourceComplexMatrix M)) (hyperbolicFundamentalSet globalKubotaKernel) + have heq : kernelSourceAction M ∘ integralOrbitProjection globalKubotaKernel= + integralOrbitProjection globalKubotaKernel ∘ act := by ext w; rfl + change Measure.map (kernelSourceAction M) + (Measure.map (integralOrbitProjection globalKubotaKernel) + (hyperbolicVolume.restrict (hyperbolicFundamentalSet globalKubotaKernel)))=_ + rw [Measure.map_map (kernelSourceAction_continuous M).measurable + (measurable_integralOrbitProjection _),heq, + ←Measure.map_map (measurable_integralOrbitProjection _) (continuous_hyperbolic_action _).measurable] + change Measure.map (integralOrbitProjection globalKubotaKernel) + (Measure.map act (hyperbolicVolume.restrict (hyperbolicFundamentalSet globalKubotaKernel)))=_ + rw [hmap.map_eq] + exact integralQuotientVolume_independent globalKubotaKernel globalKubotaKernel_le_levelThree _ + (kernelSourceAction_fundamentalDomain M) + +end CubicEisenstein + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +namespace CubicEisenstein +open CubicKubota + +def kernelSourcePullback (M : levelTwo) : KernelQuotientL2 →ₗᵢ[ℂ] KernelQuotientL2 := + Lp.compMeasurePreservingₗᵢ ℂ (kernelSourceAction M) (kernelSourceAction_measurePreserving M) + +lemma kernelSourcePullback_ae_eq (M : levelTwo) (F : KernelQuotientL2) : + kernelSourcePullback M F=ᵐ[integralQuotientVolume globalKubotaKernel] + fun q => F (kernelSourceAction M q) := + Lp.coeFn_compMeasurePreserving F (kernelSourceAction_measurePreserving M) + +lemma kernelSourcePullback_one (F : KernelQuotientL2) : kernelSourcePullback 1 F=F := by + apply Lp.ext + filter_upwards [kernelSourcePullback_ae_eq 1 F] with q hq + simpa only [kernelSourceAction_one] using hq + +lemma kernelSourcePullback_comp (M N : levelTwo) (F : KernelQuotientL2) : + kernelSourcePullback M (kernelSourcePullback N F)=kernelSourcePullback (N*M) F := by + have hcomp := (kernelSourceAction_measurePreserving M).quasiMeasurePreserving.ae_eq_comp + (kernelSourcePullback_ae_eq N F) + apply Lp.ext + filter_upwards [kernelSourcePullback_ae_eq M (kernelSourcePullback N F),hcomp, + kernelSourcePullback_ae_eq (N*M) F] with q hp hn hnm + rw [hp,hnm] + exact hn.trans (congrArg F (kernelSourceAction_mul N M q).symm) + +lemma kernelSourcePullback_surjective (M : levelTwo) : Function.Surjective (kernelSourcePullback M) := by + intro F + refine ⟨kernelSourcePullback M⁻¹ F,?_⟩ + rw [kernelSourcePullback_comp,inv_mul_cancel,kernelSourcePullback_one] + +def kernelSourceUnitary (M : levelTwo) : KernelQuotientL2 ≃ₗᵢ[ℂ] KernelQuotientL2 := + LinearIsometryEquiv.ofSurjective (kernelSourcePullback M) (kernelSourcePullback_surjective M) + +lemma kernelSourceUnitary_apply (M : levelTwo) (F : KernelQuotientL2) : + kernelSourceUnitary M F=kernelSourcePullback M F := rfl + +local notation "O" => ActualEisensteinCubic.O + +lemma kernelSourceAction_of_kernel (g : levelTwo) + (hg : (g:SL(2,ActualEisensteinCubic.O))∈globalKubotaKernel) (q : SourceKernelQuotient) : + kernelSourceAction g q=q := by + induction q using Quotient.inductionOn with + | _ w => + exact integralOrbitProjection_eq globalKubotaKernel ⟨(g:SL(2,ActualEisensteinCubic.O)),hg⟩ w + +lemma rationalCongruenceThree_in_kernel (r : SL(2,ℤ)) (hr : r∈rationalCongruenceThree) : + rationalEmbedding r∈globalKubotaKernel := by + have hr3 := (mem_rationalCongruenceThree r).mp hr + exact (globalKubotaKernel_mem _).mpr ⟨hr3,complexCharacter_rational_intersection r hr3⟩ + +lemma kernelSourceAction_rational_eq (r s : SL(2,ℤ)) + (hrs : rationalReductionThree r=rationalReductionThree s) (q : SourceKernelQuotient) : + kernelSourceAction (rationalLift r) q=kernelSourceAction (rationalLift s) q := by + have hd : r*s⁻¹∈rationalCongruenceThree := by + apply (rationalReductionThree_eq_one_iff _).mp + rw [map_mul,map_inv,hrs,mul_inv_cancel] + have hk := rationalCongruenceThree_in_kernel _ hd + have he : rationalLift r=rationalLift (r*s⁻¹)*rationalLift s := by + rw [←map_mul,inv_mul_cancel_right] + rw [he,kernelSourceAction_mul] + exact kernelSourceAction_of_kernel _ hk _ + +lemma kernelSourcePullback_rational_eq (r s : SL(2,ℤ)) + (hrs : rationalReductionThree r=rationalReductionThree s) (F : KernelQuotientL2) : + kernelSourcePullback (rationalLift r) F=kernelSourcePullback (rationalLift s) F := by + apply Lp.ext + filter_upwards [kernelSourcePullback_ae_eq (rationalLift r) F, + kernelSourcePullback_ae_eq (rationalLift s) F] with q hr hs + rw [hr,hs,kernelSourceAction_rational_eq r s hrs] + +def kernelSourceProjection : KernelQuotientL2 →L[ℂ] KernelQuotientL2 := + (24:ℂ)⁻¹ • ∑q : levelTwo ⧸ levelThreeInTwo, + (kernelSourcePullback (rationalLift (sourceRationalSection q))).toContinuousLinearMap + +lemma kernelSourceProjection_apply (F : KernelQuotientL2) : + kernelSourceProjection F=(24:ℂ)⁻¹ • ∑q : levelTwo ⧸ levelThreeInTwo, + kernelSourcePullback (rationalLift (sourceRationalSection q)) F := by + simp only [kernelSourceProjection,_root_.smul_apply,_root_.sum_apply, + LinearIsometry.coe_toContinuousLinearMap] + +lemma kernelSourceProjection_eq_twentyFour (F : KernelQuotientL2) : + kernelSourceProjection F=(24:ℂ)⁻¹ • ∑i : RationalBruhatIndex, + kernelSourcePullback (rationalLift (rationalBruhatRep i)) F := by + rw [kernelSourceProjection_apply] + congr 1 + rw [←rationalCosetEquiv.sum_comp] + simp only [sourceRationalSection,Equiv.symm_apply_apply] + +lemma norm_kernelSourceProjection_apply (F : KernelQuotientL2) : + ‖kernelSourceProjection F‖≤‖F‖ := by + rw [kernelSourceProjection_apply,norm_smul] + calc + _ ≤ ‖(24:ℂ)⁻¹‖ * ∑q : levelTwo ⧸ levelThreeInTwo, + ‖kernelSourcePullback (rationalLift (sourceRationalSection q)) F‖ := + mul_le_mul_of_nonneg_left (norm_sum_le _ _) (norm_nonneg _) + _ = ‖F‖ := by + simp only [LinearIsometry.norm_map,Finset.sum_const,Finset.card_univ,nsmul_eq_mul] + have hc : Fintype.card (levelTwo ⧸ levelThreeInTwo)=24 := by + simpa only [Nat.card_eq_fintype_card] using sourceQuotient_card + rw [hc] + norm_num + ring + +lemma norm_kernelSourceProjection : ‖kernelSourceProjection‖≤1 := + ContinuousLinearMap.opNorm_le_bound _ (by norm_num) + (fun F => by simpa using norm_kernelSourceProjection_apply F) + +lemma sourceSection_mul_reduction (q : levelTwo ⧸ levelThreeInTwo) (r : SL(2,ℤ)) : + rationalReductionThree (sourceRationalSection q*r)= + rationalReductionThree (sourceRationalSection (q*rationalQuotient r)) := by + apply (rationalQuotient_eq_iff_reduction _ _).mp + rw [map_mul,sourceRationalSection_spec,sourceRationalSection_spec] + +lemma kernelSourcePullback_projection (r : SL(2,ℤ)) (F : KernelQuotientL2) : + kernelSourcePullback (rationalLift r) (kernelSourceProjection F)=kernelSourceProjection F := by + rw [kernelSourceProjection_apply,map_smul,map_sum] + apply congrArg (fun v : KernelQuotientL2 => (24:ℂ)⁻¹ • v) + simp_rw [kernelSourcePullback_comp,←map_mul] + have he : ∀q : levelTwo ⧸ levelThreeInTwo, + kernelSourcePullback (rationalLift (sourceRationalSection q*r)) F= + kernelSourcePullback (rationalLift (sourceRationalSection (q*rationalQuotient r))) F := + fun q => kernelSourcePullback_rational_eq _ _ (sourceSection_mul_reduction q r) F + simp_rw [he] + exact Function.Bijective.sum_comp (Group.mulRight_bijective (rationalQuotient r)) + (fun q => kernelSourcePullback (rationalLift (sourceRationalSection q)) F) + +lemma kernelSourceProjection_fixed (F : KernelQuotientL2) + (hF : ∀r : SL(2,ℤ),kernelSourcePullback (rationalLift r) F=F) : + kernelSourceProjection F=F := by + rw [kernelSourceProjection_apply] + simp only [hF,Finset.sum_const,Finset.card_univ] + have hc : Fintype.card (levelTwo ⧸ levelThreeInTwo)=24 := by + simpa only [Nat.card_eq_fintype_card] using sourceQuotient_card + rw [hc] + rw [←Nat.cast_smul_eq_nsmul ℂ,smul_smul] + norm_num + +lemma kernelSourceProjection_idempotent (F : KernelQuotientL2) : + kernelSourceProjection (kernelSourceProjection F)=kernelSourceProjection F := + kernelSourceProjection_fixed _ (fun r => kernelSourcePullback_projection r F) + +end CubicEisenstein + +namespace CubicKubota +open ActualEisensteinCubic + +def sourceLevelInclusion : levelThree→*levelTwo where + toFun n := ⟨(n:SL(2,ActualEisensteinCubic.O)),levelThree_le_levelTwo n.property⟩ + map_one' := rfl + map_mul' _ _ := rfl + +lemma sourceLevelInclusion_character (n : levelThree) : + levelTwoComplexCharacter (sourceLevelInclusion n)=complexCharacter n := + levelTwoComplexCharacter_restrict n + +lemma sourceSection_factor (q : levelTwo ⧸ levelThreeInTwo) (g : levelTwo) : + ∃n : levelThree, + rationalLift (sourceRationalSection q)*g= + sourceLevelInclusion n*rationalLift (sourceRationalSection + (q*QuotientGroup.mk' levelThreeInTwo g)) ∧ + complexCharacter n=levelTwoComplexCharacter g := by + let r := sourceRationalSection q + let s := sourceRationalSection (q*QuotientGroup.mk' levelThreeInTwo g) + let n2 : levelTwo := rationalLift r*g*(rationalLift s)⁻¹ + have hn2 : n2∈levelThreeInTwo := by + apply (QuotientGroup.eq_one_iff (N:=levelThreeInTwo) n2).mp + change QuotientGroup.mk' levelThreeInTwo (rationalLift r*g*(rationalLift s)⁻¹)=1 + rw [map_mul,map_mul,map_inv] + change rationalQuotient r * QuotientGroup.mk' levelThreeInTwo g * + (rationalQuotient s)⁻¹=1 + rw [sourceRationalSection_spec,sourceRationalSection_spec,mul_inv_cancel] + let n : levelThree := ⟨(n2:SL(2,ActualEisensteinCubic.O)),hn2⟩ + refine ⟨n,?_,?_⟩ + · change rationalLift r*g=(rationalLift r*g*(rationalLift s)⁻¹)*rationalLift s + group + · rw [←levelTwoComplexCharacter_restrict n] + change levelTwoComplexCharacter (rationalLift r*g*(rationalLift s)⁻¹)=_ + rw [map_mul,map_mul,←map_inv rationalLift] + change levelTwoComplexCharacter (rationalLift r)*levelTwoComplexCharacter g* + levelTwoComplexCharacter (rationalLift s⁻¹)=_ + rw [levelTwoComplexCharacter_rationalLift,levelTwoComplexCharacter_rationalLift,one_mul,mul_one] +end CubicKubota + +namespace CubicEisenstein +open CubicKubota + +theorem kernelSourceProjection_covariance (F : KernelQuotientL2) + (hF : ∀n : levelThree,kernelSourcePullback (sourceLevelInclusion n) F= + complexCharacter n • F) (g : levelTwo) : + kernelSourcePullback g (kernelSourceProjection F)= + levelTwoComplexCharacter g • kernelSourceProjection F := by + rw [kernelSourceProjection_apply,map_smul,map_sum] + simp_rw [kernelSourcePullback_comp] + have he : ∀q : levelTwo ⧸ levelThreeInTwo, + kernelSourcePullback (rationalLift (sourceRationalSection q)*g) F= + levelTwoComplexCharacter g • + kernelSourcePullback (rationalLift (sourceRationalSection + (q*QuotientGroup.mk' levelThreeInTwo g))) F := by + intro q + obtain ⟨n,hn,hc⟩ := sourceSection_factor q g + rw [hn,←kernelSourcePullback_comp,hF,map_smul,hc] + simp_rw [he] + rw [←Finset.smul_sum] + rw [Function.Bijective.sum_comp + (Group.mulRight_bijective (QuotientGroup.mk' levelThreeInTwo g)) + (fun q => kernelSourcePullback (rationalLift (sourceRationalSection q)) F)] + rw [smul_comm] + +lemma kernelSourceProjection_ae_eq (F : KernelQuotientL2) : + kernelSourceProjection F=ᵐ[integralQuotientVolume globalKubotaKernel] + fun x => (24:ℂ)⁻¹ * ∑q : levelTwo ⧸ levelThreeInTwo, + F (kernelSourceAction (rationalLift (sourceRationalSection q)) x) := by + rw [kernelSourceProjection_apply] + have hsum := (Lp.coeFn_finsetSum Finset.univ + (fun q : levelTwo ⧸ levelThreeInTwo => + kernelSourcePullback (rationalLift (sourceRationalSection q)) F)).trans + (eventuallyEq_sum (fun q _ => + kernelSourcePullback_ae_eq (rationalLift (sourceRationalSection q)) F)) + filter_upwards [(Lp.coeFn_smul (24:ℂ)⁻¹ _).trans (hsum.const_smul (24:ℂ)⁻¹)] with x hx + simpa only [Pi.smul_apply,Finset.sum_apply,smul_eq_mul] using hx + +lemma kernelSourceProjection_representative (F : KernelQuotientL2) + (f : SourceKernelQuotient→ℂ) + (hf : F=ᵐ[integralQuotientVolume globalKubotaKernel] f) : + kernelSourceProjection F=ᵐ[integralQuotientVolume globalKubotaKernel] + fun x => (24:ℂ)⁻¹ * ∑q : levelTwo ⧸ levelThreeInTwo, + f (kernelSourceAction (rationalLift (sourceRationalSection q)) x) := by + apply (kernelSourceProjection_ae_eq F).trans + have hh : (∑q : levelTwo ⧸ levelThreeInTwo, fun x => + F (kernelSourceAction (rationalLift (sourceRationalSection q)) x)) + =ᵐ[integralQuotientVolume globalKubotaKernel] + (∑q : levelTwo ⧸ levelThreeInTwo, fun x => + f (kernelSourceAction (rationalLift (sourceRationalSection q)) x)) := + eventuallyEq_sum (fun q _ => + (kernelSourceAction_measurePreserving (rationalLift (sourceRationalSection q))).quasiMeasurePreserving.ae_eq_comp hf) + filter_upwards [hh.const_smul (24:ℂ)⁻¹] with x hx + simpa only [Pi.smul_apply,Finset.sum_apply,smul_eq_mul] using hx + +lemma kernelSourceProjection_hyperbolic_average (f : SourceKernelQuotient→ℂ) (w : HyperbolicSpace) : + (24:ℂ)⁻¹ * ∑q : levelTwo ⧸ levelThreeInTwo, + f (kernelSourceAction (rationalLift (sourceRationalSection q)) + (integralOrbitProjection globalKubotaKernel w)) = + sourceProjection (f ∘ integralOrbitProjection globalKubotaKernel) w := rfl + +end CubicEisenstein +end + +open scoped Classical + +namespace CubicEisenstein +open CubicKubota + +lemma kernelSourceAction_level (n : levelThree) : + kernelSourceAction (sourceLevelInclusion n)=kernelLevelAction n := rfl + +lemma kernelSourcePullback_level (n : levelThree) : + kernelSourcePullback (sourceLevelInclusion n)=kernelLevelPullback n := rfl + +theorem kernelSourceProjection_covariance_of_level (F : KernelQuotientL2) + (hF : ∀n : levelThree,kernelLevelPullback n F=complexCharacter n • F) (g : levelTwo) : + kernelSourcePullback g (kernelSourceProjection F)= + levelTwoComplexCharacter g • kernelSourceProjection F := by + apply kernelSourceProjection_covariance F + intro n + rw [kernelSourcePullback_level] + exact hF n + +end CubicEisenstein + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ENNReal +open Finset AddChar MulChar EisensteinEmbedding + +namespace CubicEisenstein +open EisensteinSchwartzPoisson ActualEisensteinCubic ConcreteTraceCRT Module + +def periodVector : (Fin 2 → ℝ) ≃L[ℝ] ℂ := periodBasis.equivFunL.symm + +lemma periodVector_apply (x : Fin 2 → ℝ) : + periodVector x = 3 * ((x 0 : ℂ) + (x 1 : ℂ) * omega3) := by + change periodBasis.equivFun.symm x = _ + rw [Basis.equivFun_symm_apply, Fin.sum_univ_two, periodBasis_zero, periodBasis_one] + simp only [Complex.real_smul] + ring + +def periodTorus (z : ℂ) : UnitAddTorus (Fin 2) := + fun i => (periodBasis.equivFunL z i : UnitAddCircle) + +lemma periodTorus_periodVector (x : Fin 2 → ℝ) : + periodTorus (periodVector x) = fun i => (x i : UnitAddCircle) := by + change (fun i => ((periodBasis.equivFunL (periodBasis.equivFunL.symm x)) i : UnitAddCircle)) = _ + rw [periodBasis.equivFunL.apply_symm_apply] + +def periodFrequencyEquiv : (Fin 2 → ℤ) ≃ ActualEisensteinCubic.O := + (finTwoArrowEquiv ℤ).trans dualFrequencyEquiv + +lemma periodFrequencyEquiv_apply (n : Fin 2 → ℤ) : + periodFrequencyEquiv n = dualFrequencyEquiv (n 0, n 1) := rfl + +lemma periodVector_character (n : Fin 2 → ℤ) (x : Fin 2 → ℝ) : + ShortDraftTrace.breveE (cuspFrequency (periodFrequencyEquiv n) * periodVector x) = + Complex.exp (2 * Real.pi * Complex.I * + ((n 0 : ℂ) * (x 0 : ℂ) + (n 1 : ℂ) * (x 1 : ℂ))) := by + have hlam : eisLam ≠ 0 := by + exact eisLam_ne_zero + have harg : cuspFrequency (periodFrequencyEquiv n) * periodVector x = + (eisEmbedding (dualFrequencyEquiv (n 0,n 1)) * + ((x 0 : ℂ) + (x 1 : ℂ) * omega3)) / eisLam := by + rw [cuspFrequency, periodVector_apply, periodFrequencyEquiv_apply] + field_simp + rw [harg, ←paperE, paperE_eq_exp, dualFrequencyEquiv_coordinates] + have hs : Real.sqrt 3 ≠ 0 := ne_of_gt (Real.sqrt_pos.mpr (by norm_num)) + have hw : omega3.re = -(1/2:ℝ) := by norm_num [omega3] + congr 1 + simp only [complexPoint, Complex.mul_im, Complex.add_re, Complex.add_im, + Complex.ofReal_re, Complex.ofReal_im, Complex.mul_re, hw, omega3_im] + push_cast + field_simp + ring + +lemma periodTorus_mFourier (n : Fin 2 → ℤ) (z : ℂ) : + UnitAddTorus.mFourier n (periodTorus z) = + ShortDraftTrace.breveE (cuspFrequency (periodFrequencyEquiv n) * z) := by + obtain ⟨x, rfl⟩ := periodVector.surjective z + rw [periodTorus_periodVector, periodVector_character] + simp only [UnitAddTorus.mFourier, ContinuousMap.coe_mk, Fin.prod_univ_two, + fourier_coe_apply, Complex.ofReal_one, div_one] + rw [←Complex.exp_add] + congr 1 + ring + +lemma periodFrequencyEquiv_neg (n : Fin 2 → ℤ) : + periodFrequencyEquiv (-n) = -periodFrequencyEquiv n := by + apply eisEmbedding_injective + change eisEmbedding (ActualEisensteinCoordinates.eval (-n 0 + -n 1) (-n 0)) = + eisEmbedding (-ActualEisensteinCoordinates.eval (n 0 + n 1) (n 0)) + rw [map_neg, eisEmbedding_eval, eisEmbedding_eval] + push_cast + ring + +lemma cuspFrequency_neg (h : ActualEisensteinCubic.O) : cuspFrequency (-h) = -cuspFrequency h := by + simp only [cuspFrequency, map_neg, neg_div] + +lemma periodVector_eq_lattice (x : Fin 2 → ℝ) : + periodVector x = eisensteinLatticeMap 3 (by norm_num) (Complex.measurableEquivPi.symm x) := by + rw [periodVector_apply] + simp [eisensteinLatticeMap, Complex.measurableEquivPi_symm_apply, mul_comm] + +lemma periodVector_map_volume : + Measure.map periodVector volume = ENNReal.ofReal (2/(9*Real.sqrt 3)) • volume := by + have heq : (periodVector : (Fin 2 → ℝ) → ℂ) = + eisensteinLatticeMap 3 (by norm_num) ∘ Complex.measurableEquivPi.symm := + funext periodVector_eq_lattice + rw [heq, ←Measure.map_map (eisensteinLatticeMap 3 (by norm_num)).continuous.measurable + Complex.measurableEquivPi.symm.measurable, Complex.volume_preserving_equiv_pi.symm.map_eq] + have hmap := Measure.map_linearMap_addHaar_eq_smul_addHaar volume + (eisensteinLatticeMap 3 (by norm_num)).toLinearEquiv.isUnit_det'.ne_zero + change Measure.map (eisensteinLatticeMap 3 (by norm_num)) volume = + ENNReal.ofReal (inverseJacobian (eisensteinLatticeMap 3 (by norm_num))) • volume at hmap + rw [hmap, eisenstein_inverseJacobian] + norm_num [mul_comm] + +def periodCube : Set (Fin 2 → ℝ) := {x | ∀i, x i ∈ Set.Ico 0 1} + +lemma periodVector_preimage_domain : periodVector ⁻¹' periodDomain = periodCube := by + ext x + change (∀i, periodBasis.repr (periodBasis.equivFun.symm x) i ∈ Set.Ico 0 1) ↔ _ + simp only [←Basis.equivFun_apply, periodBasis.equivFun.apply_symm_apply] + rfl + +lemma periodDomain_integral_coordinates (f : ℂ → ℂ) : + (2/(9*Real.sqrt 3):ℝ) • (∫z in periodDomain, f z) = + ∫x in periodCube, f (periodVector x) := by + have h := periodVector.toHomeomorph.toMeasurableEquiv.measurableEmbedding.setIntegral_map + f periodDomain («μ» := (volume : Measure (Fin 2 → ℝ))) + change (∫z in periodDomain, f z ∂Measure.map periodVector volume) = + ∫x in periodVector ⁻¹' periodDomain, f (periodVector x) at h + rw [periodVector_map_volume, Measure.restrict_smul, integral_smul_measure, + ENNReal.toReal_ofReal (by positivity), periodVector_preimage_domain] at h + exact h + +local instance : MeasureSpace UnitAddCircle := ⟨AddCircle.haarAddCircle⟩ +local instance : Measure.IsAddHaarMeasure (volume : Measure UnitAddCircle) := + inferInstanceAs (Measure.IsAddHaarMeasure AddCircle.haarAddCircle) +local instance : IsProbabilityMeasure (volume : Measure UnitAddCircle) := + inferInstanceAs (IsProbabilityMeasure AddCircle.haarAddCircle) + +lemma periodCube_ae_Ioc : periodCube =ᵐ[volume] + {x : Fin 2 → ℝ | ∀i, x i ∈ Set.Ioc 0 1} := by + rw [volume_pi] + have h := Measure.ae_eq_set_pi («μ» := fun _ : Fin 2 => (volume : Measure ℝ)) + (I := Set.univ) (s := fun _ => Set.Ico (0:ℝ) 1) (t := fun _ => Set.Ioc (0:ℝ) 1) + (fun _ _ => Ico_ae_eq_Ioc) + simpa only [Set.pi, Set.mem_univ, forall_true_left, periodCube] using h + +lemma periodTorus_integral (f : UnitAddTorus (Fin 2) → ℂ) : + (∫t, f t) = (2/(9*Real.sqrt 3):ℝ) • (∫z in periodDomain, f (periodTorus z)) := by + rw [periodDomain_integral_coordinates, UnitAddTorus.integral_preimage f (fun _ => 0)] + simp only [zero_add, periodTorus_periodVector] + exact setIntegral_congr_set periodCube_ae_Ioc.symm + +lemma periodTorus_fourierCoeff (f : UnitAddTorus (Fin 2) → ℂ) (n : Fin 2 → ℤ) : + UnitAddTorus.mFourierCoeff f n = (2/(9*Real.sqrt 3):ℝ) • + (∫z in periodDomain, f (periodTorus z) * + ShortDraftTrace.breveE (-cuspFrequency (periodFrequencyEquiv n)*z)) := by + rw [UnitAddTorus.mFourierCoeff, periodTorus_integral] + congr 1 + apply integral_congr_ae + exact Eventually.of_forall (fun z => by + dsimp only + rw [periodTorus_mFourier, periodFrequencyEquiv_neg, cuspFrequency_neg] + exact mul_comm _ _) + +lemma periodTorus_L2_ext (F G : Lp ℂ 2 (volume : Measure (UnitAddTorus (Fin 2)))) + (h : ∀h : ActualEisensteinCubic.O, + (∫z in periodDomain, F (periodTorus z)*ShortDraftTrace.breveE (-cuspFrequency h*z)) = + ∫z in periodDomain, G (periodTorus z)*ShortDraftTrace.breveE (-cuspFrequency h*z)) : F=G := by + apply UnitAddTorus.mFourierBasis.repr.injective + ext n + rw [UnitAddTorus.mFourierBasis_repr, UnitAddTorus.mFourierBasis_repr, + periodTorus_fourierCoeff, periodTorus_fourierCoeff, h] + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/SquarefreeCoefficients.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SquarefreeCoefficients.lean new file mode 100644 index 0000000000000000000000000000000000000000..c824ead702d8d6ee82b1456d25c7d3847ea15c64 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/SquarefreeCoefficients.lean @@ -0,0 +1,612 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.PrimeGaussFactors + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss +local notation "Eis" => ActualEisensteinCubic.O + +lemma primaryGenerator_squarefree_support (I:Ideal Eis) (hI:primaryGenerator I≠0) + (hsq:Squarefree I) : primaryGenerator I=∏P∈primeSupport I,primaryPrime P := by + have hI0:=primaryGenerator_ne_zero_ideal I hI + have hn: (UniqueFactorizationMonoid.normalizedFactors I).Nodup:= + (UniqueFactorizationMonoid.squarefree_iff_nodup_normalizedFactors hI0).mp hsq + have hv:(primeSupport I).val=UniqueFactorizationMonoid.normalizedFactors I:=by + simpa only [primeSupport, Multiset.toFinset_val] using hn.dedup + unfold primaryGenerator + rw [ite_eq_right hI0] + change _=((primeSupport I).val.map primaryPrime).prod + rw [hv] + +lemma primaryPrime_isPrime_of_mem (I P:Ideal Eis) (hI:primaryGenerator I≠0) + (hP:P∈primeSupport I) : Prime (primaryPrime P) := by + have hp0:=primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP) + have hs:=primaryPrime_spec P hp0 + let:P.IsMaximal:=hs.1 + apply (Ideal.span_singleton_prime hp0).mp + rw [hs.2.2.1] + infer_instance + +lemma primaryPrime_support_coprime (I:Ideal Eis) (hI:primaryGenerator I≠0) + (P:Ideal Eis) (hP:P∈primeSupport I) (Q:Ideal Eis) (hQ:Q∈primeSupport I) (hne:P≠Q) : + IsCoprime (primaryPrime P) (primaryPrime Q) := by + have hp:=primaryPrime_spec P (primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP)) + have hq:=primaryPrime_spec Q (primaryPrime_factor_ne_zero I Q hI (Multiset.mem_toFinset.mp hQ)) + let:P.IsMaximal:=hp.1 + let:Q.IsMaximal:=hq.1 + apply (Ideal.isCoprime_span_singleton_iff _ _).mp + rw [hp.2.2.1,hq.2.2.1] + exact Ideal.isCoprime_of_isMaximal hne + +def infinityCoefficientScalar : ℂ := star (sourceResidualFourierCoefficient 1) + +theorem infinityCoefficient_squarefree (I:Ideal Eis) (hI:primaryGenerator I≠0) + (hsq:Squarefree I) : + star (sourceResidualFourierCoefficient (primaryGenerator I))= + infinityCoefficientScalar* + star (eisEmbedding (symbol ramifiedTraceLambda (primaryGenerator I)))*gaussTwo I hI := by + have hpr:∀P∈primeSupport I,lambda^2∣primaryPrime P-1:=by + intro P hP + exact (primaryPrime_spec P (primaryPrime_factor_ne_zero I P hI (Multiset.mem_toFinset.mp hP))).2.2.2 + have he:=sourceResidualFourierCoefficient_primary_product (primeSupport I) primaryPrime + (fun P hP=>primaryPrime_isPrime_of_mem I P hI hP) hpr + (primaryPrime_support_coprime I hI) + rw [←primaryGenerator_squarefree_support I hI hsq,normalizedCubicUnitGauss_eq_gaussTwo I hI hsq] at he + exact he + +theorem infinityCoefficient_squarefree_cube (I J:Ideal Eis) + (hI:primaryGenerator I≠0) (hJ:primaryGenerator J≠0) (hsq:Squarefree I) : + star (sourceResidualFourierCoefficient (primaryGenerator I*(primaryGenerator J)^3))= + infinityCoefficientScalar*(‖eisEmbedding (primaryGenerator J)‖:ℂ)* + star (eisEmbedding (symbol ramifiedTraceLambda (primaryGenerator I)))*gaussTwo I hI := by + rw [sourceResidualFourierCoefficient_primary_cube _ hJ (primaryGenerator_spec J hJ).2 _ hI, + star_mul,infinityCoefficient_squarefree I hI hsq] + simp only [Complex.star_def,Complex.conj_ofReal] + ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal CompletedGauss UniqueFactorizationMonoid +local notation "Eis" => ActualEisensteinCubic.O + +theorem sourceArithmeticResidue_valuation_ne_two (I P:Ideal Eis) + (hI:primaryGenerator I≠0) (hP:P∈normalizedFactors I) + (hS:sourceArithmeticResidue (primaryGenerator I)≠0) : + (normalizedFactors I).count P%3≠2 := by + have hI0:=primaryGenerator_ne_zero_ideal I hI + have hprime:=prime_of_normalized_factor P hP + let p:=primaryPrime P + have hp0:p≠0:=primaryPrime_factor_ne_zero I P hI hP + have hps:=primaryPrime_spec P hp0 + have hp:Prime p:=primaryPrime_isPrime_of_mem I P hI (Multiset.mem_toFinset.mpr hP) + obtain ⟨J,hJ,hnot⟩:=(FiniteMultiplicity.of_prime_left hprime hI0).exists_eq_pow_mul_and_not_dvd + have hgen:primaryGenerator I=p^(multiplicity P I)*primaryGenerator J:=by + calc + _=primaryGenerator (P^(multiplicity P I)*J):=congrArg primaryGenerator hJ + _=p^(multiplicity P I)*primaryGenerator J:=by + rw [primaryGenerator_mul,primaryGenerator_pow] + have he:primaryGenerator P=p:=by + rw [←hps.2.2.1,primaryGenerator_span p hp0 hps.2.2.2] + rw [he] + have hgJ:primaryGenerator J≠0:=by + intro hz + exact hI (by rw [hgen,hz,mul_zero]) + have hpd:¬p∣primaryGenerator J:=by + intro hd + apply hnot + rw [Ideal.dvd_iff_le,←hps.2.2.1,←(primaryGenerator_spec J hgJ).1, + Ideal.span_singleton_le_span_singleton] + exact hd + have hcount:=multiplicity_eq_count_normalizedFactors hprime.irreducible hI0 + rw [normalize_normalized_factor P hP] at hcount + intro hc + have hm:(multiplicity P I)%3=2:=by rwa [hcount] + apply hS + rw [hgen,mul_comm,sourceArithmeticResidue_prime_power_table p hp hps.2.2.2 _ hpd, + hm] + norm_num + +def thetaSquarefreePart (I:Ideal Eis) : Ideal Eis := + ∏P∈(primeSupport I).filter (fun P=>(normalizedFactors I).count P%3=1),P + +def thetaCubePart (I:Ideal Eis) : Ideal Eis := + ∏P∈primeSupport I,P^((normalizedFactors I).count P/3) + +lemma thetaSquarefreePart_squarefree (I:Ideal Eis) : Squarefree (thetaSquarefreePart I) := by + apply IdealMobiusDivisorSum.squarefree_support_product + exact Finset.filter_subset _ _ + +lemma thetaParts_mul_cube (I:Ideal Eis) (hI:I≠0) + (he:∀P∈normalizedFactors I,(normalizedFactors I).count P%3≠2) : + thetaSquarefreePart I*thetaCubePart I^3=I := by + rw [thetaSquarefreePart,Finset.prod_filter,thetaCubePart,←Finset.prod_pow,←Finset.prod_mul_distrib] + calc + _=∏P∈primeSupport I,P^((normalizedFactors I).count P):=by + apply Finset.prod_congr rfl + intro P hP + have hp:=he P (Multiset.mem_toFinset.mp hP) + have hm:(normalizedFactors I).count P%3=0 ∨ (normalizedFactors I).count P%3=1:=by omega + rcases hm with hm|hm + · rw [ite_eq_right (by omega),one_mul,←pow_mul] + congr 1 + omega + · rw [ite_eq_left hm,←pow_mul,←pow_succ'] + congr 1 + omega + _=(normalizedFactors I).prod:=(Finset.prod_multiset_count (normalizedFactors I)).symm + _=I:=Ideal.prod_normalizedFactors_eq_self hI + +theorem sourceArithmeticResidue_squarefree_cube_support (I:Ideal Eis) + (hI:primaryGenerator I≠0) (hS:sourceArithmeticResidue (primaryGenerator I)≠0) : + Squarefree (thetaSquarefreePart I) ∧ + primaryGenerator (thetaSquarefreePart I)≠0 ∧ + primaryGenerator (thetaCubePart I)≠0 ∧ + thetaSquarefreePart I*thetaCubePart I^3=I := by + have he:=thetaParts_mul_cube I (primaryGenerator_ne_zero_ideal I hI) + (fun P hP=>sourceArithmeticResidue_valuation_ne_two I P hI hP hS) + have hgen:primaryGenerator I= + primaryGenerator (thetaSquarefreePart I)*(primaryGenerator (thetaCubePart I))^3:=by + calc + _=primaryGenerator (thetaSquarefreePart I*thetaCubePart I^3):=congrArg primaryGenerator he.symm + _=_:=by rw [primaryGenerator_mul,primaryGenerator_pow] + have hA:primaryGenerator (thetaSquarefreePart I)≠0:=by + intro hz + exact hI (by rw [hgen,hz,zero_mul]) + have hB:primaryGenerator (thetaCubePart I)≠0:=by + intro hz + exact hI (by rw [hgen,hz,zero_pow (by decide : (3:ℕ)≠0),mul_zero]) + exact ⟨thetaSquarefreePart_squarefree I,hA,hB,he⟩ + +theorem sourceFourier_squarefree_cube_support (I:Ideal Eis) + (hI:primaryGenerator I≠0) (hS:sourceResidualFourierCoefficient (primaryGenerator I)≠0) : + ∃A B:Ideal Eis,Squarefree A ∧ primaryGenerator A≠0 ∧ primaryGenerator B≠0 ∧ A*B^3=I := by + have hs:sourceArithmeticResidue (primaryGenerator I)≠0:=by + intro hz + exact hS (by rw [sourceResidualFourierCoefficient,hz,mul_zero]) + exact ⟨thetaSquarefreePart I,thetaCubePart I, + sourceArithmeticResidue_squarefree_cube_support I hI hs⟩ + +theorem sourceFourier_primary_zero_of_base_zero (hC:infinityCoefficientScalar=0) + (n:Eis) (hprimary:lambda^2∣n-1) : sourceResidualFourierCoefficient n=0 := by + have hn:n≠0:=primary_ne_zero n hprimary + let I:Ideal Eis:=Ideal.span {n} + have hgen:primaryGenerator I=n:=primaryGenerator_span n hn hprimary + have hI:primaryGenerator I≠0:=by rwa [hgen] + by_contra hT + have hTI:sourceResidualFourierCoefficient (primaryGenerator I)≠0:=by rwa [hgen] + obtain ⟨A,B,hA,hAg,hBg,hAB⟩:=sourceFourier_squarefree_cube_support I hI hTI + have harg:primaryGenerator A*(primaryGenerator B)^3=n:=by + have he:=congrArg primaryGenerator hAB + simpa only [primaryGenerator_mul,primaryGenerator_pow,hgen] using he + have he:=infinityCoefficient_squarefree_cube A B hAg hBg hA + rw [harg,hC,zero_mul,zero_mul,zero_mul] at he + exact hT (star_eq_zero.mp he) + +end + +section +open Filter +open scoped BigOperators Classical Topology + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +lemma unramifiedGaussResidue_eq_of_initial_eq (h k:Eis) + (he:∀s:ℂ,41) (fun _=>0) + (fun _ _=>analyticAt_const) (fun _ _=>analyticAt_const) + continuousAt_const continuousAt_const (fun s hs hi=>by simpa using he s hs hi) + simpa only [one_mul,zero_mul,add_zero] using hh + +theorem unramifiedGaussResidue_neg (h:Eis) : + unramifiedGaussResidue (-h)=unramifiedGaussResidue h := + unramifiedGaussResidue_eq_of_initial_eq _ _ (fun s _ _=>unramifiedCubicGaussSeries_neg s h) + +theorem unramifiedGaussResidue_lambda_pow (h:Eis) (n:ℕ) : + unramifiedGaussResidue (h*lambda^n)= + unramifiedGaussResidue (h*lambda^(n%3)) := + unramifiedGaussResidue_eq_of_initial_eq _ _ (fun s _ _=>unramifiedCubicGaussSeries_lambda_pow s h n) + +theorem unramifiedGaussResidue_lambda_cube (h:Eis) : + unramifiedGaussResidue (h*lambda^3)=unramifiedGaussResidue h := by + simpa using unramifiedGaussResidue_lambda_pow h 3 + +theorem unramifiedGaussResidue_nine_family (h:Eis) (u:Eisˣ) (n:ℕ) : + ∃j k:Fin 3,unramifiedGaussResidue (h*(9*((u:Eis)*lambda^n)))= + unramifiedGaussResidue (h*omega^j.val*lambda^k.val) := by + obtain ⟨j,k,hjk⟩:=unramifiedCubicGaussSeries_nine_family h u n + exact ⟨j,k,unramifiedGaussResidue_eq_of_initial_eq _ _ (fun s _ _=>hjk s)⟩ + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def ramifiedResidueFamilyMass (h:Eis) : ℝ := + ∑a:Fin 3×Fin 3,‖unramifiedGaussResidue (h*omega^a.1.val*lambda^a.2.val)‖ + +lemma ramifiedResidueFamilyMass_nonneg (h:Eis) : 0≤ramifiedResidueFamilyMass h := + Finset.sum_nonneg (fun _ _=>norm_nonneg _) + +lemma unramifiedGaussResidue_family_norm_le (h:Eis) (j k:Fin 3) : + ‖unramifiedGaussResidue (h*omega^j.val*lambda^k.val)‖≤ramifiedResidueFamilyMass h := by + unfold ramifiedResidueFamilyMass + exact Finset.single_le_sum (a:=(j,k)) (s:=Finset.univ) + (f:=fun a:Fin 3×Fin 3=>‖unramifiedGaussResidue (h*omega^a.1.val*lambda^a.2.val)‖) + (fun _ _=>norm_nonneg _) (Finset.mem_univ (j,k)) + +lemma unramifiedGaussResidue_nine_norm_le (h:Eis) (u:Eisˣ) (n:ℕ) : + ‖unramifiedGaussResidue (h*(9*((u:Eis)*lambda^n)))‖≤ramifiedResidueFamilyMass h := by + obtain ⟨j,k,hjk⟩:=unramifiedGaussResidue_nine_family h u n + rw [hjk] + exact unramifiedGaussResidue_family_norm_le h j k + +theorem unramifiedGaussResidue_unit_lambda_family (u:Eisˣ) (n:ℕ) : + ∃j k:Fin 3,unramifiedGaussResidue ((u:Eis)*lambda^n)= + unramifiedGaussResidue (omega^j.val*lambda^k.val) := by + obtain ⟨j,hj⟩:=unit_eq_sign_omega u + refine ⟨j,⟨n%3,Nat.mod_lt _ (by decide)⟩,?_⟩ + rcases hj with hj|hj + · rw [hj,unramifiedGaussResidue_lambda_pow] + · rw [hj,neg_mul,unramifiedGaussResidue_neg,unramifiedGaussResidue_lambda_pow] + +lemma unramifiedGaussResidue_unit_lambda_norm_le (u:Eisˣ) (n:ℕ) : + ‖unramifiedGaussResidue ((u:Eis)*lambda^n)‖≤ramifiedResidueFamilyMass 1 := by + obtain ⟨j,k,hjk⟩:=unramifiedGaussResidue_unit_lambda_family u n + rw [hjk] + simpa only [one_mul] using unramifiedGaussResidue_family_norm_le 1 j k + +lemma ramifiedResidueFamilyMass_unit_lambda_le (u:Eisˣ) (n:ℕ) : + ramifiedResidueFamilyMass ((u:Eis)*lambda^n)≤9*ramifiedResidueFamilyMass 1 := by + calc + _≤∑a:Fin 3×Fin 3,ramifiedResidueFamilyMass 1:=by + apply Finset.sum_le_sum + intro a ha + let v:Eisˣ:=u*ramifiedOmegaUnit^a.1.val + have he:((u:Eis)*lambda^n)*omega^a.1.val*lambda^a.2.val= + (v:Eis)*lambda^(n+a.2.val):=by + simp only [v,Units.val_mul,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val,pow_add] + ring + rw [he] + exact unramifiedGaussResidue_unit_lambda_norm_le v _ + _=_:=by simp + +theorem sourceArithmeticResidue_family_bound (h:Eis) (hh:h≠0) : + ‖sourceArithmeticResidue h‖≤ + ((∑i:PrincipalRamifiedIndex h,‖principalRamifiedWeight h i (4/3)‖)+3)* + ramifiedResidueFamilyMass h/(4*(9*Real.sqrt 3/2)) := by + have hM:=ramifiedResidueFamilyMass_nonneg h + have hden:0<4*(9*Real.sqrt 3/2):=by positivity + rw [sourceArithmeticResidue_eq_ramified_table h hh] + split_ifs with hphase + · rw [norm_div,norm_mul,Complex.norm_ofNat,Complex.norm_real,Real.norm_eq_abs, + abs_of_pos (show 0<(9*Real.sqrt 3/2:ℝ) by positivity)] + apply div_le_div_of_nonneg_right _ hden.le + calc + _≤‖∑i:PrincipalRamifiedIndex h,principalRamifiedWeight h i (4/3)* + unramifiedGaussResidue (principalRamifiedIndex h i)‖+ + ‖(3:ℂ)*unramifiedGaussResidue (9*h)‖:=norm_add_le _ _ + _≤(∑i:PrincipalRamifiedIndex h,‖principalRamifiedWeight h i (4/3)‖)* + ramifiedResidueFamilyMass h+3*ramifiedResidueFamilyMass h:=by + apply add_le_add + · calc + _≤∑i:PrincipalRamifiedIndex h,‖principalRamifiedWeight h i (4/3)* + unramifiedGaussResidue (principalRamifiedIndex h i)‖:=norm_sum_le _ _ + _≤∑i:PrincipalRamifiedIndex h,‖principalRamifiedWeight h i (4/3)‖* + ramifiedResidueFamilyMass h:=by + apply Finset.sum_le_sum + intro i hi + rw [norm_mul] + exact mul_le_mul_of_nonneg_left + (unramifiedGaussResidue_nine_norm_le h i.1 (i.2.val+2)) (norm_nonneg _) + _=_:=by rw [Finset.sum_mul] + · rw [norm_mul,Complex.norm_ofNat] + have hb:=unramifiedGaussResidue_nine_norm_le h (1:Eisˣ) 0 + simp only [Units.val_one,pow_zero,mul_one] at hb + simpa only [mul_comm 9 h] using mul_le_mul_of_nonneg_left hb (by norm_num : (0:ℝ)≤3) + _=_:=by ring + · rw [norm_zero] + positivity + +end + +section +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def ramifiedDecayRatio : ℝ := (3:ℝ)^(-(1/3:ℝ)) + +lemma ramifiedDecayRatio_pos : 0 simp [residueAdditive,breveE_norm] + · simp + +lemma ramifiedWeight_norm_scalar (n:ℕ) : + ‖((3^n:ℕ):ℂ)^(-(4/3:ℂ))‖*(3^n:ℕ)=ramifiedDecayRatio^n := by + have ha:0<(3:ℝ)^n:=pow_pos (by norm_num) _ + have hn:‖((3:ℂ)^n)^(-(4/3:ℂ))‖=((3:ℝ)^n)^(-(4/3:ℝ)):=by + have he:=Complex.norm_cpow_eq_rpow_re_of_pos ha (-(4/3:ℂ)) + have hre:(-(4/3:ℂ)).re=-(4/3:ℝ):=by norm_num + rw [hre] at he + simpa only [Complex.ofReal_pow,Complex.ofReal_ofNat] using he + simp only [Nat.cast_pow,Nat.cast_ofNat] + rw [hn] + calc + ((3:ℝ)^n)^(-(4/3:ℝ))*(3:ℝ)^n= + ((3:ℝ)^n)^(-(4/3:ℝ))*((3:ℝ)^n)^(1:ℝ):=by rw [Real.rpow_one] + _=((3:ℝ)^n)^(-(1/3:ℝ)):=by + rw [←Real.rpow_add ha] + congr 1 + norm_num + _=(3:ℝ)^((n:ℝ)*(-(1/3:ℝ))):=(Real.rpow_natCast_mul (by norm_num) n _).symm + _=(3:ℝ)^((-(1/3:ℝ))*(n:ℝ)):=by rw [mul_comm] + _=ramifiedDecayRatio^n:=by + rw [Real.rpow_mul (by norm_num),Real.rpow_natCast] + rfl + +lemma principalRamifiedWeight_norm_le (h:Eis) (i:PrincipalRamifiedIndex h) : + ‖principalRamifiedWeight h i (4/3)‖≤ramifiedDecayRatio^(i.2.val+2) := by + unfold principalRamifiedWeight + rw [norm_mul] + calc + _≤‖((3^(i.2.val+2):ℕ):ℂ)^(-(4/3:ℂ))‖*(3^(i.2.val+2):ℕ):= + mul_le_mul_of_nonneg_left (explicitRamifiedCoefficient_norm_le h i.1 _) (norm_nonneg _) + _=_:=ramifiedWeight_norm_scalar _ + +theorem principalRamifiedWeight_sum_norm_le (h:Eis) : + (∑i:PrincipalRamifiedIndex h,‖principalRamifiedWeight h i (4/3)‖)≤ + 6*ramifiedDecayRatio^2/(1-ramifiedDecayRatio) := by + have ht0:=ramifiedDecayRatio_pos.le + have ht1:=ramifiedDecayRatio_lt_one + have hfin:(∑n:Fin (ramifiedFrequencyBound h+1),ramifiedDecayRatio^(n.val+2))≤ + ramifiedDecayRatio^2/(1-ramifiedDecayRatio):=by + rw [Fin.sum_univ_eq_sum_range (fun n:ℕ=>ramifiedDecayRatio^(n+2))] + simp_rw [pow_add,mul_comm _ (ramifiedDecayRatio^2)] + rw [←Finset.mul_sum] + have hs: (∑n∈Finset.range (ramifiedFrequencyBound h+1),ramifiedDecayRatio^n)≤ + (1-ramifiedDecayRatio)⁻¹:=by + rw [←tsum_geometric_of_lt_one ht0 ht1] + exact (summable_geometric_of_lt_one ht0 ht1).sum_le_tsum _ (fun n _=>pow_nonneg ht0 n) + simpa only [div_eq_mul_inv] using mul_le_mul_of_nonneg_left hs (sq_nonneg ramifiedDecayRatio) + calc + _≤∑i:PrincipalRamifiedIndex h,ramifiedDecayRatio^(i.2.val+2):= + Finset.sum_le_sum (fun i _=>principalRamifiedWeight_norm_le h i) + _=(6:ℝ)*(∑n:Fin (ramifiedFrequencyBound h+1),ramifiedDecayRatio^(n.val+2)):=by + rw [Fintype.sum_prod_type] + simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] + have hc:Fintype.card Eisˣ=6:=by + simpa only [Nat.card_eq_fintype_card] using PrimaryIdealUnitReindex.card_units_eq_six + rw [hc] + norm_num + _≤6*(ramifiedDecayRatio^2/(1-ramifiedDecayRatio)):=mul_le_mul_of_nonneg_left hfin (by norm_num) + _=_:=by ring + +end + +open ActualEisensteinCubic ConcreteTraceCRT CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O +local instance : Fintype Eisˣ := @Fintype.ofFinite _ PrimaryIdealUnitReindex.finite_units + +def ramifiedSourceFamilyConstant : ℝ := + (6*ramifiedDecayRatio^2/(1-ramifiedDecayRatio)+3)/(4*(9*Real.sqrt 3/2)) + +lemma ramifiedSourceFamilyConstant_nonneg : 0≤ramifiedSourceFamilyConstant := by + have ht:0<1-ramifiedDecayRatio:=sub_pos.mpr ramifiedDecayRatio_lt_one + unfold ramifiedSourceFamilyConstant + positivity + +theorem sourceArithmeticResidue_nine_family_bound (h:Eis) (hh:h≠0) : + ‖sourceArithmeticResidue h‖≤ramifiedSourceFamilyConstant*ramifiedResidueFamilyMass h := by + have hm:=ramifiedResidueFamilyMass_nonneg h + refine (sourceArithmeticResidue_family_bound h hh).trans ?_ + have hw:(∑i:PrincipalRamifiedIndex h,‖principalRamifiedWeight h i (4/3)‖)+3≤ + 6*ramifiedDecayRatio^2/(1-ramifiedDecayRatio)+3:=by + linarith [principalRamifiedWeight_sum_norm_le h] + calc + _≤(6*ramifiedDecayRatio^2/(1-ramifiedDecayRatio)+3)* + ramifiedResidueFamilyMass h/(4*(9*Real.sqrt 3/2)):= + div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_right hw hm) (by positivity) + _=ramifiedSourceFamilyConstant*ramifiedResidueFamilyMass h:=by + unfold ramifiedSourceFamilyConstant + ring + +theorem sourceArithmeticResidue_unit_lambda_bound (u:Eisˣ) (n:ℕ) : + ‖sourceArithmeticResidue ((u:Eis)*lambda^n)‖≤ + 9*ramifiedSourceFamilyConstant*ramifiedResidueFamilyMass 1 := by + refine (sourceArithmeticResidue_nine_family_bound _ (ramifiedElement_ne_zero u n)).trans ?_ + have he:=mul_le_mul_of_nonneg_left (ramifiedResidueFamilyMass_unit_lambda_le u n) + ramifiedSourceFamilyConstant_nonneg + convert he using 1 ; ring + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +open ActualEisensteinCubic ConcreteTraceCRT CubicKubota CubicJacobiGlobal +local notation "Eis" => ActualEisensteinCubic.O + +def extraPeriodWitness : levelThree := by + let M:SL(2,Eis):=⟨!![1+3*omega,3*omega^2;-3,1-3*omega],by + rw [Matrix.det_fin_two_of] + ring⟩ + refine ⟨M,levelThree_of_entries M ?_⟩ + intro i j + fin_cases i <;> fin_cases j + · exact ⟨omega,by change 1+3*omega-1=3*omega;ring⟩ + · exact ⟨omega^2,by change 3*omega^2-0=3*omega^2;ring⟩ + · exact ⟨-1,by change -3-(0:Eis)=3*(-1);ring⟩ + · exact ⟨-omega,by change 1-3*omega-1=3*(-omega);ring⟩ + +def rationalLowerMinusThree : SL(2,ℤ):=⟨!![1,0;-3,1],by simp [Matrix.det_fin_two]⟩ + +lemma extraPeriodWitness_factor : + integralComplexMatrix (extraPeriodWitness:SL(2,Eis))= + complexTranslation (-eisEmbedding omega)* + integralComplexMatrix (rationalEmbedding rationalLowerMinusThree)* + complexTranslation (eisEmbedding omega) := by + apply Subtype.ext + simp only [Matrix.SpecialLinearGroup.coe_mul] + apply Matrix.ext + intro i j + simp only [Matrix.mul_apply, Fin.sum_univ_two, integralComplexMatrix_apply, + rationalEmbedding, Matrix.SpecialLinearGroup.map_apply_coe] + fin_cases i <;> fin_cases j <;> + simp [extraPeriodWitness, rationalLowerMinusThree, complexTranslation, map_ofNat] <;> ring + +lemma extraPeriodWitness_character : complexCharacter extraPeriodWitness=eisEmbedding omega := by + change eisEmbedding (symbol (-3) (1+3*omega))=eisEmbedding omega + apply congrArg eisEmbedding + have hp:lambda^2∣(1+3*omega)-1:=lambda_sq_dvd_three.trans ⟨omega,by ring⟩ + rw [symbol_neg_numerator _ _ hp] + have he:=ramified_symbol_at_omega (-(ramifiedOmegaUnit^2)) 2 2 + (Or.inr (by simp only [Units.val_neg,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val])) + have hl:lambda^2=-3*omega:=by + change (omega-1)^2=-3*omega + linear_combination ramified_omega_relation + have hnum:((-(ramifiedOmegaUnit^2):Eisˣ):Eis)*lambda^2=3:=by + simp only [Units.val_neg,Units.val_pow_eq_pow_val,ramifiedOmegaUnit_val] + rw [hl] + calc + _=3*omega^3:=by ring + _=3:=by rw [omega_primitive.pow_eq_one];ring + rw [hnum] at he + have hw:omega^(2*2)=omega:=by + norm_num only [Nat.reduceMul] + calc + omega^4=omega^3*omega:=by ring + _=omega:=by rw [omega_primitive.pow_eq_one,one_mul] + exact he.trans hw + +lemma extraPeriodWitness_character_ne_one : complexCharacter extraPeriodWitness≠1 := by + rw [extraPeriodWitness_character] + intro he + exact omega_primitive.ne_one (by decide) (eisEmbedding_injective (by simpa only [map_one] using he)) + +theorem cubicSource_not_eisenstein_periodic : + ¬(∀a:Eis,∀w:HyperbolicSpace, + cubicSourceResidualFunction (complexTranslation (eisEmbedding a) • w)= + cubicSourceResidualFunction w) := by + intro hperiod + apply cubicSourceResidualFunction_ne_zero + funext w + have hneg (u:HyperbolicSpace): + cubicSourceResidualFunction (complexTranslation (-eisEmbedding omega) • u)= + cubicSourceResidualFunction u:=by + simpa only [map_neg] using hperiod (-omega) u + have hinv:cubicSourceResidualFunction + (integralComplexMatrix (extraPeriodWitness:SL(2,Eis)) • w)=cubicSourceResidualFunction w:=by + rw [extraPeriodWitness_factor,mul_smul,mul_smul,hneg, + cubicSourceResidualFunction_rational_invariant,hperiod] + have hchar:=cubicSourceResidualFunction_automorphy (sourceLevelInclusion extraPeriodWitness) w + change cubicSourceResidualFunction (integralComplexMatrix (extraPeriodWitness:SL(2,Eis)) • w)= + levelTwoComplexCharacter ⟨(extraPeriodWitness:SL(2,Eis)),levelThree_le_levelTwo extraPeriodWitness.property⟩* + cubicSourceResidualFunction w at hchar + rw [levelTwoComplexCharacter_restrict] at hchar + change cubicSourceResidualFunction (integralComplexMatrix (extraPeriodWitness:SL(2,Eis)) • w)= + complexCharacter extraPeriodWitness*cubicSourceResidualFunction w at hchar + rw [hinv] at hchar + have hz:(complexCharacter extraPeriodWitness-1)*cubicSourceResidualFunction w=0:=by + linear_combination -hchar + exact (mul_eq_zero.mp hz).resolve_left (sub_ne_zero.mpr extraPeriodWitness_character_ne_one) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/TranslatedFourierResidues.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/TranslatedFourierResidues.lean new file mode 100644 index 0000000000000000000000000000000000000000..5fd10c4a726e984c0b30d31bc5118c5ec885fa6c --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/TranslatedFourierResidues.lean @@ -0,0 +1,604 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.CuspAverage + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology MatrixGroups + +section +open CubicKubota ActualEisensteinCubic ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma period_integral_fourier_translation (f:ℂ→ℂ) + (hp:∀(n:Eis)(z:ℂ),f (z+3*eisEmbedding n)=f z) (h:Eis) (b:ℂ) : + (∫z in periodDomain,f (z+b)*ShortDraftTrace.breveE (-cuspFrequency h*z))= + ShortDraftTrace.breveE (cuspFrequency h*b)* + ∫z in periodDomain,f z*ShortDraftTrace.breveE (-cuspFrequency h*z) := by + let g : ℂ→ℂ := fun z=>f z*ShortDraftTrace.breveE (-cuspFrequency h*z) + have hg : ∀(n:Eis)(z:ℂ),g (z+3*eisEmbedding n)=g z := by + intro n z + dsimp only [g] + rw [hp,cuspFrequency_negative_period] + have he (z:ℂ) : f (z+b)*ShortDraftTrace.breveE (-cuspFrequency h*z)= + ShortDraftTrace.breveE (cuspFrequency h*b)*g (b+z) := by + dsimp only [g] + rw [mul_left_comm,←AddChar.map_add_eq_mul] + congr 1 + · rw [add_comm] + · congr 1 + ring + simp_rw [he] + rw [integral_const_mul,period_integral_translation g hg b] + +theorem rational_cusp_fourier_right_T (r:SL(2,ℤ)) (n:ℕ) (h:Eis) (s:ℂ) (hs:2hyperbolicEisenstein s + (rationalComplex (r*ModularGroup.T^n) • w)*cuspFourierPhase h w + let g : HyperbolicSpace→ℂ := fun w=>hyperbolicEisenstein s + (rationalComplex r • w)*cuspFourierPhase h w + have hf : Continuous f := ((hyperbolicEisenstein_continuous s hs).comp + (continuous_hyperbolic_action _)).mul (cuspFourierPhase_continuous h) + have hg : Continuous g := ((hyperbolicEisenstein_continuous s hs).comp + (continuous_hyperbolic_action _)).mul (cuspFourierPhase_continuous h) + change (∫w in cuspPeriodStrip 5 6,f w∂hyperbolicVolume)= + ShortDraftTrace.breveE (cuspFrequency h*(n:ℂ))*∫w in cuspPeriodStrip 5 6,g w∂hyperbolicVolume + rw [cuspPeriodStrip_integral_coordinates f hf.aestronglyMeasurable (cuspCoordinateLift_weighted_integrable f hf), + cuspPeriodStrip_integral_coordinates g hg.aestronglyMeasurable (cuspCoordinateLift_weighted_integrable g hg), + ←integral_const_mul] + apply setIntegral_congr_fun measurableSet_Icc + intro v hv + have hv0 : 0hyperbolicEisenstein s (rationalComplex r • upperPoint z v hv0)) + (fun a z=>hyperbolicEisenstein_rational_periodic r a s hs z v hv0) h (n:ℂ)] + ring + +lemma translatedCuspFourier_residue_scaled_of_initial (h:Eis) (M N:levelTwo) (c:ℂ) + (he : ∀s:ℂ,4c*translatedCuspFamily h N 2 3 (by norm_num) (by norm_num) s + let domain : Set ℂ := {s | 1 + translatedCuspFamily_analyticAt_nonreal h M 2 3 (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne' + have hg : AnalyticOnNhd ℂ g domain := fun s hs=>analyticAt_const.mul + (translatedCuspFamily_analyticAt_nonreal h N 2 3 (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne') + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s:ℂ | 4kernelCuspFourier h cubicEisensteinResidue + | Sum.inr ab=>ShortDraftTrace.breveE (cuspFrequency h*(ab.2.val:ℂ))* + translatedCuspFourier h oppositeSource cubicEisensteinResidue := by + cases a with + | inl a => + rw [←one_mul (kernelCuspFourier h cubicEisensteinResidue),←translatedCuspFourier_one h] + apply translatedCuspFourier_residue_scaled_of_initial + intro s hs hi + simp_rw [sourceComplexMatrix_rationalLift,hyperbolicEisenstein_bruhat] + simp only [map_one,one_smul,one_mul] + | inr ab => + apply translatedCuspFourier_residue_scaled_of_initial + intro s hs hi + simp_rw [sourceComplexMatrix_rationalLift,hyperbolicEisenstein_bruhat] + change (∫w in cuspPeriodStrip 5 6, + hyperbolicEisenstein s (rationalComplex ModularGroup.S • + (rationalComplex (ModularGroup.T^ab.2.val) • w))*cuspFourierPhase h w∂hyperbolicVolume)= + ShortDraftTrace.breveE (cuspFrequency h*(ab.2.val:ℂ))* + ∫w in cuspPeriodStrip 5 6,hyperbolicEisenstein s (rationalComplex ModularGroup.S • w)* + cuspFourierPhase h w∂hyperbolicVolume + simpa only [map_mul,mul_smul] using + rational_cusp_fourier_right_T ModularGroup.S ab.2.val h s (by linarith) + +def sourceRayPhaseSum (h:Eis) : ℂ := + ∑ b:Fin 3,ShortDraftTrace.breveE (cuspFrequency h*(b.val:ℂ)) + +theorem kernelSourceProjection_residue_fourier (h:Eis) : + kernelCuspFourier h (kernelSourceProjection cubicEisensteinResidue)= + (4:ℂ)⁻¹*(kernelCuspFourier h cubicEisensteinResidue+ + sourceRayPhaseSum h*translatedCuspFourier h oppositeSource cubicEisensteinResidue) := by + rw [kernelSourceProjection_eq_twentyFour,map_smul,map_sum] + change (24:ℂ)⁻¹*(∑i:RationalBruhatIndex, + translatedCuspFourier h (rationalLift (rationalBruhatRep i)) cubicEisensteinResidue)=_ + rw [Fintype.sum_prod_type] + simp_rw [translatedCuspFourier_bruhat] + simp only [Fintype.sum_sum_type,Fintype.sum_prod_type,Finset.sum_const,Finset.card_univ, + Fintype.card_fin,nsmul_eq_mul] + rw [←Finset.sum_mul] + change (24:ℂ)⁻¹*((2:ℂ)*(3*kernelCuspFourier h cubicEisensteinResidue+ + 3*(sourceRayPhaseSum h*translatedCuspFourier h oppositeSource cubicEisensteinResidue)))=_ + ring + +end + +section +open CubicKubota ConcreteTraceCRT +local notation "Eis" => ActualEisensteinCubic.O + +lemma sourceRayPhase_cube (h:Eis) : + ShortDraftTrace.breveE (cuspFrequency h)^3=1 := by + rw [←AddChar.map_nsmul_eq_pow,nsmul_eq_mul] + have hp:=cuspFrequency_period h (1:Eis) + simpa only [map_one,mul_one,one_mul,Nat.cast_ofNat,mul_comm] using hp + +lemma sourceRayPhaseSum_formula (h:Eis) : + sourceRayPhaseSum h=1+ShortDraftTrace.breveE (cuspFrequency h)+ + ShortDraftTrace.breveE (cuspFrequency h)^2 := by + unfold sourceRayPhaseSum + simp only [Fin.sum_univ_succ,Fin.val_zero,Nat.cast_zero,mul_zero,AddChar.map_zero_eq_one, + Fin.val_succ,Nat.cast_add,Nat.cast_one,zero_add,mul_one,Fin.sum_univ_zero,add_zero] + have he : ShortDraftTrace.breveE (cuspFrequency h*(1+1))= + ShortDraftTrace.breveE (cuspFrequency h)^2 := by + rw [mul_add,mul_one,AddChar.map_add_eq_mul,pow_two] + rw [he] + ring + +lemma sourceRayPhaseSum_eq (h:Eis) : + sourceRayPhaseSum h=if ShortDraftTrace.breveE (cuspFrequency h)=1 then 3 else 0 := by + rw [sourceRayPhaseSum_formula] + split_ifs with he + · rw [he] + norm_num + · have hc:=sourceRayPhase_cube h + have hz : (ShortDraftTrace.breveE (cuspFrequency h)-1)* + (1+ShortDraftTrace.breveE (cuspFrequency h)+ShortDraftTrace.breveE (cuspFrequency h)^2)=0 := by + linear_combination hc + exact (mul_eq_zero.mp hz).resolve_left (sub_ne_zero.mpr he) + +lemma kernelCuspFourier_residue_horizontal (h:Eis) : + kernelCuspFourier h cubicEisensteinResidue= + ShortDraftTrace.breveE (cuspFrequency h)*kernelCuspFourier h cubicEisensteinResidue := by + have hh:=translatedCuspFourier_residue_scaled_of_initial h 1 1 + (ShortDraftTrace.breveE (cuspFrequency h)) (by + intro s hs hi + have he:=rational_cusp_fourier_right_T (1:SL(2,ℤ)) 1 h s (by linarith) + have hT (w:HyperbolicSpace) : hyperbolicEisenstein s (rationalComplex ModularGroup.T • w)=hyperbolicEisenstein s w := by + simpa only [pow_one] using hyperbolicEisenstein_T_pow s 1 w + simpa only [one_mul,pow_one,map_one,one_smul,Nat.cast_one,mul_one,hT] using he) + simpa only [translatedCuspFourier_one] using hh + +lemma kernelCuspFourier_residue_eq_zero_of_not_horizontal (h:Eis) + (hh:ShortDraftTrace.breveE (cuspFrequency h)≠1) : + kernelCuspFourier h cubicEisensteinResidue=0 := by + have he:=kernelCuspFourier_residue_horizontal h + have hz : (ShortDraftTrace.breveE (cuspFrequency h)-1)* + kernelCuspFourier h cubicEisensteinResidue=0 := by linear_combination -he + exact (mul_eq_zero.mp hz).resolve_left (sub_ne_zero.mpr hh) + +theorem kernelSourceProjection_residue_fourier_mask (h:Eis) : + kernelCuspFourier h (kernelSourceProjection cubicEisensteinResidue)= + if ShortDraftTrace.breveE (cuspFrequency h)=1 then + (4:ℂ)⁻¹*(kernelCuspFourier h cubicEisensteinResidue+ + 3*translatedCuspFourier h oppositeSource cubicEisensteinResidue) + else 0 := by + rw [kernelSourceProjection_residue_fourier,sourceRayPhaseSum_eq] + split_ifs with hh + · rfl + · rw [kernelCuspFourier_residue_eq_zero_of_not_horizontal h hh] + ring + +end + +open CubicKubota +local notation "Eis" => ActualEisensteinCubic.O + +lemma oppositeFrequency_cross_identity (h:Eis) : + Set.EqOn (fun s=>translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspWhittakerHeightFactor s (3*(9*h))) + (fun s=>translatedCuspFamily (3*(9*h)) oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspWhittakerHeightFactor s h) {s:ℂ|1translatedCuspFamily h oppositeSource 2 3 + (by norm_num) (by norm_num) s*cuspWhittakerHeightFactor s (3*(9*h))) domain := by + intro s hs + exact (translatedCuspFamily_analyticAt_nonreal h oppositeSource 2 3 + (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne').mul + (cuspWhittakerHeightFactor_analyticAt (3*(9*h)) s hs.1) + have hg : AnalyticOnNhd ℂ (fun s=>translatedCuspFamily (3*(9*h)) oppositeSource 2 3 + (by norm_num) (by norm_num) s*cuspWhittakerHeightFactor s h) domain := by + intro s hs + exact (translatedCuspFamily_analyticAt_nonreal (3*(9*h)) oppositeSource 2 3 + (by norm_num) (by norm_num) s hs.1.ne' hs.2.ne').mul + (cuspWhittakerHeightFactor_analyticAt h s hs.1) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s:ℂ | 4translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspWhittakerHeightFactor s (3*(9*h)))=ᶠ[𝓝 (5+Complex.I:ℂ)] + (fun s=>translatedCuspFamily (3*(9*h)) oppositeSource 2 3 (by norm_num) (by norm_num) s* + cuspWhittakerHeightFactor s h) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + rw [translatedCuspFamily_initial h oppositeSource 2 3 (by norm_num) (by norm_num) + (by norm_num) s hs.1 hs.2,opposite_cusp_fourier_average s (by linarith [hs.1]), + translatedCuspFamily_opposite_initial (9*h) s hs.1 hs.2] + ring + exact hf.eqOn_of_preconnected_of_eventuallyEq hg hconvex.isPreconnected hstart hev + +theorem translatedCuspFourier_unramified_residue (h:Eis) : + translatedCuspFourier h oppositeSource cubicEisensteinResidue= + unramifiedGaussResidue (9*h)*cuspWhittakerHeightFactor (4/3:ℂ) h := by + have hh (k:Eis) : Tendsto (fun s:ℂ=>cuspWhittakerHeightFactor s k) + (𝓝[≠] (4/3:ℂ)) (𝓝 (cuspWhittakerHeightFactor (4/3:ℂ) k)) := + (cuspWhittakerHeightFactor_analyticAt k (4/3) (by norm_num)).continuousAt.tendsto.mono_left nhdsWithin_le_nhds + have hl := ((translatedCuspFamily_residue_limit h oppositeSource 2 3 + (by norm_num) (by norm_num)).mul (hh (3*(9*h)))).comp upperVertical_tendsto_cubic_punctured + have hr := ((translatedCuspFamily_residue_limit (3*(9*h)) oppositeSource 2 3 + (by norm_num) (by norm_num)).mul (hh h)).comp upperVertical_tendsto_cubic_punctured + have hev : (fun t:ℝ=>((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)* + translatedCuspFamily h oppositeSource 2 3 (by norm_num) (by norm_num) ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspWhittakerHeightFactor ((4/3:ℂ)+(t:ℂ)*Complex.I) (3*(9*h))) + =ᶠ[𝓝[>] (0:ℝ)] (fun t:ℝ=>((((4/3:ℂ)+(t:ℂ)*Complex.I)-4/3)* + translatedCuspFamily (3*(9*h)) oppositeSource 2 3 (by norm_num) (by norm_num) ((4/3:ℂ)+(t:ℂ)*Complex.I))* + cuspWhittakerHeightFactor ((4/3:ℂ)+(t:ℂ)*Complex.I) h) := by + filter_upwards [self_mem_nhdsWithin] with t ht + change 0z*cuspFourierPhase h w) hw.symm + +lemma unramifiedGaussResidue_zero : + unramifiedGaussResidue 0=((9*Real.sqrt 3/2:ℝ):ℂ)*constantArithmeticResidue := by + apply mul_right_cancel₀ (cuspWhittakerHeightFactor_center_ne_zero (0:Eis)) + have ht:=translatedCuspFourier_unramified_residue (0:Eis) + simp only [mul_zero] at ht + rw [←ht,translatedCuspFourier_opposite_zero_residue] + have hp:=kernelCuspFourier_principal_residue (0:Eis) + rw [kernelCuspFourier_zero,cubicEisensteinResidue_cusp_average] at hp + simpa [principalArithmeticResidue] using hp + +lemma sourceArithmeticResidue_zero : sourceArithmeticResidue 0=constantArithmeticResidue := by + rw [sourceArithmeticResidue] + simp only [cuspFrequency,map_zero,zero_div,AddChar.map_zero_eq_one, + principalArithmeticResidue,mul_zero,unramifiedGaussResidue_zero,ite_true] + field_simp [cusp_volume_ne_zero] + ; ring + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +def horizontalPhaseMultiplier (freq direction : ℂ) : ℂ := + (2*Real.pi*Complex.I)*(freq*direction+star (freq*direction)) + +lemma brevePhase_hasDerivAt (freq z direction : ℂ) (t : ℝ) : + HasDerivAt (fun x : ℝ => ShortDraftTrace.breveE (freq*(z+(x:ℂ)*direction))) + (horizontalPhaseMultiplier freq direction* + ShortDraftTrace.breveE (freq*(z+(t:ℂ)*direction))) t := by + have hz : HasDerivAt (fun x : ℝ => freq*(z+(x:ℂ)*direction)) (freq*direction) t := by + convert (((Complex.ofRealCLM.hasDerivAt (x:=t)).mul_const direction).const_add z).const_mul freq using 1 <;> + simp + have he := ((hz.add hz.star).const_mul (2*Real.pi*Complex.I)).cexp + change HasDerivAt (fun x : ℝ => Complex.exp ((2*Real.pi*Complex.I)* + (freq*(z+(x:ℂ)*direction)+star (freq*(z+(x:ℂ)*direction))))) + ((2*Real.pi*Complex.I)*(freq*direction+star (freq*direction))* + Complex.exp ((2*Real.pi*Complex.I)* + (freq*(z+(t:ℂ)*direction)+star (freq*(z+(t:ℂ)*direction))))) t + simpa only [Pi.add_apply,mul_comm] using he + +lemma horizontalPhaseMultiplier_norm (freq direction : ℂ) : + ‖horizontalPhaseMultiplier freq direction‖≤4*Real.pi*‖freq‖*‖direction‖ := by + have hc : ‖(2*Real.pi*Complex.I:ℂ)‖=2*Real.pi := by + norm_num [norm_mul,abs_of_pos Real.pi_pos] + unfold horizontalPhaseMultiplier + rw [norm_mul,hc] + calc + _ ≤ (2*Real.pi)*(‖freq*direction‖+‖star (freq*direction)‖) := + mul_le_mul_of_nonneg_left (norm_add_le _ _) (by positivity) + _ = _ := by rw [norm_star,norm_mul];ring + +lemma horizontalPhaseMultiplier_wirtinger (freq : ℂ) : + (1/2:ℂ)*(horizontalPhaseMultiplier freq 1+ + Complex.I*horizontalPhaseMultiplier freq Complex.I)=2*Real.pi*Complex.I*star freq := by + simp only [horizontalPhaseMultiplier,mul_one,star_mul,Complex.star_def, + Complex.conj_I] + ring_nf + norm_num [Complex.I_sq,Complex.I_pow_three] + ring + +lemma norm_mul_exp_neg_bound (a r : ℝ) (ha : 0 ‖cuspFrequency h‖*Real.exp (-a*‖cuspFrequency h‖)) := by + apply Summable.of_nonneg_of_le (fun h => mul_nonneg (norm_nonneg _) (Real.exp_pos _).le) + (fun h => norm_mul_exp_neg_bound a _ ha) + exact (summable_exp_neg_cuspFrequency_norm (a/2) (half_pos ha)).mul_left (2/a) + +local notation "O" => ActualEisensteinCubic.O + +def cubicResidualDirectionalTerm (h : ActualEisensteinCubic.O) (v : ℝ) (z direction : ℂ) : ℂ := + horizontalPhaseMultiplier (cuspFrequency h) direction*cubicResidualNonzeroTerm h (v,z) + +lemma cubicResidualNonzeroTerm_horizontal_hasDerivAt (h : ActualEisensteinCubic.O) (v : ℝ) (hv : 0 cubicResidualNonzeroTerm h (v,z+(x:ℂ)*direction)) + (cubicResidualDirectionalTerm h v (z+(t:ℂ)*direction) direction) t := by + have hh := (brevePhase_hasDerivAt (cuspFrequency h) z direction t).const_mul + (cubicResidualModeAmplitude v h) + have hf : (fun x : ℝ => cubicResidualNonzeroTerm h (v,z+(x:ℂ)*direction))= + (fun x : ℝ => cubicResidualModeAmplitude v h* + ShortDraftTrace.breveE (cuspFrequency h*(z+(x:ℂ)*direction))) := by + funext x + exact cubicResidualNonzeroTerm_eq_amplitude v hv h _ + rw [hf] + convert hh using 1 + rw [cubicResidualDirectionalTerm,cubicResidualNonzeroTerm_eq_amplitude v hv h] + ring + +lemma cubicResidualDirectionalTerm_slab_bound (a b : ℝ) (ha : 0 cubicResidualDirectionalTerm h v z direction) := by + obtain ⟨C,hC,hbound⟩ := cubicResidualDirectionalTerm_slab_bound v v hv le_rfl direction + apply Summable.of_norm + apply Summable.of_nonneg_of_le (fun h => norm_nonneg _) (fun h => hbound h v z ⟨le_rfl,le_rfl⟩) + exact (summable_norm_mul_exp_neg_cuspFrequency (Real.pi*v) (mul_pos Real.pi_pos hv)).mul_left C + +lemma cubicResidualNonzeroSeries_horizontal_hasDerivAt (v : ℝ) (hv : 0 cubicResidualNonzeroSeries (v,z+(x:ℂ)*direction)) + (∑'h : ActualEisensteinCubic.O,cubicResidualDirectionalTerm h v (z+(t:ℂ)*direction) direction) t := by + obtain ⟨C,hC,hbound⟩ := cubicResidualDirectionalTerm_slab_bound v v hv le_rfl direction + have hs := (summable_norm_mul_exp_neg_cuspFrequency (Real.pi*v) (mul_pos Real.pi_pos hv)).mul_left C + have hz : Summable (fun h : ActualEisensteinCubic.O => cubicResidualNonzeroTerm h (v,z+(0:ℂ)*direction)) := by + simpa only [zero_mul,add_zero] using cubicResidualNonzeroTerm_summable (v,z) hv + exact hasDerivAt_tsum hs (fun h x => cubicResidualNonzeroTerm_horizontal_hasDerivAt h v hv z direction x) + (fun h x => hbound h v (z+(x:ℂ)*direction) ⟨le_rfl,le_rfl⟩) hz t + +lemma cubicResidualFunction_horizontal_hasDerivAt (v : ℝ) (hv : 0 cubicResidualFunction (upperPoint (z+(x:ℂ)*direction) v hv)) + (∑'h : ActualEisensteinCubic.O,cubicResidualDirectionalTerm h v (z+(t:ℂ)*direction) direction) t := by + have hh := (cubicResidualNonzeroSeries_horizontal_hasDerivAt v hv z direction t).const_add + ((3*Real.pi:ℂ)*constantArithmeticResidue*(v:ℂ)^(2/3:ℂ)) + simpa only [cubicResidualFunction,cubicResidualNonzeroFunction, + hyperbolicHeight_upperPoint,hyperbolicHorizontal_upperPoint] using hh + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +def horizontalWirtingerBar (f : ℂ→ℂ) (z : ℂ) : ℂ := + (1/2:ℂ)*(deriv (fun t : ℝ => f (z+(t:ℂ))) 0+ + Complex.I*deriv (fun t : ℝ => f (z+(t:ℂ)*Complex.I)) 0) + +lemma horizontalWirtingerBar_brevePhase (freq z : ℂ) : + horizontalWirtingerBar (fun w => ShortDraftTrace.breveE (freq*w)) z= + (2*Real.pi*Complex.I*star freq)*ShortDraftTrace.breveE (freq*z) := by + have h1 := (brevePhase_hasDerivAt freq z 1 0).deriv + have hI := (brevePhase_hasDerivAt freq z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerBar,h1,hI] + linear_combination ShortDraftTrace.breveE (freq*z)*horizontalPhaseMultiplier_wirtinger freq + +theorem cubicResidualFunction_wirtingerBar (v : ℝ) (hv : 0 cubicResidualFunction (upperPoint w v hv)) z= + ∑'h : ActualEisensteinCubic.O,(2*Real.pi*Complex.I*star (cuspFrequency h))*cubicResidualNonzeroTerm h (v,z) := by + have h1 := (cubicResidualFunction_horizontal_hasDerivAt v hv z 1 0).deriv + have hI := (cubicResidualFunction_horizontal_hasDerivAt v hv z Complex.I 0).deriv + simp only [mul_one,Complex.ofReal_zero,zero_mul,add_zero] at h1 hI + rw [horizontalWirtingerBar,h1,hI] + have hs1 := cubicResidualDirectionalTerm_summable v hv z 1 + have hsI := (cubicResidualDirectionalTerm_summable v hv z Complex.I).mul_left Complex.I + rw [←tsum_mul_left,←hs1.tsum_add hsI,←tsum_mul_left] + apply tsum_congr + intro h + unfold cubicResidualDirectionalTerm + linear_combination cubicResidualNonzeroTerm h (v,z)*horizontalPhaseMultiplier_wirtinger (cuspFrequency h) + +lemma cubicResidualFunction_wirtingerBar_summable (v : ℝ) (hv : 0 (2*Real.pi*Complex.I*star (cuspFrequency h))*cubicResidualNonzeroTerm h (v,z)) := by + have hs := ((cubicResidualDirectionalTerm_summable v hv z 1).add + ((cubicResidualDirectionalTerm_summable v hv z Complex.I).mul_left Complex.I)).mul_left (1/2:ℂ) + apply hs.congr + intro h + unfold cubicResidualDirectionalTerm + linear_combination cubicResidualNonzeroTerm h (v,z)*horizontalPhaseMultiplier_wirtinger (cuspFrequency h) + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/UnitNormalization.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/UnitNormalization.lean new file mode 100644 index 0000000000000000000000000000000000000000..fa4c3434d200a7fd7e38c7daa619bfa4553ab1c8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/UnitNormalization.lean @@ -0,0 +1,676 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.FredholmAlternative + +namespace OAI + +noncomputable section + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open scoped BigOperators Classical +namespace CanonicalUnitEuler +open ActualEisensteinCubic +open CanonicalRowCompletion +open ConcreteTraceCRT (eisEmbedding) +open UniqueFactorizationMonoid + +lemma good_prime_norm_mod_six (P : Ideal ActualEisensteinCubic.O) [P.IsMaximal] + (hg : lambda∉P) (hc : ringChar (ActualEisensteinCubic.O⧸P)≠2) : Ideal.absNorm P%6=1 := by + let : Field (ActualEisensteinCubic.O⧸P):=Ideal.Quotient.field P + let : Fintype (ActualEisensteinCubic.O⧸P):=Fintype.ofFinite _ + obtain ⟨χ,hχ⟩ : ∃χ : MulChar (ActualEisensteinCubic.O⧸P) ActualEisensteinCubic.O,orderOf χ=6 := ⟨_,sexticChar_order P hg hc⟩ + have hdiv:=χ.orderOf_dvd_card_sub_one + rw [hχ] at hdiv + have hcard : 1 simp + | @cons P s ih => + have hp:=hs P (Multiset.mem_cons_self _ _) + let : P.IsMaximal:=hp.1 + have htail : ∀Q∈s,Q.IsMaximal ∧ lambda∉Q ∧ ringChar (ActualEisensteinCubic.O⧸Q)≠2:= + fun Q hQ=>hs Q (Multiset.mem_cons_of_mem hQ) + obtain ⟨hv,hn⟩:=ih htail + have hP:=good_prime_norm_mod_six P hp.2.1 hp.2.2 + simp only [Multiset.map_cons,Multiset.prod_cons] + refine ⟨?_,by rw [Nat.mul_mod,hP,hn]⟩ + rw [localRowValue_good _ P hp.2.1,actualSextic_unit_euler P hp.2.1 hp.2.2,hv] + have hcard : Nat.card (ActualEisensteinCubic.O⧸P)=Ideal.absNorm P := by + rw [Ideal.absNorm_apply,Submodule.cardQuot_apply] + rw [hcard,unit_sixth_exponent_mul u _ _ hP hn,map_mul] + +theorem idealRowHom_unit_norm (u : ActualEisensteinCubic.Oˣ) (I : Ideal ActualEisensteinCubic.O) (hI : I≠0) + (hgood : ∀P∈normalizedFactors I,P.IsMaximal ∧ lambda∉P ∧ ringChar (ActualEisensteinCubic.O⧸P)≠2) : + idealRowHom u.val I=eisEmbedding (u.val^((Ideal.absNorm I-1)/6)) := by + have hn (s : Multiset (Ideal ActualEisensteinCubic.O)) : (s.map Ideal.absNorm).prod=Ideal.absNorm s.prod := by + induction s using Multiset.induction_on with + | empty => simp + | @cons P s ih => simp only [Multiset.map_cons,Multiset.prod_cons,map_mul,ih] + have hh:=(multiset_unit_norm u (normalizedFactors I) hgood).1 + rw [hn,Ideal.prod_normalizedFactors_eq_self hI] at hh + change (if I=0 then 0 else _) = _ + rwa [ite_eq_right hI] + +lemma ideal_norm_mod_six_of_good (I : Ideal ActualEisensteinCubic.O) (hI : I≠0) + (hgood : ∀P∈normalizedFactors I,P.IsMaximal ∧ lambda∉P ∧ ringChar (ActualEisensteinCubic.O⧸P)≠2) : + Ideal.absNorm I%6=1 := by + have hn (s : Multiset (Ideal ActualEisensteinCubic.O)) : (s.map Ideal.absNorm).prod=Ideal.absNorm s.prod := by + induction s using Multiset.induction_on with + | empty => simp + | @cons P s ih => simp only [Multiset.map_cons,Multiset.prod_cons,map_mul,ih] + have hh:=(multiset_unit_norm (1:ActualEisensteinCubic.Oˣ) (normalizedFactors I) hgood).2 + rwa [hn,Ideal.prod_normalizedFactors_eq_self hI] at hh + +theorem idealRowHom_unit_eq_of_norm_mod_thirty_six (u : ActualEisensteinCubic.Oˣ) (I J : Ideal ActualEisensteinCubic.O) + (hI : I≠0) (hJ : J≠0) + (hgI : ∀P∈normalizedFactors I,P.IsMaximal ∧ lambda∉P ∧ ringChar (ActualEisensteinCubic.O⧸P)≠2) + (hgJ : ∀P∈normalizedFactors J,P.IsMaximal ∧ lambda∉P ∧ ringChar (ActualEisensteinCubic.O⧸P)≠2) + (hmod : Ideal.absNorm I%36=Ideal.absNorm J%36) : + idealRowHom u.val I=idealRowHom u.val J := by + rw [idealRowHom_unit_norm u I hI hgI,idealRowHom_unit_norm u J hJ hgJ] + have hmi:=ideal_norm_mod_six_of_good I hI hgI + have hmj:=ideal_norm_mod_six_of_good J hJ hgJ + have hm : (Ideal.absNorm I-1)/6 ≡ (Ideal.absNorm J-1)/6 [MOD 6] := by + dsimp [Nat.ModEq] + omega + exact congrArg eisEmbedding (pow_eq_pow_of_modEq hm (unit_pow_six u)) + +theorem rowTwist_unit_norm (Ψ : ActualEisensteinCubic.O→*ℂ) (m f z n : ActualEisensteinCubic.O) (u : ActualEisensteinCubic.Oˣ) + (hn : n≠0) + (hgood : ∀P∈normalizedFactors (Ideal.span {n}), + P.IsMaximal ∧ lambda∉P ∧ ringChar (ActualEisensteinCubic.O⧸P)≠2) : + rowTwist Ψ m f (u.val*z) n = rowTwist Ψ m f z n * + eisEmbedding (u.val^((Ideal.absNorm (Ideal.span {n})-1)/6)) := by + change Ψ n*idealRowHom (m^6*f^4*(u.val*z)) (Ideal.span {n}) = + (Ψ n*idealRowHom (m^6*f^4*z) (Ideal.span {n}))*_ + rw [show m^6*f^4*(u.val*z)=u.val*(m^6*f^4*z) by ring, + idealRowHom_argument_mul, + idealRowHom_unit_norm u _ (Ideal.span_singleton_eq_bot.not.mpr hn) hgood] + ring + +end CanonicalUnitEuler + +namespace CompletedGauss +open ActualEisensteinCubic CompletedDyadic + +theorem normalized_cusp_coefficient (d ζ : ℂ) (m n b : ℝ) (hn : 0(x:ℂ)) hcross + push_cast at hc + unfold normalizedCuspAmplitude + have hsa : (((3:ℝ)^(m/6):ℝ):ℂ)≠0:=by exact_mod_cast (Real.rpow_pos_of_pos (by norm_num) (m/6)).ne' + have hsb : ((Real.sqrt b:ℝ):ℂ)≠0:=by exact_mod_cast (Real.sqrt_pos.mpr hb).ne' + have hsr : (((3:ℝ)^(m/3):ℝ):ℂ)≠0:=by exact_mod_cast (Real.rpow_pos_of_pos (by norm_num) (m/3)).ne' + have hsn : ((Real.sqrt n:ℝ):ℂ)≠0:=by exact_mod_cast (Real.sqrt_pos.mpr hn).ne' + have hbc : (b:ℂ)≠0:=by exact_mod_cast hb.ne' + rw [←hc] + push_cast + field_simp + ; ring + +theorem normalized_reflection_weight (ζ : ℂ) (hζ : ‖ζ‖≤(1:ℝ)/81) : + ‖(81:ℂ)*ζ‖≤1 := by + rw [norm_mul] + norm_num + linarith + +theorem normalized_cusp_coefficient_nat (d ζ : ℂ) (m : ℕ) (n b : ℝ) + (hn : 0completedLocalExponent I F (P i)) e 1*N):ℝ)* + (Ideal.absNorm (reflectionExtractedDivisor P (fun i=>completedLocalExponent I F (P i)) e 2*V):ℝ)^3*X/ + ((Ideal.absNorm H:ℝ)^2*(c0*(Ideal.absNorm (∏i,P i):ℝ))^2) := by + have hnorm (J : Ideal ActualEisensteinCubic.O) (hj : J≠0) : 0<(Ideal.absNorm J:ℝ) := by + exact_mod_cast Nat.pos_of_ne_zero (fun hz=>hj (Ideal.absNorm_eq_zero_iff.mp hz)) + have hp : (∏i,P i)≠0:=Finset.prod_ne_zero_iff.mpr (fun i _=>hP i) + have hD:=reflectionExtractedDivisor_ne_zero P hP (fun i=>completedLocalExponent I F (P i)) e 1 + have hE:=reflectionExtractedDivisor_ne_zero P hP (fun i=>completedLocalExponent I F (P i)) e 2 + simpa only [completedBranchScale,map_mul,Nat.cast_mul] using + reflection_kernel_scale X r c0 (Ideal.absNorm (∏i,P i):ℝ) (completedResidualScale K I Q) U B + (Ideal.absNorm H:ℝ) (Ideal.absNorm N:ℝ) (Ideal.absNorm V:ℝ) + (Ideal.absNorm (reflectionExtractedDivisor P (fun i=>completedLocalExponent I F (P i)) e 1):ℝ) + (Ideal.absNorm (reflectionExtractedDivisor P (fun i=>completedLocalExponent I F (P i)) e 2):ℝ) + hX hc0 (hnorm _ hp) hK hU hB (hnorm _ hH) (hnorm _ hN) (hnorm _ hV) (hnorm _ hD) (hnorm _ hE) + +end CompletedGauss + +open scoped BigOperators Classical SchwartzMap ContDiff +namespace CanonicalRowCompletion +open ActualEisensteinCubic +open CompletedGauss hiding O +open ConcretePrimeRowBridge hiding O columnWeight +open CanonicalQuadraticSieve hiding O +open SecondPassArithmetic hiding O +open ConcreteTraceCRT (eisEmbedding) + +theorem shortEnergy_scalar_normalization (C H R Z K X F G ε : ℝ) + (hC : 0≤C) (hH : 0≤H) (hR : 0≤R) (hZ : 1≤Z) (hK : 0≤K) + (hX : 0Ideal.span {z})) (2*K) + (X/(Ideal.absNorm H:ℝ)^3) ρ q levelBound f.val (G*f.val) + (CompletedHeight.normTwistedSource W θ) (CompletedUnitRows.unitRowFamily Ψ mask u f) lengthScale) → + 2*X*rowFamilyEnergy labels (fun I z=>shortCompletedSum (rowTwist (normHeightTwist Ψ θ) + mask (idealGenerator I) z) W X (Z^((1:ℝ)/1000))) K≤ + (C*(1+‖θ‖)^d)*(rays:ℝ)^2*‖lengthScale‖^2*(X*F)^2*Z^(7*ε-(1:ℝ)/40) := by + obtain ⟨d,hbound⟩:=canonicalShortEnergy_uniform_twist a b ha ε ρ q levelBound hε hρ hq hlevel + refine ⟨d,?_⟩ + intro W hs hW + obtain ⟨C,hC,hb⟩:=hbound W hs hW + refine ⟨C,hC,?_⟩ + intro θ rays Z K X F hZ hK hF hFZ hX hmass G hG hbad hmargin labels hlabels Ψ hΨ mask lengthScale hmodels + have he:=hb θ rays Z K X F hZ hK hF hFZ G hG hbad hmargin labels hlabels Ψ hΨ mask lengthScale hmodels + have hFZ' : F≤Z^3 := by + apply hFZ.trans + rw [←Real.rpow_natCast] + exact Real.rpow_le_rpow_of_exponent_le hZ (by norm_num) + have hGN : 1≤(Ideal.absNorm G:ℝ) := by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (fun hz=>hG (Ideal.absNorm_eq_zero_iff.mp hz)) + have hscalar:=shortEnergy_scalar_normalization C ((1+‖θ‖)^d) ((rays:ℝ)^2*‖lengthScale‖^2) + Z K X F (Ideal.absNorm G:ℝ) ε hC (by positivity) (by positivity) hZ + (zero_le_one.trans hK) hX (zero_le_one.trans hF) hGN hε.le hFZ' hmass hmargin + apply (mul_le_mul_of_nonneg_left he (by positivity : 0≤2*X)).trans + convert hscalar using 1 <;> ring + +end CanonicalRowCompletion + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff MatrixGroups + +namespace CubicEisenstein + +section +open ActualEisensteinCubic ConcreteTraceCRT +local notation "O" => ActualEisensteinCubic.O + +lemma rowCoordinates_zero : rowCoordinates (0 : Fin 2 → ActualEisensteinCubic.O)=0 := by + apply norm_le_zero_iff.mp + have h := coordinates_norm_bound (0 : Fin 2 → ActualEisensteinCubic.O) + have he : (fun i : Fin 2 => eisEmbedding ((0 : Fin 2 → ActualEisensteinCubic.O) i))=0 := by + funext i + exact map_zero _ + rw [he,norm_zero,mul_zero] at h + exact h + +lemma rowCoordinates_norm_pos {u : Fin 2 → ActualEisensteinCubic.O} (hu : u≠0) : + 0<‖rowCoordinates u‖ := by + apply norm_pos_iff.mpr + intro h + exact hu (rowCoordinates_injective (h.trans rowCoordinates_zero.symm)) + +lemma rowCoordinates_le_horizontal (u : Fin 2 → ActualEisensteinCubic.O) (z : ℂ) (hz : ‖z‖≤1) : + ‖rowCoordinates u‖≤2*(‖eisEmbedding (u 0)*z+eisEmbedding (u 1)‖+ + ‖eisEmbedding (u 0)‖) := by + apply (coordinates_norm_bound u).trans + apply mul_le_mul_of_nonneg_left _ (by norm_num) + apply (pi_norm_le_iff_of_nonneg (by positivity)).mpr + intro i + fin_cases i + · simp only [Fin.zero_eta] + linarith [norm_nonneg (eisEmbedding (u 0)*z+eisEmbedding (u 1))] + · have h : ‖eisEmbedding (u 1)‖≤ + ‖eisEmbedding (u 0)*z+eisEmbedding (u 1)‖+‖eisEmbedding (u 0)*z‖ := by + simpa only [add_sub_cancel_left] using + norm_sub_le (eisEmbedding (u 0)*z+eisEmbedding (u 1)) (eisEmbedding (u 0)*z) + rw [norm_mul] at h + have hm := mul_le_mul_of_nonneg_left hz (norm_nonneg (eisEmbedding (u 0))) + rw [mul_one] at hm + exact h.trans (add_le_add_right hm _) + +lemma height_times_coordinate_bound (A c v N : ℝ) + (_hA : 0≤A) (hc : 1≤c) (hv : 1/2≤v) (hN : N≤2*(A+c)) : + N*v≤5*(A^2+c^2*v^2) := by + have hv0 : 0≤v := by linarith + have hcv : v≤c*v := by nlinarith + have hcv0 : 1/2≤c*v := by linarith + have hv2 : v^2≤(c*v)^2 := by nlinarith + have hcross : 2*v*A≤A^2+c^2*v^2 := by nlinarith [sq_nonneg (A-v)] + have hlin : 2*c*v≤4*(c*v)^2 := by nlinarith + have hNv := mul_le_mul_of_nonneg_right hN hv0 + nlinarith [sq_nonneg A] + +lemma rowHeight_times_coordinates (u : Fin 2 → ActualEisensteinCubic.O) (hu : u 0≠0) + (z : ℂ) (hz : ‖z‖≤1) (v : ℝ) (hv : 1/2≤v) : + (v/(‖eisEmbedding (u 0)*z+eisEmbedding (u 1)‖^2+ + ‖eisEmbedding (u 0)‖^2*v^2))*‖rowCoordinates u‖≤5 := by + have hc : 1≤‖eisEmbedding (u 0)‖ := by + have hh := one_le_normSq_embedding (u 0) hu + rw [Complex.normSq_eq_norm_sq] at hh + nlinarith [norm_nonneg (eisEmbedding (u 0))] + have hden : 0<‖eisEmbedding (u 0)*z+eisEmbedding (u 1)‖^2+ + ‖eisEmbedding (u 0)‖^2*v^2 := by positivity + rw [div_mul_eq_mul_div] + apply (div_le_iff₀ hden).mpr + simpa only [mul_comm v] using + height_times_coordinate_bound _ _ _ _ (norm_nonneg _) hc hv + (rowCoordinates_le_horizontal u z hz) + +lemma positive_rpow_of_product_bound (h N C σ : ℝ) + (hh : 0≤h) (hN : 0 ActualEisensteinCubic.O + +lemma integral_row_embedding_ne_zero {u : Fin 2 → ActualEisensteinCubic.O} (hu : u≠0) : + (eisEmbedding ∘ u)≠0 := by + intro h + apply hu + funext i + apply eisEmbedding_injective + simpa only [Function.comp_apply,Pi.zero_apply,map_zero] using congrFun h i + +lemma coprime_row_ne_zero {u : Fin 2 → ActualEisensteinCubic.O} (h : IsCoprime (u 0) (u 1)) : u≠0 := by + intro hz + have hh : (0 : ActualEisensteinCubic.O)=1 := by + simpa only [hz,Pi.zero_apply,isCoprime_zero_left,isUnit_zero_iff] using h + exact zero_ne_one hh + +theorem cuspRemainderProfile_row_bound (a b : ℝ) (s : ℂ) + (hab : a eisEmbedding (u i)‖≤1 := by + apply (pi_norm_le_iff_of_nonneg zero_le_one).mpr + intro i + fin_cases i + · change ‖eisEmbedding (u 0)‖≤1 + simp only [hc,map_zero,norm_zero,zero_le_one] + · exact hdnorm.le + nlinarith + apply (cuspRemainderProfile_norm_le_bound a b s _ hab hb hh hs).trans + exact positive_rpow_of_product_bound b _ _ _ hb hN hC hs + (by nlinarith [mul_le_mul_of_nonneg_left hn hb,le_max_right (5 : ℝ) (2*b)]) + · apply (cuspRemainderProfile_norm_le a b s _ hh).trans + apply positive_rpow_of_product_bound _ _ _ _ hh.le hN hC hs + exact (rowHeight_times_coordinates u hc z hz v hv).trans (le_max_left _ _) + +def translatedCuspRow (M : SL(2,ActualEisensteinCubic.O)) (r : CuspCosets) : Fin 2 → ActualEisensteinCubic.O := + Matrix.vecMul (cosetRow r) (M : Matrix (Fin 2) (Fin 2) ActualEisensteinCubic.O) + +lemma translatedCuspRow_injective (M : SL(2,ActualEisensteinCubic.O)) : Function.Injective (translatedCuspRow M) := by + intro r t h + apply cosetRow_injective + have hh := congrArg (fun u : Fin 2 → ActualEisensteinCubic.O => Matrix.vecMul u + ((M⁻¹ : SL(2,ActualEisensteinCubic.O)) : Matrix (Fin 2) (Fin 2) ActualEisensteinCubic.O)) h + simpa only [translatedCuspRow,Matrix.vecMul_vecMul,←Matrix.SpecialLinearGroup.coe_mul, + mul_inv_cancel,Matrix.SpecialLinearGroup.coe_one,Matrix.vecMul_one] using hh + +lemma integral_bottom_coprime (M : SL(2,ActualEisensteinCubic.O)) : IsCoprime (M 1 0) (M 1 1) := by + have hd : M 0 0*M 1 1-M 0 1*M 1 0=1 := by + simpa only [Matrix.det_fin_two] using M.property + refine ⟨-M 0 1,M 0 0,?_⟩ + linear_combination hd + +lemma translatedCuspRow_coprime (M : SL(2,ActualEisensteinCubic.O)) (r : CuspCosets) : + IsCoprime (translatedCuspRow M r 0) (translatedCuspRow M r 1) := by + induction r using Quotient.inductionOn with + | _ N => + change IsCoprime (translatedCuspRow M (cosetOf N) 0) (translatedCuspRow M (cosetOf N) 1) + simpa only [translatedCuspRow,cosetRow_cosetOf,row,Matrix.SpecialLinearGroup.coe_mul, + Matrix.mul_apply,Matrix.vecMul,dotProduct] using integral_bottom_coprime ((N : SL(2,ActualEisensteinCubic.O))*M) + +lemma cosetHeight_integral_chart (M : SL(2,ActualEisensteinCubic.O)) (r : CuspCosets) + (z : ℂ) (v : ℝ) (hv : 0 + change cosetHeight (cosetOf N) (integralComplexMatrix M • upperPoint z v hv)= + transformedHeight z v (eisEmbedding ∘ translatedCuspRow M (cosetOf N)) + rw [cosetHeight_cosetOf,←integralComplexMatrix_levelThree, + ←mul_smul,←map_mul,hyperbolicHeight_action_upperPoint] + simp only [integralComplexMatrix_apply,transformedHeight,heightDenominator, + Function.comp_apply,translatedCuspRow,cosetRow_cosetOf,row, + Matrix.SpecialLinearGroup.coe_mul,Matrix.mul_apply,Matrix.vecMul,dotProduct] + +lemma translated_remainder_majorant (a b : ℝ) (s : ℂ) + (hab : a ActualEisensteinCubic.O + +lemma cuspCutoffTerm_eq_seedProfile (a b : ℝ) (ha : 1≤a) (hab : a (cosetCharacter r)⁻¹* + cuspSeedProfile a b s (cosetHeight r w)) := + (cuspCutoffTerm_summable 1 le_rfl _ w).congr + (fun r => cuspCutoffTerm_eq_seedProfile a b ha hab s r w) + +theorem eisenstein_sub_seed_eq_series (a b : ℝ) (ha : 1≤a) (hab : a cuspCutoffTerm_eq_seedProfile a b ha hab s r w) + rw [hyperbolicEisenstein_eq_height_series,heq,←hE.tsum_sub hS] + apply tsum_congr + intro r + rw [cuspRemainderProfile,positiveHeightPower_eq_cpow s _ (cosetHeight_pos r w)] + ring + +def eisensteinRemainderBound (b : ℝ) (s : ℂ) : ℝ := + (max 5 (2*b))^s.re * ∑'n : (Fin 2×Fin 2)→ℤ,‖n‖^(-s.re) + +lemma eisensteinRemainderBound_nonneg (b : ℝ) (s : ℂ) : + 0≤eisensteinRemainderBound b s := + mul_nonneg (Real.rpow_nonneg ((by norm_num : (0:ℝ)≤5).trans (le_max_left _ _)) _) + (tsum_nonneg (fun n => Real.rpow_nonneg (norm_nonneg n) _)) + +theorem eisenstein_sub_seed_chart_bound (a b : ℝ) (ha : 1≤a) (hab : a (max 5 (2*b))^s.re*‖n‖^(-s.re) + let f : CuspCosets→(Fin 2×Fin 2)→ℤ := fun r => rowCoordinates (translatedCuspRow M r) + let R : CuspCosets→ℂ := fun r => (cosetCharacter r)⁻¹*cuspRemainderProfile a b s + (cosetHeight r (integralComplexMatrix M • upperPoint z v hv0)) + have hg : Summable G := (summable_integer_four_rpow s.re hs).mul_left _ + have hi : Function.Injective f := rowCoordinates_injective.comp (translatedCuspRow_injective M) + have hb : ∀r,‖R r‖≤G (f r) := + translated_remainder_majorant a b s hab (by linarith) (by linarith) M z hz v hv hv0 + have hr : Summable (fun r => ‖R r‖) := + (hg.comp_injective hi).of_nonneg_of_le (fun _ => norm_nonneg _) hb + rw [eisenstein_sub_seed_eq_series a b ha hab s (by linarith)] + change ‖∑'r,R r‖≤eisensteinRemainderBound b s + apply (norm_tsum_le_tsum_norm hr).trans + have hsum : (∑'r,‖R r‖)≤∑'n,G n := + Summable.tsum_le_tsum_of_inj f hi (fun _ _ => by dsimp [G]; positivity) hb hr hg + simpa only [G,tsum_mul_left,eisensteinRemainderBound] using hsum + +theorem eisenstein_sub_seed_bounded (a b : ℝ) (ha : 1≤a) (hab : a hyperbolicEisenstein s w-smoothCuspSeed a b s w) := by + simp_rw [eisenstein_sub_seed_eq_series a b ha hab s hs] + apply Measurable.tsum + intro r + exact measurable_const.mul ((cuspRemainderProfile_measurable a b s).comp + (cosetHeight_continuous r).measurable) + +theorem kernel_eisenstein_sub_seed_memLp (a b : ℝ) (ha : 1≤a) (hab : a kernelQuotientEisenstein s (by linarith) q- + kernelQuotientSeed a b s q) 2 (integralQuotientVolume globalKubotaKernel) := by + have hmeas : Measurable (fun q => kernelQuotientEisenstein s (by linarith) q- + kernelQuotientSeed a b s q) := + measurable_from_quotient.mpr (eisenstein_sub_seed_measurable a b ha hab s (by linarith)) + apply MemLp.of_bound hmeas.aestronglyMeasurable (eisensteinRemainderBound b s) + apply Filter.Eventually.of_forall + intro q + induction q using Quotient.inductionOn with + | _ w => exact eisenstein_sub_seed_bounded a b ha hab s hs w + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/VariationalLaplacian.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/VariationalLaplacian.lean new file mode 100644 index 0000000000000000000000000000000000000000..d478506058afda3a2fec549114d91f70b271d32e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/VariationalLaplacian.lean @@ -0,0 +1,697 @@ +import OAI.NumberTheory.DirichletL.CubicSieve.PaddedPassage + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff + +def kernelLiftedCutoff (χ : PositiveChartCutoff) (w : HyperbolicSpace) : ℝ := + χ.func (hyperbolicEuclideanCoordinates w) + +lemma kernelLiftedCutoff_continuous (χ : PositiveChartCutoff) : Continuous (kernelLiftedCutoff χ) := + χ.smooth.continuous.comp hyperbolicEuclideanCoordinates_continuous + +lemma kernelLiftedCutoff_compact (χ : PositiveChartCutoff) : HasCompactSupport (kernelLiftedCutoff χ) := by + apply HasCompactSupport.of_support_subset_isCompact + (χ.compact.image_of_continuousOn (fun p hp => + (euclideanToHyperbolic_contMDiffAt p (χ.positive hp)).continuousAt.continuousWithinAt)) + intro w hw + refine ⟨hyperbolicEuclideanCoordinates w,?_,euclideanToHyperbolic_coordinates w⟩ + exact subset_tsupport χ.func hw + +lemma kernelLiftedCutoff_bounded (χ : PositiveChartCutoff) : + ∃C : ℝ,∀w,‖kernelLiftedCutoff χ w‖≤C := by + obtain ⟨w,hw⟩ := (kernelLiftedCutoff_continuous χ).norm.exists_forall_ge_of_hasCompactSupport + (kernelLiftedCutoff_compact χ).norm + exact ⟨_,hw⟩ + +lemma kernelCutoffGradient_memLp (χ : PositiveChartCutoff) (g : KernelGradientL2) : + MemLp (fun w => kernelLiftedCutoff χ w • g w) 2 KernelFundamentalVolume := by + obtain ⟨C,hC⟩ := kernelLiftedCutoff_bounded χ + have hm : AEStronglyMeasurable (fun w => kernelLiftedCutoff χ w • g w) KernelFundamentalVolume := + (kernelLiftedCutoff_continuous χ).aestronglyMeasurable.smul (Lp.aestronglyMeasurable g) + refine (Lp.memLp g).of_le_mul (c := C) hm (Eventually.of_forall (fun w => ?_)) + change ‖kernelLiftedCutoff χ w • g w‖≤C*‖g w‖ + rw [norm_smul] + exact mul_le_mul_of_nonneg_right (hC w) (norm_nonneg (g w)) + +def kernelCutoffGradient (χ : PositiveChartCutoff) (g : KernelGradientL2) : KernelGradientL2 := + (kernelCutoffGradient_memLp χ g).toLp (fun w => kernelLiftedCutoff χ w • g w) + +lemma kernelCutoffGradient_coe (χ : PositiveChartCutoff) (g : KernelGradientL2) : + (kernelCutoffGradient χ g : HyperbolicSpace→EuclideanSpace ℂ (Fin 3))=ᵐ[KernelFundamentalVolume] + fun w => kernelLiftedCutoff χ w • g w := (kernelCutoffGradient_memLp χ g).coeFn_toLp + +def kernelCutoffGradientLinear (χ : PositiveChartCutoff) : KernelGradientL2 →ₗ[ℂ] KernelGradientL2 where + toFun := kernelCutoffGradient χ + map_add' g h := by + apply Lp.ext + filter_upwards [kernelCutoffGradient_coe χ (g+h),kernelCutoffGradient_coe χ g, + kernelCutoffGradient_coe χ h,Lp.coeFn_add g h, + Lp.coeFn_add (kernelCutoffGradient χ g) (kernelCutoffGradient χ h)] with w hgh hg hh ha ha' + simp only [hgh,ha',ha,Pi.add_apply,hg,hh,smul_add] + map_smul' c g := by + apply Lp.ext + filter_upwards [kernelCutoffGradient_coe χ (c•g),kernelCutoffGradient_coe χ g, + Lp.coeFn_smul c g,Lp.coeFn_smul c (kernelCutoffGradient χ g)] with w hcg hg ha ha' + simp only [RingHom.id_apply,hcg,ha',ha,Pi.smul_apply,hg] + exact smul_comm _ _ _ + +lemma kernelCutoffGradient_bound (χ : PositiveChartCutoff) : + ∃C : ℝ,∀g : KernelGradientL2,‖kernelCutoffGradientLinear χ g‖≤C*‖g‖ := by + obtain ⟨C,hC⟩ := kernelLiftedCutoff_bounded χ + refine ⟨C,fun g => ?_⟩ + apply Lp.norm_le_mul_norm_of_ae_le_mul + filter_upwards [kernelCutoffGradient_coe χ g] with w hw + change ‖kernelCutoffGradient χ g w‖≤_ + rw [hw,norm_smul] + exact mul_le_mul_of_nonneg_right (hC w) (norm_nonneg _) + +def kernelCutoffGradientCLM (χ : PositiveChartCutoff) : KernelGradientL2 →L[ℂ] KernelGradientL2 := + (kernelCutoffGradientLinear χ).mkContinuousOfExistsBound (kernelCutoffGradient_bound χ) + +lemma kernelCutoffGradient_norm_sq (χ : PositiveChartCutoff) (g : KernelGradientL2) : + ‖kernelCutoffGradientCLM χ g‖^2= + ∫w,(kernelLiftedCutoff χ w)^2*‖g w‖^2∂KernelFundamentalVolume := by + calc + ‖kernelCutoffGradientCLM χ g‖^2=inner ℝ (kernelCutoffGradientCLM χ g) (kernelCutoffGradientCLM χ g) := + (real_inner_self_eq_norm_sq _).symm + _ = ∫w,inner ℝ (kernelCutoffGradient χ g w) (kernelCutoffGradient χ g w)∂KernelFundamentalVolume := rfl + _ = _ := by + apply integral_congr_ae + filter_upwards [kernelCutoffGradient_coe χ g] with w hw + rw [hw,real_inner_self_eq_norm_sq,norm_smul,mul_pow,Real.norm_eq_abs,sq_abs] + +lemma kernelCutoffGradient_core_norm_sq (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + ‖kernelCutoffGradientCLM χ (kernelGradientToL2 f)‖^2= + ∫w,(kernelLiftedCutoff χ w)^2*kernelTestEnergyDensity f w∂KernelFundamentalVolume := by + rw [kernelCutoffGradient_norm_sq] + apply integral_congr_ae + filter_upwards [kernelGradientToL2_coe f] with w hw + rw [hw,kernelGradientAt_norm_sq] + +lemma kernelLocalizedField_reverse_energy (χ : PositiveChartCutoff) (f : kernelSmoothTests) + (p : EuclideanSpatial) (hp : 0

q 2) hc + rw [kernelTestEnergyDensity_eq_partials,hv] + simp only [kernelTestPartial,hc] + have hh := mul_le_mul_of_nonneg_left hsum (sq_nonneg (p 2)) + unfold kernelLocalizedDensity + nlinarith [mul_nonneg (sq_nonneg (p 2)) (sq_nonneg ‖kernelLocalizedField χ f p‖)] + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff ENNReal + +lemma kernelLocalizedDensity_nonneg (χ : PositiveChartCutoff) (f : kernelSmoothTests) + (p : EuclideanSpatial) : 0≤kernelLocalizedDensity χ f p := by + unfold kernelLocalizedDensity + positivity + +lemma hyperbolicVolume_le_densityBound (S : Set EuclideanSpatial) (hS : MeasurableSet S) + (hpos : S⊆euclideanUpperHalf) (H : ℝ) + (hH : ∀p∈S,((p 2)^3)⁻¹≤H) : + hyperbolicEuclideanVolume.restrict S≤ENNReal.ofReal H • volume.restrict S := by + rw [hyperbolicEuclideanVolume,MeasureTheory.restrict_withDensity hS, + Measure.restrict_restrict hS,Set.inter_eq_left.mpr hpos] + have hh : hyperbolicDensity≤ᵐ[volume.restrict S] (fun _ => ENNReal.ofReal H) := by + filter_upwards [ae_restrict_mem hS] with p hp + exact ENNReal.ofReal_le_ofReal (hH p hp) + simpa only [MeasureTheory.withDensity_const] using MeasureTheory.withDensity_mono hh + +instance hyperbolicVolume_finiteOnCompacts : IsFiniteMeasureOnCompacts hyperbolicVolume where + lt_top_of_isCompact K hK := by + let S := hyperbolicEuclideanCoordinates '' K + have hSK : IsCompact S := hK.image hyperbolicEuclideanCoordinates_continuous + have hS : MeasurableSet S := hSK.measurableSet + have hpos : S⊆euclideanUpperHalf := by + rintro p ⟨w,hw,rfl⟩ + exact hyperbolicHeight_pos w + have hrho : ContinuousOn (fun p : EuclideanSpatial => ((p 2)^3)⁻¹) S := + (by fun_prop : Continuous (fun p : EuclideanSpatial => (p 2)^3)).continuousOn.inv₀ + (fun p hp => pow_ne_zero _ (ne_of_gt (hpos hp))) + obtain ⟨H,hH⟩ := hSK.bddAbove_image hrho + have hb := hyperbolicVolume_le_densityBound S hS hpos H (fun p hp => hH ⟨p,hp,rfl⟩) + have hm : hyperbolicEuclideanVolume S< (∞ : ℝ≥0∞) := by + have hbu := Measure.le_iff.mp hb Set.univ MeasurableSet.univ + simp only [Measure.restrict_apply MeasurableSet.univ,Set.univ_inter,Measure.smul_apply, + smul_eq_mul] at hbu + exact hbu.trans_lt (ENNReal.mul_lt_top ENNReal.ofReal_lt_top hSK.measure_lt_top) + have heq : euclideanToHyperbolic ⁻¹' K=ᵐ[hyperbolicEuclideanVolume]S := by + filter_upwards [hyperbolicEuclideanVolume_ae_positive] with p hp + apply propext + constructor + · intro h + exact ⟨euclideanToHyperbolic p,h,hyperbolicEuclideanCoordinates_toHyperbolic p hp⟩ + · rintro ⟨w,hw,rfl⟩ + simpa only [Set.mem_preimage,euclideanToHyperbolic_coordinates] using hw + rw [hyperbolicVolume,Measure.map_apply euclideanToHyperbolic_measurable hK.measurableSet, + measure_congr heq] + exact hm + +private lemma integrable_sq_mul_of_compact (a b : HyperbolicSpace → ℝ) + (ha : Continuous a) (hb : Continuous b) (hc : HasCompactSupport a) : + Integrable (fun w => (a w)^2*b w) hyperbolicVolume := by + have hs : HasCompactSupport (fun w => (a w)^2) := + hc.comp_left (g := fun x : ℝ => x^2) (by simp) + exact ((ha.pow 2).mul hb).integrable_of_hasCompactSupport hs.mul_right + +lemma kernelLiftedCutoffEnergy_integrable (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + Integrable (fun w => (kernelLiftedCutoff χ w)^2*kernelTestEnergyDensity f w) hyperbolicVolume := + integrable_sq_mul_of_compact (kernelLiftedCutoff χ) (kernelTestEnergyDensity f) + (kernelLiftedCutoff_continuous χ) (kernelTestEnergyDensity_continuous f) + (kernelLiftedCutoff_compact χ) + +lemma kernelLiftedCutoffEnergy_integral (χ : PositiveChartCutoff) (f : kernelSmoothTests) : + (∫w,(kernelLiftedCutoff χ w)^2*kernelTestEnergyDensity f w∂hyperbolicVolume)= + ∫p,(χ.func p)^2*kernelTestEnergyDensity f (euclideanToHyperbolic p)∂hyperbolicEuclideanVolume := by + rw [hyperbolicVolume,integral_map euclideanToHyperbolic_measurable.aemeasurable + (kernelLiftedCutoffEnergy_integrable χ f).aestronglyMeasurable] + apply integral_congr_ae + filter_upwards [hyperbolicEuclideanVolume_ae_positive] with p hp + simp only [kernelLiftedCutoff,hyperbolicEuclideanCoordinates_toHyperbolic p hp] + +lemma kernelCutoffGradient_core_estimate (χ : PositiveChartCutoff) + (hinj : Set.InjOn kernelEuclideanProjection (tsupport χ.func)) + (B D H : ℝ) (_hB : 0≤B) (hD : 0≤D) (hH : 0≤H) + (hheight : ∀p∈tsupport χ.func,p 2≤B) + (hderiv : ∀p∈tsupport χ.func, + (∑j : Fin 3,‖fderiv ℝ χ.func p (EuclideanSpace.basisFun (Fin 3) ℝ j)‖^2)≤D) + (hdensity : ∀p∈tsupport χ.func,((p 2)^3)⁻¹≤H) + (f : kernelSmoothTests) : + ‖kernelCutoffGradientCLM χ (kernelGradientToL2 f)‖^2≤ + 2*B^2*(H*‖kernelLocalizedH1 χ f‖^2+D*‖kernelSmoothTestsToL2 f‖^2) := by + let S := tsupport χ.func + have hS : MeasurableSet S := χ.compact.measurableSet + have hpos : S⊆euclideanUpperHalf := χ.positive + have hmeasure := hyperbolicVolume_le_densityBound S hS hpos H hdensity + have hloc : IntegrableOn (kernelLocalizedDensity χ f) S hyperbolicEuclideanVolume := + (((kernelLocalizedDensity_integrable χ f).integrableOn).smul_measure + (c := ENNReal.ofReal H) ENNReal.ofReal_ne_top).mono_measure hmeasure + have hmass : IntegrableOn (fun p => ‖kernelTestField f p‖^2) S hyperbolicEuclideanVolume := by + exact (kernelEuclideanProjection_measurePreserving_on S hS hpos hinj).integrable_comp_of_integrable + ((kernelSmoothTests_memLp f).norm.integrable_sq.integrableOn) + have hweight : IntegrableOn (fun p => (χ.func p)^2*kernelTestEnergyDensity f (euclideanToHyperbolic p)) + S hyperbolicEuclideanVolume := by + have hh := (kernelLiftedCutoffEnergy_integrable χ f).comp_measurable euclideanToHyperbolic_measurable + have heq : (fun p => (kernelLiftedCutoff χ (euclideanToHyperbolic p))^2* + kernelTestEnergyDensity f (euclideanToHyperbolic p))=ᵐ[hyperbolicEuclideanVolume] + fun p => (χ.func p)^2*kernelTestEnergyDensity f (euclideanToHyperbolic p) := by + filter_upwards [hyperbolicEuclideanVolume_ae_positive] with p hp + simp only [kernelLiftedCutoff,hyperbolicEuclideanCoordinates_toHyperbolic p hp] + exact (hh.congr heq).integrableOn + have hlocBound : (∫p in S,kernelLocalizedDensity χ f p∂hyperbolicEuclideanVolume)≤ + H*‖kernelLocalizedH1 χ f‖^2 := by + have hh := integral_mono_measure hmeasure + (Eventually.of_forall (kernelLocalizedDensity_nonneg χ f)) + (((kernelLocalizedDensity_integrable χ f).integrableOn).smul_measure + (c := ENNReal.ofReal H) ENNReal.ofReal_ne_top) + rw [integral_smul_measure,ENNReal.toReal_ofReal hH] at hh + rw [kernelLocalizedH1_norm_sq] + exact hh.trans (mul_le_mul_of_nonneg_left + (setIntegral_le_integral (kernelLocalizedDensity_integrable χ f) + (Eventually.of_forall (kernelLocalizedDensity_nonneg χ f))) hH) + rw [kernelCutoffGradient_core_norm_sq] + calc + _ ≤ ∫w,(kernelLiftedCutoff χ w)^2*kernelTestEnergyDensity f w∂hyperbolicVolume := + setIntegral_le_integral (kernelLiftedCutoffEnergy_integrable χ f) + (Eventually.of_forall (fun w => mul_nonneg (sq_nonneg _) (kernelTestEnergyDensity_nonneg f w))) + _ = ∫p in S,(χ.func p)^2*kernelTestEnergyDensity f (euclideanToHyperbolic p)∂hyperbolicEuclideanVolume := by + rw [kernelLiftedCutoffEnergy_integral] + apply (setIntegral_eq_integral_of_forall_compl_eq_zero _).symm + intro p hp + have hz := (notMem_tsupport_iff_eventuallyEq.mp hp).self_of_nhds + simp only [hz,Pi.zero_apply,zero_pow (by decide : 2≠0),zero_mul] + _ ≤ ∫p in S,(2*B^2*kernelLocalizedDensity χ f p+2*B^2*D*‖kernelTestField f p‖^2) + ∂hyperbolicEuclideanVolume := by + apply setIntegral_mono_on hweight ((hloc.const_mul _).add (hmass.const_mul _)) hS + intro p hp + refine (kernelLocalizedField_reverse_energy χ f p (hpos hp)).trans ?_ + simp only [Pi.add_apply] + gcongr + · exact kernelLocalizedDensity_nonneg _ _ _ + · exact (hpos hp).le + · exact hheight p hp + · exact (hpos hp).le + · exact hheight p hp + · exact hderiv p hp + _ = 2*B^2*((∫p in S,kernelLocalizedDensity χ f p∂hyperbolicEuclideanVolume)+ + D*(∫p in S,‖kernelTestField f p‖^2∂hyperbolicEuclideanVolume)) := by + rw [integral_add (hloc.const_mul _) (hmass.const_mul _),integral_const_mul,integral_const_mul] + ring + _ ≤ _ := by + gcongr + exact kernelLocalMass_le S hS hpos hinj f + +lemma kernelCutoffGradient_core_bounded (χ : PositiveChartCutoff) + (hinj : Set.InjOn kernelEuclideanProjection (tsupport χ.func)) : + ∃C : ℝ,0≤C ∧ ∀f : kernelSmoothTests, + ‖kernelCutoffGradientCLM χ (kernelGradientToL2 f)‖^2≤ + C*(‖kernelLocalizedH1 χ f‖^2+‖kernelSmoothTestsToL2 f‖^2) := by + have hgrad : Continuous (fun p : EuclideanSpatial => + ∑j : Fin 3,‖fderiv ℝ χ.func p (EuclideanSpace.basisFun (Fin 3) ℝ j)‖^2) := by + apply continuous_finsetSum + intro j hj + exact (((χ.smooth.continuous_fderiv (by simp)).clm_apply continuous_const).norm.pow 2) + have hrho : ContinuousOn (fun p : EuclideanSpatial => ((p 2)^3)⁻¹) (tsupport χ.func) := + (by fun_prop : Continuous (fun p : EuclideanSpatial => (p 2)^3)).continuousOn.inv₀ + (fun p hp => pow_ne_zero _ (ne_of_gt (χ.positive hp))) + obtain ⟨d,hd⟩ := χ.compact.bddAbove_image hgrad.continuousOn + obtain ⟨r,hr⟩ := χ.compact.bddAbove_image hrho + obtain ⟨b,hb⟩ := χ.compact.bddAbove_image (f := fun p : EuclideanSpatial => p 2) (by fun_prop) + let D := max 0 d + let H := max 0 r + let B := max 0 b + have hD : 0≤D := le_max_left _ _ + have hH : 0≤H := le_max_left _ _ + have hB : 0≤B := le_max_left _ _ + have hheight : ∀p∈tsupport χ.func,p 2≤B := fun p hp => + (hb ⟨p,hp,rfl⟩).trans (le_max_right _ _) + have hderiv : ∀p∈tsupport χ.func, + (∑j : Fin 3,‖fderiv ℝ χ.func p (EuclideanSpace.basisFun (Fin 3) ℝ j)‖^2)≤D := fun p hp => + (hd ⟨p,hp,rfl⟩).trans (le_max_right _ _) + have hdensity : ∀p∈tsupport χ.func,((p 2)^3)⁻¹≤H := fun p hp => + (hr ⟨p,hp,rfl⟩).trans (le_max_right _ _) + refine ⟨2*B^2*(H+D),by positivity,fun f => ?_⟩ + refine (kernelCutoffGradient_core_estimate χ hinj B D H hB hD hH hheight hderiv hdensity f).trans ?_ + rw [mul_assoc (2*B^2)] + apply mul_le_mul_of_nonneg_left _ (by positivity) + nlinarith [mul_nonneg hH (sq_nonneg ‖kernelSmoothTestsToL2 f‖), + mul_nonneg hD (sq_nonneg ‖kernelLocalizedH1 χ f‖)] + +lemma kernelEnergyCutoffGradient_eq_zero (χ : PositiveChartCutoff) + (hinj : Set.InjOn kernelEuclideanProjection (tsupport χ.func)) (u : KernelEnergyGraph) + (hu : kernelEnergyMass u=0) : kernelCutoffGradientCLM χ (kernelEnergyGradient u)=0 := by + obtain ⟨C,hC,hbound⟩ := kernelCutoffGradient_core_bounded χ hinj + have hh : ‖kernelCutoffGradientCLM χ (kernelEnergyGradient u)‖^2≤ + C*(‖kernelEnergyLocalize χ u‖^2+‖kernelEnergyMass u‖^2) := + kernelEnergyGraphCore_dense.induction_on u (isClosed_le (by fun_prop) (by fun_prop)) + (fun f => by simpa only [kernelEnergyGradient_core,kernelEnergyMass_core, + kernelEnergyLocalize_core χ hinj] using hbound f) + rw [kernelEnergyLocalize_eq_zero_of_mass_zero χ hinj u hu,hu] at hh + have hz : ‖kernelCutoffGradientCLM χ (kernelEnergyGradient u)‖=0 := by simpa using hh + exact norm_eq_zero.mp hz + +lemma kernelCutoffGradient_faithful (g : KernelGradientL2) + (hg : ∀χ : PositiveChartCutoff, + Set.InjOn kernelEuclideanProjection (tsupport χ.func) → kernelCutoffGradientCLM χ g=0) : g=0 := by + let Cutoff := {χ : PositiveChartCutoff // Set.InjOn kernelEuclideanProjection (tsupport χ.func)} + let U : Cutoff→Set HyperbolicSpace := fun χ => {w | kernelLiftedCutoff χ.1 w≠0} + have hU : ∀χ,IsOpen (U χ) := fun χ => + isOpen_ne.preimage (kernelLiftedCutoff_continuous χ.1) + have hcover : (Set.univ : Set HyperbolicSpace)⊆⋃χ,U χ := by + intro w hw + obtain ⟨χ,hχ,hrange,hinj⟩ := + kernelChartCutoff_exists (hyperbolicEuclideanCoordinates w) (hyperbolicHeight_pos w) + refine Set.mem_iUnion.mpr ⟨⟨χ,hinj⟩,?_⟩ + change χ.func (hyperbolicEuclideanCoordinates w)≠0 + rw [hχ] + norm_num + obtain ⟨r,hr,hcov⟩ := isLindelof_univ.elim_countable_subcover U hU hcover + let : Countable r := hr.to_subtype + have heach (χ : Cutoff) : ∀ᵐw∂KernelFundamentalVolume,kernelLiftedCutoff χ.1 w • g w=0 := by + have hzero := hg χ.1 χ.2 + change kernelCutoffGradient χ.1 g=0 at hzero + filter_upwards [kernelCutoffGradient_coe χ.1 g, + (Lp.coeFn_zero (E := EuclideanSpace ℂ (Fin 3)) (p := (2:ℝ≥0∞)) («μ» := KernelFundamentalVolume))] + with w hw hz + rw [hzero] at hw + exact hw.symm.trans hz + have hall : ∀ᵐw∂KernelFundamentalVolume,∀χ : r,kernelLiftedCutoff χ.1.1 w • g w=0 := + ae_all_iff.mpr (fun χ => heach χ.1) + apply Lp.ext + filter_upwards [hall, + (Lp.coeFn_zero (E := EuclideanSpace ℂ (Fin 3)) (p := (2:ℝ≥0∞)) («μ» := KernelFundamentalVolume))] + with w hw hz + obtain ⟨χ,hχ⟩ := Set.mem_iUnion.mp (hcov (Set.mem_univ w)) + obtain ⟨hχr,hχw⟩ := Set.mem_iUnion.mp hχ + have hsm := hw ⟨χ,hχr⟩ + have hne : kernelLiftedCutoff χ.1 w≠0 := hχw + exact ((smul_eq_zero.mp hsm).resolve_left hne).trans hz.symm + +theorem kernelEnergyMass_eq_zero (u : KernelEnergyGraph) (hu : kernelEnergyMass u=0) : u=0 := by + have hgrad : kernelEnergyGradient u=0 := + kernelCutoffGradient_faithful _ (fun χ hinj => kernelEnergyCutoffGradient_eq_zero χ hinj u hu) + apply norm_eq_zero.mp + have hn := kernelEnergyGraph_norm_sq u + simp only [hu,hgrad,norm_zero,zero_pow (by decide : 2≠0),add_zero] at hn + nlinarith [norm_nonneg u] + +theorem kernelEnergyMass_injective : Function.Injective kernelEnergyMass := by + intro u v huv + apply sub_eq_zero.mp + apply kernelEnergyMass_eq_zero + rw [map_sub,huv,sub_self] + +lemma kernelInitialGradient_closure_unique (x : KernelQuotientL2 × KernelGradientL2) + (hx : x∈kernelInitialGradient.graph.topologicalClosure) (hz : x.1=0) : x.2=0 := by + let J := (WithLp.prodContinuousLinearEquiv 2 ℂ KernelQuotientL2 KernelGradientL2).symm + have hi : J '' (kernelInitialGradientGraph : Set (KernelQuotientL2 × KernelGradientL2))= + Set.range kernelEnergyCore := by + ext y + constructor + · rintro ⟨z,⟨f,rfl⟩,rfl⟩ + exact ⟨f,rfl⟩ + · rintro ⟨f,rfl⟩ + exact ⟨(kernelSmoothTestsToL2 f,kernelGradientLinear f),⟨f,rfl⟩,rfl⟩ + rw [kernelInitialGradient_graph] at hx + change x∈closure (kernelInitialGradientGraph : Set (KernelQuotientL2 × KernelGradientL2)) at hx + have hh := image_closure_subset_closure_image J.continuous ⟨x,hx,rfl⟩ + rw [hi] at hh + let u : KernelEnergyGraph := ⟨J x,hh⟩ + have hu : kernelEnergyMass u=0 := hz + have hu0 := kernelEnergyMass_eq_zero u hu + have hv := congrArg kernelEnergyGradient hu0 + change x.2=kernelEnergyGradient 0 at hv + simpa only [map_zero] using hv + +theorem kernelInitialGradient_isClosable : kernelInitialGradient.IsClosable := by + refine ⟨kernelInitialGradient.graph.topologicalClosure.toLinearPMap,?_⟩ + exact (Submodule.toLinearPMap_graph_eq _ kernelInitialGradient_closure_unique).symm + +def kernelWeakGradient : KernelQuotientL2 →ₗ.[ℂ] KernelGradientL2 := kernelInitialGradient.closure + +theorem kernelWeakGradient_closed : kernelWeakGradient.IsClosed := + kernelInitialGradient_isClosable.closure_isClosed + +theorem kernelWeakGradient_dense_domain : Dense (kernelWeakGradient.domain : Set KernelQuotientL2) := + kernelInitialGradient_dense_domain.mono (LinearPMap.le_closure kernelInitialGradient).1 + +end + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ContDiff InnerProductSpace + +lemma kernelEnergyGraph_inner (u v : KernelEnergyGraph) : + inner ℂ u v=inner ℂ (kernelEnergyMass u) (kernelEnergyMass v)+ + inner ℂ (kernelEnergyGradient u) (kernelEnergyGradient v) := rfl + +lemma kernelEnergyMass_norm_le (u : KernelEnergyGraph) : ‖kernelEnergyMass u‖≤‖u‖ := by + have hh := kernelEnergyGraph_norm_sq u + nlinarith [sq_nonneg ‖kernelEnergyGradient u‖,norm_nonneg (kernelEnergyMass u),norm_nonneg u] + +lemma kernelEnergyMass_opNorm_le : ‖kernelEnergyMass‖≤1 := + ContinuousLinearMap.opNorm_le_bound _ zero_le_one (by simpa using kernelEnergyMass_norm_le) + +def kernelVariationalSolution : KernelQuotientL2 →L[ℂ] KernelEnergyGraph := + kernelEnergyMass.adjoint + +lemma kernelVariationalSolution_equation (F : KernelQuotientL2) (v : KernelEnergyGraph) : + inner ℂ (kernelEnergyMass (kernelVariationalSolution F)) (kernelEnergyMass v)+ + inner ℂ (kernelEnergyGradient (kernelVariationalSolution F)) (kernelEnergyGradient v)= + inner ℂ F (kernelEnergyMass v) := by + rw [←kernelEnergyGraph_inner] + exact kernelEnergyMass.adjoint_inner_left v F + +lemma kernelVariationalSolution_unique (F : KernelQuotientL2) (u : KernelEnergyGraph) + (hu : ∀v : KernelEnergyGraph, + inner ℂ (kernelEnergyMass u) (kernelEnergyMass v)+ + inner ℂ (kernelEnergyGradient u) (kernelEnergyGradient v)=inner ℂ F (kernelEnergyMass v)) : + u=kernelVariationalSolution F := by + apply ext_inner_right ℂ + intro v + rw [kernelEnergyGraph_inner,kernelEnergyGraph_inner] + exact (hu v).trans (kernelVariationalSolution_equation F v).symm + +theorem kernelVariationalSolution_existsUnique (F : KernelQuotientL2) : + ∃!u : KernelEnergyGraph,∀v : KernelEnergyGraph, + inner ℂ (kernelEnergyMass u) (kernelEnergyMass v)+ + inner ℂ (kernelEnergyGradient u) (kernelEnergyGradient v)=inner ℂ F (kernelEnergyMass v) := + ⟨kernelVariationalSolution F,kernelVariationalSolution_equation F, + fun u hu => kernelVariationalSolution_unique F u hu⟩ + +lemma kernelVariationalSolution_norm_le (F : KernelQuotientL2) : + ‖kernelVariationalSolution F‖≤‖F‖ := by + have hnorm : ‖kernelVariationalSolution‖=‖kernelEnergyMass‖ := + ContinuousLinearMap.adjoint.norm_map _ + calc + ‖kernelVariationalSolution F‖≤‖kernelVariationalSolution‖*‖F‖ := + kernelVariationalSolution.le_opNorm F + _ ≤1*‖F‖ := mul_le_mul_of_nonneg_right (hnorm ▸ kernelEnergyMass_opNorm_le) (norm_nonneg F) + _ = _ := one_mul _ + +def kernelVariationalResolvent : KernelQuotientL2 →L[ℂ] KernelQuotientL2 := + kernelEnergyMass.comp kernelVariationalSolution + +lemma kernelVariationalResolvent_norm_le (F : KernelQuotientL2) : + ‖kernelVariationalResolvent F‖≤‖F‖ := + (kernelEnergyMass_norm_le _).trans (kernelVariationalSolution_norm_le F) + +private lemma selfAdjoint_comp_adjoint {E F : Type*} + [NormedAddCommGroup E] [InnerProductSpace ℂ E] [CompleteSpace E] + [NormedAddCommGroup F] [InnerProductSpace ℂ F] [CompleteSpace F] + (A : E →L[ℂ] F) : IsSelfAdjoint (A.comp A.adjoint) := by + rw [ContinuousLinearMap.isSelfAdjoint_iff'] + rw [ContinuousLinearMap.adjoint_comp,ContinuousLinearMap.adjoint_adjoint] + +lemma kernelVariationalResolvent_selfAdjoint : IsSelfAdjoint kernelVariationalResolvent := + selfAdjoint_comp_adjoint kernelEnergyMass + +lemma kernelVariationalResolvent_positive (F : KernelQuotientL2) : + 0≤(inner ℂ F (kernelVariationalResolvent F)).re := by + change 0≤(inner ℂ F (kernelEnergyMass (kernelEnergyMass.adjoint F))).re + rw [←kernelEnergyMass.adjoint_inner_left] + exact inner_self_nonneg (𝕜 := ℂ) (x := kernelEnergyMass.adjoint F) + +lemma kernelVariationalResolvent_injective : Function.Injective kernelVariationalResolvent := by + apply (LinearMap.ker_eq_bot).mp + apply LinearMap.ker_eq_bot'.mpr + intro F hF + change kernelEnergyMass (kernelVariationalSolution F)=0 at hF + have hu : kernelVariationalSolution F=0 := kernelEnergyMass_injective (by + rw [map_zero] + exact hF) + have he : (fun g : KernelQuotientL2 => inner ℂ F g)=(fun _ => (0 : ℂ)) := + kernelEnergyMass_dense.equalizer (by fun_prop) continuous_const (by + funext v + change inner ℂ F (kernelEnergyMass v)=0 + rw [←kernelEnergyMass.adjoint_inner_left] + change inner ℂ (kernelVariationalSolution F) v=0 + rw [hu,inner_zero_left]) + exact inner_self_eq_zero.mp (congrFun he F) + +lemma kernelVariationalResolvent_dense : DenseRange kernelVariationalResolvent := by + change Dense (kernelVariationalResolvent.range : Set KernelQuotientL2) + apply Submodule.dense_iff_topologicalClosure_eq_top.mpr + have hh := kernelVariationalResolvent.orthogonal_ker + rw [LinearMap.ker_eq_bot.mpr kernelVariationalResolvent_injective,Submodule.bot_orthogonal_eq_top, + kernelVariationalResolvent_selfAdjoint.adjoint_eq] at hh + exact hh.symm + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace + +def kernelLaplacianEquation : (KernelQuotientL2 × KernelQuotientL2) →L[ℂ] KernelQuotientL2 := + kernelVariationalResolvent.comp ((ContinuousLinearMap.fst ℂ KernelQuotientL2 KernelQuotientL2)+ + (ContinuousLinearMap.snd ℂ KernelQuotientL2 KernelQuotientL2))- + (ContinuousLinearMap.fst ℂ KernelQuotientL2 KernelQuotientL2) + +def kernelLaplacianGraph : Submodule ℂ (KernelQuotientL2 × KernelQuotientL2) := + kernelLaplacianEquation.ker + +lemma mem_kernelLaplacianGraph (u f : KernelQuotientL2) : + (u,f)∈kernelLaplacianGraph ↔ kernelVariationalResolvent (u+f)=u := by + change kernelVariationalResolvent (u+f)-u=0 ↔ _ + exact sub_eq_zero + +lemma kernelLaplacianGraph_unique (x : KernelQuotientL2 × KernelQuotientL2) + (hx : x∈kernelLaplacianGraph) (hz : x.1=0) : x.2=0 := by + have hh := (mem_kernelLaplacianGraph x.1 x.2).mp hx + rw [hz,zero_add] at hh + apply kernelVariationalResolvent_injective + rw [map_zero] + exact hh + +def kernelEnergyLaplacian : KernelQuotientL2 →ₗ.[ℂ] KernelQuotientL2 := + kernelLaplacianGraph.toLinearPMap + +lemma kernelEnergyLaplacian_graph : kernelEnergyLaplacian.graph=kernelLaplacianGraph := + Submodule.toLinearPMap_graph_eq _ kernelLaplacianGraph_unique + +lemma kernelEnergyLaplacian_closed : kernelEnergyLaplacian.IsClosed := by + rw [LinearPMap.IsClosed,kernelEnergyLaplacian_graph] + exact kernelLaplacianEquation.isClosed_ker + +lemma kernelEnergyLaplacian_resolvent_graph (F : KernelQuotientL2) : + (kernelVariationalResolvent F,F-kernelVariationalResolvent F)∈kernelEnergyLaplacian.graph := by + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] + congr 1 + abel + +lemma kernelEnergyLaplacian_resolvent_domain (F : KernelQuotientL2) : + kernelVariationalResolvent F∈kernelEnergyLaplacian.domain := + LinearPMap.mem_domain_of_mem_graph (kernelEnergyLaplacian_resolvent_graph F) + +lemma kernelEnergyLaplacian_resolvent_apply (F : KernelQuotientL2) : + kernelEnergyLaplacian ⟨kernelVariationalResolvent F,kernelEnergyLaplacian_resolvent_domain F⟩= + F-kernelVariationalResolvent F := + kernelEnergyLaplacian.mem_graph_snd_inj (kernelEnergyLaplacian.mem_graph _) + (kernelEnergyLaplacian_resolvent_graph F) rfl + +lemma kernelEnergyLaplacian_dense_domain : + Dense (kernelEnergyLaplacian.domain : Set KernelQuotientL2) := by + apply kernelVariationalResolvent_dense.mono + rintro _ ⟨F,rfl⟩ + exact kernelEnergyLaplacian_resolvent_domain F + +lemma kernelEnergyLaplacian_resolvent_relation (u : kernelEnergyLaplacian.domain) : + kernelVariationalResolvent (kernelEnergyLaplacian u+u)=u := by + have hh := kernelEnergyLaplacian.mem_graph u + rw [kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] at hh + simpa only [add_comm] using hh + +lemma kernelEnergyLaplacian_isFormalAdjoint : + kernelEnergyLaplacian.IsFormalAdjoint kernelEnergyLaplacian := by + intro u v + have hh := kernelVariationalResolvent_selfAdjoint.isSymmetric + (kernelEnergyLaplacian u+u) (kernelEnergyLaplacian v+v) + simp only [ContinuousLinearMap.coe_coe] at hh + rw [kernelEnergyLaplacian_resolvent_relation,kernelEnergyLaplacian_resolvent_relation] at hh + simp only [inner_add_left,inner_add_right] at hh + exact add_right_cancel hh.symm + +lemma kernelEnergyLaplacian_form (u : kernelEnergyLaplacian.domain) (v : KernelEnergyGraph) : + inner ℂ (kernelEnergyLaplacian u) (kernelEnergyMass v)= + inner ℂ (kernelEnergyGradient (kernelVariationalSolution (kernelEnergyLaplacian u+u))) + (kernelEnergyGradient v) := by + have hh := kernelVariationalSolution_equation (kernelEnergyLaplacian u+u) v + have he : kernelEnergyMass (kernelVariationalSolution (kernelEnergyLaplacian u+u))=u := + kernelEnergyLaplacian_resolvent_relation u + rw [he,inner_add_left] at hh + exact (add_left_cancel (hh.trans (add_comm _ _))).symm + +lemma kernelEnergyLaplacian_nonnegative (u : kernelEnergyLaplacian.domain) : + 0≤(inner ℂ (kernelEnergyLaplacian u) (u : KernelQuotientL2)).re := by + have hh := kernelEnergyLaplacian_form u + (kernelVariationalSolution (kernelEnergyLaplacian u+u)) + have he : kernelEnergyMass (kernelVariationalSolution (kernelEnergyLaplacian u+u))=u := + kernelEnergyLaplacian_resolvent_relation u + rw [he] at hh + rw [hh] + exact inner_self_nonneg (𝕜 := ℂ) + +theorem kernelEnergyLaplacian_selfAdjoint : IsSelfAdjoint kernelEnergyLaplacian := by + rw [LinearPMap.isSelfAdjoint_def] + apply le_antisymm + · apply LinearPMap.le_of_le_graph + intro x hx + obtain ⟨u,hu,hv⟩ := (kernelEnergyLaplacian.adjoint.mem_graph_iff).mp hx + change (x.1,x.2)∈kernelEnergyLaplacian.graph + rw [←hu,←hv,kernelEnergyLaplacian_graph,mem_kernelLaplacianGraph] + apply ext_inner_right ℂ + intro F + have ha := LinearPMap.adjoint_isFormalAdjoint kernelEnergyLaplacian_dense_domain u + ⟨kernelVariationalResolvent F,kernelEnergyLaplacian_resolvent_domain F⟩ + rw [kernelEnergyLaplacian_resolvent_apply] at ha + have hs := kernelVariationalResolvent_selfAdjoint.isSymmetric + ((u : KernelQuotientL2)+kernelEnergyLaplacian.adjoint u) F + simp only [ContinuousLinearMap.coe_coe] at hs + rw [hs,inner_add_left,ha,inner_sub_right] + abel + · exact LinearPMap.IsFormalAdjoint.le_adjoint kernelEnergyLaplacian_dense_domain + kernelEnergyLaplacian_isFormalAdjoint + +end CubicEisenstein + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Eisenstein/WhittakerContinuation.lean b/lean/OAI/NumberTheory/DirichletL/Eisenstein/WhittakerContinuation.lean new file mode 100644 index 0000000000000000000000000000000000000000..358b68311598b0b2f4af0ed7bf1474ab6a9546ae --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Eisenstein/WhittakerContinuation.lean @@ -0,0 +1,637 @@ +import OAI.NumberTheory.DirichletL.Eisenstein.ScatteringCoefficients + +namespace OAI + +noncomputable section + +namespace CubicEisenstein + +open scoped BigOperators +open MulChar AddChar +open scoped BigOperators +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped FourierTransform SchwartzMap +open Finset Complex +open scoped Classical +open scoped Classical +open Filter Real Asymptotics +open ActualEisensteinCubic +open Filter +open ActualEisensteinCubic RationalPrimeExtraction ShortDraftLatticeCount +open ActualEisensteinCubic ShortDraftLatticeCount +open Filter +open scoped Topology +open EisensteinEmbedding ConcreteTraceCRT ActualEisensteinCubic +open MulChar AddChar +open Filter Asymptotics +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter +open MulChar AddChar +open MulChar AddChar +open scoped LSeries.notation ArithmeticFunction.Moebius +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Ideal NumberField RingOfIntegers UniqueFactorizationMonoid +open Filter Asymptotics +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics Ideal NumberField +open Filter +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open Filter Asymptotics MeasureTheory +open scoped Topology +open MeasureTheory Real +open scoped ContDiff FourierTransform SchwartzMap +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical SchwartzMap ContDiff +open scoped BigOperators Classical +open scoped BigOperators Classical SchwartzMap ContDiff +open MeasureTheory Set +open scoped BigOperators +open scoped BigOperators Classical +open scoped BigOperators Classical +open ActualEisensteinCubic UniqueFactorizationMonoid +open scoped BigOperators +open scoped BigOperators +open scoped BigOperators Classical SchwartzMap +open scoped BigOperators Classical + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +lemma cuspWhittakerHeightFactor_analyticAt (h : ActualEisensteinCubic.O) (s : ℂ) (hs : 1 cuspWhittakerHeightFactor w h) s := by + apply Complex.analyticAt_iff_eventually_differentiableAt.mpr + have hopen : IsOpen {w : ℂ | 1 (s-4/3)*continuedNonzeroScattering h s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (nonzeroScatteringResidue h)) := by + have hden : Tendsto (fun s : ℂ => ((9*Real.sqrt 3/2:ℝ):ℂ)*cuspWhittakerHeightFactor s h) + (𝓝[≠] (4/3:ℂ)) (𝓝 (((9*Real.sqrt 3/2:ℝ):ℂ)*cuspWhittakerHeightFactor (4/3:ℂ) h)) := (continuousAt_const.mul + (cuspWhittakerHeightFactor_analyticAt h (4/3) (by norm_num)).continuousAt).tendsto.mono_left + (show 𝓝[≠] (4/3:ℂ)≤𝓝 (4/3:ℂ) from nhdsWithin_le_nhds) + have hlimit := (kernelCuspFourierFamily_residue_limit h 2 3 (by norm_num) (by norm_num)).div hden + (mul_ne_zero cusp_volume_ne_zero (cuspWhittakerHeightFactor_center_ne_zero h)) + change Tendsto (fun s : ℂ => + ((s-4/3)*kernelCuspFourierFamily h 2 3 (by norm_num) (by norm_num) s)/ + (((9*Real.sqrt 3/2:ℝ):ℂ)*cuspWhittakerHeightFactor s h)) + (𝓝[≠] (4/3:ℂ)) (𝓝 (nonzeroScatteringResidue h)) at hlimit + convert hlimit using 1 + funext s + exact (mul_div_assoc _ _ _).symm + +lemma continuedNonzeroScattering_initial (h : ActualEisensteinCubic.O) (hh : h≠0) (s : ℂ) + (hs : 4 ((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h*cuspWhittakerHeightFactor s h) + {s : ℂ | 2 ((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h*cuspWhittakerHeightFactor s h) domain := by + intro s hs + exact (analyticAt_const.mul (scatteringCoefficient_analyticOnNhd h s hs.1)).mul + (cuspWhittakerHeightFactor_analyticAt h s (by linarith [hs.1])) + have hstart : (5+Complex.I:ℂ)∈domain := by norm_num [domain] + have hopen : IsOpen {s : ℂ | 4 ((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h*cuspWhittakerHeightFactor s h) := by + filter_upwards [hopen.mem_nhds (by norm_num)] with s hs + exact kernelCuspFourierFamily_nonzero_of_initial_overlap h hh 2 3 + (by norm_num) (by norm_num) s (by linarith [hs.1]) + (kernelEisensteinL2Correction_initial_overlap 2 3 (by norm_num) (by norm_num) s hs.1 hs.2) + exact hleft.eqOn_of_preconnected_of_eventuallyEq hright hconvex.isPreconnected hstart hevent + +lemma continuedNonzeroScattering_eq_upper (h : ActualEisensteinCubic.O) (hh : h≠0) (s : ℂ) + (hs : 2 scatteringCoefficient s h) U := by + obtain ⟨ε,hε,hball⟩ := Metric.eventually_nhds_iff.mp (cuspWhittakerHeightFactor_ne_zero_near_five h) + let z : ℂ := 5+(ε/2:ℝ)*Complex.I + have hz : dist z (5:ℂ)<ε := by + have hdist : dist z (5:ℂ)=ε/2 := by + simp [z,dist_eq_norm,hε.le] + rw [hdist] + linarith + have hzim : 0 ρ p.1*whittakerIntegrand freq s p) whittakerProductVolume := by + apply ((whittaker_bound_integrable s.re hs).const_mul ‖ρ‖).mono' + · exact ((ρ.continuous.comp continuous_fst).mul (whittakerIntegrand_continuous freq s)).aestronglyMeasurable + · exact Eventually.of_forall (fun p => by + rw [norm_mul] + exact mul_le_mul (ρ.norm_coe_le_norm p.1) + (whittakerIntegrand_norm_bound freq s p s.re (by linarith) le_rfl) (norm_nonneg _) (norm_nonneg _)) + +lemma weightedWhittakerProduct_differentiableAt (ρ : BoundedContinuousFunction ℝ ℂ) (freq s : ℂ) (hs : 1 ∫p : ℝ × ℂ,ρ p.1*whittakerIntegrand freq w p∂whittakerProductVolume) s := by + let b : ℝ := (s.re+1)/2 + let ε : ℝ := (s.re-1)/4 + have hb : 1 ρ p.1*whittakerIntegrand freq w p) + (F' := fun w (p : ℝ × ℂ) => ρ p.1*whittakerIntegrandDeriv freq w p) + (bound := fun p => ‖ρ‖*(ε⁻¹*(1+‖p.2‖^2)^(-b))) hU + (Eventually.of_forall (fun w => + ((ρ.continuous.comp continuous_fst).mul (whittakerIntegrand_continuous freq w)).aestronglyMeasurable)) + (weightedWhittakerIntegrand_integrable ρ freq s hs) + ((ρ.continuous.comp continuous_fst).mul (whittakerIntegrandDeriv_continuous freq s)).aestronglyMeasurable + (Eventually.of_forall (fun p w hw => by + rw [norm_mul] + exact mul_le_mul (ρ.norm_coe_le_norm p.1) + (whittakerIntegrandDeriv_norm_bound freq w p b ε (by linarith) hε hw.le) + (norm_nonneg _) (norm_nonneg _))) + (((whittaker_bound_integrable b hb).const_mul ε⁻¹).const_mul ‖ρ‖) + (Eventually.of_forall (fun p w _ => (whittakerIntegrand_hasDerivAt freq w p).const_mul (ρ p.1))) + exact h.2.differentiableAt + +lemma weightedWhittakerProduct_eq_average (ρ : BoundedContinuousFunction ℝ ℂ) (freq s : ℂ) (hs : 1 by + dsimp only + rw [whittakerIntegrand_eq freq s v hv.1 z] + ring) + _ = _ := integral_const_mul _ _ + +theorem cuspWeightedWhittakerAverage_differentiableAt (ρ : BoundedContinuousFunction ℝ ℂ) (freq s : ℂ) (hs : 1 ∫v in Set.Icc (5:ℝ) 6,ρ v*(v:ℂ)^(-w-1)*sourceFourierKernel w (freq*v)) s := by + have he : (fun w => ∫v in Set.Icc (5:ℝ) 6,ρ v*(v:ℂ)^(-w-1)*sourceFourierKernel w (freq*v)) + =ᶠ[𝓝 s](fun w => ∫p : ℝ × ℂ,ρ p.1*whittakerIntegrand freq w p∂whittakerProductVolume) := by + filter_upwards [(isOpen_lt continuous_const Complex.continuous_re).mem_nhds hs] with w hw + exact (weightedWhittakerProduct_eq_average ρ freq w hw).symm + exact (weightedWhittakerProduct_differentiableAt ρ freq s hs).congr_of_eventuallyEq he + +section +open Filter MeasureTheory +open scoped BigOperators Classical Topology ENNReal + +theorem kernelCompact_projection_measure_bound (K : Set HyperbolicSpace) (hK : IsCompact K) : + ∃N : ℕ,Measure.map (integralOrbitProjection globalKubotaKernel) (hyperbolicVolume.restrict K)≤ + (N:ℝ≥0∞) • integralQuotientVolume globalKubotaKernel := by + choose e he heq using kernelQuotient_localHomeomorph + have hcover : K⊆⋃w : HyperbolicSpace,(e w).source := by + intro w _ + exact Set.mem_iUnion.mpr ⟨w,he w⟩ + obtain ⟨t,ht⟩ := hK.elim_finite_subcover (fun w => (e w).source) (fun w => (e w).open_source) hcover + have hinj (w : HyperbolicSpace) : + Set.InjOn (integralOrbitProjection globalKubotaKernel) (e w).source := by + rw [heq w] + exact (e w).injOn + refine ⟨t.card,Measure.le_iff.mpr ?_⟩ + intro B hB + rw [Measure.map_apply (measurable_integralOrbitProjection _) hB, + Measure.restrict_apply ((measurable_integralOrbitProjection _) hB),Measure.smul_apply] + change hyperbolicVolume ((integralOrbitProjection globalKubotaKernel) ⁻¹' B ∩ K)≤ + (t.card:ℝ≥0∞)*integralQuotientVolume globalKubotaKernel B + calc + _ ≤ hyperbolicVolume (⋃w∈t,(integralOrbitProjection globalKubotaKernel) ⁻¹' B ∩ (e w).source) := by + apply measure_mono + rintro w ⟨hw,hK⟩ + obtain ⟨v,hv,hwv⟩ := Set.mem_iUnion₂.mp (ht hK) + exact Set.mem_iUnion₂.mpr ⟨v,hv,hw,hwv⟩ + _ ≤ ∑w∈t,hyperbolicVolume ((integralOrbitProjection globalKubotaKernel) ⁻¹' B ∩ (e w).source) := + measure_biUnion_finset_le _ _ + _ ≤ ∑_w∈t,integralQuotientVolume globalKubotaKernel B := by + apply Finset.sum_le_sum + intro w hw + have hm := kernelProjection_measurePreserving_on (e w).source (e w).open_source.measurableSet (hinj w) + rw [←Measure.restrict_apply ((measurable_integralOrbitProjection _) hB), + ←Measure.map_apply (measurable_integralOrbitProjection _) hB,hm.map_eq] + exact Measure.restrict_le_self B + _ = _ := by simp [nsmul_eq_mul] + +section DominatedComplexL2 +variable {α : Type*} [MeasurableSpace α] {«μ» ν : Measure α} {c : ℝ≥0∞} + +def dominatedComplexL2 (hc : c≠⊤) (h : ν≤c•«μ») : Lp ℂ 2 «μ»→L[ℂ]Lp ℂ 2 ν where + toFun := Lp.LpToLpOfMeasureLeSMul hc h + map_add' := map_add (Lp.LpToLpOfMeasureLeSMul hc h) + map_smul' z f := by + apply Lp.ext + filter_upwards [Lp.coeFn_LpToLpOfMeasureLeSMul hc h (z•f), + Lp.coeFn_LpToLpOfMeasureLeSMul hc h f, + Lp.coeFn_smul z (Lp.LpToLpOfMeasureLeSMul hc h f), + (Measure.absolutelyContinuous_of_le_smul h).ae_eq (Lp.coeFn_smul z f)] with x h1 h2 h3 h4 + simp only [RingHom.id_apply,Pi.smul_apply] at * + rw [h1,h3,h2,h4] + cont := (Lp.LpToLpOfMeasureLeSMul hc h).continuous + +lemma dominatedComplexL2_ae (hc : c≠⊤) (h : ν≤c•«μ») (f : Lp ℂ 2 «μ») : + dominatedComplexL2 hc h f=ᵐ[ν]f := + Lp.coeFn_LpToLpOfMeasureLeSMul hc h f + +lemma dominatedComplexL2_norm_le (hc : c≠⊤) (h : ν≤c•«μ») (f : Lp ℂ 2 «μ») : + ‖dominatedComplexL2 hc h f‖≤c.toReal^((1:ℝ)/2)*‖f‖ := by + have hb := (Lp.LpToLpOfMeasureLeSMul hc h : Lp ℂ 2 «μ»→L[ℝ]Lp ℂ 2 ν).le_opNorm f + have hn := Lp.norm_LpToLpOfMeasureLeSMul_le (E := ℂ) (p := 2) hc h + apply hb.trans + apply mul_le_mul_of_nonneg_right _ (norm_nonneg _) + simpa only [ENNReal.toReal_div,ENNReal.toReal_one,ENNReal.toReal_ofNat] using hn + +end DominatedComplexL2 + +def kernelCompactMultiplicity (K : Set HyperbolicSpace) (hK : IsCompact K) : ℕ := + (kernelCompact_projection_measure_bound K hK).choose + +lemma kernelCompactMultiplicity_spec (K : Set HyperbolicSpace) (hK : IsCompact K) : + Measure.map (integralOrbitProjection globalKubotaKernel) (hyperbolicVolume.restrict K)≤ + (kernelCompactMultiplicity K hK:ℝ≥0∞) • integralQuotientVolume globalKubotaKernel := + (kernelCompact_projection_measure_bound K hK).choose_spec + +def kernelCompactPullbackCLM (K : Set HyperbolicSpace) (hK : IsCompact K) : + KernelQuotientL2→L[ℂ]Lp ℂ 2 (hyperbolicVolume.restrict K) := + (Lp.compMeasurePreservingₗᵢ ℂ (integralOrbitProjection globalKubotaKernel) + ⟨measurable_integralOrbitProjection _,rfl⟩).toContinuousLinearMap.comp + (dominatedComplexL2 (by simp : (kernelCompactMultiplicity K hK:ℝ≥0∞)≠⊤) + (kernelCompactMultiplicity_spec K hK)) + +theorem kernelCompactPullbackCLM_ae (K : Set HyperbolicSpace) (hK : IsCompact K) + (F : KernelQuotientL2) : + kernelCompactPullbackCLM K hK F=ᵐ[hyperbolicVolume.restrict K] + fun w => F (integralOrbitProjection globalKubotaKernel w) := by + have hm : MeasurePreserving (integralOrbitProjection globalKubotaKernel) + (hyperbolicVolume.restrict K) + (Measure.map (integralOrbitProjection globalKubotaKernel) (hyperbolicVolume.restrict K)) := + ⟨measurable_integralOrbitProjection _,rfl⟩ + have he := dominatedComplexL2_ae + (by simp : (kernelCompactMultiplicity K hK:ℝ≥0∞)≠⊤) (kernelCompactMultiplicity_spec K hK) F + exact (Lp.coeFn_compMeasurePreserving _ hm).trans (hm.quasiMeasurePreserving.ae_eq_comp he) + +lemma whittaker_bound_integrable_finite («μ» : Measure ℝ) [IsFiniteMeasure «μ»] + (b : ℝ) (hb : 1 (1+‖p.2‖^2)^(-b)) («μ».prod volume) := by + have hk : Integrable (fun z : ℂ => (1+‖z‖^2)^(-b)) := by + convert (hyperbolicKernel_integrable (b:ℂ) hb).norm using 1 + funext z + simp only [hyperbolicKernel,Complex.norm_cpow_eq_rpow_re_of_pos + (by positivity : 0<1+‖z‖^2),Complex.neg_re,Complex.ofReal_re] + have hv : Integrable (fun _ : ℝ => (1:ℝ)) «μ» := integrable_const _ + simpa only [one_mul] using hv.mul_prod hk + +lemma scaledWhittakerIntegrand_integrable («μ» : Measure ℝ) [IsFiniteMeasure «μ»] + (ρ : BoundedContinuousFunction ℝ ℂ) (c : ℝ) (freq s : ℂ) (hs : 1 ρ p.1*whittakerIntegrand freq s (c*p.1,p.2)) («μ».prod volume) := by + apply ((whittaker_bound_integrable_finite «μ» s.re hs).const_mul ‖ρ‖).mono' + · exact ((ρ.continuous.comp continuous_fst).mul + ((whittakerIntegrand_continuous freq s).comp (by fun_prop))).aestronglyMeasurable + · exact Eventually.of_forall (fun p => by + rw [norm_mul] + exact mul_le_mul (ρ.norm_coe_le_norm p.1) + (whittakerIntegrand_norm_bound freq s (c*p.1,p.2) s.re (by linarith) le_rfl) + (norm_nonneg _) (norm_nonneg _)) + +lemma scaledWhittakerProduct_differentiableAt («μ» : Measure ℝ) [IsFiniteMeasure «μ»] + (ρ : BoundedContinuousFunction ℝ ℂ) (c : ℝ) (freq s : ℂ) (hs : 1 ∫p : ℝ × ℂ,ρ p.1*whittakerIntegrand freq w (c*p.1,p.2)∂«μ».prod volume) s := by + let b : ℝ := (s.re+1)/2 + let ε : ℝ := (s.re-1)/4 + have hb : 1 ρ p.1*whittakerIntegrand freq w (c*p.1,p.2)) + (F' := fun w (p : ℝ × ℂ) => ρ p.1*whittakerIntegrandDeriv freq w (c*p.1,p.2)) + (bound := fun p => ‖ρ‖*(ε⁻¹*(1+‖p.2‖^2)^(-b))) hU + (Eventually.of_forall (fun w => + ((ρ.continuous.comp continuous_fst).mul + ((whittakerIntegrand_continuous freq w).comp (by fun_prop))).aestronglyMeasurable)) + (scaledWhittakerIntegrand_integrable «μ» ρ c freq s hs) + ((ρ.continuous.comp continuous_fst).mul + ((whittakerIntegrandDeriv_continuous freq s).comp (by fun_prop))).aestronglyMeasurable + (Eventually.of_forall (fun p w hw => by + rw [norm_mul] + exact mul_le_mul (ρ.norm_coe_le_norm p.1) + (whittakerIntegrandDeriv_norm_bound freq w (c*p.1,p.2) b ε (by linarith) hε hw.le) + (norm_nonneg _) (norm_nonneg _))) + (((whittaker_bound_integrable_finite «μ» b hb).const_mul ε⁻¹).const_mul ‖ρ‖) + (Eventually.of_forall (fun p w _ => + (whittakerIntegrand_hasDerivAt freq w (c*p.1,p.2)).const_mul (ρ p.1))) + exact h.2.differentiableAt + +lemma whittakerIntegrand_scale (c v : ℝ) (hc : 0 by + dsimp only + calc + _ = ρ v*(((5/a:ℝ):ℂ)^(s+1)*whittakerIntegrand (freq/(5/a:ℝ)) s ((5/a)*v,z)) := by ring + _ = _ := by rw [whittakerIntegrand_scale (5/a) v (by positivity) hvp hcv freq s z]; ring) + _ = _ := integral_const_mul _ _ + +theorem cuspWeightedWhittakerInterval_differentiableAt (ρ : BoundedContinuousFunction ℝ ℂ) + (a b : ℝ) (ha : 0 ∫v in Set.Icc a b,ρ v*(v:ℂ)^(-w-1)*sourceFourierKernel w (freq*v)) s := by + have hc : ((5/a:ℝ):ℂ)≠0 := by exact_mod_cast (show (5/a:ℝ)≠0 by positivity) + have hd := ((differentiableAt_id.add_const (1:ℂ)).const_cpow (Or.inl hc)).mul + (scaledWhittakerProduct_differentiableAt (volume.restrict (Set.Icc a b)) ρ (5/a) (freq/(5/a:ℝ)) s hs) + apply hd.congr_of_eventuallyEq + filter_upwards [(isOpen_lt continuous_const Complex.continuous_re).mem_nhds hs] with w hw + exact (scaledWhittakerProduct_eq_average ρ a b ha freq w hw).symm + +end + +open Filter MeasureTheory +open scoped BigOperators Classical Topology InnerProductSpace ComplexConjugate MatrixGroups ENNReal +open Finset AddChar MulChar EisensteinEmbedding + +local notation "O" => ActualEisensteinCubic.O + +def cuspWeightedFourierPhase (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (w : HyperbolicSpace) : ℂ := + ρ (hyperbolicHeight w)*cuspFourierPhase h w + +lemma cuspWeightedFourierPhase_continuous (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) : + Continuous (cuspWeightedFourierPhase ρ h) := + (ρ.continuous.comp hyperbolicHeight_continuous).mul (cuspFourierPhase_continuous h) + +lemma cuspWeightedFourierPhase_bound (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (w : HyperbolicSpace) : + ‖cuspWeightedFourierPhase ρ h w‖≤‖ρ‖ := by + rw [cuspWeightedFourierPhase,norm_mul,cuspFourierPhase_norm,mul_one] + exact ρ.norm_coe_le_norm _ + +lemma cuspWeightedFourierTest_memLp (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) : + MemLp (fun w => star (cuspWeightedFourierPhase ρ h w)) 2 + (hyperbolicVolume.restrict (cuspPeriodStrip 5 6)) := by + apply MemLp.of_bound (cuspWeightedFourierPhase_continuous ρ h).star.aestronglyMeasurable ‖ρ‖ + exact Eventually.of_forall (fun w => by rw [norm_star]; exact cuspWeightedFourierPhase_bound ρ h w) + +def cuspWeightedFourierTestL2 (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) : CuspStripL2 := + (cuspWeightedFourierTest_memLp ρ h).toLp (fun w => star (cuspWeightedFourierPhase ρ h w)) + +def kernelCuspWeightedFourier (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) : KernelQuotientL2→L[ℂ]ℂ := + (innerSL ℂ (cuspWeightedFourierTestL2 ρ h)).comp kernelCuspPullback + +lemma kernelCuspWeightedFourier_integral (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (F : KernelQuotientL2) : + kernelCuspWeightedFourier ρ h F=∫w in cuspPeriodStrip 5 6, + F (integralOrbitProjection globalKubotaKernel w)*cuspWeightedFourierPhase ρ h w∂hyperbolicVolume := by + change inner ℂ (cuspWeightedFourierTestL2 ρ h) (kernelCuspPullback F)=_ + rw [L2.inner_def] + apply integral_congr_ae + filter_upwards [MemLp.coeFn_toLp (cuspWeightedFourierTest_memLp ρ h),kernelCuspPullback_ae_eq F] with w hw hp + rw [RCLike.inner_apply,cuspWeightedFourierTestL2,hw,hp] + simp only [starRingEnd_apply,star_star] + +lemma kernelCuspWeightedFourier_restrict (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (F : KernelQuotientL2) : + kernelCuspWeightedFourier ρ h (kernelMassRestrictionCLM kernelCuspAverageCompact + kernelCuspAverageCompact_isCompact.measurableSet F)=kernelCuspWeightedFourier ρ h F := by + rw [kernelCuspWeightedFourier_integral,kernelCuspWeightedFourier_integral] + have hm := kernelProjection_cuspPeriodStrip_measurePreserving 5 6 (by norm_num) + have he := hm.quasiMeasurePreserving.ae_eq_comp (ae_restrict_of_ae + (kernelMassRestriction_coe kernelCuspAverageCompact kernelCuspAverageCompact_isCompact.measurableSet F) + (s := kernelCuspStripSet)) + apply integral_congr_ae + filter_upwards [he,ae_restrict_mem (cuspPeriodStrip_measurable 5 6)] with w hw hwm + exact congrArg (fun z : ℂ => z*cuspWeightedFourierPhase ρ h w) + (hw.trans (Set.indicator_of_mem (kernelCuspStripSet_subset_compact ⟨w,hwm,rfl⟩) _)) + +def kernelCuspWeightedFourierFamily (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) (s : ℂ) : ℂ := + kernelCuspWeightedFourier ρ h + (kernelLocalCorrectedSeed kernelCuspAverageCompact kernelCuspAverageCompact_isCompact + 2 3 (by norm_num) (by norm_num) s) + +lemma kernelCuspWeightedFourierFamily_meromorphicAt (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) : + MeromorphicAt (kernelCuspWeightedFourierFamily ρ h) (4/3:ℂ) := + meromorphicAt_clm (kernelCuspWeightedFourier ρ h) + (kernelLocalCorrectedSeed_meromorphicAt kernelCuspAverageCompact kernelCuspAverageCompact_isCompact + 2 3 (by norm_num) (by norm_num)) + +lemma kernelCuspWeightedFourierFamily_analyticAt_nonreal (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) + (s : ℂ) (hs : s.re≠1) (hi : s.im≠0) : + AnalyticAt ℂ (kernelCuspWeightedFourierFamily ρ h) s := by + exact (ContinuousLinearMap.analyticAt (𝕜 := ℂ) (E := KernelQuotientL2) (F := ℂ) + (kernelCuspWeightedFourier ρ h) _).comp_of_eq + (kernelLocalCorrectedSeed_analyticAt_nonreal kernelCuspAverageCompact + kernelCuspAverageCompact_isCompact 2 3 (by norm_num) (by norm_num) s hs hi) rfl + +lemma kernelCuspWeightedFourierFamily_residue_limit (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) : + Tendsto (fun s : ℂ => (s-4/3)*kernelCuspWeightedFourierFamily ρ h s) + (𝓝[≠] (4/3:ℂ)) (𝓝 (kernelCuspWeightedFourier ρ h cubicEisensteinResidue)) := by + have hh := (kernelCuspWeightedFourier ρ h).continuous.continuousAt.tendsto.comp + (cubicEisensteinResidue_local_limit kernelCuspAverageCompact kernelCuspAverageCompact_isCompact) + simpa only [Function.comp_def,map_smul,smul_eq_mul,kernelCuspWeightedFourier_restrict, + kernelCuspWeightedFourierFamily] using hh + +lemma kernelCuspWeightedFourierFamily_initial (ρ : BoundedContinuousFunction ℝ ℂ) (h : ActualEisensteinCubic.O) + (s : ℂ) (hs : 4 hyperbolicEisenstein s w*cuspWeightedFourierPhase ρ h w + have hg : Continuous g := (hyperbolicEisenstein_continuous s hs).mul (cuspWeightedFourierPhase_continuous ρ h) + rw [cuspPeriodStrip_integral_coordinates g hg.aestronglyMeasurable (cuspCoordinateLift_weighted_integrable g hg)] + have hexp : ∀v∈Set.Icc (5:ℝ) 6, + ((∫z in periodDomain,g (cuspCoordinateLift (v,z)))/(v:ℂ)^3)= + (((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h)* + (ρ v*((v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v))) := by + intro v hv + have hpos : 0 by ring) + rw [hrearr,eisensteinFourierCoefficient] + congr 1 + exact (div_mul_cancel₀ _ cusp_volume_ne_zero).symm + rw [hinner,eisensteinFourierCoefficient_formula v hpos s hs h,ite_eq_right hh,zero_add] + have hv0 : (v:ℂ)≠0 := Complex.ofReal_ne_zero.mpr hpos.ne' + have hp : (v:ℂ)^(-s-1)=(v:ℂ)^(2-s)/(v:ℂ)^3 := by + rw [show -s-1=(2-s)-3 by ring,Complex.cpow_sub _ _ hv0] + congr 1 + exact Complex.cpow_natCast _ 3 + rw [hp] + ring + calc + _ = ∫v in Set.Icc (5:ℝ) 6,(((9*Real.sqrt 3/2:ℝ):ℂ)*scatteringCoefficient s h)* + (ρ v*((v:ℂ)^(-s-1)*sourceFourierKernel s (cuspFrequency h*v))) := + setIntegral_congr_fun measurableSet_Icc hexp + _ = _ := integral_const_mul _ _ + +lemma kernelCuspWeightedFourierFamily_initial_factor (ρ : BoundedContinuousFunction ℝ ℂ) + (h : ActualEisensteinCubic.O) (hh : h≠0) (s : ℂ) (hs : 4 + (Real.exp (-Real.pi * normForm (a + L * n.1) (b + L * n.2) * t) : ℂ)) + (∑ e : Fin 2, (parityPair a b L hL e).f t) := by + let F : Fin 2 × (ℤ × ℤ) → ℝ := fun p => + Real.exp (-Real.pi * (L ^ 2 * (p.2.1 + xShift a b L p.1) ^ 2 + + (3 * L ^ 2) * (p.2.2 + yShift b L p.1) ^ 2) * t) + have hsum (e : Fin 2) : HasSum (fun n : ℤ × ℤ => (F (e, n) : ℂ)) + ((parityPair a b L hL e).f t) := + rectangularPair_hasSum (xShift a b L e) (yShift b L e) (L ^ 2) (3 * L ^ 2) (sq_pos_of_pos hL) + (mul_pos (by norm_num) (sq_pos_of_pos hL)) ht + have hreal (e : Fin 2) : Summable (fun n : ℤ × ℤ => F (e, n)) := + Complex.summable_ofReal.mp (hsum e).summable + have hF : Summable F := + (summable_prod_of_nonneg (fun _ => (Real.exp_pos _).le)).2 + ⟨hreal, (hasSum_fintype _).summable⟩ + have hFC : Summable (fun p => (F p : ℂ)) := Complex.summable_ofReal.mpr hF + have hid (p : Fin 2 × (ℤ × ℤ)) : + Real.exp (-Real.pi * normForm + (a + L * (parityEquiv.symm p).1) (b + L * (parityEquiv.symm p).2) * t) = F p := by + change Real.exp (-Real.pi * normForm + (a + L * ((p.2.1 + p.2.2 : ℤ) : ℝ)) + (b + L * ((p.2.2 * 2 + (p.1 : ℕ) : ℤ) : ℝ)) * t) = _ + push_cast + rw [show (p.2.2 : ℝ) * 2 = 2 * p.2.2 from mul_comm _ _] + rw [normForm_parity a b L hL.ne'] + apply parityEquiv.symm.hasSum_iff.mp + change HasSum (fun p : Fin 2 × (ℤ × ℤ) => + (Real.exp (-Real.pi * normForm (a + L * (parityEquiv.symm p).1) + (b + L * (parityEquiv.symm p).2) * t) : ℂ)) _ + simp_rw [hid] + convert hFC.hasSum using 1 + rw [hFC.tsum_prod, tsum_fintype] + exact (Finset.sum_congr rfl (fun e _ => (hsum e).tsum_eq)).symm + +theorem cosetTheta_eq_parity_sum (a b L : ℝ) (hL : 0 < L) {t : ℝ} (ht : 0 < t) : + cosetTheta a b L t = ∑ e : Fin 2, (parityPair a b L hL e).f t := + (cosetTheta_hasSum a b L hL ht).tsum_eq + +@[simp] theorem parityPair_k (a b L : ℝ) (hL : 0 < L) (e : Fin 2) : + (parityPair a b L hL e).k = 1 := rectangularPair_k _ _ _ _ _ _ + +def cosetConstant (a b L : ℝ) (hL : 0 < L) : ℂ := + ∑ e : Fin 2, (parityPair a b L hL e).f₀ + +theorem parityPair_f₀ (a b L : ℝ) (hL : 0 < L) (e : Fin 2) : + (parityPair a b L hL e).f₀ = + (if (xShift a b L e : UnitAddCircle) = 0 then 1 else 0) * + (if (yShift b L e : UnitAddCircle) = 0 then 1 else 0) := rfl + +theorem cosetConstant_eq (a b L : ℝ) (hL : 0 < L) + (ha₀ : 0 ≤ a) (haL : a < L) (hb₀ : 0 ≤ b) (hbL : b < L) : + cosetConstant a b L hL = if a = 0 ∧ b = 0 then 1 else 0 := by + have htwo : 0 < 2 * L := by positivity + have hy1 : yShift b L 1 ∈ Set.Ico (0 : ℝ) 1 := by + simp only [yShift, Fin.val_one, Nat.cast_one, mul_one, Set.mem_Ico] + constructor + · positivity + · apply (div_lt_one htwo).2 + linarith + have hy1pos : 0 < yShift b L 1 := by + simp only [yShift, Fin.val_one, Nat.cast_one, mul_one] + exact div_pos (by linarith) htwo + have hy1ne : (yShift b L 1 : UnitAddCircle) ≠ 0 := by + intro h + have := (AddCircle.coe_eq_zero_iff_of_mem_Ico hy1).mp h + linarith + have hy0 : yShift b L 0 ∈ Set.Ico (0 : ℝ) 1 := by + simp only [yShift, Fin.val_zero, Nat.cast_zero, mul_zero, add_zero, Set.mem_Ico] + constructor + · positivity + · apply (div_lt_one htwo).2 + linarith + have hy0iff : (yShift b L 0 : UnitAddCircle) = 0 ↔ b = 0 := by + rw [AddCircle.coe_eq_zero_iff_of_mem_Ico hy0] + simp [yShift, div_eq_zero_iff, hL.ne'] + rw [cosetConstant, Fin.sum_univ_two, parityPair_f₀, parityPair_f₀, + ite_eq_right hy1ne, mul_zero, add_zero] + by_cases hb : b = 0 + · subst b + rw [ite_eq_left (hy0iff.mpr rfl), mul_one] + have hx : xShift a 0 L 0 = a / L := by + simp only [xShift, sub_zero, Fin.val_zero, Nat.cast_zero, mul_zero] + field_simp + have hxmem : a / L ∈ Set.Ico (0 : ℝ) 1 := + ⟨div_nonneg ha₀ hL.le, (div_lt_one hL).2 haL⟩ + have hxiff : (xShift a 0 L 0 : UnitAddCircle) = 0 ↔ a = 0 := by + rw [hx, AddCircle.coe_eq_zero_iff_of_mem_Ico hxmem] + simp [div_eq_zero_iff, hL.ne'] + simp only [hxiff, and_true] + · rw [ite_eq_right (fun h => hb (hy0iff.mp h)), mul_zero, ite_eq_right (fun h => hb h.2)] + +def completedCoset (a b L : ℝ) (hL : 0 < L) (s : ℂ) : ℂ := + ∑ e : Fin 2, (parityPair a b L hL e).Λ s + +theorem completedCoset_differentiableAt (a b L : ℝ) (hL : 0 < L) + {s : ℂ} (hs₀ : s ≠ 0) (hs₁ : s ≠ 1) : + DifferentiableAt ℂ (completedCoset a b L hL) s := by + apply DifferentiableAt.fun_sum + intro e _ + exact rectangularPair_differentiableAt (xShift a b L e) (yShift b L e) + (L ^ 2) (3 * L ^ 2) _ _ hs₀ hs₁ + +end SevenEighths.EisensteinTheta + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Endpoint.lean b/lean/OAI/NumberTheory/DirichletL/Endpoint.lean new file mode 100644 index 0000000000000000000000000000000000000000..1d15f7d40e8a6da1913732fae92e62f30f163270 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Endpoint.lean @@ -0,0 +1,113 @@ +import Mathlib.Basic.Real.Basic +import Mathlib.Tactic.Linarith +import Mathlib.Tactic.NormNum +import Mathlib.Tactic.FieldSimp +import Mathlib.Tactic.Ring +import Mathlib.Tactic.Positivity + +namespace OAI + +namespace SevenEighths.Endpoint + +noncomputable section + +def denominator (y : ℝ) : ℝ := (37 + 34 * y) / 18 + +def primeWeight (y : ℝ) : ℝ := (7 + 18 * y + 8 * y ^ 2) / 9 + +def balanceDenominator (δ y : ℝ) : ℝ := + (5 / 6 - δ) * denominator y + δ * primeWeight y + +def certificateWeight (y : ℝ) : ℝ := 51 + 41 * y + +def balancedCutoff (δ y : ℝ) : ℝ := + 1 + δ * primeWeight y / (2 * balanceDenominator δ y) + +def balancedRowCount (δ y : ℝ) : ℝ := + 1 - 5 / 6 + (5 / 6 - δ) * balancedCutoff δ y + +def balancedExponent (δ y : ℝ) : ℝ := + -(1 / 48) + (2 / 3) * δ + δ * (1 / 2 - y) / 6 - + (13 / 16) * (1 - balancedRowCount δ y) + +theorem denominator_bounds {y : ℝ} (hy0 : 0 ≤ y) (hy1 : y ≤ 1 / 2) : + 7 / 9 ≤ denominator y ∧ denominator y ≤ 3 := by + dsimp [denominator] + constructor <;> linarith + +theorem primeWeight_bounds {y : ℝ} (hy0 : 0 ≤ y) (hy1 : y ≤ 1 / 2) : + 7 / 9 ≤ primeWeight y ∧ primeWeight y ≤ 2 := by + have hs := sq_nonneg y + have ht := mul_nonneg hy0 (sub_nonneg.mpr hy1) + dsimp [primeWeight] + constructor <;> nlinarith + +theorem balanceDenominator_bounds {δ y : ℝ} + (hδ0 : 0 ≤ δ) (hδ1 : δ ≤ 5 / 6) (hy0 : 0 ≤ y) (hy1 : y ≤ 1 / 2) : + 35 / 54 ≤ balanceDenominator δ y ∧ balanceDenominator δ y ≤ 5 / 2 := by + obtain ⟨hd0, hd1⟩ := denominator_bounds hy0 hy1 + obtain ⟨hp0, hp1⟩ := primeWeight_bounds hy0 hy1 + have ha : 0 ≤ 5 / 6 - δ := sub_nonneg.mpr hδ1 + have hl1 := mul_le_mul_of_nonneg_left hd0 ha + have hl2 := mul_le_mul_of_nonneg_left hp0 hδ0 + have hu1 := mul_le_mul_of_nonneg_left hd1 ha + have hu2 := mul_le_mul_of_nonneg_left (le_trans hp1 (by norm_num : (2 : ℝ) ≤ 3)) hδ0 + dsimp [balanceDenominator] + constructor <;> nlinarith + +theorem endpoint_identity (δ y : ℝ) (hJ : balanceDenominator δ y ≠ 0) : + 10368 * certificateWeight y * balanceDenominator δ y * (-balancedExponent δ y) = + (3 + 5 * y) * ((4 * certificateWeight y * δ - 79) ^ 2 + 49) + + 4 * y * (4 * certificateWeight y * δ * + ((1 + 3 * y) * (15 + 32 * y) * δ + 9 - 13 * y) + 265 + 3485 * y) := by + unfold balancedExponent balancedRowCount balancedCutoff + field_simp + simp only [balanceDenominator, denominator, primeWeight, certificateWeight] + ring + +theorem balanced_endpoint_margin {δ y : ℝ} + (hδ0 : 0 ≤ δ) (hδ1 : δ ≤ 5 / 6) (hy0 : 0 ≤ y) (hy1 : y ≤ 1 / 2) : + (49 : ℝ) / 440640 ≤ -balancedExponent δ y := by + obtain ⟨hJlo, hJhi⟩ := balanceDenominator_bounds hδ0 hδ1 hy0 hy1 + have hJpos : 0 < balanceDenominator δ y := by linarith + have hvpos : 0 < certificateWeight y := by dsimp [certificateWeight]; linarith + have hinner : 0 ≤ (1 + 3 * y) * (15 + 32 * y) * δ + 9 - 13 * y := by + have hp : 0 ≤ (1 + 3 * y) * (15 + 32 * y) * δ := by positivity + linarith + have hrest : 0 ≤ 4 * y * (4 * certificateWeight y * δ * + ((1 + 3 * y) * (15 + 32 * y) * δ + 9 - 13 * y) + 265 + 3485 * y) := by + positivity + have hsq : 0 ≤ (3 + 5 * y) * (4 * certificateWeight y * δ - 79) ^ 2 := by + positivity + have hid := endpoint_identity δ y (ne_of_gt hJpos) + have hcert : 49 * (3 + 5 * y) ≤ + 10368 * certificateWeight y * balanceDenominator δ y * (-balancedExponent δ y) := by + nlinarith only [hid, hrest, hsq] + have hvhi : certificateWeight y ≤ 17 * (3 + 5 * y) := by + dsimp [certificateWeight] + linarith + have hscaled : 49 * certificateWeight y ≤ + 176256 * certificateWeight y * balanceDenominator δ y * (-balancedExponent δ y) := by + nlinarith only [hcert, hvhi] + have hcancel : 49 ≤ 176256 * balanceDenominator δ y * (-balancedExponent δ y) := by + nlinarith only [hscaled, hvpos] + have hEpos : 0 < -balancedExponent δ y := by + by_contra hn + have hn' : -balancedExponent δ y ≤ 0 := le_of_not_gt hn + have hp := mul_nonpos_of_nonneg_of_nonpos (le_of_lt hJpos) hn' + nlinarith only [hcancel, hp] + have hup := mul_le_mul_of_nonneg_right hJhi (le_of_lt hEpos) + nlinarith only [hcancel, hup] + +theorem balanced_endpoint_strict {δ y : ℝ} + (hδ0 : 0 ≤ δ) (hδ1 : δ ≤ 5 / 6) (hy0 : 0 ≤ y) (hy1 : y ≤ 1 / 2) : + balancedExponent δ y < -(1 / 10000 : ℝ) := by + have h := balanced_endpoint_margin hδ0 hδ1 hy0 hy1 + norm_num at * + linarith + +end + +end SevenEighths.Endpoint + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/ActiveChildRestoration.lean b/lean/OAI/NumberTheory/DirichletL/Energy/ActiveChildRestoration.lean new file mode 100644 index 0000000000000000000000000000000000000000..41231aadc228b3823ee0621b72d4630d33793499 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/ActiveChildRestoration.lean @@ -0,0 +1,87 @@ +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary +import OAI.NumberTheory.DirichletL.Moments.RadialEligibleEnergy + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.CenteredMomentEnergyActiveChildRestoration +open ConcretePrimeRowBridge +open HeckeFamily CenteredMomentCommonRadialData CenteredMomentCommonAllocationSum +open CenteredMomentCommonProfile CenteredMomentCommonHeightEnvelope +open CenteredMomentFirstAnnularInput CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentDivisorAllocation CenteredMomentDivisorRetained +open CenteredMomentRetainedEnergy CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy CenteredMomentCommonMaskEnergy +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α] +local instance {β:Type*}:DecidableEq β:=Classical.decEq _ + +theorem allocated_row_active (s:Input α)(C R:Ideal O) + (B:actualAllocations (activeInput s).pools C)(τ:Character)(v:ℝ) + (D:Ideal O)(a:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (z:O)(W₁ W₂:ℝ→ℂ)(X₁ X₂:ℝ): + let d : CenteredMomentEligibleEnergy.Data (CenteredMomentCommonProfile.liveIndices B.val) := + commonData (withHeight (activeInput s) τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools] using B.property⟩ + let e : CenteredMomentEligibleEnergy.Data (CenteredMomentCommonProfile.liveIndices B.val) := + commonData (withHeight s τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools, restoreAllocation_val] + using (restoreAllocation s C B).property⟩ + allocatedPositiveRow d.η d.m d.A z d.t d.slots d.coefficient d.P D a W₁ W₂ X₁ X₂= + allocatedPositiveRow e.η e.m e.A z e.t e.slots e.coefficient e.P D a W₁ W₂ X₁ X₂ := by + change positiveSlotRow τ + (CenteredMomentSecondHeightFamily.fixedBadMask * idealGenerator (R * C)) 1 z + (dilated W₁ (clipDilation (X₁ / Ideal.absNorm (CenteredMomentDivisorRectangle.selectedPlain D a 0)))) + (dilated W₂ (clipDilation (X₂ / Ideal.absNorm (CenteredMomentDivisorRectangle.selectedPlain D a 1)))) + (fun i : CenteredMomentDivisorRaw.liveIndices D a => (activeInput s).slots i.val.val) + (fun i => (activeInput s).toData.coefficient i.val.val) + (fun i => (activeInput s).P i.val.val) v _ _ = + positiveSlotRow τ + (CenteredMomentSecondHeightFamily.fixedBadMask * idealGenerator (R * C)) 1 z + (dilated W₁ (clipDilation (X₁ / Ideal.absNorm (CenteredMomentDivisorRectangle.selectedPlain D a 0)))) + (dilated W₂ (clipDilation (X₂ / Ideal.absNorm (CenteredMomentDivisorRectangle.selectedPlain D a 1)))) + (fun i : CenteredMomentDivisorRaw.liveIndices D a => s.slots i.val.val) + (fun i => s.toData.coefficient i.val.val) + (fun i => s.P i.val.val) v _ _ + unfold positiveSlotRow + congr 2 + apply Finset.prod_congr rfl + intro i _ + have hz (f : Ideal O → ℂ) : heightCoefficient f 0 = f := by + funext I + simp [heightCoefficient] + simpa only [hz] using rowSlot_active s i.val.val τ + (CenteredMomentSecondHeightFamily.fixedBadMask * idealGenerator (R * C)) 1 z v 0 + +theorem child_energy_active (s:Input α)(C R:Ideal O) + (B:actualAllocations (activeInput s).pools C)(τ:Character)(v:ℝ) + (D:Ideal O)(a:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (rad:Radial): + let d : CenteredMomentEligibleEnergy.Data (CenteredMomentCommonProfile.liveIndices B.val) := + commonData (withHeight (activeInput s) τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools] using B.property⟩ + let e : CenteredMomentEligibleEnergy.Data (CenteredMomentCommonProfile.liveIndices B.val) := + commonData (withHeight s τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools, restoreAllocation_val] + using (restoreAllocation s C B).property⟩ + childEnergy d rad D a = childEnergy e rad D a := by + dsimp only + unfold childEnergy + apply tsum_congr + intro z + exact congrArg₂ (fun x y : ℂ => rad.weight z * (‖x‖ ^ 2 + ‖y‖ ^ 2)) + (allocated_row_active s C R B τ v D a z s.W₁ s.W₂ + (s.X₁ / Ideal.absNorm (B.val (Sum.inr 0))) + (s.X₂ / Ideal.absNorm (B.val (Sum.inr 1)))) + (allocated_row_active s C R B τ v D a z s.W₁ s.W₂ + (s.Y₁ / Ideal.absNorm (B.val (Sum.inr 0))) + (s.Y₂ / Ideal.absNorm (B.val (Sum.inr 1)))) + +end SevenEighths.CenteredMomentEnergyActiveChildRestoration + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedBound.lean b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..6fb6a0013fdb2b9ddf0c18b5f6aed5a520fc334e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedBound.lean @@ -0,0 +1,45 @@ +import OAI.NumberTheory.DirichletL.Energy.AllocatedChildren + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.CenteredMomentEnergyAllocatedChildren +open HeckeFamily CenteredMomentAllocatedNaturalSource CenteredMomentAllocatedNaturalRadial +open CenteredMomentCommonRadialData CenteredMomentCommonHeightEnvelope +open CenteredMomentCommonAllocationSum CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentNaturalRowSource CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +theorem actual_common_from_energy (b M:α→ℝ)(hM:∀i,0≤M i)(ε:ℝ)(hε:0<ε): + ∃C₀:ℝ,0(support_prime (R*C) I ((Finset.mem_powerset.mp hD₁) hi)).ne_zero) + (fun I hi=>(support_prime (R*C) I ((Finset.mem_powerset.mp hD₂) hi)).ne_zero)] + exact he true D₁ hD₁ D₂ hD₂ J hJ + · intro D₁ hD₁ D₂ hD₂ J hJ + rw [commonChild_energy s τ v C R B L a V₁ V₂ r hz false D₁ D₂ J + (fun I hi=>(support_prime (R*C) I ((Finset.mem_powerset.mp hD₁) hi)).ne_zero) + (fun I hi=>(support_prime (R*C) I ((Finset.mem_powerset.mp hD₂) hi)).ne_zero)] + exact he false D₁ hD₁ D₂ hD₂ J hJ + +end SevenEighths.CenteredMomentEnergyAllocatedChildren + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedChildren.lean b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedChildren.lean new file mode 100644 index 0000000000000000000000000000000000000000..a33e197a65c45d422939117bace00fe994917d43 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedChildren.lean @@ -0,0 +1,154 @@ +import OAI.NumberTheory.DirichletL.Energy.ChildState +import OAI.NumberTheory.DirichletL.Moments.AllocatedNaturalRadial +import OAI.NumberTheory.DirichletL.Moments.NaturalFixedRaySourceFiber +import OAI.NumberTheory.DirichletL.Moments.DetectorDictionaryUniformTests +import OAI.NumberTheory.DirichletL.Moments.RayMaskedFloorSlots + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.CenteredMomentEnergyAllocatedChildren +open HeckeFamily HeckeDyadic ConcreteTraceCRT +open CenteredMomentNaturalRowSource CenteredMomentNaturalFixedRaySource +open CenteredMomentCommonMaskExpansion CenteredMomentCommonMaskEnergy +open CenteredMomentAllocatedNaturalSource CenteredMomentAllocatedNaturalRadial +open CenteredMomentDetectorDictionary CenteredMomentHeckeSlots CenteredMomentWholeSlotDeletion +open CenteredMomentSecondHeightFamily CenteredMomentHeckeHeight +open CenteredMomentOriginalRadialComparison CenteredMomentInductionEnergy +open CenteredMomentCommonRadialData CenteredMomentCommonHeightEnvelope +open CenteredMomentRadialEligibleEnergy (Radial) +local notation "O"=>HeckeFamily.O + +variable {α:Type*}[Fintype α][DecidableEq α] + +lemma natural_product_eq_positive {η:Character}{z:O}(F:NaturalRow η z) + (W₁ W₂:ℝ→ℂ)(pool:α→Finset (Ideal O))(β:α→Ideal O→ℂ)(P:α→ℝ) + (X₁ X₂:ℝ)(hX₁:0polynomial (naturalCharacter η z) false W₁ X₁ 0 0* + polynomial (naturalCharacter η z) false W₂ X₂ 0 0* + ∏i,naturalSlot (naturalCharacter η z) (pool i) (β i) (P i)) + r.keep r.profile r.scale= + CenteredMomentInductionEnergy.energy η + (fixedBadMask*ConcretePrimeRowBridge.idealGenerator 1) 1 0 W₁ W₂ pool β P + X₁ X₂ r.keep r.profile r.scale:=by + unfold radialEnergy CenteredMomentInductionEnergy.energy + apply tsum_congr + intro z + by_cases hk:r.keep z + · simp only [ite_eq_left hk,naturalCharacter_eq η z (hz z hk)] + rw [natural_product_eq_positive (naturalRow η z (hz z hk)) W₁ W₂ pool β P X₁ X₂ hX₁ hX₂ hP] + · simp only [ite_eq_right hk] + +omit [Fintype α] in +lemma natural_subset_radial_eq_energy (η:Character)(r:Radial)(hz:∀z,r.keep z→z≠0) + (F:Finset α)(W₁ W₂:ℝ→ℂ)(pool:α→Finset (Ideal O))(β:α→Ideal O→ℂ)(P:α→ℝ) + (X₁ X₂:ℝ)(hX₁:0polynomial (naturalCharacter η z) false W₁ X₁ 0 0* + polynomial (naturalCharacter η z) false W₂ X₂ 0 0* + ∏i∈F,naturalSlot (naturalCharacter η z) (pool i) (β i) (P i)) + r.keep r.profile r.scale= + CenteredMomentInductionEnergy.energy η + (fixedBadMask*ConcretePrimeRowBridge.idealGenerator 1) 1 0 W₁ W₂ + (fun i:F=>pool i) (fun i:F=>β i) (fun i:F=>P i) X₁ X₂ r.keep r.profile r.scale:=by + have hh:=natural_radial_eq_energy (α:=F) η r hz W₁ W₂ + (fun i:F=>pool i) (fun i:F=>β i) (fun i:F=>P i) X₁ X₂ hX₁ hX₂ + (fun i=>hP i i.property) + have hp (z:O):(∏i:F,naturalSlot (naturalCharacter η z) (pool i) (β i) (P i))= + ∏i∈F,naturalSlot (naturalCharacter η z) (pool i) (β i) (P i):= + Finset.prod_coe_sort F (fun i:α=>naturalSlot (naturalCharacter η z) (pool i) (β i) (P i)) + simp_rw [hp] at hh + exact hh + +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentDivisorRetained +open CenteredMomentRetainedProfile CenteredMomentCommonAllocationSum + +def allocatedEnergy (η:Character)(r:Radial)(D:Ideal O) + (a:Allocation D (Finset.univ:Finset (α⊕Fin 2))) (V₁ V₂:Plain) + (pool:α→Finset (Ideal O))(β:α→Ideal O→ℂ)(P:α→ℝ) + (t X₁ X₂:ℝ)(hX₁:0pool i) (fun i:↥(liveIndices D a\J)=>heightCoefficient (β i) t) + (fun i:↥(liveIndices D a\J)=>P i) + (clippedScale (rawScale D a X₁ 0)/(Ideal.absNorm (∏I∈D₁,I):ℝ)) + (clippedScale (rawScale D a X₂ 1)/(Ideal.absNorm (∏I∈D₂,I):ℝ)) + r.keep r.profile r.scale + +lemma child_radial_eq_energy (η:Character)(r:Radial)(hz:∀z,r.keep z→z≠0) + (D:Ideal O)(a:Allocation D (Finset.univ:Finset (α⊕Fin 2))) (V₁ V₂:Plain) + (pool:α→Finset (Ideal O))(β:α→Ideal O→ℂ)(P:α→ℝ)(hP:∀i,0

child (α:=α) (naturalCharacter η z) D a V₁ V₂ pool β P + t X₁ X₂ hX₁ hX₂ D₁ D₂ J) r.keep r.profile r.scale= + allocatedEnergy η r D a V₁ V₂ pool β P t X₁ X₂ hX₁ hX₂ D₁ D₂ J:=by + have hd₁:0<(Ideal.absNorm (∏I∈D₁,I):ℝ):=by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr (Finset.prod_ne_zero_iff.mpr hD₁)) + have hd₂:0<(Ideal.absNorm (∏I∈D₂,I):ℝ):=by + exact_mod_cast Nat.pos_of_ne_zero (Ideal.absNorm_eq_zero_iff.not.mpr (Finset.prod_ne_zero_iff.mpr hD₂)) + exact natural_subset_radial_eq_energy η r hz (liveIndices D a\J) + (V₁.profile (rawScale D a X₁ 0) (rawScale_pos D a X₁ hX₁ 0) t) + (V₂.profile (rawScale D a X₂ 1) (rawScale_pos D a X₂ hX₂ 1) t) + pool (fun i=>heightCoefficient (β i) t) P + (clippedScale (rawScale D a X₁ 0)/(Ideal.absNorm (∏I∈D₁,I):ℝ)) + (clippedScale (rawScale D a X₂ 1)/(Ideal.absNorm (∏I∈D₂,I):ℝ)) + (div_pos (by unfold clippedScale;positivity) hd₁) + (div_pos (by unfold clippedScale;positivity) hd₂) (fun i _=>hP i) + +def commonAllocatedEnergy (s:Input α)(τ:Character)(v:ℝ)(C R:Ideal O) + (B:actualAllocations s.pools C)(D:Ideal O) + (a:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (V₁ V₂:Plain)(r:Radial)(left:Bool)(D₁ D₂:Finset (Ideal O)) + (J:Finset (CenteredMomentCommonProfile.liveIndices B.val)):ℝ:= + let d:=commonData (withHeight s τ v) C R B + if left then allocatedEnergy τ r D a V₁ V₂ d.slots d.coefficient d.P + v d.X₁ d.X₂ d.X₁_pos d.X₂_pos D₁ D₂ J + else allocatedEnergy τ r D a V₁ V₂ d.slots d.coefficient d.P + v d.Y₁ d.Y₂ d.Y₁_pos d.Y₂_pos D₁ D₂ J + +lemma commonChild_energy (s:Input α)(τ:Character)(v:ℝ)(C R:Ideal O) + (B:actualAllocations s.pools C)(D:Ideal O) + (a:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (V₁ V₂:Plain)(r:Radial)(hz:∀z,r.keep z→z≠0)(left:Bool)(D₁ D₂:Finset (Ideal O)) + (J:Finset (CenteredMomentCommonProfile.liveIndices B.val)) + (hD₁:∀I∈D₁,I≠0)(hD₂:∀I∈D₂,I≠0): + radialEnergy (fun z=>commonChild s τ v C R B D a V₁ V₂ left z D₁ D₂ J) + r.keep r.profile r.scale=commonAllocatedEnergy s τ v C R B D a V₁ V₂ r left D₁ D₂ J:=by + let d:=commonData (withHeight s τ v) C R B + cases left + · exact child_radial_eq_energy τ r hz D a V₁ V₂ d.slots d.coefficient d.P d.P_pos + v d.Y₁ d.Y₂ d.Y₁_pos d.Y₂_pos D₁ D₂ J hD₁ hD₂ + · exact child_radial_eq_energy τ r hz D a V₁ V₂ d.slots d.coefficient d.P d.P_pos + v d.X₁ d.X₂ d.X₁_pos d.X₂_pos D₁ D₂ J hD₁ hD₂ + +end SevenEighths.CenteredMomentEnergyAllocatedChildren + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedClipped.lean b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedClipped.lean new file mode 100644 index 0000000000000000000000000000000000000000..6c99bac4cfa1042f096666478d727beef9377a42 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedClipped.lean @@ -0,0 +1,120 @@ +import OAI.NumberTheory.DirichletL.Energy.AllocatedPaid +import OAI.NumberTheory.DirichletL.Energy.AllocatedZero + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyAllocatedClipped +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +def pair (D:Ideal O)(alloc:Allocation D (Finset.univ:Finset (α⊕Fin 2))) + {a b:ℝ}(ha:0pool i) + (fun i:↥(liveIndices D alloc\J)=>CenteredMomentCommonMaskEnergy.heightCoefficient (β i) v) + (fun i:↥(liveIndices D alloc\J)=>P i) + (scale D alloc X₁ 0 F₁) (scale D alloc X₂ 1 F₂) + st.radial.keep st.radial.profile st.radial.scale:=by + simp only [allocatedEnergy,pair,retainedPair,scale,NaturalState.mask,hunit, + Matrix.cons_val_zero,Matrix.cons_val_one] + +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_clipped_paid_bands (W:ℝ→ℂ)(aslot bslot Mcap bΦ Lslot εremove lo hi κ:ℝ) + (ha:0HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_clipped_homogeneous_bands (W:ℝ→ℂ)(aslot bslot Mcap bΦ Lslot εremove lo hi κ:ℝ) + (a b:ℝ)(haPlain:0 HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_allocated_paid_bands (W:ℝ→ℂ)(aslot bslot Mcap bΦ Lslot εremove lo hi κ:ℝ) + (ha:0d.slots i.val) + (fun i:remaining src C B D alloc J=>CenteredMomentCommonMaskEnergy.heightCoefficient (d.coefficient i.val) v) + (fun i:remaining src C B D alloc J=>d.P i.val) + X₁ X₂ st.radial.keep st.radial.profile st.radial.scale ≤ + Cc*(C₀+C₁)*diagonalControl st.radial.profile*(p.control S)^2* + (1+(|v|+height))^(dc+degree)* + Z^(st.width+εchild+εremove+ + CenteredMomentLiveCapacity.excess (originalImage src C B D alloc J) w + (length Z X₁) (length Z X₂) st.width κ/6+κ*mesh) := by + obtain ⟨dc,Cc,hCc,hbound⟩:=actual_paid_bands (α:=α) M H hH W aslot bslot Mcap bΦ Lslot + εremove lo hi κ ha hWs hW hMcap hbΦ hLs hε hbeta hκ + refine ⟨dc,Cc,hCc,?_⟩ + intro η₀ θ + obtain ⟨Z₀,hZ₀,hbound⟩:=hbound η₀ θ + refine ⟨Z₀,hZ₀,?_⟩ + intro Z hZ a b Bmask L εchild Q hQM degree S C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq + src hmatch C R B D alloc J st hunit hQ hs p X₁ X₂ hX₁ hX₂ hc₁ hc₂ + dsimp only + rw [common_energy hmatch st.character v C R B D alloc J st.mask 1 + (p.profile 0) (p.profile 1) X₁ X₂ st.radial.keep st.radial.profile st.radial.scale] + have he:=hbound Z hZ a b Bmask L εchild Q hQM degree S C₀ C₁ hC₀ hC₁ hzero hpos + (originalImage src C B D alloc J) w σ (fun i=>v+freq i) 0 (|v|+height) mesh + hmesh hw hwm hwL hσlo hσhi (add_nonneg (abs_nonneg _) hheight) + (fun i=>(abs_add_le _ _).trans (add_le_add le_rfl (hfreq i))) + st hunit hQ hs p X₁ X₂ hX₁ hX₂ hc₁ hc₂ + simpa only [abs_zero,add_zero] using he + +end SevenEighths.CenteredMomentEnergyAllocatedPaid + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedProfiles.lean b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedProfiles.lean new file mode 100644 index 0000000000000000000000000000000000000000..a58761373d852ab43bbbf8c577a5c3876c4ca6cc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/AllocatedProfiles.lean @@ -0,0 +1,35 @@ +import OAI.NumberTheory.DirichletL.Energy.Profiles + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +namespace SevenEighths.CenteredMomentEnergyAllocatedProfiles +open CenteredMomentFiniteProfileExceptional + +def retainedPair (a b:ℝ)(ha:0(sourcePlain a b ha (p.profile i) (p.support i)).profile (U i) (hU i) t + support:=fun i=>sourcePlain_support a b ha (p.profile i) (p.support i) (U i) (hU i) t + +theorem retained_pair_control (a b:ℝ)(ha:0HeckeFamily.O + +variable {α:Type*}[Fintype α][DecidableEq α] + +lemma allocatedScale_le (D:Ideal O) + (a:Allocation D (Finset.univ:Finset (α⊕Fin 2)))(X:ℝ)(hX:0by + have hi:=Finset.mem_sdiff.mp i.property + exact hi.2 hi.1⟩ + simp only [allocatedEnergy,energy,CenteredMomentCoreFloor.zeroEnergy, + CenteredMomentCoreFloor.zeroRow,positiveSlotRow,Fintype.prod_empty,mul_one] + +theorem empty_from_zeroAt (lo hi Z Bmask bΦ L Mcap ε:ℝ)(hlo:0 HeckeFamily.O +variable {ι:Type*} [Fintype ι] +local instance {α:Type*}:DecidableEq α:=Classical.decEq _ + +lemma ball_support : Function.support (ballProfile:ℝ→ℂ)⊆Set.Iic (2:ℝ) := by + intro x hx + by_cases h:0≤x + · exact (ballProfile_support_upper x h hx).le + · exact (lt_of_not_ge h).le.trans (by norm_num) + +theorem actual_ball_witness (η:Character)(t:ℝ)(S:Finset (Ideal O))(β:Ideal O→ℂ) + (C D:Ideal O)(hC:Supported C)(hD:Supported D)(U:Finset (CommonIndex C D)) + (R:ℝ)(rows:Finset O)(W:𝓢(ℝ,ℂ))(K:ℝ)(n:Fin 4→ℤ) + (hne:physicalBlock η t S β C D hC hD U R rows W K n≠0) : + ∃z:O,z≠0 ∧ ballProfile (normValue z/dyadicScale (n 1))=1 := by + obtain ⟨z,_,hz,hz0,_⟩:=physicalBlock_live_dyadic_witness η t S β C D hC hD U R rows W K n hne + refine ⟨z,hz0,ballProfile_one _ (div_nonneg (normValue_pos z hz0).le (dyadicScale_pos _).le) ?_⟩ + exact (div_le_one (dyadicScale_pos _)).mpr (dyadicRows_norm rows n z hz).2.le + +def geometry (N:ℕ)(b:ℝ):ℝ := (b^N)^2 + +lemma geometry_pos (N:ℕ)(b:ℝ)(hb:1≤b):0 ring + +lemma error_nominal_cap (N:ℕ)(b:ℝ)(hb:1≤b)(s:Input ι) + (hc:Fintype.card ι≤N)(hs:s.upper≤b)(C R:Ideal O)(B:actualAllocations s.pools C) + (τ:Character)(t:ℝ)(hne:frozenCoefficient B.val C R s.ν s.W s.P≠0) + (Q:Ideal O)(hQ:Q≠0)(k:ℕ) + (hslot:∀i,∀I∈(activeInput (child s C R B τ t)).slots i,IsCoprime Q I) + (Bp:actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ:Character)(v K:ℝ)(hK:0P.val) E}) K V)) + (Real.logb Z (C.absNorm:ℝ)) σ δ reserve + +def errorRadius (C D:Ideal O)(E:Finset (CommonIndex C D))(K V Z σ δ reserve:ℝ)(p:O)(k:ℕ):ℝ := + errorCommonRadius Z (Real.logb Z (D.absNorm:ℝ)) + (Real.logb Z (firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K V)) + (Real.logb Z (C.absNorm:ℝ)) σ δ reserve p k + +lemma mainRadius_eq (C D:Ideal O)(hC:Supported C)(hD:Supported D) + (hCD:primeSupport C=primeSupport D)(E:Finset (CommonIndex C D))(K V Z σ δ reserve:ℝ): + mainRadius C D E K V Z σ δ reserve= + mainCommonRadius Z (Real.logb Z ((commonPart D C).absNorm:ℝ)) + (nominalLog C D (∏P∈E,P.val) K V Z) + (Real.logb Z ((commonPart C D).absNorm:ℝ)) σ δ reserve := by + rw [commonPart_eq_left C D hC.1 hCD,commonPart_eq_left D C hD.1 hCD.symm] + simp only [mainRadius,nominalLog,primeSubsetGenerator,span_idealGenerator] + +lemma errorRadius_eq (C D:Ideal O)(hC:Supported C)(hD:Supported D) + (hCD:primeSupport C=primeSupport D)(E:Finset (CommonIndex C D))(K V Z σ δ reserve:ℝ)(p:O)(k:ℕ): + errorRadius C D E K V Z σ δ reserve p k= + errorCommonRadius Z (Real.logb Z ((commonPart D C).absNorm:ℝ)) + (nominalLog C D (∏P∈E,P.val) K V Z) + (Real.logb Z ((commonPart C D).absNorm:ℝ)) σ δ reserve p k := by + rw [commonPart_eq_left C D hC.1 hCD,commonPart_eq_left D C hD.1 hCD.symm] + simp only [errorRadius,nominalLog,primeSubsetGenerator,span_idealGenerator] + +def threshold (N:ℕ)(b σ:ℝ)(hb:1≤b)(hσ:0<σ):ℝ := + fixedWidthThreshold 2 (geometry N b) σ (by norm_num) (geometry_pos N b hb) hσ + +lemma threshold_gt_one (N:ℕ)(b σ:ℝ)(hb:1≤b)(hσ:0<σ):1P.val) E*activeConductor C D}) + (K δ reserve ξ q Mparent:ℝ)(hK:0P.val) E*activeConductor C D}) + (p:O)(hp:p≠0)(k:ℕ)(hk:k=0∨k=5∨k=6) + (hslot:∀i,∀I∈(activeInput (child s C R B τ t)).slots i,IsCoprime (Ideal.span {p}) I) + (Bp:actualAllocations (activeInput (child s C R B τ t)).pools ((Ideal.span {p})^(k+1))) + (υ:Character)(χ₀:RayCharacter)(v:ℝ) + (hN:υ.modulus.absNorm≤radicalBound (childCharacter τ χ₀) fixedBadMask p (errorMovingExponent k)) + (K δ reserve ξ q Mparent:ℝ)(hK:0 HeckeFamily.O +variable {α : Type*} [Fintype α] +local instance {β : Type*} : DecidableEq β := Classical.decEq _ + +lemma active_pools_subset (s : Input α) (j : α⊕Fin 2) : + (activeInput s).pools j⊆s.pools j := by + cases j with + | inl i => exact Finset.filter_subset _ _ + | inr j => exact Finset.Subset.refl _ + +lemma actualAllocations_mono {β : Type*} [Fintype β] + (S T : β→Finset (Ideal O)) (h : ∀i,S i⊆T i) (C : Ideal O) : + actualAllocations S C⊆actualAllocations T C := by + intro B hB + obtain ⟨hlabel,hprod⟩ := Finset.mem_filter.mp hB + obtain ⟨v,hv,hvB⟩ := Finset.mem_image.mp hlabel + refine Finset.mem_filter.mpr ⟨Finset.mem_image.mpr ⟨v,?_,hvB⟩,hprod⟩ + exact Fintype.mem_piFinset.mpr (fun i=>h i (Fintype.mem_piFinset.mp hv i)) + +abbrev restoreAllocation (s : Input α) (C : Ideal O) + (B : actualAllocations (activeInput s).pools C) : actualAllocations s.pools C := + ⟨B.val,actualAllocations_mono _ _ (active_pools_subset s) C B.property⟩ + +@[simp] lemma restoreAllocation_val (s : Input α) (C : Ideal O) + (B : actualAllocations (activeInput s).pools C) : (restoreAllocation s C B).val=B.val := rfl + +lemma restoreAllocation_injective (s : Input α) (C : Ideal O) : + Function.Injective (restoreAllocation s C) := by + intro B D h + exact Subtype.ext (congrArg (fun x : actualAllocations s.pools C=>x.val) h) + +lemma child_active (s : Input α) (C R : Ideal O) + (B : actualAllocations (activeInput s).pools C) (τ : Character) (t : ℝ) : + child (activeInput s) C R B τ t= + activeInput (child s C R (restoreAllocation s C B) τ t) := rfl + +lemma active_coefficient (s : Input α) (i : α) : + (activeInput s).toData.coefficient i=s.toData.coefficient i := rfl + +lemma rowSlot_active (s : Input α) (i : α) (η : Character) (m A z : O) (t v : ℝ) : + rowSlot η m A z ((activeInput s).slots i) + (heightCoefficient ((activeInput s).toData.coefficient i) v) t= + rowSlot η m A z (s.slots i) (heightCoefficient (s.toData.coefficient i) v) t := by + unfold rowSlot + apply Finset.sum_subset (Finset.filter_subset _ _) + intro I hI hn + have hz : s.W i ((I.absNorm:ℝ)/s.P i)=0 := by + by_contra hh + exact hn (Finset.mem_filter.mpr ⟨hI,hh⟩) + simp only [heightCoefficient,Data.coefficient,activeInput,hz,mul_zero,zero_mul] + +lemma positive_active (s : Input α) (η : Character) (m A z : O) + (W₁ W₂ : ℝ→ℂ) (t v X₁ X₂ : ℝ) : + positiveSlotRow η m A z W₁ W₂ (activeInput s).slots + (fun i=>heightCoefficient ((activeInput s).toData.coefficient i) v) + (activeInput s).P t X₁ X₂= + positiveSlotRow η m A z W₁ W₂ s.slots + (fun i=>heightCoefficient (s.toData.coefficient i) v) s.P t X₁ X₂ := by + unfold positiveSlotRow + congr 2 + exact Finset.prod_congr rfl (fun i _=>rowSlot_active s i η m A z t v) + +theorem energy_active (s : Input α) (η : Character) (m A : O) + (W₁ W₂ : ℝ→ℂ) (t v X₁ X₂ : ℝ) (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + energy η m A t W₁ W₂ (activeInput s).slots + (fun i=>heightCoefficient ((activeInput s).toData.coefficient i) v) + (activeInput s).P X₁ X₂ keep Φ K= + energy η m A t W₁ W₂ s.slots + (fun i=>heightCoefficient (s.toData.coefficient i) v) s.P X₁ X₂ keep Φ K := by + unfold energy + apply tsum_congr + intro z + rw [positive_active] + +theorem positive_active_restrict {κ : Type*} [Fintype κ] (s : Input α) (f : κ→α) + (η : Character) (m A z : O) (W₁ W₂ : ℝ→ℂ) (t v X₁ X₂ : ℝ) : + positiveSlotRow η m A z W₁ W₂ (fun i=>(activeInput s).slots (f i)) + (fun i=>heightCoefficient ((activeInput s).toData.coefficient (f i)) v) + (fun i=>(activeInput s).P (f i)) t X₁ X₂= + positiveSlotRow η m A z W₁ W₂ (fun i=>s.slots (f i)) + (fun i=>heightCoefficient (s.toData.coefficient (f i)) v) + (fun i=>s.P (f i)) t X₁ X₂ := by + unfold positiveSlotRow + congr 2 + exact Finset.prod_congr rfl (fun i _=>rowSlot_active s (f i) η m A z t v) + +theorem energy_active_restrict {κ : Type*} [Fintype κ] (s : Input α) (f : κ→α) + (η : Character) (m A : O) (W₁ W₂ : ℝ→ℂ) (t v X₁ X₂ : ℝ) + (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + energy η m A t W₁ W₂ (fun i=>(activeInput s).slots (f i)) + (fun i=>heightCoefficient ((activeInput s).toData.coefficient (f i)) v) + (fun i=>(activeInput s).P (f i)) X₁ X₂ keep Φ K= + energy η m A t W₁ W₂ (fun i=>s.slots (f i)) + (fun i=>heightCoefficient (s.toData.coefficient (f i)) v) + (fun i=>s.P (f i)) X₁ X₂ keep Φ K := by + unfold energy + apply tsum_congr + intro z + rw [positive_active_restrict] + +theorem common_energy_active (s : Input α) (C R : Ideal O) + (B : actualAllocations (activeInput s).pools C) (τ : Character) (v : ℝ) + (L : Ideal O) + (a : CenteredMomentDivisorAllocation.Allocation L (Finset.univ : Finset (liveIndices B.val⊕Fin 2))) + (J : Finset (liveIndices B.val)) (m A : O) (W₁ W₂ : ℝ→ℂ) (X₁ X₂ : ℝ) + (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + let d : CenteredMomentEligibleEnergy.Data (liveIndices B.val) := + commonData (withHeight (activeInput s) τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools] using B.property⟩ + let e : CenteredMomentEligibleEnergy.Data (liveIndices B.val) := + commonData (withHeight s τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools, restoreAllocation_val] + using (restoreAllocation s C B).property⟩ + energy τ m A 0 W₁ W₂ + (fun i:remaining (activeInput s) C B L a J=>d.slots i.val) + (fun i:remaining (activeInput s) C B L a J=>heightCoefficient (d.coefficient i.val) v) + (fun i:remaining (activeInput s) C B L a J=>d.P i.val) X₁ X₂ keep Φ K= + energy τ m A 0 W₁ W₂ + (fun i:remaining s C (restoreAllocation s C B) L a J=>e.slots i.val) + (fun i:remaining s C (restoreAllocation s C B) L a J=>heightCoefficient (e.coefficient i.val) v) + (fun i:remaining s C (restoreAllocation s C B) L a J=>e.P i.val) X₁ X₂ keep Φ K := by + exact energy_active_restrict s + (fun i:remaining (activeInput s) C B L a J=>i.val.val) τ m A W₁ W₂ 0 v X₁ X₂ keep Φ K + +def restoredError (s : Input α) (C R : Ideal O) (B : actualAllocations s.pools C) + (τ : Character) (t : ℝ) (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) : Input (liveIndices Bp.val) := + twiceChild s C R B τ t Q k (restoreAllocation (child s C R B τ t) (Q^k) Bp) υ v + +lemma error_source_active (s : Input α) (C R : Ideal O) (B : actualAllocations s.pools C) + (τ : Character) (t : ℝ) (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) : + child (activeInput (child s C R B τ t)) (Q^k) (R*C) Bp υ v= + activeInput (restoredError s C R B τ t Q k Bp υ v) := rfl + +theorem restoredError_data (s : Input α) (C R : Ideal O) (B : actualAllocations s.pools C) + (τ : Character) (t : ℝ) (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) : + let d:=restoredError s C R B τ t Q k Bp υ v + d.η=υ ∧ d.t=v ∧ d.m=fixedBadMask*ConcretePrimeRowBridge.idealGenerator ((R*C)*(Q^k)) ∧ + d.X₁=s.X₁/(B.val (Sum.inr 0)).absNorm/(Bp.val (Sum.inr 0)).absNorm ∧ + d.X₂=s.X₂/(B.val (Sum.inr 1)).absNorm/(Bp.val (Sum.inr 1)).absNorm ∧ + d.Y₁=s.Y₁/(B.val (Sum.inr 0)).absNorm/(Bp.val (Sum.inr 0)).absNorm ∧ + d.Y₂=s.Y₂/(B.val (Sum.inr 1)).absNorm/(Bp.val (Sum.inr 1)).absNorm := + ⟨rfl,rfl,rfl,rfl,rfl,rfl,rfl⟩ + +theorem error_live_slots (s : Input α) (C R : Ideal O) (B : actualAllocations s.pools C) + (τ : Character) (t : ℝ) (Q : Ideal O) (hQ : Q≠0) (k : ℕ) + (hslot : ∀i,∀I∈(activeInput (child s C R B τ t)).slots i,IsCoprime Q I) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) : + liveIndices Bp.val=Finset.univ := + prime_slots_live (activeInput (child s C R B τ t)) Q hQ k hslot Bp + +theorem restoredError_volume (s : Input α) (C R : Ideal O) (B : actualAllocations s.pools C) + (τ : Character) (t : ℝ) (Q : Ideal O) (hQ : Q≠0) (k : ℕ) + (hslot : ∀i,∀I∈(activeInput (child s C R B τ t)).slots i,IsCoprime Q I) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) : + volume (restoredError s C R B τ t Q k Bp υ v)= + volume s/(CenteredMomentCommonRawScale.rawReduction B.val s.P*(Q.absNorm:ℝ)^k) := by + have hh:=child_volume (activeInput (child s C R B τ t)) Q hQ k hslot (R*C) Bp υ v + rw [error_source_active,active_volume,active_volume,common_volume,div_div] at hh + exact hh + +theorem error_normalized_source (s : Input α) (C R seed : Ideal O) + (B : actualAllocations s.pools C) (τ : Character) (t : ℝ) (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + childNormalizedGaussSource (activeInput (child s C R B τ t)) (Q^k) (R*C) seed Bp υ v Φ K= + normalizedGaussSource (restoredError s C R B τ t Q k Bp υ v) ((R*C)*(Q^k)) seed Φ K := by + unfold childNormalizedGaussSource + rw [error_source_active,active_normalized] + +theorem error_normalized_sum (s : Input α) (C R seed : Ideal O) + (B : actualAllocations s.pools C) (τ : Character) (t : ℝ) (Q : Ideal O) (k : ℕ) + (υ : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)→Character) + (v : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)→ℝ) + (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + (∑Bp:actualAllocations (activeInput (child s C R B τ t)).pools (Q^k), + childNormalizedGaussSource (activeInput (child s C R B τ t)) (Q^k) (R*C) seed Bp (υ Bp) (v Bp) Φ K)= + ∑Bp:actualAllocations (activeInput (child s C R B τ t)).pools (Q^k), + normalizedGaussSource (restoredError s C R B τ t Q k Bp (υ Bp) (v Bp)) ((R*C)*(Q^k)) seed Φ K := + Finset.sum_congr rfl (fun Bp _=>error_normalized_source s C R seed B τ t Q k Bp (υ Bp) (v Bp) Φ K) + +theorem error_energy (s : Input α) (C R : Ideal O) (B : actualAllocations s.pools C) + (τ : Character) (t : ℝ) (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) (W₁ W₂ : ℝ→ℂ) (X₁ X₂ : ℝ) + (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + let e:=child (activeInput (child s C R B τ t)) (Q^k) (R*C) Bp υ v + let d:=restoredError s C R B τ t Q k Bp υ v + energy e.η e.m 1 0 W₁ W₂ e.slots + (fun i=>heightCoefficient (e.toData.coefficient i) e.t) e.P X₁ X₂ keep Φ K= + energy d.η d.m 1 0 W₁ W₂ d.slots + (fun i=>heightCoefficient (d.toData.coefficient i) d.t) d.P X₁ X₂ keep Φ K := by + dsimp only + rw [error_source_active] + exact energy_active (restoredError s C R B τ t Q k Bp υ v) υ + (fixedBadMask*ConcretePrimeRowBridge.idealGenerator ((R*C)*(Q^k))) 1 W₁ W₂ 0 v X₁ X₂ keep Φ K + +section Ray +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) +variable {s : Input α} {η₀ : Character} {θ : α→RayQuotient.Characters M H} + {w σ freq : α→ℝ} {W : ℝ→ℂ} {bslot Z : ℝ} + +theorem matches_child (h : Matches M H hH s η₀ θ w σ freq W bslot Z) + (C R : Ideal O) (B : actualAllocations s.pools C) (τ : Character) (t : ℝ) : + Matches M H hH (child s C R B τ t) η₀ + (fun i=>θ i.val) (fun i=>w i.val) (fun i=>σ i.val) + (fun i=>freq i.val) W bslot Z := by + constructor + · intro i I;exact h.character i.val I + · intro i y;exact h.profile i.val y + · intro i;exact h.pool i.val + · intro i;exact h.scale i.val + +theorem matches_twiceChild (h : Matches M H hH s η₀ θ w σ freq W bslot Z) + (C R : Ideal O) (B : actualAllocations s.pools C) (τ : Character) (t : ℝ) + (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (child s C R B τ t).pools (Q^k)) (υ : Character) (v : ℝ) : + Matches M H hH (twiceChild s C R B τ t Q k Bp υ v) η₀ + (fun i=>θ i.val.val) (fun i=>w i.val.val) (fun i=>σ i.val.val) + (fun i=>freq i.val.val) W bslot Z := + matches_child M H hH (matches_child M H hH h C R B τ t) (Q^k) (R*C) Bp υ v + +theorem active_common_ray_energy (h : Matches M H hH s η₀ θ w σ freq W bslot Z) + (τ : Character) (v : ℝ) (C R : Ideal O) + (B : actualAllocations (activeInput s).pools C) (L : Ideal O) + (a : CenteredMomentDivisorAllocation.Allocation L (Finset.univ : Finset (liveIndices B.val⊕Fin 2))) + (J : Finset (liveIndices B.val)) (m A : O) (W₁ W₂ : ℝ→ℂ) (X₁ X₂ : ℝ) + (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + let d : CenteredMomentEligibleEnergy.Data (liveIndices B.val) := + commonData (withHeight (activeInput s) τ v) C R + ⟨B.val, by simpa only [withHeight, Input.pools] using B.property⟩ + energy τ m A 0 W₁ W₂ + (fun i:remaining (activeInput s) C B L a J=>d.slots i.val) + (fun i:remaining (activeInput s) C B L a J=>heightCoefficient (d.coefficient i.val) v) + (fun i:remaining (activeInput s) C B L a J=>d.P i.val) X₁ X₂ keep Φ K= + energy τ m A 0 W₁ W₂ + (fun i:originalImage s C (restoreAllocation s C B) L a J=>primePool M H bslot (Z^(w i))) + (fun i:originalImage s C (restoreAllocation s C B) L a J=>fun I=> + idealCoeff (relativeCharacter M H hH η₀ (θ i)) I* + HeckePrimeAnnular.annularWeight W (Z^(w i)) (σ i) (v+freq i) I) + (fun i:originalImage s C (restoreAllocation s C B) L a J=>Z^(w i)) X₁ X₂ keep Φ K := + (common_energy_active s C R B τ v L a J m A W₁ W₂ X₁ X₂ keep Φ K).trans + (common_energy h τ v C R (restoreAllocation s C B) L a J m A W₁ W₂ X₁ X₂ keep Φ K) + +theorem restoredError_matches (h : Matches M H hH s η₀ θ w σ freq W bslot Z) + (C R : Ideal O) (B : actualAllocations s.pools C) (τ : Character) (t : ℝ) + (Q : Ideal O) (k : ℕ) + (Bp : actualAllocations (activeInput (child s C R B τ t)).pools (Q^k)) + (υ : Character) (v : ℝ) : + Matches M H hH (restoredError s C R B τ t Q k Bp υ v) η₀ + (fun i=>θ i.val.val) (fun i=>w i.val.val) (fun i=>σ i.val.val) + (fun i=>freq i.val.val) W bslot Z := + matches_twiceChild M H hH h C R B τ t Q k (restoreAllocation (child s C R B τ t) (Q^k) Bp) υ v + +end Ray +end SevenEighths.CenteredMomentEnergyAmplifiedRayDictionary + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/AmplifierFamilyAdmission.lean b/lean/OAI/NumberTheory/DirichletL/Energy/AmplifierFamilyAdmission.lean new file mode 100644 index 0000000000000000000000000000000000000000..4488bfb4faba4f68317757f4aa96d275b1ea9cec --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/AmplifierFamilyAdmission.lean @@ -0,0 +1,55 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedUniform +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPowerBudget +import OAI.NumberTheory.DirichletL.Moments.FirstCommonReferencePower +import OAI.NumberTheory.DirichletL.Moments.FirstMixedMainError +import OAI.NumberTheory.DirichletL.Energy.FirstLiveAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstAnnularAdmission + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +open Filter + +namespace SevenEighths.CenteredMomentEnergyAmplifierFamilyAdmission +open HeckeFamily CanonicalQuadraticSieve ConcreteTraceCRT ActualEisensteinCubic +open CenteredMomentFirstSourceConductorCaps CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentFirstAmplificationChoice +open CenteredMomentFirstPhysicalSource CenteredMomentSecondHeightFamily CenteredMomentChildRows +open CenteredMomentSectorLocalization CenteredMomentFirstAmplifiedFourCoefficients +local notation "O"=>HeckeFamily.O +local instance {ι:Type*}:DecidableEq (ι⊕Fin 2):=Classical.decEq _ + +def referenceCost : ℝ := max 1 rayCost + +lemma referenceCost_ge_one : 1≤referenceCost := le_max_left _ _ + +theorem actual_error_reference_cap (ρ υ:Character)(χ:RayFourExpansion.RayCharacter) + (p:O)(hp:p≠0)(n:ℕ)(hn:n=0 ∨ n=5 ∨ n=6)(Z:ℝ)(hZ:1HeckeFamily.O + +def widenState {Z B b B' b':ℝ}(s:NaturalState Z B b)(hB:B≤B')(hb:b≤b'): + NaturalState Z B' b':= + {s with + puncture_bound:=s.puncture_bound.trans (Real.rpow_le_rpow_of_exponent_le s.base_ge_one hB) + radial_support:=fun _x hx=>le_trans (s.radial_support hx) hb} + +def widenProfiles {a b a' b':ℝ}(p:Profiles a b)(ha:a'≤a)(hb:b≤b'):Profiles a' b' where + profile:=p.profile + support:=fun i _x hx=>⟨ha.trans (p.support i hx).1,(p.support i hx).2.trans hb⟩ + +lemma widenState_width {Z B b B' b':ℝ}(s:NaturalState Z B b)(hB:B≤B')(hb:b≤b'): + (widenState s hB hb).width=s.width:=rfl + +lemma widenProfiles_control {a b a' b':ℝ}(p:Profiles a b)(ha:a'≤a)(hb:b≤b') + (S:Finset (ℕ×ℕ)):(widenProfiles p ha hb).control S=p.control S:=rfl + +lemma profile_control_mono {a b:ℝ}(p:Profiles a b){S T:Finset (ℕ×ℕ)}(hst:S⊆T): + p.control S≤p.control T:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono hst) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hst) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + +theorem zeroAt_transport (Q:Ideal O)(a b radial mask L Mcap eps Z:ℝ) + (a' b' radial' mask' L' Mcap' eps':ℝ) + (J J':ℕ)(S T:Finset (ℕ×ℕ))(C C':ℝ) + (hZ:1≤Z)(ha:a≤a')(hb:b'≤b)(hr:radial'≤radial)(hm:mask'≤mask) + (hL:L'≤L)(hM:Mcap'≤Mcap)(he:eps≤eps')(hJ:J≤J')(hS:S⊆T) + (hC:0≤C)(hCC:C≤C') + (h:ZeroAt Q a b radial mask L Mcap eps Z J S C): + ZeroAt Q a' b' radial' mask' L' Mcap' eps' Z J' T C':=by + intro s hQ hwidth p t X₁ X₂ hX₁ hX₂ hcap₁ hcap₂ + have hcap:Z^L'≤Z^L:=Real.rpow_le_rpow_of_exponent_le hZ hL + have hh:=h (widenState s hm hr) hQ (hwidth.trans hM) (widenProfiles p ha hb) + t X₁ X₂ hX₁ hX₂ (hcap₁.trans hcap) (hcap₂.trans hcap) + change s.plainEnergy p t X₁ X₂≤C*diagonalControl s.radial.profile*(p.control S)^2* + (1+‖t‖)^J*Z^(s.width+eps) at hh + have hp:=profile_control_mono p hS + have hp0:=p.control_nonneg S + have hd:=diagonalControl_nonneg s.radial.profile + have ht:(1+‖t‖)^J≤(1+‖t‖)^J':=pow_le_pow_right₀ (by linarith [norm_nonneg t]) hJ + have hz:Z^(s.width+eps)≤Z^(s.width+eps'):=Real.rpow_le_rpow_of_exponent_le hZ (by linarith) + have hCnew:0≤C':=hC.trans hCC + apply hh.trans + gcongr + +variable {α:Type*}[Fintype α][DecidableEq α] +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +omit [Fintype α] [DecidableEq α] in +theorem positiveAt_transport (W:ℝ→ℂ)(bslot a b radial mask L Lslot lo hi Mcap eps κ Z:ℝ) + (a' b' radial' mask' L' Mcap' eps':ℝ) + (η₀:Character)(Q:Ideal O)(J J':ℕ)(S T:Finset (ℕ×ℕ))(C C':ℝ) + (hZ:1≤Z)(ha:a≤a')(hb:b'≤b)(hr:radial'≤radial)(hm:mask'≤mask) + (hL:L'≤L)(hM:Mcap'≤Mcap)(he:eps≤eps')(hJ:J≤J')(hS:S⊆T) + (hC:0≤C)(hCC:C≤C') + (h:PositiveAt (α:=α) M H hH W bslot a b radial mask L Lslot lo hi Mcap eps κ Z η₀ Q J S C): + PositiveAt (α:=α) M H hH W bslot a' b' radial' mask' L' Lslot lo hi Mcap' eps' κ Z η₀ Q J' T C':=by + intro A θ w σ freq t height hw hwL hσlo hσhi hheight hfreq s hQ hwidth + p X₁ X₂ hX₁ hX₂ hcap₁ hcap₂ hcapacity + have hcap:Z^L'≤Z^L:=Real.rpow_le_rpow_of_exponent_le hZ hL + have hh:=h A θ w σ freq t height hw hwL hσlo hσhi hheight hfreq + (widenState s hm hr) hQ (hwidth.trans hM) (widenProfiles p ha hb) + X₁ X₂ hX₁ hX₂ (hcap₁.trans hcap) (hcap₂.trans hcap) hcapacity + change _≤C*diagonalControl s.radial.profile*(p.control S)^2* + (1+|t|+height)^J*Z^(s.width+eps) at hh + have hp:=profile_control_mono p hS + have hp0:=p.control_nonneg S + have hd:=diagonalControl_nonneg s.radial.profile + have ht:(1+|t|+height)^J≤(1+|t|+height)^J':= + pow_le_pow_right₀ (by linarith [abs_nonneg t]) hJ + have hz:Z^(s.width+eps)≤Z^(s.width+eps'):=Real.rpow_le_rpow_of_exponent_le hZ (by linarith) + have hCnew:0≤C':=hC.trans hCC + apply hh.trans + gcongr + +end SevenEighths.CenteredMomentEnergyBandMonotonicity + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/BandSubtypeTransport.lean b/lean/OAI/NumberTheory/DirichletL/Energy/BandSubtypeTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..7ef86350b55aa2fd4ead5519d998023e2e8f7c15 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/BandSubtypeTransport.lean @@ -0,0 +1,73 @@ +import OAI.NumberTheory.DirichletL.Energy.Bands +import OAI.NumberTheory.DirichletL.Energy.Reindex + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.CenteredMomentEnergyBandSubtypeTransport +open HeckeFamily CenteredMomentEnergyBands CenteredMomentEnergyState +open CenteredMomentNaturalFixedRaySource CenteredMomentInductionEnergy +open CenteredMomentPrimeSlot CenteredMomentEnergyReindex +local notation "O" => HeckeFamily.O +variable {α β : Type*} [Fintype α] [Fintype β] +variable (M : Ideal O) [NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O⧸M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) + +omit [Fintype α] [Fintype β] in +theorem positiveAt_embedding (e : β↪α) + (W : ℝ→ℂ) (bslot a b bΦ Bmask L Lslot lo hi Mcap ε κ Z : ℝ) + (η₀ : Character) (Q : Ideal O) (degree : ℕ) (S : Finset (ℕ×ℕ)) (C : ℝ) + (h : PositiveAt (α:=α) M H hH W bslot a b bΦ Bmask L Lslot lo hi Mcap ε κ Z + η₀ Q degree S C) : + PositiveAt (α:=β) M H hH W bslot a b bΦ Bmask L Lslot lo hi Mcap ε κ Z + η₀ Q degree S C := by + intro T θ w σ v t height hw hwL hσlo hσhi hheight hv s hQ hs p X₁ X₂ + hX₁ hX₂ hcap₁ hcap₂ hcapacity + let E : T≃T.map e := Finset.equivMap e T + let θ' : T.map e→RayQuotient.Characters M H := θ∘E.symm + let w' : T.map e→ℝ := w∘E.symm + let σ' : T.map e→ℝ := σ∘E.symm + let v' : T.map e→ℝ := v∘E.symm + have hsum : (∑i:T.map e,w' i)=∑i:T,w i := E.symm.sum_comp w + have hh := h (T.map e) θ' w' σ' v' t height + (fun i=>hw (E.symm i)) (fun i=>hwL (E.symm i)) + (fun i=>hσlo (E.symm i)) (fun i=>hσhi (E.symm i)) + hheight (fun i=>hv (E.symm i)) s hQ hs p X₁ X₂ hX₁ hX₂ hcap₁ hcap₂ + (by rw [hsum];exact hcapacity) + have he := energy_reindex E s.character s.mask 1 (p.profile 0) (p.profile 1) + (fun i:T.map e=>primePool M H bslot (Z^(w' i))) + (fun (i:T.map e) I=>idealCoeff (relativeCharacter M H hH η₀ (θ' i)) I* + HeckePrimeAnnular.annularWeight W (Z^(w' i)) (σ' i) (v' i) I) + (fun i:T.map e=>Z^(w' i)) t X₁ X₂ s.radial.keep s.radial.profile s.radial.scale + have he' : energy s.character s.mask 1 t (p.profile 0) (p.profile 1) + (fun i:T=>primePool M H bslot (Z^(w i))) + (fun (i:T) I=>idealCoeff (relativeCharacter M H hH η₀ (θ i)) I* + HeckePrimeAnnular.annularWeight W (Z^(w i)) (σ i) (v i) I) + (fun i:T=>Z^(w i)) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale = + energy s.character s.mask 1 t (p.profile 0) (p.profile 1) + (fun i:T.map e=>primePool M H bslot (Z^(w' i))) + (fun (i:T.map e) I=>idealCoeff (relativeCharacter M H hH η₀ (θ' i)) I* + HeckePrimeAnnular.annularWeight W (Z^(w' i)) (σ' i) (v' i) I) + (fun i:T.map e=>Z^(w' i)) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale := by + simpa only [Function.comp_def,θ',w',σ',v',Equiv.symm_apply_apply] using he + exact he'.le.trans hh + +omit [Fintype α] in +theorem positiveAt_subtype (T : Finset α) + (W : ℝ→ℂ) (bslot a b bΦ Bmask L Lslot lo hi Mcap ε κ Z : ℝ) + (η₀ : Character) (Q : Ideal O) (degree : ℕ) (S : Finset (ℕ×ℕ)) (C : ℝ) + (h : PositiveAt (α:=α) M H hH W bslot a b bΦ Bmask L Lslot lo hi Mcap ε κ Z + η₀ Q degree S C) : + PositiveAt (α:=T) M H hH W bslot a b bΦ Bmask L Lslot lo hi Mcap ε κ Z + η₀ Q degree S C := + positiveAt_embedding M H hH ⟨Subtype.val,Subtype.val_injective⟩ W bslot a b bΦ Bmask L + Lslot lo hi Mcap ε κ Z η₀ Q degree S C h + +end SevenEighths.CenteredMomentEnergyBandSubtypeTransport + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/Bands.lean b/lean/OAI/NumberTheory/DirichletL/Energy/Bands.lean new file mode 100644 index 0000000000000000000000000000000000000000..a565218399cadcd62d92fbb47313631847c1ff4f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/Bands.lean @@ -0,0 +1,106 @@ +import OAI.NumberTheory.DirichletL.Energy.Floor +import OAI.NumberTheory.DirichletL.Moments.RayMaskedFloorState + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff +open Filter +namespace SevenEighths.CenteredMomentEnergyBands +open HeckeFamily CenteredMomentEnergyState CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentInductionEnergy +open CenteredMomentPrimeSlot QuadraticInitialBound +local notation "O"=>HeckeFamily.O + +def length (Z X:ℝ):ℝ:=Real.logb Z (max 1 X) + +lemma length_nonneg (Z X:ℝ)(hZ:1primePool M H bslot (Z^(w i))) + (fun i I=>idealCoeff (relativeCharacter M H hH η₀ (θ i)) I* + HeckePrimeAnnular.annularWeight W (Z^(w i)) (σ i) (v i) I) + (fun i=>Z^(w i)) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale≤ + C*diagonalControl s.radial.profile*(p.control S)^2* + (1+|t|+height)^degree*Z^(s.width+ε) + +theorem exists_positive_bottom (W:ℝ→ℂ)(aslot bslot:ℝ)(haslot:0(hC T).le) + dsimp [C₀];linarith + refine ⟨∑T:Finset α,J T,S₀,C₀,hC₀,?_⟩ + intro η₀ + have hall:∀ᶠZ:ℝ in atTop,∀T:Finset α,_:=Filter.eventually_all.mpr (fun T=>hbound T η₀) + filter_upwards [hall,eventually_gt_atTop (1:ℝ)] with Z hZ hZ1 + refine ⟨hZ1,?_⟩ + intro Q hQM T θ w σ v t height hw hwL hσlo hσhi hheight hv s hQ hs p X₁ X₂ hX₁ hX₂ hcap₁ hcap₂ hcapacity + have hslots:6*κ*(∑i,w i)≤s.width:=by + linarith [length_nonneg Z X₁ hZ1,length_nonneg Z X₂ hZ1] + have hh:=hZ T θ w σ v t height hw hwL hσlo hσhi hheight hv Q hQM s hQ hs hslots p X₁ X₂ hX₁ hX₂ + have hsub:S T⊆S₀:=by + intro x hx + exact Finset.mem_biUnion.mpr ⟨T,Finset.mem_univ _,hx⟩ + have hpc:p.control (S T)≤p.control S₀:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono hsub) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hsub) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hc:C T≤C₀:=by + have hh:=Finset.single_le_sum (fun T (_:T∈(Finset.univ:Finset (Finset α)))=>(hC T).le) + (Finset.mem_univ T) + dsimp [C₀];linarith + have hj:J T≤∑T:Finset α,J T:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ T) + have hpow:(1+|t|+height)^(J T)≤(1+|t|+height)^(∑T:Finset α,J T):= + pow_le_pow_right₀ (by linarith [abs_nonneg t]) hj + have hd:=diagonalControl_nonneg s.radial.profile + have hp:=p.control_nonneg S₀ + have hpt:=p.control_nonneg (S T) + apply hh.trans + gcongr +end SevenEighths.CenteredMomentEnergyBands + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAmplifiedColumn.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAmplifiedColumn.lean new file mode 100644 index 0000000000000000000000000000000000000000..a92c682427916b3ae0b5875210298391f15aa83e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAmplifiedColumn.lean @@ -0,0 +1,88 @@ +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedFourCoefficients +import OAI.NumberTheory.DirichletL.Moments.FirstAnnularMajorant + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.CenteredMomentEnergyCanonicalAmplifiedColumn +open HeckeFamily CanonicalQuadraticSieve ConcreteTraceCRT ConcretePrimeRowBridge +open CenteredMomentAmplificationChildInput CenteredMomentCommonRadialData +open CenteredMomentFirstPhysicalSource CenteredMomentCommonAllocationSum +open CenteredMomentFirstCommonReferencePower CenteredMomentFirstAmplifiedFourCoefficients +open CenteredMomentPrimeElements CenteredMomentFirstAmplificationChoice +open CenteredMomentSectorLocalization CenteredMomentSecondChildPowerBudget +open CenteredMomentSourceLiveColumn +local notation "O"=>HeckeFamily.O +local notation "Ray"=>RayFourExpansion.RayCharacter +local instance {ι:Type*}:DecidableEq (ι⊕Fin 2):=Classical.decEq _ + +lemma main_coefficients_nonneg (q Z K ell deficit paid saving r:ℝ) + (hq:0≤q)(hZ:0≤Z)(hK:0≤K):∀j,0≤mainPowers q Z K ell deficit paid saving r j:=by + intro j + fin_cases j <;> simp only [mainPowers,Matrix.cons_val,Fin.reduceFinMk] <;> positivity + +lemma error_coefficients_nonneg (p:O)(k:ℕ)(q Z K deficit paid saving r:ℝ) + (hq:0≤q)(hZ:0≤Z)(hK:0≤K):∀j,0≤errorPowers p k q Z K deficit paid saving r j:=by + intro j + fin_cases j <;> simp only [errorPowers,Matrix.cons_val,Fin.reduceFinMk] <;> positivity + +theorem common_annular_reference_powers (N:ℕ)(a b ε:ℝ)(ha:0H j*mainPowers q Z Kmain ell deficit paid saving rmain j; + let aerror:=fun (p:elementPool P)(i:Fin 3)(χ:Ray)(j:Fin 4)=> + H j*errorPowers p (errorIndex i+1) q Z (Kerror p i χ) deficit paid saving (rerror p i χ) j; + (∀B:actualAllocations s.pools C,frozenCoefficient B.val C R s.ν s.W s.P≠0→ + childNormalizedGaussSource s C R L B τ t CenteredMomentFirstAnnularMajorant.profile H0≤ + (∑j,sourceCoefficients P mainFactor amain aerror (powers ε) j* + (volume (child s C R B τ t))^(powers ε j))* + CenteredMomentFirstChildProfileControl.mass (child s C R B τ t)^2)→ + (commonEnergy (original s R seed) C hC τ t L CenteredMomentFirstAnnularMajorant.profile H0).re≤ + reference q (volume s) (C.absNorm:ℝ) Z allowance* + (Cb*CenteredMomentFirstChildProfileControl.mass s^2* + ∑j,(C.absNorm:ℝ)^ε*(b^N)^(powers ε j)* + averagedCoefficients P mainFactor H + (mainCores q (volume s) (C.absNorm:ℝ) Z allowance Kmain ell deficit paid ε saving rmain) + (fun p i χ=>errorCores p (errorIndex i+1) q (volume s) (C.absNorm:ℝ) + Z allowance (Kerror p i χ) deficit paid ε saving (rerror p i χ)) j):=by + obtain ⟨Cb,hCb,hbound⟩:=common_energy_reference_powers N a b ε ha hb hε + refine ⟨Cb,hCb,?_⟩ + intro ι _ s hc hlo hhi C R seed hC hseed τ t L H0 Z allowance hH0 hZ + P mainFactor H hmain hH Kmain ell deficit paid saving rmain hKmain Kerror rerror hKerror + dsimp only + intro hchildren + have hq:0<(τ.modulus.absNorm:ℝ):=CenteredMomentFirstScale.norm_pos _ τ.modulus_ne_bot + have hNC:0<(C.absNorm:ℝ):=CenteredMomentFirstScale.norm_pos _ hC.1 + have hcoeff:=source_coefficients_nonneg P mainFactor hmain + (fun j=>H j*mainPowers (τ.modulus.absNorm:ℝ) Z Kmain ell deficit paid saving rmain j) + (fun p i χ j=>H j*errorPowers p (errorIndex i+1) (τ.modulus.absNorm:ℝ) Z + (Kerror p i χ) deficit paid saving (rerror p i χ) j) (powers ε) + (fun j=>mul_nonneg (hH j) (main_coefficients_nonneg _ _ _ _ _ _ _ _ hq.le hZ.le hKmain j)) + (fun p i χ j=>mul_nonneg (hH j) (error_coefficients_nonneg _ _ _ _ _ _ _ _ _ + hq.le hZ.le (hKerror p i χ) j)) + have hh:=hbound s hc hlo hhi C R seed hC hseed τ t L + CenteredMomentFirstAnnularMajorant.profile H0 Z allowance hH0 hZ + (fun z=>CenteredMomentFirstAnnularMajorant.profile_nonneg _) 4 _ (powers ε) + hcoeff (powers_nonneg ε hε.le) hchildren + apply hh.trans_eq + unfold reference + congr 2 + apply Finset.sum_congr rfl + intro j _ + exact actual_power_reference_identity P mainFactor b (volume s) (C.absNorm:ℝ) + (τ.modulus.absNorm:ℝ) Z allowance ε N H Kmain ell deficit paid saving rmain Kerror rerror + (volume_pos s) hNC hq hZ j + +end SevenEighths.CenteredMomentEnergyCanonicalAmplifiedColumn + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAmplifiedUniform.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAmplifiedUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..37b988def660b5eada3610597776b1b9ce4c2918 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAmplifiedUniform.lean @@ -0,0 +1,294 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalAmplifiedUniform +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +lemma front_mono {a b:ℝ}(p:Profiles a b)(U V:Finset (ℕ×ℕ))(hUV:U⊆V) + (J K:ℕ)(hJK:J≤K)(c d C₀ C₁ t height:ℝ) + (hc:0≤c)(hcd:c≤d)(hC₀:0≤C₀)(hC₁:0≤C₁)(hh:0≤height): + c*(C₀+C₁+1)*(p.control U)^2*(1+|t|+height)^J≤ + d*(C₀+C₁+1)*(p.control V)^2*(1+|t|+height)^K:=by + have hp:p.control U≤p.control V:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono hUV) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hUV) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hp0:=p.control_nonneg U + have hp1:=p.control_nonneg V + have ht:(1+|t|+height)^J≤(1+|t|+height)^K:= + pow_le_pow_right₀ (by linarith [abs_nonneg t]) hJK + have hd:0≤d:=hc.trans hcd + gcongr + +theorem actual_original_subsets_amplified_power + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + Ready input (R0*C) Kmain Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + normalizedGaussSource input (R0*C) seed CenteredMomentFirstAmplificationChoice.ballProfile Kmain≤ + (∑j,(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|t|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ))* + mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2) ∧ + (∀Aorig:Finset α,∀θ:Aorig→RayQuotient.Characters M H,∀Z:ℝ,Z₀≤Z → + ∀εchild:ℝ,∀C₀ C₁:ℝ,0≤C₀ → 0≤C₁ → + ZeroAt (internalQ Q η₀) (a/max 1 b) b 2 0 L Mcap εchild Z degree S C₀ → + PositiveAt (α:=α) M H hH Wslot bslot (a/max 1 b) b 2 0 L Lslot lo hi + Mcap εchild κ Z η₀ Q degree S C₁ → + ∀(w σ freq:Aorig→ℝ)(height mesh:ℝ),0≤mesh → (∀i,0≤w i) → (∀i,w i≤mesh) → + (∀i,w i≤Lslot) → (∀i,lo≤σ i) → (∀i,σ i≤hi) → 0≤height → (∀i,|freq i|≤height) → + ∀src:Input Aorig,Matches M H hH src η₀ θ w σ freq Wslot bslot Z → + (∀i,src.hi i≤bslot) → (∀i,src.M i≤Mslot) → + (∀i,src.lo i=lows i.val) → (∀i,src.hi i=highs i.val) → + Fintype.card Aorig≤N → lower≤src.lower → src.upper≤upper → + 0≤src.b₁ → 0≤src.b₂ → src.b₁≤max 1 b → src.b₂≤max 1 b → + ∀(C D R0:Ideal O),∀_hC:Supported C,∀_hD:Supported D,primeSupport C=primeSupport D → + ∀(E:Finset (CommonIndex C D))(B:actualAllocations src.pools C)(τ:Character)(t:ℝ), + frozenCoefficient B.val C R0 src.ν src.W src.P≠0 → + τ.modulus=src.η.modulus*Ideal.span {fixedBadMask}*Ideal.span {(72:O)}* + Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E*activeConductor C D} → + ∀K delta reserve asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime (k+1) + Ready input ((R0*C)*(Ideal.span {prime})^(k+1)) Kerror Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + normalizedGaussSource input ((R0*C)*(Ideal.span {prime})^(k+1)) seed + CenteredMomentFirstAmplificationChoice.ballProfile Kerror≤ + (∑j,(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|t|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ))* + CenteredMomentFirstAmplifiedFourCoefficients.errorPowers prime (k+1) + (τ.modulus.absNorm:ℝ) Z Kerror + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2) :=by + obtain ⟨Um,Jm,hm⟩:= + CenteredMomentEnergyCanonicalMainSubsets.actual_original_subsets_main_power (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma cost hsigma hξsmall hcost + obtain ⟨Ue,Je,he⟩:= + CenteredMomentEnergyCanonicalErrorSubsets.actual_original_subsets_error_power (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma cost hsigma hξsmall hcost + refine ⟨Um∪Ue,max Jm Je,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Cm,hCm,Zm,hZm,hmain⟩:=hm η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Ce,hCe,Ze,hZe,herror⟩:=he η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Cm+Ce,add_pos hCm hCe,max Zm Ze,lt_of_lt_of_le hZm (le_max_left _ _),?_,?_⟩ + · + intro Aorig θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + have hg:=hmain Aorig θ Z ((le_max_left _ _).trans hZ) εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + have hfront:=front_mono p Um (Um∪Ue) Finset.subset_union_left Jm (max Jm Je) (le_max_left _ _) + Cm (Cm+Ce) C₀ C₁ t height hCm.le (le_add_of_nonneg_right hCe.le) hC₀ hC₁ hheight + dsimp only at hg ⊢ + have hz:0 simp only [mainPowers,Matrix.cons_val,Fin.reduceFinMk] <;> + try unfold mainCommonRadius + all_goals positivity + · + intro Aorig θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr hN hυ input hinput + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + have hg:=herror Aorig θ Z ((le_max_right _ _).trans hZ) εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr t hN hυ input hinput + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + have hfront:=front_mono p Ue (Um∪Ue) Finset.subset_union_right Je (max Jm Je) (le_max_right _ _) + Ce (Cm+Ce) C₀ C₁ t height hCe.le (le_add_of_nonneg_left hCm.le) hC₀ hC₁ hheight + dsimp only at hg ⊢ + have hz:0 simp only [CenteredMomentFirstAmplifiedFourCoefficients.errorPowers,Matrix.cons_val,Fin.reduceFinMk] <;> + try unfold errorCommonRadius + all_goals positivity + +end SevenEighths.CenteredMomentEnergyCanonicalAmplifiedUniform + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAnnularLower.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAnnularLower.lean new file mode 100644 index 0000000000000000000000000000000000000000..1ece92fe71d85b6d54571b5efa87b31d4d981cb3 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAnnularLower.lean @@ -0,0 +1,133 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalAnnularPower + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.CenteredMomentEnergyCanonicalAnnularLower +open HeckeFamily CanonicalQuadraticSieve CompletedGauss CenteredMomentCanonicalFirst +open CenteredMomentFirstAmplifiedFourCoefficients CenteredMomentFirstAmplificationChoice +open CenteredMomentPrimeElements CenteredMomentSectorLocalization +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentAmplificationChildInput CenteredMomentCommonRadialData +open CenteredMomentCommonAllocationSum CenteredMomentFirstChildProfileControl +open CenteredMomentSecondChildPowerBudget +local notation "O"=>HeckeFamily.O +local notation "Ray"=>RayFourExpansion.RayCharacter +local instance {ι:Type*}:DecidableEq (ι⊕Fin 2):=Classical.decEq _ + +lemma parent_lower_ge {ι:Type*}[Fintype ι](s:Input ι)(Z r:ℝ)(hZ:1 simp only [mainPowers,Matrix.cons_val,Fin.reduceFinMk,le_refl] + exact mul_le_mul_of_nonneg_left (exceptional_cap_antitone Z r s hZ hrs) (Real.rpow_nonneg hK _) + +lemma error_powers_antitone (p:O)(k:ℕ)(q Z K deficit paid saving r s:ℝ) + (hZ:1≤Z)(hK:0≤K)(hrs:r≤s): + ∀j,errorPowers p k q Z K deficit paid saving s j≤errorPowers p k q Z K deficit paid saving r j:=by + intro j + fin_cases j <;> simp only [errorPowers,Matrix.cons_val,Fin.reduceFinMk,le_refl] + exact mul_le_mul_of_nonneg_left (exceptional_cap_antitone Z r s hZ hrs) (Real.rpow_nonneg hK _) + +lemma source_coefficients_mono (P:Finset (Ideal O))(mainFactor:ℝ)(hf:0≤mainFactor) + (am bm:Fin 4→ℝ)(ae be:elementPool P→Fin 3→Ray→Fin 4→ℝ)(alpha:Fin 4→ℝ) + (hm:∀j,am j≤bm j)(he:∀p i χ j,ae p i χ j≤be p i χ j): + ∀j,sourceCoefficients P mainFactor am ae alpha j≤sourceCoefficients P mainFactor bm be alpha j:=by + intro j + unfold sourceCoefficients + apply mul_le_mul_of_nonneg_left _ (by positivity) + apply add_le_add (mul_le_mul_of_nonneg_left (hm j) hf) + apply Finset.sum_le_sum + intro p _ + apply Finset.sum_le_sum + intro i _ + apply mul_le_mul_of_nonneg_left _ + (mul_nonneg (by positivity) (CenteredMomentAmplificationErrorEnergy.localErrorCost_nonneg p (errorIndex i))) + apply Finset.sum_le_sum + intro χ _ + exact mul_le_mul_of_nonneg_right (he p i χ j) + (Real.rpow_nonneg (pow_nonneg (by unfold normValue;positivity) _) _) + +theorem actual_source_coefficients_lower {ι:Type*}[Fintype ι] + (src:Input ι)(P:Finset (Ideal O))(C D:Ideal O)(E:Finset (CommonIndex C D)) + (K Z sigma delta reserve Mamp q deficit paid saving r:ℝ) + (hZ:1fun i:Fin 3=>errorRadius C D E K (volume src) Z sigma delta reserve p (errorIndex i+1); + let oldr:=parentLower src Z-Real.logb Z (C.absNorm:ℝ); + let newr:=r-Real.logb Z (C.absNorm:ℝ); + ∀j,sourceCoefficients P ((Mamp+2*sigma)/(sigma/6)) + (fun j=>Hcoef j*mainPowers q Z Kmain (sigma/3) deficit paid saving oldr j) + (fun p i _χ j=>Hcoef j*errorPowers p (errorIndex i+1) q Z (Kerr p i) deficit paid saving + (oldr-errorRemoval p Z (errorIndex i+1)) j) alpha j≤ + sourceCoefficients P ((Mamp+2*sigma)/(sigma/6)) + (fun j=>Hcoef j*mainPowers q Z Kmain (sigma/3) deficit paid saving newr j) + (fun p i _χ j=>Hcoef j*errorPowers p (errorIndex i+1) q Z (Kerr p i) deficit paid saving + (newr-errorRemoval p Z (errorIndex i+1)) j) alpha j:=by + dsimp only + have hr:=parent_lower_ge src Z r hZ hX₁ hX₂ hY₁ hY₂ + apply source_coefficients_mono P _ (by positivity) + · intro j + exact mul_le_mul_of_nonneg_left (main_powers_antitone q Z _ _ _ _ _ _ _ hZ.le + (by unfold mainRadius CenteredMomentAmplifiedRetainedRadius.mainCommonRadius;positivity) + (sub_le_sub_right hr _) j) (hH j) + · intro p i χ j + exact mul_le_mul_of_nonneg_left (error_powers_antitone p (errorIndex i+1) q Z _ _ _ _ _ _ hZ.le + (by unfold errorRadius CenteredMomentAmplifiedRetainedRadius.errorCommonRadius;positivity) + (sub_le_sub_right (sub_le_sub_right hr _) _) j) (hH j) + +theorem actual_high_annular_sum {ι:Type*}[Fintype ι] + (src:Input ι)(P:Finset (Ideal O))(C D R:Ideal O)(E:Finset (CommonIndex C D)) + (B:actualAllocations src.pools C)(τ:Character)(t:ℝ) + (K Z sigma delta reserve Mamp deficit paid saving Mwidth eps:ℝ) + (hZ:1fun i:Fin 3=>errorRadius C D E K (volume src) Z sigma delta reserve p (errorIndex i+1); + let oldr:=parentLower src Z-Real.logb Z (C.absNorm:ℝ); + let newr:=Mwidth/4-Real.logb Z (C.absNorm:ℝ); + (∑j,sourceCoefficients P ((Mamp+2*sigma)/(sigma/6)) + (fun j=>Hcoef j*mainPowers q Z Kmain (sigma/3) deficit paid saving oldr j) + (fun p i _χ j=>Hcoef j*errorPowers p (errorIndex i+1) q Z (Kerr p i) deficit paid saving + (oldr-errorRemoval p Z (errorIndex i+1)) j) (powers eps) j* + (volume input)^(powers eps j))*mass input^2≤ + (∑j,sourceCoefficients P ((Mamp+2*sigma)/(sigma/6)) + (fun j=>Hcoef j*mainPowers q Z Kmain (sigma/3) deficit paid saving newr j) + (fun p i _χ j=>Hcoef j*errorPowers p (errorIndex i+1) q Z (Kerr p i) deficit paid saving + (newr-errorRemoval p Z (errorIndex i+1)) j) (powers eps) j* + (volume input)^(powers eps j))*mass input^2:=by + dsimp only + have h:=actual_source_coefficients_lower src P C D E K Z sigma delta reserve Mamp + (τ.modulus.absNorm:ℝ) deficit paid saving (Mwidth/4) hZ hsigma hMamp hX₁ hX₂ hY₁ hY₂ + Hcoef hH (powers eps) + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + exact Finset.sum_le_sum (fun j _=>mul_le_mul_of_nonneg_right (h j) + (Real.rpow_nonneg (volume_pos _).le _)) + +end SevenEighths.CenteredMomentEnergyCanonicalAnnularLower + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAnnularPower.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAnnularPower.lean new file mode 100644 index 0000000000000000000000000000000000000000..a6cd098e140d544b9c6518edb58d5bad506b5640 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalAnnularPower.lean @@ -0,0 +1,329 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedUniform +import OAI.NumberTheory.DirichletL.Energy.AmplifierFamilyAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstLiveAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstAnnularAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstRawScaleAdmission +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPowerBudget +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalAnnularPower +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +theorem actual_original_subsets_annular_power + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K H0:ℝ,0P.val) E}) K (volume src)) Z ξ → + 8*H0≤Z^(amplifierCap A 0 ξ) → + ∀(B:actualAllocations src.pools C)(t:ℝ), + frozenCoefficient B.val C R0 src.ν src.W src.P≠0 → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + a0≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + Ready (child src C R0 B τ t) (R0*C) + (mainRadius C D E K (volume src) Z sigma (frequencyLoss Z 32 ξ) reserve) Z ξ (readyBudget A Pcap) → + (∀prime:elementPool P,∀i:Fin 3,∀χ:RayCharacter, + ∀Bp:actualAllocations (activeInput (child src C R0 B τ t)).pools ((Ideal.span {prime.val})^(errorIndex i+1)), + let d:=errorInput src C R0 B τ t (Ideal.span {prime.val}) (errorIndex i+1) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t; + (∀I:Ideal O,coefficient d ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) seed I=0) ∨ + Ready d ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) + (errorRadius C D E K (volume src) Z sigma (frequencyLoss Z 32 ξ) reserve prime (errorIndex i+1)) + Z ξ (readyBudget A Pcap)) → + let input:=child src C R0 B τ t; + let delta:=frequencyLoss Z 32 ξ; + let Bcap:=readyBudget A Pcap; + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + let deficit:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)); + let rmain:=parentLower src Z-Real.logb Z (C.absNorm:ℝ); + let Kmain:=mainRadius C D E K (volume src) Z sigma delta reserve; + let Hcoef:=fun j=>Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|t|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ); + let amain:=fun j=>Hcoef j*mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) deficit paid saving rmain j; + let aerror:=fun (prime:elementPool P)(i:Fin 3)(_χ:RayCharacter)(j:Fin 4)=> + Hcoef j*errorPowers prime (errorIndex i+1) (τ.modulus.absNorm:ℝ) Z + (errorRadius C D E K (volume src) Z sigma delta reserve prime (errorIndex i+1)) + deficit paid saving (rmain-errorRemoval prime Z (errorIndex i+1)) j; + childNormalizedGaussSource src C R0 seed B τ t CenteredMomentFirstAnnularMajorant.profile + H0≤ + (∑j,sourceCoefficients P ((amplifierCap A 0 ξ+2*sigma)/(sigma/6)) amain aerror (powers εsrc) j* + (volume input)^(powers εsrc j))*mass input^2 :=by + let Bcap:=readyBudget A Pcap + have hBcap:0≤Bcap:=readyBudget_nonneg A Pcap hA hPcap + have hAmp:0≤amplifierCap A 0 ξ:=by unfold amplifierCap;positivity + obtain ⟨U,J,huniform⟩:=actual_original_subsets_amplified_power (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma referenceCost hsigma hξsmall referenceCost_ge_one + refine ⟨U,J,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Cbound,hCbound,Zbase,hZbase,hm,he⟩:=huniform η₀ Q hQM hQ0 hQt hQ72 + have hall:=Filter.eventually_all.mpr (fun Aorig:Finset α=> + eventually_original_subsets_power_amplification (Ω:=Aorig) M H hH fixedBadPrimes (Finset.Subset.refl _) + sigma primeLoss (Pcap+A+1) Bseed (amplifierCap A 0 ξ) (max 1 bslot) eta 1 ξ reserve + hsigma hPrimeLoss hAmp (by positivity) heta (by norm_num) hξ.le hreserve) + have hsepEvent:=CenteredMomentFirstAmplificationChoice.eventually_dyadic_amplification.{0} + M H hH fixedBadPrimes (Finset.Subset.refl _) sigma primeLoss (Pcap+A+1) Bseed + (amplifierCap A 0 ξ) (max 1 bslot) eta hsigma hPrimeLoss hAmp heta + obtain ⟨Z₀,hZ₀⟩:=Filter.eventually_atTop.mp + (hall.and (hsepEvent.and (eventually_ge_atTop Zbase))) + refine ⟨Cbound,hCbound,max Z₀ Zbase,lt_of_lt_of_le hZbase (le_max_right _ _),?_⟩ + intro Z hZthreshold + obtain ⟨hamp,hsepdata,hZZbase⟩:= + hZ₀ Z ((le_max_left _ _).trans hZthreshold) + have hZ:1Cbound*(C₀+C₁+1)*(p.control U)^2*(1+|t|+height)^J* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ) + let amain:=fun j=>Hcoef j*mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) deficit paid saving rmain j + let aerror:=fun (prime:elementPool (primePool M H fixedBadPrimes (1/2) 1 (Z^(sigma/3)))) + (i:Fin 3)(χ:RayCharacter)(j:Fin 4)=>Hcoef j* + errorPowers prime (errorIndex i+1) (τ.modulus.absNorm:ℝ) Z + (errorRadius C D E K (volume src) Z sigma delta reserve prime (errorIndex i+1)) + deficit paid saving (rmain-errorRemoval prime Z (errorIndex i+1)) j + have hHcoef:∀j,0≤Hcoef j:=by intro j;dsimp [Hcoef];positivity + have haerror:∀prime i χ j,0≤aerror prime i χ j:=by + intro prime i χ j + apply mul_nonneg (hHcoef j) + fin_cases j <;> simp only [errorPowers,Matrix.cons_val,Fin.reduceFinMk] + all_goals try unfold errorRadius errorCommonRadius + all_goals positivity + have hsupp:∀i,Function.support (input.W i)⊆Set.Iic (max 1 bslot):=by + intro i x hx + exact ((src.support i.val hx).2.trans (hhi i.val)).trans (le_max_right _ _) + let z:CenteredMomentCommonProfile.liveIndices B.val→ℝ:=fun i=>w i.val + have hz:∀i,z i≤eta:=fun i=>hweta i.val + have hlen:∀i,input.P i=Z^(z i):=fun i=>hmatch.scale i.val + obtain ⟨_,_,_,hsep,hdata,_⟩:=hsepdata + have herror:∀prime:elementPool (primePool M H fixedBadPrimes (1/2) 1 (Z^(sigma/3))), + ∀i:Fin 3,∀χ:RayCharacter, + ∀Bp:actualAllocations (activeInput input).pools ((Ideal.span {prime.val})^(errorIndex i+1)), + childNormalizedGaussSource (activeInput input) ((Ideal.span {prime.val})^(errorIndex i+1)) + (R0*C) seed Bp (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) input.t + CenteredMomentFirstAmplificationChoice.ballProfile + (errorRadius C D E K (volume src) Z sigma delta reserve prime (errorIndex i+1))≤ + (∑j,aerror prime i χ j*(volume (child (activeInput input) + ((Ideal.span {prime.val})^(errorIndex i+1)) (R0*C) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) input.t))^(powers εsrc j))* + mass (child (activeInput input) ((Ideal.span {prime.val})^(errorIndex i+1)) (R0*C) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) input.t)^2:=by + intro prime i χ Bp + have hd:=elementPool_data _ (fun Q hQ=>(hdata Q hQ).1) + (fun Q hQ=>(hdata Q hQ).2.1) prime.val prime.property + have hprime:prime.val≠0:=hd.1.ne_zero + have hcop:∀j,∀I∈(activeInput input).slots j,IsCoprime (Ideal.span {prime.val}) I:=by + exact CenteredMomentFirstAmplificationChoice.original_slot_coprime (original input (R0*C) seed).active + Z sigma (max 1 bslot) eta hZ.le (by positivity) hsep z hz hlen hsupp + (original input (R0*C) seed).active_slot + (fun j Q hQ=>input.prime j Q ((original input (R0*C) seed).active_subset _ hQ)) + _ (hdata _ hd.2.1).1 (hdata _ hd.2.1).2.2.1 + have hk:=CenteredMomentFirstAmplificationChoice.errorIndex_cases i + have hk':errorIndex i+1=1∨errorIndex i+1=6∨errorIndex i+1=7:=by omega + have hN:=hυN Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ + have hvcap:=actual_error_reference_cap τ _ χ prime.val hprime (errorIndex i) hk Z hZ hN + have hre:=herrorPacket prime i χ Bp + rcases hre with hdead|hlive + · change normalizedGaussSource _ _ _ _ _≤_ + apply (CenteredMomentFirstSecondInputGates.normalized_zero _ _ _ hdead _ _).le.trans + exact mul_nonneg (Finset.sum_nonneg (fun j _=>mul_nonneg (haerror prime i χ j) + (Real.rpow_nonneg (volume_pos _).le _))) (sq_nonneg _) + · have hlower:=error_minimum_lower src C R0 hC.1 B τ t prime.val hprime + (errorIndex i+1) Bp (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t Z hZ + have hprimeScale: sigma/6≤Real.logb Z (normValue prime.val):=by + have hh:=Real.logb_le_logb_of_le hZ + (Real.rpow_pos_of_pos (zero_lt_one.trans hZ) (sigma/6)) (hdata _ hd.2.1).2.2.1 + simpa only [normValue,Real.logb_rpow (zero_lt_one.trans hZ) hZ.ne'] using hh + have hh:=he Aorig θ Z hZZbase εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve a0 hK ha0 hdelta hreserve.le le_rfl + prime.val hprime (errorIndex i) hk hprimeScale hcop Bp _ χ hN hvcap _ rfl + hlive seed hseed hseedne hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower _ + hlower.1 hlower.2.1 hlower.2.2.1 hlower.2.2.2 + exact hh + have hE:Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}≠0:= + Ideal.span_singleton_eq_bot.not.mpr (primeSubsetGenerator_ne_zero _ _) + have hann:=henergy Aorig (CenteredMomentCommonProfile.liveIndices B.val) input rfl hsupp z hz hlen + (R0*C) seed (mul_ne_zero hR0 hC.1) hseedne hRcommon hseedcap + (Real.logb Z (D.absNorm:ℝ)) (Real.logb Z (C.absNorm:ℝ)) C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) hE K (volume src) _ + hK (volume_pos src) (by simp only [one_mul];exact le_rfl) H0 hH0 houter hHcap + amain aerror (powers εsrc) haerror (by simpa only [mul_one,nominalLog,input,amain,Hcoef,Kmain,mainRadius,paid,deficit,rmain,delta] using hmain) + (by simpa only [mul_one,nominalLog,errorRadius,delta] using herror) + apply hann.trans_eq + rw [source_coefficients_identity _ _ _ (volume_pos input).le] + dsimp only [normValue] + ring + +end SevenEighths.CenteredMomentEnergyCanonicalAnnularPower + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalChildBound.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalChildBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..0357606e7a6f8bfce71b9ed5021de4f3cd9b2135 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalChildBound.lean @@ -0,0 +1,94 @@ +import OAI.NumberTheory.DirichletL.Energy.AllocatedHomogeneous +import OAI.NumberTheory.DirichletL.Energy.ChildState + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalChildBound +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_canonical_child_bands (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b:ℝ)(haPlain:0 simp only [st,canonicalState,NaturalState.width] ; ring + +end SevenEighths.CenteredMomentEnergyCanonicalChildBound + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalCommonPaid.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalCommonPaid.lean new file mode 100644 index 0000000000000000000000000000000000000000..819fb8a96973f1270c576e832293f2528ed43fb4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalCommonPaid.lean @@ -0,0 +1,129 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalPaidSource +import OAI.NumberTheory.DirichletL.Energy.AllocatedBound + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalCommonPaid +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_common_paid_source (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0bslot) (fun _=>Mslot) + (fun _=>hMslot) εmask hεmask + refine ⟨n,T,dc,2*Cm*Cc,by positivity,?_⟩ + intro η₀ θ + obtain ⟨Z₀,hZ₀,hbound⟩:=hbound η₀ θ + refine ⟨Z₀,hZ₀,?_⟩ + intro Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq + src hmatch hhi hMs C R B D alloc hR τ dyad hn hwidth p hp₁ hp₂ + dsimp only + intro hX₁ hX₂ hY₁ hY₂ A Mparent Mnom u ell δ₁ δ₂ θclip + hu hell hδ₁ hδ₂ hθclip hparent hshift hdefect hclip + let d:=commonData (withHeight src τ v) C R B + let rad:=canonicalRadial τ (internalQ Q η₀) dyad + let V₁:=sourcePlain a b haPlain (p.profile 0) (p.support 0) + let V₂:=sourcePlain a b haPlain (p.profile 1) (p.support 1) + let E:=Cc*(C₀+C₁)*diagonalControl rad.profile*(p.control T)^2* + (1+(|v|+height))^(dc+degree+4*n)* + Z^(Mnom+εchild+εremove+(δ₂+u+ell+δ₁/6+θclip/3)+κ*mesh) + have hz:1hz.1) E E he he (by + intro left F₁ hF₁ F₂ hF₂ J hJ + have hf₁:∀I∈F₁,I≠0:=fun I hi=>(CenteredMomentNaturalRowSource.support_prime (R*C) I + ((Finset.mem_powerset.mp hF₁) hi)).ne_zero + have hf₂:∀I∈F₂,I≠0:=fun I hi=>(CenteredMomentNaturalRowSource.support_prime (R*C) I + ((Finset.mem_powerset.mp hF₂) hi)).ne_zero + cases left + · exact hleft d.Y₁ d.Y₂ d.Y₁_pos d.Y₂_pos hY₁ hY₂ d.same_product F₁ F₂ hf₁ hf₂ J + · exact hleft d.X₁ d.X₂ d.X₁_pos d.X₂_pos hX₁ hX₂ rfl F₁ F₂ hf₁ hf₂ J) + apply hh.trans_eq + dsimp [E] + ring + +end SevenEighths.CenteredMomentEnergyCanonicalCommonPaid + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorAdmitted.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorAdmitted.lean new file mode 100644 index 0000000000000000000000000000000000000000..394f7b84a602f9115df1f2c1ae3f8e4d77fcd7e6 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorAdmitted.lean @@ -0,0 +1,205 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorGaussian +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorUniform +import OAI.NumberTheory.DirichletL.Moments.FirstNestedSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorAdmitted +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstNestedSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_error_smaller_gaussian + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime (k+1) + Ready input ((R0*C)*(Ideal.span {prime})^(k+1)) Kerror Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀Scols:Finset (Ideal O),∀β:Ideal O→ℂ, + Scols=finiteColumns (Fintype.piFinset input.pools) → + β=coefficient input ((R0*C)*(Ideal.span {prime})^(k+1)) seed → + ∃family:(q:ActiveLabel Scols β)→Finset (CommonIndex q.val.1 q.val.2)→RayCharacter→Character, + (∀q U,Family input.η q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U (family q U)) ∧ + ∀_χ₀:RayCharacter,∀m:O,m≠0 → goodLambda∣m → (2:O)∣m → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let Echild:=CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((Bcap+Bcap)*εmask+(εchild+εremove+errorRemoval prime Z (k+1)+ + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3+κ*mesh)) + normalizedGaussSource input ((R0*C)*(Ideal.span {prime})^(k+1)) seed CenteredMomentFirstAmplificationChoice.ballProfile Kerror≤ + (∑j,coefficients N upper (max 1 b) (max 1 b) (mass src) Sp p J (internalQ Q η₀) Kc v0 + εsrc (seed.absNorm:ℝ) + (seededFactors Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap saving Kerror v0 + (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z (k+1))) Echild Echild r (∏i,input.lo i) a (seed.absNorm:ℝ) + (dc+degree+4*n) (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile) j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hmain⟩:= + CenteredMomentEnergyCanonicalErrorGaussian.actual_error_gaussian_from_bands (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ + refine ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Kc,hKc,Zi,hZi,hi⟩:=hmain η₀ Q hQM hQ0 hQt hQ72 + let Zw:=CenteredMomentEnergyAmplifiedChildWidth.threshold N upper sigma hupper hsigma + refine ⟨Kc,hKc,max Zi Zw,lt_of_lt_of_le hZi (le_max_left _ _),?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input hinput + subst input + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β hScols hβ + have hZiZ:Zi≤Z:=(le_max_left _ _).trans hZ + have hZw:Zw≤Z:=(le_max_right _ _).trans hZ + have hz:1(dyad i:ℤ)) hphysical χ + exact hh.le.trans hdrop + +end SevenEighths.CenteredMomentEnergyCanonicalErrorAdmitted + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorGaussian.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorGaussian.lean new file mode 100644 index 0000000000000000000000000000000000000000..1239786517727b801e0553c53a672003a92c8274 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorGaussian.lean @@ -0,0 +1,277 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorUniform +import OAI.NumberTheory.DirichletL.Moments.FirstNestedSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorGaussian +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstNestedSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_error_gaussian_from_bands + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K sigma delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime k + Ready input ((R0*C)*(Ideal.span {prime})^k) Kerror Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀Scols:Finset (Ideal O),∀β:Ideal O→ℂ, + Scols=finiteColumns (Fintype.piFinset input.pools) → + β=coefficient input ((R0*C)*(Ideal.span {prime})^k) seed → + ∃family:(q:ActiveLabel Scols β)→Finset (CommonIndex q.val.1 q.val.2)→RayCharacter→Character, + (∀q U,Family input.η q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U (family q U)) ∧ + ∀χ₀:RayCharacter,∀m:O,m≠0 → goodLambda∣m → (2:O)∣m → + (∀q∈liveLabels input.η Scols β,∀U:Finset (CommonIndex q.val.1 q.val.2), + ∀dyad:SourceBlocks q.val.1 q.val.2 U Kerror (frequencyRadius (nominal input Kerror) Z ξ) + (sourceRadius input), + physicalBlock input.η input.t (activeSource Scols β) β q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U + (frequencyRadius (nominal input Kerror) Z ξ) + (partRows false input.η χ₀ (internalQ Q η₀) m q.val.1 q.val.2 U + (frequencyRadius (nominal input Kerror) Z ξ)) + CenteredMomentFirstAmplificationChoice.ballProfile Kerror (fun i=>(dyad i:ℤ))≠0 → + ∀χ:RayCharacter,Real.logb Z (dyadicScale (dyad 1))+ + Real.logb Z ((family q U χ).modulus.absNorm:ℝ)≤Mcap) → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let Echild:=CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((Bcap+Bcap)*εmask+(εchild+εremove+errorRemoval prime Z k+ + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3+κ*mesh)) + normalizedGaussSource input ((R0*C)*(Ideal.span {prime})^k) seed CenteredMomentFirstAmplificationChoice.ballProfile Kerror≤ + (∑j,coefficients N upper (max 1 b) (max 1 b) (mass src) Sp p J (internalQ Q η₀) Kc v0 + εsrc (seed.absNorm:ℝ) + (seededFactors Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap saving Kerror v0 + (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) Echild Echild r (∏i,input.lo i) a (seed.absNorm:ℝ) + (dc+degree+4*n) (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile) j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,hmain⟩:= + CenteredMomentEnergyCanonicalErrorUniform.actual_error_uniform_child (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain L hL + degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ + N lower upper a0 Bcap Bcap θsource hlower ha0 hθsource + obtain ⟨J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hgauss⟩:= + actual_nested_subsets_seeded_gaussian_power a b haPlain hbPlain lows highs hhighs + CenteredMomentFirstAmplificationChoice.ballProfile (dc+degree+4*n) (dc+degree+4*n) + N upper (max 1 b) (max 1 b) hupper (le_max_left _ _) (le_max_left _ _) + εsrc δsrc θsrc Bcap Bseed ξ saving hεsrc hδsrc hθsrc hBcap hξ + refine ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Zm,hZm,hm⟩:=hmain η₀ + obtain ⟨Kc,hKc,hevent⟩:=hgauss (internalQ Q η₀) hQ0 hQt hQ72 + obtain ⟨Zg,hZg⟩:=Filter.eventually_atTop.1 hevent + refine ⟨Kc,hKc,max Zm Zg,lt_of_lt_of_le hZm (le_max_left _ _),?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ v0 hυ input hinput + subst input + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip + hcap hMdecl hclip hasourceFactor Scols β hScols hβ + let input:=errorInput src C R0 B τ t (Ideal.span {prime}) k Bp υ v0 + let Km:=errorCommonRadius Z (Real.logb Z (D.absNorm:ℝ)) + (Real.logb Z (firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime k + have hZmZ:Zm≤Z:=(le_max_left _ _).trans hZ + have hgZ:=hZg Z ((le_max_right _ _).trans hZ) + have hz:1hloSrc i.val.val) (fun i=>hhiSrc i.val.val) hP hp₁.symm hp₂.symm (mass src) + hupperSrc hcardInput hb1 hb2 hb1max hb2max hmass + ((R0*C)*(Ideal.span {prime})^k) seed hready.puncture_ne hseed hseed0 hseedcap hready.source_nonneg hready.source_cap + hready.conductor_cap hready.puncture_cap + change Scols=finiteColumns (Fintype.piFinset input.pools) at hScols + change β=coefficient input ((R0*C)*(Ideal.span {prime})^k) seed at hβ + dsimp only at hsource + subst Scols β + obtain ⟨family,hfamily,hbound⟩:=hsource + refine ⟨family,hfamily,?_⟩ + intro χ₀ m hm0 hml hm2 hwidth r hr1 hr2 hr3 hr4 + let Ec:=CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((Bcap+Bcap)*εmask+(εchild+εremove+errorRemoval prime Z k+ + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3+κ*mesh)) + have hEc:0≤Ec:=CenteredMomentEnergyChildEnvelopeFitting.coefficient_nonneg + Cc C₀ C₁ p T height (dc+degree+4*n) Z _ hCc.le hC₀ hC₁ hheight (zero_le_one.trans hz.le) + have hpzero (j:Fin 2):p.profile j 0=0:=by + by_contra hn + exact (not_le_of_gt haPlain) ((p.support j hn).1) + have hz1:input.W₁ 0=0:=by change src.W₁ 0=0;rw [←hp₁];exact hpzero 0 + have hz2:input.W₂ 0=0:=by change src.W₂ 0=0;rw [←hp₂];exact hpzero 1 + have hlowerInput:lower ≤ input.lower:=hlowerSrc + have hplain₁:∀x,input.W₁ x≠0→a≤x:=by + intro x hx + change src.W₁ x≠0 at hx + rw [←hp₁] at hx + exact (p.support 0 hx).1 + have hplain₂:∀x,input.W₂ x≠0→a≤x:=by + intro x hx + change src.W₂ x≠0 at hx + rw [←hp₂] at hx + exact (p.support 1 hx).1 + have hlowerBeta (I:Ideal O) + (hI:coefficient input ((R0*C)*(Ideal.span {prime})^k) seed I≠0): + asource*volume input≤(I.absNorm:ℝ):=by + exact (mul_le_mul_of_nonneg_right hasourceFactor (volume_pos input).le).trans + (CenteredMomentSecondInputCapacitySource.actual_lower_support N lower a hlower haPlain + input hcardInput hlowerInput hplain₁ hplain₂ _ seed I hI) + apply hbound χ₀ m hm0 hml hm2 Km (nominal input Km) hready.scale_pos hready.volume_cap + hready.nominal_cap (le_refl _) hready.frequency_pos hready.frequency_cap + (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) + (mul_pos (mul_pos (zero_lt_one.trans_le hcost) (norm_pos τ.modulus τ.modulus_ne_bot)) + (Real.rpow_pos_of_pos (zero_lt_one.trans hz) _)) + Ec Ec hEc hEc ?_ ?_ r hr1 hr2 hr3 hr4 + all_goals + intro q hq U dyad hphysical D0 hD0 hD0cap hD0sq χ v B₂ hB₂ alloc halloc + have hqp:=q.property + have hg:=actual_common_gates input ((R0*C)*(Ideal.span {prime})^k) seed hseed hz1 hz2 q.val.1 q.val.2 hqp + have hs:=commonLabels_supported (activeSource _ _) _ _ q.property + · exact hm θ Z hZmZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hcard hlowerSrc hupperSrc C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ v0 hυ input rfl + _ _ q.val.1 q.val.2 hs.1 hs.2 hg.2.2.1 U _ _ _ (fun i=>(dyad i:ℤ)) + hlowerBeta hphysical (family q U) (hfamily q U) χ (hwidth q hq U dyad hphysical χ) + q.val.1 ((R0*C)*(Ideal.span {prime})^k) (Or.inl rfl) hready.puncture_ne hready.puncture_cap + (hg.2.2.2.2.2.1.trans hready.source_cap) B₂ hB₂ D0 alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + · exact hm θ Z hZmZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hcard hlowerSrc hupperSrc C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ v0 hυ input rfl + _ _ q.val.1 q.val.2 hs.1 hs.2 hg.2.2.1 U _ _ _ (fun i=>(dyad i:ℤ)) + hlowerBeta hphysical (family q U) (hfamily q U) χ (hwidth q hq U dyad hphysical χ) + q.val.2 ((R0*C)*(Ideal.span {prime})^k) (Or.inr rfl) hready.puncture_ne hready.puncture_cap + (hg.2.2.2.2.2.2.trans hready.source_cap) B₂ hB₂ D0 alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + +end SevenEighths.CenteredMomentEnergyCanonicalErrorGaussian + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorHomogeneous.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorHomogeneous.lean new file mode 100644 index 0000000000000000000000000000000000000000..e2ad65d4d00bf727f63ae95f2270c104175aa1ef --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorHomogeneous.lean @@ -0,0 +1,210 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorAdmitted +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorGaussian +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorUniform +import OAI.NumberTheory.DirichletL.Moments.FirstNestedSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorHomogeneous +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstNestedSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_error_homogeneous + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime (k+1) + Ready input ((R0*C)*(Ideal.span {prime})^(k+1)) Kerror Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + normalizedGaussSource input ((R0*C)*(Ideal.span {prime})^(k+1)) seed + CenteredMomentFirstAmplificationChoice.ballProfile Kerror≤ + (∑j,(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|v0|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ))* + CenteredMomentFirstAmplifiedFourCoefficients.errorPowers prime (k+1) + (τ.modulus.absNorm:ℝ) Z Kerror + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hmain⟩:= + CenteredMomentEnergyCanonicalErrorPower.actual_error_power_from_bands (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma hsigma hξsmall + have hlo:=CenteredMomentSecondInputCapacitySource.lowerFactor_pos N lower a hlower haPlain + obtain ⟨Uprofile,Jheight,hweights⟩:= + CenteredMomentEnergyFirstGaussianProfileWeights.actual_weights (a:=a) (b:=b) + N upper (max 1 b) (max 1 b) ((max 1 Mslot)^N) + (CenteredMomentSecondInputCapacitySource.lowerFactor N lower a) + Cm Ce Cd Ct Cc cost εsrc δsrc θsrc Bcap J (dc+degree+4*n) (dc+degree+4*n) + Sp T Sf CenteredMomentFirstAmplificationChoice.ballProfile + (zero_le_one.trans hupper) (le_trans zero_le_one (le_max_left _ _)) + (le_trans zero_le_one (le_max_left _ _)) (by positivity) hlo + hCm.le hCe hCd.le hCt.le hCc.le (zero_le_one.trans hcost) + refine ⟨Uprofile,Jheight,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Kc,hKc,Zi,hZi,hi⟩:=hmain η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Cbound,hCbound,hwbound⟩:=hweights (internalQ Q η₀) Kc hKc.le + refine ⟨Cbound,hCbound,Zi,hZi,?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input hinput + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + let Scols:=finiteColumns (Fintype.piFinset input.pools) + let β:=coefficient input ((R0*C)*(Ideal.span {prime})^(k+1)) seed + obtain ⟨family,hfamily,hbound⟩:=hi θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input hinput + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β rfl rfl + have hg:=hbound 1 fixedBadMask fixedBadMask_ne_zero (dvd_mul_right _ _) (dvd_mul_left _ _) + r hr1 hr2 hr3 hr4 + dsimp only at hg ⊢ + have hz:0(hMs i).trans (le_max_right _ _)) + have hnseed:1≤(seed.absNorm:ℝ):=norm_ge_one seed hseed0 + have hh:=hwbound p Z v0 height (mass src) (seed.absNorm:ℝ) C₀ C₁ + hz hheight (mass_nonneg src) hmass hnseed hC₀ hC₁ + dsimp only at hh + apply hg.trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + apply Finset.sum_le_sum + intro j _ + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg (volume_pos input).le _) + apply mul_le_mul_of_nonneg_right (hh j) + fin_cases j <;> simp only [CenteredMomentFirstAmplifiedFourCoefficients.errorPowers,Matrix.cons_val,Fin.reduceFinMk] <;> + try unfold errorCommonRadius + all_goals positivity + +end SevenEighths.CenteredMomentEnergyCanonicalErrorHomogeneous + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorPaid.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorPaid.lean new file mode 100644 index 0000000000000000000000000000000000000000..e9b5f81bcd8cb7763218b297ce670d70339f4151 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorPaid.lean @@ -0,0 +1,302 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.CanonicalNestedReference +import OAI.NumberTheory.DirichletL.Energy.ActiveChildRestoration +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorPaid +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][instα:DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentEnergyCanonicalMainPaid CenteredMomentEnergyCanonicalNestedReference +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open CenteredMomentEnergyActiveChildRestoration + +def castAllocation (s t:Input α)(h:s=t)(C:Ideal O) + (B:actualAllocations s.pools C):actualAllocations t.pools C:= + ⟨B.val,by rw [←h];exact B.property⟩ + +def castDivisorAllocation (s t:Input α)(h:s=t)(C:Ideal O) + (B:actualAllocations s.pools C)(D:Ideal O) + (alloc:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))): + Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices (castAllocation s t h C B).val⊕Fin 2)):=alloc + +def restoreDivisorAllocation (s:Input α)(C:Ideal O) + (B:actualAllocations (activeInput s).pools C)(D:Ideal O) + (alloc:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))): + Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices (restoreAllocation s C B).val⊕Fin 2)):=alloc + +lemma cast_child_energy (s t:Input α)(h:s=t)(C R:Ideal O) + (B:actualAllocations s.pools C)(τ:Character)(v:ℝ)(D:Ideal O) + (alloc:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (rad:Radial): + childEnergy (commonData (withHeight s τ v) C R B) rad D alloc= + childEnergy (commonData (withHeight t τ v) C R (castAllocation s t h C B)) rad D + (castDivisorAllocation s t h C B D alloc):=by + subst t + rfl + +lemma restored_child_energy (s:Input α)(C R:Ideal O) + (B:actualAllocations (activeInput s).pools C)(τ:Character)(v:ℝ)(D:Ideal O) + (alloc:Allocation D (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (rad:Radial): + childEnergy (commonData (withHeight (activeInput s) τ v) C R B) rad D alloc= + childEnergy (commonData (withHeight s τ v) C R (restoreAllocation s C B)) rad D + (restoreDivisorAllocation s C B D alloc):=by + cases Subsingleton.elim instα (Classical.decEq α) + exact child_energy_active s C R B τ v D alloc rad + +omit instα in +lemma cast_preVolume (s t:Input α)(h:s=t)(C R:Ideal O) + (B:actualAllocations s.pools C)(τ:Character)(v:ℝ): + CenteredMomentAllocatedChildCapacity.preVolume (commonData (withHeight t τ v) C R (castAllocation s t h C B))= + CenteredMomentAllocatedChildCapacity.preVolume (commonData (withHeight s τ v) C R B):=by + subst t + rfl + +omit instα in +lemma cast_slot_sum (s t:Input α)(h:s=t)(C:Ideal O) + (B:actualAllocations s.pools C)(f:α→ℝ): + (∑i:CenteredMomentCommonProfile.liveIndices (castAllocation s t h C B).val,f i.val)= + ∑i:CenteredMomentCommonProfile.liveIndices B.val,f i.val:=rfl + +omit instα in +lemma restored_preVolume (s:Input α)(C R:Ideal O) + (B:actualAllocations (activeInput s).pools C)(τ:Character)(v:ℝ): + CenteredMomentAllocatedChildCapacity.preVolume (commonData (withHeight s τ v) C R (restoreAllocation s C B))= + CenteredMomentAllocatedChildCapacity.preVolume (commonData (withHeight (activeInput s) τ v) C R B):=rfl + +omit instα in +lemma restored_slot_sum (s:Input α)(C:Ideal O) + (B:actualAllocations (activeInput s).pools C)(f:α→ℝ): + (∑i:CenteredMomentCommonProfile.liveIndices (restoreAllocation s C B).val,f i.val)= + ∑i:CenteredMomentCommonProfile.liveIndices B.val,f i.val:=rfl + +theorem actual_error_child_from_bands (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K sigma delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime k + ∀(Scols:Finset (Ideal O))(βsource:Ideal O→ℂ)(C₂ D₂:Ideal O), + ∀hC₂:Supported C₂,∀hD₂:Supported D₂,primeSupport C₂=primeSupport D₂ → + ∀(U:Finset (CommonIndex C₂ D₂))(Rwindow:ℝ)(rows:Finset O)(Wkernel:𝓢(ℝ,ℂ))(dyad:Fin 4→ℤ), + (∀I:Ideal O,βsource I≠0 → asource*volume input≤(I.absNorm:ℝ)) → + physicalBlock υ v0 Scols βsource C₂ D₂ hC₂ hD₂ U Rwindow rows Wkernel Kerror dyad≠0 → + ∀family:RayFourExpansion.RayCharacter→Character,Family υ C₂ D₂ hC₂ hD₂ U family → + ∀χ:RayFourExpansion.RayCharacter, + Real.logb Z (dyadicScale (dyad 1))+Real.logb Z ((family χ).modulus.absNorm:ℝ)≤Mcap → + ∀Cpick Rpick:Ideal O,Cpick=C₂ ∨ Cpick=D₂ → Rpick≠0 → + ∀B₂:actualAllocations input.pools Cpick, + frozenCoefficient B₂.val Cpick Rpick input.ν input.W input.P≠0 → + ∀Dalloc:Ideal O,∀alloc:Allocation Dalloc + (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B₂.val⊕Fin 2)), + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + let δpaid:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + sourceReserve src input C D Z delta reserve cost asource + childEnergy (commonData (withHeight input (family χ) v) Cpick Rpick B₂) + (canonicalRadial (family χ) (internalQ Q η₀) dyad) Dalloc alloc≤ + Cc*(Ideal.absNorm (Rpick*Cpick).radical:ℝ)^εmask*(C₀+C₁)* + diagonalControl (canonicalRadial (family χ) (internalQ Q η₀) dyad).profile* + (p.control T)^2*(1+(|v|+height))^(dc+degree+4*n)* + envelopeRef (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) C₂ D₂ U dyad*(ratioPenalty dyad)^((1:ℝ)/6)* + Z^(εchild+εremove+(errorRemoval prime Z k+δpaid/6+θclip/3)+κ*mesh):=by + cases Subsingleton.elim instα (Classical.decEq α) + obtain ⟨n,T,dc,Cc,hCc,hbound⟩:=nested_original_subsets_reference_paid (α:=α) M H hH W aslot bslot + Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain L hL degree S + ha hWs hW hMcap hLs hε hbeta hκ + refine ⟨n,T,dc,Cc,hCc,?_⟩ + intro η₀ + obtain ⟨Z₀,hZ₀,hbound⟩:=hbound η₀ + refine ⟨Z₀,hZ₀,?_⟩ + intro θ Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + C D R0 hC hD hCD E B τ t hB hmod K sigma delta reserve cost asource hK hsigma hcost hasource + prime hprime k hk hprimeScale hslot Bp υ v0 hυ input hinput + dsimp only + intro Scols βsource C₂ D₂ hC₂ hD₂ hCD₂ U Rwindow rows Wkernel dyad hlower hphysical + family hfamily χ hwidth Cpick Rpick hside hRpick B₂ hB₂ Dalloc alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + subst input + have hz:1P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime k + have hKerror:0w i.val.val)).trans + (cast_slot_sum input (activeInput restored) heInput Cpick B₂ (fun i=>w i.val.val)) + exact (congrArg (fun x=>Real.logb Z (volume src)+(6*κ-1)*x) heSum).trans_le hpar + have hshiftw: + Real.logb Z ((commonData (withHeight restored (family χ) v) Cpick Rpick B₂r).X₁* + (commonData (withHeight restored (family χ) v) Cpick Rpick B₂r).X₂* + ∏i:CenteredMomentCommonProfile.liveIndices B₂r.val,restored.P i.val)- + Real.logb Z (envelopeRef (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) C₂ D₂ U dyad)≤ + Real.logb Z (volume src)-Mdecl+6*(errorRemoval prime Z k+0)+ + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + sourceReserve src input C D Z delta reserve cost asource)+Real.logb Z (ratioPenalty dyad):=by + change Real.logb Z (CenteredMomentAllocatedChildCapacity.preVolume + (commonData (withHeight restored (family χ) v) Cpick Rpick B₂r))-_≤_ + have hpv:= (restored_preVolume restored Cpick Rpick B₂a (family χ) v).trans + ((cast_preVolume input (activeInput restored) heInput Cpick Rpick B₂ (family χ) v).trans + (common_preVolume_height input Cpick Rpick B₂ (family χ) υ v v0)) + calc + _ = Real.logb Z (CenteredMomentAllocatedChildCapacity.preVolume + (commonData (withHeight input υ v0) Cpick Rpick B₂)) - + Real.logb Z (envelopeRef (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) C₂ D₂ U dyad) := + congrArg (fun x=>Real.logb Z x - Real.logb Z + (envelopeRef (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) C₂ D₂ U dyad)) hpv + _ ≤ _ := by + dsimp only [input] + simpa only [add_zero] using hshift + have hh:=hbound (CenteredMomentCommonProfile.liveIndices B.val) + (CenteredMomentCommonProfile.liveIndices Bp.val) (fun i=>θ i.val.val) + Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + (fun i=>w i.val.val) (fun i=>σ i.val.val) (fun i=>freq i.val.val) v height mesh hmesh + (fun i=>hw i.val.val) (fun i=>hwm i.val.val) (fun i=>hwL i.val.val) (fun i=>hσlo i.val.val) + (fun i=>hσhi i.val.val) hheight (fun i=>hfreq i.val.val) + have hh := hh restored hm (fun i=>hhi i.val.val) (fun i=>hMs i.val.val) + have hh := hh Cpick Rpick B₂r + let allocA:=castDivisorAllocation input (activeInput restored) heInput Cpick B₂ Dalloc alloc + let allocR:=restoreDivisorAllocation restored Cpick B₂a Dalloc allocA + have hh := hh Dalloc allocR hRpick + have hh := hh (family χ) dyad hn hwidth + have hh := hh p hp₁ hp₂ + have hh := hh caps₃.1 caps₃.2.1 caps₃.2.2.1 caps₃.2.2.2 + have hh := hh (Real.logb Z (volume src)) Mdecl + (envelopeRef (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) C₂ D₂ U dyad) + (errorRemoval prime Z k) 0 + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + sourceReserve src input C D Z delta reserve cost asource) + 0 θclip (envelope_pos _ hqpos _ _ hC₂ _ _) + hrem le_rfl hδ le_rfl hθclip + have hh := hh hparw + have hh := hh hshiftw + have hh := hh (by linarith only [hdef]) hclip + have he := (cast_child_energy input (activeInput restored) heInput Cpick Rpick B₂ (family χ) v Dalloc alloc + (canonicalRadial (family χ) (internalQ Q η₀) dyad)).trans + (restored_child_energy restored Cpick Rpick B₂a (family χ) v Dalloc allocA + (canonicalRadial (family χ) (internalQ Q η₀) dyad)) + apply he.trans_le + simpa only [zero_add,add_zero] using hh + +end SevenEighths.CenteredMomentEnergyCanonicalErrorPaid + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorPower.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorPower.lean new file mode 100644 index 0000000000000000000000000000000000000000..c6d19ef649d3b67760f0951fc7cc338c4da76806 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorPower.lean @@ -0,0 +1,236 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorAdmitted +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorGaussian +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorUniform +import OAI.NumberTheory.DirichletL.Moments.FirstNestedSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorPower +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstNestedSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_error_power_from_bands + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime (k+1) + Ready input ((R0*C)*(Ideal.span {prime})^(k+1)) Kerror Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀Scols:Finset (Ideal O),∀β:Ideal O→ℂ, + Scols=finiteColumns (Fintype.piFinset input.pools) → + β=coefficient input ((R0*C)*(Ideal.span {prime})^(k+1)) seed → + ∃family:(q:ActiveLabel Scols β)→Finset (CommonIndex q.val.1 q.val.2)→RayCharacter→Character, + (∀q U,Family input.η q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U (family q U)) ∧ + ∀_χ₀:RayCharacter,∀m:O,m≠0 → goodLambda∣m → (2:O)∣m → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + let Ebase:=Cc*(C₀+C₁)*diagonalControl CenteredMomentFirstAmplificationChoice.ballProfile* + (p.control T)^2*(1+height)^(dc+degree+4*n); + let Hweights:=coefficients N upper (max 1 b) (max 1 b) (mass src) Sp p J + (internalQ Q η₀) Kc v0 εsrc (seed.absNorm:ℝ) + (CenteredMomentEnergyFirstGaussianCoefficients.fixedFactors Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap cost Ebase v0 + (CenteredMomentSecondInputCapacitySource.lowerFactor N lower a) (seed.absNorm:ℝ) + (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile); + normalizedGaussSource input ((R0*C)*(Ideal.span {prime})^(k+1)) seed + CenteredMomentFirstAmplificationChoice.ballProfile Kerror≤ + (∑j,Hweights j*CenteredMomentFirstAmplifiedFourCoefficients.errorPowers prime (k+1) + (τ.modulus.absNorm:ℝ) Z Kerror + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hmain⟩:= + CenteredMomentEnergyCanonicalErrorAdmitted.actual_error_smaller_gaussian (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma hsigma hξsmall + refine ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Kc,hKc,Zi,hZi,hi⟩:=hmain η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Kc,hKc,Zi,hZi,?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input hinput + subst input + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β hScols hβ + let input:=errorInput src C R0 B τ t (Ideal.span {prime}) (k+1) Bp υ v0 + let Km:=errorCommonRadius Z (Real.logb Z (D.absNorm:ℝ)) + (Real.logb Z (firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime (k+1) + obtain ⟨family,hfamily,hbound⟩:=hi θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input rfl + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β hScols hβ + refine ⟨family,hfamily,?_⟩ + intro χ₀ m hm hml hm2 r hr1 hr2 hr3 hr4 + have hg:=hbound χ₀ m hm hml hm2 r hr1 hr2 hr3 hr4 + dsimp only at hg ⊢ + let Ebase:=Cc*(C₀+C₁)*diagonalControl CenteredMomentFirstAmplificationChoice.ballProfile* + (p.control T)^2*(1+height)^(dc+degree+4*n) + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh + have hz:0hlowerSrc.trans (src.lower_le i.val.val)) + have hlo:CenteredMomentSecondInputCapacitySource.lowerFactor N lower a≤(∏i,input.lo i)*a*a:=by + unfold CenteredMomentSecondInputCapacitySource.lowerFactor + simpa only [pow_two, mul_assoc] using + mul_le_mul_of_nonneg_right hloProd (sq_nonneg a) + have hcoef:=CenteredMomentEnergyFirstGaussianCoefficients.error_coefficients + N upper (max 1 b) (max 1 b) (mass src) Sp p J (internalQ Q η₀) Kc prime (k+1) + Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap saving Km v0 (τ.modulus.absNorm:ℝ) cost Ebase + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid r + (∏i,input.lo i) a (CenteredMomentSecondInputCapacitySource.lowerFactor N lower a) (seed.absNorm:ℝ) + (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile + (zero_le_one.trans hupper) (le_trans zero_le_one (le_max_left _ _)) + (le_trans zero_le_one (le_max_left _ _)) hKc.le (Nat.cast_nonneg _) hCm.le hCe hz hE + (by unfold Km errorCommonRadius;positivity) + (CenteredMomentSecondInputCapacitySource.lowerFactor_pos N lower a hlower haPlain) hlo + have hexp: + (Bcap+Bcap)*εmask+(εchild+εremove+errorRemoval prime Z (k+1)+ + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3+κ*mesh)= + errorRemoval prime Z (k+1)+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)))/6+paid :=by + dsimp [paid];ring + apply hg.trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + apply Finset.sum_le_sum + intro j _ + have hh:=mul_le_mul_of_nonneg_right (hcoef j) + (Real.rpow_nonneg (volume_pos input).le (powers εsrc j)) + simpa only [CenteredMomentEnergyChildEnvelopeFitting.coefficient,hexp,Ebase,paid] using hh + +end SevenEighths.CenteredMomentEnergyCanonicalErrorPower + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorSubsets.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorSubsets.lean new file mode 100644 index 0000000000000000000000000000000000000000..328800ca5c93d49e0075bf3a3ff8f4b865f57ce8 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorSubsets.lean @@ -0,0 +1,231 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorAdmitted +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorGaussian +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorUniform +import OAI.NumberTheory.DirichletL.Moments.FirstNestedSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorSubsets +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstNestedSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_original_subsets_error_power + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime (k+1) + Ready input ((R0*C)*(Ideal.span {prime})^(k+1)) Kerror Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + normalizedGaussSource input ((R0*C)*(Ideal.span {prime})^(k+1)) seed + CenteredMomentFirstAmplificationChoice.ballProfile Kerror≤ + (∑j,(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|v0|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ))* + CenteredMomentFirstAmplifiedFourCoefficients.errorPowers prime (k+1) + (τ.modulus.absNorm:ℝ) Z Kerror + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2 :=by + have hmain (Aorig:Finset α):= + CenteredMomentEnergyCanonicalErrorHomogeneous.actual_error_homogeneous (α:=Aorig) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource (fun i=>lows i.val) (fun i=>highs i.val) + (fun i=>hhighs i.val) εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma cost hsigma hξsmall hcost + choose Uj Jj hj using hmain + let Uprofile:Finset (ℕ×ℕ):=Finset.univ.biUnion Uj + let Jheight:ℕ:=∑Aorig:Finset α,Jj Aorig + refine ⟨Uprofile,Jheight,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + choose Cj hCj Zj hZj hconsume using fun Aorig=>hj Aorig η₀ Q hQM hQ0 hQt hQ72 + let Cbound:ℝ:=1+∑Aorig:Finset α,Cj Aorig + let Z₀:ℝ:=2+∑Aorig:Finset α,|Zj Aorig| + have hCbound:0(hCj Aorig).le) + dsimp [Cbound];linarith + have hZ₀:1abs_nonneg (Zj Aorig)) + dsimp [Z₀];linarith + have hCC (Aorig:Finset α):Cj Aorig≤Cbound:=by + have hh:=Finset.single_le_sum (fun A (_:A∈(Finset.univ:Finset (Finset α)))=>(hCj A).le) + (Finset.mem_univ Aorig) + dsimp [Cbound];linarith + have hZZ (Aorig:Finset α):Zj Aorig≤Z₀:=by + have hh:=Finset.single_le_sum (fun A (_:A∈(Finset.univ:Finset (Finset α)))=>abs_nonneg (Zj A)) + (Finset.mem_univ Aorig) + dsimp [Z₀];linarith [le_abs_self (Zj Aorig)] + refine ⟨Cbound,hCbound,Z₀,hZ₀,?_⟩ + intro Aorig θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input hinput + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + have hposA:=positiveAt_subtype M H hH Aorig Wslot bslot (a/max 1 b) b 2 0 L Lslot lo hi + Mcap εchild κ Z η₀ Q degree S C₁ hpos + have hg:=hconsume Aorig θ Z ((hZZ Aorig).trans hZ) εchild C₀ C₁ hC₀ hC₁ hzero hposA + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ χerr v0 hN hυ input hinput + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + dsimp only at hg ⊢ + have hsub:Uj Aorig⊆Uprofile:=by + intro x hx + exact Finset.mem_biUnion.mpr ⟨Aorig,Finset.mem_univ _,hx⟩ + have hp:p.control (Uj Aorig)≤p.control Uprofile:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono hsub) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hsub) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hJ:Jj Aorig≤Jheight:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ Aorig) + have hz:0 simp only [CenteredMomentFirstAmplifiedFourCoefficients.errorPowers,Matrix.cons_val,Fin.reduceFinMk] <;> + try unfold errorCommonRadius + all_goals positivity + +end SevenEighths.CenteredMomentEnergyCanonicalErrorSubsets + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorUniform.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..fa558bfff5ffa54a29ec5ba278afba78406e9606 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalErrorUniform.lean @@ -0,0 +1,181 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.CanonicalNestedReference +import OAI.NumberTheory.DirichletL.Energy.ActiveChildRestoration +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalErrorUniform +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open CenteredMomentEnergyCanonicalMainPaid CenteredMomentEnergyCanonicalNestedReference +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) +open CenteredMomentEnergyActiveChildRestoration + +theorem actual_error_uniform_child (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K sigma delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve prime k + ∀(Scols:Finset (Ideal O))(βsource:Ideal O→ℂ)(C₂ D₂:Ideal O), + ∀hC₂:Supported C₂,∀hD₂:Supported D₂,primeSupport C₂=primeSupport D₂ → + ∀(U:Finset (CommonIndex C₂ D₂))(Rwindow:ℝ)(rows:Finset O)(Wkernel:𝓢(ℝ,ℂ))(dyad:Fin 4→ℤ), + (∀I:Ideal O,βsource I≠0 → asource*volume input≤(I.absNorm:ℝ)) → + physicalBlock υ v0 Scols βsource C₂ D₂ hC₂ hD₂ U Rwindow rows Wkernel Kerror dyad≠0 → + ∀family:RayFourExpansion.RayCharacter→Character,Family υ C₂ D₂ hC₂ hD₂ U family → + ∀χ:RayFourExpansion.RayCharacter, + Real.logb Z (dyadicScale (dyad 1))+Real.logb Z ((family χ).modulus.absNorm:ℝ)≤Mcap → + ∀Cpick Rpick:Ideal O,Cpick=C₂ ∨ Cpick=D₂ → Rpick≠0 → + (Rpick.absNorm:ℝ)≤Z^BR → (Cpick.absNorm:ℝ)≤Z^BC → + ∀B₂:actualAllocations input.pools Cpick, + frozenCoefficient B₂.val Cpick Rpick input.ν input.W input.P≠0 → + ∀Dalloc:Ideal O,∀alloc:Allocation Dalloc + (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B₂.val⊕Fin 2)), + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + childEnergy (commonData (withHeight input (family χ) v) Cpick Rpick B₂) + (canonicalRadial (family χ) (internalQ Q η₀) dyad) Dalloc alloc≤ + CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((BR+BC)*εmask+(εchild+εremove+errorRemoval prime Z k+ + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3+κ*mesh))* + envelopeRef (cost*(τ.modulus.absNorm:ℝ)*Z^(errorMoving prime Z k)) C₂ D₂ U dyad* + (ratioPenalty dyad)^((1:ℝ)/6)*(1+‖v‖)^(2*(dc+degree+4*n)) :=by + obtain ⟨n,T,dc,Cc,hCc,hbound⟩:= + CenteredMomentEnergyCanonicalErrorPaid.actual_error_child_from_bands (α:=α) M H hH + W aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain L hL + degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ + obtain ⟨Zr,hZr,hr⟩:=CenteredMomentFirstAmplifiedPaidReserve.eventually_source_reserve + N lower upper 1 a0 θsource hlower (by norm_num) ha0 hθsource + refine ⟨n,T,dc,Cc,hCc,?_⟩ + intro η₀ + obtain ⟨Zi,hZi,hi⟩:=hbound η₀ + refine ⟨max Zi Zr,lt_of_lt_of_le hZi (le_max_left _ _),?_⟩ + intro θ Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hcard hlowerSrc hupperSrc C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + prime hprime k hk hprimeScale hslot Bp υ v0 hυ input hinput + dsimp only + intro Scols βsource C₂ D₂ hC₂ hD₂ hCD₂ U Rwindow rows Wkernel dyad hlowerBeta hphysical + family hfamily χ hwidth Cpick Rpick hside hRpick hRN hCN B₂ hB₂ Dalloc alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + have hZiZ:Zi≤Z:=(le_max_left _ _).trans hZ + have hZrZ:Zr≤Z:=(le_max_right _ _).trans hZ + have hz:1HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers + +open CenteredMomentEnergyCanonicalLowColumn CenteredMomentEnergyCanonicalAnnularLower +open CenteredMomentEnergyFirstHighGaussianUniformPowers + +theorem actual_admitted_subsets_high_column + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K H0:ℝ,0P.val) E}) K (volume src)) Z ξ → + 8*H0≤Z^(amplifierCap A 0 ξ) → + ∀(t:ℝ)(seed0:Ideal O),seed0∣C → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → 0≤Mdecl → Mdecl≤A → + Mwidth≤Mdecl → + Z^(Mwidth/4)≤src.X₁ → Z^(Mwidth/4)≤src.X₂ → + Z^(Mwidth/4)≤src.Y₁ → Z^(Mwidth/4)≤src.Y₂ → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + a0≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + (∀B:actualAllocations src.pools C, + frozenCoefficient B.val C R0 src.ν src.W src.P≠0 → + Ready (child src C R0 B τ t) (R0*C) + (mainRadius C D E K (volume src) Z sigma (frequencyLoss Z 32 ξ) reserve) Z ξ (readyBudget A Pcap) ∧ + (∀prime:elementPool P,∀i:Fin 3,∀χ:RayCharacter, + ∀Bp:actualAllocations (activeInput (child src C R0 B τ t)).pools ((Ideal.span {prime.val})^(errorIndex i+1)), + let d:=errorInput src C R0 B τ t (Ideal.span {prime.val}) (errorIndex i+1) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t; + (∀I:Ideal O,coefficient d ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) seed I=0) ∨ + Ready d ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) + (errorRadius C D E K (volume src) Z sigma (frequencyLoss Z 32 ξ) reserve prime (errorIndex i+1)) + Z ξ (readyBudget A Pcap))) → + let delta:=frequencyLoss Z 32 ξ; + let Bcap:=readyBudget A Pcap; + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + let deficit:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)); + let ref:=(τ.modulus.absNorm:ℝ)*(volume src/(C.absNorm:ℝ))^2*Z^(CenteredMomentFirstMixedAllowance.allowance C D Z); + (commonEnergy (original src R0 seed0) C hC τ t seed + CenteredMomentFirstAnnularMajorant.profile H0).re≤ + (ref/(seed.absNorm:ℝ))*(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+height)^Jheight* + Z^(deficit+εsrc*(A+1)+primeLoss)* + ∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j))*(1+|t|)^(2*Jheight) :=by + obtain ⟨U,J,hann⟩:=actual_original_subsets_annular_power (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bseed ξ saving + hεsrc hδsrc hθsrc hξ sigma hsigma hξsmall A Pcap eta primeLoss reserve + hA hPcap heta hPrimeLoss hsigma1 hξ1 hreserve + obtain ⟨Cb,hCb,hcommon⟩:=common_energy_reference_powers N lower upper εsrc hlower hupper hεsrc + let Mamp:=amplifierCap A 0 ξ + let avg:=56*((Mamp+2*sigma)/(sigma/6)+1872*(Fintype.card RayCharacter:ℝ)) + have hMamp:0≤Mamp:=by dsimp [Mamp,amplifierCap];positivity + have havg:0 + errorRadius C D E K (volume src) Z sigma delta reserve prime (errorIndex i+1) + let rerror:=fun (prime:elementPool P)(i:Fin 3)(_:RayCharacter)=> + rmain-errorRemoval prime Z (errorIndex i+1) + let front:=Ca*(C₀+C₁+1)*(p.control U)^2*(1+|t|+height)^J + let Hcoef:=fun j:Fin 4=>front* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ) + let amain:=fun j=>Hcoef j*mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) deficit paid saving rmain j + let aerror:=fun (prime:elementPool P)(i:Fin 3)(χ:RayCharacter)(j:Fin 4)=> + Hcoef j*errorPowers prime (errorIndex i+1) (τ.modulus.absNorm:ℝ) Z + (Kerror prime i χ) deficit paid saving (rerror prime i χ) j + let coeff:=sourceCoefficients P ((Mamp+2*sigma)/(sigma/6)) amain aerror (powers εsrc) + have hNseed:0<(seed.absNorm:ℝ):=CenteredMomentFirstScale.norm_pos _ hseedne + have hq:0<(τ.modulus.absNorm:ℝ):=CenteredMomentFirstScale.norm_pos _ τ.modulus_ne_bot + have hfront:0≤front:=by dsimp [front];positivity + have hHcoef:∀j,0≤Hcoef j:=by intro j;dsimp [Hcoef];positivity + have hKmain:0≤Kmain:=by unfold Kmain mainRadius mainCommonRadius;positivity + have hKerror:∀prime i χ,0≤Kerror prime i χ:=by + intro prime i χ;unfold Kerror errorRadius errorCommonRadius;positivity + have hcoeff:∀j,0≤coeff j:=source_coefficients_nonneg P _ (by positivity) + amain aerror (powers εsrc) + (fun j=>mul_nonneg (hHcoef j) (main_coefficients_nonneg _ _ _ _ _ _ _ _ hq.le hZpos.le hKmain j)) + (fun prime i χ j=>mul_nonneg (hHcoef j) + (error_coefficients_nonneg _ _ _ _ _ _ _ _ _ hq.le hZpos.le (hKerror prime i χ) j)) + have hchildren (B:actualAllocations src.pools C) + (hB:frozenCoefficient B.val C R0 src.ν src.W src.P≠0): + childNormalizedGaussSource src C R0 seed B τ t CenteredMomentFirstAnnularMajorant.profile H0≤ + (∑j,coeff j*(volume (child src C R0 B τ t))^(powers εsrc j))*mass (child src C R0 B τ t)^2:=by + have hann:=henergy Aorig θ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD hR0 hRcap hNC E hmod + K H0 hK hH0 houter hHcap B t hB seed hseed hseedne hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ + Mdecl Mwidth θclip hθclip hcap hMdecl hMwidth hdrop hclip hsourceLower + (hpackets B hB).1 (hpackets B hB).2 + apply hann.trans + exact actual_high_annular_sum src P C D R0 E B τ t + K Z sigma delta reserve Mamp deficit paid saving Mwidth εsrc hZ hsigma hMamp + hrawX₁ hrawX₂ hrawY₁ hrawY₂ Hcoef hHcoef + have hcommonBound:=hcommon src hcard hlowerSrc hupperSrc C R0 seed0 hC hseed0 τ t seed + CenteredMomentFirstAnnularMajorant.profile H0 Z (CenteredMomentFirstMixedAllowance.allowance C D Z) + hH0 hZpos (fun z=>CenteredMomentFirstAnnularMajorant.profile_nonneg _) 4 coeff (powers εsrc) + hcoeff (powers_nonneg εsrc hεsrc.le) hchildren + have hPsrc:∀i,1≤src.P i:=by + intro i + rw [hmatch.scale i] + exact Real.one_le_rpow hZ.le (hw i) + have hlogs:∀i,Real.logb Z (src.P i)=w i:=by + intro i + rw [hmatch.scale i,Real.logb_rpow hZpos hZ.ne'] + have hVcap:=CenteredMomentEnergyInputParentCapacity.original_volume_cap src Z κ Mdecl hZ hκsmall hPsrc + (by simpa only [hlogs] using hcap) + have hvolume:Real.logb Z (volume src)≤Mdecl:=by + have hh:=Real.logb_le_logb_of_le hZ (volume_pos src) hVcap + simpa only [Real.logb_rpow hZpos hZ.ne'] using hh + have hscalar:=actual_high_homogeneous_four_powers M H fixedBadPrimes (Finset.Subset.refl _) + src.η τ C D hC hD hCD E K (volume src) Z sigma delta reserve paid εsrc saving Mdecl Mwidth A Mamp primeLoss + hK (volume_pos src) hZ hsigma hεsrc.le hMdecl0 hMA hMwidth hwidthle hvolume hPrimeLoss.le hMamp hPcard hmod + upper N hupper Hcoef hHcoef front (seed.absNorm:ℝ) (A+1) + (CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap) + hfront hNseed heps1 hNC (fun j=>le_rfl) + dsimp only at hscalar + have hmass:=source_mass_cap src N Mslot hcard hMs + have hmass2:mass src^2≤(max 1 Mslot)^(2*N):=by + calc + _≤((max 1 Mslot)^N)^2:=pow_le_pow_left₀ (mass_nonneg src) hmass 2 + _=_:=by rw [←pow_mul];congr 1;omega + have hheightSplit:=inherited_height_split t height J hheight + let ref:=(τ.modulus.absNorm:ℝ)*(volume src/(C.absNorm:ℝ))^2* + Z^(CenteredMomentFirstMixedAllowance.allowance C D Z) + have href:0≤ref:=by dsimp [ref];positivity + have hsum:0≤∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j):=Finset.sum_nonneg (fun _ _=>Real.rpow_nonneg hZpos.le _) + calc + _≤ref*(Cb*mass src^2*∑j,normalizedPower upper (volume src) (C.absNorm:ℝ) + (τ.modulus.absNorm:ℝ) Z (CenteredMomentFirstMixedAllowance.allowance C D Z) + εsrc (coeff j) N (powers εsrc j)):=hcommonBound + _≤ref*(Cb*mass src^2*((upper^N*avg*front/(seed.absNorm:ℝ))* + Z^(deficit+εsrc*(A+1)+primeLoss)* + ∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j))):=by + apply mul_le_mul_of_nonneg_left _ href + apply mul_le_mul_of_nonneg_left hscalar + exact mul_nonneg hCb.le (sq_nonneg _) + _≤ref*(Cb*(max 1 Mslot)^(2*N)*((upper^N*avg* + (Ca*(C₀+C₁+1)*(p.control U)^2*((1+height)^J*(1+|t|)^(2*J)))/(seed.absNorm:ℝ))* + Z^(deficit+εsrc*(A+1)+primeLoss)* + ∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j))):=by + have hfrontBound:front≤Ca*(C₀+C₁+1)*(p.control U)^2* + ((1+height)^J*(1+|t|)^(2*J)):= + mul_le_mul_of_nonneg_left hheightSplit + (mul_nonneg (mul_nonneg hCa.le + (add_nonneg (add_nonneg hC₀ hC₁) zero_le_one)) (sq_nonneg _)) + apply mul_le_mul_of_nonneg_left _ href + apply mul_le_mul + · exact mul_le_mul_of_nonneg_left hmass2 hCb.le + · apply mul_le_mul_of_nonneg_right _ hsum + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg hZpos.le _) + apply div_le_div_of_nonneg_right _ hNseed.le + exact mul_le_mul_of_nonneg_left hfrontBound + (mul_nonneg (pow_nonneg (zero_le_one.trans hupper) _) havg.le) + · exact mul_nonneg (mul_nonneg + (div_nonneg (mul_nonneg + (mul_nonneg (pow_nonneg (zero_le_one.trans hupper) _) havg.le) hfront) hNseed.le) + (Real.rpow_nonneg hZpos.le _)) hsum + · exact mul_nonneg hCb.le hmcap.le + _=_:=by dsimp only [Ccolumn,ref,deficit,paid,Bcap,delta];ring + +end SevenEighths.CenteredMomentEnergyCanonicalHighColumn + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalHighPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalHighPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..a07dd29bcf9bb1b88eb1a522a0f369de4a86759f --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalHighPhysical.lean @@ -0,0 +1,340 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalHighSource +import OAI.NumberTheory.DirichletL.Energy.CanonicalRightSourceColumn +import OAI.NumberTheory.DirichletL.Energy.FirstColumnPairing +import OAI.NumberTheory.DirichletL.Energy.FirstPhysicalNormalization +import OAI.NumberTheory.DirichletL.Energy.FirstTwoSeedAdmission +import OAI.NumberTheory.DirichletL.Energy.CanonicalLowColumn +import OAI.NumberTheory.DirichletL.Energy.CanonicalAnnularPower +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedColumn +import OAI.NumberTheory.DirichletL.Energy.FirstLowHomogeneousPowers +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedUniform +import OAI.NumberTheory.DirichletL.Energy.AmplifierFamilyAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstLiveAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstAnnularAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstRawScaleAdmission +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPowerBudget +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalHighPhysical +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers +open CenteredMomentEnergyCanonicalLowColumn CenteredMomentFirstNonexceptionalLocalWeightSum + +theorem actual_high_physical + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0|highs i.val|) (max 1 b) (max 1 b) A ξ εphysical + lowerProduct hA hξ.le hεphysical hlowerProduct + choose Cp hCp hp using hphysical + let Cmass:ℝ:=1+∑T:Finset α,Cp T + have hCmass:0(hCp T).le) + dsimp [Cmass];linarith + have hCpCap (T:Finset α):Cp T≤Cmass:=by + have hh:=Finset.single_le_sum (fun T (_:T∈(Finset.univ:Finset (Finset α)))=>(hCp T).le) + (Finset.mem_univ T) + dsimp [Cmass];linarith + refine ⟨UL∪UR,2*(JL+JR),?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨CL,hCL,ZL,hZL,hleft⟩:=hleft η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨CR,hCR,ZR,hZR,hright⟩:=hright η₀ Q hQM hQ0 hQt hQ72 + have hmL:=CenteredMomentSecondWindowBudget.profileMoment_nonneg JL + have hmR:=CenteredMomentSecondWindowBudget.profileMoment_nonneg JR + let Cm:ℝ:=Cmass*(CL+CR)*(1+CenteredMomentSecondWindowBudget.profileMoment JL)* + (1+CenteredMomentSecondWindowBudget.profileMoment JR) + have hCm:0 + CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc (readyBudget A Pcap) j+ + lossVector sigma delta reserve paid εsrc A saving j + let deficit:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)) + let base:=εsrc*(A+1)+primeLoss + let FL:=CL*(C₀+C₁+1)*(p.control UL)^2*(1+height)^JL + let FR:=CR*(C₀+C₁+1)*(p.control UR)^2*(1+height)^JR + let Fcap:ℝ:=(CL+CR)*(C₀+C₁+1)*(p.control (UL∪UR))^2*(1+height)^(JL+JR) + let frontL:=FL*Z^(deficit+base) + let frontR:=FR*Z^(deficit+base) + have hfrontL:0≤frontL:=by dsimp [frontL,FL];positivity + have hfrontR:0≤frontR:=by dsimp [frontR,FR];positivity + have hFcap:0≤Fcap:=by dsimp [Fcap];positivity + have hcontrol (S₁:Finset (ℕ×ℕ))(hs:S₁⊆UL∪UR):p.control S₁≤p.control (UL∪UR):=by + unfold Profiles.control + exact mul_le_mul + (Seminorm.le_def.mp (Finset.sup_mono hs) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hs) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hFL:FL≤Fcap:=by + dsimp [FL,Fcap] + gcongr + · linarith + · exact p.control_nonneg UL + · exact hcontrol UL Finset.subset_union_left + · linarith + · omega + have hFR:FR≤Fcap:=by + dsimp [FR,Fcap] + gcongr + · linarith + · exact p.control_nonneg UR + · exact hcontrol UR Finset.subset_union_right + · linarith + · omega + have hcoeff (F:ℝ)(hF:F≤Fcap)(j:Fin 4): + (F*Z^(deficit+base))*Z^(powers j)≤Fcap*Z^(deficit+ell):=by + rw [mul_assoc,←Real.rpow_add hz] + apply mul_le_mul hF (Real.rpow_le_rpow_of_exponent_le hZ.le ?_) (Real.rpow_nonneg hz.le _) hFcap + have hh:powers j+base≤ell:=by + dsimp [powers,base,paid,delta] + linarith [hfit j] + linarith + have hcols (lab:CenteredMomentFirstNonexceptionalWeightSum.Labels src R0 seed0) + (E:Finset (CommonIndex lab.val.1 lab.val.2)) + (n:CenteredMomentFirstReferenceSource.SourceBlocks src R0 seed0 K Z ξ lab E) + (hne:originalBlock src R0 seed0 (Ψ T) K Z ξ lab E n≠0): + CenteredMomentFirstReferenceEnergy.ColumnBounds src R0 seed0 Z JL JR + (fun j=>frontL*Z^(powers j)) (fun j=>frontR*Z^(powers j)) lab E (fun i=>(n i).val):=by + apply CenteredMomentEnergyFirstColumnPairing.column_bounds_of_reference_sums + · intro innerL hLcap hLsq χ v + let hs:=CenteredMomentFirstReferenceEnergy.supported src R0 seed0 lab + let family:=fixedPair src.η lab.val.1 lab.val.2 hs.1 E χ χ + have hh:=hleft T θ Z hZL' εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max R0 seed0 hR0 hRcap hseed0 + lab.val.1 lab.val.2 hs.1 hs.2 lab.property E χ χ family family.left (Or.inl rfl) + K hK1 (Ψ T) n hne innerL hLsq hLcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ + Mdecl Mwidth θclip hθclip hMA hcap hMdecl hMwidth hdrop hclip hsourceLower hwidthle hrawX₁ hrawX₂ hrawY₁ hrawY₂ v + simpa only [frontL,FL,powers,delta,paid,deficit,base,add_assoc,family,hs, + CenteredMomentAmplificationChildInput.volume,CenteredMomentExceptionalAmplitudePair.volume] using hh + · intro innerL hLcap hLsq χ v + let hs:=CenteredMomentFirstReferenceEnergy.supported src R0 seed0 lab + let family:=fixedPair src.η lab.val.1 lab.val.2 hs.1 E χ χ + have hh:=hright T θ Z hZR' εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max R0 seed0 hR0 hRcap hseed0 + lab.val.1 lab.val.2 hs.1 hs.2 lab.property E χ χ family family.right rfl + K hK1 (Ψ T) n hne innerL hLsq hLcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ + Mdecl Mwidth θclip hθclip hMA hcap hMdecl hMwidth hdrop hclip hsourceLower hwidthle hrawX₁ hrawX₂ hrawY₁ hrawY₂ v + simpa only [frontR,FR,powers,delta,paid,deficit,base,add_assoc,family,hs, + CenteredMomentAmplificationChildInput.volume,CenteredMomentExceptionalAmplitudePair.volume] using hh + have hmass:=(hZp Z ((le_max_left _ _).trans hZZ) T) src R0 seed0 hseed0 hseed00 + (fun i=>by rw [hhiSrc]) (by rwa [abs_of_nonneg hb1]) (by rwa [abs_of_nonneg hb2]) + a a K haPlain haPlain hK hprod hs₁ hs₂ hV hKi Fcap Mdecl ell (fun _=>ell) (fun _=>ell) + (fun j=>frontL*Z^(powers j)) (fun j=>frontR*Z^(powers j)) hFcap + (fun j=>mul_nonneg hfrontL (Real.rpow_nonneg hz.le _)) + (fun j=>mul_nonneg hfrontR (Real.rpow_nonneg hz.le _)) + (hcoeff FL hFL) (hcoeff FR hFR) (fun _=>le_rfl) + (fun _=>le_rfl) (fun lab E _ n hne=>hcols lab E n hne) + have hconst:Cp T*(CL+CR)*CenteredMomentSecondWindowBudget.profileMoment JL* + CenteredMomentSecondWindowBudget.profileMoment JR≤Cm:=by + dsimp [Cm] + gcongr + · exact hCpCap T + · linarith + · linarith + have hheightProduct:(1+height)^(JL+JR)*(1+|src.t|)^(JL+JR)≤ + (1+|src.t|+height)^(2*(JL+JR)):=by + have heq:(1+|src.t|+height)^(2*(JL+JR))= + (1+|src.t|+height)^(JL+JR)*(1+|src.t|+height)^(JL+JR):=by + rw [show 2*(JL+JR)=(JL+JR)+(JL+JR) by omega] + exact pow_add _ _ _ + rw [heq] + apply mul_le_mul + (pow_le_pow_left₀ (by linarith) (by linarith [abs_nonneg src.t]) _) + (pow_le_pow_left₀ (by positivity) (by linarith) _) + (by positivity) (by positivity) + calc + _ ≤ (Cp T*(CL+CR)*CenteredMomentSecondWindowBudget.profileMoment JL* + CenteredMomentSecondWindowBudget.profileMoment JR)*(C₀+C₁+1)* + (p.control (UL∪UR))^2*((1+height)^(JL+JR)*(1+|src.t|)^(JL+JR))* + Z^(Mdecl+ell+εphysical)/(seed0.absNorm:ℝ) := by + apply hmass.trans_eq + dsimp [Fcap] + ring + _ ≤ _ := by gcongr + +end SevenEighths.CenteredMomentEnergyCanonicalHighPhysical + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalHighSource.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalHighSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..8d4bc5f0c5143f4778cada5c215ee8c09ca8d1bc --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalHighSource.lean @@ -0,0 +1,328 @@ +import OAI.NumberTheory.DirichletL.Energy.FirstTwoSeedAdmission +import OAI.NumberTheory.DirichletL.Energy.CanonicalHighColumn +import OAI.NumberTheory.DirichletL.Energy.CanonicalLowColumn +import OAI.NumberTheory.DirichletL.Energy.CanonicalAnnularPower +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedColumn +import OAI.NumberTheory.DirichletL.Energy.FirstLowHomogeneousPowers +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedUniform +import OAI.NumberTheory.DirichletL.Energy.AmplifierFamilyAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstLiveAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstAnnularAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstRawScaleAdmission +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPowerBudget +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalHighSource +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers +open CenteredMomentEnergyCanonicalLowColumn CenteredMomentEnergyCanonicalHighColumn CenteredMomentFirstNonexceptionalLocalWeightSum + +theorem actual_original_left_high_column + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0by rw [hhiSrc i];exact hhighs i.val),hb1,hb1max,hb2,hb2max⟩ + have hW₁:∀x,src.W₁ x≠0→a≤x:=by + intro x hx + have hh:p.profile 0 x≠0:=by simpa only [hp₁] using hx + exact (p.support 0 hh).1 + have hW₂:∀x,src.W₂ x≠0→a≤x:=by + intro x hx + have hh:p.profile 1 x≠0:=by simpa only [hp₂] using hx + exact (p.support 1 hh).1 + have hcols:=actual_common_gates src R0 seed0 hseed0 + (lower_profile_zero src.W₁ a haPlain hW₁) (lower_profile_zero src.W₂ a haPlain hW₂) C D hlabel + have hCD:primeSupport C=primeSupport D:=hcols.2.2.1 + have hseedC:seed0∣C:=hcols.2.2.2.1 + have hDnorm:1≤(D.absNorm:ℝ):=by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hD.1) + have hradius:=hsource.2 Aorig src hcard + (fun i=>by rw [abs_of_nonneg (hends.2.1 i)];exact (src.upper_ge i).trans hupperSrc) + (by simpa only [abs_of_nonneg hb1] using hb1max) + (by simpa only [abs_of_nonneg hb2] using hb2max) R0 seed0 K ξ hK le_rfl hV + (by simpa only [Real.rpow_zero] using inv_le_one_of_one_le₀ hK1) + have hNC:(C.absNorm:ℝ)≤Z^(A+1):=hcols.2.2.2.2.2.1.trans hradius.1 + have hseedne:seed≠0:=hseed.ne_zero + have hseedCap:(seed.absNorm:ℝ)≤Z^Bseed:=by + calc + _≤sourceRadius src/(D.absNorm:ℝ):=hseedcap + _≤sourceRadius src:=div_le_self ((Nat.cast_nonneg C.absNorm).trans hcols.2.2.2.2.2.1) hDnorm + _≤Z^(A+1):=hradius.1 + _≤Z^Bseed:=Real.rpow_le_rpow_of_exponent_le hZ.le hBseed + have hamp:=(hradius.2 ⟨(C,D),hlabel⟩ E n) + have hTspan:=source_nominal_span src R0 seed0 K ⟨(C,D),hlabel⟩ E + have hmod:τ.modulus=src.η.modulus*Ideal.span {fixedBadMask}*Ideal.span {(72:O)}* + Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E*activeConductor C D}:=by + rcases hτ with rfl|rfl + · exact F.left_modulus + · exact F.right_modulus + obtain ⟨hPne,hPcard,hfamilies⟩:=hcolumn Z hZbaseLe + obtain ⟨υ,hυ,hbound⟩:=hfamilies τ + have houter:dyadicScale (n 1)≤4*frequencyRadius + (firstNominalScale C D (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) + K (volume src)) Z ξ:=by simpa only [primeSubsetGenerator,span_idealGenerator,CenteredMomentExceptionalAmplitudePair.volume,CenteredMomentAmplificationChildInput.volume] using hamp.2.2.1 + apply hbound Aorig θ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD hR0 hRcap hNC E hmod + K (dyadicScale (n 1)) hK (zero_lt_one.trans hamp.2.1) houter hamp.2.2.2.1 t seed0 hseedC + seed hseed hseedne hseedCap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip hMdecl0 hMA hwidthle hrawX₁ hrawX₂ hrawY₁ hrawY₂ + hcap hMdecl hMwidth hdrop hclip hsourceLower + intro B hB + have hm:=hmain.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F τ hτ + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun i=>n i) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock false B t hB + refine ⟨?_,?_⟩ + · have hmReady:Ready (child src C R0 B τ t) (R0*C) + (mainRadius C D E K (volume src) Z sigma (frequencyLoss Z (32*1) ξ) reserve) + Z ξ (readyBudget A Pcap):=hm.1 + simpa only [mul_one] using hmReady + · intro prime i χ Bp + obtain ⟨_,_,_,hseparate,hpdata,_⟩:=hsep + have hd:=elementPool_data _ (fun I hI=>(hpdata I hI).1) + (fun I hI=>(hpdata I hI).2.1) prime.val prime.property + let input:=child src C R0 B τ t + let z:CenteredMomentCommonProfile.liveIndices B.val→ℝ:=fun j=>w j.val + have hsupp:∀j,Function.support (input.W j)⊆Set.Iic (max 1 bslot):=by + intro j x hx + exact ((src.support j.val hx).2.trans (hhi j.val)).trans (le_max_right _ _) + have hcop:∀j,∀I∈(activeInput input).slots j,IsCoprime (Ideal.span {prime.val}) I:=by + exact CenteredMomentFirstAmplificationChoice.original_slot_coprime (original input (R0*C) seed).active + Z sigma (max 1 bslot) eta hZ.le (by positivity) hseparate z (fun j=>hweta j.val) + (fun j=>hmatch.scale j.val) hsupp (original input (R0*C) seed).active_slot + (fun j I hI=>input.prime j I ((original input (R0*C) seed).active_subset _ hI)) + _ (hpdata _ hd.2.1).1 (hpdata _ hd.2.1).2.2.1 + have hk:errorIndex i+1=1∨errorIndex i+1=6∨errorIndex i+1=7:=by + have hi:=errorIndex_cases i;omega + have hrad:=hυ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ + have he:=herror.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F τ hτ + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hsigma1 hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun i=>n i) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock false B t seed hB M H fixedBadPrimes (Finset.Subset.refl _) + prime.val prime.property (errorIndex i+1) hk hcop Bp χ + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t + (by simpa only [Nat.add_sub_cancel] using hrad) + rcases he with hdead|hlive + · exact Or.inl hdead.1 + · have hr:Ready (errorInput src C R0 B τ t (Ideal.span {prime.val}) (errorIndex i+1) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t) + ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) + (errorRadius C D E K (volume src) Z sigma (frequencyLoss Z (32*1) ξ) reserve prime.val (errorIndex i+1)) + Z ξ (readyBudget A Pcap):=hlive.1 + exact Or.inr (by simpa only [mul_one] using hr) + +end SevenEighths.CenteredMomentEnergyCanonicalHighSource + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLiveBound.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLiveBound.lean new file mode 100644 index 0000000000000000000000000000000000000000..8163cf81ee21dfefd9587730c2f53a97db0b3ce2 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLiveBound.lean @@ -0,0 +1,155 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalChildBound + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalLiveBound +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +def LiveChild (η:Character)(r:Radial)(D:Ideal O) + (a:Allocation D (Finset.univ:Finset (α⊕Fin 2)))(V₁ V₂:Plain) + (pool:α→Finset (Ideal O))(β:α→Ideal O→ℂ)(P:α→ℝ) + (t X₁ X₂:ℝ)(hX₁:0(0:ℝ)) ?_).trans (tsum_zero) + intro z + by_cases hk:r.keep z + · rw [ite_eq_left hk] + by_cases hφ:(r.profile (‖eisEmbedding z‖^2/r.scale)).re=0 + · rw [hφ,mul_zero] + · have hc:child (naturalCharacter η z) D a V₁ V₂ pool β P t X₁ X₂ hX₁ hX₂ F₁ F₂ J=0:=by + by_contra hh + exact hn ⟨z,hk,hφ,hh⟩ + simp only [hc,norm_zero,zero_pow (by decide:2≠0),zero_mul] + · rw [ite_eq_right hk] + +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_live_canonical_child_bands (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b:ℝ)(haPlain:0hz.1) D alloc V₁ V₂ + d.slots d.coefficient d.P d.P_pos v X₁ X₂ hX₁ hX₂ F₁ F₂ J hF₁ hF₂ hne + change allocatedEnergy τ rad D alloc V₁ V₂ d.slots d.coefficient d.P + v X₁ X₂ hX₁ hX₂ F₁ F₂ J≤_ + rw [he] + have hd:0≤diagonalControl rad.profile:=by unfold diagonalControl;positivity + have hp:=p.control_nonneg T + positivity + +end SevenEighths.CenteredMomentEnergyCanonicalLiveBound + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLiveCapacity.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLiveCapacity.lean new file mode 100644 index 0000000000000000000000000000000000000000..dc7a82f5c11dec2a8a1cedec0124cc8f5a2be0cf --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLiveCapacity.lean @@ -0,0 +1,78 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalLiveBound +import OAI.NumberTheory.DirichletL.Energy.DeletedChildCapacity + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap + +namespace SevenEighths.CenteredMomentEnergyCanonicalLiveCapacity +open HeckeFamily ConcreteTraceCRT CenteredMomentEnergyCanonicalLiveBound +open CenteredMomentCommonRadialData CenteredMomentCommonAllocationSum +open CenteredMomentCommonHeightEnvelope CenteredMomentAllocatedRayDictionary +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentAllocatedNaturalRadial CenteredMomentRetainedProfile +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyBands +open CenteredMomentEnergyDeletedChildCapacity CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +lemma original_deleted_excess (src:Input α)(C R:Ideal O)(B:actualAllocations src.pools C) + (D:Ideal O)(alloc:Allocation D (Finset.univ:Finset + (CenteredMomentCommonProfile.liveIndices B.val⊕Fin 2))) + (J:Finset (CenteredMomentCommonProfile.liveIndices B.val)) + (τ:Character)(v Z X₁ X₂ κ Mactual:ℝ)(w:α→ℝ) + (hZ:1HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers + +lemma source_mass_cap {ι:Type*}[Fintype ι](s:Input ι)(N:ℕ)(Mslot:ℝ) + (hc:Fintype.card ι≤N)(hM:∀i,s.M i≤Mslot):mass s≤(max 1 Mslot)^N:=by + calc + _≤∏i:ι,max 1 Mslot:=by + apply Finset.prod_le_prod₀ + · intro i _;exact zero_le_one.trans (s.M_ge_one i) + · intro i _;exact (hM i).trans (le_max_right _ _) + _=(max 1 Mslot)^Fintype.card ι:=by simp + _≤_:=pow_le_pow_right₀ (le_max_left _ _) hc + +lemma inherited_height_split (t height:ℝ)(J:ℕ)(hh:0≤height): + (1+|t|+height)^J≤(1+height)^J*(1+|t|)^(2*J):=by + have hbase:1+|t|+height≤(1+height)*(1+|t|):=by + nlinarith [abs_nonneg t,mul_nonneg hh (abs_nonneg t)] + calc + _≤((1+height)*(1+|t|))^J:=pow_le_pow_left₀ (by positivity) hbase J + _=(1+height)^J*(1+|t|)^J:=mul_pow _ _ _ + _≤_:=mul_le_mul_of_nonneg_left + (pow_le_pow_right₀ (by linarith [abs_nonneg t]) (by omega:J≤2*J)) (by positivity) + +theorem actual_admitted_subsets_low_column + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K H0:ℝ,0P.val) E}) K (volume src)) Z ξ → + 8*H0≤Z^(amplifierCap A 0 ξ) → + ∀(t:ℝ)(seed0:Ideal O),seed0∣C → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → 0≤Mdecl → Mdecl≤A → + Real.logb Z (volume src)≤5*Mdecl/6 → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + a0≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + (∀B:actualAllocations src.pools C, + frozenCoefficient B.val C R0 src.ν src.W src.P≠0 → + Ready (child src C R0 B τ t) (R0*C) + (mainRadius C D E K (volume src) Z sigma (frequencyLoss Z 32 ξ) reserve) Z ξ (readyBudget A Pcap) ∧ + (∀prime:elementPool P,∀i:Fin 3,∀χ:RayCharacter, + ∀Bp:actualAllocations (activeInput (child src C R0 B τ t)).pools ((Ideal.span {prime.val})^(errorIndex i+1)), + let d:=errorInput src C R0 B τ t (Ideal.span {prime.val}) (errorIndex i+1) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t; + (∀I:Ideal O,coefficient d ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) seed I=0) ∨ + Ready d ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) + (errorRadius C D E K (volume src) Z sigma (frequencyLoss Z 32 ξ) reserve prime (errorIndex i+1)) + Z ξ (readyBudget A Pcap))) → + let delta:=frequencyLoss Z 32 ξ; + let Bcap:=readyBudget A Pcap; + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + let deficit:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)); + let ref:=(τ.modulus.absNorm:ℝ)*(volume src/(C.absNorm:ℝ))^2*Z^(CenteredMomentFirstMixedAllowance.allowance C D Z); + (commonEnergy (original src R0 seed0) C hC τ t seed + CenteredMomentFirstAnnularMajorant.profile H0).re≤ + (ref/(seed.absNorm:ℝ))*(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+height)^Jheight* + Z^(deficit+εsrc*(A+1)+primeLoss)* + ∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j))*(1+|t|)^(2*Jheight) :=by + obtain ⟨U,J,hann⟩:=actual_original_subsets_annular_power (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bseed ξ saving + hεsrc hδsrc hθsrc hξ sigma hsigma hξsmall A Pcap eta primeLoss reserve + hA hPcap heta hPrimeLoss hsigma1 hξ1 hreserve + obtain ⟨Cb,hCb,hcommon⟩:=common_energy_reference_powers N lower upper εsrc hlower hupper hεsrc + let Mamp:=amplifierCap A 0 ξ + let avg:=56*((Mamp+2*sigma)/(sigma/6)+1872*(Fintype.card RayCharacter:ℝ)) + have hMamp:0≤Mamp:=by dsimp [Mamp,amplifierCap];positivity + have havg:0 + errorRadius C D E K (volume src) Z sigma delta reserve prime (errorIndex i+1) + let rerror:=fun (prime:elementPool P)(i:Fin 3)(_:RayCharacter)=> + rmain-errorRemoval prime Z (errorIndex i+1) + let front:=Ca*(C₀+C₁+1)*(p.control U)^2*(1+|t|+height)^J + let Hcoef:=fun j:Fin 4=>front* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ) + let amain:=fun j=>Hcoef j*mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) deficit paid saving rmain j + let aerror:=fun (prime:elementPool P)(i:Fin 3)(χ:RayCharacter)(j:Fin 4)=> + Hcoef j*errorPowers prime (errorIndex i+1) (τ.modulus.absNorm:ℝ) Z + (Kerror prime i χ) deficit paid saving (rerror prime i χ) j + let coeff:=sourceCoefficients P ((Mamp+2*sigma)/(sigma/6)) amain aerror (powers εsrc) + have hNseed:0<(seed.absNorm:ℝ):=CenteredMomentFirstScale.norm_pos _ hseedne + have hq:0<(τ.modulus.absNorm:ℝ):=CenteredMomentFirstScale.norm_pos _ τ.modulus_ne_bot + have hfront:0≤front:=by dsimp [front];positivity + have hHcoef:∀j,0≤Hcoef j:=by intro j;dsimp [Hcoef];positivity + have hKmain:0≤Kmain:=by unfold Kmain mainRadius mainCommonRadius;positivity + have hKerror:∀prime i χ,0≤Kerror prime i χ:=by + intro prime i χ;unfold Kerror errorRadius errorCommonRadius;positivity + have hcoeff:∀j,0≤coeff j:=source_coefficients_nonneg P _ (by positivity) + amain aerror (powers εsrc) + (fun j=>mul_nonneg (hHcoef j) (main_coefficients_nonneg _ _ _ _ _ _ _ _ hq.le hZpos.le hKmain j)) + (fun prime i χ j=>mul_nonneg (hHcoef j) + (error_coefficients_nonneg _ _ _ _ _ _ _ _ _ hq.le hZpos.le (hKerror prime i χ) j)) + have hchildren (B:actualAllocations src.pools C) + (hB:frozenCoefficient B.val C R0 src.ν src.W src.P≠0): + childNormalizedGaussSource src C R0 seed B τ t CenteredMomentFirstAnnularMajorant.profile H0≤ + (∑j,coeff j*(volume (child src C R0 B τ t))^(powers εsrc j))*mass (child src C R0 B τ t)^2:=by + exact henergy Aorig θ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD hR0 hRcap hNC E hmod + K H0 hK hH0 houter hHcap B t hB seed hseed hseedne hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ + Mdecl Mwidth θclip hθclip hcap hMdecl hMwidth hdrop hclip hsourceLower + (hpackets B hB).1 (hpackets B hB).2 + have hcommonBound:=hcommon src hcard hlowerSrc hupperSrc C R0 seed0 hC hseed0 τ t seed + CenteredMomentFirstAnnularMajorant.profile H0 Z (CenteredMomentFirstMixedAllowance.allowance C D Z) + hH0 hZpos (fun z=>CenteredMomentFirstAnnularMajorant.profile_nonneg _) 4 coeff (powers εsrc) + hcoeff (powers_nonneg εsrc hεsrc.le) hchildren + have hscalar:=actual_low_homogeneous_four_powers M H fixedBadPrimes (Finset.Subset.refl _) + src.η τ C D hC hD hCD E K (volume src) Z sigma delta reserve paid εsrc saving Mdecl A Mamp primeLoss + hK (volume_pos src) hZ hsigma hεsrc.le hMdecl0 hMA hMdecl hlow hPrimeLoss.le hMamp hPcard hmod + upper N hupper Hcoef hHcoef front (seed.absNorm:ℝ) (A+1) + (CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap) + hfront hNseed heps1 hNC (fun j=>le_rfl) rmain rerror + dsimp only at hscalar + have hmass:=source_mass_cap src N Mslot hcard hMs + have hmass2:mass src^2≤(max 1 Mslot)^(2*N):=by + calc + _≤((max 1 Mslot)^N)^2:=pow_le_pow_left₀ (mass_nonneg src) hmass 2 + _=_:=by rw [←pow_mul];congr 1;omega + have hheightSplit:=inherited_height_split t height J hheight + let ref:=(τ.modulus.absNorm:ℝ)*(volume src/(C.absNorm:ℝ))^2* + Z^(CenteredMomentFirstMixedAllowance.allowance C D Z) + have href:0≤ref:=by dsimp [ref];positivity + have hsum:0≤∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j):=Finset.sum_nonneg (fun _ _=>Real.rpow_nonneg hZpos.le _) + calc + _≤ref*(Cb*mass src^2*∑j,normalizedPower upper (volume src) (C.absNorm:ℝ) + (τ.modulus.absNorm:ℝ) Z (CenteredMomentFirstMixedAllowance.allowance C D Z) + εsrc (coeff j) N (powers εsrc j)):=hcommonBound + _≤ref*(Cb*mass src^2*((upper^N*avg*front/(seed.absNorm:ℝ))* + Z^(deficit+εsrc*(A+1)+primeLoss)* + ∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j))):=by + apply mul_le_mul_of_nonneg_left _ href + apply mul_le_mul_of_nonneg_left hscalar + exact mul_nonneg hCb.le (sq_nonneg _) + _≤ref*(Cb*(max 1 Mslot)^(2*N)*((upper^N*avg* + (Ca*(C₀+C₁+1)*(p.control U)^2*((1+height)^J*(1+|t|)^(2*J)))/(seed.absNorm:ℝ))* + Z^(deficit+εsrc*(A+1)+primeLoss)* + ∑j:Fin 4,Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j+ + lossVector sigma delta reserve paid εsrc A saving j))):=by + have hfrontBound:front≤Ca*(C₀+C₁+1)*(p.control U)^2* + ((1+height)^J*(1+|t|)^(2*J)):= + mul_le_mul_of_nonneg_left hheightSplit + (mul_nonneg (mul_nonneg hCa.le + (add_nonneg (add_nonneg hC₀ hC₁) zero_le_one)) (sq_nonneg _)) + apply mul_le_mul_of_nonneg_left _ href + apply mul_le_mul + · exact mul_le_mul_of_nonneg_left hmass2 hCb.le + · apply mul_le_mul_of_nonneg_right _ hsum + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg hZpos.le _) + apply div_le_div_of_nonneg_right _ hNseed.le + exact mul_le_mul_of_nonneg_left hfrontBound + (mul_nonneg (pow_nonneg (zero_le_one.trans hupper) _) havg.le) + · exact mul_nonneg (mul_nonneg + (div_nonneg (mul_nonneg + (mul_nonneg (pow_nonneg (zero_le_one.trans hupper) _) havg.le) hfront) hNseed.le) + (Real.rpow_nonneg hZpos.le _)) hsum + · exact mul_nonneg hCb.le hmcap.le + _=_:=by dsimp only [Ccolumn,ref,deficit,paid,Bcap,delta];ring + +end SevenEighths.CenteredMomentEnergyCanonicalLowColumn + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLowPhysical.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLowPhysical.lean new file mode 100644 index 0000000000000000000000000000000000000000..3a2d36ff37797543a9453199c3b9eec44ae34cc9 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLowPhysical.lean @@ -0,0 +1,338 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalLowSource +import OAI.NumberTheory.DirichletL.Energy.CanonicalRightSourceColumn +import OAI.NumberTheory.DirichletL.Energy.FirstColumnPairing +import OAI.NumberTheory.DirichletL.Energy.FirstPhysicalNormalization +import OAI.NumberTheory.DirichletL.Energy.FirstTwoSeedAdmission +import OAI.NumberTheory.DirichletL.Energy.CanonicalLowColumn +import OAI.NumberTheory.DirichletL.Energy.CanonicalAnnularPower +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedColumn +import OAI.NumberTheory.DirichletL.Energy.FirstLowHomogeneousPowers +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedUniform +import OAI.NumberTheory.DirichletL.Energy.AmplifierFamilyAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstLiveAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstAnnularAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstRawScaleAdmission +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPowerBudget +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalLowPhysical +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers +open CenteredMomentEnergyCanonicalLowColumn CenteredMomentFirstNonexceptionalLocalWeightSum + +theorem actual_low_physical + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0|highs i.val|) (max 1 b) (max 1 b) A ξ εphysical + lowerProduct hA hξ.le hεphysical hlowerProduct + choose Cp hCp hp using hphysical + let Cmass:ℝ:=1+∑T:Finset α,Cp T + have hCmass:0(hCp T).le) + dsimp [Cmass];linarith + have hCpCap (T:Finset α):Cp T≤Cmass:=by + have hh:=Finset.single_le_sum (fun T (_:T∈(Finset.univ:Finset (Finset α)))=>(hCp T).le) + (Finset.mem_univ T) + dsimp [Cmass];linarith + refine ⟨UL∪UR,2*(JL+JR),?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨CL,hCL,ZL,hZL,hleft⟩:=hleft η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨CR,hCR,ZR,hZR,hright⟩:=hright η₀ Q hQM hQ0 hQt hQ72 + have hmL:=CenteredMomentSecondWindowBudget.profileMoment_nonneg JL + have hmR:=CenteredMomentSecondWindowBudget.profileMoment_nonneg JR + let Cm:ℝ:=Cmass*(CL+CR)*(1+CenteredMomentSecondWindowBudget.profileMoment JL)* + (1+CenteredMomentSecondWindowBudget.profileMoment JR) + have hCm:0 + CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc (readyBudget A Pcap) j+ + lossVector sigma delta reserve paid εsrc A saving j + let deficit:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)) + let base:=εsrc*(A+1)+primeLoss + let FL:=CL*(C₀+C₁+1)*(p.control UL)^2*(1+height)^JL + let FR:=CR*(C₀+C₁+1)*(p.control UR)^2*(1+height)^JR + let Fcap:ℝ:=(CL+CR)*(C₀+C₁+1)*(p.control (UL∪UR))^2*(1+height)^(JL+JR) + let frontL:=FL*Z^(deficit+base) + let frontR:=FR*Z^(deficit+base) + have hfrontL:0≤frontL:=by dsimp [frontL,FL];positivity + have hfrontR:0≤frontR:=by dsimp [frontR,FR];positivity + have hFcap:0≤Fcap:=by dsimp [Fcap];positivity + have hcontrol (S₁:Finset (ℕ×ℕ))(hs:S₁⊆UL∪UR):p.control S₁≤p.control (UL∪UR):=by + unfold Profiles.control + exact mul_le_mul + (Seminorm.le_def.mp (Finset.sup_mono hs) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hs) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hFL:FL≤Fcap:=by + dsimp [FL,Fcap] + gcongr + · linarith + · exact p.control_nonneg UL + · exact hcontrol UL Finset.subset_union_left + · linarith + · omega + have hFR:FR≤Fcap:=by + dsimp [FR,Fcap] + gcongr + · linarith + · exact p.control_nonneg UR + · exact hcontrol UR Finset.subset_union_right + · linarith + · omega + have hcoeff (F:ℝ)(hF:F≤Fcap)(j:Fin 4): + (F*Z^(deficit+base))*Z^(powers j)≤Fcap*Z^(deficit+ell):=by + rw [mul_assoc,←Real.rpow_add hz] + apply mul_le_mul hF (Real.rpow_le_rpow_of_exponent_le hZ.le ?_) (Real.rpow_nonneg hz.le _) hFcap + have hh:powers j+base≤ell:=by + dsimp [powers,base,paid,delta] + linarith [hfit j] + linarith + have hcols (lab:CenteredMomentFirstNonexceptionalWeightSum.Labels src R0 seed0) + (E:Finset (CommonIndex lab.val.1 lab.val.2)) + (n:CenteredMomentFirstReferenceSource.SourceBlocks src R0 seed0 K Z ξ lab E) + (hne:originalBlock src R0 seed0 (Ψ T) K Z ξ lab E n≠0): + CenteredMomentFirstReferenceEnergy.ColumnBounds src R0 seed0 Z JL JR + (fun j=>frontL*Z^(powers j)) (fun j=>frontR*Z^(powers j)) lab E (fun i=>(n i).val):=by + apply CenteredMomentEnergyFirstColumnPairing.column_bounds_of_reference_sums + · intro innerL hLcap hLsq χ v + let hs:=CenteredMomentFirstReferenceEnergy.supported src R0 seed0 lab + let family:=fixedPair src.η lab.val.1 lab.val.2 hs.1 E χ χ + have hh:=hleft T θ Z hZL' εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max R0 seed0 hR0 hRcap hseed0 + lab.val.1 lab.val.2 hs.1 hs.2 lab.property E χ χ family family.left (Or.inl rfl) + K hK1 (Ψ T) n hne innerL hLsq hLcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ + Mdecl Mwidth θclip hθclip hMA hcap hMdecl hMwidth hdrop hclip hsourceLower hlow v + simpa only [frontL,FL,powers,delta,paid,deficit,base,add_assoc,family,hs, + CenteredMomentAmplificationChildInput.volume,CenteredMomentExceptionalAmplitudePair.volume] using hh + · intro innerL hLcap hLsq χ v + let hs:=CenteredMomentFirstReferenceEnergy.supported src R0 seed0 lab + let family:=fixedPair src.η lab.val.1 lab.val.2 hs.1 E χ χ + have hh:=hright T θ Z hZR' εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max R0 seed0 hR0 hRcap hseed0 + lab.val.1 lab.val.2 hs.1 hs.2 lab.property E χ χ family family.right rfl + K hK1 (Ψ T) n hne innerL hLsq hLcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ + Mdecl Mwidth θclip hθclip hMA hcap hMdecl hMwidth hdrop hclip hsourceLower hlow v + simpa only [frontR,FR,powers,delta,paid,deficit,base,add_assoc,family,hs, + CenteredMomentAmplificationChildInput.volume,CenteredMomentExceptionalAmplitudePair.volume] using hh + have hmass:=(hZp Z ((le_max_left _ _).trans hZZ) T) src R0 seed0 hseed0 hseed00 + (fun i=>by rw [hhiSrc]) (by rwa [abs_of_nonneg hb1]) (by rwa [abs_of_nonneg hb2]) + a a K haPlain haPlain hK hprod hs₁ hs₂ hV hKi Fcap Mdecl ell (fun _=>ell) (fun _=>ell) + (fun j=>frontL*Z^(powers j)) (fun j=>frontR*Z^(powers j)) hFcap + (fun j=>mul_nonneg hfrontL (Real.rpow_nonneg hz.le _)) + (fun j=>mul_nonneg hfrontR (Real.rpow_nonneg hz.le _)) + (hcoeff FL hFL) (hcoeff FR hFR) (fun _=>le_rfl) + (fun _=>le_rfl) (fun lab E _ n hne=>hcols lab E n hne) + have hconst:Cp T*(CL+CR)*CenteredMomentSecondWindowBudget.profileMoment JL* + CenteredMomentSecondWindowBudget.profileMoment JR≤Cm:=by + dsimp [Cm] + gcongr + · exact hCpCap T + · linarith + · linarith + have hheightProduct:(1+height)^(JL+JR)*(1+|src.t|)^(JL+JR)≤ + (1+|src.t|+height)^(2*(JL+JR)):=by + have heq:(1+|src.t|+height)^(2*(JL+JR))= + (1+|src.t|+height)^(JL+JR)*(1+|src.t|+height)^(JL+JR):=by + rw [show 2*(JL+JR)=(JL+JR)+(JL+JR) by omega] + exact pow_add _ _ _ + rw [heq] + apply mul_le_mul + (pow_le_pow_left₀ (by linarith) (by linarith [abs_nonneg src.t]) _) + (pow_le_pow_left₀ (by positivity) (by linarith) _) + (by positivity) (by positivity) + calc + _ ≤ (Cp T*(CL+CR)*CenteredMomentSecondWindowBudget.profileMoment JL* + CenteredMomentSecondWindowBudget.profileMoment JR)*(C₀+C₁+1)* + (p.control (UL∪UR))^2*((1+height)^(JL+JR)*(1+|src.t|)^(JL+JR))* + Z^(Mdecl+ell+εphysical)/(seed0.absNorm:ℝ) := by + apply hmass.trans_eq + dsimp [Fcap] + ring + _ ≤ _ := by gcongr + +end SevenEighths.CenteredMomentEnergyCanonicalLowPhysical + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLowSource.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLowSource.lean new file mode 100644 index 0000000000000000000000000000000000000000..4e6e3d205c31f7ccb37c4d8157d0e64fcb87488b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalLowSource.lean @@ -0,0 +1,325 @@ +import OAI.NumberTheory.DirichletL.Energy.FirstTwoSeedAdmission +import OAI.NumberTheory.DirichletL.Energy.CanonicalLowColumn +import OAI.NumberTheory.DirichletL.Energy.CanonicalAnnularPower +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedColumn +import OAI.NumberTheory.DirichletL.Energy.FirstLowHomogeneousPowers +import OAI.NumberTheory.DirichletL.Energy.CanonicalAmplifiedUniform +import OAI.NumberTheory.DirichletL.Energy.AmplifierFamilyAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstLiveAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstAnnularAdmission +import OAI.NumberTheory.DirichletL.Energy.FirstRawScaleAdmission +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPowerBudget +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalErrorSubsets +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalLowSource +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers +open CenteredMomentEnergyCanonicalLowColumn CenteredMomentFirstNonexceptionalLocalWeightSum + +theorem actual_original_left_low_column + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0by rw [hhiSrc i];exact hhighs i.val),hb1,hb1max,hb2,hb2max⟩ + have hW₁:∀x,src.W₁ x≠0→a≤x:=by + intro x hx + have hh:p.profile 0 x≠0:=by simpa only [hp₁] using hx + exact (p.support 0 hh).1 + have hW₂:∀x,src.W₂ x≠0→a≤x:=by + intro x hx + have hh:p.profile 1 x≠0:=by simpa only [hp₂] using hx + exact (p.support 1 hh).1 + have hcols:=actual_common_gates src R0 seed0 hseed0 + (lower_profile_zero src.W₁ a haPlain hW₁) (lower_profile_zero src.W₂ a haPlain hW₂) C D hlabel + have hCD:primeSupport C=primeSupport D:=hcols.2.2.1 + have hseedC:seed0∣C:=hcols.2.2.2.1 + have hDnorm:1≤(D.absNorm:ℝ):=by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hD.1) + have hradius:=hsource.2 Aorig src hcard + (fun i=>by rw [abs_of_nonneg (hends.2.1 i)];exact (src.upper_ge i).trans hupperSrc) + (by simpa only [abs_of_nonneg hb1] using hb1max) + (by simpa only [abs_of_nonneg hb2] using hb2max) R0 seed0 K ξ hK le_rfl hV + (by simpa only [Real.rpow_zero] using inv_le_one_of_one_le₀ hK1) + have hNC:(C.absNorm:ℝ)≤Z^(A+1):=hcols.2.2.2.2.2.1.trans hradius.1 + have hseedne:seed≠0:=hseed.ne_zero + have hseedCap:(seed.absNorm:ℝ)≤Z^Bseed:=by + calc + _≤sourceRadius src/(D.absNorm:ℝ):=hseedcap + _≤sourceRadius src:=div_le_self ((Nat.cast_nonneg C.absNorm).trans hcols.2.2.2.2.2.1) hDnorm + _≤Z^(A+1):=hradius.1 + _≤Z^Bseed:=Real.rpow_le_rpow_of_exponent_le hZ.le hBseed + have hamp:=(hradius.2 ⟨(C,D),hlabel⟩ E n) + have hTspan:=source_nominal_span src R0 seed0 K ⟨(C,D),hlabel⟩ E + have hmod:τ.modulus=src.η.modulus*Ideal.span {fixedBadMask}*Ideal.span {(72:O)}* + Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E*activeConductor C D}:=by + rcases hτ with rfl|rfl + · exact F.left_modulus + · exact F.right_modulus + obtain ⟨hPne,hPcard,hfamilies⟩:=hcolumn Z hZbaseLe + obtain ⟨υ,hυ,hbound⟩:=hfamilies τ + have houter:dyadicScale (n 1)≤4*frequencyRadius + (firstNominalScale C D (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) + K (volume src)) Z ξ:=by simpa only [primeSubsetGenerator,span_idealGenerator,CenteredMomentExceptionalAmplitudePair.volume,CenteredMomentAmplificationChildInput.volume] using hamp.2.2.1 + apply hbound Aorig θ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD hR0 hRcap hNC E hmod + K (dyadicScale (n 1)) hK (zero_lt_one.trans hamp.2.1) houter hamp.2.2.2.1 t seed0 hseedC + seed hseed hseedne hseedCap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip hMdecl0 hMA hlow + hcap hMdecl hMwidth hdrop hclip hsourceLower + intro B hB + have hm:=hmain.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F τ hτ + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun i=>n i) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock false B t hB + refine ⟨?_,?_⟩ + · have hmReady:Ready (child src C R0 B τ t) (R0*C) + (mainRadius C D E K (volume src) Z sigma (frequencyLoss Z (32*1) ξ) reserve) + Z ξ (readyBudget A Pcap):=hm.1 + simpa only [mul_one] using hmReady + · intro prime i χ Bp + obtain ⟨_,_,_,hseparate,hpdata,_⟩:=hsep + have hd:=elementPool_data _ (fun I hI=>(hpdata I hI).1) + (fun I hI=>(hpdata I hI).2.1) prime.val prime.property + let input:=child src C R0 B τ t + let z:CenteredMomentCommonProfile.liveIndices B.val→ℝ:=fun j=>w j.val + have hsupp:∀j,Function.support (input.W j)⊆Set.Iic (max 1 bslot):=by + intro j x hx + exact ((src.support j.val hx).2.trans (hhi j.val)).trans (le_max_right _ _) + have hcop:∀j,∀I∈(activeInput input).slots j,IsCoprime (Ideal.span {prime.val}) I:=by + exact CenteredMomentFirstAmplificationChoice.original_slot_coprime (original input (R0*C) seed).active + Z sigma (max 1 bslot) eta hZ.le (by positivity) hseparate z (fun j=>hweta j.val) + (fun j=>hmatch.scale j.val) hsupp (original input (R0*C) seed).active_slot + (fun j I hI=>input.prime j I ((original input (R0*C) seed).active_subset _ hI)) + _ (hpdata _ hd.2.1).1 (hpdata _ hd.2.1).2.2.1 + have hk:errorIndex i+1=1∨errorIndex i+1=6∨errorIndex i+1=7:=by + have hi:=errorIndex_cases i;omega + have hrad:=hυ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ + have he:=herror.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F τ hτ + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hsigma1 hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun i=>n i) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock false B t seed hB M H fixedBadPrimes (Finset.Subset.refl _) + prime.val prime.property (errorIndex i+1) hk hcop Bp χ + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t + (by simpa only [Nat.add_sub_cancel] using hrad) + rcases he with hdead|hlive + · exact Or.inl hdead.1 + · have hr:Ready (errorInput src C R0 B τ t (Ideal.span {prime.val}) (errorIndex i+1) Bp + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t) + ((R0*C)*(Ideal.span {prime.val})^(errorIndex i+1)) + (errorRadius C D E K (volume src) Z sigma (frequencyLoss Z (32*1) ξ) reserve prime.val (errorIndex i+1)) + Z ξ (readyBudget A Pcap):=hlive.1 + exact Or.inr (by simpa only [mul_one] using hr) + +end SevenEighths.CenteredMomentEnergyCanonicalLowSource + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainGaussian.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainGaussian.lean new file mode 100644 index 0000000000000000000000000000000000000000..149d54db73c4a8ca82646702cba3346c2b57c054 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainGaussian.lean @@ -0,0 +1,255 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainGaussian +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_main_gaussian_from_bands + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K sigma delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + Ready input (R0*C) Kmain Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀Scols:Finset (Ideal O),∀β:Ideal O→ℂ, + Scols=finiteColumns (Fintype.piFinset input.pools) → + β=coefficient input (R0*C) seed → + ∃family:(q:ActiveLabel Scols β)→Finset (CommonIndex q.val.1 q.val.2)→RayCharacter→Character, + (∀q U,Family input.η q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U (family q U)) ∧ + ∀χ₀:RayCharacter,∀m:O,m≠0 → goodLambda∣m → (2:O)∣m → + (∀q∈liveLabels input.η Scols β,∀U:Finset (CommonIndex q.val.1 q.val.2), + ∀dyad:SourceBlocks q.val.1 q.val.2 U Kmain (frequencyRadius (nominal input Kmain) Z ξ) + (sourceRadius input), + physicalBlock input.η input.t (activeSource Scols β) β q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U + (frequencyRadius (nominal input Kmain) Z ξ) + (partRows false input.η χ₀ (internalQ Q η₀) m q.val.1 q.val.2 U + (frequencyRadius (nominal input Kmain) Z ξ)) + CenteredMomentFirstAmplificationChoice.ballProfile Kmain (fun i=>(dyad i:ℤ))≠0 → + ∀χ:RayCharacter,Real.logb Z (dyadicScale (dyad 1))+ + Real.logb Z ((family q U χ).modulus.absNorm:ℝ)≤Mcap) → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let Echild:=CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((Bcap+Bcap)*εmask+(εchild+εremove+ + (sigma/3+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3)+κ*mesh)) + normalizedGaussSource input (R0*C) seed CenteredMomentFirstAmplificationChoice.ballProfile Kmain≤ + (∑j,coefficients N upper (max 1 b) (max 1 b) (mass src) Sp p J (internalQ Q η₀) Kc t + εsrc (seed.absNorm:ℝ) + (seededFactors Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap saving Kmain t + (cost*(τ.modulus.absNorm:ℝ)) Echild Echild r (∏i,input.lo i) a (seed.absNorm:ℝ) + (dc+degree+4*n) (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile) j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,hmain⟩:= + CenteredMomentEnergyCanonicalMainUniform.actual_main_uniform_child (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain L hL + degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ + N lower upper a0 Bcap Bcap θsource hlower ha0 hθsource + obtain ⟨J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hgauss⟩:= + actual_subsets_seeded_gaussian_power a b haPlain hbPlain lows highs hhighs + CenteredMomentFirstAmplificationChoice.ballProfile (dc+degree+4*n) (dc+degree+4*n) + N upper (max 1 b) (max 1 b) hupper (le_max_left _ _) (le_max_left _ _) + εsrc δsrc θsrc Bcap Bseed ξ saving hεsrc hδsrc hθsrc hBcap hξ + refine ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Zm,hZm,hm⟩:=hmain η₀ + obtain ⟨Kc,hKc,hevent⟩:=hgauss (internalQ Q η₀) hQ0 hQt hQ72 + obtain ⟨Zg,hZg⟩:=Filter.eventually_atTop.1 hevent + refine ⟨Kc,hKc,max Zm Zg,lt_of_lt_of_le hZm (le_max_left _ _),?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip + hcap hMdecl hclip hsourceLower Scols β hScols hβ + let input:=child src C R0 B τ t + let Km:=mainCommonRadius Z (Real.logb Z (D.absNorm:ℝ)) + (Real.logb Z (firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + have hZmZ:Zm≤Z:=(le_max_left _ _).trans hZ + have hgZ:=hZg Z ((le_max_right _ _).trans hZ) + have hz:1hloSrc i.val) (fun i=>hhiSrc i.val) hP hp₁.symm hp₂.symm (mass src) + hupperSrc hcardInput hb1 hb2 hb1max hb2max (child_mass src C R0 B τ t) + (R0*C) seed hready.puncture_ne hseed hseed0 hseedcap hready.source_nonneg hready.source_cap + hready.conductor_cap hready.puncture_cap + change Scols=finiteColumns (Fintype.piFinset input.pools) at hScols + change β=coefficient input (R0*C) seed at hβ + dsimp only at hsource + subst Scols β + obtain ⟨family,hfamily,hbound⟩:=hsource + refine ⟨family,hfamily,?_⟩ + intro χ₀ m hm0 hml hm2 hwidth r hr1 hr2 hr3 hr4 + let Ec:=CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((Bcap+Bcap)*εmask+(εchild+εremove+ + (sigma/3+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3)+κ*mesh)) + have hEc:0≤Ec:=CenteredMomentEnergyChildEnvelopeFitting.coefficient_nonneg + Cc C₀ C₁ p T height (dc+degree+4*n) Z _ hCc.le hC₀ hC₁ hheight (zero_le_one.trans hz.le) + have hpzero (j:Fin 2):p.profile j 0=0:=by + by_contra hn + exact (not_le_of_gt haPlain) ((p.support j hn).1) + have hz1:input.W₁ 0=0:=by change src.W₁ 0=0;rw [←hp₁];exact hpzero 0 + have hz2:input.W₂ 0=0:=by change src.W₂ 0=0;rw [←hp₂];exact hpzero 1 + apply hbound χ₀ m hm0 hml hm2 Km (nominal input Km) hready.scale_pos hready.volume_cap + hready.nominal_cap (le_refl _) hready.frequency_pos hready.frequency_cap + (cost*(τ.modulus.absNorm:ℝ)) + (mul_pos (zero_lt_one.trans_le hcost) (norm_pos τ.modulus τ.modulus_ne_bot)) + Ec Ec hEc hEc ?_ ?_ r hr1 hr2 hr3 hr4 + all_goals + intro q hq U dyad hphysical D0 hD0 hD0cap hD0sq χ v B₂ hB₂ alloc halloc + have hg:=actual_common_gates input (R0*C) seed hseed hz1 hz2 q.val.1 q.val.2 q.property + have hs:=commonLabels_supported (activeSource _ _) _ _ q.property + · exact hm θ Z hZmZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hcard hlowerSrc hupperSrc C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + _ _ q.val.1 q.val.2 hs.1 hs.2 hg.2.2.1 U _ _ _ (fun i=>(dyad i:ℤ)) + hlowerBeta hphysical (family q U) (hfamily q U) χ (hwidth q hq U dyad hphysical χ) + q.val.1 (R0*C) (Or.inl rfl) hready.puncture_ne hready.puncture_cap + (hg.2.2.2.2.2.1.trans hready.source_cap) B₂ hB₂ D0 alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + · exact hm θ Z hZmZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hcard hlowerSrc hupperSrc C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + _ _ q.val.1 q.val.2 hs.1 hs.2 hg.2.2.1 U _ _ _ (fun i=>(dyad i:ℤ)) + hlowerBeta hphysical (family q U) (hfamily q U) χ (hwidth q hq U dyad hphysical χ) + q.val.2 (R0*C) (Or.inr rfl) hready.puncture_ne hready.puncture_cap + (hg.2.2.2.2.2.2.trans hready.source_cap) B₂ hB₂ D0 alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + +end SevenEighths.CenteredMomentEnergyCanonicalMainGaussian + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainHomogeneous.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainHomogeneous.lean new file mode 100644 index 0000000000000000000000000000000000000000..ef8bea54f54c48211398ad118832856a0c765e4b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainHomogeneous.lean @@ -0,0 +1,195 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainHomogeneous +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients +theorem actual_main_homogeneous + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + Ready input (R0*C) Kmain Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + normalizedGaussSource input (R0*C) seed CenteredMomentFirstAmplificationChoice.ballProfile Kmain≤ + (∑j,(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|t|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ))* + mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hmain⟩:= + CenteredMomentEnergyCanonicalMainSeparatedPower.actual_main_separated_power (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma hsigma hξsmall + have hlo:=CenteredMomentSecondInputCapacitySource.lowerFactor_pos N lower a hlower haPlain + obtain ⟨Uprofile,Jheight,hweights⟩:= + CenteredMomentEnergyFirstGaussianProfileWeights.actual_weights (a:=a) (b:=b) + N upper (max 1 b) (max 1 b) ((max 1 Mslot)^N) + (CenteredMomentSecondInputCapacitySource.lowerFactor N lower a) + Cm Ce Cd Ct Cc cost εsrc δsrc θsrc Bcap J (dc+degree+4*n) (dc+degree+4*n) + Sp T Sf CenteredMomentFirstAmplificationChoice.ballProfile + (zero_le_one.trans hupper) (le_trans zero_le_one (le_max_left _ _)) + (le_trans zero_le_one (le_max_left _ _)) (by positivity) hlo + hCm.le hCe hCd.le hCt.le hCc.le (zero_le_one.trans hcost) + refine ⟨Uprofile,Jheight,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Kc,hKc,Zi,hZi,hi⟩:=hmain η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Cbound,hCbound,hwbound⟩:=hweights (internalQ Q η₀) Kc hKc.le + refine ⟨Cbound,hCbound,Zi,hZi,?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + let input:=child src C R0 B τ t + let Scols:=finiteColumns (Fintype.piFinset input.pools) + let β:=coefficient input (R0*C) seed + obtain ⟨family,hfamily,hbound⟩:=hi θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β rfl rfl + have hg:=hbound 1 fixedBadMask fixedBadMask_ne_zero (dvd_mul_right _ _) (dvd_mul_left _ _) + r hr1 hr2 hr3 hr4 + dsimp only at hg ⊢ + have hz:0(hMs i).trans (le_max_right _ _)) + have hnseed:1≤(seed.absNorm:ℝ):=norm_ge_one seed hseed0 + have hh:=hwbound p Z t height (mass src) (seed.absNorm:ℝ) C₀ C₁ + hz hheight (mass_nonneg src) hmass hnseed hC₀ hC₁ + dsimp only at hh + apply hg.trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + apply Finset.sum_le_sum + intro j _ + apply mul_le_mul_of_nonneg_right _ (Real.rpow_nonneg (volume_pos input).le _) + apply mul_le_mul_of_nonneg_right (hh j) + fin_cases j <;> simp only [mainPowers,Matrix.cons_val,Fin.reduceFinMk] <;> + try unfold mainCommonRadius + all_goals positivity + +end SevenEighths.CenteredMomentEnergyCanonicalMainHomogeneous + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainPaid.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainPaid.lean new file mode 100644 index 0000000000000000000000000000000000000000..6ef51b54a7ace7a7f5247ba5386e821565ebcfe5 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainPaid.lean @@ -0,0 +1,177 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainPaid +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +omit [DecidableEq α] in +lemma common_raw_caps (src:Input α)(C R:Ideal O)(B:actualAllocations src.pools C) + (τ:Character)(t F:ℝ)(h₁:src.X₁≤F)(h₂:src.X₂≤F)(h₃:src.Y₁≤F)(h₄:src.Y₂≤F): + let d:=commonData (withHeight src τ t) C R B + d.X₁≤F ∧ d.X₂≤F ∧ d.Y₁≤F ∧ d.Y₂≤F:=by + have hN (j:α⊕Fin 2):(1:ℝ)≤Ideal.absNorm (B.val j):= + norm_ge_one _ (alloc_ne src C B j) + exact ⟨(div_le_self src.X₁_pos.le (hN _)).trans h₁, + (div_le_self src.X₂_pos.le (hN _)).trans h₂, + (div_le_self src.Y₁_pos.le (hN _)).trans h₃, + (div_le_self src.Y₂_pos.le (hN _)).trans h₄⟩ + +theorem actual_main_child_from_bands (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K sigma delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + ∀(Scols:Finset (Ideal O))(βsource:Ideal O→ℂ)(C₂ D₂:Ideal O), + ∀hC₂:Supported C₂,∀hD₂:Supported D₂,primeSupport C₂=primeSupport D₂ → + ∀(U:Finset (CommonIndex C₂ D₂))(Rwindow:ℝ)(rows:Finset O)(Wkernel:𝓢(ℝ,ℂ))(dyad:Fin 4→ℤ), + (∀I:Ideal O,βsource I≠0 → asource*volume input≤(I.absNorm:ℝ)) → + physicalBlock τ t Scols βsource C₂ D₂ hC₂ hD₂ U Rwindow rows Wkernel Kmain dyad≠0 → + ∀family:RayFourExpansion.RayCharacter→Character,Family τ C₂ D₂ hC₂ hD₂ U family → + ∀χ:RayFourExpansion.RayCharacter, + Real.logb Z (dyadicScale (dyad 1))+Real.logb Z ((family χ).modulus.absNorm:ℝ)≤Mcap → + ∀Cpick Rpick:Ideal O,Cpick=C₂ ∨ Cpick=D₂ → Rpick≠0 → + ∀B₂:actualAllocations input.pools Cpick, + frozenCoefficient B₂.val Cpick Rpick input.ν input.W input.P≠0 → + ∀Dalloc:Ideal O,∀alloc:Allocation Dalloc + (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B₂.val⊕Fin 2)), + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + let δpaid:=Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + sourceReserve src input C D Z delta reserve cost asource + childEnergy (commonData (withHeight input (family χ) v) Cpick Rpick B₂) + (canonicalRadial (family χ) (internalQ Q η₀) dyad) Dalloc alloc≤ + Cc*(Ideal.absNorm (Rpick*Cpick).radical:ℝ)^εmask*(C₀+C₁)* + diagonalControl (canonicalRadial (family χ) (internalQ Q η₀) dyad).profile* + (p.control T)^2*(1+(|v|+height))^(dc+degree+4*n)* + envelopeRef (cost*(τ.modulus.absNorm:ℝ)) C₂ D₂ U dyad*(ratioPenalty dyad)^((1:ℝ)/6)* + Z^(εchild+εremove+(sigma/3+δpaid/6+θclip/3)+κ*mesh):=by + obtain ⟨n,T,dc,Cc,hCc,hbound⟩:=original_subsets_reference_paid (α:=α) M H hH W aslot bslot + Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain L hL degree S + ha hWs hW hMcap hLs hε hbeta hκ + refine ⟨n,T,dc,Cc,hCc,?_⟩ + intro η₀ + obtain ⟨Z₀,hZ₀,hbound⟩:=hbound η₀ + refine ⟨Z₀,hZ₀,?_⟩ + intro θ Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + C D R0 hC hD hCD E B τ t hB hmod K sigma delta reserve cost asource hK hsigma hcost hasource + dsimp only + intro Scols βsource C₂ D₂ hC₂ hD₂ hCD₂ U Rwindow rows Wkernel dyad hlower hphysical + family hfamily χ hwidth Cpick Rpick hside hRpick B₂ hB₂ Dalloc alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + have hz:1P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + have hKmain:0θ i.val) + Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + (fun i=>w i.val) (fun i=>σ i.val) (fun i=>freq i.val) v height mesh hmesh + (fun i=>hw i.val) (fun i=>hwm i.val) (fun i=>hwL i.val) (fun i=>hσlo i.val) + (fun i=>hσhi i.val) hheight (fun i=>hfreq i.val) input hm + (fun i=>hhi i.val) (fun i=>hMs i.val) Cpick Rpick B₂ Dalloc alloc hRpick + (family χ) dyad hn hwidth p hp₁ hp₂ caps₂.1 caps₂.2.1 caps₂.2.2.1 caps₂.2.2.2 + (Real.logb Z (volume src)) Mdecl (envelopeRef (cost*(τ.modulus.absNorm:ℝ)) C₂ D₂ U dyad) + 0 (sigma/3) _ 0 θclip (envelope_pos _ (mul_pos hcost0 hτnorm) _ _ hC₂ _ _) le_rfl + (by positivity) hδ le_rfl hθclip + (by simpa only [input,CenteredMomentAmplificationChildInput.child,commonData,withHeight,hmatch.scale, + Real.logb_rpow (zero_lt_one.trans hz) hz.ne'] using hpar) + (by simpa only [CenteredMomentAllocatedChildCapacity.preVolume,commonData,withHeight, + zero_add] using hshift) + (by linarith) hclip + simpa only [zero_add] using hh + +end SevenEighths.CenteredMomentEnergyCanonicalMainPaid + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSeparated.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSeparated.lean new file mode 100644 index 0000000000000000000000000000000000000000..d4bf4617df1654fd0f57a4857f07f32f8c71660e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSeparated.lean @@ -0,0 +1,188 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainGaussian +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainSeparated +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +theorem actual_main_separated_gaussian + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + Ready input (R0*C) Kmain Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀Scols:Finset (Ideal O),∀β:Ideal O→ℂ, + Scols=finiteColumns (Fintype.piFinset input.pools) → + β=coefficient input (R0*C) seed → + ∃family:(q:ActiveLabel Scols β)→Finset (CommonIndex q.val.1 q.val.2)→RayCharacter→Character, + (∀q U,Family input.η q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U (family q U)) ∧ + ∀_χ₀:RayCharacter,∀m:O,m≠0 → goodLambda∣m → (2:O)∣m → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let Echild:=CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((Bcap+Bcap)*εmask+(εchild+εremove+ + (sigma/3+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3)+κ*mesh)) + normalizedGaussSource input (R0*C) seed CenteredMomentFirstAmplificationChoice.ballProfile Kmain≤ + (∑j,coefficients N upper (max 1 b) (max 1 b) (mass src) Sp p J (internalQ Q η₀) Kc t + εsrc (seed.absNorm:ℝ) + (seededFactors Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap saving Kmain t + (cost*(τ.modulus.absNorm:ℝ)) Echild Echild r (∏i,input.lo i) a (seed.absNorm:ℝ) + (dc+degree+4*n) (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile) j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hmain⟩:= + CenteredMomentEnergyCanonicalMainGaussian.actual_main_gaussian_from_bands (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ + refine ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Kc,hKc,Zi,hZi,hi⟩:=hmain η₀ Q hQM hQ0 hQt hQ72 + let Zw:=CenteredMomentEnergyAmplifiedChildWidth.threshold N upper sigma hupper hsigma + refine ⟨Kc,hKc,max Zi Zw,lt_of_lt_of_le hZi (le_max_left _ _),?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β hScols hβ + have hZiZ:Zi≤Z:=(le_max_left _ _).trans hZ + have hZw:Zw≤Z:=(le_max_right _ _).trans hZ + have hz:1(dyad i:ℤ)) hphysical χ + exact hh.le.trans hdrop + +end SevenEighths.CenteredMomentEnergyCanonicalMainSeparated + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSeparatedPower.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSeparatedPower.lean new file mode 100644 index 0000000000000000000000000000000000000000..203c5c59d53e09fbf577043d1fed5aee8ebeb435 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSeparatedPower.lean @@ -0,0 +1,220 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainSeparatedPower +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients +theorem actual_main_separated_power + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + Ready input (R0*C) Kmain Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀Scols:Finset (Ideal O),∀β:Ideal O→ℂ, + Scols=finiteColumns (Fintype.piFinset input.pools) → + β=coefficient input (R0*C) seed → + ∃family:(q:ActiveLabel Scols β)→Finset (CommonIndex q.val.1 q.val.2)→RayCharacter→Character, + (∀q U,Family input.η q.val.1 q.val.2 + (commonLabels_supported (activeSource Scols β) _ _ q.property).1 + (commonLabels_supported (activeSource Scols β) _ _ q.property).2 U (family q U)) ∧ + ∀_χ₀:RayCharacter,∀m:O,m≠0 → goodLambda∣m → (2:O)∣m → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + let Ebase:=Cc*(C₀+C₁)*diagonalControl CenteredMomentFirstAmplificationChoice.ballProfile* + (p.control T)^2*(1+height)^(dc+degree+4*n); + let Hweights:=coefficients N upper (max 1 b) (max 1 b) (mass src) Sp p J + (internalQ Q η₀) Kc t εsrc (seed.absNorm:ℝ) + (fixedFactors Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap cost Ebase t + (CenteredMomentSecondInputCapacitySource.lowerFactor N lower a) (seed.absNorm:ℝ) + (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile); + normalizedGaussSource input (R0*C) seed CenteredMomentFirstAmplificationChoice.ballProfile Kmain≤ + (∑j,Hweights j*mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2 :=by + obtain ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,hmain⟩:= + CenteredMomentEnergyCanonicalMainSeparated.actual_main_separated_gaussian (α:=α) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource lows highs hhighs εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma hsigma hξsmall + refine ⟨n,T,dc,Cc,hCc,J,Sp,Sf,hSp,Cm,Ce,Cd,Ct,hCm,hCe,hCd,hCt,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Kc,hKc,Zi,hZi,hi⟩:=hmain η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Kc,hKc,Zi,hZi,?_⟩ + intro θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β hScols hβ + obtain ⟨family,hfamily,hbound⟩:=hi θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve cost asource hK hcost hasource hdelta hreserve haSource + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower Scols β hScols hβ + refine ⟨family,hfamily,?_⟩ + intro χ₀ m hm hml hm2 r hr1 hr2 hr3 hr4 + have hg:=hbound χ₀ m hm hml hm2 r hr1 hr2 hr3 hr4 + dsimp only at hg ⊢ + let Ebase:=Cc*(C₀+C₁)*diagonalControl CenteredMomentFirstAmplificationChoice.ballProfile* + (p.control T)^2*(1+height)^(dc+degree+4*n) + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh + have hz:0hlowerSrc.trans (src.lower_le i.val)) + have hlo:CenteredMomentSecondInputCapacitySource.lowerFactor N lower a≤ + (∏i,(child src C R0 B τ t).lo i)*a*a:=by + unfold CenteredMomentSecondInputCapacitySource.lowerFactor + simpa only [pow_two, mul_assoc] using + mul_le_mul_of_nonneg_right hloProd (sq_nonneg a) + have hcoef:=CenteredMomentEnergyFirstGaussianCoefficients.main_coefficients + N upper (max 1 b) (max 1 b) (mass src) Sp p J (internalQ Q η₀) Kc + Cm Ce Cd Ct Z εsrc δsrc θsrc Bcap saving + (mainCommonRadius Z (Real.logb Z (D.absNorm:ℝ)) + (Real.logb Z (firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve) + t (τ.modulus.absNorm:ℝ) cost Ebase (sigma/3) + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid r + (∏i,(child src C R0 B τ t).lo i) a + (CenteredMomentSecondInputCapacitySource.lowerFactor N lower a) (seed.absNorm:ℝ) + (dc+degree+4*n) Sf CenteredMomentFirstAmplificationChoice.ballProfile + (zero_le_one.trans hupper) (le_trans zero_le_one (le_max_left _ _)) + (le_trans zero_le_one (le_max_left _ _)) hKc.le (Nat.cast_nonneg _) hCm.le hCe hz hE + (by unfold mainCommonRadius;positivity) + (CenteredMomentSecondInputCapacitySource.lowerFactor_pos N lower a hlower haPlain) hlo + have hexp: + (Bcap+Bcap)*εmask+(εchild+εremove+ + (sigma/3+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3)+κ*mesh)= + sigma/3+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)))/6+paid :=by + dsimp [paid];ring + apply hg.trans + apply mul_le_mul_of_nonneg_right _ (sq_nonneg _) + apply Finset.sum_le_sum + intro j _ + have hh:=mul_le_mul_of_nonneg_right (hcoef j) + (Real.rpow_nonneg (volume_pos (child src C R0 B τ t)).le (powers εsrc j)) + simpa only [CenteredMomentEnergyChildEnvelopeFitting.coefficient,hexp,Ebase,paid] using hh + +end SevenEighths.CenteredMomentEnergyCanonicalMainSeparatedPower + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSubsets.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSubsets.lean new file mode 100644 index 0000000000000000000000000000000000000000..e98464391b540da12d04de95cbbb1ac08420f61b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainSubsets.lean @@ -0,0 +1,215 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainHomogeneous +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparatedPower +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianProfileWeights +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainSeparated +import OAI.NumberTheory.DirichletL.Energy.FirstGaussianCoefficients +import OAI.NumberTheory.DirichletL.Energy.OriginalProfileControl +import OAI.NumberTheory.DirichletL.Energy.AmplifiedChildWidth +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainUniform +import OAI.NumberTheory.DirichletL.Moments.FirstSeededGaussianPower +import OAI.NumberTheory.DirichletL.Moments.FirstSecondInputGates +import OAI.NumberTheory.DirichletL.Moments.SecondInputCapacitySource +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainSubsets +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients +theorem actual_original_subsets_main_power + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K delta reserve asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + Ready input (R0*C) Kmain Z ξ Bcap → + ∀seed:Ideal O,Squarefree seed → seed≠0 → (seed.absNorm:ℝ)≤Z^Bseed → + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl Mwidth θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mwidth → + Mwidth-sigma/2≤Mcap → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + asource≤CenteredMomentSecondInputCapacitySource.lowerFactor N lower a → + ∀r:ℝ,Z^r≤ input.X₁ → Z^r≤ input.X₂ → Z^r≤ input.Y₁ → Z^r≤ input.Y₂ → + let paid:=(Bcap+Bcap)*εmask+εchild+εremove+(delta+reserve+θsource)/6+θclip/3+κ*mesh; + normalizedGaussSource input (R0*C) seed CenteredMomentFirstAmplificationChoice.ballProfile Kmain≤ + (∑j,(Cbound*(C₀+C₁+1)*(p.control Uprofile)^2*(1+|t|+height)^Jheight* + Z^(CenteredMomentEnergyFirstGaussianProfileWeights.losses εsrc δsrc θsrc Bcap j)/(seed.absNorm:ℝ))* + mainPowers (τ.modulus.absNorm:ℝ) Z Kmain (sigma/3) + (Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))) paid saving r j* + (volume input)^(powers εsrc j))*mass input^2 :=by + have hmain (Aorig:Finset α):= + CenteredMomentEnergyCanonicalMainHomogeneous.actual_main_homogeneous (α:=Aorig) M H hH + Wslot aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain hbPlain + L hL degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ N lower upper a0 θsource + hlower hupper ha0 hθsource (fun i=>lows i.val) (fun i=>highs i.val) + (fun i=>hhighs i.val) εsrc δsrc θsrc Bcap Bseed ξ saving + hεsrc hδsrc hθsrc hBcap hξ sigma cost hsigma hξsmall hcost + choose Uj Jj hj using hmain + let Uprofile:Finset (ℕ×ℕ):=Finset.univ.biUnion Uj + let Jheight:ℕ:=∑Aorig:Finset α,Jj Aorig + refine ⟨Uprofile,Jheight,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + choose Cj hCj Zj hZj hconsume using fun Aorig=>hj Aorig η₀ Q hQM hQ0 hQt hQ72 + let Cbound:ℝ:=1+∑Aorig:Finset α,Cj Aorig + let Z₀:ℝ:=2+∑Aorig:Finset α,|Zj Aorig| + have hCbound:0(hCj Aorig).le) + dsimp [Cbound];linarith + have hZ₀:1abs_nonneg (Zj Aorig)) + dsimp [Z₀];linarith + have hCC (Aorig:Finset α):Cj Aorig≤Cbound:=by + have hh:=Finset.single_le_sum (fun A (_:A∈(Finset.univ:Finset (Finset α)))=>(hCj A).le) + (Finset.mem_univ Aorig) + dsimp [Cbound];linarith + have hZZ (Aorig:Finset α):Zj Aorig≤Z₀:=by + have hh:=Finset.single_le_sum (fun A (_:A∈(Finset.univ:Finset (Finset α)))=>abs_nonneg (Zj A)) + (Finset.mem_univ Aorig) + dsimp [Z₀];linarith [le_abs_self (Zj Aorig)] + refine ⟨Cbound,hCbound,Z₀,hZ₀,?_⟩ + intro Aorig θ Z hZ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh hmesh hw hwm hwL + hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc hcard hlowerSrc hupperSrc + hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + dsimp only + intro hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + have hposA:=positiveAt_subtype M H hH Aorig Wslot bslot (a/max 1 b) b 2 0 L Lslot lo hi + Mcap εchild κ Z η₀ Q degree S C₁ hpos + have hg:=hconsume Aorig θ Z ((hZZ Aorig).trans hZ) εchild C₀ C₁ hC₀ hC₁ hzero hposA + w σ freq height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hloSrc hhiSrc hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max C D R0 hC hD hCD E B τ t hB hmod + K delta reserve asource hK hasource hdelta hreserve haSource + hready seed hseed hseed0 hseedcap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip + hcap hMdecl hMwidth hdrop hclip hsourceLower r hr1 hr2 hr3 hr4 + dsimp only at hg ⊢ + have hsub:Uj Aorig⊆Uprofile:=by + intro x hx + exact Finset.mem_biUnion.mpr ⟨Aorig,Finset.mem_univ _,hx⟩ + have hp:p.control (Uj Aorig)≤p.control Uprofile:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono hsub) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono hsub) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hJ:Jj Aorig≤Jheight:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ Aorig) + have hz:0 simp only [mainPowers,Matrix.cons_val,Fin.reduceFinMk] <;> + try unfold mainCommonRadius + all_goals positivity + +end SevenEighths.CenteredMomentEnergyCanonicalMainSubsets + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainUniform.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainUniform.lean new file mode 100644 index 0000000000000000000000000000000000000000..2e50c9b791e35759f258ed49b02123d10a5d248e --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalMainUniform.lean @@ -0,0 +1,158 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalMainPaid +import OAI.NumberTheory.DirichletL.Energy.ChildEnvelopeFitting +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidReserve +import OAI.NumberTheory.DirichletL.Energy.CanonicalUniformReference +import OAI.NumberTheory.DirichletL.Moments.FirstAmplifiedPaidAdmission +import OAI.NumberTheory.DirichletL.Energy.AmplifiedRayDictionary + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalMainUniform +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +theorem actual_main_uniform_child (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0P.val) E*activeConductor C D} → + ∀K sigma delta reserve cost asource:ℝ,0P.val) E}) K (volume src))) + (Real.logb Z (C.absNorm:ℝ)) sigma delta reserve + ∀(Scols:Finset (Ideal O))(βsource:Ideal O→ℂ)(C₂ D₂:Ideal O), + ∀hC₂:Supported C₂,∀hD₂:Supported D₂,primeSupport C₂=primeSupport D₂ → + ∀(U:Finset (CommonIndex C₂ D₂))(Rwindow:ℝ)(rows:Finset O)(Wkernel:𝓢(ℝ,ℂ))(dyad:Fin 4→ℤ), + (∀I:Ideal O,βsource I≠0 → asource*volume input≤(I.absNorm:ℝ)) → + physicalBlock τ t Scols βsource C₂ D₂ hC₂ hD₂ U Rwindow rows Wkernel Kmain dyad≠0 → + ∀family:RayFourExpansion.RayCharacter→Character,Family τ C₂ D₂ hC₂ hD₂ U family → + ∀χ:RayFourExpansion.RayCharacter, + Real.logb Z (dyadicScale (dyad 1))+Real.logb Z ((family χ).modulus.absNorm:ℝ)≤Mcap → + ∀Cpick Rpick:Ideal O,Cpick=C₂ ∨ Cpick=D₂ → Rpick≠0 → + (Rpick.absNorm:ℝ)≤Z^BR → (Cpick.absNorm:ℝ)≤Z^BC → + ∀B₂:actualAllocations input.pools Cpick, + frozenCoefficient B₂.val Cpick Rpick input.ν input.W input.P≠0 → + ∀Dalloc:Ideal O,∀alloc:Allocation Dalloc + (Finset.univ:Finset (CenteredMomentCommonProfile.liveIndices B₂.val⊕Fin 2)), + ∀p:Profiles a b,p.profile 0=src.W₁ → p.profile 1=src.W₂ → + src.X₁≤Z^L → src.X₂≤Z^L → src.Y₁≤Z^L → src.Y₂≤Z^L → + ∀Mdecl θclip:ℝ,0≤θclip → + length Z src.X₁+length Z src.X₂+6*κ*(∑i,w i)≤Mdecl → + Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ)≤Mdecl → + Real.logb Z (max 1 b*max 1 b)≤2*θclip → + childEnergy (commonData (withHeight input (family χ) v) Cpick Rpick B₂) + (canonicalRadial (family χ) (internalQ Q η₀) dyad) Dalloc alloc≤ + CenteredMomentEnergyChildEnvelopeFitting.coefficient Cc C₀ C₁ p T height (dc+degree+4*n) Z + ((BR+BC)*εmask+(εchild+εremove+ + (sigma/3+(Mdecl-(Real.logb Z K+Real.logb Z (src.η.modulus.absNorm:ℝ))+ + delta+reserve+θsource)/6+θclip/3)+κ*mesh))* + envelopeRef (cost*(τ.modulus.absNorm:ℝ)) C₂ D₂ U dyad* + (ratioPenalty dyad)^((1:ℝ)/6)*(1+‖v‖)^(2*(dc+degree+4*n)) :=by + obtain ⟨n,T,dc,Cc,hCc,hbound⟩:= + CenteredMomentEnergyCanonicalMainPaid.actual_main_child_from_bands (α:=α) M H hH + W aslot bslot Mcap Lslot εremove lo hi κ a b Mslot εmask hMslot hεmask haPlain L hL + degree S ha hWs hW hMcap hLs hε hκsmall hbeta hκ + obtain ⟨Zr,hZr,hr⟩:=CenteredMomentFirstAmplifiedPaidReserve.eventually_actual_amplified_reserves + N lower upper 1 a0 θsource hlower (by norm_num) ha0 hθsource + refine ⟨n,T,dc,Cc,hCc,?_⟩ + intro η₀ + obtain ⟨Zi,hZi,hi⟩:=hbound η₀ + refine ⟨max Zi Zr,lt_of_lt_of_le hZi (le_max_left _ _),?_⟩ + intro θ Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq src hmatch hhi hMs + hcard hlowerSrc hupperSrc C D R0 hC hD hCD E B τ t hB hmod + K sigma delta reserve cost asource hK hsigma hcost hasource hdelta hreserve haSource + dsimp only + intro Scols βsource C₂ D₂ hC₂ hD₂ hCD₂ U Rwindow rows Wkernel dyad hlowerBeta hphysical + family hfamily χ hwidth Cpick Rpick hside hRpick hRN hCN B₂ hB₂ Dalloc alloc p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ Mdecl θclip hθclip hcap hMdecl hclip + have hZiZ:Zi≤Z:=(le_max_left _ _).trans hZ + have hZrZ:Zr≤Z:=(le_max_right _ _).trans hZ + have hz:1HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem nested_original_subsets_reference_paid (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0(hCc J).le) + dsimp [Ctot];linarith + refine ⟨n₀,T₀,dc₀,Ctot,hCt,?_⟩ + intro η₀ + let Choices:=ΣJ:Pairs,J.2→RayQuotient.Characters M H + let:Fintype (RayQuotient.Characters M H):=Fintype.ofFinite _ + let:Fintype Choices:=inferInstance + have hchoices (c:Choices):∃Z₀:ℝ,1False.elim (Finset.notMem_empty _ i.property)⟩⟩ + let:Nonempty Choices:=hn + have hh:=Finset.sum_pos (s:=Finset.univ) (fun c _=>(zero_lt_one.trans (hZchoice c))) + Finset.univ_nonempty + dsimp [Z₀];linarith + refine ⟨Z₀,hZ₀,?_⟩ + intro Jparent Jorig θ Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq + src hmatch hhi hMs C R B D alloc hR τ dyad hn hwidth p hp₁ hp₂ + dsimp only + intro hX₁ hX₂ hY₁ hY₂ A Mparent reference u ell δ₁ δ₂ θclip href + hu hell hδ₁ hδ₂ hθclip hparent hshift hdefect hclip + have hZi:Zchoice ⟨⟨Jparent,Jorig⟩,θ⟩≤Z:=by + have hh:=Finset.single_le_sum (s:=Finset.univ) + (fun c _=>(zero_lt_one.trans (hZchoice c)).le) (Finset.mem_univ (⟨⟨Jparent,Jorig⟩,θ⟩:Choices)) + dsimp [Z₀] at hZ + linarith + have hp₀:=positiveAt_subtype M H hH Jparent W bslot (a/max 1 b) b 2 0 L Lslot lo hi + Mcap εchild κ Z η₀ Q degree S C₁ hpos + have hp:=positiveAt_subtype M H hH Jorig W bslot (a/max 1 b) b 2 0 L Lslot lo hi + Mcap εchild κ Z η₀ Q degree S C₁ hp₀ + have hh:=hb ⟨⟨Jparent,Jorig⟩,θ⟩ Z hZi εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hp + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq + src hmatch hhi hMs C R B D alloc hR τ dyad hn hwidth p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ A Mparent reference u ell δ₁ δ₂ θclip href + hu hell hδ₁ hδ₂ hθclip hparent hshift hdefect hclip + have hc:Cc ⟨Jparent,Jorig⟩≤Ctot:=by + have hh:=Finset.single_le_sum (s:=Finset.univ) (fun J _=>(hCc J).le) (Finset.mem_univ (⟨Jparent,Jorig⟩:Pairs)) + dsimp [Ctot];linarith + have ht:T ⟨Jparent,Jorig⟩⊆T₀:=by + intro x hx + exact Finset.mem_biUnion.mpr ⟨⟨Jparent,Jorig⟩,Finset.mem_univ _,hx⟩ + have hctrl:p.control (T ⟨Jparent,Jorig⟩)≤p.control T₀:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono ht) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono ht) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hn₀:n ⟨Jparent,Jorig⟩≤n₀:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ (⟨Jparent,Jorig⟩:Pairs)) + have hdc₀:dc ⟨Jparent,Jorig⟩≤dc₀:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ (⟨Jparent,Jorig⟩:Pairs)) + have hdeg:dc ⟨Jparent,Jorig⟩+degree+4*n ⟨Jparent,Jorig⟩≤dc₀+degree+4*n₀:=by omega + have hpow:(1+(|v|+height))^(dc ⟨Jparent,Jorig⟩+degree+4*n ⟨Jparent,Jorig⟩)≤ + (1+(|v|+height))^(dc₀+degree+4*n₀):= + pow_le_pow_right₀ (by linarith [abs_nonneg v]) hdeg + have hcontrol:=p.control_nonneg (T ⟨Jparent,Jorig⟩) + have hd:0≤diagonalControl (canonicalRadial τ (internalQ Q η₀) dyad).profile:=by + unfold diagonalControl;positivity + have hz0:0HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_canonical_paid_source (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b:ℝ)(haPlain:0HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_reference_paid_source (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +local instance {ι:Type*} : DecidableEq (ι⊕Fin 2) := Classical.decEq _ + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +open CenteredMomentEnergyCanonicalUniformReference CenteredMomentEnergyAmplifiedRayDictionary +open CenteredMomentFirstAmplifiedPaidAdmission CenteredMomentFirstAmplifiedCapacityCommon +open CenteredMomentAmplificationChildInput CenteredMomentAmplificationChildSourceCaps +open CenteredMomentCanonicalFirst CenteredMomentSecondExceptionalFamily CenteredMomentSourceLiveColumn +open CenteredMomentSecondPhysicalBlock CenteredMomentSecondCanonical CanonicalQuadraticSieve CompletedGauss +open CanonicalRowCompletion ConcretePrimeRowBridge ActualEisensteinCubic +open CenteredMomentSecondHeightFamily +open CenteredMomentFirstCanonicalFamily CenteredMomentFirstScale CenteredMomentAmplifiedRetainedRadius + +open RayFourExpansion CenteredMomentSourceMass CenteredMomentSecondRetainedAggregate +open CenteredMomentSecondEnergySplit CenteredMomentGaussNormalization +open Filter CenteredMomentOriginalCommonHarmonic CenteredMomentActiveSource +open CenteredMomentSecondLiveBlock CenteredMomentSecondBlockAggregate CenteredMomentSecondWindowSource +open CenteredMomentFirstChildProfileControl CenteredMomentSecondChildPowerBudget +open CenteredMomentSecondSourceSeededPowerDescent CenteredMomentSecondReferenceNormalization +open CenteredMomentFirstSeededGaussianPower CenteredMomentFirstSecondInputGates + +open CenteredMomentEnergyFirstGaussianCoefficients CenteredMomentFirstAmplifiedFourCoefficients + +open CenteredMomentFirstSecondActiveErrorGates CenteredMomentFirstAnnularInput +open CenteredMomentFirstAmplificationChoice (errorMoving errorRemoval) + +open CenteredMomentEnergyAmplifiedChildWidth +open CenteredMomentEnergyCanonicalAmplifiedUniform CenteredMomentEnergyAmplifierFamilyAdmission +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyFirstAnnularAdmission +open CenteredMomentEnergyFirstRawScaleAdmission CenteredMomentEnergyInputParentCapacity +open CenteredMomentFirstReferenceSource CenteredMomentFirstNonexceptionalWeightSum +open CenteredMomentPrimePool CenteredMomentPrimeElements CenteredMomentAmplificationRadicalFamily +open CenteredMomentAmplificationActiveFactor CenteredMomentAmplificationEligibility +open CenteredMomentFirstPhysicalSource CenteredMomentFirstPhysicalDyadicRows +open CenteredMomentFirstAmplifiedPowerBudget CenteredMomentFirstAmplificationChoice +open CenteredMomentSecondRetainedRows CenteredMomentLogDyadic + +open CenteredMomentEnergyCanonicalAnnularPower CenteredMomentEnergyCanonicalAmplifiedColumn +open CenteredMomentFirstCommonReferencePower CenteredMomentEnergyFirstLowHomogeneousPowers +open CenteredMomentEnergyCanonicalLowColumn CenteredMomentFirstMixedRightTransport +open CenteredMomentFirstNonexceptionalLocalWeightSum +open CenteredMomentEnergyFirstRightAdmission + +theorem actual_original_right_low_column + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0by rw [hhiSrc i];exact hhighs i.val),hb1,hb1max,hb2,hb2max⟩ + have hW₁:∀x,src.W₁ x≠0→a≤x:=by + intro x hx + have hh:p.profile 0 x≠0:=by simpa only [hp₁] using hx + exact (p.support 0 hh).1 + have hW₂:∀x,src.W₂ x≠0→a≤x:=by + intro x hx + have hh:p.profile 1 x≠0:=by simpa only [hp₂] using hx + exact (p.support 1 hh).1 + have hcols:=actual_common_gates src R0 seed0 hseed0 + (lower_profile_zero src.W₁ a haPlain hW₁) (lower_profile_zero src.W₂ a haPlain hW₂) C D hlabel + have hCD:primeSupport C=primeSupport D:=hcols.2.2.1 + have hseedD:seed0∣D:=hcols.2.2.2.2.1 + have hDnorm:1≤(D.absNorm:ℝ):=by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hD.1) + have hradius:=hsource.2 Aorig src hcard + (fun i=>by rw [abs_of_nonneg (hends.2.1 i)];exact (src.upper_ge i).trans hupperSrc) + (by simpa only [abs_of_nonneg hb1] using hb1max) + (by simpa only [abs_of_nonneg hb2] using hb2max) R0 seed0 K ξ hK le_rfl hV + (by simpa only [Real.rpow_zero] using inv_le_one_of_one_le₀ hK1) + have hND:(D.absNorm:ℝ)≤Z^(A+1):=hcols.2.2.2.2.2.2.trans hradius.1 + have hseedne:seed≠0:=hseed.ne_zero + have hseedCap:(seed.absNorm:ℝ)≤Z^Bseed:=by + calc + _≤sourceRadius src/(D.absNorm:ℝ):=hseedcap + _≤sourceRadius src:=div_le_self ((Nat.cast_nonneg C.absNorm).trans hcols.2.2.2.2.2.1) hDnorm + _≤Z^(A+1):=hradius.1 + _≤Z^Bseed:=Real.rpow_le_rpow_of_exponent_le hZ.le hBseed + have hamp:=(hradius.2 ⟨(C,D),hlabel⟩ E n) + have hTspan:=source_nominal_span src R0 seed0 K ⟨(C,D),hlabel⟩ E + let Es:=swapSubset C D E + have hmod:F.right.modulus=src.η.modulus*Ideal.span {fixedBadMask}*Ideal.span {(72:O)}* + Ideal.span {primeSubsetGenerator (fun P:CommonIndex D C=>P.val) Es*activeConductor D C}:=by + exact right_modulus src.η C D hC E χ₁ χ₂ F + obtain ⟨hPne,hPcard,hfamilies⟩:=hcolumn Z hZbaseLe + obtain ⟨υ,hυ,hbound⟩:=hfamilies F.right + have hnom:firstNominalScale D C + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex D C=>P.val) Es}) K (volume src)= + firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K (volume src):=by + dsimp only [Es] + rw [swapSubset_generator,nominal_swap] + have houter:dyadicScale (n 1)≤4*frequencyRadius + (firstNominalScale D C (Ideal.span {primeSubsetGenerator (fun P:CommonIndex D C=>P.val) Es}) + K (volume src)) Z ξ:=by + rw [hnom] + simpa only [primeSubsetGenerator,span_idealGenerator,CenteredMomentExceptionalAmplitudePair.volume,CenteredMomentAmplificationChildInput.volume] using hamp.2.2.1 + apply hbound Aorig θ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max D C R0 hD hC hCD.symm hR0 hRcap hND Es hmod + K (dyadicScale (n 1)) hK (zero_lt_one.trans hamp.2.1) houter hamp.2.2.2.1 t seed0 hseedD + seed hseed hseedne hseedCap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip hMdecl0 hMA hlow + hcap hMdecl hMwidth hdrop hclip hsourceLower + intro B hB + have hm:=hmain.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun i=>n i) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock B t seed hB + refine ⟨?_,?_⟩ + · simpa only [mul_one] using hm.2.1 + · intro prime i χ Bp + obtain ⟨_,_,_,hseparate,hdata,_⟩:=hsep + have hd:=elementPool_data _ (fun Q hQ=>(hdata Q hQ).1) + (fun Q hQ=>(hdata Q hQ).2.1) prime.val prime.property + let input:=child src D R0 B F.right t + let z:CenteredMomentCommonProfile.liveIndices B.val→ℝ:=fun j=>w j.val + have hz:∀j,z j≤eta:=fun j=>hweta j.val + have hlen:∀j,input.P j=Z^(z j):=fun j=>hmatch.scale j.val + have hsupp:∀j,Function.support (input.W j)⊆Set.Iic (max 1 bslot):=by + intro j x hx + exact ((src.support j.val hx).2.trans (hhi j.val)).trans (le_max_right _ _) + have hslot:∀j,∀I∈(activeInput input).slots j,IsCoprime (Ideal.span {prime.val}) I:=by + exact original_slot_coprime (original input (R0*D) seed).active Z sigma (max 1 bslot) eta + hZ.le (by positivity) hseparate z hz hlen hsupp + (original input (R0*D) seed).active_slot + (fun j Q hQ=>input.prime j Q ((original input (R0*D) seed).active_subset _ hQ)) + _ (hdata _ hd.2.1).1 (hdata _ hd.2.1).2.2.1 + have hk:=errorIndex_cases i + have hk':errorIndex i+1=1∨errorIndex i+1=6∨errorIndex i+1=7:=by omega + have hN:=hυ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ + have he:=herror.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hsigma1 hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun j=>n j) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock B t seed hB M H fixedBadPrimes (Finset.Subset.refl _) prime.val prime.property + (errorIndex i+1) hk' hslot Bp χ + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t + (by simpa only [Nat.add_sub_cancel] using hN) + rcases he.2 with hdead|hlive + · exact Or.inl hdead.1 + · exact Or.inr (by simpa only [mul_one] using hlive.1) + +theorem actual_original_right_high_column + (Wslot:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0by rw [hhiSrc i];exact hhighs i.val),hb1,hb1max,hb2,hb2max⟩ + have hW₁:∀x,src.W₁ x≠0→a≤x:=by + intro x hx + have hh:p.profile 0 x≠0:=by simpa only [hp₁] using hx + exact (p.support 0 hh).1 + have hW₂:∀x,src.W₂ x≠0→a≤x:=by + intro x hx + have hh:p.profile 1 x≠0:=by simpa only [hp₂] using hx + exact (p.support 1 hh).1 + have hcols:=actual_common_gates src R0 seed0 hseed0 + (lower_profile_zero src.W₁ a haPlain hW₁) (lower_profile_zero src.W₂ a haPlain hW₂) C D hlabel + have hCD:primeSupport C=primeSupport D:=hcols.2.2.1 + have hseedD:seed0∣D:=hcols.2.2.2.2.1 + have hDnorm:1≤(D.absNorm:ℝ):=by + exact_mod_cast Nat.one_le_iff_ne_zero.mpr (Ideal.absNorm_eq_zero_iff.not.mpr hD.1) + have hradius:=hsource.2 Aorig src hcard + (fun i=>by rw [abs_of_nonneg (hends.2.1 i)];exact (src.upper_ge i).trans hupperSrc) + (by simpa only [abs_of_nonneg hb1] using hb1max) + (by simpa only [abs_of_nonneg hb2] using hb2max) R0 seed0 K ξ hK le_rfl hV + (by simpa only [Real.rpow_zero] using inv_le_one_of_one_le₀ hK1) + have hND:(D.absNorm:ℝ)≤Z^(A+1):=hcols.2.2.2.2.2.2.trans hradius.1 + have hseedne:seed≠0:=hseed.ne_zero + have hseedCap:(seed.absNorm:ℝ)≤Z^Bseed:=by + calc + _≤sourceRadius src/(D.absNorm:ℝ):=hseedcap + _≤sourceRadius src:=div_le_self ((Nat.cast_nonneg C.absNorm).trans hcols.2.2.2.2.2.1) hDnorm + _≤Z^(A+1):=hradius.1 + _≤Z^Bseed:=Real.rpow_le_rpow_of_exponent_le hZ.le hBseed + have hamp:=(hradius.2 ⟨(C,D),hlabel⟩ E n) + have hTspan:=source_nominal_span src R0 seed0 K ⟨(C,D),hlabel⟩ E + let Es:=swapSubset C D E + have hmod:F.right.modulus=src.η.modulus*Ideal.span {fixedBadMask}*Ideal.span {(72:O)}* + Ideal.span {primeSubsetGenerator (fun P:CommonIndex D C=>P.val) Es*activeConductor D C}:=by + exact right_modulus src.η C D hC E χ₁ χ₂ F + obtain ⟨hPne,hPcard,hfamilies⟩:=hcolumn Z hZbaseLe + obtain ⟨υ,hυ,hbound⟩:=hfamilies F.right + have hnom:firstNominalScale D C + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex D C=>P.val) Es}) K (volume src)= + firstNominalScale C D + (Ideal.span {primeSubsetGenerator (fun P:CommonIndex C D=>P.val) E}) K (volume src):=by + dsimp only [Es] + rw [swapSubset_generator,nominal_swap] + have houter:dyadicScale (n 1)≤4*frequencyRadius + (firstNominalScale D C (Ideal.span {primeSubsetGenerator (fun P:CommonIndex D C=>P.val) Es}) + K (volume src)) Z ξ:=by + rw [hnom] + simpa only [primeSubsetGenerator,span_idealGenerator,CenteredMomentExceptionalAmplitudePair.volume,CenteredMomentAmplificationChildInput.volume] using hamp.2.2.1 + apply hbound Aorig θ εchild C₀ C₁ hC₀ hC₁ hzero hpos w σ freq height mesh + hmesh hw hwm hweta hwL hσlo hσhi hheight hfreq src hmatch hhi hMs hloSrc hhiSrc + hcard hlowerSrc hupperSrc hb1 hb2 hb1max hb2max D C R0 hD hC hCD.symm hR0 hRcap hND Es hmod + K (dyadicScale (n 1)) hK (zero_lt_one.trans hamp.2.1) houter hamp.2.2.2.1 t seed0 hseedD + seed hseed hseedne hseedCap p hp₁ hp₂ hX₁ hX₂ hY₁ hY₂ Mdecl Mwidth θclip hθclip hMdecl0 hMA hwidthle hrawX₁ hrawX₂ hrawY₁ hrawY₂ + hcap hMdecl hMwidth hdrop hclip hsourceLower + intro B hB + have hm:=hmain.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun i=>n i) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock B t seed hB + refine ⟨?_,?_⟩ + · simpa only [mul_one] using hm.2.1 + · intro prime i χ Bp + obtain ⟨_,_,_,hseparate,hdata,_⟩:=hsep + have hd:=elementPool_data _ (fun Q hQ=>(hdata Q hQ).1) + (fun Q hQ=>(hdata Q hQ).2.1) prime.val prime.property + let input:=child src D R0 B F.right t + let z:CenteredMomentCommonProfile.liveIndices B.val→ℝ:=fun j=>w j.val + have hz:∀j,z j≤eta:=fun j=>hweta j.val + have hlen:∀j,input.P j=Z^(z j):=fun j=>hmatch.scale j.val + have hsupp:∀j,Function.support (input.W j)⊆Set.Iic (max 1 bslot):=by + intro j x hx + exact ((src.support j.val hx).2.trans (hhi j.val)).trans (le_max_right _ _) + have hslot:∀j,∀I∈(activeInput input).slots j,IsCoprime (Ideal.span {prime.val}) I:=by + exact original_slot_coprime (original input (R0*D) seed).active Z sigma (max 1 bslot) eta + hZ.le (by positivity) hseparate z hz hlen hsupp + (original input (R0*D) seed).active_slot + (fun j Q hQ=>input.prime j Q ((original input (R0*D) seed).active_subset _ hQ)) + _ (hdata _ hd.2.1).1 (hdata _ hd.2.1).2.2.1 + have hk:=errorIndex_cases i + have hk':errorIndex i+1=1∨errorIndex i+1=6∨errorIndex i+1=7:=by omega + have hN:=hυ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ + have he:=herror.2 src hcard hends hlowerSrc hW₁ hW₂ κ hκsmall hPs hcapacity hηcap + R0 seed0 hR0 hRcap hseed0 C D hC hD hlabel E χ₁ χ₂ F + K 1 (firstNominalScale C D (∏P∈E,P.val) K (volume src)) sigma ξ reserve + hK (by norm_num) hsigma.le hsigma1 hξ.le hξ1 hreserve.le hamp.2.2.2.2 + (retainedRows (localRadius src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E) 1) + Wphysical (fun j=>n j) (source_dyad_retained src R0 seed0 K Z ξ ⟨(C,D),hlabel⟩ E n) + hblock B t seed hB M H fixedBadPrimes (Finset.Subset.refl _) prime.val prime.property + (errorIndex i+1) hk' hslot Bp χ + (υ Aorig (CenteredMomentCommonProfile.liveIndices B.val) prime i χ) t + (by simpa only [Nat.add_sub_cancel] using hN) + rcases he.2 with hdead|hlive + · exact Or.inl hdead.1 + · exact Or.inr (by simpa only [mul_one] using hlive.1) + +end SevenEighths.CenteredMomentEnergyCanonicalRightSourceColumn + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalUniformReference.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalUniformReference.lean new file mode 100644 index 0000000000000000000000000000000000000000..98ae85fc6508177bf8fca0d2ca36b6aa09eb21d4 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CanonicalUniformReference.lean @@ -0,0 +1,150 @@ +import OAI.NumberTheory.DirichletL.Energy.CanonicalReferencePaid +import OAI.NumberTheory.DirichletL.Energy.BandSubtypeTransport + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff + +namespace SevenEighths.CenteredMomentEnergyCanonicalUniformReference +open HeckeFamily ConcreteTraceCRT +open CenteredMomentEnergyAllocatedChildren CenteredMomentAllocatedNaturalSource +open CenteredMomentAllocatedNaturalRadial CenteredMomentOriginalRadialComparison +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw CenteredMomentRetainedProfile +open CenteredMomentRadialEligibleEnergy +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] + +open CenteredMomentEnergyCanonicalLiveBound CenteredMomentEnergyCanonicalLiveCapacity +open CenteredMomentEnergyCanonicalPaidSource CenteredMomentEnergyCanonicalCommonPaid +open CenteredMomentEnergyCanonicalReferencePaid CenteredMomentEnergyBandSubtypeTransport +open CenteredMomentFirstAmplifiedCapacityCommon (ratioPenalty) +open CenteredMomentEnergyAllocatedClipped CenteredMomentEnergyAllocatedHomogeneous +open CenteredMomentEnergyChildState CenteredMomentSecondNonexceptionalChosenBlock +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyAllocatedPaid CenteredMomentEnergyAllocatedProfiles +open CenteredMomentEnergyAllocatedChildren CenteredMomentEnergyAllocatedZero +open CenteredMomentInductionEnergy CenteredMomentFiniteProfileExceptional +open CenteredMomentNaturalFixedRaySource CenteredMomentCommonRadialData +open CenteredMomentCommonHeightEnvelope CenteredMomentCommonAllocationSum +open CenteredMomentDivisorAllocation CenteredMomentDivisorRaw +open CenteredMomentAllocatedNaturalSource CenteredMomentRetainedProfile +open CenteredMomentAllocatedRayDictionary QuadraticInitialBound + +open CenteredMomentEnergyCanonicalChildBound CenteredMomentSectorLocalization +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem original_subsets_reference_paid (W:ℝ→ℂ)(aslot bslot Mcap Lslot εremove lo hi κ:ℝ) + (a b Mslot εmask:ℝ)(hMslot:0≤Mslot)(hεmask:0<εmask)(haPlain:0(hCc J).le) + dsimp [Ctot];linarith + refine ⟨n₀,T₀,dc₀,Ctot,hCt,?_⟩ + intro η₀ + let Choices:=ΣJ:Finset α,J→RayQuotient.Characters M H + let:Fintype (RayQuotient.Characters M H):=Fintype.ofFinite _ + let:Fintype Choices:=inferInstance + have hchoices (c:Choices):∃Z₀:ℝ,1False.elim (Finset.notMem_empty _ i.property)⟩⟩ + let:Nonempty Choices:=hn + have hh:=Finset.sum_pos (s:=Finset.univ) (fun c _=>(zero_lt_one.trans (hZchoice c))) + Finset.univ_nonempty + dsimp [Z₀];linarith + refine ⟨Z₀,hZ₀,?_⟩ + intro Jorig θ Z hZ εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hpos + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq + src hmatch hhi hMs C R B D alloc hR τ dyad hn hwidth p hp₁ hp₂ + dsimp only + intro hX₁ hX₂ hY₁ hY₂ A Mparent reference u ell δ₁ δ₂ θclip href + hu hell hδ₁ hδ₂ hθclip hparent hshift hdefect hclip + have hZi:Zchoice ⟨Jorig,θ⟩≤Z:=by + have hh:=Finset.single_le_sum (s:=Finset.univ) + (fun c _=>(zero_lt_one.trans (hZchoice c)).le) (Finset.mem_univ (⟨Jorig,θ⟩:Choices)) + dsimp [Z₀] at hZ + linarith + have hp:=positiveAt_subtype M H hH Jorig W bslot (a/max 1 b) b 2 0 L Lslot lo hi + Mcap εchild κ Z η₀ Q degree S C₁ hpos + have hh:=hb ⟨Jorig,θ⟩ Z hZi εchild Q hQM C₀ C₁ hC₀ hC₁ hzero hp + w σ freq v height mesh hmesh hw hwm hwL hσlo hσhi hheight hfreq + src hmatch hhi hMs C R B D alloc hR τ dyad hn hwidth p hp₁ hp₂ + hX₁ hX₂ hY₁ hY₂ A Mparent reference u ell δ₁ δ₂ θclip href + hu hell hδ₁ hδ₂ hθclip hparent hshift hdefect hclip + have hc:Cc Jorig≤Ctot:=by + have hh:=Finset.single_le_sum (s:=Finset.univ) (fun J _=>(hCc J).le) (Finset.mem_univ Jorig) + dsimp [Ctot];linarith + have ht:T Jorig⊆T₀:=by + intro x hx + exact Finset.mem_biUnion.mpr ⟨Jorig,Finset.mem_univ _,hx⟩ + have hctrl:p.control (T Jorig)≤p.control T₀:=by + unfold Profiles.control + exact mul_le_mul (Seminorm.le_def.mp (Finset.sup_mono ht) (p.profile 0)) + (Seminorm.le_def.mp (Finset.sup_mono ht) (p.profile 1)) + (sourceControl_nonneg _ _) (sourceControl_nonneg _ _) + have hn₀:n Jorig≤n₀:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ Jorig) + have hdc₀:dc Jorig≤dc₀:=Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_univ Jorig) + have hdeg:dc Jorig+degree+4*n Jorig≤dc₀+degree+4*n₀:=by omega + have hpow:(1+(|v|+height))^(dc Jorig+degree+4*n Jorig)≤ + (1+(|v|+height))^(dc₀+degree+4*n₀):= + pow_le_pow_right₀ (by linarith [abs_nonneg v]) hdeg + have hcontrol:=p.control_nonneg (T Jorig) + have hd:0≤diagonalControl (canonicalRadial τ (internalQ Q η₀) dyad).profile:=by + unfold diagonalControl;positivity + have hz0:0 HeckeFamily.O +variable {ι : Type*} [Fintype ι] [DecidableEq ι] + +theorem compact_radial_summable (f : O→ℂ) (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) + (K b : ℝ) (hK : 0if keep z then ‖f z‖^2*(Φ (‖eisEmbedding z‖^2/K)).re else 0) := by + obtain ⟨N,hN⟩:=exists_nat_ge (b*K) + apply summable_of_ne_finset_zero (s:=ShortDraftLatticeCount.rowNormBall N) + intro z hz + have hΦ : Φ (‖eisEmbedding z‖^2/K)=0 := by + by_contra hn + have hh : ‖eisEmbedding z‖^2≤(N:ℝ):=((div_le_iff₀ hK).mp (hs hn)).trans hN + apply hz + apply ShortDraftLatticeCount.mem_rowNormBall_of_absNorm_le + exact_mod_cast (show ((Ideal.span {z}).absNorm:ℝ)≤N by + rwa [←ActualEisensteinCubic.eisEmbedding_norm_sq_eq_absNorm_span]) + simp [hΦ] + +omit [DecidableEq ι] in + +theorem energy_support (η : Character) (m A : O) (t : ℝ) (W₁ W₂ : ℝ→ℂ) + (S : ι→Finset (Ideal O)) (β : ι→Ideal O→ℂ) (P : ι→ℝ) (X₁ X₂ : ℝ) + (keep : O→Prop) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + energy η m A t W₁ W₂ S β P X₁ X₂ keep Φ K= + energy η m A t W₁ W₂ S β P X₁ X₂ + (fun z=>keep z ∧ Φ (‖eisEmbedding z‖^2/K)≠0) Φ K := by + unfold energy + apply tsum_congr + intro z + by_cases hk : keep z <;> by_cases hp : Φ (‖eisEmbedding z‖^2/K)=0 <;> simp [hk,hp] + +omit [Fintype ι] in + +theorem selected_eq_positive (J : Finset ι) (η : Character) (m A z : O) + (W₁ W₂ : ℝ→ℂ) (S : ι→Finset (Ideal O)) (β : ι→Ideal O→ℂ) + (P : ι→ℝ) (t X₁ X₂ : ℝ) (hX : 0≤X₁*X₂) (hP : ∀i,0≤P i) : + selectedProduct J η m A z W₁ W₂ S β P t X₁ X₂= + positiveSlotRow η m A z W₁ W₂ (fun i:J=>S i) (fun i:J=>β i) + (fun i:J=>P i) t X₁ X₂ := by + have hh:=selectedProduct_univ η m A z W₁ W₂ + (fun i:J=>S i) (fun i:J=>β i) (fun i:J=>P i) t X₁ X₂ hX (fun i=>hP i) + have hp : (∏i:J,normalizedSlot η m A z (S i) (β i) t (P i))= + ∏i∈J,normalizedSlot η m A z (S i) (β i) t (P i) := + Finset.prod_coe_sort J (fun i=>normalizedSlot η m A z (S i) (β i) t (P i)) + unfold selectedProduct at hh ⊢ + rw [hp] at hh + exact hh + +theorem unit_puncture_energy (η : Character) (t : ℝ) (W₁ W₂ : ℝ→ℂ) + (S : ι→Finset (Ideal O)) (β : ι→Ideal O→ℂ) (P : ι→ℝ) (X₁ X₂ : ℝ) + (keep : O→Prop) (hz : ∀z,keep z→z≠0) (Φ : 𝓢(ℝ,ℂ)) (K : ℝ) : + energy η (fixedBadMask*ConcretePrimeRowBridge.idealGenerator 1) 1 t W₁ W₂ S β P X₁ X₂ keep Φ K= + energy η fixedBadMask 1 t W₁ W₂ S β P X₁ X₂ keep Φ K := by + unfold energy + apply tsum_congr + intro z + by_cases hk : keep z + · simp only [ite_eq_left hk] + rw [natural_unit_mask_positive (naturalRow η z (hz z hk))] + · simp only [ite_eq_right hk] + +theorem eventual_state_conductor (bΦ Mcap : ℝ) (hb : 0≤bΦ) : + ∀ᶠZ:ℝ in atTop,1 rw [Real.rpow_add (zero_lt_one.trans hZ),Real.rpow_one] + ring + +lemma state_unit_nonexceptional {Z Bmask bΦ : ℝ} (s : NaturalState Z Bmask bΦ) + (hpuncture : s.puncture=1) (Q : Ideal O) (hQ : s.fixedModulus=Q) + (z : O) (hk : s.radial.keep z) : ¬FixedInducingRow s.character Q fixedBadMask 1 z := by + intro hh + apply s.nonexceptional z hk + rw [hQ,hpuncture] + exact (fixedInducingRow_mul_mask_iff s.character Q fixedBadMask + (ConcretePrimeRowBridge.idealGenerator 1) 1 z fixedBadMask_ne_zero + (ConcretePrimeRowBridge.idealGenerator_ne_zero 1 one_ne_zero) one_ne_zero (s.row_ne_zero z hk) + (dvd_mul_right _ _) (dvd_mul_left _ _)).mpr hh + +variable (M : Ideal O) [NeZero M] +local instance : Finite (O⧸M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O⧸M)ˣ) (hH : RayOrthogonality.globalUnits M≤H) +include hH + +theorem actual_state_capacity_removal + (W : ι→ℝ→ℂ) (a b : ι→ℝ) (ha : ∀i,0Z^(w i) + let S:=fun i=>primePool M H (b i) (P i) + let coeff:=fun i I=>idealCoeff (ν i) I*HeckePrimeAnnular.annularWeight (W i) (P i) (σ i) (freq i) I + energy s.character s.mask 1 t W₁ W₂ (fun i:J=>S i) (fun i:J=>coeff i) + (fun i:J=>P i) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale≤ + C*(1+|t|+V)^degree*Z^(ε+CenteredMomentLiveCapacity.excess J w n₁ n₂ width κ/6+κ*mesh)* + energy s.character s.mask 1 t W₁ W₂ (fun i:↥(J\R)=>S i) (fun i:↥(J\R)=>coeff i) + (fun i:↥(J\R)=>P i) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale := by + obtain ⟨degree,C,hC,hbound⟩:=actual_relative_capacity_removal M H hH W a b ha hWs hW + Lmod Lslot ε lo hi κ hLm hLs hε hbeta hκ + obtain ⟨Zsupport,hsupport⟩:=eventually_atTop.mp (eventual_row_conductor bΦ Mrow hbΦ) + refine ⟨degree,C,hC,?_⟩ + intro ν + obtain ⟨Zbase,hZbase,hbound⟩:=hbound ν + refine ⟨max Zbase Zsupport,lt_of_lt_of_le hZbase (le_max_left _ _),?_⟩ + intro J w n₁ n₂ width mesh hmesh hw hwm hwcap + obtain ⟨R,hR,hcapacity,hcost,hpoint⟩:=hbound J w n₁ n₂ width mesh hmesh hw hwm hwcap + refine ⟨R,hR,hcapacity,hcost,?_⟩ + intro Z hZ Bmask s hpuncture hrow q hmod hLmod Q hQ hQM hQν σ freq t V hσ hσhi hV hfreq W₁ W₂ X₁ X₂ hX₁ hX₂ + dsimp only + have hZbase' : Zbase≤Z:=(le_max_left _ _).trans hZ + have hs:=(hsupport Z ((le_max_right _ _).trans hZ)) + have hZpos:0Z^(w i) + let S:=fun i=>primePool M H (b i) (P i) + let coeff:=fun i I=>idealCoeff (ν i) I*HeckePrimeAnnular.annularWeight (W i) (P i) (σ i) (freq i) I + let cost:=C*(1+|t|+V)^degree*Z^(ε+CenteredMomentLiveCapacity.excess J w n₁ n₂ width κ/6+κ*mesh) + have hmask:s.mask=fixedBadMask*ConcretePrimeRowBridge.idealGenerator 1:=by rw [NaturalState.mask,hpuncture] + rw [hmask,unit_puncture_energy _ _ _ _ _ _ _ _ _ _ s.row_ne_zero, + unit_puncture_energy _ _ _ _ _ _ _ _ _ _ s.row_ne_zero] + change energy s.character fixedBadMask 1 t W₁ W₂ (fun i:J=>S i) (fun i:J=>coeff i) + (fun i:J=>P i) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale≤ + cost*energy s.character fixedBadMask 1 t W₁ W₂ (fun i:↥(J\R)=>S i) (fun i:↥(J\R)=>coeff i) + (fun i:↥(J\R)=>P i) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale + have hsum (T:Finset ι):=compact_radial_summable + (fun z=>positiveSlotRow s.character fixedBadMask 1 z W₁ W₂ (fun i:T=>S i) + (fun i:T=>coeff i) (fun i:T=>P i) t X₁ X₂) + s.radial.keep s.radial.profile s.radial.scale bΦ s.radial.scale_pos s.radial_support + unfold energy + rw [←tsum_mul_left] + apply (hsum J).tsum_le_tsum _ ((hsum (J\R)).mul_left cost) + intro z + by_cases hk:s.radial.keep z + · simp only [ite_eq_left hk] + by_cases hp:s.radial.profile (‖eisEmbedding z‖^2/s.radial.scale)=0 + · simp [hp] + · have hz:=s.row_ne_zero z hk + have hc:((naturalRow s.character z hz).character.modulus.absNorm:ℝ)≤Z^Lmod:= + (hs.2 Bmask s hrow q hmod z hz hp).trans + (Real.rpow_le_rpow_of_exponent_le hs.1.le hLmod) + have hh:=hpoint Z hZbase' s.character z hz (naturalRow s.character z hz) hc + Q hQM hQν (state_unit_nonexceptional s hpuncture Q hQ z hk) + σ freq t V hσ hσhi hV hfreq W₁ W₂ X₁ X₂ + dsimp only at hh + rw [selected_eq_positive J s.character fixedBadMask 1 z W₁ W₂ S coeff P t X₁ X₂ (mul_pos hX₁ hX₂).le hscale, + selected_eq_positive (J\R) s.character fixedBadMask 1 z W₁ W₂ S coeff P t X₁ X₂ (mul_pos hX₁ hX₂).le hscale] at hh + exact (mul_le_mul_of_nonneg_right hh (s.radial.nonneg z)).trans_eq (by dsimp only [cost];ring) + · simp only [ite_eq_right hk,mul_zero,le_refl] + +theorem actual_relative_state_capacity_removal + (W : ι→ℝ→ℂ) (a b : ι→ℝ) (ha : ∀i,0relativeCharacter M H hH η₀ (θ i); + ∃Z₀:ℝ,1Z^(w i) + let S:=fun i=>primePool M H (b i) (P i) + let coeff:=fun i I=>idealCoeff (ν i) I*HeckePrimeAnnular.annularWeight (W i) (P i) (σ i) (freq i) I + energy s.character s.mask 1 t W₁ W₂ (fun i:J=>S i) (fun i:J=>coeff i) + (fun i:J=>P i) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale≤ + C*(1+|t|+V)^degree*Z^(ε+CenteredMomentLiveCapacity.excess J w n₁ n₂ width κ/6+κ*mesh)* + energy s.character s.mask 1 t W₁ W₂ (fun i:↥(J\R)=>S i) (fun i:↥(J\R)=>coeff i) + (fun i:↥(J\R)=>P i) X₁ X₂ s.radial.keep s.radial.profile s.radial.scale := by + obtain ⟨degree,C,hC,hbound⟩:=actual_state_capacity_removal M H hH W a b ha hWs hW + Mrow bΦ Lmod Lslot ε lo hi κ hbΦ hLm hLs hε hbeta hκ + refine ⟨degree,C,hC,?_⟩ + intro η₀ θ + dsimp only + obtain ⟨Z₀,hZ₀,hbound⟩:=hbound (fun i=>relativeCharacter M H hH η₀ (θ i)) + refine ⟨Z₀,hZ₀,?_⟩ + intro J w n₁ n₂ width mesh hmesh hw hwm hwcap + obtain ⟨R,hR,hcapacity,hcost,henergy⟩:=hbound J w n₁ n₂ width mesh hmesh hw hwm hwcap + refine ⟨R,hR,hcapacity,hcost,?_⟩ + intro Z hZ Bmask s hpuncture hrow q hmod hLmod Q hQ hQM + exact henergy Z hZ Bmask s hpuncture hrow q hmod hLmod (internalQ Q η₀) hQ + (inf_le_left.trans hQM) + (fun i=>relativeCharacter_fixedQ M H hH η₀ (θ i) (internalQ Q η₀) + (inf_le_left.trans hQM) inf_le_right) + +end SevenEighths.CenteredMomentEnergyCapacityRemoval + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CappedAnalyticSuccessor.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CappedAnalyticSuccessor.lean new file mode 100644 index 0000000000000000000000000000000000000000..e48d2c10a65012a44b1525fa5231921ad1120566 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CappedAnalyticSuccessor.lean @@ -0,0 +1,180 @@ +import OAI.NumberTheory.DirichletL.Energy.CappedLowStage +import OAI.NumberTheory.DirichletL.Energy.NaturalHighStage +import OAI.NumberTheory.DirichletL.Energy.NaturalZeroStage +import OAI.NumberTheory.DirichletL.Energy.CappedSuccessorPacking +import OAI.NumberTheory.DirichletL.Energy.CappedRequests +import OAI.NumberTheory.DirichletL.Energy.CappedBandTransport + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap ContDiff +open Filter + +namespace SevenEighths.CenteredMomentEnergyCappedAnalyticSuccessor +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyReferenceLowBands CenteredMomentEnergyPositiveHighBound +open CenteredMomentEnergyWidthSchedule CenteredMomentEnergyWidthRanges +open CenteredMomentEnergyWidthInduction (remaining lowerAt lengthAt lowerAt_pos child_support child_length) +open CenteredMomentEnergyCappedWidthInduction +open CenteredMomentEnergyStageReserveSchedule CenteredMomentEnergyStageMargins +open CenteredMomentEnergyBandMonotonicity CenteredMomentEnergyStageMonotonicity +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergyCappedRequests +open CenteredMomentEnergySourceCapSchedule CenteredMomentNaturalFixedRaySource +local notation "O"=>HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_successor + (W:ℝ→ℂ)(aslot bslot a b radial Bmask L lo hi Mcap κ ε:ℝ) + (haslot:0 linarith + have hzeroReady:readyBudget (max Mp (2*Lgrow)) Bmask≤Bs:=by + have hc:max Mp (2*Lgrow)≤A:=by + apply max_le + · exact hMA + · dsimp [A];linarith + apply le_trans _ hready + unfold readyBudget + linarith + obtain ⟨Jzero,Uzero,hzero⟩:=hzeroStage Lp hLp hzeroCap hzeroReady Jold Jlow Sold Slow + have hmarg:=margins Mcap Bs κ ε hMcap.le hBs hκ0 hε k + apply CenteredMomentEnergyCappedSuccessorPacking.certified_from_stages (α:=α) M H hH + W bslot a b radial Bmask L lo hi Mcap κ ε ha hmask hMcap.le hκ0 hε k + (stageLoss Mcap Bs ε (k+1)) (physicalLoss Mcap Bs ε k) (reflectedLoss Mcap Bs ε k) + le_rfl (hmarg.2.2.2.1.trans hmarg.2.2.2.2) hmarg.2.2.2.2 ⟨Jold,Sold,hprev⟩ + · refine ⟨Jzero,Uzero,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨C₀,C₁,hC₀,hC₁,hprevZ⟩:=hprev η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Clow,hClow,hlowZ⟩:=hlow η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Cz,hCz,hzeroZ⟩:=hzero η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Cz*(Clow+C₀+C₁+1),by positivity,?_⟩ + filter_upwards [hprevZ,hlowZ,hzeroZ] with Z hp hl hz + have hzz:=hp.2.1 + have hpp:=hp.2.2 + rw [hsupport] at hzz hpp + have hlowRestricted:=zeroLowAt_transport (internalQ Q η₀) + ac b radial Bmask Lreq Mp (physicalLoss Mcap Bs ε k) Z + ac b radial Bmask Llow Mp (physicalLoss Mcap Bs ε k) Jlow Jlow Slow Slow Clow Clow + hp.1.le le_rfl le_rfl le_rfl le_rfl hLlowReq le_rfl le_rfl le_rfl + (Finset.Subset.refl _) hClow.le le_rfl hl.2.2 + exact hz.2 _ C₀ C₁ Clow le_rfl hC₀.le hC₁.le hClow.le hzz hpp hlowRestricted + · refine ⟨Jlow,Slow,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Clow,hClow,hlowZ⟩:=hlow η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Clow,hClow,?_⟩ + filter_upwards [hlowZ] with Z hl + exact positiveLowAt_transport (α:=α) M H hH W bslot + ac b radial Bmask Lreq (fineMesh Mcap Bmask L κ ε) lo hi Mp (physicalLoss Mcap Bs ε k) κ Z + ac b radial Bmask Lc Mp (physicalLoss Mcap Bs ε k) η₀ Q Jlow Jlow Slow Slow Clow Clow + hl.1.le le_rfl le_rfl le_rfl le_rfl hreq.2.1 le_rfl le_rfl le_rfl + (Finset.Subset.refl _) hClow.le le_rfl hl.2.1 + · refine ⟨Jhigh,Uhigh,?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨C₀,C₁,hC₀,hC₁,hprevZ⟩:=hprev η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Clow,hClow,hlowZ⟩:=hlow η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Ch,hCh,hhighZ⟩:=hhigh η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Ch*(C₀+C₁+Clow+1),by positivity,?_⟩ + filter_upwards [hprevZ,hlowZ,hhighZ] with Z hp hl hh + have hzz:=hp.2.1 + have hpp:=hp.2.2 + rw [hsupport] at hzz hpp + have hzSmall:=zeroAt_transport (internalQ Q η₀) + (ac/max 1 b) b radial Bmask Lp Mc (stageLoss Mcap Bs ε k) Z + (ac/max 1 b) b 2 0 (max Lc Mp) Mc (stageLoss Mcap Bs ε k) + Jold Jold Sold Sold C₀ C₀ hp.1.le le_rfl le_rfl hrad hmask hhighL le_rfl le_rfl le_rfl + (Finset.Subset.refl _) hC₀.le le_rfl hzz + have hpSmall:=positiveAt_transport (α:=α) M H hH W bslot + (ac/max 1 b) b radial Bmask Lp (fineMesh Mcap Bmask L κ ε) lo hi Mc (stageLoss Mcap Bs ε k) κ Z + (ac/max 1 b) b 2 0 (max Lc Mp) Mc (stageLoss Mcap Bs ε k) η₀ Q + Jold Jold Sold Sold C₁ C₁ hp.1.le le_rfl le_rfl hrad hmask hhighL le_rfl le_rfl le_rfl + (Finset.Subset.refl _) hC₁.le le_rfl hpp + have hlRestricted:=positiveLowAt_transport (α:=α) M H hH W bslot + ac b radial Bmask Lreq (fineMesh Mcap Bmask L κ ε) lo hi Mp (physicalLoss Mcap Bs ε k) κ Z + ac b radial Bmask (Mp+Bmask+Mc/100) Mp (physicalLoss Mcap Bs ε k) η₀ Q + Jlow Jlow Slow Slow Clow Clow hp.1.le le_rfl le_rfl le_rfl le_rfl href le_rfl le_rfl le_rfl + (Finset.Subset.refl _) hClow.le le_rfl hl.2.1 + exact hh.2 _ C₀ C₁ Clow le_rfl hC₀.le hC₁.le hClow.le hzSmall hpSmall hlRestricted + +end SevenEighths.CenteredMomentEnergyCappedAnalyticSuccessor + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CappedBandTransport.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CappedBandTransport.lean new file mode 100644 index 0000000000000000000000000000000000000000..8c04c12da6d54c6bcad388309a8a34e344084e10 --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CappedBandTransport.lean @@ -0,0 +1,61 @@ +import OAI.NumberTheory.DirichletL.Energy.CappedWidthInduction + +namespace OAI + +noncomputable section +open scoped Classical BigOperators SchwartzMap +open Filter + +namespace SevenEighths.CenteredMomentEnergyCappedBandTransport +open HeckeFamily CenteredMomentEnergyState CenteredMomentEnergyBands +open CenteredMomentEnergyCappedWidthInduction CenteredMomentEnergyWidthInduction +open CenteredMomentEnergyWidthSchedule CenteredMomentEnergyWidthRanges +open CenteredMomentEnergyStageReserveSchedule CenteredMomentEnergyBandMonotonicity +open CenteredMomentNaturalFixedRaySource +local notation "O"=>HeckeFamily.O +variable {α:Type*} +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +lemma saturated_successor (W:ℝ→ℂ)(bslot a b radial Bmask L lo hi Mcap κ ε:ℝ) + (ha:0HeckeFamily.O +variable {α:Type*}[Fintype α][DecidableEq α] +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem actual_capped_low + (W:ℝ→ℂ)(aslot bslot a b radial Bmask L lo hi Mcap κ ε:ℝ) + (hW:ContDiff ℝ ∞ W)(haslot:0 HeckeFamily.O +variable {α : Type*} +variable (M : Ideal O) [NeZero M] +local instance : Finite (O ⧸ M) := Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H : Subgroup (O ⧸ M)ˣ) (hH : RayOrthogonality.globalUnits M ≤ H) + +theorem certified_radial_mono (W : ℝ → ℂ) + (bslot a b radialOld radialNew Bmask L lo hi Mcap κ ε : ℝ) (k : ℕ) + (hrad : radialNew ≤ radialOld) + (h : CertifiedBand (α := α) M H hH W bslot a b radialOld Bmask L lo hi Mcap κ ε k) : + CertifiedBand (α := α) M H hH W bslot a b radialNew Bmask L lo hi Mcap κ ε k := by + obtain ⟨degree, S, hbound⟩ := h + refine ⟨degree, S, ?_⟩ + intro η₀ Q hQM hQ0 hQt hQ72 + obtain ⟨Czero, Cpositive, hCzero, hCpositive, hcert⟩ := hbound η₀ Q hQM hQ0 hQt hQ72 + refine ⟨Czero, Cpositive, hCzero, hCpositive, ?_⟩ + filter_upwards [hcert] with Z hZ + refine ⟨hZ.1, ?_, ?_⟩ + · exact zeroAt_transport _ _ _ _ _ _ _ _ Z _ _ _ _ _ _ _ + degree degree S S Czero Czero hZ.1.le le_rfl le_rfl hrad le_rfl + le_rfl le_rfl le_rfl le_rfl (Finset.Subset.refl _) hCzero.le le_rfl hZ.2.1 + · exact positiveAt_transport (α := α) M H hH W bslot _ _ _ _ _ _ _ _ _ _ κ Z + _ _ _ _ _ _ _ η₀ Q degree degree S S Cpositive Cpositive hZ.1.le + le_rfl le_rfl hrad le_rfl le_rfl le_rfl le_rfl le_rfl (Finset.Subset.refl _) + hCpositive.le le_rfl hZ.2.2 + +theorem certified_from_max_two (W : ℝ → ℂ) + (bslot a b radial Bmask L lo hi Mcap κ ε : ℝ) (k : ℕ) + (h : CertifiedBand (α := α) M H hH W bslot a b (max 2 radial) + Bmask L lo hi Mcap κ ε k) : + CertifiedBand (α := α) M H hH W bslot a b radial Bmask L lo hi Mcap κ ε k := + certified_radial_mono (α := α) M H hH W bslot a b (max 2 radial) radial + Bmask L lo hi Mcap κ ε k (le_max_right _ _) h + +end SevenEighths.CenteredMomentEnergyCappedRadialTransport + +end + +end OAI diff --git a/lean/OAI/NumberTheory/DirichletL/Energy/CappedRequests.lean b/lean/OAI/NumberTheory/DirichletL/Energy/CappedRequests.lean new file mode 100644 index 0000000000000000000000000000000000000000..16fcf20c11de2eb0ecbe73a8069dfb1d76b7058b --- /dev/null +++ b/lean/OAI/NumberTheory/DirichletL/Energy/CappedRequests.lean @@ -0,0 +1,77 @@ +import OAI.NumberTheory.DirichletL.Energy.CappedWidthInduction +import OAI.NumberTheory.DirichletL.Energy.SourceCapSchedule + +namespace OAI + +noncomputable section + +namespace SevenEighths.CenteredMomentEnergyCappedRequests +open CenteredMomentEnergyWidthSchedule CenteredMomentEnergyWidthRanges +open CenteredMomentEnergyWidthInduction CenteredMomentEnergyCappedWidthInduction +open CenteredMomentEnergyFirstLiveAdmission CenteredMomentEnergySourceCapSchedule + +def requestLength (M B L:ℝ):ℝ:=max L (2*M+B+2)+1 + +lemma request_bounds (M B L:ℝ)(hM:0≤M)(hB:0≤B)(_hL:0≤L): + 0≤requestLength M B L ∧ L≤requestLength M B L ∧ M≤requestLength M B L:=by + have hh:=le_max_left L (2*M+B+2) + have hg:=le_max_right L (2*M+B+2) + unfold requestLength + constructor + · linarith + constructor <;> linarith + +lemma actual_contours (M B L parent rho d:ℝ)(hM:0≤M)(_hB:0≤B) + (hp:parent≤M)(hr:rho≤M)(hd:d≤1): + max (max L (parent+B+2*d)+1) (parent+B+rho/100)≤requestLength M B L:=by + have hmax:max L (parent+B+2*d)≤max L (2*M+B+2):=by + apply max_le_max_left + linarith + have hh:=le_max_right L (2*M+B+2) + unfold requestLength + apply max_le <;> linarith + +lemma doubled_request (M B L e:ℝ)(hM:0≤M)(hB:0≤B)(hL:0≤L)(he:e≤1): + 2*requestLength M B L+e≤step M B L:=by + have hh:max L (2*M+B+2)≤L+2*M+B+2:=by + apply max_le <;> linarith + unfold requestLength step + linarith + +lemma previous_admits (M B L ε parent e:ℝ)(hM:0≤M)(hB:0≤B) + (hp:parent≤M)(he:e≤1)(k:ℕ)(hk:kHeckeFamily.O +variable {α:Type*} +variable (M:Ideal O)[NeZero M] +local instance : Finite (O⧸M):=Ring.HasFiniteQuotients.finiteQuotient (NeZero.ne M) +variable (H:Subgroup (O⧸M)ˣ)(hH:RayOrthogonality.globalUnits M≤H) + +theorem certified_from_stages + (W:ℝ→ℂ)(bslot a b radial Bmask L lo hi Mcap κ ε:ℝ) + (ha:0