import OAI.MathematicalPhysics.AlternatingFlow.CertifiedBounds
import OAI.MathematicalPhysics.AlternatingFlow.TypedPrograms
import OAI.MathematicalPhysics.AlternatingFlow.JetNames

namespace OAI

section JetProgramsDevelopment

open scoped BigOperators Topology ContDiff
namespace AlternatingNS.Effective
attribute [local instance] Arithmetic.rationalCoding

variable {A : Type*}

def jetApprox (b : (A × RationalPoint) × ℕ → ℚ) (B : A × ℕ → ℕ)
    (a : A) : List (Fin 4) → RationalPoint → ℕ → ℚ
  | [], q, k => b ((a,q),k)
  | i::w, q, k =>
    let n := k+1+B (a,w.length+2)
    let m := k+2+n
    (jetApprox b B a w (shift i (tolerance n) q) m - jetApprox b B a w q m) / tolerance n

attribute [local irreducible] jetApprox

lemma jetApprox_computable [Primcodable A] (b : (A × RationalPoint) × ℕ → ℚ) (B : A × ℕ → ℕ)
    (hb : Computable b) (hB : Computable B) :
    Computable (fun z : A × List (Fin 4) × RationalPoint × ℕ => jetApprox b B z.1 z.2.1 z.2.2.1 z.2.2.2) := by
  let Q := A × List (Fin 4) × RationalPoint × ℕ
  let n (z : Q) := z.2.2.2+1+B (z.1,z.2.1.tail.length+2)
  let m (z : Q) := z.2.2.2+2+n z
  let left (z : Q) : Q := (z.1,z.2.1.tail,shift (z.2.1.head?.getD 0) (tolerance (n z)) z.2.2.1,m z)
  let right (z : Q) : Q := (z.1,z.2.1.tail,z.2.2.1,m z)
  have ha : Computable (fun z : Q => z.1) := Computable.fst
  have hw : Computable (fun z : Q => z.2.1) := Computable.fst.comp Computable.snd
  have hq : Computable (fun z : Q => z.2.2.1) := Computable.fst.comp (Computable.snd.comp Computable.snd)
  have hk : Computable (fun z : Q => z.2.2.2) := Computable.snd.comp (Computable.snd.comp Computable.snd)
  have ht : Computable (fun z : Q => z.2.1.tail) := Primrec.list_tail.to_comp.comp hw
  have hn : Computable n := Primrec.nat_add.to_comp.comp (Computable.succ.comp hk)
    (hB.comp (ha.pair (Primrec.nat_add.to_comp.comp (Computable.list_length.comp ht) (Computable.const 2))))
  have hm : Computable m := Primrec.nat_add.to_comp.comp
    (Primrec.nat_add.to_comp.comp hk (Computable.const 2)) hn
  have he : Computable (fun z : Q => tolerance (n z)) := tolerance_primrec.to_comp.comp hn
  have hl : Computable left := ha.pair (ht.pair ((shift_computable.comp
    ((Computable.option_getD (Primrec.list_head?.to_comp.comp hw) (Computable.const 0)).pair
      (he.pair hq))).pair hm))
  have hr : Computable right := ha.pair (ht.pair (hq.pair hm))
  have hbase : Computable (fun z : Q => b ((z.1,z.2.2.1),z.2.2.2)) :=
    hb.comp ((ha.pair hq).pair hk)
  have hop : Computable (fun z : Q × ℚ × ℚ => (z.2.1-z.2.2)/tolerance (n z.1)) :=
    Arithmetic.rat_div.to_comp.comp (Arithmetic.rat_sub.to_comp.comp
      (Computable.fst.comp Computable.snd) (Computable.snd.comp Computable.snd))
      (he.comp Computable.fst)
  obtain ⟨c,hc⟩ := binary_recursive_program (fun z : Q => z.2.1 = [])
    (Primrec.eq.decide.to_comp.comp hw (Computable.const []))
    (fun z => b ((z.1,z.2.2.1),z.2.2.2)) hbase left right hl hr
    (fun z : Q × ℚ × ℚ => (z.2.1-z.2.2)/tolerance (n z.1)) hop
  apply computable_of_execute c
  rintro ⟨a,w,q,k⟩
  induction w generalizing q k with
  | nil => simp [hc, jetApprox]
  | cons i w ih =>
    rw [hc]
    simp only [List.cons_ne_nil, ite_false]
    apply Part.mem_bind_iff.mpr
    refine ⟨_, ih (shift i (tolerance (n (a,i::w,q,k))) q) (m (a,i::w,q,k)), ?_⟩
    apply (Part.mem_map_iff _).mpr
    refine ⟨_, ih q (m (a,i::w,q,k)), ?_⟩
    rw [jetApprox]
    rfl

