import OAI.MathematicalPhysics.AlternatingFlow.InitialNames

namespace OAI

section DecayBoundsDevelopment

open scoped BigOperators Topology ContDiff
open Filter
namespace AlternatingNS.Effective
attribute [local instance] Arithmetic.rationalCoding
open Bounds (readScale readScale_nonneg potential_decomposition norm_iterated_curl amplitude norm_comp_linear)

lemma potential_bound : ∃ C : (Machine × ℕ) × ℕ → ℕ, Computable C ∧ ∀ M N r n x,
    ‖iteratedFDeriv ℝ r (fun x => Spatial.cutoff x *
      Spatial.shearPotential (Construction.donorIndex n) (Construction.receiverIndex n) 0
        (LocalRule.write M N n) (LocalRule.signal M N n) x) x‖ ≤
        (C ((M,N),r) : ℝ) * (Scales.ε M.base N n + Scales.ε M.base N (n + 1) * readScale M N n ^ r) := by
  obtain ⟨sA, A, cA, ha⟩ := fixedPotential_scaled
  obtain ⟨sB, B, cB, hb⟩ := corePotential_scaled
  refine ⟨fun z => A ((), z.2) + B z,
    Primrec.nat_add.to_comp.comp
      (cA.comp ((Computable.const ()).pair Computable.snd)) cB, fun M N r n x => ?_⟩
  have hA : 0 ≤ (A ((),r) : ℝ) := Nat.cast_nonneg _
  have hB : 0 ≤ (B ((M,N),r) : ℝ) := Nat.cast_nonneg _
  simp only [Nat.cast_add]
  have hε : 0 ≤ Scales.ε M.base N (n + 1) := Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega)
  have hε' : Scales.ε M.base N (n + 1) ≤ Scales.ε M.base N n :=
    (Scales.ε_strictAnti M.base N (by have := M.base_ge_four; omega)).antitone (by omega)
  have h₁ := sA () n
  have h₂ := sB (M,N) n
  simp_rw [potential_decomposition]
  change ‖iteratedFDeriv ℝ r (fun x =>
    (Scales.ε M.base N n - Scales.ε M.base N (n + 1)) • Bounds.fixedPotential n x +
      Scales.ε M.base N (n + 1) • Bounds.corePotential M N n x) x‖ ≤ _
  have hs₁ : ContDiff ℝ ∞ (fun x =>
      (Scales.ε M.base N n - Scales.ε M.base N (n + 1)) • Bounds.fixedPotential n x) := h₁.const_smul _
  have hs₂ : ContDiff ℝ ∞ (fun x =>
      Scales.ε M.base N (n + 1) • Bounds.corePotential M N n x) := h₂.const_smul _
  rw [fun_iteratedFDeriv_add_apply
    (hs₁.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt
    (hs₂.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt]
  apply (norm_add_le _ _).trans
  rw [iteratedFDeriv_const_smul_apply' (h₁.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt,
    iteratedFDeriv_const_smul_apply' (h₂.of_le (WithTop.coe_le_coe.mpr le_top)).contDiffAt,
    norm_smul, norm_smul, Real.norm_eq_abs, Real.norm_eq_abs,
    abs_of_nonneg (sub_nonneg.mpr hε'), abs_of_nonneg hε]
  have haa : ‖iteratedFDeriv ℝ r (Bounds.fixedPotential n) x‖ ≤ (A ((),r) : ℝ) := by simpa using ha () r n x
  have hbb := hb (M,N) r n x
  have hscale := pow_nonneg (readScale_nonneg M N n) r
  calc
    _ ≤ Scales.ε M.base N n * (A ((),r) : ℝ) +
      Scales.ε M.base N (n + 1) * ((B ((M,N),r) : ℝ) * readScale M N n ^ r) := by
      exact add_le_add
        (mul_le_mul (by linarith) haa (norm_nonneg _) (by linarith))
        (mul_le_mul_of_nonneg_left hbb hε)
    _ ≤ _ := by nlinarith [mul_nonneg (show 0 ≤ Scales.ε M.base N n by linarith) hB,
      mul_nonneg hA (mul_nonneg hε hscale)]

lemma slot_estimate : ∃ C : (Machine × ℕ) × ℕ → ℕ, Computable C ∧ ∀ M N r n x,
    ‖iteratedFDeriv ℝ r (Construction.slot M N n) x‖ ≤
      (C ((M,N),r) : ℝ) * (Scales.ε M.base N n + Scales.ε M.base N (n + 1) * readScale M N n ^ (r + 1)) := by
  obtain ⟨C, hC, hc⟩ := potential_bound
  refine ⟨fun z => 2 * C (z.1,z.2+1),
    Primrec.nat_mul.to_comp.comp (Computable.const 2)
      (hC.comp (Computable.fst.pair (Computable.succ.comp Computable.snd))), fun M N r n x => ?_⟩
  have h := norm_iterated_curl (Construction.receiverIndex n) 0 _
    (Spatial.cutoff_smooth.mul (Spatial.shearPotential_smooth (Construction.donorIndex n)
      (Construction.receiverIndex n) 0 _ _
      (LocalRule.write_smooth M N n) (LocalRule.signal_smooth M N n))) r x
  apply h.trans
  push_cast
  nlinarith [hc M N (r+1) n x]

def readCost (z : (Machine × ℕ) × ℕ) : ℕ :=
  1 + ∑ n ∈ Finset.range z.2, z.1.1.base ^
    (Scales.s z.1.2 n + (z.2+1) * (Scales.s z.1.2 n + 1 + Scales.K z.1.2 n))

lemma readCost_computable : Computable readCost := by
  have hM : Computable (fun z : ((Machine × ℕ) × ℕ) × ℕ => z.1.1.1) :=
    Computable.fst.comp (Computable.fst.comp Computable.fst)
  have hN : Computable (fun z : ((Machine × ℕ) × ℕ) × ℕ => z.1.1.2) :=
    Computable.snd.comp (Computable.fst.comp Computable.fst)
  have hs : Computable (fun z : ((Machine × ℕ) × ℕ) × ℕ => Scales.s z.1.1.2 z.2) := exponent.to_comp.comp hN Computable.snd
  have hK : Computable (fun z : ((Machine × ℕ) × ℕ) × ℕ => Scales.K z.1.1.2 z.2) := capacity.to_comp.comp hN Computable.snd
  have hp : Computable₂ (fun z : (Machine × ℕ) × ℕ => fun n : ℕ => z.1.1.base ^ (Scales.s z.1.2 n + (z.2+1) * (Scales.s z.1.2 n + 1 + Scales.K z.1.2 n))) := nat_pow.to_comp.comp (base.to_comp.comp hM)
    (Primrec.nat_add.to_comp.comp hs (Primrec.nat_mul.to_comp.comp
      (Computable.succ.comp (Computable.snd.comp Computable.fst))
      (Primrec.nat_add.to_comp.comp (Computable.succ.comp hs) hK)))
  unfold readCost
  exact Primrec.nat_add.to_comp.comp (Computable.const 1)
    ((nat_sum_range hp).comp Computable.id Computable.snd)

lemma uniform_read_cost (M : Machine) (N r n : ℕ) :
    Scales.ε M.base N (n + 1) * readScale M N n ^ (r + 1) ≤
      (readCost ((M,N),r) : ℝ) * Scales.ε M.base N n := by
  have hb : (1 : ℝ) ≤ M.base := by have := M.base_ge_four; exact_mod_cast (by omega : 1 ≤ M.base)
  have hε (n : ℕ) : 0 < Scales.ε M.base N n :=
    Scales.ε_pos _ _ _ (by have := M.base_ge_four; omega)
  have hD : (1 : ℝ) ≤ readCost ((M,N),r) := by
    dsimp [readCost]; push_cast
    exact le_add_of_nonneg_right (Finset.sum_nonneg (by intros; positivity))
  have he : readScale M N n ^ (r + 1) =
      (M.base : ℝ) ^ ((r+1) * (Scales.s N n + 1 + Scales.K N n)) := by
    rw [readScale, ← pow_mul, Nat.mul_comm]
  by_cases hn : n < r
  · have hle : M.base ^ (Scales.s N n + (r+1) * (Scales.s N n + 1 + Scales.K N n)) ≤ readCost ((M,N),r) :=
      (Finset.single_le_sum (f := fun n => M.base ^ (Scales.s N n + (r+1) * (Scales.s N n + 1 + Scales.K N n)))
        (fun _ _ => Nat.zero_le _) (Finset.mem_range.mpr hn)).trans (Nat.le_add_left _ _)
    have hpow : ((M.base : ℝ) ^ Scales.s N n) ≠ 0 := ne_of_gt (pow_pos (zero_lt_one.trans_le hb) _)
    calc
      _ ≤ readScale M N n ^ (r+1) := by
        apply mul_le_of_le_one_left (pow_nonneg (readScale_nonneg M N n) _)
        simpa [Scales.ε, abs_of_nonneg (inv_nonneg.mpr (pow_nonneg (zero_le_one.trans hb) _))] using
          Bounds.inverse_power_bound M (Scales.s N (n+1))
      _ = (M.base : ℝ) ^ (Scales.s N n + (r+1) * (Scales.s N n + 1 + Scales.K N n)) * Scales.ε M.base N n := by
        rw [he, pow_add, Scales.ε]; field_simp
      _ ≤ _ := mul_le_mul_of_nonneg_right (by exact_mod_cast hle) (hε n).le
  · rw [he]
    exact (Scales.derivative_cost_bound M.base N r n (by have := M.base_ge_four; omega)
      (by omega)).trans (le_mul_of_one_le_left (hε n).le hD)

lemma slot_decay : ∃ C : (Machine × ℕ) × ℕ → ℕ, Computable C ∧ ∀ M N r n x,
    ‖iteratedFDeriv ℝ r (Construction.slot M N n) x‖ ≤ (C ((M,N),r) : ℝ) * Scales.ε M.base N n := by
  obtain ⟨C,hC,hc⟩ := slot_estimate
  refine ⟨fun z => C z * (1 + readCost z), Primrec.nat_mul.to_comp.comp hC
    (Primrec.nat_add.to_comp.comp (Computable.const 1) readCost_computable), fun M N r n x => ?_⟩
  apply (hc M N r n x).trans
  push_cast
  have h := mul_le_mul_of_nonneg_left (uniform_read_cost M N r n) (Nat.cast_nonneg (C ((M,N),r)) : (0 : ℝ) ≤ _)
  nlinarith

lemma loading_bound : ∃ C : (Machine × List ℕ) × ℕ → ℕ, Computable C ∧ ∀ M w r x,
    ‖iteratedFDeriv ℝ r (Construction.loading M w) x‖ ≤ C ((M,w),r) := by
  obtain ⟨hs,C,hC,hc⟩ := loadingPotential_scaled
  refine ⟨fun z => 2 * C (z.1,z.2+1), Primrec.nat_mul.to_comp.comp (Computable.const 2)
    (hC.comp (Computable.fst.pair (Computable.succ.comp Computable.snd))), fun M w r x => ?_⟩
  apply (norm_iterated_curl 1 0 _ (hs (M,w) 0) r x).trans
  have h := hc (M,w) (r+1) 0 x
  simp only [one_pow, mul_one] at h
  push_cast
  linarith

lemma piece_decay : ∃ C : (Machine × List ℕ) × ℕ → ℕ, Computable C ∧ ∀ M w r n x,
    ‖iteratedFDeriv ℝ r (Construction.piece M w n) x‖ ≤ (C ((M,w),r) : ℝ) * amplitude M w.length n := by
  obtain ⟨A,hA,ha⟩ := loading_bound
  obtain ⟨B,hB,hb⟩ := slot_decay
  refine ⟨fun z => A z + B ((z.1.1,z.1.2.length),z.2), Primrec.nat_add.to_comp.comp hA
    (hB.comp (((Computable.fst.comp Computable.fst).pair
      (Primrec.list_length.to_comp.comp (Computable.snd.comp Computable.fst))).pair Computable.snd)), fun M w r n x => ?_⟩
  cases n with
  | zero =>
    simp only [Construction.piece, amplitude, mul_one, Nat.cast_add]
    exact (ha M w r x).trans (le_add_of_nonneg_right (Nat.cast_nonneg _))
  | succ n =>
    simp only [Construction.piece, amplitude, Nat.cast_add]
    exact (hb M w.length r n x).trans (mul_le_mul_of_nonneg_right
      (le_add_of_nonneg_left (Nat.cast_nonneg _)) (Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega)))

lemma pulse_scaled : Scaled (fun _ : Unit => fun _ => 1) (fun _ _ => Profiles.pulse) := by
  have hclock := transition_scaled.affine (fun _ _ => zero_le_one) (fun _ _ => 2)
    (fun _ _ => -1/2) (fun _ => 2) (Computable.const 2) (by intros; norm_num)
  have he : (fun t => Real.smoothTransition (2 * t + -1/2)) = Profiles.clock := by
    funext t; unfold Profiles.clock; congr 1; ring
  obtain ⟨hs,C,hC,hc⟩ := hclock
  refine ⟨fun _ _ => Profiles.pulse_smooth, fun z => C ((),z.2+1),
    hC.comp ((Computable.const ()).pair (Computable.succ.comp Computable.snd)), fun a r n x => ?_⟩
  rw [he] at hc
  change ‖iteratedFDeriv ℝ r (deriv Profiles.clock) x‖ ≤ _
  simpa [one_pow, norm_iteratedFDeriv_eq_norm_iteratedDeriv, iteratedDeriv_succ'] using hc () (r+1) 0 x

lemma pulsePiece_decay : ∃ C : (Machine × List ℕ) × ℕ → ℕ, Computable C ∧ ∀ M w r n z,
    ‖iteratedFDeriv ℝ r (Bounds.pulsePiece M w n) z‖ ≤ (C ((M,w),r) : ℝ) * amplitude M w.length n := by
  obtain ⟨_,A,hA,ha⟩ := pulse_scaled
  obtain ⟨B,hB,hb⟩ := piece_decay
  let C := fun z : (Machine × List ℕ) × ℕ => ∑ i ∈ Finset.range (z.2+1), z.2.choose i * A ((),i) * B (z.1,z.2-i)
  have hi : Computable₂ (fun z : (Machine × List ℕ) × ℕ => fun i : ℕ => z.2.choose i * A ((),i) * B (z.1,z.2-i)) :=
    Primrec.nat_mul.to_comp.comp (Primrec.nat_mul.to_comp.comp
      (choose.to_comp.comp (Computable.snd.comp Computable.fst) Computable.snd)
      (hA.comp ((Computable.const ()).pair Computable.snd)))
      (hB.comp ((Computable.fst.comp Computable.fst).pair
        (Primrec.nat_sub.to_comp.comp (Computable.snd.comp Computable.fst) Computable.snd)))
  refine ⟨C, (nat_sum_range hi).comp Computable.id (Computable.succ.comp Computable.snd), fun M w r n z => ?_⟩
  have hp (i : ℕ) :
      ‖iteratedFDeriv ℝ i (fun z : ℝ × Space => Profiles.pulse (z.1 - n)) z‖ ≤ (A ((),i) : ℝ) := by
    apply (norm_comp_linear (fun t => Profiles.pulse (t - n))
      (Profiles.pulse_smooth.comp (contDiff_id.sub contDiff_const)) (ContinuousLinearMap.fst ℝ ℝ Space)
      i z).trans
    rw [iteratedFDeriv_comp_sub]
    have h₁ : ‖iteratedFDeriv ℝ i Profiles.pulse (z.1 - n)‖ ≤ (A ((),i) : ℝ) := by simpa using ha () i 0 (z.1 - n)
    have h₂ := pow_le_pow_left₀ (norm_nonneg _) (ContinuousLinearMap.norm_fst_le ℝ ℝ Space) i
    simpa only [one_pow, mul_one, ContinuousLinearMap.coe_fst', ContinuousLinearMap.coe_snd'] using mul_le_mul h₁ h₂ (pow_nonneg (norm_nonneg _) _) (Nat.cast_nonneg (A ((),i)))
  have hw (i : ℕ) :
      ‖iteratedFDeriv ℝ i (fun z : ℝ × Space => Construction.piece M w n z.2) z‖ ≤
        (B ((M,w),i) : ℝ) * amplitude M w.length n := by
    apply (norm_comp_linear (Construction.piece M w n) (Construction.piece_smooth M w n)
      (ContinuousLinearMap.snd ℝ ℝ Space) i z).trans
    have h₁ := hb M w i n z.2
    have h₂ := pow_le_pow_left₀ (norm_nonneg _) (ContinuousLinearMap.norm_snd_le ℝ ℝ Space) i
    simpa only [one_pow, mul_one, ContinuousLinearMap.coe_fst', ContinuousLinearMap.coe_snd'] using mul_le_mul h₁ h₂ (pow_nonneg (norm_nonneg _) _)
      (mul_nonneg (Nat.cast_nonneg (B ((M,w),i))) (Bounds.amplitude_nonneg M w.length n))
  apply (norm_iteratedFDeriv_smul_le
    (Profiles.pulse_smooth.comp (contDiff_fst.sub contDiff_const))
    ((Construction.piece_smooth M w n).comp contDiff_snd) z (WithTop.coe_le_coe.mpr le_top)).trans
  calc
    _ ≤ ∑ i ∈ Finset.range (r + 1), (r.choose i : ℝ) * (A ((),i) : ℝ) * ((B ((M,w),r-i) : ℝ) * amplitude M w.length n) := by
      apply Finset.sum_le_sum
      intro i _
      apply mul_le_mul _ (hw (r - i)) (norm_nonneg _) (mul_nonneg (Nat.cast_nonneg _) (Nat.cast_nonneg (A ((),i))))
      exact mul_le_mul_of_nonneg_left (hp i) (Nat.cast_nonneg _)
    _ = (C ((M,w),r) : ℝ) * amplitude M w.length n := by
      simp only [C, Nat.cast_sum, Nat.cast_mul, Finset.sum_mul, mul_assoc]

lemma epsilon_small (M : Machine) (N n : ℕ) : Scales.ε M.base N n ≤ (1/8:ℝ)^n := by
  have hb : (2 : ℝ) ≤ M.base := by exact_mod_cast (le_trans (by decide : 2 ≤ 4) M.base_ge_four)
  have hs : 3*n ≤ Scales.s N n := by have := Scales.s_lower N n; nlinarith
  unfold Scales.ε
  have hp : (8:ℝ)^n ≤ (M.base:ℝ)^Scales.s N n := by
    calc
      _ = (2:ℝ)^(3*n) := by rw [pow_mul]; norm_num
      _ ≤ (2:ℝ)^Scales.s N n := pow_le_pow_right₀ (by norm_num) hs
      _ ≤ _ := pow_le_pow_left₀ (by norm_num) hb _
  simpa only [one_div, inv_pow] using inv_anti₀ (by positivity : (0:ℝ) < 8^n) hp

lemma weighted_epsilon (M : Machine) (N J n : ℕ) :
    (1+(n:ℝ))^J * Scales.ε M.base N n ≤ 4 * J.factorial * (1/2:ℝ)^n := by
  have hpoly : (1+(n:ℝ))^J ≤ (J.factorial:ℝ) * (4 * 4^n) := by
    have h := (div_le_iff₀ (by positivity : (0:ℝ) < J.factorial)).mp
      (Real.pow_div_factorial_le_exp (1+(n:ℝ)) (by positivity) J)
    have he : Real.exp (1+(n:ℝ)) ≤ 4 * 4^n := by
      rw [Real.exp_add, show (n:ℝ) = n*1 by ring, Real.exp_nat_mul]
      exact mul_le_mul (Real.exp_one_lt_three.le.trans (by norm_num))
        (pow_le_pow_left₀ (Real.exp_pos _).le (Real.exp_one_lt_three.le.trans (by norm_num)) n)
        (by positivity) (by norm_num)
    exact h.trans (by nlinarith [mul_le_mul_of_nonneg_right he (Nat.cast_nonneg J.factorial : (0:ℝ) ≤ _)])
  calc
    _ ≤ ((J.factorial:ℝ) * (4 * 4^n)) * (1/8:ℝ)^n :=
      mul_le_mul hpoly (epsilon_small M N n) (Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega)) (by positivity)
    _ = _ := by rw [mul_assoc _ (4*4^n), mul_assoc 4, ← mul_pow]; norm_num; ring

lemma weighted_amplitude_sum (M : Machine) (N J : ℕ) :
    (∑' n : ℕ, (1+(n:ℝ))^J * amplitude M N n) ≤ (1 + 8 * 2^J * J.factorial : ℕ) := by
  have hs := Bounds.weighted_amplitude_summable M N J
  rw [hs.tsum_eq_zero_add]
  simp only [amplitude, Nat.cast_zero, add_zero, one_pow, mul_one]
  have hc : ∀ n : ℕ, (1+(n+1:ℕ))^J * amplitude M N (n+1) ≤
      (2:ℝ)^J * (4 * J.factorial * (1/2:ℝ)^n) := by
    intro n
    simp only [amplitude, Nat.cast_add, Nat.cast_one]
    calc
      _ ≤ (2*(1+(n:ℝ)))^J * Scales.ε M.base N n := mul_le_mul_of_nonneg_right
        (pow_le_pow_left₀ (by positivity) (by nlinarith) J)
        (Scales.ε_nonneg _ _ _ (by have := M.base_ge_four; omega))
      _ ≤ _ := by rw [mul_pow, mul_assoc]; exact mul_le_mul_of_nonneg_left (weighted_epsilon M N J n) (by positivity)
  have h := (hs.comp_injective Nat.succ_injective).tsum_le_tsum hc
    ((summable_geometric_two.mul_left (4*(J.factorial:ℝ))).mul_left ((2:ℝ)^J))
  simp only [tsum_mul_left, tsum_geometric_two, amplitude, Nat.cast_add, Nat.cast_one] at h
  push_cast
  nlinarith

end AlternatingNS.Effective

end DecayBoundsDevelopment

end OAI