import OAI.MathematicalPhysics.RapidForcing.RawMachine
import OAI.MathematicalPhysics.RapidForcing.ScaledSyntax

namespace OAI

section
open scoped BigOperators Topology ENNReal ContDiff
open Set Filter
namespace RapidForcing
lemma addressCurl_jetBound (M : Machine) (w : M.Input) (k : ℕ) :
    ∀ 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‖ ≤
        (EffectiveProfile.Formula.curlJetBound k : ℝ) * ((M.scaleData w).b n / (M.scaleData w).δ n ^ k) := by
  let C : ℝ := EffectiveProfile.Formula.curlJetBound k
  have hbound := EffectiveProfile.Formula.curlJetBound_spec k
  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_jetBound (M : Machine) (w : M.Input) (k : ℕ) :
    ∀ n : ℕ, ∀ p : ℝ × Space,
      ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖ ≤
        (2 * (EffectiveProfile.Formula.curlJetBound k : ℝ)) * ((M.scaleData w).b n / (M.scaleData w).δ n ^ (k + 1)) := by
  let C : ℝ := EffectiveProfile.Formula.curlJetBound k
  have hC : 0 ≤ C := by dsimp [C]; exact_mod_cast EffectiveProfile.Formula.curlJetBound_nonneg k
  have hb := addressCurl_jetBound M w k
  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

namespace ScaleData
variable (d : ScaleData)

lemma s_quadratic_lower (n : ℕ) : (n+4)*n+n ≤ d.s n := by
  have h := Nat.two_mul_sq_add_one_le_two_pow_two_mul (n+2)
  have h' : 2 ^ (2*(n+2)) ≤ 2 ^ ((n+2)^2) :=
    Nat.pow_le_pow_right (by decide) (by nlinarith)
  have h'' : 2 ^ ((n+2)^2) ≤ d.s n := by
    unfold s
    exact Nat.le_mul_of_pos_left _ d.C_pos
  nlinarith

lemma coefficient_tail_bound (J p n : ℕ) (hn : max J p ≤ n) :
    ((n : ℝ)+4)^J * (d.b n / d.δ n^p) ≤ (1/2:ℝ)^n := by
  have hJ : J ≤ n := (le_max_left J p).trans hn
  have hp : p ≤ n := (le_max_right J p).trans hn
  have hexp : (n+4)*J+n ≤ d.s n :=
    (Nat.add_le_add_right (Nat.mul_le_mul_left _ hJ) _).trans (d.s_quadratic_lower n)
  have hpoly : ((n : ℝ)+4)^J ≤ (2:ℝ)^((n+4)*J) := by
    rw [pow_mul]
    apply pow_le_pow_left₀ (by positivity)
    exact_mod_cast (Nat.lt_two_pow_self (n := n+4)).le
  have hdelta : d.δ n ≤ (1/2:ℝ)^((n+4)*J+n) :=
    pow_le_pow_of_le_one (by norm_num) (by norm_num) hexp
  calc
    _ ≤ ((n : ℝ)+4)^J * d.δ n :=
      mul_le_mul_of_nonneg_left (d.scaled_b_le_delta n p (by omega)) (by positivity)
    _ ≤ (2:ℝ)^((n+4)*J) * (1/2:ℝ)^((n+4)*J+n) :=
      mul_le_mul hpoly hdelta (d.delta_nonneg n) (by positivity)
    _ = _ := by rw [pow_add, ← mul_assoc, ← mul_pow]; norm_num

def coefficientBound (J p : ℕ) : ℚ :=
  (∑ n ∈ Finset.range (max J p), ((n:ℚ)+4)^J * (d.bQ n / d.δQ n^p)) + 2

lemma coefficientBound_nonneg (J p : ℕ) : 0 ≤ d.coefficientBound J p := by
  have h : ∀ n : ℕ, (0:ℚ) ≤ ((n:ℚ)+4)^J * (d.bQ n / d.δQ n^p) := by
    intro n
    have hd : (0:ℚ) ≤ d.δQ n := by unfold δQ; positivity
    have hb : (0:ℚ) ≤ d.bQ n := by unfold bQ δQ; positivity
    positivity
  unfold coefficientBound
  exact add_nonneg (Finset.sum_nonneg (fun n _ => h n)) (by norm_num)

