| import Mathlib |
| import OAI.NumberTheory.PiExponent.Analysis.AnalyticCollision |
| import OAI.NumberTheory.PiExponent.Approximation.RowTranslation |
|
|
| namespace OAI |
|
|
| open scoped BigOperators |
|
|
| namespace PiExponent.LogTailAnalytic |
|
|
| noncomputable def logTail (T : ℕ) (z : ℂ) : ℂ := |
| Complex.logTaylor T z - Complex.log (1 + z) |
|
|
| theorem eval_trunc_log (T : ℕ) (z : ℂ) : |
| (PowerSeries.trunc T (PowerSeries.log ℂ)).eval z = Complex.logTaylor T z := by |
| change (PowerSeries.trunc T (PowerSeries.log ℂ)).eval₂ (RingHom.id ℂ) z = _ |
| rw [PowerSeries.eval₂_trunc_eq_sum_range] |
| unfold Complex.logTaylor |
| apply Finset.sum_congr rfl |
| intro n hn |
| simp only [RingHom.id_apply, PowerSeries.coeff_log] |
| by_cases h : n = 0 |
| · simp [h] |
| · simp [h, map_div₀, map_pow] |
| ring |
|
|
| theorem analyticAt_logTail (T : ℕ) {z : ℂ} (hz : ‖z‖ < 1) : |
| AnalyticAt ℂ (logTail T) z := by |
| unfold logTail Complex.logTaylor |
| apply AnalyticAt.sub |
| · apply Finset.analyticAt_fun_sum |
| intro n hn |
| fun_prop |
| · exact (analyticAt_const.add analyticAt_id).clog (Complex.mem_slitPlane_of_norm_lt_one hz) |
|
|
| theorem norm_logTail_le (T : ℕ) (hT : 1 ≤ T) {z : ℂ} (hz : ‖z‖ < 1) : |
| ‖logTail T z‖ ≤ ‖z‖ ^ T * (1 - ‖z‖)⁻¹ / T := by |
| obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : T ≠ 0) |
| unfold logTail |
| rw [norm_sub_rev] |
| simpa only [Nat.succ_eq_add_one, Nat.cast_add, Nat.cast_one] using |
| Complex.norm_log_sub_logTaylor_le n hz |
|
|
| theorem norm_logTail_le_one (T : ℕ) (hT : 1 ≤ T) {z : ℂ} (hz : ‖z‖ ≤ 1 / 2) : |
| ‖logTail T z‖ ≤ 1 := by |
| have hz1 : ‖z‖ < 1 := by linarith |
| have hpow : ‖z‖ ^ T ≤ 1 / 2 := by |
| obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : T ≠ 0) |
| rw [pow_succ] |
| have hh : ‖z‖ ^ n ≤ 1 := pow_le_one₀ (norm_nonneg z) hz1.le |
| nlinarith [norm_nonneg z] |
| have hinv : (1 - ‖z‖)⁻¹ ≤ 2 := by |
| rw [inv_le_comm₀ (by linarith : 0 < 1 - ‖z‖) (by norm_num : (0 : ℝ) < 2)] |
| linarith |
| have hTreal : (1 : ℝ) ≤ T := by exact_mod_cast hT |
| calc |
| ‖logTail T z‖ ≤ ‖z‖ ^ T * (1 - ‖z‖)⁻¹ / T := norm_logTail_le T hT hz1 |
| _ ≤ (1 / 2 : ℝ) * 2 / T := by gcongr |
| _ ≤ 1 := by rw [div_le_iff₀ (by positivity : (0 : ℝ) < T)]; nlinarith |
|
|
| theorem norm_prod_logTail_le_one {ι : Type*} (s : Finset ι) (T d : ι → ℕ) |
| (hT : ∀ i ∈ s, 1 ≤ T i) {z : ℂ} (hz : ‖z‖ ≤ 1 / 2) : |
| ‖∏ i ∈ s, logTail (T i) z ^ d i‖ ≤ 1 := by |
| rw [norm_prod] |
| apply Finset.prod_le_one₀ |
| · intro i hi |
| positivity |
| · intro i hi |
| rw [norm_pow] |
| exact pow_le_one₀ (norm_nonneg _) (norm_logTail_le_one (T i) (hT i hi) hz) |
|
|
| theorem analyticAt_prod_logTail {ι : Type*} (s : Finset ι) (T d : ι → ℕ) |
| {z : ℂ} (hz : ‖z‖ < 1) : |
| AnalyticAt ℂ (fun t => ∏ i ∈ s, logTail (T i) t ^ d i) z := by |
| apply Finset.analyticAt_fun_prod |
| intro i hi |
| exact (analyticAt_logTail (T i) hz).pow (d i) |
|
|
| theorem norm_rowTest_prod_logTail_le {ι : Type*} (s : Finset ι) (T d : ι → ℕ) |
| (hT : ∀ i ∈ s, 1 ≤ T i) (k : ℕ) : |
| ‖AnalyticCollision.rowTest k (fun z => ∏ i ∈ s, logTail (T i) z ^ d i)‖ ≤ |
| (2 : ℝ) ^ k := by |
| have h := AnalyticCollision.norm_rowTest_le |
| (f := fun z => ∏ i ∈ s, logTail (T i) z ^ d i) (D := 1) ?_ k |
| · simpa only [mul_one] using h |
| intro z hz |
| apply norm_prod_logTail_le_one s T d hT |
| exact (by simpa only [Metric.mem_sphere, dist_zero_right] using hz : ‖z‖ = 1 / 2).le |
|
|
| theorem logTail_isBigO (T : ℕ) (hT : 1 ≤ T) : |
| (fun z => logTail T z) =O[nhds (0 : ℂ)] (fun z => z ^ T) := by |
| obtain ⟨n, rfl⟩ := Nat.exists_eq_succ_of_ne_zero (by omega : T ≠ 0) |
| have h := (Complex.log_sub_logTaylor_isBigO n).neg_left |
| simpa only [logTail, neg_sub, Nat.succ_eq_add_one] using h |
|
|
| theorem order_formal_logTail (T : ℕ) : |
| (T : ℕ∞) ≤ (RowTranslation.tail T (PowerSeries.log ℂ)).order := |
| RowTranslation.order_tail T (PowerSeries.log ℂ) |
|
|
| theorem hasSum_formal_log {z : ℂ} (hz : ‖z‖ < 1) : |
| HasSum (fun n => PowerSeries.coeff n (PowerSeries.log ℂ) * z ^ n) |
| (Complex.log (1 + z)) := by |
| convert Complex.hasSum_taylorSeries_log hz using 1 |
| funext n |
| by_cases hn : n = 0 |
| · simp [hn] |
| · simp [PowerSeries.coeff_log, hn, map_div₀, map_pow] |
| ring |
|
|
| theorem hasSum_trunc_log (T : ℕ) (z : ℂ) : |
| HasSum (fun n => PowerSeries.coeff n |
| (PowerSeries.trunc T (PowerSeries.log ℂ) : PowerSeries ℂ) * z ^ n) |
| (Complex.logTaylor T z) := by |
| have h := hasSum_sum_of_ne_finset_zero (L := SummationFilter.unconditional ℕ) |
| (s := Finset.range T) |
| (f := fun n => PowerSeries.coeff n |
| (PowerSeries.trunc T (PowerSeries.log ℂ) : PowerSeries ℂ) * z ^ n) ?_ |
| · convert h using 1 |
| rw [← eval_trunc_log] |
| change (PowerSeries.trunc T (PowerSeries.log ℂ)).eval₂ (RingHom.id ℂ) z = _ |
| rw [PowerSeries.eval₂_trunc_eq_sum_range] |
| apply Finset.sum_congr rfl |
| intro n hn |
| simp [PowerSeries.coeff_trunc, Finset.mem_range.mp hn] |
| · intro n hn |
| have hn' : ¬ n < T := by simpa only [Finset.mem_range] using hn |
| simp [PowerSeries.coeff_trunc, hn'] |
|
|
| theorem hasSum_formal_logTail (T : ℕ) {z : ℂ} (hz : ‖z‖ < 1) : |
| HasSum (fun n => PowerSeries.coeff n |
| (RowTranslation.tail T (PowerSeries.log ℂ)) * z ^ n) (logTail T z) := by |
| convert (hasSum_trunc_log T z).sub (hasSum_formal_log hz) using 1 |
| · funext n |
| simp only [RowTranslation.tail, map_sub, sub_mul] |
| · rfl |
|
|
| theorem hasFPowerSeriesAt_logTail (T : ℕ) : |
| HasFPowerSeriesAt (logTail T) |
| (FormalMultilinearSeries.ofScalars ℂ |
| (fun n => PowerSeries.coeff n (RowTranslation.tail T (PowerSeries.log ℂ)))) 0 := by |
| rw [hasFPowerSeriesAt_iff] |
| filter_upwards [Metric.ball_mem_nhds (0 : ℂ) (by norm_num : (0 : ℝ) < 1)] with z hz |
| have hn : ‖z‖ < 1 := by simpa only [Metric.mem_ball, dist_zero_right] using hz |
| simpa only [FormalMultilinearSeries.coeff_ofScalars, zero_add, smul_eq_mul, mul_comm] using |
| hasSum_formal_logTail T hn |
|
|
| theorem hasSum_coeff_mul {f g : PowerSeries ℂ} {x y z : ℂ} |
| (hf : HasSum (fun n => PowerSeries.coeff n f * z ^ n) x) |
| (hg : HasSum (fun n => PowerSeries.coeff n g * z ^ n) y) : |
| HasSum (fun n => PowerSeries.coeff n (f * g) * z ^ n) (x * y) := by |
| have hfn := hf.summable.norm |
| have hgn := hg.summable.norm |
| have hs := (summable_norm_sum_mul_antidiagonal_of_summable_norm hfn hgn).of_norm.hasSum |
| have heq := tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm hfn hgn |
| rw [hf.tsum_eq, hg.tsum_eq] at heq |
| rw [← heq] at hs |
| convert hs using 1 |
| funext n |
| rw [PowerSeries.coeff_mul, Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro a ha |
| have he : a.1 + a.2 = n := Finset.HasAntidiagonal.mem_antidiagonal.mp ha |
| rw [← he, pow_add] |
| ring |
|
|
| theorem hasSum_coeff_one (z : ℂ) : |
| HasSum (fun n => PowerSeries.coeff n (1 : PowerSeries ℂ) * z ^ n) 1 := by |
| convert hasSum_ite_eq 0 (1 : ℂ) using 1 |
| funext n |
| by_cases hn : n = 0 <;> simp [PowerSeries.coeff_one, hn] |
|
|
| theorem hasSum_coeff_pow {f : PowerSeries ℂ} {x z : ℂ} |
| (hf : HasSum (fun n => PowerSeries.coeff n f * z ^ n) x) (d : ℕ) : |
| HasSum (fun n => PowerSeries.coeff n (f ^ d) * z ^ n) (x ^ d) := by |
| induction d with |
| | zero => simpa only [pow_zero] using hasSum_coeff_one z |
| | succ d hd => simpa only [pow_succ] using hasSum_coeff_mul hd hf |
|
|
| theorem hasSum_formal_prod_logTail {ι : Type*} (s : Finset ι) (T d : ι → ℕ) |
| {z : ℂ} (hz : ‖z‖ < 1) : |
| HasSum (fun n => PowerSeries.coeff n |
| (∏ i ∈ s, RowTranslation.tail (T i) (PowerSeries.log ℂ) ^ d i) * z ^ n) |
| (∏ i ∈ s, logTail (T i) z ^ d i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simpa only [Finset.prod_empty] using hasSum_coeff_one z |
| | @insert i s hi hs => |
| simpa only [Finset.prod_insert hi] using |
| hasSum_coeff_mul (hasSum_coeff_pow (hasSum_formal_logTail (T i) hz) (d i)) hs |
|
|
| theorem hasFPowerSeriesAt_prod_logTail {ι : Type*} (s : Finset ι) (T d : ι → ℕ) : |
| HasFPowerSeriesAt (fun z => ∏ i ∈ s, logTail (T i) z ^ d i) |
| (FormalMultilinearSeries.ofScalars ℂ |
| (fun n => PowerSeries.coeff n |
| (∏ i ∈ s, RowTranslation.tail (T i) (PowerSeries.log ℂ) ^ d i))) 0 := by |
| rw [hasFPowerSeriesAt_iff] |
| filter_upwards [Metric.ball_mem_nhds (0 : ℂ) (by norm_num : (0 : ℝ) < 1)] with z hz |
| have hn : ‖z‖ < 1 := by simpa only [Metric.mem_ball, dist_zero_right] using hz |
| simpa only [FormalMultilinearSeries.coeff_ofScalars, zero_add, smul_eq_mul, mul_comm] using |
| hasSum_formal_prod_logTail s T d hn |
|
|
| theorem rowTest_prod_logTail_eq_coeff {ι : Type*} (s : Finset ι) (T d : ι → ℕ) (k : ℕ) : |
| AnalyticCollision.rowTest k (fun z => ∏ i ∈ s, logTail (T i) z ^ d i) = |
| PowerSeries.coeff k (∏ i ∈ s, RowTranslation.tail (T i) (PowerSeries.log ℂ) ^ d i) := by |
| have hd : DifferentiableOn ℂ (fun z => ∏ i ∈ s, logTail (T i) z ^ d i) |
| (Metric.closedBall 0 (1 / 2)) := by |
| intro z hz |
| apply (analyticAt_prod_logTail s T d ?_).differentiableAt.differentiableWithinAt |
| have hz' : ‖z‖ ≤ 1 / 2 := by simpa only [Metric.mem_closedBall, dist_zero_right] using hz |
| linarith |
| have hp := hd.hasFPowerSeriesOnBall (R := (1 / 2 : NNReal)) (by norm_num) |
| have he := hp.hasFPowerSeriesAt.eq_formalMultilinearSeries |
| (hasFPowerSeriesAt_prod_logTail s T d) |
| have hh := congrArg (fun p : FormalMultilinearSeries ℂ ℂ ℂ => p k (fun _ => 1)) he |
| simpa only [AnalyticCollision.rowTest, FormalMultilinearSeries.apply_eq_prod_smul_coeff, |
| Finset.prod_const_one, one_smul, FormalMultilinearSeries.coeff_ofScalars, |
| NNReal.coe_div, NNReal.coe_one, NNReal.coe_ofNat] using hh |
|
|
| theorem norm_coeff_prod_formal_logTail_le {ι : Type*} (s : Finset ι) (T d : ι → ℕ) |
| (hT : ∀ i ∈ s, 1 ≤ T i) (k : ℕ) : |
| ‖PowerSeries.coeff k (∏ i ∈ s, RowTranslation.tail (T i) (PowerSeries.log ℂ) ^ d i)‖ ≤ |
| (2 : ℝ) ^ k := by |
| rw [← rowTest_prod_logTail_eq_coeff] |
| exact norm_rowTest_prod_logTail_le s T d hT k |
|
|
| theorem rowTest_tail_budget {ι : Type*} (s : Finset ι) (T d : ι → ℕ) (k : ℕ) |
| (hk : AnalyticCollision.rowTest k (fun z => ∏ i ∈ s, logTail (T i) z ^ d i) ≠ 0) : |
| ∑ i ∈ s, d i * T i ≤ k := by |
| rw [rowTest_prod_logTail_eq_coeff] at hk |
| exact RowTranslation.tail_budget_nat s T d (fun _ => PowerSeries.log ℂ) k hk |
|
|
| end PiExponent.LogTailAnalytic |
|
|
| end OAI |
|
|
