import OAI.MathematicalPhysics.Transonic.Core

namespace OAI

section

/-! Exact integer polynomial evaluation and interval control for the regular shooting ODE. -/
namespace SepticProfile.IntegerPolynomial
open Set
abbrev Poly := List ℤ

def add : Poly → Poly → Poly
  | [],q => q
  | p,[] => p
  | a::p,b::q => (a+b)::add p q

def scale (a : ℤ) : Poly → Poly
  | [] => []
  | b::p => (a*b)::scale a p
def sub (p q : Poly) : Poly := add p (scale (-1) q)
def mul : Poly → Poly → Poly
  | [],_ => []
  | a::p,q => add (scale a q) (0::mul p q)
def der : Poly → Poly
  | [] => []
  | _::p => add p (0::der p)
def sq (p : Poly) : Poly := mul p p

def eval : Poly → ℝ → ℝ
  | [],_ => 0
  | a::p,x => a+x*eval p x

def norm : Poly → ℤ
  | [] => 0
  | a::p => |a|+norm p

def head (p : Poly) : ℤ := p.headD 0

def tailNorm (p : Poly) : ℤ := norm p.tail

def Positive (p : Poly) : Prop := tailNorm p<head p
instance (p : Poly) : Decidable (Positive p) := inferInstanceAs (Decidable (tailNorm p<head p))

lemma eval_add (p q : Poly) (x : ℝ) : eval (add p q) x=eval p x+eval q x := by
  induction p generalizing q with
  | nil => simp [add,eval]
  | cons a p ih =>
    cases q with
    | nil => simp [add,eval]
    | cons b q => simp [add,eval,ih]; ring

lemma eval_scale (a : ℤ) (p : Poly) (x : ℝ) : eval (scale a p) x=a*eval p x := by
  induction p with
  | nil => simp [scale,eval]
  | cons b p ih => simp only [scale,eval,Int.cast_mul,ih]; ring

lemma eval_sub (p q : Poly) (x : ℝ) : eval (sub p q) x=eval p x-eval q x := by
  simp [sub,eval_add,eval_scale,sub_eq_add_neg]

lemma eval_mul (p q : Poly) (x : ℝ) : eval (mul p q) x=eval p x*eval q x := by
  induction p with
  | nil => simp [mul,eval]
  | cons a p ih => rw [mul,eval_add,eval_scale,eval,ih,eval]; simp only [Int.cast_zero]; ring

lemma eval_sq (p : Poly) (x : ℝ) : eval (sq p) x=(eval p x)^2 := by
  rw [sq,eval_mul,pow_two]

lemma hasDerivAt_eval (p : Poly) (x : ℝ) : HasDerivAt (eval p) (eval (der p) x) x := by
  induction p with
  | nil => simpa only [eval,der] using hasDerivAt_const x (0:ℝ)
  | cons a p ih =>
    have hh := (hasDerivAt_const x (a : ℝ)).add ((hasDerivAt_id x).mul ih)
    change HasDerivAt (fun y => (a : ℝ)+y*eval p y)
      (0+(1*eval p x+x*eval (der p) x)) x at hh
    change HasDerivAt (fun y => (a : ℝ)+y*eval p y)
      (eval (add p (0::der p)) x) x
    simpa only [zero_add,one_mul,eval_add,eval,Int.cast_zero] using hh

lemma contDiff_eval (p : Poly) {n : WithTop ℕ∞} : ContDiff ℝ n (eval p) := by
  induction p with
  | nil => exact contDiff_const
  | cons a p ih => exact contDiff_const.add (contDiff_id.mul ih)

lemma norm_nonneg (p : Poly) : 0≤norm p := by
  induction p <;> simp_all [norm]; positivity

