import OAI.MathematicalPhysics.AlternatingFlow.JetPrograms

namespace OAI

section FieldProgramsDevelopment

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

variable {A E F : Type*} [Primcodable A]
  [NormedAddCommGroup E] [NormedSpace ℝ E] [NormedAddCommGroup F] [NormedSpace ℝ F]

def JetBound (f : A → E → F) : Prop :=
  (∀ a, ContDiff ℝ ∞ (f a)) ∧ ∃ B : A × ℕ → ℕ, Computable B ∧
    ∀ a r x, ‖iteratedFDeriv ℝ r (f a) x‖ ≤ B (a,r)

lemma Certified.jetBound {f : A → ℝ × Space → F} (hf : Certified f) : JetBound f := by
  obtain ⟨sf,B,hB,h⟩ := hf
  exact ⟨sf, fun z => B (z.1,0,z.2), hB.comp (Computable.fst.pair ((Computable.const 0).pair Computable.snd)),
    fun a r z => by simpa using h a 0 r z⟩

lemma JetBound.congr {f g : A → E → F} (hf : JetBound f) (h : ∀ a x, f a x = g a x) : JetBound g := by
  rwa [← funext (fun a => funext (h a))]

lemma JetBound.param {B : Type*} [Primcodable B] {f : A → E → F} (hf : JetBound f)
    {g : B → A} (hg : Computable g) : JetBound (fun b => f (g b)) := by
  obtain ⟨sf,C,hC,h⟩ := hf
  exact ⟨fun b => sf (g b), fun z => C (g z.1,z.2), hC.comp ((hg.comp Computable.fst).pair Computable.snd), fun b => h (g b)⟩

lemma JetBound.comp_unit {G : Type*} [NormedAddCommGroup G] [NormedSpace ℝ G]
    {f : A → E → F} (hf : JetBound f) (L : A → G →L[ℝ] E) (hL : ∀ a, ‖L a‖ ≤ 1) :
    JetBound (fun a => f a ∘ L a) := by
  obtain ⟨sf,B,hB,h⟩ := hf
  refine ⟨fun a => (sf a).comp (L a).contDiff, B, hB, fun a r z => ?_⟩
  exact (Bounds.norm_comp_linear (f a) (sf a) (L a) r z).trans
    ((mul_le_of_le_one_right (norm_nonneg _) (pow_le_one₀ (norm_nonneg _) (hL a))).trans (h a r _))

lemma JetBound.linear_unit {G : Type*} [NormedAddCommGroup G] [NormedSpace ℝ G]
    {f : A → E → F} (hf : JetBound f) (L : A → F →L[ℝ] G) (hL : ∀ a, ‖L a‖ ≤ 1) :
    JetBound (fun a => L a ∘ f a) := by
  obtain ⟨sf,B,hB,h⟩ := hf
  refine ⟨fun a => (L a).contDiff.comp (sf a), B, hB, fun a r z => ?_⟩
  exact (Bounds.norm_postcomp_linear (f a) (sf a) (L a) r z).trans
    ((mul_le_of_le_one_left (norm_nonneg _) (hL a)).trans (h a r z))

lemma Scaled.jetBound {s : A → ℕ → ℝ} {f : A → ℕ → E → F} (hf : Scaled s f)
    (hs : ∀ a n, 0 ≤ s a n) (S : A × ℕ → ℕ) (hS : Computable S)
    (sS : ∀ a n, s a n ≤ S (a,n)) : JetBound (fun a : A × ℕ => f a.1 a.2) := by
  obtain ⟨sf,B,hB,h⟩ := hf
  refine ⟨fun a => sf a.1 a.2, fun z => B (z.1.1,z.2) * S z.1 ^ z.2,
    Primrec.nat_mul.to_comp.comp
      (hB.comp ((Computable.fst.comp Computable.fst).pair Computable.snd))
      (nat_pow.to_comp.comp (hS.comp Computable.fst) Computable.snd), ?_⟩
  rintro ⟨a,n⟩ r x
  simpa only [Nat.cast_mul, Nat.cast_pow] using (h a r n x).trans
    (mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (hs a n) (sS a n) r) (Nat.cast_nonneg _))

lemma norm_proj (i : Fin 3) : ‖PiLp.proj 2 (𝕜 := ℝ) (fun _ : Fin 3 => ℝ) i‖ ≤ 1 :=
  ContinuousLinearMap.opNorm_le_bound _ zero_le_one (fun x => by simpa using PiLp.norm_apply_le x i)

lemma norm_fst : ‖ContinuousLinearMap.fst ℝ ℝ Space‖ ≤ 1 :=
  ContinuousLinearMap.opNorm_le_bound _ zero_le_one (fun x => by simpa using norm_fst_le x)

