import OAI.MathematicalPhysics.AlternatingFlow.ExpNames

namespace OAI

section ProfileNamesDevelopment

open scoped BigOperators Topology ContDiff
open Filter

namespace AlternatingNS.Effective
attribute [local instance] Arithmetic.rationalCoding

lemma rat_max : Primrec₂ (fun x y : ℚ => max x y) :=
  (Primrec.ite Arithmetic.rat_le Primrec.snd Primrec.fst).of_eq (by intro z; simp [max_def])

lemma Named.inv_of_lower {A : Type*} [Primcodable A] {f : A → ℝ}
    (hf : Named f) (b : A → ℚ) (hb : Computable b) (hpos : ∀ x, 0 < b x)
    (hlower : ∀ x, (b x : ℝ) ≤ f x) : Named (fun x => (f x)⁻¹) := by
  obtain ⟨a,ha,he⟩ := hf
  let c : A × ℕ → ℚ := fun z => max (b z.1) (a z)
  have hc : Computable c := rat_max.to_comp.comp (hb.comp Computable.fst) ha
  apply Named.of_certificate _ (fun z => (c z)⁻¹)
    (fun z => (b z.1)⁻¹ ^ 2 * tolerance z.2)
    (Arithmetic.rat_inv.to_comp.comp hc)
    (Arithmetic.rat_mul.to_comp.comp
      (Arithmetic.rat_pow.to_comp.comp (Arithmetic.rat_inv.to_comp.comp (hb.comp Computable.fst))
        (Computable.const 2)) (tolerance_primrec.to_comp.comp Computable.snd))
  · intro x n
    have hb₀ : (0 : ℝ) < b x := by exact_mod_cast hpos x
    have hc₀ : (b x : ℝ) ≤ c (x,n) := by exact_mod_cast (le_max_left (b x) (a (x,n)))
    have ha₀ : (a (x,n) : ℝ) ≤ c (x,n) := by exact_mod_cast (le_max_right (b x) (a (x,n)))
    have hce : |f x - (c (x,n) : ℝ)| ≤ tolerance n := by
      rw [abs_le]
      have h := abs_le.mp (he x n)
      refine ⟨?_, by linarith⟩
      have hmax : (c (x,n) : ℝ) ≤ f x + (tolerance n : ℝ) := by
        dsimp only [c]; push_cast
        apply max_le
        · exact (hlower x).trans (le_add_of_nonneg_right (tolerance_pos n).le)
        · linarith
      linarith
    have hfx : 0 < f x := hb₀.trans_le (hlower x)
    have hcx : 0 < (c (x,n) : ℝ) := hb₀.trans_le hc₀
    push_cast
    rw [inv_sub_inv hfx.ne' hcx.ne', abs_div, abs_mul,
      abs_of_pos hfx, abs_of_pos hcx, abs_sub_comm]
    calc
      _ ≤ (tolerance n : ℝ) / ((b x : ℝ) * (b x : ℝ)) :=
        div_le_div₀ (tolerance_pos n).le hce (mul_pos hb₀ hb₀)
          (mul_le_mul (hlower x) hc₀ hb₀.le hfx.le)
      _ = _ := by ring
  · intro x
    convert tolerance_tendsto.const_mul ((b x : ℝ)⁻¹ ^ 2) using 1 <;>
      simp only [Rat.cast_mul, Rat.cast_pow, Rat.cast_inv, inv_pow, mul_zero]

lemma Named.sum_range {A : Type*} [Primcodable A] {f : A × ℕ → ℝ}
    (hf : Named f) (N : A → ℕ) (hN : Computable N) :
    Named (fun x => ∑ i ∈ Finset.range (N x), f (x,i)) := by
  obtain ⟨a,ha,he⟩ := hf
  have hs : Computable₂ (fun z : A × ℕ => fun i : ℕ => a ((z.1,i),z.2)) :=
    ha.comp (((Computable.fst.comp Computable.fst).pair Computable.snd).pair
      (Computable.snd.comp Computable.fst))
  apply Named.of_certificate _ (fun z => ∑ i ∈ Finset.range (N z.1), a ((z.1,i),z.2))
    (fun z => (N z.1 : ℚ) * tolerance z.2)
    ((rat_sum_range hs).comp Computable.id (hN.comp Computable.fst))
    (Arithmetic.rat_mul.to_comp.comp (Arithmetic.rat_natCast.to_comp.comp (hN.comp Computable.fst))
      (tolerance_primrec.to_comp.comp Computable.snd))
  · intro x n; push_cast; rw [← Finset.sum_sub_distrib]
    apply (Finset.abs_sum_le_sum_abs _ _).trans
    calc
      _ ≤ ∑ i ∈ Finset.range (N x), (tolerance n : ℝ) := Finset.sum_le_sum (fun i _ => he (x,i) n)
      _ = _ := by simp
  · intro x; push_cast
    simpa only [inv_pow, mul_zero] using tolerance_tendsto.const_mul (N x : ℝ)

lemma rho_named : Named (fun q : ℚ => expNegInvGlue (q : ℝ)) := by
  have hn := exp_named.comp (Arithmetic.rat_neg.comp Arithmetic.rat_inv |>.to_comp)
  exact (Named.ite (fun q : ℚ => q ≤ 0)
    (Arithmetic.rat_le.decide.to_comp.comp Computable.id (Computable.const 0))
    (Named.const 0) hn).congr (by intro q; simp [expNegInvGlue])

lemma transition_named : Named (fun q : ℚ => Real.smoothTransition (q : ℝ)) := by
  have h₂ := rho_named.comp (Arithmetic.rat_sub.to_comp.comp (Computable.const 1) Computable.id)
  have hd := rho_named.add h₂
  have hi := hd.inv_of_lower (fun _ => 1/9) (Computable.const _) (by intro; norm_num)
    (by intro q; simpa [Function.comp_def] using Quantitative.transition_denom_lower (q : ℝ))
  exact (rho_named.mul hi).congr (by intro q; simp [Real.smoothTransition, div_eq_mul_inv])

lemma jet_one_lipschitz {f : ℝ → ℝ} (hf : ContDiff ℝ ∞ f) (B : ℕ)
    (hB : ∀ x, ‖iteratedFDeriv ℝ 1 f x‖ ≤ B) (x y : ℝ) :
    |f x - f y| ≤ (B : ℝ) * |x-y| := by
  have h : ∀ x, ‖deriv f x‖ ≤ (B : ℝ) := by
    intro z
    simpa only [norm_iteratedFDeriv_eq_norm_iteratedDeriv, iteratedDeriv_one] using hB z
  simpa only [Real.norm_eq_abs] using Convex.norm_image_sub_le_of_norm_deriv_le
    (fun z (_ : z ∈ Set.univ) => hf.differentiable (by simp) z) (fun z _ => h z)
    (convex_univ : Convex ℝ (Set.univ : Set ℝ)) (Set.mem_univ y) (Set.mem_univ x)

lemma Named.transition {A : Type*} [Primcodable A] {f : A → ℝ} (hf : Named f) :
    Named (fun a => Real.smoothTransition (f a)) := by
  apply Named.apply_lipschitz (fun _ => Real.smoothTransition)
    (fun _ => (Quantitative.transitionBound 1 : ℚ)) (Computable.const _) (fun _ => by positivity)
    (fun _ x y => ?_) (transition_named.comp Computable.snd) hf
  simpa only [Rat.cast_natCast] using jet_one_lipschitz Real.smoothTransition.contDiff
    (Quantitative.transitionBound 1) (Quantitative.transition_jet_bound 1) x y

end AlternatingNS.Effective

end ProfileNamesDevelopment

end OAI