lemma eval_abs_le (p : Poly) {x : ℝ} (hx : x ∈ Icc 0 1) : |eval p x|≤norm p := by
  induction p with
  | nil => simp [eval,norm]
  | cons a p ih =>
    rw [eval,norm,Int.cast_add,Int.cast_abs]
    calc
      _ ≤ |(a : ℝ)|+|x*eval p x| := abs_add_le _ _
      _ = |(a : ℝ)|+x*|eval p x| := by rw [abs_mul,abs_of_nonneg hx.1]
      _ ≤ |(a : ℝ)|+|eval p x| := add_le_add_right (mul_le_of_le_one_left (abs_nonneg _) hx.2) _
      _ ≤ _ := add_le_add_right ih _

lemma eval_deviation (p : Poly) {x : ℝ} (hx : x ∈ Icc 0 1) :
    |eval p x-head p|≤tailNorm p := by
  cases p with
  | nil => simp [eval,head,tailNorm,norm]
  | cons a p =>
    simp only [head,List.headD_cons,eval,add_sub_cancel_left,tailNorm,List.tail_cons]
    rw [abs_mul,abs_of_nonneg hx.1]
    have h := eval_abs_le p hx
    exact (mul_le_of_le_one_left (abs_nonneg _) hx.2).trans h

lemma eval_pos {p : Poly} (hp : Positive p) {x : ℝ} (hx : x ∈ Icc 0 1) : 0<eval p x := by
  have hd := (abs_le.mp (eval_deviation p hx)).1
  have hp' : (tailNorm p : ℝ)<head p := by exact_mod_cast hp
  linarith

lemma eval_bounds (p : Poly) {x : ℝ} (hx : x ∈ Icc 0 1) :
    ((head p-tailNorm p : ℤ) : ℝ)≤eval p x ∧ eval p x≤((head p+tailNorm p : ℤ) : ℝ) := by
  have hh := abs_le.mp (eval_deviation p hx)
  push_cast
  constructor <;> linarith

end SepticProfile.IntegerPolynomial

namespace SepticProfile.IntegerPolynomial
open Set

/-- Numerator after substituting `z=(Z-Hs)/R`, `u=P(s)/Q` in the
exact normalized source ODE. All arithmetic in certificates is integral. -/
def residual (S SN K KN R Q Z H : ℤ) (p : Poly) : Poly :=
  let z : Poly := [Z,-H]
  let v := sub [Q^2] (sq p)
  add (scale (5*K*Q) (mul (mul (mul z (sub [S*R^2] (scale SN (sq z)))) v) (der p)))
    (scale (H*S*R) (mul (sub [5*Q^2] (scale 3 (sq p)))
      (add (scale KN (mul z v)) (scale (3*K) (sub (scale (Q^2) z) (scale (R*Q) p))))))

def denom (sigma z u : ℝ) : ℝ := z*(1-sigma*z^2)*(1-u^2)
noncomputable def numer (kappa z u : ℝ) : ℝ := (1-3*u^2/5)*(kappa*z*(1-u^2)+3*(z-u))

noncomputable def coordinate (R Z H : ℤ) (s : ℝ) : ℝ := (Z-H*s)/R

noncomputable def velocity (Q : ℤ) (p : Poly) (s : ℝ) : ℝ := eval p s/Q

lemma eval_singleton (a : ℤ) (x : ℝ) : eval [a] x=a := by simp [eval]
lemma eval_linear (a b : ℤ) (x : ℝ) : eval [a,b] x=a+b*x := by simp [eval]; ring

lemma eval_residual (S SN K KN R Q Z H : ℤ) (p : Poly) (s : ℝ)
    (hS : S≠0) (hK : K≠0) (hR : R≠0) (hQ : Q≠0) :
    eval (residual S SN K KN R Q Z H p) s =
      5*K*S*R^3*Q^4 *
       (denom (SN/S) (coordinate R Z H s) (velocity Q p s)*(eval (der p) s/Q)
        +(H/R)*numer (KN/K) (coordinate R Z H s) (velocity Q p s)) := by
  have hs : (S : ℝ)≠0 := by exact_mod_cast hS
  have hk : (K : ℝ)≠0 := by exact_mod_cast hK
  have hr : (R : ℝ)≠0 := by exact_mod_cast hR
  have hq : (Q : ℝ)≠0 := by exact_mod_cast hQ
  simp only [residual,eval_add,eval_sub,eval_scale,eval_mul,eval_sq,
    eval_singleton,eval_linear,Int.cast_mul,Int.cast_pow,Int.cast_ofNat,Int.cast_neg,
    denom,numer,coordinate,velocity]
  field_simp
  ring