lemma norm_snd : ‖ContinuousLinearMap.snd ℝ ℝ Space‖ ≤ 1 :=
  ContinuousLinearMap.opNorm_le_bound _ zero_le_one (fun x => by simpa using norm_snd_le x)

lemma JetBound.named_wordJet {f : A → ℝ × Space → ℝ} (hf : JetBound f)
    (hn : Named (fun z : A × RationalPoint => f z.1 (rationalPoint z.2))) :
    Named (fun z : (A × List (Fin 4)) × RationalPoint => wordJet (f z.1.1) z.1.2 (rationalPoint z.2)) := by
  obtain ⟨sf,B,hB,h⟩ := hf
  exact AlternatingNS.Effective.named_wordJet sf hn B hB h

lemma JetBound.named_directional {f : A → ℝ × Space → ℝ} (hf : JetBound f)
    (hn : Named (fun z : A × RationalPoint => f z.1 (rationalPoint z.2)))
    (i : A → Fin 4) (hi : Computable i) :
    Named (fun z : A × RationalPoint => fderiv ℝ (f z.1) (rationalPoint z.2) (direction (i z.1))) := by
  have hw : Computable (fun z : A × RationalPoint => ((z.1,[i z.1]),z.2)) :=
    (Computable.fst.pair (Primrec.list_cons.to_comp.comp (hi.comp Computable.fst) (Computable.const []))).pair Computable.snd
  have hh := hf.named_wordJet hn |>.comp hw
  exact hh.congr (fun _ => rfl)

lemma Certified.sum3 {f : Fin 3 → A → ℝ × Space → F} (hf : ∀ i, Certified (f i)) :
    Certified (fun a z => ∑ i : Fin 3, f i a z) := by
  exact ((hf 0).add ((hf 1).add (hf 2))).congr (fun _ _ => by simp [Fin.sum_univ_succ])

lemma Certified.dx {f : A → Velocity} (hf : Certified (fun a => Function.uncurry (f a))) (i : Fin 3) :
    Certified (fun a => Function.uncurry (dx i (f a))) :=
  (hf.directional (fun _ => (0,e i)) (fun _ => by simp [Prod.norm_def, Bounds.norm_e])).congr
    (fun a z => (Bounds.dx_eq_full_directional (f a) (hf.1 a) i z).symm)

lemma Certified.fullDt {f : A → Velocity} (hf : Certified (fun a => Function.uncurry (f a))) :
    Certified (fun a => Function.uncurry (Analytic.fullDt (f a))) :=
  (hf.directional (fun _ => (1,0)) (fun _ => by simp [Prod.norm_def])).congr
    (fun a z => (Bounds.fullDt_eq_full_directional (f a) (hf.1 a) z).symm)

lemma Certified.component {f : A → ℝ × Space → Space} (hf : Certified f) (i : A → Fin 3) :
    Certified (fun a z => f a z (i a)) :=
  hf.linear (fun a => PiLp.proj 2 (𝕜 := ℝ) (fun _ : Fin 3 => ℝ) (i a)) (fun _ => 1) (Computable.const 1) (fun a => by simpa using norm_proj (i a))

lemma Certified.advection {f : A → Velocity} (hf : Certified (fun a => Function.uncurry (f a))) :
    Certified (fun a => Function.uncurry (advection (f a))) := by
  have hi (i : Fin 3) := (hf.component (fun _ => i)).smul (hf.dx i)
  exact (Certified.sum3 hi).congr (fun a z => (Bounds.advection_eq_sum (f a) z.1 z.2).symm)

lemma Certified.laplacian {f : A → Velocity} (hf : Certified (fun a => Function.uncurry (f a))) :
    Certified (fun a => Function.uncurry (laplacian (f a))) := Certified.sum3 (fun i => (hf.dx i).dx i)

noncomputable def fullForce (ν : ℝ) (M : Machine) (w : List ℕ) : Velocity :=
  fun t x => Analytic.fullDt (Construction.velocity M w) t x + advection (Construction.velocity M w) t x -
    ν • laplacian (Construction.velocity M w) t x

lemma force_certified (ν : ℝ) : Certified (fun z : Machine × List ℕ => Function.uncurry (fullForce ν z.1 z.2)) := by
  obtain ⟨D,hD⟩ := exists_nat_ge |ν|
  exact (velocity_certified.fullDt.add velocity_certified.advection).sub (velocity_certified.laplacian.csmul ν D hD)

lemma fullForce_half (ν : ℝ) (M : Machine) (w : List ℕ) :
    Bounds.HalfEq (fullForce ν M w) (Construction.force ν M w) := by
  intro t ht x
  simp only [fullForce, Construction.force, residual]
  rw [Analytic.dt_eq_full _ (Construction.velocity_smooth M w) t ht x]

end AlternatingNS.Effective

end FieldProgramsDevelopment

end OAI