Download data/lean/OAI/NumberTheory/PrimePackets/AnalyticLogarithms.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 23.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PrimePackets/AnalyticLogarithms.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/NumberTheory/PrimePackets/AnalyticLogarithms.lean
-
curl -L -o AnalyticLogarithms.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/NumberTheory/PrimePackets/AnalyticLogarithms.lean
23.7 kB
| import Mathlib | |
| namespace OAI | |
| section | |
| noncomputable section | |
| open scoped Matrix Topology BigOperators Classical TensorProduct ENNReal | |
| open MeasureTheory Filter Set Module | |
| universe u | |
| open scoped TensorProduct | |
| open Set Module | |
| open MeasureTheory Set | |
| open scoped ENNReal | |
| open IsDiscreteValuationRing IsLocalRing | |
| open scoped ENNReal BigOperators | |
| open MeasureTheory Set IsDiscreteValuationRing | |
| open Filter | |
| open scoped BigOperators Topology | |
| open NumberField | |
| open scoped NumberField nonZeroDivisors | |
| open scoped BigOperators ArithmeticFunction.zeta | |
| open Finset | |
| open scoped BigOperators Classical ArithmeticFunction.Moebius | |
| open Finset Nat ArithmeticFunction BoundingSieve | |
| open scoped BigOperators Classical | |
| open Finset Nat | |
| open scoped BigOperators | |
| open Filter Topology | |
| open scoped nonZeroDivisors | |
| open Ideal NumberField Finset UniqueFactorizationMonoid | |
| open Filter Set Topology NumberField | |
| open scoped Matrix Topology BigOperators Classical TensorProduct ENNReal NumberField Pointwise nonZeroDivisors | |
| open MeasureTheory Filter Set Module NumberField FractionalIdeal Topology TopologicalSpace | |
| open Filter Set Topology | |
| open scoped Matrix Topology BigOperators Classical TensorProduct ENNReal NumberField Pointwise nonZeroDivisors RealInnerProductSpace | |
| open MeasureTheory Filter Set Module NumberField FractionalIdeal Topology TopologicalSpace Matrix | |
| open MeasureTheory Filter Set Module TopologicalSpace | |
| open MeasureTheory Filter Set | |
| open scoped BigOperators Topology ENNReal | |
| open scoped BigOperators Topology ENNReal Classical | |
| open scoped BigOperators Topology ENNReal Classical Matrix Matrix.Norms.Elementwise | |
| open scoped BigOperators Topology ENNReal Classical Matrix Matrix.Norms.Elementwise Pointwise | |
| open scoped BigOperators Topology ENNReal Classical Matrix Pointwise | |
| open scoped BigOperators Topology ENNReal Classical Matrix | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open Set Filter | |
| open scoped Topology | |
| open scoped Classical | |
| open scoped Topology ENNReal Classical | |
| open scoped ENNReal Classical | |
| open MeasureTheory Set Topology UniformSpace TopologicalSpace | |
| open scoped ENNReal Topology | |
| open MeasureTheory Filter Set Matrix | |
| open scoped Topology Classical | |
| open scoped Matrix Classical | |
| open scoped Topology Classical Matrix | |
| open scoped Classical Pointwise | |
| open scoped Topology Classical ENNReal | |
| open scoped Matrix Topology Classical | |
| open MeasureTheory ProbabilityTheory Set Filter | |
| open scoped Matrix Topology Classical ENNReal ProbabilityTheory | |
| open scoped ENNReal ProbabilityTheory | |
| open Set Filter Topology | |
| open Set Filter Topology MeasureTheory | |
| open MeasureTheory Set Filter Topology | |
| open MeasureTheory ProbabilityTheory Set Filter Topology | |
| open scoped Matrix ENNReal NNReal ProbabilityTheory | |
| open MeasureTheory | |
| open scoped BigOperators ENNReal | |
| open NumberField Finset | |
| open NumberField Filter Set Topology | |
| open MeasureTheory ProbabilityTheory Matrix | |
| open scoped Classical BigOperators ENNReal | |
| open MeasureTheory Set Filter Topology Module | |
| open scoped BigOperators SchwartzMap | |
| open MeasureTheory Set Filter Topology Module WithLp | |
| open scoped BigOperators SchwartzMap ZeroAtInfty | |
| open scoped FourierTransform | |
| open scoped BigOperators SchwartzMap FourierTransform | |
| open scoped BigOperators FourierTransform | |
| open MeasureTheory Set Filter Topology Module WithLp Asymptotics | |
| open Module WithLp MeasureTheory | |
| open scoped BigOperators Matrix | |
| open Module MeasureTheory | |
| open MeasureTheory Module WithLp | |
| open scoped BigOperators NumberField nonZeroDivisors ENNReal | |
| open Complex Set Metric Filter | |
| namespace PrimeDegreePackets.AnalyticGrowth | |
| lemma exists_disk_logarithm {g : β β β} {R : β} (hR : 0 < R) | |
| (hg : DifferentiableOn β g (ball 0 R)) | |
| (hzero : β z β ball 0 R, g z β 0) : | |
| β h : β β β, h 0 = 0 β§ | |
| (β z β ball 0 R, HasDerivAt h (logDeriv g z) z) β§ | |
| (β z β ball 0 R, Complex.exp (h z) = g z / g 0) := by | |
| have hga : AnalyticOnNhd β g (ball 0 R) := hg.analyticOnNhd isOpen_ball | |
| have hld : DifferentiableOn β (logDeriv g) (ball 0 R) := by | |
| intro z hz | |
| exact (((hga z hz).deriv.differentiableAt).div | |
| ((hg z hz).differentiableAt (isOpen_ball.mem_nhds hz)) (hzero z hz)).differentiableWithinAt | |
| obtain β¨h,h0,hhβ© := hld.isExactOn_ball.with_val_at 0 0 | |
| refine β¨h,h0,hh,?_β© | |
| have HD : β z β ball 0 R, | |
| HasDerivAt (fun z => g z * Complex.exp (-h z)) 0 z := by | |
| intro z hz | |
| have H := ((hg z hz).differentiableAt (isOpen_ball.mem_nhds hz)).hasDerivAt.mul ((hh z hz).neg.cexp) | |
| apply H.congr_deriv | |
| dsimp only [Pi.neg_apply, logDeriv_apply] | |
| field_simp [hzero z hz] | |
| ring | |
| have HE : EqOn (fun z => g z * Complex.exp (-h z)) (fun _ => g 0) (ball 0 R) := by | |
| apply isOpen_ball.eqOn_of_deriv_eq (convex_ball (0:β) R).isPreconnected | |
| (fun z hz => (HD z hz).differentiableAt.differentiableWithinAt) | |
| (differentiableOn_const _) (fun z hz => by rw [(HD z hz).deriv, deriv_const]) | |
| (mem_ball_self hR) | |
| simp [h0] | |
| intro z hz | |
| have H := HE hz | |
| rw [eq_div_iff (hzero 0 (mem_ball_self hR))] | |
| have He : Complex.exp (-h z) * Complex.exp (h z) = 1 := by | |
| rw [β Complex.exp_add, neg_add_cancel, Complex.exp_zero] | |
| have HH := congrArg (fun w => w*Complex.exp (h z)) H | |
| rw [mul_assoc, He, mul_one] at HH | |
| exact (mul_comm _ _).trans HH.symm | |
| lemma disk_logarithm_re {g h : β β β} {z : β} | |
| (hzero : g 0 β 0) (hz : Complex.exp (h z) = g z / g 0) : | |
| (h z).re = Real.log βg zβ - Real.log βg 0β := by | |
| have Hg : g z β 0 := by | |
| intro H | |
| rw [H, zero_div] at hz | |
| exact Complex.exp_ne_zero _ hz | |
| have H := congrArg (fun w : β => Real.log βwβ) hz | |
| simpa only [Complex.norm_exp, Real.log_exp, norm_div, | |
| Real.log_div (norm_ne_zero_iff.mpr Hg) (norm_ne_zero_iff.mpr hzero)] using H | |
| end PrimeDegreePackets.AnalyticGrowth | |
| namespace PrimeDegreePackets.AnalyticGrowth | |
| lemma deriv_sub_le_of_re_le {h : β β β} {R M : β} (hR : 0 < R) (hM : 0 < M) | |
| (hh : DifferentiableOn β h (ball 0 R)) (h0 : h 0 = 0) | |
| (hreal : β z β ball 0 R, (h z).re β€ M) | |
| {z w : β} (hz : z β Metric.ball 0 (R/4)) (hw : w β Metric.ball 0 (R/4)) : | |
| βderiv h z - deriv h wβ β€ (64*M/R^2)*βz-wβ := by | |
| have HR4 : 0 < R/4 := by positivity | |
| have HE : β a β Metric.ball (0:β) (R/4), | |
| closedBall a (R/4) β ball (0:β) R := by | |
| intro a ha b hb | |
| rw [mem_ball_zero_iff] at ha β’ | |
| have HB := norm_le_norm_sub_add b a | |
| have HH : βb-aβ β€ R/4 := by simpa [dist_eq_norm] using hb | |
| linarith | |
| have HB : β a β Metric.ball (0:β) (R/4), β b β sphere a (R/4), βh bβ β€ 2*M := by | |
| intro a ha b hb | |
| have Hba : βb-aβ = R/4 := by simpa [dist_eq_norm] using hb | |
| have Ha : βaβ < R/4 := mem_ball_zero_iff.mp ha | |
| have Hb : βbβ < R/2 := by linarith [norm_le_norm_sub_add b a] | |
| have HBR : b β ball (0:β) R := mem_ball_zero_iff.mpr (by linarith) | |
| have H := Complex.borelCaratheodory_zero hM hh (fun x hx => hreal x hx) hR HBR h0 | |
| apply H.trans | |
| rw [div_le_iffβ (by linarith : 0 < R-βbβ)] | |
| nlinarith | |
| have H2 : β a β Metric.ball (0:β) (R/4), | |
| βderiv (deriv h) aβ β€ 64*M/R^2 := by | |
| intro a ha | |
| have H := Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le | |
| 2 HR4 (hh.diffContOnCl_ball (HE a ha)) (HB a ha) | |
| have HN : (2:β)*(2*M)/(R/4)^2 = 64*M/R^2 := by ring | |
| simpa only [iteratedDeriv_succ, iteratedDeriv_zero, Nat.factorial_two, | |
| Nat.cast_ofNat, HN] using H | |
| apply Convex.norm_image_sub_le_of_norm_deriv_le _ H2 (convex_ball (0:β) (R/4)) hw hz | |
| intro a ha | |
| apply ((hh.analyticOnNhd isOpen_ball) a (HE a ha (mem_closedBall_self HR4.le))).deriv.differentiableAt | |
| lemma logDeriv_sub_le_of_log_norm_le {g : β β β} {R M : β} | |
| (hR : 0 < R) (hM : 0 < M) (hg : DifferentiableOn β g (ball 0 R)) | |
| (hzero : β z β ball 0 R, g z β 0) | |
| (hbound : β z β ball 0 R, Real.log βg zβ - Real.log βg 0β β€ M) | |
| {z w : β} (hz : z β Metric.ball 0 (R/4)) (hw : w β Metric.ball 0 (R/4)) : | |
| βlogDeriv g z - logDeriv g wβ β€ (64*M/R^2)*βz-wβ := by | |
| obtain β¨h,h0,hh,HEβ© := exists_disk_logarithm hR hg hzero | |
| have hh' : DifferentiableOn β h (ball 0 R) := | |
| fun z hz => (hh z hz).differentiableAt.differentiableWithinAt | |
| have H := deriv_sub_le_of_re_le hR hM hh' h0 (fun z hz => by | |
| rw [disk_logarithm_re (hzero 0 (mem_ball_self hR)) (HE z hz)] | |
| exact hbound z hz) hz hw | |
| have hs : Metric.ball (0:β) (R/4) β ball 0 R := ball_subset_ball (by linarith) | |
| rwa [(hh z (hs hz)).deriv, (hh w (hs hw)).deriv] at H | |
| end PrimeDegreePackets.AnalyticGrowth | |
| open Complex Set Metric Filter MeromorphicOn | |
| namespace PrimeDegreePackets.AnalyticGrowth | |
| lemma entire_order_ne_top {f : β β β} (hf : Differentiable β f) (h0 : f 0 β 0) | |
| (z : β) : meromorphicOrderAt f z β β€ := by | |
| have HM : Meromorphic f := fun z => (hf.analyticAt z).meromorphicAt | |
| apply HM.exists_meromorphicOrderAt_ne_top_iff_forall.mp | |
| use 0 | |
| rw [(hf.analyticAt 0).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr h0] | |
| simp | |
| lemma divisor_sphere_eq_zero {f : β β β} {R : β} (hf : Differentiable β f) | |
| (hS : β z β sphere (0:β) R, f z β 0) : divisor f (sphere 0 R) = 0 := by | |
| ext z | |
| by_cases hz : z β sphere (0:β) R | |
| Β· rw [MeromorphicOn.divisor_apply (fun z _ => (hf.analyticAt z).meromorphicAt) hz, | |
| (hf.analyticAt z).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr (hS z hz)] | |
| simp | |
| Β· simp only [divisor_def, hz, and_false, ite_false, Function.locallyFinsuppWithin.coe_zero, Pi.zero_apply] | |
| lemma exists_entire_ecanonicalDecomp {f : β β β} {R : β} | |
| (hf : Differentiable β f) (h0 : f 0 β 0) : | |
| β g, ECanonicalDecomp f g R := by | |
| exact MeromorphicOn.exists_ecanonicalDecomp (fun z _ => (hf.analyticAt z).meromorphicAt) | |
| (fun z => entire_order_ne_top hf h0 z) | |
| lemma ecanonical_log_norm_eq_on_sphere {f g : β β β} {R : β} | |
| (D : ECanonicalDecomp f g R) (hf : Differentiable β f) (hR : 0 < R) | |
| (hS : β z β sphere (0:β) R, f z β 0) {z : β} (hz : z β sphere (0:β) R) : | |
| Real.log βg zβ = Real.log βf zβ := by | |
| rw [D.log_norm_eq (sphere_subset_closedBall hz) | |
| ((hf.analyticAt z).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr (hS z hz)) hR, | |
| (hf.analyticAt z).meromorphicTrailingCoeffAt_of_ne_zero (hS z hz), | |
| divisor_sphere_eq_zero hf hS] | |
| suffices (βαΆ i, (divisor f (ball (0:β) R) i : β) * | |
| Real.log βcanonicalFactor R i zβ) = 0 by simp [this] | |
| trans βαΆ _i : β, (0:β) | |
| Β· apply finsum_congr | |
| intro i | |
| by_cases hi : divisor f (ball (0:β) R) i = 0 | |
| Β· simp [hi] | |
| Β· have hiB := (divisor f (ball (0:β) R)).supportWithinDomain hi | |
| rw [norm_canonicalFactor_eval_circle_eq_one hiB hz, Real.log_one, mul_zero] | |
| Β· exact finsum_zero | |
| lemma norm_canonicalFactor_zero {R : β} {i : β} (hR : 0 < R) : | |
| βcanonicalFactor R i 0β = R/βiβ := by | |
| simp only [canonicalFactor_apply, mul_zero, sub_zero, zero_sub, norm_div, | |
| norm_pow, norm_real, Real.norm_eq_abs, abs_of_pos hR, norm_mul, norm_neg] | |
| by_cases hi : i = 0 | |
| Β· simp [hi] | |
| Β· field_simp | |
| lemma ecanonical_log_norm_zero_ge {f g : β β β} {R : β} | |
| (D : ECanonicalDecomp f g R) (hf : Differentiable β f) (hR : 0 < R) | |
| (hS : β z β sphere (0:β) R, f z β 0) (h0 : f 0 β 0) : | |
| Real.log βf 0β β€ Real.log βg 0β := by | |
| rw [D.log_norm_eq (mem_closedBall_self hR.le) | |
| ((hf.analyticAt 0).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr h0) hR, | |
| (hf.analyticAt 0).meromorphicTrailingCoeffAt_of_ne_zero h0, | |
| divisor_sphere_eq_zero hf hS] | |
| simp only [Function.locallyFinsuppWithin.coe_zero, Pi.zero_apply, Int.cast_zero, zero_mul, | |
| finsum_zero, sub_zero, le_add_iff_nonneg_left] | |
| apply finsum_nonneg | |
| intro i | |
| by_cases hi : divisor f (ball (0:β) R) i = 0 | |
| Β· simp [hi] | |
| have hiB := (divisor f (ball (0:β) R)).supportWithinDomain hi | |
| have hi0 : i β 0 := by | |
| intro H | |
| subst i | |
| rw [MeromorphicOn.divisor_apply (fun z _ => (hf.analyticAt z).meromorphicAt) | |
| (mem_ball_self hR), (hf.analyticAt 0).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr h0] at hi | |
| simp at hi | |
| apply mul_nonneg | |
| Β· exact_mod_cast AnalyticOnNhd.divisor_nonneg (fun z _ => hf.analyticAt z) i | |
| Β· rw [norm_canonicalFactor_zero hR] | |
| apply Real.log_nonneg | |
| apply (le_div_iffβ (norm_pos_iff.mpr hi0)).mpr | |
| simpa using (mem_ball_zero_iff.mp hiB).le | |
| lemma ecanonical_log_norm_le {f g : β β β} {R B : β} | |
| (D : ECanonicalDecomp f g R) (hf : Differentiable β f) (hR : 0 < R) | |
| (hS : β z β sphere (0:β) R, f z β 0) | |
| (hbound : β z β sphere (0:β) R, βf zβ β€ Real.exp B) | |
| {z : β} (hz : z β closedBall (0:β) R) : Real.log βg zβ β€ B := by | |
| apply (Real.log_le_iff_le_exp (norm_pos_iff.mpr (D.ne_zero z hz))).mpr | |
| apply Complex.norm_le_of_forall_mem_frontier_norm_le (isBounded_ball (x := (0:β)) (r := R)) | |
| (D.analyticOnNhd.differentiableOn.diffContOnCl_ball subset_rfl) | |
| Β· intro w hw | |
| have hwS : w β sphere (0:β) R := by simpa [frontier_ball _ hR.ne'] using hw | |
| have H := ecanonical_log_norm_eq_on_sphere D hf hR hS hwS | |
| have HE := congrArg Real.exp H | |
| rw [Real.exp_log (norm_pos_iff.mpr (D.ne_zero w (sphere_subset_closedBall hwS))), | |
| Real.exp_log (norm_pos_iff.mpr (hS w hwS))] at HE | |
| exact HE βΈ hbound w hwS | |
| Β· simpa [closure_ball _ hR.ne'] using hz | |
| end PrimeDegreePackets.AnalyticGrowth | |
| open scoped Topology ComplexConjugate | |
| namespace PrimeDegreePackets.AnalyticGrowth | |
| def canonicalCorrection (R : β) (Ο z : β) : β := conj Ο / ((R:β)^2-conj Ο*z) | |
| lemma canonicalNumerator_norm_lower {R : β} {Ο z : β} (hR : 0 < R) | |
| (hΟ : βΟβ β€ R) (hz : βzβ β€ R/2) : | |
| R^2/2 β€ β(R:β)^2-conj Ο*zβ := by | |
| have H := norm_sub_norm_le ((R:β)^2) (conj Ο*z) | |
| simp only [norm_pow, norm_real, Real.norm_eq_abs, abs_of_pos hR, | |
| norm_mul, norm_conj] at H | |
| have H' := mul_le_mul hΟ hz (norm_nonneg z) hR.le | |
| nlinarith | |
| lemma canonicalNumerator_ne_zero {R : β} {Ο z : β} (hR : 0 < R) | |
| (hΟ : βΟβ β€ R) (hz : βzβ β€ R/2) : (R:β)^2-conj Ο*z β 0 := by | |
| exact norm_pos_iff.mp (lt_of_lt_of_le (by positivity) (canonicalNumerator_norm_lower hR hΟ hz)) | |
| lemma norm_canonicalCorrection_sub_le {R : β} {Ο z w : β} (hR : 0 < R) | |
| (hΟ : βΟβ β€ R) (hz : βzβ β€ R/2) (hw : βwβ β€ R/2) : | |
| βcanonicalCorrection R Ο z-canonicalCorrection R Ο wβ β€ 4/R^2*βz-wβ := by | |
| have hZ := canonicalNumerator_ne_zero hR hΟ hz | |
| have hW := canonicalNumerator_ne_zero hR hΟ hw | |
| have HE : canonicalCorrection R Ο z-canonicalCorrection R Ο w = | |
| (conj Ο)^2*(z-w)/(((R:β)^2-conj Ο*z)*((R:β)^2-conj Ο*w)) := by | |
| unfold canonicalCorrection | |
| field_simp | |
| ring | |
| rw [HE, norm_div, norm_mul, norm_mul, norm_pow, norm_conj] | |
| have Hden : R^4/4 β€ β(R:β)^2-conj Ο*zβ*β(R:β)^2-conj Ο*wβ := by | |
| have H := mul_le_mul (canonicalNumerator_norm_lower hR hΟ hz) | |
| (canonicalNumerator_norm_lower hR hΟ hw) (by positivity : 0 β€ R^2/2) | |
| (norm_nonneg _) | |
| nlinarith | |
| have Hn : βΟβ^2*βz-wβ β€ R^2*βz-wβ := | |
| mul_le_mul_of_nonneg_right (pow_le_pow_leftβ (norm_nonneg _) hΟ 2) (norm_nonneg _) | |
| calc | |
| _ β€ R^2*βz-wβ/(R^4/4) := div_le_divβ (by positivity) Hn (by positivity) Hden | |
| _ = _ := by field_simp | |
| lemma logDeriv_canonicalFactor {R : β} {Ο z : β} (hR : R β 0) | |
| (hz : z β Ο) (hnum : (R:β)^2-conj Ο*z β 0) : | |
| logDeriv (canonicalFactor R Ο) z = -canonicalCorrection R Ο z - 1/(z-Ο) := by | |
| have HR : (R:β) β 0 := by exact_mod_cast hR | |
| have HZ : z-Ο β 0 := sub_ne_zero.mpr hz | |
| have Hn : HasDerivAt (fun z : β => (R:β)^2-conj Ο*z) (-conj Ο) z := by | |
| apply ((hasDerivAt_const z ((R:β)^2)).sub | |
| ((hasDerivAt_id z).const_mul (conj Ο))).congr_deriv | |
| simp | |
| have Hd : HasDerivAt (fun z : β => (R:β)*(z-Ο)) (R:β) z := by | |
| apply (((hasDerivAt_id z).sub_const Ο).const_mul (R:β)).congr_deriv | |
| simp | |
| unfold canonicalFactor | |
| rw [logDeriv_fun_div (g := fun z : β => (R:β)*(z-Ο)) z hnum (mul_ne_zero HR HZ) Hn.differentiableAt Hd.differentiableAt] | |
| rw [logDeriv_apply, logDeriv_apply, Hn.deriv, Hd.deriv] | |
| unfold canonicalCorrection | |
| field_simp | |
| end PrimeDegreePackets.AnalyticGrowth | |
| namespace PrimeDegreePackets.AnalyticGrowth | |
| lemma ecanonical_logDeriv {f g : β β β} {R : β} | |
| (D : ECanonicalDecomp f g R) (hf : Differentiable β f) (hR : 0 < R) | |
| (hS : β z β sphere (0:β) R, f z β 0) {z : β} | |
| (hz : βzβ β€ R/2) (hfz : f z β 0) : | |
| logDeriv f z = (βαΆ Ο, (divisor f (ball (0:β) R) Ο : β) * | |
| (1/(z-Ο)+canonicalCorrection R Ο z)) + logDeriv g z := by | |
| classical | |
| let t := D.meromorphicOn.divisor_ball_support_finite.toFinset | |
| have ht (Ο : β) : Ο β t β divisor f (ball (0:β) R) Ο β 0 := by | |
| simp only [t, Set.Finite.mem_toFinset, Function.mem_support] | |
| have hΟB (Ο : β) (hΟ : Ο β t) : Ο β ball (0:β) R := | |
| (divisor f (ball (0:β) R)).supportWithinDomain ((ht Ο).mp hΟ) | |
| have hzB : z β closedBall (0:β) R := mem_closedBall_zero_iff.mpr (by linarith) | |
| have havoid (Ο : β) (hΟ : Ο β t) : z β Ο := by | |
| intro H | |
| obtain rfl := H | |
| have HH := (ht z).mp hΟ | |
| rw [MeromorphicOn.divisor_apply (fun z _ => (hf.analyticAt z).meromorphicAt) (hΟB z hΟ), | |
| (hf.analyticAt z).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr hfz] at HH | |
| simp at HH | |
| let P : β β β := fun x => β Ο β t, canonicalFactor R Ο x ^ (-divisor f (ball 0 R) Ο) | |
| have HPa : AnalyticAt β P z := by | |
| apply Finset.analyticAt_fun_prod | |
| intro Ο hΟ | |
| apply (analyticOnNhd_canonicalFactor R Ο z (havoid Ο hΟ)).fun_zpow | |
| exact canonicalFactor_ne_zero (hΟB Ο hΟ) hzB (havoid Ο hΟ) | |
| have HPz : P z β 0 := by | |
| apply Finset.prod_ne_zero_iff.mpr | |
| intro Ο hΟ | |
| exact zpow_ne_zero _ (canonicalFactor_ne_zero (hΟB Ο hΟ) hzB (havoid Ο hΟ)) | |
| have HP : (βαΆ Ο, (canonicalFactor R Ο)^(-divisor f (ball (0:β) R) Ο)) = P := by | |
| rw [finprod_eq_prod_of_mulSupport_subset (s := t) _ ?_] | |
| Β· ext x | |
| simp only [P, Finset.prod_apply, Pi.pow_apply] | |
| Β· intro Ο hΟ | |
| apply (ht Ο).mpr | |
| intro H | |
| simp [H] at hΟ | |
| have HE : f =αΆ [codiscreteWithin (closedBall (0:β) R)] (fun x => P x*g x) := by | |
| have H := D.eventuallyEq | |
| rw [HP, divisor_sphere_eq_zero hf hS] at H | |
| filter_upwards [H] with x hx | |
| simpa only [Function.locallyFinsuppWithin.coe_zero, Pi.zero_apply, zpow_zero, | |
| finprod_one, mul_one, Pi.smul_apply, smul_eq_mul, Pi.mul_apply] using hx | |
| have HEz : f =αΆ [π z] (fun x => P x*g x) := by | |
| apply ((hf z).continuousAt.eventuallyEq_nhds_iff_eventuallyEq_nhdsNE | |
| (HPa.mul (D.analyticOnNhd z hzB)).continuousAt).mp | |
| apply (hf.analyticAt z).meromorphicAt.eventuallyEq_nhdsNE_of_eventuallyEq_codiscreteWithin_preperfect | |
| (HPa.mul (D.analyticOnNhd z hzB)).meromorphicAt hzB _ HE | |
| rw [β closure_ball _ hR.ne'] | |
| exact isOpen_ball.perfect_closure.2 | |
| rw [(logDeriv_congr_nhds HEz).eq_of_nhds, | |
| logDeriv_fun_mul z HPz (D.ne_zero z hzB) HPa.differentiableAt (D.analyticOnNhd z hzB).differentiableAt] | |
| congr 1 | |
| change logDeriv (fun x => β Ο β t, canonicalFactor R Ο x ^ (-divisor f (ball 0 R) Ο)) z = _ | |
| rw [logDeriv_fun_prod (f := fun Ο x : β => canonicalFactor R Ο x ^ | |
| (-divisor f (ball 0 R) Ο)) (s := t) (x := z) (fun Ο hΟ => zpow_ne_zero _ | |
| (canonicalFactor_ne_zero (hΟB Ο hΟ) hzB (havoid Ο hΟ))) (fun Ο hΟ => | |
| ((analyticOnNhd_canonicalFactor R Ο z (havoid Ο hΟ)).fun_zpow | |
| (canonicalFactor_ne_zero (hΟB Ο hΟ) hzB (havoid Ο hΟ))).differentiableAt)] | |
| rw [finsum_eq_sum_of_support_subset (s := t) _ (by | |
| intro Ο hΟ | |
| apply (ht Ο).mpr | |
| intro H | |
| simp [H] at hΟ)] | |
| apply Finset.sum_congr rfl | |
| intro Ο hΟ | |
| rw [logDeriv_fun_zpow (analyticOnNhd_canonicalFactor R Ο z (havoid Ο hΟ)).differentiableAt, | |
| logDeriv_canonicalFactor hR.ne' (havoid Ο hΟ) | |
| (canonicalNumerator_ne_zero hR (mem_ball_zero_iff.mp (hΟB Ο hΟ)).le hz)] | |
| push_cast | |
| ring | |
| end PrimeDegreePackets.AnalyticGrowth | |
| namespace PrimeDegreePackets.AnalyticGrowth | |
| def zeroMultiplicity (f : β β β) (z : β) : β€ := (meromorphicOrderAt f z).untopβ | |
| lemma zeroMultiplicity_nonneg {f : β β β} (hf : Differentiable β f) (z : β) : | |
| 0 β€ zeroMultiplicity f z := by | |
| have H := AnalyticOnNhd.divisor_nonneg (fun z (_ : z β (univ : Set β)) => hf.analyticAt z) z | |
| simpa only [zeroMultiplicity, MeromorphicOn.divisor_apply | |
| (fun z _ => (hf.analyticAt z).meromorphicAt) (mem_univ z), | |
| Function.locallyFinsuppWithin.coe_zero, Pi.zero_apply] using H | |
| lemma zeroMultiplicity_eq_zero_iff {f : β β β} (hf : Differentiable β f) | |
| (h0 : f 0 β 0) (z : β) : zeroMultiplicity f z = 0 β f z β 0 := by | |
| rw [zeroMultiplicity, WithTop.untopβ_eq_zero] | |
| simp only [entire_order_ne_top hf h0 z, or_false, | |
| (hf.analyticAt z).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff] | |
| lemma zeroMultiplicity_ne_zero_iff {f : β β β} (hf : Differentiable β f) | |
| (h0 : f 0 β 0) (z : β) : zeroMultiplicity f z β 0 β f z = 0 := by | |
| simp [zeroMultiplicity_eq_zero_iff hf h0] | |
| lemma exists_zero_free_sphere {f : β β β} (hf : Differentiable β f) | |
| (h0 : f 0 β 0) {a b : β} (hab : a < b) : | |
| β R β Ioo a b, β z β sphere (0:β) R, f z β 0 := by | |
| have Hfin := ((divisor f (closedBall (0:β) b)).finiteSupport (isCompact_closedBall 0 b)).image | |
| (fun z : β => βzβ) | |
| obtain β¨R,hR,Hβ© := (Set.Ioo_infinite hab).exists_notMem_finite Hfin | |
| refine β¨R,hR,?_β© | |
| intro z hz hz0 | |
| apply H | |
| have HZ : βzβ = R := mem_sphere_zero_iff_norm.mp hz | |
| refine β¨z,?_,HZβ© | |
| change divisor f (closedBall (0:β) b) z β 0 | |
| rw [MeromorphicOn.divisor_apply (fun z _ => (hf.analyticAt z).meromorphicAt) | |
| (show z β closedBall (0:β) b from mem_closedBall_zero_iff.mpr (HZ βΈ hR.2.le))] | |
| exact (zeroMultiplicity_ne_zero_iff hf h0 z).mpr hz0 | |
| def diskZeroCount (f : β β β) (R : β) : β := | |
| ((βαΆ z, divisor f (closedBall (0:β) R) z : β€) : β) | |
| lemma diskZeroCount_eq_finsum (f : β β β) (R : β) : | |
| diskZeroCount f R = βαΆ z, (divisor f (closedBall (0:β) R) z : β) := by | |
| exact map_finsum (Int.castRingHom β) | |
| ((divisor f (closedBall (0:β) R)).finiteSupport (isCompact_closedBall 0 R)) | |
| lemma diskZeroCount_nonneg {f : β β β} (hf : Differentiable β f) (R : β) : | |
| 0 β€ diskZeroCount f R := by | |
| rw [diskZeroCount_eq_finsum] | |
| apply finsum_nonneg | |
| intro z | |
| exact_mod_cast AnalyticOnNhd.divisor_nonneg (fun z _ => hf.analyticAt z) z | |
| lemma diskZeroCount_le {f : β β β} (hf : Differentiable β f) (h0 : f 0 β 0) | |
| {R B : β} (hR : 0 < R) (hB : 0 β€ B) | |
| (hbound : β z : β, βzβ β€ 2*R β βf zβ β€ Real.exp B) : | |
| diskZeroCount f R β€ (B-Real.log βf 0β)/Real.log 2 := by | |
| have H := AnalyticOnNhd.sum_divisor_le (f := f) (c := (0:β)) (r := R) (R := 2*R) | |
| (by simpa [abs_of_pos hR] using hR) | |
| (by rw [abs_of_pos hR, abs_of_pos (by positivity : 0 < 2*R)]; linarith) | |
| (Real.one_le_exp_iff.mpr hB) (fun z _ => hf.analyticAt z) h0 | |
| (fun z hz => hbound z (by | |
| simpa only [abs_of_pos (by positivity : 0 < 2*R)] using | |
| le_of_eq (mem_sphere_zero_iff_norm.mp hz))) | |
| rw [abs_of_pos hR] at H | |
| have HE : 2*R/R = 2 := by field_simp | |
| simpa only [diskZeroCount, abs_of_pos hR, Real.log_div (Real.exp_ne_zero B) | |
| (norm_ne_zero_iff.mpr h0), Real.log_exp, HE] using H | |
| end PrimeDegreePackets.AnalyticGrowth | |
| end | |
| end | |
| end OAI | |