lean/OAI/Probability/JammingConcavity/RowCalcJet.lean

import Mathlib
import OAI.Probability.JammingConcavity.RowDerivativeApprox

namespace OAI

/-! Row Calc Jet. -/

noncomputable section

open MeasureTheory ProbabilityTheory Set
open scoped NNReal ENNReal
open Set Filter
open scoped Topology
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory Filter Set
open scoped ENNReal NNReal BigOperators
open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal Topology
open scoped NNReal ENNReal Topology
open scoped NNReal Topology
open Set
open Set Filter MeasureTheory
open scoped BigOperators
open scoped Topology NNReal
open scoped Topology BigOperators
open Set

namespace MicroscopicJamming.Hessian
 
structure CalcJet where
  val : ℝ → ℝ → ℝ
  dx : ℝ → ℝ → ℝ
  dxx : ℝ → ℝ → ℝ
  dt : ℝ → ℝ → ℝ
  valid : Jet val dx dxx dt
namespace CalcJet
def add (u v : CalcJet) : CalcJet :=
  ⟨fun t z => u.val t z+v.val t z,fun t z => u.dx t z+v.dx t z,
   fun t z => u.dxx t z+v.dxx t z,fun t z => u.dt t z+v.dt t z,u.valid.add v.valid⟩
def neg (u : CalcJet) : CalcJet :=
  ⟨fun t z => -u.val t z,fun t z => -u.dx t z,fun t z => -u.dxx t z,fun t z => -u.dt t z,u.valid.neg⟩
def mul (u v : CalcJet) : CalcJet :=
  ⟨fun t z => u.val t z*v.val t z,fun t z => u.dx t z*v.val t z+u.val t z*v.dx t z,
   fun t z => u.dxx t z*v.val t z+2*u.dx t z*v.dx t z+u.val t z*v.dxx t z,
   fun t z => u.dt t z*v.val t z+u.val t z*v.dt t z,u.valid.mul v.valid⟩
def const (c : ℝ) : CalcJet := ⟨fun _ _ => c,fun _ _ => 0,fun _ _ => 0,fun _ _ => 0,Jet.const c⟩
def smul (c : ℝ) (u : CalcJet) : CalcJet := (const c).mul u
def sq (u : CalcJet) : CalcJet := u.mul u
def rank : CalcJet := ⟨fun t _ => t,fun _ _ => 0,fun _ _ => 0,fun _ _ => 1,Jet.rank⟩
def coeff (a da : ℝ → ℝ) (ha : ∀ t∈Ico (0:ℝ) 1,HasDerivWithinAt a (da t) (Ici t) t) : CalcJet :=
  ⟨fun t _ => a t,fun _ _ => 0,fun _ _ => 0,fun t _ => da t,Jet.coeff ha⟩
def inv (u : CalcJet) (hu : ∀ t∈Icc (0:ℝ) 1,∀ x,u.val t x≠0) : CalcJet :=
  ⟨fun t x => (u.val t x)⁻¹,fun t x => -u.dx t x/(u.val t x)^2,
   fun t x => 2*(u.dx t x)^2/(u.val t x)^3-u.dxx t x/(u.val t x)^2,
   fun t x => -u.dt t x/(u.val t x)^2,u.valid.inv hu⟩
def gen (a b : ℝ → ℝ → ℝ) (u : CalcJet) (t x : ℝ) : ℝ := u.dt t x+a t x*u.dxx t x+b t x*u.dx t x
lemma gen_add (a b : ℝ → ℝ → ℝ) (u v : CalcJet) (t x : ℝ) :
    gen a b (u.add v) t x=gen a b u t x+gen a b v t x := by dsimp [gen,add]; ring
lemma gen_mul (a b : ℝ → ℝ → ℝ) (u v : CalcJet) (t x : ℝ) :
    gen a b (u.mul v) t x=gen a b u t x*v.val t x+u.val t x*gen a b v t x+2*a t x*u.dx t x*v.dx t x := by
  dsimp [gen,mul]; ring
lemma gen_inv (a b : ℝ → ℝ → ℝ) (u : CalcJet) (hu : ∀ t∈Icc (0:ℝ) 1,∀ x,u.val t x≠0)
    {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : ℝ) :
    gen a b (u.inv hu) t x= -gen a b u t x/(u.val t x)^2+2*a t x*(u.dx t x)^2/(u.val t x)^3 := by
  dsimp [gen,inv]
  field_simp [hu t ht x]
  ring
end CalcJet
end MicroscopicJamming.Hessian

 
open Set Filter
open scoped Topology BigOperators

namespace MicroscopicJamming.Hessian
open Higher Parameter

lemma jet_of_evolution {f d : ℝ → ℝ → ℝ} (hf : JointSpatialSmooth (Icc 0 1) f)
    (ht : ∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => f s x) (d t x) (Ici t) t) :
    Jet f (fun t => iteratedDeriv 1 (f t)) (fun t => iteratedDeriv 2 (f t)) d := by
  refine ⟨fun t htt x => ?_,fun t htt x => ?_,ht⟩
  · simpa only [iteratedDeriv_succ,iteratedDeriv_zero] using ((hf.1 t htt).differentiable (by simp) x).hasDerivAt
  · simpa only [iteratedDeriv_succ,iteratedDeriv_zero] using (((hf.jet 1).1 t htt).differentiable (by simp) x).hasDerivAt

structure EvolutionSystem (A B : ℝ → ℝ) (f v g : ℝ → ℝ → ℝ) : Prop where
  fs : JointSpatialSmooth (Icc 0 1) f
  vs : JointSpatialSmooth (Icc 0 1) v
  gs : JointSpatialSmooth (Icc 0 1) g
  ft : ∀ n,∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (f s) x)
    (ftime (A t) t (fun k => iteratedDeriv k (f t) x) n) (Ici t) t
  vt : ∀ n,∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (v s) x)
    (vtime (A t) (B t) t (fun k => iteratedDeriv k (f t) x) (fun k => iteratedDeriv k (v t) x) n) (Ici t) t
  gt : ∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => g s x)
    (gtime (A t) (B t) t (fun k => iteratedDeriv k (f t) x) (fun k => iteratedDeriv k (v t) x)
      (fun k => iteratedDeriv k (g t) x)) (Ici t) t

