import OAI.MathematicalPhysics.RapidForcing.Detector

namespace OAI


open scoped BigOperators ENNReal Topology
open Set MeasureTheory

namespace RapidForcing

section UniformBounds
variable {P E F : Type} [NormedAddCommGroup P] [NormedSpace ℝ P]
  [NormedAddCommGroup E] [NormedSpace ℝ E]
  [NormedAddCommGroup F] [NormedSpace ℝ F]

lemma norm_iteratedFDeriv_slice_le {f : P × E → F}
    (hf : ContDiff ℝ (⊤ : ℕ∞) f) (a : P) (x : E) (k : ℕ) :
    ‖iteratedFDeriv ℝ k (fun y => f (a, y)) x‖ ≤
      ‖iteratedFDeriv ℝ k f (a, x)‖ := by
  let L := ContinuousLinearMap.inr ℝ P E
  have hL : ‖L‖ ≤ 1 := ContinuousLinearMap.opNorm_le_bound _ zero_le_one (by
    intro y
    simp [L])
  have hf' : ContDiff ℝ (⊤ : ℕ∞) (fun z : P × E => f (z + (a, 0))) :=
    hf.comp (contDiff_id.add contDiff_const)
  have hd := L.iteratedFDeriv_comp_right hf' x (i := k) (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤))
  have hfun : (fun y => f (a, y)) = (fun z : P × E => f (z + (a, 0))) ∘ L := by
    ext y
    simp [L]
  rw [hfun, hd, iteratedFDeriv_comp_add_right]
  have hb := (iteratedFDeriv ℝ k f (L x + (a, 0))).norm_compContinuousLinearMap_le
    (fun _ : Fin k => L)
  simp only [Finset.prod_const, Finset.card_univ, Fintype.card_fin] at hb
  calc
    _ ≤ ‖iteratedFDeriv ℝ k f (L x + (a, 0))‖ * ‖L‖ ^ k := hb
    _ ≤ ‖iteratedFDeriv ℝ k f (L x + (a, 0))‖ * 1 :=
      mul_le_mul_of_nonneg_left (by simpa using pow_le_pow_left₀ (norm_nonneg L) hL k)
        (norm_nonneg _)
    _ = _ := by simp [L]

lemma uniform_derivative_bound {f : P × E → F}
    (hf : ContDiff ℝ (⊤ : ℕ∞) f) {A : Set P} {B : Set E}
    (hA : IsCompact A) (hB : IsCompact B)
    (hs : ∀ a ∈ A, tsupport (fun x => f (a, x)) ⊆ B) (k : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ a ∈ A, ∀ x,
      ‖iteratedFDeriv ℝ k (fun y => f (a, y)) x‖ ≤ C := by
  obtain ⟨C, hC⟩ := (hA.prod hB).exists_bound_of_continuousOn
    ((hf.continuous_iteratedFDeriv (m := k) (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤))).continuousOn)
  refine ⟨max 0 C, le_max_left _ _, ?_⟩
  intro a ha x
  by_cases hx : x ∈ B
  · exact (norm_iteratedFDeriv_slice_le hf a x k).trans ((hC (a, x) ⟨ha, hx⟩).trans
      (le_max_right _ _))
  · have hz : iteratedFDeriv ℝ k (fun y => f (a, y)) x = 0 :=
      image_eq_zero_of_notMem_tsupport (fun h => hx (hs a ha
        (tsupport_iteratedFDeriv_subset k h)))
    rw [hz, norm_zero]
    exact le_max_left _ _
end UniformBounds

noncomputable def scaledCurl (η ξ : Space) : Field Space := fun σ y =>
  curl (fun z => ζ (z - θ σ • η) •
    ((1 / 2 : ℝ) • cross (deriv θ σ • ξ) (z - θ σ • η))) y

