| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! Modulo-twelve cardinal functions and Gaussian-damped radial Schwartz realization. -/ |
|
|
| noncomputable section |
| open scoped BigOperators Topology FourierTransform SchwartzMap ComplexConjugate |
| open MeasureTheory Set Filter |
|
|
| namespace Triangular |
|
|
| abbrev Plane := EuclideanSpace ℝ (Fin 2) |
|
|
| def b : ℝ := Real.sqrt 3 / 2 |
|
|
| def h : ℝ := 2 / 5 |
|
|
| def L : Finset ℤ := {0, 1, 3, 4, 7, 9} |
|
|
| def zeroSet : Set ℝ := |
| {s | ∃ j : ℤ, ∃ a : ℤ, a ∈ L ∧ s = 12 * (j : ℝ) + (a : ℝ)} |
|
|
| def nodes : Set ℝ := zeroSet ∩ Set.Ioi 0 |
|
|
| def T (k : ℝ) (s : ℝ) : ℝ := k⁻¹ * Real.exp (-k * (s - 1)) |
|
|
| def IsRadial (f : Plane → ℝ) : Prop := |
| ∀ x y : Plane, ‖x‖ = ‖y‖ → f x = f y |
|
|
| def realFourier (f : Plane → ℝ) : Plane → ℂ := |
| 𝓕 (fun x : Plane => (f x : ℂ)) |
|
|
| lemma b_pos : 0 < b := by |
| unfold b |
| positivity |
|
|
| lemma h_pos : 0 < h := by norm_num [h] |
|
|
| lemma b_sq : b ^ 2 = 3 / 4 := by |
| unfold b |
| rw [div_pow, Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 3)] |
| norm_num |
|
|
| lemma k_pos {k : ℝ} (hk : (59 : ℝ) / 25 ≤ k) : 0 < k := by linarith |
|
|
| lemma hasDerivAt_T {k : ℝ} (hk : k ≠ 0) (s : ℝ) : |
| HasDerivAt (T k) (-Real.exp (-k * (s - 1))) s := by |
| have hd := ((((hasDerivAt_id s).sub_const 1).const_mul (-k)).exp).const_mul k⁻¹ |
| convert! hd using 1 |
| simp only [id_eq, mul_one] |
| field_simp |
|
|
| lemma deriv_T {k : ℝ} (hk : k ≠ 0) (s : ℝ) : |
| deriv (T k) s = -Real.exp (-k * (s - 1)) := |
| (hasDerivAt_T hk s).deriv |
|
|
| lemma T_pos {k : ℝ} (hk : (59 : ℝ) / 25 ≤ k) (s : ℝ) : 0 < T k s := |
| mul_pos (inv_pos.mpr (k_pos hk)) (Real.exp_pos _) |
|
|
| lemma realFourier_eq_integral (f : Plane → ℝ) (ξ : Plane) : |
| realFourier f ξ = |
| ∫ x : Plane, (f x : ℂ) * |
| Complex.exp (-(2 * (Real.pi : ℂ)) * Complex.I * (inner ℝ x ξ : ℂ)) := by |
| rw [realFourier, Real.fourier_eq'] |
| apply integral_congr_ae |
| filter_upwards [] with x |
| simp only [smul_eq_mul] |
| rw [mul_comm] |
| apply congrArg (fun z : ℂ => (f x : ℂ) * Complex.exp z) |
| push_cast |
| ring |
|
|
| lemma zero_mem_zeroSet : (0 : ℝ) ∈ zeroSet := by |
| exact ⟨0, 0, by simp [L], by norm_num⟩ |
|
|
| lemma twentyFour_mem_nodes : (24 : ℝ) ∈ nodes := by |
| exact ⟨⟨2, 0, by simp [L], by norm_num⟩, by norm_num⟩ |
|
|
| def nodes₀ : Set ℝ := {0} ∪ nodes |
|
|
| abbrev Node := {n : ℝ // n ∈ nodes₀} |
|
|
| lemma Node.mem_zeroSet (n : Node) : n.val ∈ zeroSet := by |
| rcases n.property with hn | hn |
| · rw [Set.mem_singleton_iff.mp hn] |
| exact zero_mem_zeroSet |
| · exact hn.1 |
|
|
| namespace Cardinal |
|
|
| def sineFactor (a : ℤ) (s : ℂ) : ℂ := |
| 2 * Complex.sin (((Real.pi / 12 : ℝ) : ℂ) * (s - (a : ℂ))) |
|
|
| def rootProduct (s : ℂ) : ℂ := ∏ a ∈ L, sineFactor a s |
|
|
| def P (s : ℂ) : ℂ := ∏ a ∈ L, (sineFactor a s) ^ 2 |
|
|
| lemma P_eq_square (s : ℂ) : P s = rootProduct s ^ 2 := by |
| simp only [P, rootProduct, Finset.prod_pow] |
|
|
| lemma sineFactor_add_twelve (a : ℤ) (s : ℂ) : |
| sineFactor a (s + 12) = -sineFactor a s := by |
| unfold sineFactor |
| have he : ((Real.pi / 12 : ℝ) : ℂ) * (s + 12 - (a : ℂ)) = |
| ((Real.pi / 12 : ℝ) : ℂ) * (s - (a : ℂ)) + (Real.pi : ℂ) := by |
| push_cast |
| ring |
| rw [he, Complex.sin_add_pi] |
| ring |
|
|
| lemma P_periodic : Function.Periodic P 12 := by |
| intro s |
| simp only [P, sineFactor_add_twelve, neg_sq] |
|
|
| lemma P_ofReal (s : ℝ) : |
| P (s : ℂ) = ((∏ a ∈ L, (2 * Real.sin (Real.pi / 12 * (s - (a : ℝ)))) ^ 2 : ℝ) : ℂ) := by |
| simp only [P, sineFactor, Complex.ofReal_prod, Complex.ofReal_pow, |
| Complex.ofReal_mul, Complex.ofReal_sin, Complex.ofReal_sub, Complex.ofReal_intCast, |
| Complex.ofReal_ofNat] |
|
|
| lemma P_nonneg (s : ℝ) : 0 ≤ (P (s : ℂ)).re := by |
| rw [P_ofReal] |
| simp only [Complex.ofReal_re] |
| exact Finset.prod_nonneg (fun _ _ => sq_nonneg _) |
|
|
| lemma differentiable_rootProduct : Differentiable ℂ rootProduct := by |
| unfold rootProduct sineFactor |
| fun_prop |
|
|
| lemma differentiable_P : Differentiable ℂ P := by |
| unfold P sineFactor |
| fun_prop |
|
|
| lemma rootProduct_zero {n : ℝ} (hn : n ∈ zeroSet) : rootProduct (n : ℂ) = 0 := by |
| obtain ⟨j, a, ha, hn⟩ := hn |
| apply Finset.prod_eq_zero ha |
| have he : ((n : ℂ) - (a : ℂ)) = 12 * (j : ℂ) := by |
| exact_mod_cast (show n - (a : ℝ) = 12 * (j : ℝ) by linarith) |
| have hh : (((Real.pi / 12 : ℝ) : ℂ) * (12 * (j : ℂ))) = |
| (j : ℂ) * (Real.pi : ℂ) := by push_cast; ring |
| have hz : Complex.sin ((j : ℂ) * (Real.pi : ℂ)) = 0 := by |
| have hh := congrArg Complex.ofReal (Real.sin_int_mul_pi j) |
| simpa only [Complex.ofReal_zero, Complex.ofReal_sin, Complex.ofReal_mul, |
| Complex.ofReal_intCast] using hh |
| simp only [sineFactor, he, hh, hz, mul_zero] |
|
|
| lemma P_zero {n : ℝ} (hn : n ∈ zeroSet) : P (n : ℂ) = 0 := by |
| rw [P_eq_square, rootProduct_zero hn] |
| norm_num |
|
|
| lemma P_real_zero_iff (s : ℝ) : P (s : ℂ) = 0 ↔ s ∈ zeroSet := by |
| constructor |
| · intro hP |
| rw [P_eq_square, sq_eq_zero_iff] at hP |
| obtain ⟨a, ha, hz⟩ := Finset.prod_eq_zero_iff.mp hP |
| have hs : Complex.sin (((Real.pi / 12 : ℝ) : ℂ) * ((s : ℂ) - a)) = 0 := |
| (mul_eq_zero.mp hz).resolve_left (by norm_num) |
| obtain ⟨j, hj⟩ := Complex.sin_eq_zero_iff.mp hs |
| have hpi : (Real.pi : ℂ) ≠ 0 := by exact_mod_cast Real.pi_ne_zero |
| have he : (Real.pi : ℂ) * ((s : ℂ) - (12 * (j : ℂ) + a)) = 0 := by |
| push_cast at hj |
| linear_combination 12 * hj |
| have he' := sub_eq_zero.mp ((mul_eq_zero.mp he).resolve_left hpi) |
| exact ⟨j, a, ha, by exact_mod_cast he'⟩ |
| · exact P_zero |
|
|
| lemma hasDerivAt_P_zero {n : ℝ} (hn : n ∈ zeroSet) : |
| HasDerivAt P 0 (n : ℂ) := by |
| have hd := (differentiable_rootProduct (n : ℂ)).hasDerivAt.pow 2 |
| have he : rootProduct ^ 2 = P := funext fun s => (P_eq_square s).symm |
| simpa [he, rootProduct_zero hn] using hd |
|
|
| lemma deriv_P_zero {n : ℝ} (hn : n ∈ zeroSet) : deriv P (n : ℂ) = 0 := |
| (hasDerivAt_P_zero hn).deriv |
|
|
| lemma P_node (n : Node) : P (n.val : ℂ) = 0 := P_zero n.mem_zeroSet |
|
|
| lemma deriv_P_node (n : Node) : deriv P (n.val : ℂ) = 0 := |
| deriv_P_zero n.mem_zeroSet |
|
|
| def dBasis (n : Node) : ℂ → ℂ := dslope P (n.val : ℂ) |
|
|
| def cBasis (n : Node) : ℂ → ℂ := dslope (dBasis n) (n.val : ℂ) |
|
|
| lemma differentiable_dBasis (n : Node) : Differentiable ℂ (dBasis n) := by |
| rw [← differentiableOn_univ] |
| exact (Complex.differentiableOn_dslope Filter.univ_mem).mpr |
| differentiable_P.differentiableOn |
|
|
| lemma differentiable_cBasis (n : Node) : Differentiable ℂ (cBasis n) := by |
| rw [← differentiableOn_univ] |
| exact (Complex.differentiableOn_dslope Filter.univ_mem).mpr |
| (differentiable_dBasis n).differentiableOn |
|
|
| lemma dBasis_node (n : Node) : dBasis n (n.val : ℂ) = 0 := by |
| simp [dBasis, dslope_same, deriv_P_node] |
|
|
| lemma dBasis_eq (n : Node) {s : ℂ} (hs : s ≠ (n.val : ℂ)) : |
| dBasis n s = P s / (s - n.val) := by |
| simp [dBasis, dslope_of_ne _ hs, slope_def_field, P_node] |
|
|
| lemma cBasis_eq (n : Node) {s : ℂ} (hs : s ≠ (n.val : ℂ)) : |
| cBasis n s = P s / (s - n.val) ^ 2 := by |
| rw [cBasis, dslope_of_ne _ hs, slope_def_field, dBasis_node, |
| sub_zero, dBasis_eq n hs, div_div, pow_two] |
|
|
| lemma node_cast_ne {m n : Node} (hmn : m ≠ n) : (m.val : ℂ) ≠ (n.val : ℂ) := by |
| intro hh |
| exact hmn (Subtype.ext (Complex.ofReal_injective hh)) |
|
|
| lemma dBasis_other {m n : Node} (hmn : m ≠ n) : dBasis n (m.val : ℂ) = 0 := by |
| rw [dBasis_eq n (node_cast_ne hmn), P_node, zero_div] |
|
|
| lemma cBasis_other {m n : Node} (hmn : m ≠ n) : cBasis n (m.val : ℂ) = 0 := by |
| rw [cBasis_eq n (node_cast_ne hmn), P_node, zero_div] |
|
|
| lemma mul_dBasis (n : Node) : |
| (fun s : ℂ => (s - n.val) * dBasis n s) = P := by |
| funext s |
| simpa only [smul_eq_mul, P_node, sub_zero, dBasis] using |
| sub_smul_dslope P (n.val : ℂ) s |
|
|
| lemma mul_cBasis (n : Node) : |
| (fun s : ℂ => (s - n.val) * cBasis n s) = dBasis n := by |
| funext s |
| simpa only [smul_eq_mul, dBasis_node, sub_zero, cBasis] using |
| sub_smul_dslope (dBasis n) (n.val : ℂ) s |
|
|
| lemma deriv_dBasis_other {m n : Node} (hmn : m ≠ n) : |
| deriv (dBasis n) (m.val : ℂ) = 0 := by |
| have hd := (((hasDerivAt_id (m.val : ℂ)).sub_const (n.val : ℂ)).mul |
| ((differentiable_dBasis n (m.val : ℂ)).hasDerivAt)).deriv |
| simp only [Pi.mul_def, id_eq] at hd |
| rw [mul_dBasis] at hd |
| simp only [deriv_P_node, dBasis_other hmn, mul_zero, zero_add] at hd |
| exact (mul_eq_zero.mp hd.symm).resolve_left (sub_ne_zero.mpr (node_cast_ne hmn)) |
|
|
| lemma deriv_cBasis_other {m n : Node} (hmn : m ≠ n) : |
| deriv (cBasis n) (m.val : ℂ) = 0 := by |
| have hd := (((hasDerivAt_id (m.val : ℂ)).sub_const (n.val : ℂ)).mul |
| ((differentiable_cBasis n (m.val : ℂ)).hasDerivAt)).deriv |
| simp only [Pi.mul_def, id_eq] at hd |
| rw [mul_cBasis] at hd |
| simp only [deriv_dBasis_other hmn, cBasis_other hmn, mul_zero, zero_add] at hd |
| exact (mul_eq_zero.mp hd.symm).resolve_left (sub_ne_zero.mpr (node_cast_ne hmn)) |
|
|
| lemma cBasis_node (n : Node) : cBasis n (n.val : ℂ) = deriv (dBasis n) (n.val : ℂ) := by |
| exact dslope_same (dBasis n) (n.val : ℂ) |
|
|
| lemma P_conj (s : ℂ) : conj (P s) = P (conj s) := by |
| simp only [P, sineFactor, map_prod, map_pow, map_mul, ← Complex.sin_conj, |
| map_sub, Complex.conj_ofReal, map_ofNat, map_intCast] |
|
|
| lemma dslope_conj_real {f : ℂ → ℂ} (hf : ∀ s, conj (f s) = f (conj s)) |
| (r : ℝ) (s : ℂ) : conj (dslope f (r : ℂ) s) = dslope f (r : ℂ) (conj s) := by |
| have he : conj ∘ f ∘ conj = f := by |
| ext z |
| simp only [Function.comp_apply, hf, RCLike.conj_conj] |
| have hd := congrFun (deriv_conj_conj (f := f)) (r : ℂ) |
| rw [he] at hd |
| simp only [Function.comp_apply, Complex.conj_ofReal] at hd |
| by_cases hs : s = (r : ℂ) |
| · subst s |
| simpa only [Complex.conj_ofReal, dslope_same] using hd.symm |
| · have hc : conj s ≠ (r : ℂ) := by |
| intro h |
| apply hs |
| have hh := congrArg conj h |
| simpa using hh |
| rw [dslope_of_ne _ hs, dslope_of_ne _ hc] |
| simp only [slope_def_field, map_div₀, map_sub, hf, Complex.conj_ofReal] |
|
|
| lemma dBasis_conj (n : Node) (s : ℂ) : |
| conj (dBasis n s) = dBasis n (conj s) := |
| dslope_conj_real P_conj n.val s |
|
|
| lemma cBasis_conj (n : Node) (s : ℂ) : |
| conj (cBasis n s) = cBasis n (conj s) := |
| dslope_conj_real (dBasis_conj n) n.val s |
|
|
| lemma norm_two_sin_le (z : ℂ) : ‖2 * Complex.sin z‖ ≤ 2 * Real.exp |z.im| := by |
| rw [Complex.two_sin, norm_mul, Complex.norm_I, mul_one] |
| calc |
| ‖Complex.exp (-z * Complex.I) - Complex.exp (z * Complex.I)‖ ≤ |
| ‖Complex.exp (-z * Complex.I)‖ + ‖Complex.exp (z * Complex.I)‖ := norm_sub_le _ _ |
| _ = Real.exp z.im + Real.exp (-z.im) := by simp [Complex.norm_exp] |
| _ ≤ Real.exp |z.im| + Real.exp |z.im| := |
| add_le_add (Real.exp_le_exp.mpr (le_abs_self _)) |
| (Real.exp_le_exp.mpr (neg_le_abs _)) |
| _ = 2 * Real.exp |z.im| := by ring |
|
|
| def stripBound (R : ℝ) : ℝ := (2 * Real.exp (Real.pi * R / 12)) ^ 12 |
|
|
| lemma stripBound_nonneg (R : ℝ) : 0 ≤ stripBound R := by |
| unfold stripBound |
| positivity |
|
|
| lemma P_strip_bound (R : ℝ) (s : ℂ) (hs : |s.im| ≤ R) : ‖P s‖ ≤ stripBound R := by |
| unfold P sineFactor |
| rw [norm_prod] |
| calc |
| ∏ a ∈ L, ‖(2 * Complex.sin (((Real.pi / 12 : ℝ) : ℂ) * (s - a))) ^ 2‖ ≤ |
| ∏ _a ∈ L, (2 * Real.exp (Real.pi * R / 12)) ^ 2 := by |
| apply Finset.prod_le_prod₀ (by intros; positivity) |
| intro a _ |
| rw [norm_pow] |
| apply pow_le_pow_left₀ (norm_nonneg _) |
| refine (norm_two_sin_le _).trans ?_ |
| apply mul_le_mul_of_nonneg_left _ (by norm_num : (0 : ℝ) ≤ 2) |
| apply Real.exp_le_exp.mpr |
| have he : ((((Real.pi / 12 : ℝ) : ℂ) * (s - a))).im = |
| Real.pi * s.im / 12 := by simp [div_eq_mul_inv]; ring |
| rw [he, abs_div, abs_mul, abs_of_pos Real.pi_pos] |
| norm_num only [abs_of_pos (by norm_num : (0 : ℝ) < 12)] |
| exact div_le_div_of_nonneg_right |
| (mul_le_mul_of_nonneg_left hs Real.pi_pos.le) (by norm_num) |
| _ = stripBound R := by simp [stripBound, ← pow_mul, L] |
|
|
| lemma im_le_dist_real (w : ℂ) (n : ℝ) : |w.im| ≤ dist w (n : ℂ) := by |
| simpa [dist_eq_norm] using Complex.abs_im_le_norm (w - (n : ℂ)) |
|
|
| lemma uniform_basis_bound (R : ℝ) : ∃ M : ℝ, 0 ≤ M ∧ |
| ∀ (n : Node) (s : ℂ), |s.im| ≤ R → ‖cBasis n s‖ ≤ M ∧ ‖dBasis n s‖ ≤ M := by |
| let A := max R 2 |
| let M := stripBound A |
| have hM : 0 ≤ M := stripBound_nonneg A |
| refine ⟨M, hM, ?_⟩ |
| intro n s hs |
| have hmapP : Set.MapsTo P (Metric.ball (n.val : ℂ) 2) |
| (Metric.closedBall (P (n.val : ℂ)) M) := by |
| intro w hw |
| simp only [Metric.mem_closedBall, P_node, dist_zero_right] |
| exact P_strip_bound A w ((im_le_dist_real w n.val).trans |
| ((Metric.mem_ball.mp hw).le.trans (le_max_right _ _))) |
| have hd : ∀ w ∈ Metric.ball (n.val : ℂ) 2, ‖dBasis n w‖ ≤ M / 2 := by |
| intro w hw |
| exact Complex.norm_dslope_le_div_of_mapsTo_ball |
| differentiable_P.differentiableOn hmapP hw |
| have hmapD : Set.MapsTo (dBasis n) (Metric.ball (n.val : ℂ) 1) |
| (Metric.closedBall (dBasis n (n.val : ℂ)) (M / 2)) := by |
| intro w hw |
| simp only [Metric.mem_closedBall, dBasis_node, dist_zero_right] |
| apply hd w |
| exact (Metric.ball_subset_ball (by norm_num : (1 : ℝ) ≤ 2)) hw |
| have hc : ∀ w ∈ Metric.ball (n.val : ℂ) 1, ‖cBasis n w‖ ≤ M / 2 := by |
| intro w hw |
| simpa [cBasis] using Complex.norm_dslope_le_div_of_mapsTo_ball |
| (differentiable_dBasis n).differentiableOn hmapD hw |
| have hPs : ‖P s‖ ≤ M := P_strip_bound A s (hs.trans (le_max_left _ _)) |
| have hhalf : M / 2 ≤ M := by linarith |
| by_cases hnear : dist s (n.val : ℂ) < 1 |
| · exact ⟨(hc s hnear).trans hhalf, |
| (hd s (lt_trans hnear (by norm_num : (1 : ℝ) < 2))).trans hhalf⟩ |
| · have hfar : 1 ≤ ‖s - (n.val : ℂ)‖ := by |
| simpa [dist_eq_norm] using le_of_not_gt hnear |
| have hne : s ≠ (n.val : ℂ) := by intro he; norm_num [he] at hfar |
| rw [cBasis_eq n hne, dBasis_eq n hne, norm_div, norm_div, norm_pow] |
| constructor |
| · exact (div_le_self (norm_nonneg _) (one_le_pow₀ hfar)).trans hPs |
| · exact (div_le_self (norm_nonneg _) hfar).trans hPs |
|
|
| structure Coefficients where |
| C : ℝ |
| c : Node → ℝ |
| d : Node → ℝ |
| summable : Summable (fun n => |c n| + |d n|) |
|
|
| def profile (a : Coefficients) (s : ℂ) : ℂ := |
| (a.C : ℂ) * P s + |
| ∑' n : Node, ((a.c n : ℂ) * cBasis n s + (a.d n : ℂ) * dBasis n s) |
|
|
| lemma summand_norm_bound (a : Coefficients) {R M : ℝ} |
| (hM : ∀ (n : Node) (s : ℂ), |s.im| ≤ R → ‖cBasis n s‖ ≤ M ∧ ‖dBasis n s‖ ≤ M) |
| (n : Node) (s : ℂ) (hs : |s.im| ≤ R) : |
| ‖(a.c n : ℂ) * cBasis n s + (a.d n : ℂ) * dBasis n s‖ ≤ |
| (|a.c n| + |a.d n|) * M := by |
| refine (norm_add_le _ _).trans ?_ |
| simp only [norm_mul, Complex.norm_real, Real.norm_eq_abs] |
| calc |
| _ ≤ |a.c n| * M + |a.d n| * M := |
| add_le_add (mul_le_mul_of_nonneg_left (hM n s hs).1 (abs_nonneg _)) |
| (mul_le_mul_of_nonneg_left (hM n s hs).2 (abs_nonneg _)) |
| _ = _ := by ring |
|
|
| lemma differentiable_profile (a : Coefficients) : Differentiable ℂ (profile a) := by |
| intro s |
| obtain ⟨M, hM, hB⟩ := uniform_basis_bound (|s.im| + 1) |
| let U : Set ℂ := {w | |w.im| < |s.im| + 1} |
| have hU : IsOpen U := isOpen_lt Complex.continuous_im.abs continuous_const |
| have hs : s ∈ U := by dsimp [U]; linarith |
| have hd : DifferentiableOn ℂ |
| (fun w => ∑' n : Node, ((a.c n : ℂ) * cBasis n w + (a.d n : ℂ) * dBasis n w)) U := by |
| apply Complex.differentiableOn_tsum_of_summable_norm (a.summable.mul_right M) |
| · intro n |
| exact ((differentiable_cBasis n).const_mul _ |>.add |
| ((differentiable_dBasis n).const_mul _)).differentiableOn |
| · exact hU |
| · intro n w hw |
| exact summand_norm_bound a hB n w (le_of_lt hw) |
| exact ((differentiable_P s).const_mul _).add (hd.differentiableAt (hU.mem_nhds hs)) |
|
|
| lemma profile_strip (a : Coefficients) (R : ℝ) : |
| ∃ M : ℝ, ∀ s : ℂ, |s.im| ≤ R → ‖profile a s‖ ≤ M := by |
| obtain ⟨M, hM, hB⟩ := uniform_basis_bound R |
| refine ⟨|a.C| * stripBound R + ∑' n : Node, (|a.c n| + |a.d n|) * M, ?_⟩ |
| intro s hs |
| have hsum := (a.summable.mul_right M).of_norm_bounded |
| (fun n => summand_norm_bound a hB n s hs) |
| unfold profile |
| refine (norm_add_le _ _).trans (add_le_add ?_ ?_) |
| · simpa only [norm_mul, Complex.norm_real, Real.norm_eq_abs] using |
| mul_le_mul_of_nonneg_left (P_strip_bound R s hs) (abs_nonneg a.C) |
| · exact (norm_tsum_le_tsum_norm hsum.norm).trans |
| (hsum.norm.tsum_le_tsum (fun n => summand_norm_bound a hB n s hs) |
| (a.summable.mul_right M)) |
|
|
| lemma profile_conj (a : Coefficients) (s : ℂ) : |
| conj (profile a s) = profile a (conj s) := by |
| simp only [profile, map_add, map_mul, Complex.conj_ofReal, P_conj, |
| Complex.conj_tsum, cBasis_conj, dBasis_conj] |
|
|
| lemma profile_real (a : Coefficients) (s : ℝ) : (profile a (s : ℂ)).im = 0 := by |
| have hh : conj (profile a (s : ℂ)) = profile a (s : ℂ) := by |
| simpa only [Complex.conj_ofReal] using profile_conj a (s : ℂ) |
| exact Complex.conj_eq_iff_im.mp hh |
|
|
| lemma profile_eq (a : Coefficients) (s : ℂ) (hs : ∀ n : Node, s ≠ (n.val : ℂ)) : |
| profile a s = P s * ((a.C : ℂ) + |
| ∑' n : Node, ((a.c n : ℂ) / (s - n.val) ^ 2 + (a.d n : ℂ) / (s - n.val))) := by |
| simp_rw [profile, cBasis_eq _ (hs _), dBasis_eq _ (hs _)] |
| rw [mul_add, ← tsum_mul_left] |
| congr 1 |
| · ring |
| · apply tsum_congr |
| intro n |
| ring |
|
|
| lemma deriv_profile (a : Coefficients) (s : ℂ) : |
| deriv (profile a) s = (a.C : ℂ) * deriv P s + |
| ∑' n : Node, ((a.c n : ℂ) * deriv (cBasis n) s + |
| (a.d n : ℂ) * deriv (dBasis n) s) := by |
| obtain ⟨M, hM, hB⟩ := uniform_basis_bound (|s.im| + 1) |
| let U : Set ℂ := {w | |w.im| < |s.im| + 1} |
| let F : Node → ℂ → ℂ := fun n w => (a.c n : ℂ) * cBasis n w + (a.d n : ℂ) * dBasis n w |
| have hU : IsOpen U := isOpen_lt Complex.continuous_im.abs continuous_const |
| have hs : s ∈ U := by dsimp [U]; linarith |
| have hd (n : Node) : Differentiable ℂ (F n) := |
| ((differentiable_cBasis n).const_mul _).add ((differentiable_dBasis n).const_mul _) |
| have hF (n : Node) (w : ℂ) (hw : w ∈ U) : ‖F n w‖ ≤ (|a.c n| + |a.d n|) * M := |
| summand_norm_bound a hB n w (le_of_lt hw) |
| have hsum := Complex.hasSum_deriv_of_summable_norm (a.summable.mul_right M) |
| (fun n => (hd n).differentiableOn) hU hF hs |
| have hdiff := (Complex.differentiableOn_tsum_of_summable_norm (a.summable.mul_right M) |
| (fun n => (hd n).differentiableOn) hU hF).differentiableAt (hU.mem_nhds hs) |
| change deriv (fun z => (a.C : ℂ) * P z + ∑' n : Node, F n z) s = _ |
| rw [deriv_fun_add ((differentiable_P s).const_mul _) hdiff, |
| deriv_const_mul _ (differentiable_P s), ← hsum.tsum_eq] |
| congr 1 |
| apply tsum_congr |
| intro n |
| exact ((((differentiable_cBasis n s).hasDerivAt.const_mul (a.c n : ℂ)).add |
| ((differentiable_dBasis n s).hasDerivAt.const_mul (a.d n : ℂ))).deriv) |
|
|
| lemma profile_node (a : Coefficients) (n : Node) : |
| profile a (n.val : ℂ) = (a.c n : ℂ) * cBasis n (n.val : ℂ) := by |
| classical |
| simp only [profile, P_node, mul_zero, zero_add] |
| rw [tsum_eq_single n] |
| · simp only [dBasis_node, mul_zero, add_zero] |
| · intro m hmn |
| simp only [cBasis_other hmn.symm, dBasis_other hmn.symm, mul_zero, add_zero] |
|
|
| lemma deriv_profile_node (a : Coefficients) (n : Node) : |
| deriv (profile a) (n.val : ℂ) = |
| (a.c n : ℂ) * deriv (cBasis n) (n.val : ℂ) + |
| (a.d n : ℂ) * cBasis n (n.val : ℂ) := by |
| classical |
| rw [deriv_profile, deriv_P_node, mul_zero, zero_add, tsum_eq_single n] |
| · rw [cBasis_node] |
| · intro m hmn |
| simp only [deriv_cBasis_other hmn.symm, deriv_dBasis_other hmn.symm, |
| mul_zero, add_zero] |
|
|
| end Cardinal |
|
|
| namespace Analysis |
|
|
| lemma polynomial_gaussian_bound {c : ℝ} (hc : 0 < c) (m : ℕ) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ r : ℝ, 0 ≤ r → (1+r)^m * Real.exp (-c*r^2) ≤ C := by |
| let B : ℝ := 2+c⁻¹ |
| refine ⟨B^m*(m.factorial:ℝ)*Real.exp 1, by positivity, ?_⟩ |
| intro r hr |
| have hc' : 0 < c⁻¹ := inv_pos.mpr hc |
| have hB : 0 ≤ B := by dsimp [B]; positivity |
| have h : 1+r ≤ B*(1+c*r^2) := by |
| dsimp [B] |
| have hsq := sq_nonneg (r-1) |
| have hmul : c⁻¹*c=1 := inv_mul_cancel₀ hc.ne' |
| nlinarith [sq_nonneg r, mul_nonneg hc.le (sq_nonneg r)] |
| have hp : (1+c*r^2)^m ≤ (m.factorial:ℝ)*Real.exp (1+c*r^2) := by |
| have hh := Real.pow_div_factorial_le_exp (1+c*r^2) (by positivity : 0 ≤ 1+c*r^2) m |
| exact (div_le_iff₀ (by positivity : (0 : ℝ) < (m.factorial : ℝ))).mp hh |>.trans_eq (mul_comm _ _) |
| calc |
| (1+r)^m * Real.exp (-c*r^2) ≤ (B*(1+c*r^2))^m * Real.exp (-c*r^2) := by gcongr |
| _ = B^m * ((1+c*r^2)^m * Real.exp (-c*r^2)) := by rw [mul_pow]; ring |
| _ ≤ B^m * (((m.factorial:ℝ)*Real.exp (1+c*r^2))*Real.exp (-c*r^2)) := by gcongr |
| _ = B^m*(m.factorial:ℝ)*Real.exp 1 := by |
| rw [mul_assoc (m.factorial:ℝ), ← Real.exp_add] |
| rw [show 1+c*r^2 + -c*r^2 = 1 by ring] |
| ring |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
|
|
| lemma gaussian_schwartz_decay {c : ℝ} (hc : 0 < c) (k n : ℕ) : |
| ∃ C : ℝ, ∀ x : E, ‖x‖^k * ‖iteratedFDeriv ℝ n (fun y : E => Real.exp (-c*‖y‖^2)) x‖ ≤ C := by |
| have ht : (fun x : E => -c*‖x‖^2).HasTemperateGrowth := by fun_prop |
| obtain ⟨l,B,hB,hder⟩ := ht.norm_iteratedFDeriv_le_uniform n |
| obtain ⟨C,hC,hCbound⟩ := polynomial_gaussian_bound hc (k+l*n) |
| refine ⟨(n.factorial:ℝ)*(B+1)^n*C, fun x => ?_⟩ |
| have hw : 1 ≤ (B+1)*(1+‖x‖)^l := by |
| have hh : 1 ≤ (1+‖x‖)^l := one_le_pow₀ (by linarith [norm_nonneg x]) |
| nlinarith |
| have hD (i : ℕ) (hi : 1 ≤ i) (hin : i ≤ n) : |
| ‖iteratedFDeriv ℝ i (fun x : E => -c*‖x‖^2) x‖ ≤ ((B+1)*(1+‖x‖)^l)^i := by |
| calc |
| _ ≤ B*(1+‖x‖)^l := hder i hin x |
| _ ≤ (B+1)*(1+‖x‖)^l := by gcongr; linarith |
| _ ≤ ((B+1)*(1+‖x‖)^l)^i := le_self_pow₀ hw (by omega) |
| have hexp (i : ℕ) (_hi : i ≤ n) : |
| ‖iteratedFDeriv ℝ i Real.exp (-c*‖x‖^2)‖ ≤ Real.exp (-c*‖x‖^2) := by |
| rw [norm_iteratedFDeriv_eq_norm_iteratedDeriv,iteratedDeriv_eq_iterate,Real.iter_deriv_exp] |
| exact le_of_eq (Real.norm_of_nonneg (Real.exp_pos _).le) |
| have hd := norm_iteratedFDeriv_comp_le (𝕜 := ℝ) Real.contDiff_exp ht.1 (by exact_mod_cast (show (n : ℕ∞) ≤ ⊤ from le_top)) x hexp hD |
| calc |
| _ ≤ ‖x‖^k * ((n.factorial:ℝ)*Real.exp (-c*‖x‖^2)*((B+1)*(1+‖x‖)^l)^n) := |
| mul_le_mul_of_nonneg_left hd (by positivity) |
| _ ≤ (1+‖x‖)^k * ((n.factorial:ℝ)*Real.exp (-c*‖x‖^2)*((B+1)*(1+‖x‖)^l)^n) := by gcongr; linarith |
| _ = (n.factorial:ℝ)*(B+1)^n*((1+‖x‖)^(k+l*n)*Real.exp (-c*‖x‖^2)) := by |
| rw [mul_pow,pow_add,pow_mul] |
| ring |
| _ ≤ (n.factorial:ℝ)*(B+1)^n*C := by gcongr; exact hCbound ‖x‖ (norm_nonneg _) |
|
|
| def gaussianSchwartz (c : ℝ) (hc : 0 < c) : 𝓢(E,ℝ) where |
| toFun x := Real.exp (-c*‖x‖^2) |
| smooth' := Real.contDiff_exp.comp (contDiff_const.mul (contDiff_norm_sq ℝ)) |
| decay' := gaussian_schwartz_decay hc |
|
|
| @[simp] lemma gaussianSchwartz_apply (c : ℝ) (hc : 0 < c) (x : E) : |
| gaussianSchwartz c hc x = Real.exp (-c*‖x‖^2) := rfl |
|
|
| lemma iteratedDeriv_real_of_complex {f : ℂ → ℂ} (hf : Differentiable ℂ f) (n : ℕ) : |
| iteratedDeriv n (fun x : ℝ => (f x).re) = fun x : ℝ => (iteratedDeriv n f x).re := by |
| induction n with |
| | zero => simp only [iteratedDeriv_zero] |
| | succ n ih => |
| rw [iteratedDeriv_succ, ih, iteratedDeriv_succ] |
| funext x |
| exact ((hf.contDiff (n := ⊤)).differentiable_iteratedDeriv n (by simp) (x : ℂ)).hasDerivAt.real_of_complex.deriv |
|
|
| lemma entire_real_temperate {f : ℂ → ℂ} (hf : Differentiable ℂ f) |
| (hstrip : ∃ M : ℝ, ∀ z : ℂ, |z.im| ≤ 1 → ‖f z‖ ≤ M) : |
| Function.HasTemperateGrowth (fun x : ℝ => (f x).re) := by |
| obtain ⟨M,hM⟩ := hstrip |
| refine ⟨hf.contDiff.real_of_complex, fun n => ⟨0,(n.factorial:ℝ)*M,?_⟩⟩ |
| intro x |
| rw [pow_zero,mul_one,norm_iteratedFDeriv_eq_norm_iteratedDeriv,iteratedDeriv_real_of_complex hf] |
| apply (Complex.abs_re_le_norm _).trans |
| have hh := Complex.norm_iteratedDeriv_le_of_forall_mem_sphere_norm_le (f := f) n |
| (by norm_num : (0:ℝ)<1) hf.diffContOnCl (c := (x:ℂ)) (C := M) (fun z hz => hM z (by |
| have hi := Complex.abs_im_le_norm (z-(x:ℂ)) |
| have he := Metric.mem_sphere.mp hz |
| simpa only [Complex.sub_im,Complex.ofReal_im,sub_zero,← dist_eq_norm,he] using hi)) |
| simpa using hh |
|
|
| def dampedEntireSchwartz (c : ℝ) (hc : 0 < c) (b : ℝ) (f : ℂ → ℂ) |
| (_hf : Differentiable ℂ f) (_hstrip : ∃ M : ℝ, ∀ z : ℂ, |z.im| ≤ 1 → ‖f z‖ ≤ M) : 𝓢(E,ℝ) := |
| SchwartzMap.smulLeftCLM ℝ (fun x : E => (f (b*‖x‖^2)).re) (gaussianSchwartz c hc) |
|
|
| lemma dampedEntireSchwartz_apply (c : ℝ) (hc : 0 < c) (b : ℝ) (f : ℂ → ℂ) |
| (hf : Differentiable ℂ f) (hstrip : ∃ M : ℝ, ∀ z : ℂ, |z.im| ≤ 1 → ‖f z‖ ≤ M) (x : E) : |
| dampedEntireSchwartz c hc b f hf hstrip x = Real.exp (-c*‖x‖^2)*(f (b*‖x‖^2)).re := by |
| have ht := entire_real_temperate hf hstrip |
| have hg : Function.HasTemperateGrowth (fun x : E => (f (b*‖x‖^2)).re) := by |
| convert ht.comp (by fun_prop : Function.HasTemperateGrowth (fun x : E => b*‖x‖^2)) using 1 |
| funext x |
| simp |
| rw [dampedEntireSchwartz,SchwartzMap.smulLeftCLM_apply_apply hg,gaussianSchwartz_apply] |
| simp [mul_comm] |
|
|
| end Analysis |
|
|
| namespace Cardinal |
|
|
| def dampedProfile (a : Coefficients) : SchwartzMap Plane ℝ := |
| Analysis.dampedEntireSchwartz (Real.pi * h * b) |
| (mul_pos (mul_pos Real.pi_pos h_pos) b_pos) b (profile a) |
| (differentiable_profile a) (profile_strip a 1) |
|
|
| lemma dampedProfile_apply (a : Coefficients) (x : Plane) : |
| dampedProfile a x = Real.exp (-Real.pi * h * b * ‖x‖ ^ 2) * |
| (profile a ((b * ‖x‖ ^ 2 : ℝ) : ℂ)).re := by |
| rw [dampedProfile, Analysis.dampedEntireSchwartz_apply] |
| push_cast |
| congr 3; ring |
|
|
| lemma dampedProfile_complex (a : Coefficients) (x : Plane) : |
| (dampedProfile a x : ℂ) = (Real.exp (-Real.pi * h * b * ‖x‖ ^ 2) : ℂ) * |
| profile a ((b * ‖x‖ ^ 2 : ℝ) : ℂ) := by |
| rw [dampedProfile_apply, Complex.ofReal_mul] |
| have hh : ((profile a ((b * ‖x‖ ^ 2 : ℝ) : ℂ)).re : ℂ) = |
| profile a ((b * ‖x‖ ^ 2 : ℝ) : ℂ) := |
| Complex.conj_eq_iff_re.mp (by |
| simpa only [Complex.conj_ofReal] using profile_conj a ((b * ‖x‖ ^ 2 : ℝ) : ℂ)) |
| rw [hh] |
|
|
| lemma dampedProfile_radial (a : Coefficients) : IsRadial (dampedProfile a) := by |
| intro x y hxy |
| simp only [dampedProfile_apply, hxy] |
|
|
| theorem cardinal_realization (a : Coefficients) : |
| Differentiable ℂ (profile a) ∧ |
| (∀ s : ℝ, (profile a (s : ℂ)).im = 0) ∧ |
| ∃ f : SchwartzMap Plane ℝ, IsRadial f ∧ |
| ∀ x : Plane, (f x : ℂ) = |
| (Real.exp (-Real.pi * h * b * ‖x‖ ^ 2) : ℂ) * |
| profile a ((b * ‖x‖ ^ 2 : ℝ) : ℂ) := by |
| exact ⟨differentiable_profile a, profile_real a, dampedProfile a, |
| dampedProfile_radial a, dampedProfile_complex a⟩ |
|
|
| end Cardinal |
|
|
| end Triangular |
|
|
| end |
|
|
| end OAI |
|
|