lemma actual_evolution {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData (Ioo (-r) r) A B F) :
    EvolutionSystem A B (F 0) (pjet F 0) (pjet2 F 0) := by
  have h0 : (0:ℝ)∈Ioo (-r) r := ⟨by linarith,hr⟩
  have hj := hf.parameter_jets hr
  have htime := hf.parameter_time_jets hr
  have hs := hf.smooth 0 h0
  have hG := hs.row_rhs hf.Acont continuousOn_id
  have hft := evolution_all_jets (by norm_num : (0:ℝ)<1) (hs.2 0) hG.2 hs.1 hG.1
    (fun t ht x => by simpa only [zero_mul,add_zero,id_eq] using hf.time 0 h0 t ht x)
  refine ⟨hs,hj.1.1,hj.2.1,?_,?_,?_⟩
  · intro n t ht x
    simpa only [iterated_rhs (A t) t (hs.1 t ⟨ht.1,ht.2.le⟩) n x,id_eq] using hft n t ht x
  · intro n t ht x
    simpa only [iterated_linearRhs (hs.1 t ⟨ht.1,ht.2.le⟩) (hj.1.1.1 t ⟨ht.1,ht.2.le⟩) n x]
      using htime.1 n t ht x
  · intro t ht x
    exact htime.2 0 t ht x

namespace EvolutionSystem
variable {A B : ℝ → ℝ} {f v g : ℝ → ℝ → ℝ} (h : EvolutionSystem A B f v g)
def fj (n : ℕ) : CalcJet where
  val := fun t => iteratedDeriv n (f t)
  dx := fun t => iteratedDeriv (n+1) (f t)
  dxx := fun t => iteratedDeriv (n+2) (f t)
  dt := fun t x => ftime (A t) t (fun k => iteratedDeriv k (f t) x) n
  valid := by
    simpa only [iteratedDeriv_iteratedDeriv,Nat.add_comm 1,Nat.add_comm 2] using jet_of_evolution (h.fs.jet n) (h.ft n)
def vj (n : ℕ) : CalcJet where
  val := fun t => iteratedDeriv n (v t)
  dx := fun t => iteratedDeriv (n+1) (v t)
  dxx := fun t => iteratedDeriv (n+2) (v t)
  dt := fun t x => vtime (A t) (B t) t (fun k => iteratedDeriv k (f t) x) (fun k => iteratedDeriv k (v t) x) n
  valid := by
    simpa only [iteratedDeriv_iteratedDeriv,Nat.add_comm 1,Nat.add_comm 2] using jet_of_evolution (h.vs.jet n) (h.vt n)
def gj : CalcJet where
  val := g
  dx := fun t => iteratedDeriv 1 (g t)
  dxx := fun t => iteratedDeriv 2 (g t)
  dt := fun t x => gtime (A t) (B t) t (fun k => iteratedDeriv k (f t) x) (fun k => iteratedDeriv k (v t) x) (fun k => iteratedDeriv k (g t) x)
  valid := jet_of_evolution h.gs h.gt

def drift (t x : ℝ) : ℝ := 2*A t*t*iteratedDeriv 1 (f t) x

def ell (E : CalcJet) : CalcJet := (h.vj 1).add
  ((CalcJet.smul (1/2) E).mul ((h.fj 3).add (CalcJet.smul 2 (CalcJet.rank.mul ((h.fj 1).mul (h.fj 2))))))
def mu : CalcJet := (h.fj 4).add
  ((CalcJet.smul 2 (CalcJet.rank.mul ((h.fj 2).sq))).add
    ((CalcJet.smul 4 (CalcJet.rank.mul ((h.fj 1).mul (h.fj 3)))).add
      (CalcJet.smul 4 (CalcJet.rank.sq.mul (((h.fj 1).sq).mul (h.fj 2))))))
def mainJet (E : CalcJet) : CalcJet := (CalcJet.smul 2 h.gj).add
  ((E.mul ((h.vj 2).add (CalcJet.smul 2 (CalcJet.rank.mul ((h.fj 1).mul (h.vj 1)))))).add
    ((CalcJet.smul (1/4) E.sq).mul h.mu))
end EvolutionSystem
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming.Hessian
namespace EvolutionSystem
variable {A B : ℝ → ℝ} {f v g : ℝ → ℝ → ℝ} (h : EvolutionSystem A B f v g)
variable {η : ℝ → ℝ} (hη : ∀ t∈Ico (0:ℝ) 1,HasDerivWithinAt η (2*B t) (Ici t) t)
local notation "E" => CalcJet.coeff η (fun t => 2*B t) hη
lemma gen_ell (t x : ℝ) :
    CalcJet.gen (fun t _ => A t) (drift (A:=A) (f:=f)) (h.ell E) t x =
      η t*iteratedDeriv 1 (f t) x*iteratedDeriv 2 (f t) x-
        2*A t*t*iteratedDeriv 2 (f t) x*(h.ell E).val t x := by
  dsimp [CalcJet.gen,ell,fj,vj,drift,CalcJet.add,CalcJet.mul,CalcJet.smul,CalcJet.rank,CalcJet.const,CalcJet.coeff]
  simp only [ftime,vtime,Finset.sum_range_succ,Finset.sum_range_zero,Nat.choose_zero_right,Nat.choose_self]
  norm_num [Nat.choose]
  ring
lemma gen_curvature (t x : ℝ) :
    CalcJet.gen (fun t _ => A t) (drift (A:=A) (f:=f)) (h.fj 2).neg t x =
      2*A t*t*((h.fj 2).neg.val t x)^2 := by
  dsimp [CalcJet.gen,fj,drift,CalcJet.neg]
  simp only [ftime,Finset.sum_range_succ,Finset.sum_range_zero,Nat.choose_zero_right,Nat.choose_self]
  norm_num [Nat.choose]
  ring