lemma hasDerivAt_velocity (Q : ℤ) (p : Poly) (s : ℝ) :
    HasDerivAt (velocity Q p) (eval (der p) s/Q) s :=
  (hasDerivAt_eval p s).div_const Q

lemma residual_strict {S SN K KN R Q Z H : ℤ} (hS : 0<S) (hK : 0<K)
    (hR : 0<R) (hQ : 0<Q) {p : Poly} (hp : Positive (residual S SN K KN R Q Z H p))
    {s : ℝ} (hs : s ∈ Icc 0 1) :
    0 < denom (SN/S) (coordinate R Z H s) (velocity Q p s)*(eval (der p) s/Q)
      +(H/R)*numer (KN/K) (coordinate R Z H s) (velocity Q p s) := by
  have h := eval_pos hp hs
  rw [eval_residual S SN K KN R Q Z H p s (ne_of_gt hS) (ne_of_gt hK)
    (ne_of_gt hR) (ne_of_gt hQ)] at h
  have hs' : (0:ℝ)<S := by exact_mod_cast hS
  have hk' : (0:ℝ)<K := by exact_mod_cast hK
  have hr' : (0:ℝ)<R := by exact_mod_cast hR
  have hq' : (0:ℝ)<Q := by exact_mod_cast hQ
  exact (mul_pos_iff_of_pos_left (by positivity)).mp h

lemma residual_negative {S SN K KN R Q Z H : ℤ} (hS : 0<S) (hK : 0<K)
    (hR : 0<R) (hQ : 0<Q) {p : Poly}
    (hp : Positive (scale (-1) (residual S SN K KN R Q Z H p)))
    {s : ℝ} (hs : s ∈ Icc 0 1) :
    denom (SN/S) (coordinate R Z H s) (velocity Q p s)*(eval (der p) s/Q)
      +(H/R)*numer (KN/K) (coordinate R Z H s) (velocity Q p s) < 0 := by
  have h := eval_pos hp hs
  rw [eval_scale,eval_residual S SN K KN R Q Z H p s (ne_of_gt hS)
    (ne_of_gt hK) (ne_of_gt hR) (ne_of_gt hQ)] at h
  have hs' : (0:ℝ)<S := by exact_mod_cast hS
  have hk' : (0:ℝ)<K := by exact_mod_cast hK
  have hr' : (0:ℝ)<R := by exact_mod_cast hR
  have hq' : (0:ℝ)<Q := by exact_mod_cast hQ
  have hn : ((5:ℝ)*K*S*R^3*Q^4) *
        (denom (SN/S) (coordinate R Z H s) (velocity Q p s)*(eval (der p) s/Q)
        +(H/R)*numer (KN/K) (coordinate R Z H s) (velocity Q p s))<0 := by
    norm_num only [Int.cast_neg,Int.cast_one,neg_one_mul] at h
    linarith
  exact neg_pos.mp ((mul_pos_iff_of_pos_left (show (0:ℝ)<5*K*S*R^3*Q^4 by positivity)).mp (by nlinarith : 0<(5:ℝ)*K*S*R^3*Q^4 * -_))
end SepticProfile.IntegerPolynomial

namespace SepticProfile.IntegerPolynomial

@[simp] lemma eval_zero (p : Poly) : eval p 0=head p := by
  cases p <;> simp [eval,head]

@[simp] lemma eval_one (p : Poly) : eval p 1=(p.sum : ℤ) := by
  induction p <;> simp_all [eval]