lemma jetApprox_error (f : A → ℝ × Space → ℝ) (sf : ∀ a, ContDiff ℝ ∞ (f a))
    (b : (A × RationalPoint) × ℕ → ℚ) (B : A × ℕ → ℕ)
    (hb : ∀ a q k, |f a (rationalPoint q) - (b ((a,q),k) : ℝ)| ≤ tolerance k)
    (hB : ∀ a r z, ‖iteratedFDeriv ℝ r (f a) z‖ ≤ B (a,r)) :
    ∀ a w q k, |wordJet (f a) w (rationalPoint q) - (jetApprox b B a w q k : ℝ)| ≤ tolerance k := by
  intro a w
  induction w with
  | nil => simpa only [wordJet, jetApprox] using hb a
  | cons i w ih =>
    intro q k
    let C := B (a,w.length+2)
    let n := k+1+C
    let m := k+2+n
    have hd := difference_error (wordJet_smooth (sf a) w) (Nat.cast_nonneg C)
      (fun z => (wordJet_bound (sf a) w 2 z).trans (by rw [Nat.add_comm 2 w.length]; exact hB a (w.length+2) z))
      (rationalPoint q) (direction i) (direction_norm i) (tolerance_pos n)
    have he : |(wordJet (f a) w (rationalPoint (shift i (tolerance n) q)) - wordJet (f a) w (rationalPoint q)) /
        (tolerance n : ℝ) -
        ((jetApprox b B a w (shift i (tolerance n) q) m - jetApprox b B a w q m) / tolerance n : ℚ)| ≤
          2 * (tolerance m : ℝ) / tolerance n := by
      push_cast
      rw [← sub_div, abs_div, abs_of_pos (tolerance_pos n)]
      apply div_le_div_of_nonneg_right _ (tolerance_pos n).le
      calc
        _ = |(wordJet (f a) w (rationalPoint (shift i (tolerance n) q)) - (jetApprox b B a w (shift i (tolerance n) q) m : ℝ)) -
          (wordJet (f a) w (rationalPoint q) - (jetApprox b B a w q m : ℝ))| := by congr 1; ring
        _ ≤ _ := (abs_sub _ _).trans (by linarith [ih (shift i (tolerance n) q) m, ih q m])
    have hp : 2 * (tolerance m : ℝ) / tolerance n = tolerance (k+1) := by
      dsimp [m]
      rw [tolerance_add, mul_div_assoc, mul_div_cancel_right₀ _ (tolerance_pos n).ne']
      simp [tolerance, pow_add]; ring
    have hh := abs_sub_le (fderiv ℝ (wordJet (f a) w) (rationalPoint q) (direction i))
      ((wordJet (f a) w (rationalPoint (shift i (tolerance n) q)) - wordJet (f a) w (rationalPoint q))/(tolerance n : ℝ))
      (((jetApprox b B a w (shift i (tolerance n) q) m - jetApprox b B a w q m)/tolerance n : ℚ) : ℝ)
    rw [shift_cast] at he hh
    have hsum := hh.trans (add_le_add hd he)
    rw [hp] at hsum
    have hp' := difference_precision C k
    have ht : (tolerance (k+1) : ℝ)+(tolerance (k+1) : ℝ) = tolerance k := by simp [tolerance, pow_succ]; ring
    change |fderiv ℝ (wordJet (f a) w) (rationalPoint q) (direction i) - _| ≤ _
    unfold jetApprox
    exact hsum.trans (by linarith)

lemma named_wordJet [Primcodable A] {f : A → ℝ × Space → ℝ}
    (sf : ∀ a, ContDiff ℝ ∞ (f a))
    (hf : Named (fun z : A × RationalPoint => f z.1 (rationalPoint z.2)))
    (B : A × ℕ → ℕ) (hB : Computable B)
    (hbound : ∀ a r z, ‖iteratedFDeriv ℝ r (f a) z‖ ≤ B (a,r)) :
    Named (fun z : (A × List (Fin 4)) × RationalPoint => wordJet (f z.1.1) z.1.2 (rationalPoint z.2)) := by
  obtain ⟨b,hb,h⟩ := hf
  refine ⟨fun z => jetApprox b B z.1.1.1 z.1.1.2 z.1.2 z.2, ?_, ?_⟩
  · have hp : Computable (fun z : (((A × List (Fin 4)) × RationalPoint) × ℕ) =>
        (z.1.1.1,z.1.1.2,z.1.2,z.2)) :=
      (Computable.fst.comp (Computable.fst.comp Computable.fst)).pair
        ((Computable.snd.comp (Computable.fst.comp Computable.fst)).pair
          ((Computable.snd.comp Computable.fst).pair Computable.snd))
    have hg := jetApprox_computable (A := A) b B hb hB
    have hcomp := Computable.comp hg hp
    exact hcomp
  · rintro ⟨⟨a,w⟩,q⟩ k
    exact jetApprox_error f sf b B (fun a q k => h (a,q) k) hbound a w q k

end AlternatingNS.Effective

end JetProgramsDevelopment

end OAI