lemma gen_main (t x : ℝ) :
    CalcJet.gen (fun t _ => A t) (drift (A:=A) (f:=f)) (h.mainJet E) t x =
      2*η t*iteratedDeriv 1 (f t) x*(h.ell E).val t x-
      2*A t*t*((h.ell E).val t x)^2+η t^2*(iteratedDeriv 2 (f t) x)^2/2 := by
  dsimp [CalcJet.gen,mainJet,mu,ell,fj,vj,gj,drift,CalcJet.add,CalcJet.mul,CalcJet.smul,CalcJet.sq,CalcJet.rank,CalcJet.const,CalcJet.coeff]
  simp only [ftime,vtime,gtime,Finset.sum_range_succ,Finset.sum_range_zero,Nat.choose_zero_right,Nat.choose_self]
  norm_num [Nat.choose]
  ring
end EvolutionSystem
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming.Hessian
open Higher
namespace CalcJet
def Controlled (u : CalcJet) : Prop :=
  ContinuousOn (fun p : ℝ × ℝ => u.val p.1 p.2) (Icc 0 1 ×ˢ univ) ∧
  UniformPolynomialGrowth (Icc 0 1) u.val
lemma Controlled.add {u v : CalcJet} (hu : Controlled u) (hv : Controlled v) : Controlled (u.add v) :=
  ⟨hu.1.add hv.1,hu.2.add hv.2⟩
lemma Controlled.mul {u v : CalcJet} (hu : Controlled u) (hv : Controlled v) : Controlled (u.mul v) :=
  ⟨hu.1.mul hv.1,hu.2.mul hv.2⟩
lemma controlled_const (c : ℝ) : Controlled (const c) :=
  ⟨continuousOn_const,UniformPolynomialGrowth.const _ c⟩
lemma Controlled.smul {u : CalcJet} (hu : Controlled u) (c : ℝ) : Controlled (smul c u) :=
  (controlled_const c).mul hu
lemma Controlled.neg {u : CalcJet} (hu : Controlled u) : Controlled u.neg :=
  ⟨hu.1.neg,by simpa only [neg_one_mul,CalcJet.neg] using hu.2.const_mul (-1)⟩
lemma Controlled.sq {u : CalcJet} (hu : Controlled u) : Controlled u.sq := hu.mul hu
lemma controlled_coeff {a da : ℝ → ℝ} (ha : ∀ t∈Ico (0:ℝ) 1,HasDerivWithinAt a (da t) (Ici t) t)
    (hc : ContinuousOn a (Icc 0 1)) : Controlled (coeff a da ha) := by
  refine ⟨hc.comp continuousOn_fst (fun p hp => hp.1),?_⟩
  obtain ⟨T,hT,hm⟩ := isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr (by norm_num : (0:ℝ)≤1)) hc.abs
  exact ⟨0,|a T|,abs_nonneg _,fun t ht x => by simpa only [CalcJet.coeff,pow_zero,mul_one] using (show |a t|≤|a T| from hm ht)⟩
lemma controlled_rank : Controlled rank := by
  refine ⟨continuousOn_fst,0,1,by norm_num,fun t ht x => ?_⟩
  simpa only [rank,pow_zero,mul_one,abs_of_nonneg ht.1] using ht.2
lemma Controlled.inv {u : CalcJet} (hu : Controlled u) {c : ℝ} (hc : 0<c)
    (hl : ∀ t∈Icc (0:ℝ) 1,∀ x,c≤u.val t x) :
    Controlled (u.inv (fun t ht x => ne_of_gt (hc.trans_le (hl t ht x)))) := by
  refine ⟨hu.1.inv₀ (fun p hp => ne_of_gt (hc.trans_le (hl p.1 hp.1 p.2))),0,c⁻¹,by positivity,?_⟩
  intro t ht x
  simp only [CalcJet.inv,pow_zero,mul_one,abs_inv,abs_of_pos (hc.trans_le (hl t ht x))]
  exact inv_anti₀ hc (hl t ht x)
lemma nonpos_of_gen_nonneg {u : CalcJet} (hu : Controlled u) {a b : ℝ → ℝ → ℝ} {A K : ℝ}
    (hA : 0≤A) (hK : 0≤K) (ha : ∀ t∈Icc (0:ℝ) 1,∀ x,0≤a t x ∧ a t x≤A)
    (hb : ∀ t∈Icc (0:ℝ) 1,∀ x,|b t x|≤K*(1+|x|))
    (hg : ∀ t∈Ico (0:ℝ) 1,∀ x,0≤gen a b u t x)
    (hterm : ∀ x,u.val 1 x≤0) : ∀ t∈Icc (0:ℝ) 1,∀ x,u.val t x≤0 := by
  have hx : ∀ t∈Icc (0:ℝ) 1,Differentiable ℝ (u.val t) ∧ Differentiable ℝ (deriv (u.val t)) := by
    intro t ht
    refine ⟨fun x => (u.valid.x t ht x).differentiableAt,?_⟩
    rw [u.valid.spatial_deriv ht]
    exact fun x => (u.valid.xx t ht x).differentiableAt
  apply VariableDiffusion.backward_polynomial_comparison (by norm_num : (0:ℝ)<1) hK hA hu.1
    hx u.valid.time ha hb hu.2 _ hterm
  intro t ht x _
  rw [u.valid.spatial_deriv2 ⟨ht.1,ht.2.le⟩,u.valid.spatial_deriv ⟨ht.1,ht.2.le⟩]
  exact hg t ht x