lemma coefficient_sum_le (J p N : ℕ) :
    (∑ n ∈ Finset.range N, ((n:ℝ)+4)^J * (d.b n / d.δ n^p)) ≤
      (d.coefficientBound J p : ℝ) := by
  let a : ℕ → ℝ := fun n => ((n:ℝ)+4)^J * (d.b n / d.δ n^p)
  have ha : ∀ n, 0 ≤ a n := fun n => mul_nonneg (by positivity)
    (div_nonneg (d.b_pos n).le (pow_nonneg (d.delta_nonneg n) _))
  have hlo : (∑ n ∈ (Finset.range N).filter (fun n => n < max J p), a n) ≤
      ∑ n ∈ Finset.range (max J p), a n := by
    apply Finset.sum_le_sum_of_subset_of_nonneg
    · intro n hn
      exact Finset.mem_range.mpr (Finset.mem_filter.mp hn).2
    · exact fun n _ _ => ha n
  have hhi : (∑ n ∈ (Finset.range N).filter (fun n => ¬ n < max J p), a n) ≤ 2 := by
    apply (Finset.sum_le_sum (fun n hn => d.coefficient_tail_bound J p n
      (by have := (Finset.mem_filter.mp hn).2; omega))).trans
    apply le_trans _ (sum_geometric_two_le N)
    exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _)
      (fun n _ _ => by positivity)
  have h := add_le_add hlo hhi
  rw [Finset.sum_filter_add_sum_filter_not] at h
  simpa only [coefficientBound, Rat.cast_add, Rat.cast_sum, Rat.cast_mul, Rat.cast_pow,
    Rat.cast_div, Rat.cast_natCast, Rat.cast_ofNat, ScaleData.cast_bQ, ScaleData.cast_deltaQ] using h

end ScaleData

open EffectiveProfile.Formula in
lemma loadingVelocity_jetBound (M : Machine) (w : M.Input) (k : ℕ) (p : ℝ × Space) :
    ‖iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p‖ ≤
      (curlJetBound k : ℝ) := by
  let v := vec (-1) ((M.scaleData w).δ 0 * (M.initialDigit w : ℝ)) 0
  have hv : ‖v‖ ≤ 2 := by
    have hy := initial_coordinate_mem M w
    have hcoord : ∀ i : Fin 3, |v i| ≤ 1 := by
      intro i
      fin_cases i <;> dsimp [v, vec]
      · norm_num
      · exact (abs_le.mpr ⟨by linarith [hy.1], hy.2.le⟩)
      · norm_num
    simpa only [mul_one] using norm_le_two_mul_of_coord_le zero_le_one hcoord
  have he : Function.uncurry (loadingVelocity M w) = Function.uncurry (scaledCurl v v) := by
    funext q
    have h := movingCurl_normalized (0:Space) v (δ := 1) (b := 1) (by norm_num) (by norm_num) q.1 q.2
    change movingCurl (fun s => θ s • v) 1 q.1 q.2 = scaledCurl v v q.1 q.2
    simpa only [zero_add, inv_one, one_smul, sub_zero] using h
  rw [he]
  exact curlJetBound_spec k v v hv hv p

open EffectiveProfile.Formula in
lemma loadingVelocity_weighted_jetBound (M : Machine) (w : M.Input) (J k : ℕ) (p : ℝ × Space) :
    (1+‖p‖)^J * ‖iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p‖ ≤
      4^J * (curlJetBound k : ℝ) := by
  by_cases hp : p ∈ tsupport (Function.uncurry (loadingVelocity M w))
  · have hs := loadingVelocity_joint_tsupport M w hp
    have hn : ‖p‖ ≤ 3 := by
      change max ‖p.1‖ ‖p.2‖ ≤ 3
      apply max_le
      · rw [Real.norm_eq_abs, abs_of_nonneg hs.1.1]; linarith [hs.1.2]
      · exact norm_le_three_of_mem_K hs.2
    exact mul_le_mul (pow_le_pow_left₀ (by positivity) (by linarith) J)
      (loadingVelocity_jetBound M w k p) (norm_nonneg _) (by positivity)
  · have hz : iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p = 0 :=
      image_eq_zero_of_notMem_tsupport (fun h => hp (tsupport_iteratedFDeriv_subset k h))
    rw [hz, norm_zero, mul_zero]
    exact mul_nonneg (by positivity) (by exact_mod_cast curlJetBound_nonneg k)

open EffectiveProfile.Formula in
lemma stepVelocity_weighted_jetBound (M : Machine) (w : M.Input) (J k n : ℕ) (p : ℝ × Space) :
    (1+‖p‖)^J * ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖ ≤
      (2 * (curlJetBound k : ℝ)) * (((n:ℝ)+4)^J *
        ((M.scaleData w).b n / (M.scaleData w).δ n^(k+1))) := by
  by_cases hp : p ∈ tsupport (Function.uncurry (stepVelocity M w n))
  · have hn := norm_le_slot (stepVelocity_joint_tsupport M w n hp)
    calc
      _ ≤ ((n:ℝ)+4)^J * ((2 * (curlJetBound k : ℝ)) *
          ((M.scaleData w).b n / (M.scaleData w).δ n^(k+1))) :=
        mul_le_mul (pow_le_pow_left₀ (by positivity) (by linarith) _) (stepVelocity_jetBound M w k n p)
          (norm_nonneg _) (by positivity)
      _ = _ := by ring
  · have hz : iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p = 0 :=
      image_eq_zero_of_notMem_tsupport (fun h => hp (tsupport_iteratedFDeriv_subset k h))
    rw [hz, norm_zero, mul_zero]
    have hC : (0:ℝ) ≤ curlJetBound k := by exact_mod_cast curlJetBound_nonneg k
    have hd := (M.scaleData w).delta_nonneg n
    have hb := (M.scaleData w).b_pos n
    positivity