lemma scaledCurl_joint_smooth : ContDiff ℝ (⊤ : ℕ∞)
    (fun p : (Space × Space) × (ℝ × Space) => scaledCurl p.1.1 p.1.2 p.2.1 p.2.2) := by
  have hθ := theta_smooth
  have hdθ : ContDiff ℝ (⊤ : ℕ∞) (deriv θ) :=
    (contDiff_infty_iff_deriv.mp theta_smooth).2
  have h : ContDiff ℝ (⊤ : ℕ∞)
      (fun p : ((Space × Space) × (ℝ × Space)) × Space =>
        ζ (p.2 - θ p.1.2.1 • p.1.1.1) •
          ((1 / 2 : ℝ) • cross (deriv θ p.1.2.1 • p.1.1.2)
            (p.2 - θ p.1.2.1 • p.1.1.1))) := by
    apply (contDiff_piLp 2).mpr
    intro i
    fin_cases i <;> dsimp [cross, vec] <;> unfold ζ <;> fun_prop (disch := assumption)
  have hD : ContDiff ℝ (⊤ : ℕ∞)
      (fun p : (Space × Space) × (ℝ × Space) =>
        fderiv ℝ (fun z => ζ (z - θ p.2.1 • p.1.1) •
          ((1 / 2 : ℝ) • cross (deriv θ p.2.1 • p.1.2) (z - θ p.2.1 • p.1.1))) p.2.2) :=
    h.fderiv (contDiff_snd.snd) (by simp)
  apply (contDiff_piLp 2).mpr
  intro i
  fin_cases i <;> dsimp [scaledCurl, curl, vec] <;> fun_prop

lemma deriv_theta_left {σ : ℝ} (hσ : σ < 1 / 4) : deriv θ σ = 0 := by
  have he : θ =ᶠ[𝓝 σ] fun _ => 0 := by
    filter_upwards [Iio_mem_nhds hσ] with s hs
    exact theta_zero hs.le
  simpa using he.deriv_eq

lemma deriv_theta_right {σ : ℝ} (hσ : 3 / 4 < σ) : deriv θ σ = 0 := by
  have he : θ =ᶠ[𝓝 σ] fun _ => 1 := by
    filter_upwards [Ioi_mem_nhds hσ] with s hs
    exact theta_one hs.le
  simpa using he.deriv_eq

lemma scaledCurl_eq_zero_of_deriv_theta (η ξ : Space) {σ : ℝ} (hσ : deriv θ σ = 0) :
    scaledCurl η ξ σ = 0 := by
  funext y
  have hc : ∀ z : Space, cross (0 : Space) z = 0 := by
    intro z
    ext i
    fin_cases i <;> simp [cross, vec]
  simp [scaledCurl, hσ, hc, curl, vec]

lemma norm_le_two_mul_of_coord_le {z : Space} {r : ℝ} (hr : 0 ≤ r)
    (hz : ∀ i : Fin 3, |z i| ≤ r) : ‖z‖ ≤ 2 * r := by
  have hs (i : Fin 3) : (z i) ^ 2 ≤ r ^ 2 := by
    simpa only [sq_abs] using (sq_le_sq₀ (abs_nonneg _) hr).mpr (hz i)
  have hnorm : ‖z‖ ^ 2 = (z 0) ^ 2 + (z 1) ^ 2 + (z 2) ^ 2 := by
    simpa [Fin.sum_univ_three, Real.norm_eq_abs, sq_abs] using EuclideanSpace.norm_sq_eq z
  nlinarith [hs 0, hs 1, hs 2, norm_nonneg z, sq_nonneg r]