end CalcJet
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming.Hessian
lemma gen_square_quotient {a b : ℝ → ℝ → ℝ} (l k : CalcJet)
    (hk : ∀ t∈Icc (0:ℝ) 1,∀ x,k.val t x≠0) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : ℝ) :
    CalcJet.gen a b (l.sq.mul (k.inv hk)) t x =
      2*l.val t x/k.val t x*CalcJet.gen a b l t x-
      (l.val t x)^2/(k.val t x)^2*CalcJet.gen a b k t x+
      2*a t x/k.val t x*(l.dx t x-l.val t x*k.dx t x/k.val t x)^2 := by
  rw [CalcJet.gen_mul,CalcJet.gen_inv a b k hk ht x]
  change CalcJet.gen a b (l.mul l) t x*(k.val t x)⁻¹+
    (l.val t x*l.val t x)*(-CalcJet.gen a b k t x/(k.val t x)^2+2*a t x*(k.dx t x)^2/(k.val t x)^3)+
    2*a t x*(l.dx t x*l.val t x+l.val t x*l.dx t x)*(-k.dx t x/(k.val t x)^2)=_
  rw [CalcJet.gen_mul]
  field_simp [hk t ht x]
  ring
namespace EvolutionSystem
variable {A B : ℝ → ℝ} {f v g : ℝ → ℝ → ℝ} (h : EvolutionSystem A B f v g)
variable {η : ℝ → ℝ} (hη : ∀ t∈Ico (0:ℝ) 1,HasDerivWithinAt η (2*B t) (Ici t) t)
local notation "E" => CalcJet.coeff η (fun t => 2*B t) hη
lemma gen_corrected (hk : ∀ t∈Icc (0:ℝ) 1,∀ x,(h.fj 2).neg.val t x≠0)
    {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : ℝ) :
    CalcJet.gen (fun t _ => A t) (drift (A:=A) (f:=f))
      ((h.mainJet E).add ((h.ell E).sq.mul ((h.fj 2).neg.inv hk))) t x =
      η t^2*(iteratedDeriv 2 (f t) x)^2/2+
      2*A t/(h.fj 2).neg.val t x*((h.ell E).dx t x-
        (h.ell E).val t x*(h.fj 2).neg.dx t x/(h.fj 2).neg.val t x)^2 := by
  rw [CalcJet.gen_add,gen_square_quotient _ _ hk ht x,h.gen_main hη,h.gen_ell hη,h.gen_curvature]
  have hn : iteratedDeriv 2 (f t) x≠0 := by simpa only [fj,CalcJet.neg,neg_ne_zero] using hk t ht x
  simp only [fj,CalcJet.neg]
  field_simp
  ring
end EvolutionSystem
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming.Hessian
open Higher Parameter
namespace EvolutionSystem
variable {A B : ℝ → ℝ} {f v g : ℝ → ℝ → ℝ} (h : EvolutionSystem A B f v g)
lemma controlled_fj (hpoly : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (f t))) (n : ℕ) :
    CalcJet.Controlled (h.fj n) := ⟨h.fs.2 n,hpoly n⟩
lemma controlled_vj (hpoly : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (v t))) (n : ℕ) :
    CalcJet.Controlled (h.vj n) := ⟨h.vs.2 n,hpoly n⟩
lemma controlled_gj (hpoly : UniformPolynomialGrowth (Icc 0 1) g) :
    CalcJet.Controlled h.gj := ⟨h.gs.2 0,hpoly⟩
lemma controlled_ell {E : CalcJet} (he : E.Controlled)
    (hf : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (f t)))
    (hv : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (v t))) :
    (h.ell E).Controlled :=
  (h.controlled_vj hv 1).add ((he.smul (1/2)).mul
    ((h.controlled_fj hf 3).add ((CalcJet.controlled_rank.mul
      ((h.controlled_fj hf 1).mul (h.controlled_fj hf 2))).smul 2)))
lemma controlled_mu
    (hf : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (f t))) : h.mu.Controlled :=
  (h.controlled_fj hf 4).add (((CalcJet.controlled_rank.mul ((h.controlled_fj hf 2).sq)).smul 2).add
    (((CalcJet.controlled_rank.mul ((h.controlled_fj hf 1).mul (h.controlled_fj hf 3))).smul 4).add
      ((CalcJet.controlled_rank.sq.mul (((h.controlled_fj hf 1).sq).mul (h.controlled_fj hf 2))).smul 4)))
lemma controlled_main {E : CalcJet} (he : E.Controlled)
    (hf : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (f t)))
    (hv : ∀ n,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (v t)))
    (hg : UniformPolynomialGrowth (Icc 0 1) g) : (h.mainJet E).Controlled :=
  ((h.controlled_gj hg).smul 2).add
    ((he.mul ((h.controlled_vj hv 2).add
      ((CalcJet.controlled_rank.mul ((h.controlled_fj hf 1).mul (h.controlled_vj hv 1))).smul 2))).add
        ((he.sq.smul (1/4)).mul (h.controlled_mu hf)))
end EvolutionSystem
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming.Hessian.CalcJet
lemma nonpos_of_reaction_nonneg {u : CalcJet} (hu : Controlled u) {a b r : ℝ → ℝ → ℝ} {A K R : ℝ}
    (hA : 0≤A) (hK : 0≤K) (hR : 0≤R)
    (ha : ∀ t∈Icc (0:ℝ) 1,∀ x,0≤a t x ∧ a t x≤A)
    (hb : ∀ t∈Icc (0:ℝ) 1,∀ x,|b t x|≤K*(1+|x|))
    (hr : ∀ t∈Ico (0:ℝ) 1,∀ x,r t x≤R)
    (hg : ∀ t∈Ico (0:ℝ) 1,∀ x,0≤gen a b u t x+r t x*u.val t x)
    (hterm : ∀ x,u.val 1 x≤0) : ∀ t∈Icc (0:ℝ) 1,∀ x,u.val t x≤0 := by
  have hx : ∀ t∈Icc (0:ℝ) 1,Differentiable ℝ (u.val t) ∧ Differentiable ℝ (deriv (u.val t)) := by
    intro t ht
    refine ⟨fun x => (u.valid.x t ht x).differentiableAt,?_⟩
    rw [u.valid.spatial_deriv ht]
    exact fun x => (u.valid.xx t ht x).differentiableAt
  have hh := VariableDiffusion.backward_reaction_source_upper (H:=0) (S:=0)
    (by norm_num : (0:ℝ)<1) hK hA hR (by norm_num) (by norm_num) hu.1 hx u.valid.time
    ha hb hu.2 hr (fun t ht x => ?_) hterm
  · simpa only [zero_mul,add_zero] using hh
  · rw [u.valid.spatial_deriv2 ⟨ht.1,ht.2.le⟩,u.valid.spatial_deriv ⟨ht.1,ht.2.le⟩]
    simpa only [neg_zero,CalcJet.gen] using hg t ht x