def velocityJetBound (d : ScaleData) (J k : ℕ) : ℚ :=
  EffectiveProfile.Formula.curlJetBound k * (4^J + 2*d.coefficientBound J (k+1))

lemma velocityJetBound_nonneg (d : ScaleData) (J k : ℕ) : 0 ≤ velocityJetBound d J k :=
  mul_nonneg (EffectiveProfile.Formula.curlJetBound_nonneg k)
    (add_nonneg (by positivity) (mul_nonneg (by norm_num) (d.coefficientBound_nonneg J (k+1))))

lemma addressedVelocity_weighted_jetBound (M : Machine) (w : M.Input) (J k : ℕ) (p : ℝ × Space) :
    (1+‖p‖)^J * ‖iteratedFDeriv ℝ k (Function.uncurry (addressedVelocity M w)) p‖ ≤
      (velocityJetBound (M.scaleData w) J k : ℝ) := by
  obtain ⟨N, hN⟩ := exists_nat_gt p.1
  have he : Function.uncurry (addressedVelocity M w) =ᶠ[𝓝 p]
      fun q : ℝ × Space => loadingVelocity M w q.1 q.2 +
        ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2 := by
    have hopen : IsOpen {q : ℝ × Space | q.1 < (N : ℝ) + 1} :=
      isOpen_lt continuous_fst continuous_const
    have ho : ∀ᶠ q : ℝ × Space in 𝓝 p, q.1 < (N : ℝ) + 1 :=
      hopen.mem_nhds (by change p.1 < (N : ℝ) + 1; linarith)
    filter_upwards [ho] with q hq
    simpa only [Function.uncurry, Pi.add_apply, Finset.sum_apply] using
      congrFun (addressedVelocity_eq_finite M w N hq) q.2
  have hk := finite_order k
  have hload : ContDiffAt ℝ k (Function.uncurry (loadingVelocity M w)) p :=
    ((loadingVelocity_smooth M w).of_le hk).contDiffAt
  have hstep (n : ℕ) : ContDiffAt ℝ k (Function.uncurry (stepVelocity M w n)) p :=
    ((stepVelocity_smooth M w n).of_le hk).contDiffAt
  have hsplit : iteratedFDeriv ℝ k
      (fun q : ℝ × Space => loadingVelocity M w q.1 q.2 +
        ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2) p =
      iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p +
        ∑ n ∈ Finset.range N,
          iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p := by
    calc
      _ = iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p +
          iteratedFDeriv ℝ k (fun q : ℝ × Space =>
            ∑ n ∈ Finset.range N, stepVelocity M w n q.1 q.2) p :=
        fun_iteratedFDeriv_add_apply hload (ContDiffAt.sum (s := Finset.range N) (fun n _ => hstep n))
      _ = _ := congrArg (_ + ·) (iteratedFDeriv_fun_sum_apply (fun n _ => hstep n))
  let C : ℝ := EffectiveProfile.Formula.curlJetBound k
  have hC : 0 ≤ C := by dsimp [C]; exact_mod_cast EffectiveProfile.Formula.curlJetBound_nonneg k
  let d := M.scaleData w
  rw [(he.iteratedFDeriv ℝ k).eq_of_nhds, hsplit]
  calc
    _ ≤ (1+‖p‖)^J * (‖iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p‖ +
        ∑ n ∈ Finset.range N, ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖) := by
      apply mul_le_mul_of_nonneg_left _ (by positivity)
      exact (norm_add_le _ _).trans (add_le_add le_rfl (norm_sum_le _ _))
    _ = (1+‖p‖)^J * ‖iteratedFDeriv ℝ k (Function.uncurry (loadingVelocity M w)) p‖ +
        ∑ n ∈ Finset.range N, (1+‖p‖)^J *
          ‖iteratedFDeriv ℝ k (Function.uncurry (stepVelocity M w n)) p‖ := by
      rw [mul_add, Finset.mul_sum]
    _ ≤ 4^J*C + ∑ n ∈ Finset.range N, 2*C * (((n:ℝ)+4)^J * (d.b n / d.δ n^(k+1))) :=
      add_le_add (loadingVelocity_weighted_jetBound M w J k p)
        (Finset.sum_le_sum (fun n _ => stepVelocity_weighted_jetBound M w J k n p))
    _ = 4^J*C + 2*C * ∑ n ∈ Finset.range N, ((n:ℝ)+4)^J * (d.b n / d.δ n^(k+1)) := by
      rw [Finset.mul_sum]
    _ ≤ 4^J*C + 2*C * (d.coefficientBound J (k+1) : ℝ) :=
      add_le_add le_rfl (mul_le_mul_of_nonneg_left (d.coefficient_sum_le J (k+1) N) (by positivity))
    _ = _ := by simp only [velocityJetBound, Rat.cast_mul, Rat.cast_add, Rat.cast_pow, Rat.cast_ofNat]; dsimp [C,d]; ring

end RapidForcing

end

end OAI