lemma scaledCurl_tsupport_subset (η ξ : Space) (hη : ‖η‖ ≤ 2) :
    tsupport (Function.uncurry (scaledCurl η ξ)) ⊆
      Icc (0 : ℝ) 1 ×ˢ Metric.closedBall (0 : Space) 3 := by
  apply closure_minimal _ (isClosed_Icc.prod Metric.isClosed_closedBall)
  intro p hp
  have ht : p.1 ∈ Icc (0 : ℝ) 1 := by
    by_contra h
    have hz : scaledCurl η ξ p.1 = 0 := by
      have hor : p.1 < 0 ∨ 1 < p.1 := by
        by_cases hh : 0 ≤ p.1
        · exact Or.inr (lt_of_not_ge (fun hh' => h ⟨hh, hh'⟩))
        · exact Or.inl (lt_of_not_ge hh)
      rcases hor with h | h
      · exact scaledCurl_eq_zero_of_deriv_theta η ξ (deriv_theta_left (by linarith))
      · exact scaledCurl_eq_zero_of_deriv_theta η ξ (deriv_theta_right (by linarith))
    exact hp (congrFun hz p.2)
  refine ⟨ht, ?_⟩
  have hz : p.2 ∈ tsupport (fun z => ζ (z - θ p.1 • η) •
      ((1 / 2 : ℝ) • cross (deriv θ p.1 • ξ) (z - θ p.1 • η))) :=
    curl_tsupport_subset _ (subset_closure hp)
  have hs : tsupport (fun z => ζ (z - θ p.1 • η) •
      ((1 / 2 : ℝ) • cross (deriv θ p.1 • ξ) (z - θ p.1 • η))) ⊆
      supportBox (θ p.1 • η) (1 / 8) := by
    apply closure_minimal _ (supportBox_closed _ _)
    intro z hz i
    by_contra hi
    have hv := zeta_zero (i := i) (v := z - θ p.1 • η) (le_of_lt (not_le.mp hi))
    exact hz (by dsimp; rw [hv, zero_smul])
  have hc := hs hz
  have hn : ‖p.2 - θ p.1 • η‖ ≤ 1 := by
    have hcoord := norm_le_two_mul_of_coord_le (z := p.2 - θ p.1 • η) (by norm_num : (0 : ℝ) ≤ 1 / 8) (fun i => hc i)
    exact hcoord.trans (by norm_num)
  have hθη : ‖θ p.1 • η‖ ≤ 2 := by
    rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (theta_nonneg _)]
    exact (mul_le_of_le_one_left (norm_nonneg η) (theta_le_one _)).trans hη
  rw [Metric.mem_closedBall, dist_zero_right]
  calc
    ‖p.2‖ = ‖(p.2 - θ p.1 • η) + θ p.1 • η‖ := by rw [sub_add_cancel]
    _ ≤ ‖p.2 - θ p.1 • η‖ + ‖θ p.1 • η‖ := norm_add_le _ _
    _ ≤ 3 := by linarith

lemma scaledCurl_derivative_bound (k : ℕ) : ∃ C : ℝ, 0 ≤ C ∧
    ∀ η ξ : Space, ‖η‖ ≤ 2 → ‖ξ‖ ≤ 2 → ∀ p : ℝ × Space,
      ‖iteratedFDeriv ℝ k (Function.uncurry (scaledCurl η ξ)) p‖ ≤ C := by
  obtain ⟨C, hC, hb⟩ := uniform_derivative_bound scaledCurl_joint_smooth
    ((isCompact_closedBall (0 : Space) 2).prod (isCompact_closedBall (0 : Space) 2))
    (isCompact_Icc.prod (isCompact_closedBall (0 : Space) 3))
    (fun a ha => scaledCurl_tsupport_subset a.1 a.2 (by simpa using ha.1)) k
  refine ⟨C, hC, ?_⟩
  intro η ξ hη hξ p
  exact hb (η, ξ) (by simpa using And.intro hη hξ) p

lemma cross_smul_left (r : ℝ) (a b : Space) : cross (r • a) b = r • cross a b := by
  ext i
  fin_cases i <;> dsimp [cross, vec] <;> ring

lemma cross_smul_right (r : ℝ) (a b : Space) : cross a (r • b) = r • cross a b := by
  ext i
  fin_cases i <;> dsimp [cross, vec] <;> ring

lemma curl_const_smul {V : Space → Space} (hV : Differentiable ℝ V) (r : ℝ) (x : Space) :
    curl (fun y => r • V y) x = r • curl V x := by
  have hd : fderiv ℝ (fun y => r • V y) x = r • fderiv ℝ V x :=
    fderiv_const_smul (hV x) r
  ext i
  fin_cases i <;> simp only [curl, hd, vec, smul_apply] <;>
    dsimp <;> ring

lemma curl_affine_scale {V : Space → Space} (hV : Differentiable ℝ V)
    (a : Space) (r : ℝ) (x : Space) :
    curl (fun y => V (r • (y - a))) x = r • curl V (r • (x - a)) := by
  have ha : HasFDerivAt (fun y : Space => r • (y - a))
      (r • ContinuousLinearMap.id ℝ Space) x :=
    ((hasFDerivAt_id x).sub_const a).const_smul r
  have hd : fderiv ℝ (fun y => V (r • (y - a))) x =
      (fderiv ℝ V (r • (x - a))).comp (r • ContinuousLinearMap.id ℝ Space) :=
    ((hV (r • (x - a))).hasFDerivAt.comp x ha).fderiv
  ext i
  fin_cases i <;> simp only [curl, hd, vec, ContinuousLinearMap.comp_apply,
    smul_apply, ContinuousLinearMap.id_apply, map_smul] <;>
    dsimp <;> ring