end MicroscopicJamming.Hessian.CalcJet

 
open Set

namespace MicroscopicJamming.Hessian
lemma strict_negative_curvature (u : CalcJet) (hu : u.Controlled)
    {a b c : ℝ → ℝ → ℝ} {A K C H ρ : ℝ}
    (hA : 0≤A) (hK : 0≤K) (hC : 0≤C) (hH : 0≤H) (hρ : 0<ρ)
    (ha : ∀ t∈Icc (0:ℝ) 1,∀ x,0≤a t x ∧ a t x≤A)
    (hb : ∀ t∈Icc (0:ℝ) 1,∀ x,|b t x|≤K*(1+|x|))
    (hc : ∀ t∈Icc (0:ℝ) 1,∀ x,0≤c t x ∧ c t x≤C)
    (hh : ∀ t∈Icc (0:ℝ) 1,∀ x,|u.val t x|≤H)
    (hp : ∀ t∈Ico (0:ℝ) 1,∀ x,CalcJet.gen a b u t x = -c t x*(u.val t x)^2)
    (hterm : ∀ x,u.val 1 x≤-ρ) :
    ∃ δ : ℝ,0<δ ∧ ∀ t∈Icc (0:ℝ) 1,∀ x,δ≤-u.val t x := by
  let R := C*H
  have hR : 0≤R := mul_nonneg hC hH
  have hr (t : ℝ) (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : |c t x*u.val t x|≤R := by
    rw [abs_mul,abs_of_nonneg (hc t ht x).1]
    exact mul_le_mul (hc t ht x).2 (hh t ht x) (abs_nonneg _) hC
  have hnon := CalcJet.nonpos_of_reaction_nonneg (r:=fun t x => c t x*u.val t x) hu hA hK hR ha hb
    (fun t ht x => (le_abs_self _).trans (hr t ⟨ht.1,ht.2.le⟩ x))
    (fun t ht x => by rw [hp t ht x]; nlinarith) (fun x => (hterm x).trans (by linarith))
  let φ : ℝ → ℝ := fun t => ρ*Real.exp (R*(t-1))
  have hφ (t : ℝ) : HasDerivAt φ (R*φ t) t := by
    convert ((((hasDerivAt_id t).sub_const 1).const_mul R).exp.const_mul ρ) using 1 <;>
      first | rfl | (dsimp [φ]; ring)
  have hφc : Continuous φ := continuous_iff_continuousAt.mpr (fun t => (hφ t).continuousAt)
  let p := CalcJet.coeff φ (fun t => R*φ t) (fun t _ => (hφ t).hasDerivWithinAt)
  have hcV : (p.add u).Controlled := (CalcJet.controlled_coeff _ hφc.continuousOn).add hu
  have hV := CalcJet.nonpos_of_reaction_nonneg (a:=a) (b:=b) (r:=fun t x => c t x*u.val t x)
    hcV hA hK (R:=0) (by norm_num) ha hb
    (fun t ht x => mul_nonpos_of_nonneg_of_nonpos (hc t ⟨ht.1,ht.2.le⟩ x).1 (hnon t ⟨ht.1,ht.2.le⟩ x))
    (fun t ht x => ?_) (fun x => ?_)
  · refine ⟨ρ*Real.exp (-R),by positivity,fun t ht x => ?_⟩
    have hv := hV t ht x
    change φ t+u.val t x≤0 at hv
    have he : ρ*Real.exp (-R)≤φ t := by
      apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr _) hρ.le
      nlinarith [mul_nonneg hR ht.1]
    linarith
  · rw [CalcJet.gen_add,hp t ht x]
    change 0≤R*φ t+a t x*0+b t x*0+-c t x*(u.val t x)^2+
      (c t x*u.val t x)*(φ t+u.val t x)
    have hr' := (abs_le.mp (hr t ⟨ht.1,ht.2.le⟩ x)).1
    have hφp : 0≤φ t := mul_nonneg hρ.le (Real.exp_nonneg _)
    nlinarith [mul_nonneg (show 0≤R+c t x*u.val t x by linarith) hφp]
  · change φ 1+u.val 1 x≤0
    have hp1 : φ 1=ρ := by simp [φ]
    rw [hp1]
    linarith [hterm x]
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming.Hessian
open Parameter Higher
lemma actual_second_nonpos {r : ℝ} (hr : 0<r) {A B η : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData (Ioo (-r) r) A B F)
    (hη : ∀ t∈Ico (0:ℝ) 1,HasDerivWithinAt η (2*B t) (Ici t) t)
    (hηc : ContinuousOn η (Icc 0 1)) (hη0 : η 0=0) (hη1 : η 1=0)
    {ρ : ℝ} (hρ : 0<ρ) (htcurv : ∀ x,iteratedDeriv 2 (F 0 1) x≤-ρ) :
    deriv (deriv (fun e => F e 0 0)) 0≤0 := by
  have h0 : (0:ℝ)∈Ioo (-r) r := ⟨by linarith,hr⟩
  let h := actual_evolution hr hf
  let E := CalcJet.coeff η (fun t => 2*B t) hη
  let a : ℝ → ℝ → ℝ := fun t _ => A t
  let b := EvolutionSystem.drift (A:=A) (f:=F 0)
  obtain ⟨D,hD,hcoef,_⟩ := hf.coeff
  obtain ⟨L,hL,hlo⟩ := hf.lower
  obtain ⟨H,hH,hh⟩ := hf.higher 2 (by norm_num)
  have ha (t : ℝ) (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : 0≤a t x ∧ a t x≤D := by
    simpa only [a,zero_mul,add_zero] using hcoef 0 h0 t ht
  have hb (t : ℝ) (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : |b t x|≤(2*D*L)*(1+|x|) := by
    have hat : 0≤A t := (ha t ht x).1
    have hd : A t≤D := (ha t ht x).2
    have hfac : |2*A t*t|≤2*D := by
      rw [abs_of_nonneg (mul_nonneg (mul_nonneg (by norm_num) hat) ht.1)]
      nlinarith [mul_nonneg hat (sub_nonneg.mpr ht.2)]
    change |(2*A t*t)*iteratedDeriv 1 (F 0 t) x|≤_
    rw [abs_mul]
    have hl := (hlo 0 h0 t ht x).2
    simpa only [iteratedDeriv_succ,iteratedDeriv_zero,mul_assoc] using
      mul_le_mul hfac hl (abs_nonneg _) (by positivity : 0≤2*D)
  have hpF (n : ℕ) : UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (F 0 t)) :=
    (hf.poly.bounds n).individual h0
  have hcF := h.controlled_fj hpF 2
  have hcc (t : ℝ) (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : 0≤2*A t*t ∧ 2*A t*t≤2*D := by
    constructor
    · exact mul_nonneg (mul_nonneg (by norm_num) (ha t ht x).1) ht.1
    · nlinarith [mul_nonneg (ha t ht x).1 (sub_nonneg.mpr ht.2),(ha t ht x).2]
  have hP (t : ℝ) (ht : t∈Ico (0:ℝ) 1) (x : ℝ) :
      CalcJet.gen a b (h.fj 2) t x= -(2*A t*t)*((h.fj 2).val t x)^2 := by
    have hn : CalcJet.gen a b (h.fj 2).neg t x = -CalcJet.gen a b (h.fj 2) t x := by
      dsimp [CalcJet.gen,CalcJet.neg]; ring
    have hh' := h.gen_curvature t x
    rw [hn] at hh'
    change -CalcJet.gen a b (h.fj 2) t x=2*A t*t*(-(h.fj 2).val t x)^2 at hh'
    nlinarith
  obtain ⟨δ,hδ,hk⟩ := strict_negative_curvature (a:=a) (b:=b) (c:=fun t _ => 2*A t*t)
    (h.fj 2) hcF hD (show 0≤2*D*L by positivity) (show 0≤2*D by positivity) hH hρ ha hb hcc
    (fun t ht x => hh 0 h0 t ht x) hP htcurv
  have hnonzero : ∀ t∈Icc (0:ℝ) 1,∀ x,(h.fj 2).neg.val t x≠0 :=
    fun t ht x => ne_of_gt (hδ.trans_le (hk t ht x))
  have hparam := hf.parameter_growth hr
  have hterm := hf.parameter_terminal hr
  have hEc : E.Controlled := CalcJet.controlled_coeff hη hηc
  let J := (h.mainJet E).add ((h.ell E).sq.mul ((h.fj 2).neg.inv hnonzero))
  have hJc : J.Controlled :=
    (h.controlled_main hEc hpF hparam.1 (hparam.2 0)).add
      ((h.controlled_ell hEc hpF hparam.1).sq.mul (hcF.neg.inv hδ hk))
  have hJ := CalcJet.nonpos_of_gen_nonneg (u:=J) hJc hD (show 0≤2*D*L by positivity) ha hb
    (fun t ht x => ?_) (fun x => ?_)
  · have hv := hJ 0 (by norm_num) 0
    change (h.mainJet E).val 0 0+((h.ell E).val 0 0*(h.ell E).val 0 0)*((h.fj 2).neg.val 0 0)⁻¹≤0 at hv
    rw [←pow_two] at hv
    have hnn : 0≤((h.ell E).val 0 0)^2*((h.fj 2).neg.val 0 0)⁻¹ :=
      mul_nonneg (sq_nonneg _) (inv_nonneg.mpr ((hδ.trans_le (hk 0 (by norm_num) 0)).le))
    have he : (h.mainJet E).val 0 0=deriv (deriv (fun e => F e 0 0)) 0 := by
      simp only [EvolutionSystem.mainJet,CalcJet.add,CalcJet.smul,CalcJet.const,CalcJet.mul,CalcJet.sq,
        E,CalcJet.coeff,hη0,zero_mul,EvolutionSystem.gj,pjet2,iteratedDeriv_zero]
      ring
    rw [he] at hv
    linarith
  · rw [h.gen_corrected hη hnonzero ⟨ht.1,ht.2.le⟩ x]
    exact add_nonneg (div_nonneg (mul_nonneg (sq_nonneg _) (sq_nonneg _)) (by norm_num))
      (mul_nonneg (div_nonneg (mul_nonneg (by norm_num) (ha t ⟨ht.1,ht.2.le⟩ x).1)
        ((hδ.trans_le (hk t ⟨ht.1,ht.2.le⟩ x)).le)) (sq_nonneg _))
  · have hvterm : (pjet F 0) 1=fun _ => 0 := funext hterm.1
    have hgterm := hterm.2 x
    dsimp [J,EvolutionSystem.mainJet,EvolutionSystem.ell,CalcJet.add,CalcJet.smul,CalcJet.const,
      CalcJet.mul,CalcJet.sq,CalcJet.inv,E,CalcJet.coeff,EvolutionSystem.vj,EvolutionSystem.gj]
    rw [hη1]
    simp only [zero_mul,zero_add]
    rw [hvterm,hgterm]
    simp only [iteratedDeriv_succ,iteratedDeriv_zero,deriv_const,mul_zero,zero_mul,add_zero,le_refl]
end MicroscopicJamming.Hessian

 
open Set

namespace MicroscopicJamming
 

def canonicalRank (u q : ℝ → ℝ) : ℝ → ℝ → ℝ := by
  classical
  exact if h : ∃ f,RowClassicalRankSolution u q f then Classical.choose h else fun _ _ => 0
lemma canonicalRank_spec {u q : ℝ → ℝ} (hex : ∃ f,RowClassicalRankSolution u q f) :
    RowClassicalRankSolution u q (canonicalRank u q) := by
  unfold canonicalRank; rw [dite_eq_left hex]; exact Classical.choose_spec hex
lemma canonicalRank_eq {A B C κ Q : ℝ} {u q : ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (hq : RowSmoothProfile Q q)
    {f : ℝ → ℝ → ℝ} (hf : RowClassicalRankSolution u q f) :
    ∀ t∈Icc (0:ℝ) 1,∀ x,canonicalRank u q t x=f t x := by
  obtain ⟨g,hg,_,huniq⟩ := row_rank_existence_unique hQ hu hq
  intro t ht x
  exact (huniq _ (canonicalRank_spec ⟨f,hf⟩) t ht x).symm.trans (huniq f hf t ht x)
lemma rowSmooth_chord {Q : ℝ} {q₀ q₁ : ℝ → ℝ}
    (h0 : RowSmoothProfile Q q₀) (h1 : RowSmoothProfile Q q₁) {θ : ℝ} (hθ : θ∈Icc (0:ℝ) 1) :
    RowSmoothProfile Q (fun t => q₀ t+θ*(q₁ t-q₀ t)) := by
  refine ⟨h0.1.add (contDiff_const.mul (h1.1.sub h0.1)),?_,?_,?_⟩
  · simp only [h0.2.1,h1.2.1,sub_self,mul_zero,add_zero]
  · simp only [h0.2.2.1,h1.2.2.1,sub_self,mul_zero,add_zero]
  · intro t ht
    have hd := ((h0.1.differentiable (by simp) t).hasDerivAt.add
      (((h1.1.differentiable (by simp) t).hasDerivAt.sub
        (h0.1.differentiable (by simp) t).hasDerivAt).const_mul θ)).deriv
    change 0<deriv (fun s => q₀ s+θ*(q₁ s-q₀ s)) t
    change deriv (fun s => q₀ s+θ*(q₁ s-q₀ s)) t = _ at hd
    rw [hd]
    have a := h0.2.2.2 t ht
    have b := h1.2.2.2 t ht
    by_cases hz : θ=0
    · simpa only [hz,zero_mul,add_zero] using a
    · have hz' : 0<θ := lt_of_le_of_ne hθ.1 (Ne.symm hz)
      nlinarith [mul_pos hz' b,mul_nonneg (sub_nonneg.mpr hθ.2) a.le]
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
lemma twice_derivative_local_shift {φ ψ : ℝ → ℝ} (θ : ℝ)
    (he : φ =ᶠ[𝓝 θ] fun y => ψ (y-θ))
    (hψ : DifferentiableAt ℝ ψ 0 ∧ DifferentiableAt ℝ (deriv ψ) 0) :
    DifferentiableAt ℝ φ θ ∧ DifferentiableAt ℝ (deriv φ) θ ∧
      deriv (deriv φ) θ=deriv (deriv ψ) 0 := by
  have hsub : DifferentiableAt ℝ (fun y : ℝ => y-θ) θ := differentiableAt_id.sub_const θ
  have hd : DifferentiableAt ℝ (fun y => ψ (y-θ)) θ := by
    apply DifferentiableAt.comp θ _ hsub
    simpa only [sub_self] using hψ.1
  have hd2 : DifferentiableAt ℝ (fun y => deriv ψ (y-θ)) θ := by
    have h := DifferentiableAt.comp (g := deriv ψ) (f := fun y : ℝ => y-θ) θ
      (show DifferentiableAt ℝ (deriv ψ) ((fun y : ℝ => y-θ) θ) from by simpa using hψ.2) hsub
    exact h
  have he2 : deriv φ =ᶠ[𝓝 θ] fun y => deriv ψ (y-θ) := by
    filter_upwards [he.deriv] with y hy
    simpa only [deriv_comp_sub_const] using hy
  refine ⟨hd.congr_of_eventuallyEq he,hd2.congr_of_eventuallyEq he2,?_⟩
  rw [he2.deriv_eq,deriv_comp_sub_const,sub_self]
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
open Parameter Hessian
lemma canonicalRank_chord_second {A B C κ Q ρ : ℝ} {u q η : ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (hρ : 0<ρ)
    (hucurv : ∀ x,iteratedDeriv 2 u x≤-ρ)
    (hη : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) η) (hη0 : η 0=0) (hη1 : η 1=0)
    (θ : ℝ) (hqθ : RowSmoothProfile Q (fun s => q s+θ*η s)) :
    let φ := fun z => canonicalRank u (fun s => q s+z*η s) 0 0
    DifferentiableAt ℝ φ θ ∧ DifferentiableAt ℝ (deriv φ) θ ∧ deriv (deriv φ) θ≤0 := by
  dsimp only
  let qθ := fun s => q s+θ*η s
  obtain ⟨r,hr,F,hF,hdata⟩ := actual_parameter_family hQ hu hqθ hη hη0 hη1
  obtain ⟨d,hd,hdq⟩ := rowSmooth_perturbation hqθ hη hη0 hη1
  have hshift : (fun z => canonicalRank u (fun s => q s+z*η s) 0 0) =ᶠ[𝓝 θ] fun z => F (z-θ) 0 0 := by
    filter_upwards [Metric.ball_mem_nhds θ (lt_min hr hd)] with z hz
    have hz' : |z-θ| < min r d := by simpa only [Metric.mem_ball,Real.dist_eq] using hz
    have he : (fun s => (q s+θ*η s)+(z-θ)*η s)=(fun s => q s+z*η s) := by funext s; ring
    rw [←he]
    exact canonicalRank_eq hQ hu (hdq (z-θ) (hz'.trans_le (min_le_right _ _)))
      (hF (z-θ) (hz'.trans_le (min_le_left _ _))) 0 (by norm_num) 0
  have htwice := twice_derivative_local_shift θ hshift
    (show DifferentiableAt ℝ (fun e => F e 0 0) 0 ∧ DifferentiableAt ℝ (deriv (fun e => F e 0 0)) 0 from
      MicroscopicJamming.RankFamilyData.parameter_C2 hdata isOpen_Ioo ⟨by linarith,hr⟩ 0 0 (by norm_num) 0)
  refine ⟨htwice.1,htwice.2.1,?_⟩
  rw [htwice.2.2]
  apply actual_second_nonpos hr hdata _ hη.continuous.continuousOn hη0 hη1 hρ
  · have he : F 0 1=u := funext (hF 0 (by simpa using hr)).2.2.2.2.2.1
    rw [he]
    exact hucurv
  · intro t ht
    convert ((hη.differentiable (by simp) t).hasDerivAt.hasDerivWithinAt :
      HasDerivWithinAt η (deriv η t) (Ici t) t) using 1; first | rfl | ring

lemma canonicalRank_chord_concave_strict {A B C κ Q ρ : ℝ} {u q₀ q₁ : ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (hρ : 0<ρ)
    (hucurv : ∀ x,iteratedDeriv 2 u x≤-ρ)
    (hq0 : RowSmoothProfile Q q₀) (hq1 : RowSmoothProfile Q q₁) :
    ConcaveOn ℝ (Icc 0 1) (fun θ => canonicalRank u (fun s => q₀ s+θ*(q₁ s-q₀ s)) 0 0) := by
  have he := hq1.1.sub hq0.1
  have he0 : (fun s => q₁ s-q₀ s) 0=0 := by dsimp only; rw [hq0.2.1,hq1.2.1]; ring
  have he1 : (fun s => q₁ s-q₀ s) 1=0 := by dsimp only; rw [hq0.2.2.1,hq1.2.2.1]; ring
  have hd (θ : ℝ) (hθ : θ∈Icc (0:ℝ) 1) := canonicalRank_chord_second hQ hu hρ hucurv
    he he0 he1 θ (rowSmooth_chord hq0 hq1 hθ)
  apply concaveOn_of_deriv2_nonpos' (convex_Icc _ _)
    (fun θ hθ => (hd θ hθ).1.differentiableWithinAt)
    (fun θ hθ => (hd θ hθ).2.1.differentiableWithinAt)
  intro θ hθ
  exact (hd θ hθ).2.2
end MicroscopicJamming

 
open Set

namespace MicroscopicJamming
lemma rowTerminal_penalty_jets {u : ℝ → ℝ}
    (hu : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) u) (l : ℝ) (n : ℕ) (x : ℝ) :
    iteratedDeriv n (fun z => u z-l*z^2) x =
      iteratedDeriv n u x-l*((2:ℕ).descFactorial n*x^(2-n)) := by
  rw [iteratedDeriv_fun_sub (hu.of_le (show (n : WithTop ℕ∞) ≤ ((⊤ : ℕ∞) : WithTop ℕ∞) from by exact_mod_cast le_top)).contDiffAt
    (by fun_prop : ContDiffAt ℝ n (fun z : ℝ => l*z^2) x)]
  rw [iteratedDeriv_const_mul_field,iteratedDeriv_pow]

lemma rowTerminal_penalty {A B C κ Q : ℝ} {u : ℝ → ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) {l : ℝ} (hl0 : 0≤l) (hl1 : l≤1) :
    RowAnalyticTerminal (fun z => u z-l*z^2) (A+1) B (C+2) κ Q := by
  refine ⟨hu.1.sub (by fun_prop),by linarith [hu.2.1],by linarith [hu.2.2.1],
    hu.2.2.2.1,hu.2.2.2.2.1,?_,?_⟩
  · intro n hn
    obtain ⟨K,hK⟩ := hu.2.2.2.2.2.1 n hn
    refine ⟨K+2,fun x => ?_⟩
    rw [rowTerminal_penalty_jets hu.1]
    have hn' : 2-n=0 := Nat.sub_eq_zero_of_le hn
    rw [hn',pow_zero,mul_one]
    have hdf : ((2:ℕ).descFactorial n:ℝ)≤2 := by
      rcases eq_or_lt_of_le hn with h|h
      · subst n; norm_num
      · rw [Nat.descFactorial_eq_zero_iff_lt.mpr h]; norm_num
    calc
      _ ≤ |iteratedDeriv n u x|+|l*((2:ℕ).descFactorial n:ℝ)| := abs_sub _ _
      _ ≤ K+2 := by rw [abs_of_nonneg (mul_nonneg hl0 (Nat.cast_nonneg _))]; nlinarith [hK x,(show (0:ℝ)≤((2:ℕ).descFactorial n:ℝ) by positivity)]
  · intro x
    have hh := hu.2.2.2.2.2.2 x
    have hj := rowTerminal_penalty_jets hu.1 l 2 x
    have hj' : deriv (deriv (fun z => u z-l*z^2)) x=deriv (deriv u) x-2*l := by
      norm_num [iteratedDeriv_succ,iteratedDeriv_zero] at hj ⊢
      linarith
    rw [hj']
    refine ⟨?_,?_,?_,?_⟩
    · nlinarith [sq_nonneg x,mul_le_mul_of_nonneg_right hl1 (sq_nonneg x)]
    · nlinarith [mul_nonneg hl0 (sq_nonneg x)]
    · linarith
    · linarith

lemma rowTerminal_penalty_strict {A B C κ Q : ℝ} {u : ℝ → ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (hc : ConcaveOn ℝ univ u) (l x : ℝ) :
    iteratedDeriv 2 (fun z => u z-l*z^2) x≤-(2*l) := by
  have ha : Antitone (deriv u) := by
    intro x y hxy
    exact hc.antitoneOn_deriv (fun z _ => hu.1.differentiable (by simp) z) (mem_univ x) (mem_univ y) hxy
  have hb := ha.deriv_nonpos (x := x)
  rw [rowTerminal_penalty_jets hu.1]
  norm_num [iteratedDeriv_succ,iteratedDeriv_zero] at *
  linarith
end MicroscopicJamming

end

end OAI