structure Step where
  Z : ℤ
  H : ℤ
  lo : Poly
  hi : Poly

def Range (Q : ℤ) (p : Poly) : Prop :=
  0<head p-tailNorm p ∧ 1000*(head p+tailNorm p)<999*Q
instance (Q : ℤ) (p : Poly) : Decidable (Range Q p) :=
  inferInstanceAs (Decidable (_ ∧ _))

def Valid (S SN K KN R Q : ℤ) (a : Step) : Prop :=
  0<a.H ∧ 9*R≤10*(a.Z-a.H) ∧ 100*a.Z≤99*R ∧
  Range Q a.lo ∧ Range Q a.hi ∧ head a.lo≤head a.hi ∧
  Positive (scale (-1) (residual S SN K KN R Q a.Z a.H a.lo)) ∧
  Positive (residual S SN K KN R Q a.Z a.H a.hi)
instance (S SN K KN R Q : ℤ) (a : Step) : Decidable (Valid S SN K KN R Q a) :=
  inferInstanceAs (Decidable (_ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _ ∧ _))

lemma range_velocity {Q : ℤ} (hq : 0<Q) {p : Poly} (hp : Range Q p) {s : ℝ}
    (hs : s ∈ Set.Icc 0 1) : velocity Q p s ∈ Set.Icc (0:ℝ) (999/1000) := by
  have hq' : (0:ℝ)<Q := by exact_mod_cast hq
  have hr := eval_bounds p hs
  have hlo : (0:ℝ)<((head p-tailNorm p : ℤ) : ℝ) := by exact_mod_cast hp.1
  have hhi : (1000:ℝ)*((head p+tailNorm p : ℤ) : ℝ)<999*Q := by exact_mod_cast hp.2
  constructor
  · exact div_nonneg (le_of_lt (hlo.trans_le hr.1)) hq'.le
  · apply (div_le_iff₀ hq').mpr
    nlinarith

lemma coordinate_bounds {R Z H : ℤ} (hr : 0<R) (hh : 0<H)
    (hstart : 100*Z≤99*R) (hend : 9*R≤10*(Z-H)) {s : ℝ}
    (hs : s ∈ Set.Icc 0 1) : coordinate R Z H s ∈ Set.Icc (9/10:ℝ) (99/100) := by
  have hr' : (0:ℝ)<R := by exact_mod_cast hr
  have hh' : (0:ℝ)<H := by exact_mod_cast hh
  have ha : (100:ℝ)*Z≤99*R := by exact_mod_cast hstart
  have hb : (9:ℝ)*R≤10*(Z-H) := by exact_mod_cast hend
  unfold coordinate
  constructor
  · apply (le_div_iff₀ hr').mpr
    nlinarith [mul_le_of_le_one_right hh'.le hs.2]
  · apply (div_le_iff₀ hr').mpr
    nlinarith [mul_nonneg hh'.le hs.1]

lemma denom_pos {sigma z u : ℝ} (hsigma : sigma ∈ Set.Icc (0:ℝ) 1)
    (hz : z ∈ Set.Icc (9/10:ℝ) (99/100)) (hu : u ∈ Set.Icc (0:ℝ) (999/1000)) :
    0<denom sigma z u := by
  have hz0 : 0<z := by linarith [hz.1]
  have hz1 : z^2<1 := by nlinarith [hz.2]
  have hu1 : u^2<1 := by nlinarith [hu.1,hu.2]
  have hsz : sigma*z^2≤z^2 := mul_le_of_le_one_left (sq_nonneg _) hsigma.2
  exact mul_pos (mul_pos hz0 (by linarith)) (by linarith)
end SepticProfile.IntegerPolynomial


namespace SepticProfile.IntegerPolynomial
open Set
open RegularContinuation

noncomputable def stepField (sigma kappa : ℝ) (R Z H : ℤ) (s w : ℝ) : ℝ :=
  -(H/R)*numer kappa (coordinate R Z H s) (clamp 0 (999/1000) w)/
    denom sigma (coordinate R Z H s) (clamp 0 (999/1000) w)

/-- Exact signed polynomial residuals control the actual clamped ODE, not an
approximate trajectory. The comparison proves the clamp inactive on this step. -/
theorem step_control {S SN K KN R Q : ℤ} (hs : 0<S) (hk : 0<K) (hr : 0<R)
    (hq : 0<Q) (hsigma : ((SN:ℝ)/S) ∈ Icc (0:ℝ) 1) {a : Step}
    (ha : Valid S SN K KN R Q a) {w : ℝ → ℝ}
    (hwc : ContinuousOn w (Icc 0 1))
    (hwd : ∀ s ∈ Icc (0:ℝ) 1, HasDerivWithinAt w
      (stepField (SN/S) (KN/K) R a.Z a.H s (w s)) (Icc 0 1) s)
    (hw0 : w 0 ∈ Icc ((head a.lo:ℝ)/Q) ((head a.hi:ℝ)/Q)) :
    ∀ s ∈ Icc (0:ℝ) 1, w s ∈ Icc (velocity Q a.lo s) (velocity Q a.hi s) := by
  obtain ⟨hh,hend,hstart,hlo,hhi,_,hlor,_hhir⟩ := ha
  have hright (s : ℝ) (ht : s ∈ Ico (0:ℝ) 1) : HasDerivWithinAt w
      (stepField (SN/S) (KN/K) R a.Z a.H s (w s)) (Ici s) s := by
    apply (hwd s ⟨ht.1,ht.2.le⟩).mono_of_mem_nhdsWithin
    exact Filter.mem_of_superset (Icc_mem_nhdsGE ht.2) (Icc_subset_Icc_left ht.1)
  have hupper : ∀ s ∈ Icc (0:ℝ) 1, w s≤velocity Q a.hi s := by
    apply image_le_of_deriv_right_lt_deriv_boundary' hwc hright
      (B' := fun s => eval (der a.hi) s/Q) (by simpa [velocity] using hw0.2)
      (fun s _ => (hasDerivAt_velocity Q a.hi s).continuousAt.continuousWithinAt)
      (fun s _ => (hasDerivAt_velocity Q a.hi s).hasDerivWithinAt)
    intro s ht he
    have he2 : s ∈ Icc (0:ℝ) 1 := ⟨ht.1,ht.2.le⟩
    have hrange := range_velocity hq hhi he2
    have hz := coordinate_bounds hr hh hstart hend he2
    have hd := denom_pos hsigma hz hrange
    have heq := clamp_eq hrange
    have hhres := residual_strict hs hk hr hq _hhir he2
    dsimp only [stepField]
    rw [he,heq]
    apply (div_lt_iff₀ hd).mpr
    nlinarith
  have hlower : ∀ s ∈ Icc (0:ℝ) 1, velocity Q a.lo s≤w s := by
    have hhcmp := image_le_of_deriv_right_lt_deriv_boundary' hwc.neg
      (fun s hs => (hright s hs).neg) (B := fun s => -velocity Q a.lo s)
      (B' := fun s => -(eval (der a.lo) s/Q))
      (by simpa [velocity] using neg_le_neg hw0.1)
      (fun s _ => (hasDerivAt_velocity Q a.lo s).neg.continuousAt.continuousWithinAt)
      (fun s _ => (hasDerivAt_velocity Q a.lo s).neg.hasDerivWithinAt)
    have hhcmp' : ∀ s ∈ Icc (0:ℝ) 1, -w s≤ -velocity Q a.lo s := by
      apply hhcmp
      intro s ht he
      have he' : w s=velocity Q a.lo s := neg_inj.mp he
      have he2 : s ∈ Icc (0:ℝ) 1 := ⟨ht.1,ht.2.le⟩
      have hrange := range_velocity hq hlo he2
      have hz := coordinate_bounds hr hh hstart hend he2
      have hd := denom_pos hsigma hz hrange
      have heq := clamp_eq hrange
      have hlres := residual_negative hs hk hr hq hlor he2
      apply neg_lt_neg
      dsimp only [stepField]
      rw [he',heq]
      apply (lt_div_iff₀ hd).mpr
      nlinarith
    intro s hs
    linarith [hhcmp' s hs]
  intro s hs
  exact ⟨hlower s hs,hupper s hs⟩

end SepticProfile.IntegerPolynomial

namespace SepticProfile.IntegerPolynomial
open Set RegularContinuation

noncomputable def globalField (sigma kappa : ℝ) (t w : ℝ) : ℝ :=
  -numer kappa (99/100-t) (clamp 0 (999/1000) w)/
    denom sigma (99/100-t) (clamp 0 (999/1000) w)
noncomputable def stepTime (R Z H : ℤ) (s : ℝ) : ℝ := 99/100-coordinate R Z H s
noncomputable def startTime (R : ℤ) (a : Step) : ℝ := 99/100-a.Z/R
noncomputable def stopTime (R : ℤ) (a : Step) : ℝ := 99/100-((a.Z-a.H : ℤ):ℝ)/R

lemma hasDerivAt_stepTime (R Z H : ℤ) (s : ℝ) : HasDerivAt (stepTime R Z H) (H/R) s := by
  have hh := (hasDerivAt_const s (99/100:ℝ)).sub
    (((hasDerivAt_const s (Z:ℝ)).sub ((hasDerivAt_id s).const_mul (H:ℝ))).div_const R)
  change HasDerivAt (stepTime R Z H) (0-(0-(H:ℝ)*1)/R) s at hh
  simpa only [mul_one,zero_sub,neg_div,neg_neg] using hh

lemma stepTime_mem {R Z H : ℤ} (hr : 0<R) (hh : 0<H)
    (hstart : 100*Z≤99*R) (hend : 9*R≤10*(Z-H)) {s : ℝ}
    (hs : s ∈ Icc (0:ℝ) 1) : stepTime R Z H s ∈ Icc (0:ℝ) (9/100) := by
  have hz := coordinate_bounds hr hh hstart hend hs
  unfold stepTime
  constructor <;> linarith [hz.1,hz.2]

lemma localized_derivative {sigma kappa : ℝ} {R Z H : ℤ} (hr : 0<R) (hh : 0<H)
    (hstart : 100*Z≤99*R) (hend : 9*R≤10*(Z-H)) {u : ℝ → ℝ}
    (hud : ∀ t ∈ Icc (0:ℝ) (9/100), HasDerivWithinAt u (globalField sigma kappa t (u t))
      (Icc 0 (9/100)) t) (s : ℝ) (hs : s ∈ Icc (0:ℝ) 1) :
    HasDerivWithinAt (u ∘ stepTime R Z H)
      (stepField sigma kappa R Z H s ((u ∘ stepTime R Z H) s)) (Icc 0 1) s := by
  have hm := stepTime_mem hr hh hstart hend hs
  have hd := (hud _ hm).comp s (hasDerivAt_stepTime R Z H s).hasDerivWithinAt
    (fun t ht => stepTime_mem hr hh hstart hend ht)
  have he : globalField sigma kappa (stepTime R Z H s) (u (stepTime R Z H s)) * (H/R) =
      stepField sigma kappa R Z H s ((u ∘ stepTime R Z H) s) := by
    dsimp [globalField,stepField,stepTime]
    simp only [sub_sub_cancel]
    ring
  rw [← he]
  exact hd

/-- Each integer certificate propagates a rigorous interval for the same
single globally constructed clamped solution. No approximate flow is used. -/
theorem global_step_endpoint {S SN K KN R Q : ℤ} (hs : 0<S) (hk : 0<K) (hr : 0<R)
    (hq : 0<Q) (hsigma : ((SN:ℝ)/S) ∈ Icc (0:ℝ) 1) {a : Step}
    (ha : Valid S SN K KN R Q a) {u : ℝ → ℝ}
    (hud : ∀ t ∈ Icc (0:ℝ) (9/100), HasDerivWithinAt u (globalField (SN/S) (KN/K) t (u t))
      (Icc 0 (9/100)) t)
    (hu0 : u (startTime R a) ∈ Icc ((head a.lo:ℝ)/Q) ((head a.hi:ℝ)/Q)) :
    u (stopTime R a) ∈ Icc ((a.lo.sum:ℝ)/Q) ((a.hi.sum:ℝ)/Q) := by
  have hd := localized_derivative hr ha.1 ha.2.2.1 ha.2.1 hud
  have hc : ContinuousOn (u ∘ stepTime R a.Z a.H) (Icc 0 1) :=
    fun s hs => (hd s hs).continuousWithinAt
  have hzero : (u ∘ stepTime R a.Z a.H) 0=u (startTime R a) := by
    simp [stepTime,coordinate,startTime]
  have hb := step_control hs hk hr hq hsigma ha hc hd (hzero.symm ▸ hu0) 1 (by norm_num)
  simpa [stepTime,coordinate,stopTime,velocity] using hb

lemma join_bound {R Q : ℤ} (hq : 0<Q) {a b : Step} {u : ℝ → ℝ}
    (hjoin : a.Z-a.H=b.Z ∧ head b.lo≤a.lo.sum ∧ a.hi.sum≤head b.hi)
    (hb : u (stopTime R a) ∈ Icc ((a.lo.sum:ℝ)/Q) ((a.hi.sum:ℝ)/Q)) :
    u (startTime R b) ∈ Icc ((head b.lo:ℝ)/Q) ((head b.hi:ℝ)/Q) := by
  have he : stopTime R a=startTime R b := by rw [stopTime,startTime,hjoin.1]
  rw [he] at hb
  have hq' : (0:ℝ)≤Q := le_of_lt (by exact_mod_cast hq)
  constructor
  · exact (div_le_div_of_nonneg_right (by exact_mod_cast hjoin.2.1) hq').trans hb.1
  · exact hb.2.trans (div_le_div_of_nonneg_right (by exact_mod_cast hjoin.2.2) hq')
end SepticProfile.IntegerPolynomial

namespace SepticProfile.IntegerPolynomial
open Set RegularContinuation

lemma regular_field_contDiffOn (sigma kappa : ℝ) (hs : sigma ∈ Icc (0:ℝ) 1) :
    ContDiffOn ℝ 1 (fun p : ℝ×ℝ => -numer kappa (99/100-p.1) p.2 /
      denom sigma (99/100-p.1) p.2) (Icc (0:ℝ) (9/100) ×ˢ Icc (0:ℝ) (999/1000)) := by
  apply ContDiffOn.div
  · unfold numer
    fun_prop
  · unfold denom
    fun_prop
  · intro p hp
    apply ne_of_gt (denom_pos hs _ hp.2)
    constructor <;> linarith [hp.1.1,hp.1.2]

/-- A single exact clamped trajectory exists on the entire regular shooting
interval. Step certificates will certify its value, rather than assume a flow. -/
theorem exists_global_clamped_solution (sigma kappa : ℝ) (hs : sigma ∈ Icc (0:ℝ) 1)
    (u0 : ℝ) : ∃ u : ℝ → ℝ, u 0=u0 ∧ ContinuousOn u (Icc (0:ℝ) (9/100)) ∧
      ∀ t ∈ Icc (0:ℝ) (9/100), HasDerivWithinAt u (globalField sigma kappa t (u t))
        (Icc 0 (9/100)) t := by
  exact exists_clamped_solution (by norm_num) (by norm_num)
    (regular_field_contDiffOn sigma kappa hs) u0
end SepticProfile.IntegerPolynomial


end

end OAI