lemma movingCurl_normalized (a v : Space) {δ b : ℝ} (hδ : δ ≠ 0) (hb : b ≠ 0)
    (σ : ℝ) (x : Space) :
    movingCurl (fun s => a + θ s • v) δ σ x =
      b • scaledCurl (δ⁻¹ • v) (b⁻¹ • v) σ (δ⁻¹ • (x - a)) := by
  let η := δ⁻¹ • v
  let ξ := b⁻¹ • v
  let V : Space → Space := fun z => ζ (z - θ σ • η) •
    ((1 / 2 : ℝ) • cross (deriv θ σ • ξ) (z - θ σ • η))
  have hθ := theta_smooth
  have hVsm : ContDiff ℝ (⊤ : ℕ∞) V := by
    apply (contDiff_piLp 2).mpr
    intro i
    fin_cases i <;> dsimp [V, cross, vec] <;> unfold ζ <;> fun_prop
  have hV : Differentiable ℝ V := hVsm.differentiable (by simp)
  have hc : deriv (fun s => a + θ s • v) σ = deriv θ σ • v := by
    rw [deriv_const_add, deriv_smul_const]
    exact theta_smooth.differentiable (by simp) σ
  have hz (y : Space) : δ⁻¹ • (y - (a + θ σ • v)) = δ⁻¹ • (y - a) - θ σ • η := by
    dsimp [η]
    module
  have hz' (y : Space) : y - (a + θ σ • v) =
      δ • (δ⁻¹ • (y - a) - θ σ • η) := by
    rw [← hz, smul_inv_smul₀ hδ]
  have hv : deriv θ σ • v = b • (deriv θ σ • ξ) := by
    dsimp [ξ]
    rw [smul_comm (deriv θ σ), smul_inv_smul₀ hb]
  have hpot : (fun y => ζ (δ⁻¹ • (y - (a + θ σ • v))) •
      ((1 / 2 : ℝ) • cross (deriv (fun s => a + θ s • v) σ) (y - (a + θ σ • v)))) =
      (fun y => (b * δ) • V (δ⁻¹ • (y - a))) := by
    funext y
    rw [hc, hz, hv, hz' y, cross_smul_left, cross_smul_right]
    dsimp [V]
    module
  change curl _ x = _
  have hcomp : Differentiable ℝ (fun y => V (δ⁻¹ • (y - a))) :=
    hV.comp (((differentiable_id : Differentiable ℝ (fun y : Space => y)).sub_const a).const_smul δ⁻¹)
  rw [hpot, curl_const_smul hcomp, curl_affine_scale hV]
  change (b * δ) • (δ⁻¹ • _) = _
  rw [smul_smul, mul_assoc, mul_inv_cancel₀ hδ, mul_one]
  rfl

lemma address_parameters_bound (M : Machine) (w : M.Input) (n m : ℕ) :
    ‖((M.scaleData w).δ n)⁻¹ • addressDisplacement M (M.scaleData w) n m‖ ≤ 2 ∧
    ‖((M.scaleData w).b n)⁻¹ • addressDisplacement M (M.scaleData w) n m‖ ≤ 2 := by
  let d := M.scaleData w
  have hv := addressDisplacement_bound M w n m
  have hη (i : Fin 3) : |(d.δ n)⁻¹ * addressDisplacement M d n m i| ≤ 1 := by
    rw [abs_mul, abs_of_pos (inv_pos.mpr (d.delta_pos n))]
    exact (mul_le_mul_of_nonneg_left (hv i) (inv_nonneg.mpr (d.delta_nonneg n))).trans
      ((inv_mul_le_one₀ (d.delta_pos n)).mpr <| (d.b_lt_delta_div_eight n).le.trans
        (by linarith [d.delta_nonneg n]))
  have hξ (i : Fin 3) : |(d.b n)⁻¹ * addressDisplacement M d n m i| ≤ 1 := by
    rw [abs_mul, abs_of_pos (inv_pos.mpr (d.b_pos n))]
    exact (mul_le_mul_of_nonneg_left (hv i) (inv_nonneg.mpr (d.b_pos n).le)).trans_eq
      (inv_mul_cancel₀ (d.b_pos n).ne')
  constructor
  · simpa only [mul_one] using norm_le_two_mul_of_coord_le (r := 1) (by norm_num) hη
  · simpa only [mul_one] using norm_le_two_mul_of_coord_le (r := 1) (by norm_num) hξ

section ScaledBounds
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E]

lemma norm_iteratedFDeriv_scaled {g : ℝ × Space → E}
    (hg : ContDiff ℝ (⊤ : ℕ∞) g) {k : ℕ} {C r : ℝ}
    (hC : ∀ p, ‖iteratedFDeriv ℝ k g p‖ ≤ C) (hr : 1 ≤ r)
    (b τ : ℝ) (a : Space) (p : ℝ × Space) :
    ‖iteratedFDeriv ℝ k (fun q : ℝ × Space =>
      b • g (q.1 - τ, r • (q.2 - a))) p‖ ≤ |b| * C * r ^ k := by
  let L : (ℝ × Space) →L[ℝ] (ℝ × Space) :=
    (ContinuousLinearMap.fst ℝ ℝ Space).prod (r • ContinuousLinearMap.snd ℝ ℝ Space)
  have hL : ‖L‖ ≤ r := by
    apply ContinuousLinearMap.opNorm_le_bound _ (by linarith)
    intro q
    change max ‖q.1‖ ‖r • q.2‖ ≤ r * ‖q‖
    apply max_le
    · exact (norm_fst_le q).trans (le_mul_of_one_le_left (norm_nonneg _) hr)
    · rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by linarith : 0 ≤ r)]
      exact mul_le_mul_of_nonneg_left (norm_snd_le q) (by linarith)
  have heq : (fun q : ℝ × Space => g (q.1 - τ, r • (q.2 - a))) =
      (fun q => (g ∘ L) (q - (τ, a))) := rfl
  have hsm : ContDiff ℝ (⊤ : ℕ∞) (fun q : ℝ × Space =>
      g (q.1 - τ, r • (q.2 - a))) := by
    exact hg.comp ((contDiff_fst.sub contDiff_const).prodMk
      ((contDiff_snd.sub contDiff_const).const_smul r))
  rw [iteratedFDeriv_const_smul_apply' (hsm.of_le
    (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤))).contDiffAt, heq,
    iteratedFDeriv_comp_sub, L.iteratedFDeriv_comp_right hg _
      (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤)), norm_smul, Real.norm_eq_abs]
  calc
    _ ≤ |b| * (‖iteratedFDeriv ℝ k g (L (p - (τ, a)))‖ * ‖L‖ ^ k) := by
      apply mul_le_mul_of_nonneg_left _ (abs_nonneg _)
      simpa using (iteratedFDeriv ℝ k g (L (p - (τ, a)))).norm_compContinuousLinearMap_le
        (fun _ : Fin k => L)
    _ ≤ |b| * (C * r ^ k) := by
      apply mul_le_mul_of_nonneg_left _ (abs_nonneg _)
      exact mul_le_mul (hC _) (pow_le_pow_left₀ (norm_nonneg _) hL _)
        (pow_nonneg (norm_nonneg _) _) ((norm_nonneg _).trans (hC (0, 0)))
    _ = _ := by ring
