lean/OAI/Analysis/CardinalInterpolation/ModTwelve.lean

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