end ScaledBounds

lemma addressCurl_derivative_bound (M : Machine) (w : M.Input) (k : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ n m : ℕ, ∀ p : ℝ × Space,
      ‖iteratedFDeriv ℝ k (fun q : ℝ × Space =>
        movingCurl (addressPath M (M.scaleData w) n m) ((M.scaleData w).δ n)
          (q.1 - 1 - (n : ℝ)) q.2) p‖ ≤
        C * ((M.scaleData w).b n / (M.scaleData w).δ n ^ k) := by
  obtain ⟨C, hC, hbound⟩ := scaledCurl_derivative_bound k
  refine ⟨C, hC, ?_⟩
  intro n m p
  let d := M.scaleData w
  let η := (d.δ n)⁻¹ • addressDisplacement M d n m
  let ξ := (d.b n)⁻¹ • addressDisplacement M d n m
  have hsm : ContDiff ℝ (⊤ : ℕ∞) (Function.uncurry (scaledCurl η ξ)) := by
    change ContDiff ℝ (⊤ : ℕ∞)
      ((fun p : (Space × Space) × (ℝ × Space) => scaledCurl p.1.1 p.1.2 p.2.1 p.2.2) ∘
        (fun q : ℝ × Space => ((η, ξ), q)))
    exact scaledCurl_joint_smooth.comp (contDiff_const.prodMk contDiff_id)
  have heq : (fun q : ℝ × Space => movingCurl (addressPath M d n m) (d.δ n)
      (q.1 - 1 - (n : ℝ)) q.2) = (fun q : ℝ × Space =>
      d.b n • scaledCurl η ξ (q.1 - (1 + (n : ℝ)))
        ((d.δ n)⁻¹ • (q.2 - addressCenter d n m))) := by
    funext q
    change movingCurl (fun s => addressCenter d n m + θ s • addressDisplacement M d n m)
      (d.δ n) _ _ = _
    rw [movingCurl_normalized _ _ (d.delta_pos n).ne' (d.b_pos n).ne']
    change d.b n • scaledCurl η ξ (q.1 - 1 - (n : ℝ)) _ = _
    congr 2
    ring
  rw [heq]
  have hparam := address_parameters_bound M w n m
  have hbnd := norm_iteratedFDeriv_scaled hsm (hbound η ξ hparam.1 hparam.2)
    ((one_le_inv₀ (d.delta_pos n)).mpr (d.delta_le_one n))
    (d.b n) (1 + (n : ℝ)) (addressCenter d n m) p
  convert hbnd using 1
  · rfl
  · change C * (d.b n / d.δ n ^ k) = _
    rw [abs_of_pos (d.b_pos n), inv_pow]
    ring

lemma stepVelocity_derivative_bound (M : Machine) (w : M.Input) (k : ℕ) :
    ∃ C : ℝ, 0 ≤ C ∧ ∀ n : ℕ, ∀ p : ℝ × Space,
      ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖ ≤
        C * ((M.scaleData w).b n / (M.scaleData w).δ n ^ (k + 1)) := by
  obtain ⟨C, hC, hb⟩ := addressCurl_derivative_bound M w k
  refine ⟨2 * C, by positivity, ?_⟩
  intro n p
  let d := M.scaleData w
  have hsm (m : ℕ) : ContDiff ℝ (⊤ : ℕ∞)
      (fun q : ℝ × Space => movingCurl (addressPath M d n m) (d.δ n)
        (q.1 - 1 - (n : ℝ)) q.2) := by
    change ContDiff ℝ (⊤ : ℕ∞)
      (Function.uncurry (movingCurl (addressPath M d n m) (d.δ n)) ∘
        (fun q : ℝ × Space => (q.1 - 1 - (n : ℝ), q.2)))
    exact (movingCurl_joint_smooth (addressPath_smooth M d n m) _).comp
      ((contDiff_fst.sub contDiff_const |>.sub contDiff_const).prodMk contDiff_snd)
  have hsum := iteratedFDeriv_fun_sum_apply (𝕜 := ℝ) (n := k) (x := p)
    (u := Finset.range (d.D n + 1)) (fun m _ => (hsm m |>.of_le
      (by exact_mod_cast (le_top : (k : ℕ∞) ≤ ⊤))).contDiffAt)
  change ‖iteratedFDeriv ℝ k (fun q : ℝ × Space => ∑ m ∈ Finset.range (d.D n + 1),
    movingCurl (addressPath M d n m) (d.δ n) (q.1 - 1 - (n : ℝ)) q.2) p‖ ≤ _
  rw [hsum]
  calc
    _ ≤ ∑ m ∈ Finset.range (d.D n + 1),
        ‖iteratedFDeriv ℝ k (fun q : ℝ × Space => movingCurl (addressPath M d n m)
          (d.δ n) (q.1 - 1 - (n : ℝ)) q.2) p‖ := norm_sum_le _ _
    _ ≤ ∑ m ∈ Finset.range (d.D n + 1), C * (d.b n / d.δ n ^ k) :=
      Finset.sum_le_sum (fun m _ => hb n m p)
    _ = ((d.D n : ℝ) + 1) * (C * (d.b n / d.δ n ^ k)) := by simp
    _ ≤ (2 * (d.δ n)⁻¹) * (C * (d.b n / d.δ n ^ k)) := by
      apply mul_le_mul_of_nonneg_right _ (mul_nonneg hC
        (div_nonneg (d.b_pos n).le (pow_nonneg (d.delta_nonneg n) k)))
      have hD : (d.D n : ℝ) = (d.δ n)⁻¹ := by rw [d.delta_eq_inv_D, inv_inv]
      rw [hD]
      have hi := (one_le_inv₀ (d.delta_pos n)).mpr (d.delta_le_one n)
      linarith
    _ = (2 * C) * (d.b n / d.δ n ^ (k + 1)) := by rw [pow_succ]; field_simp

end RapidForcing

end OAI