import Mathlib
import OAI.Probability.JammingConcavity.RowMixedCalculus

namespace OAI

/-! Row Integral Jets. -/

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 Set Filter MeasureTheory
open scoped Topology

namespace MicroscopicJamming

lemma integral_hasDerivAt_of_jointly_continuous {F G : ℝ → ℝ → ℝ} {a b x : ℝ}
    (hF : ContinuousOn (fun p : ℝ × ℝ => F p.1 p.2) (uIcc a b ×ˢ univ))
    (hG : ContinuousOn (fun p : ℝ × ℝ => G p.1 p.2) (uIcc a b ×ˢ univ))
    (hd : ∀ t∈uIcc a b,∀ y,HasDerivAt (F t) (G t y) y) :
    HasDerivAt (fun y => ∫ t in a..b,F t y) (∫ t in a..b,G t x) x := by
  have hfc (y : ℝ) : ContinuousOn (fun t => F t y) (uIcc a b) :=
    hF.comp (continuousOn_id.prodMk continuousOn_const) (fun t ht => ⟨ht,mem_univ _⟩)
  have hgc (y : ℝ) : ContinuousOn (fun t => G t y) (uIcc a b) :=
    hG.comp (continuousOn_id.prodMk continuousOn_const) (fun t ht => ⟨ht,mem_univ _⟩)
  have hcompact : IsCompact (uIcc a b ×ˢ Icc (x-1) (x+1)) := isCompact_uIcc.prod isCompact_Icc
  obtain ⟨M,hM⟩ := hcompact.exists_bound_of_continuousOn (hG.mono (prod_mono_right (subset_univ _)))
  refine (intervalIntegral.hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (F:=fun y t => F t y) (F':=fun y t => G t y) (s:=Icc (x-1) (x+1))
    (Icc_mem_nhds (by linarith) (by linarith))
    (Eventually.of_forall (fun y => ((hfc y).aestronglyMeasurable measurableSet_uIcc).mono_set uIoc_subset_uIcc))
    (hfc x).intervalIntegrable
    (((hgc x).aestronglyMeasurable measurableSet_uIcc).mono_set uIoc_subset_uIcc)
    (Eventually.of_forall (fun t ht y hy => hM (t,y) ⟨uIoc_subset_uIcc ht,hy⟩))
    (intervalIntegrable_const (c:=M))
    (Eventually.of_forall (fun t ht y _ => hd t (uIoc_subset_uIcc ht) y))).2

lemma iteratedDeriv_integral_of_jets {F : ℝ → ℝ → ℝ} {a b : ℝ}
    (hc : ∀ n : ℕ,ContinuousOn (fun p : ℝ × ℝ => iteratedDeriv n (F p.1) p.2) (uIcc a b ×ˢ univ))
    (hs : ∀ t∈uIcc a b,ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (F t)) :
    ∀ n : ℕ, iteratedDeriv n (fun y => ∫ t in a..b,F t y)=fun y => ∫ t in a..b,iteratedDeriv n (F t) y := by
  intro n
  induction n with
  | zero => simp
  | succ n ih =>
    rw [iteratedDeriv_succ,ih]
    funext x
    exact (integral_hasDerivAt_of_jointly_continuous (hc n) (hc (n+1)) (fun t ht y => by
      have hd := ((contDiff_iff_iteratedDeriv.mp (hs t ht)).2 n (by simp) y).hasDerivAt
      simpa only [iteratedDeriv_succ] using hd)).deriv
end MicroscopicJamming

 
open Set Filter MeasureTheory
open scoped Topology

namespace MicroscopicJamming

lemma evolution_all_jets {Q : ℝ} (hQ : 0<Q) {F G : ℝ → ℝ → ℝ}
    (hcF : ContinuousOn (fun p : ℝ × ℝ => F p.1 p.2) (Icc 0 Q ×ˢ univ))
    (hcG : ∀ n : ℕ,ContinuousOn (fun p : ℝ × ℝ => iteratedDeriv n (G p.1) p.2) (Icc 0 Q ×ˢ univ))
    (hsF : ∀ t∈Icc 0 Q,ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (F t))
    (hsG : ∀ t∈Icc 0 Q,ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (G t))
    (ht : ∀ t∈Ioo 0 Q,∀ x,HasDerivAt (fun r => F r x) (G t x) t) :
    ∀ n : ℕ,∀ t∈Ico 0 Q,∀ x,HasDerivWithinAt (fun r => iteratedDeriv n (F r) x)
      (iteratedDeriv n (G t) x) (Ici t) t := by
  have hsub (t : ℝ) (ht' : t∈Icc 0 Q) : uIcc t Q ⊆ Icc 0 Q := by
    rw [uIcc_of_le ht'.2]; exact Icc_subset_Icc ht'.1 le_rfl
  have heq (t : ℝ) (ht' : t∈Icc 0 Q) : (fun y => ∫ r in t..Q,G r y) = fun y => F Q y-F t y := by
    funext y
    apply intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le ht'.2
    · exact hcF.comp (continuousOn_id.prodMk continuousOn_const) (fun r hr => ⟨⟨ht'.1.trans hr.1,hr.2⟩,mem_univ _⟩)
    · exact fun r hr => ht r ⟨lt_of_le_of_lt ht'.1 hr.1,hr.2⟩ y
    · have hc : ContinuousOn (fun r => iteratedDeriv 0 (G r) y) (uIcc t Q) := (hcG 0).comp (continuousOn_id.prodMk continuousOn_const) (fun r hr => ⟨hsub t ht' hr,mem_univ _⟩)
      simpa only [iteratedDeriv_zero] using hc.intervalIntegrable
  have hjeq (n : ℕ) (t : ℝ) (ht' : t∈Icc 0 Q) (x : ℝ) :
      iteratedDeriv n (F t) x=iteratedDeriv n (F Q) x-∫ r in t..Q,iteratedDeriv n (G r) x := by
    have hh := congrFun (iteratedDeriv_integral_of_jets
      (fun n => (hcG n).mono (prod_mono_left (hsub t ht')))
      (fun r hr => hsG r (hsub t ht' hr)) n) x
    rw [heq t ht'] at hh
    rw [iteratedDeriv_fun_sub ((hsF Q ⟨hQ.le,le_rfl⟩).of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))).contDiffAt
      ((hsF t ht').of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))).contDiffAt] at hh
    linarith
  intro n t htt x
  let E : ℝ → ℝ := fun r => iteratedDeriv n (G (projIcc 0 Q hQ.le r)) x
  have hE : Continuous E := by
    apply ((continuousOn_iff_continuous_domRestrict.mp ((hcG n).comp
      (continuousOn_id.prodMk continuousOn_const) (fun r hr => ⟨hr,mem_univ _⟩))).comp (continuous_projIcc (h:=hQ.le)))
  have hEe (r : ℝ) (hr : r∈Icc 0 Q) : E r=iteratedDeriv n (G r) x := by
    dsimp only [E]; rw [projIcc_of_mem hQ.le hr]
  have hder := (intervalIntegral.integral_hasDerivAt_left (hE.intervalIntegrable t Q)
    hE.aestronglyMeasurable.stronglyMeasurableAtFilter hE.continuousAt).const_sub (iteratedDeriv n (F Q) x)
  have hder' : HasDerivWithinAt (fun r => iteratedDeriv n (F Q) x-∫ s in r..Q,E s)
      (iteratedDeriv n (G t) x) (Ici t) t := by
    simpa only [neg_neg,hEe t ⟨htt.1,htt.2.le⟩] using hder.hasDerivWithinAt (s:=Ici t)
  apply hder'.congr_of_eventuallyEq
  · filter_upwards [Icc_mem_nhdsGE htt.2] with r hr
    have hr' : r∈Icc 0 Q := ⟨htt.1.trans hr.1,hr.2⟩
    rw [hjeq n r hr']
    congr 1
    apply intervalIntegral.integral_congr
    intro s hs
    exact (hEe s ((hsub r hr') hs)).symm
  · rw [hjeq n t ⟨htt.1,htt.2.le⟩]
    congr 1
    apply intervalIntegral.integral_congr
    intro s hs
    exact (hEe s ((hsub t ⟨htt.1,htt.2.le⟩) hs)).symm
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Higher

lemma sum_linear_jet_decompose (n : ℕ) (b u : ℕ → ℝ) :
    (∑ i∈Finset.range (n+2),((n+1).choose i:ℝ)*b i*u (n+1-i+1)) =
      b 0*u (n+2)+(n+1)*b 1*u (n+1)+
        ∑ j∈Finset.range n,((n+1).choose (j+2):ℝ)*b (j+2)*u (n-j) := by
  rw [show n+2=n+1+1 by omega,Finset.sum_range_succ',Finset.sum_range_succ']
  simp only [Nat.choose_zero_right,Nat.cast_one,one_mul,Nat.sub_zero,Nat.choose_one_right,
    Nat.cast_add,Nat.cast_one,Nat.zero_add,Nat.sub_add_cancel (by omega : 1≤n+1)]
  have he : (∑ j∈Finset.range n,((n+1).choose (j+1+1):ℝ)*b (j+1+1)*u (n+1-(j+1+1)+1)) =
      ∑ j∈Finset.range n,((n+1).choose (j+2):ℝ)*b (j+2)*u (n-j) := by
    apply Finset.sum_congr rfl
    intro j hj
    have hh := Finset.mem_range.mp hj
    have ha : n+1-(j+1+1)+1=n-j := by omega
    simp only [ha,Nat.add_assoc]
  rw [he]
  ring

lemma family_linear_bound {ι : Type*} {P : ι → Prop} {Q K R A : ℝ}
    (hQ : 0<Q) (hK : 0≤K) (hR : 0≤R) (hA : 0≤A)
    {U b d r a H : ι → ℝ → ℝ → ℝ}
    (hc : ∀ i,P i → ContinuousOn (fun p : ℝ × ℝ => U i p.1 p.2) (Icc 0 Q ×ˢ univ))
    (hx : ∀ i,P i → ∀ t∈Icc 0 Q,Differentiable ℝ (U i t) ∧ Differentiable ℝ (deriv (U i t)))
    (ht : ∀ i,P i → ∀ t∈Ico 0 Q,∀ x,HasDerivWithinAt (fun s => U i s x) (d i t x) (Ici t) t)
    (ha : ∀ i,P i → ∀ t∈Icc 0 Q,∀ x,0≤a i t x ∧ a i t x≤A)
    (hb : ∀ i,P i → ∀ t∈Icc 0 Q,∀ x,|b i t x|≤K*(1+|x|))
    (hr : ∀ i,P i → ∀ t∈Ico 0 Q,∀ x,r i t x≤R)
    (hg : ∀ i,P i → UniformPolynomialGrowth (Icc 0 Q) (U i))
    (hH : FamilyGrowth P (Icc 0 Q) H)
    (hp : ∀ i,P i → ∀ t∈Ico 0 Q,∀ x,
      d i t x+a i t x*deriv (deriv (U i t)) x+b i t x*deriv (U i t) x+r i t x*U i t x=H i t x)
    (hterm : ∀ i,P i → ∀ x,U i Q x=0) : FamilyGrowth P (Icc 0 Q) U := by
  obtain ⟨n,C,hC,hbd⟩ := hH.polynomial_source
  let g := R+(4*A*(n+2)^2+4*K*(n+2)+1)+1
  have hg0 : 0≤g := by dsimp [g]; positivity
  refine ⟨2*(n+2),C*Real.exp (g*Q),by positivity,fun i hi t htt x => ?_⟩
  have hu := VariableDiffusion.backward_polynomial_source_bound n hQ hK hA hR (le_refl 0) hC
    (hc i hi) (hx i hi) (ht i hi) (ha i hi) (hb i hi) (hg i hi) (hr i hi)
    (fun t htt x => by rw [hp i hi t htt x]; exact hbd i hi t ⟨htt.1,htt.2.le⟩ x)
    (fun x => by rw [hterm i hi x]; simp)
  have hpw : (1+x^2)^(n+2) ≤ (1+|x|)^(2*(n+2)) := by
    rw [pow_mul]
    apply pow_le_pow_left₀ (by positivity)
    nlinarith [sq_abs x,abs_nonneg x]
  calc
    |U i t x| ≤ polynomialBarrier n (0+C) g Q t x := hu t htt x
    _ = C*Real.exp (g*(Q-t))*(1+x^2)^(n+2) := by simp [polynomialBarrier]
    _ ≤ C*Real.exp (g*Q)*(1+|x|)^(2*(n+2)) := by
      apply mul_le_mul _ hpw (by positivity) (by positivity)
      apply mul_le_mul_of_nonneg_left _ hC
      exact Real.exp_le_exp.mpr (by nlinarith [htt.1])

lemma linear_all_jets_growth {ι : Type*} {P : ι → Prop} {Q K A : ℝ}
    (hQ : 0<Q) (hK : 0≤K) (hA : 0≤A)
    {U b H : ι → ℝ → ℝ → ℝ} {a : ι → ℝ → ℝ}
    (hs : ∀ i,P i → JointSpatialSmooth (Icc 0 Q) (U i))
    (ha : ∀ i,P i → ∀ t∈Icc 0 Q,0≤a i t ∧ a i t≤A)
    (hb : ∀ i,P i → ∀ t∈Icc 0 Q,∀ x,|b i t x|≤K*(1+|x|))
    (hbb : ∀ n : ℕ,1≤n → ∃ B : ℝ,0≤B ∧ ∀ i,P i → ∀ t∈Icc 0 Q,∀ x,|iteratedDeriv n (b i t) x|≤B)
    (hg : ∀ i,P i → ∀ n : ℕ,UniformPolynomialGrowth (Icc 0 Q) (fun t => iteratedDeriv n (U i t)))
    (hH : ∀ n : ℕ,FamilyGrowth P (Icc 0 Q) (fun i t => iteratedDeriv n (H i t)))
    (ht : ∀ i,P i → ∀ n : ℕ,∀ t∈Ico 0 Q,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (U i s) x)
      (iteratedDeriv n (H i t) x-a i t*iteratedDeriv (n+2) (U i t) x-
        ∑ j∈Finset.range (n+1),(n.choose j:ℝ)*iteratedDeriv j (b i t) x*iteratedDeriv (n-j+1) (U i t) x)
      (Ici t) t)
    (hterm : ∀ i,P i → ∀ x,U i Q x=0) :
    ∀ n : ℕ,FamilyGrowth P (Icc 0 Q) (fun i t => iteratedDeriv n (U i t)) := by
  have hd (i : ι) (hi : P i) (n : ℕ) (t : ℝ) (htt : t∈Icc 0 Q) :
      Differentiable ℝ (iteratedDeriv n (U i t)) :=
    (contDiff_iff_iteratedDeriv.mp ((hs i hi).1 t htt)).2 n (by simp)
  have htermj (i : ι) (hi : P i) (n : ℕ) (x : ℝ) : iteratedDeriv n (U i Q) x=0 := by
    have he : U i Q=fun _ => 0 := funext (hterm i hi)
    rw [he]
    simp
  intro n
  induction n using Nat.strong_induction_on with
  | h N ih =>
    let D : ι → ℝ → ℝ → ℝ := fun i t x => iteratedDeriv N (H i t) x-a i t*iteratedDeriv (N+2) (U i t) x-
      ∑ j∈Finset.range (N+1),(N.choose j:ℝ)*iteratedDeriv j (b i t) x*iteratedDeriv (N-j+1) (U i t) x
    have hhx (i : ι) (hi : P i) (t : ℝ) (htt : t∈Icc 0 Q) :
        Differentiable ℝ (iteratedDeriv N (U i t)) ∧ Differentiable ℝ (deriv (iteratedDeriv N (U i t))) := by
      exact ⟨hd i hi N t htt,by simpa only [←iteratedDeriv_succ] using hd i hi (N+1) t htt⟩
    cases N with
    | zero =>
      apply family_linear_bound (d:=D) (r:=fun _ _ _ => 0) (a:=fun i t _ => a i t)
        hQ hK (le_refl 0) hA (fun i hi => (hs i hi).2 0) hhx
        (fun i hi => ht i hi 0) (fun i hi t htt _ => ha i hi t htt) hb
        (fun _ _ _ _ _ => le_refl 0) (fun i hi => hg i hi 0) (hH 0) _ (fun i hi => htermj i hi 0)
      intro i hi t htt x
      simp [D,iteratedDeriv_succ]
      ring
    | succ n =>
      obtain ⟨B,hB,hbd⟩ := hbb 1 (by omega)
      let E : ι → ℝ → ℝ → ℝ := fun i t x => iteratedDeriv (n+1) (H i t) x-
        ∑ j∈Finset.range n,((n+1).choose (j+2):ℝ)*iteratedDeriv (j+2) (b i t) x*iteratedDeriv (n-j) (U i t) x
      have hE : FamilyGrowth P (Icc 0 Q) E := by
        apply (hH (n+1)).sub
        apply FamilyGrowth.finset_sum
        intro j hj
        obtain ⟨B',hB',hbd'⟩ := hbb (j+2) (by omega)
        exact ((FamilyGrowth.of_bound hB' hbd').const_mul ((n+1).choose (j+2):ℝ)).mul
          (ih (n-j) (by omega))
      apply family_linear_bound (d:=D) (r:=fun i t x => (n+1)*iteratedDeriv 1 (b i t) x)
        (a:=fun i t _ => a i t) hQ hK (show 0≤((n:ℝ)+1)*B by positivity) hA
        (fun i hi => (hs i hi).2 (n+1)) hhx (fun i hi => ht i hi (n+1))
        (fun i hi t htt _ => ha i hi t htt) hb _ (fun i hi => hg i hi (n+1)) hE _ (fun i hi => htermj i hi (n+1))
      · intro i hi t htt x
        exact mul_le_mul_of_nonneg_left ((le_abs_self _).trans (hbd i hi t ⟨htt.1,htt.2.le⟩ x)) (by positivity)
      · intro i hi t htt x
        dsimp [D,E]
        rw [sum_linear_jet_decompose n (fun j => iteratedDeriv j (b i t) x) (fun j => iteratedDeriv j (U i t) x)]
        simp only [iteratedDeriv_zero,←iteratedDeriv_succ]
        ring
end Higher
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Higher

lemma JointSpatialSmooth.sub {S : Set ℝ} {F G : ℝ → ℝ → ℝ}
    (hf : JointSpatialSmooth S F) (hg : JointSpatialSmooth S G) :
    JointSpatialSmooth S (fun t x => F t x-G t x) := by
  simpa only [neg_one_mul,sub_eq_add_neg] using hf.add (hg.coeff_mul (a:=fun _ => -1) continuousOn_const)

lemma linear_evolution_jets {Q : ℝ} (hQ : 0<Q) {U b H : ℝ → ℝ → ℝ} {a : ℝ → ℝ}
    (hs : JointSpatialSmooth (Icc 0 Q) U) (hb : JointSpatialSmooth (Icc 0 Q) b)
    (hH : JointSpatialSmooth (Icc 0 Q) H) (ha : ContinuousOn a (Icc 0 Q))
    (ht : ∀ t∈Ioo 0 Q,∀ x,HasDerivAt (fun s => U s x)
      (H t x-a t*iteratedDeriv 2 (U t) x-b t x*iteratedDeriv 1 (U t) x) t) :
    ∀ n : ℕ,∀ t∈Ico 0 Q,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (U s) x)
      (iteratedDeriv n (H t) x-a t*iteratedDeriv (n+2) (U t) x-
        ∑ j∈Finset.range (n+1),(n.choose j:ℝ)*iteratedDeriv j (b t) x*iteratedDeriv (n-j+1) (U t) x)
      (Ici t) t := by
  have hG := (hH.sub ((hs.jet 2).coeff_mul ha)).sub (hb.mul (hs.jet 1))
  have hh := evolution_all_jets hQ (by simpa using hs.2 0) hG.2 hs.1 hG.1 ht
  intro n t htt x
  have htcc : t∈Icc 0 Q := ⟨htt.1,htt.2.le⟩
  have hUn (k : ℕ) : ContDiff ℝ (n:WithTop ℕ∞) (iteratedDeriv k (U t)) :=
    ((hs.jet k).1 t htcc).of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
  have hbn : ContDiff ℝ (n:WithTop ℕ∞) (b t) :=
    (hb.1 t htcc).of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
  have hHn : ContDiff ℝ (n:WithTop ℕ∞) (H t) :=
    (hH.1 t htcc).of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
  convert hh n t htt x using 1
  symm
  rw [iteratedDeriv_fun_sub (hHn.sub (contDiff_const.mul (hUn 2))).contDiffAt (hbn.mul (hUn 1)).contDiffAt]
  rw [iteratedDeriv_fun_sub hHn.contDiffAt (contDiff_const.mul (hUn 2)).contDiffAt]
  rw [iteratedDeriv_const_mul_field,iteratedDeriv_fun_mul hbn.contDiffAt (hUn 1).contDiffAt]
  simp only [iteratedDeriv_iteratedDeriv]

end Higher
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Higher

structure PolynomialJetFamily {ι : Type*} (P : ι → Prop) (T : Set ℝ)
    (F : ι → ℝ → ℝ → ℝ) : Prop where
  smooth : ∀ i,P i → JointSpatialSmooth T (F i)
  bounds : ∀ n : ℕ,FamilyGrowth P T (fun i t => iteratedDeriv n (F i t))

lemma PolynomialJetFamily.jet {ι : Type*} {P : ι → Prop} {T : Set ℝ} {F : ι → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily P T F) (n : ℕ) :
    PolynomialJetFamily P T (fun i t => iteratedDeriv n (F i t)) := by
  refine ⟨fun i hi => (hf.smooth i hi).jet n,fun k => ?_⟩
  simpa only [iteratedDeriv_iteratedDeriv] using hf.bounds (k+n)

lemma PolynomialJetFamily.comp {ι κ : Type*} {P : ι → Prop} {R : κ → Prop} {T : Set ℝ}
    {F : ι → ℝ → ℝ → ℝ} (hf : PolynomialJetFamily P T F) (g : κ → ι) (hg : ∀ i,R i → P (g i)) :
    PolynomialJetFamily R T (fun i => F (g i)) :=
  ⟨fun i hi => hf.smooth (g i) (hg i hi),fun n => (hf.bounds n).comp g hg⟩

lemma PolynomialJetFamily.add {ι : Type*} {P : ι → Prop} {T : Set ℝ} {F G : ι → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily P T F) (hg : PolynomialJetFamily P T G) :
    PolynomialJetFamily P T (fun i t x => F i t x+G i t x) := by
  refine ⟨fun i hi => (hf.smooth i hi).add (hg.smooth i hi),fun n => ?_⟩
  apply ((hf.bounds n).add (hg.bounds n)).congr
  intro i hi t ht x
  exact (iteratedDeriv_fun_add ((hf.smooth i hi).1 t ht |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))).contDiffAt
    ((hg.smooth i hi).1 t ht |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))).contDiffAt).symm

lemma PolynomialJetFamily.coeff_mul {ι : Type*} {P : ι → Prop} {T : Set ℝ}
    {F : ι → ℝ → ℝ → ℝ} {a : ι → ℝ → ℝ}
    (hf : PolynomialJetFamily P T F) (ha : ∀ i,P i → ContinuousOn (a i) T)
    {A : ℝ} (hA : 0≤A) (hab : ∀ i,P i → ∀ t∈T,|a i t|≤A) :
    PolynomialJetFamily P T (fun i t x => a i t*F i t x) := by
  refine ⟨fun i hi => (hf.smooth i hi).coeff_mul (ha i hi),fun n => ?_⟩
  apply ((FamilyGrowth.of_bound hA (fun i hi t ht _ => hab i hi t ht)).mul (hf.bounds n)).congr
  intro i hi t ht x
  exact (iteratedDeriv_const_mul_field (n:=n) (x:=x) (a i t) (F i t)).symm

lemma PolynomialJetFamily.const_mul {ι : Type*} {P : ι → Prop} {T : Set ℝ}
    {F : ι → ℝ → ℝ → ℝ} (hf : PolynomialJetFamily P T F) (c : ℝ) :
    PolynomialJetFamily P T (fun i t x => c*F i t x) :=
  hf.coeff_mul (fun _ _ => continuousOn_const) (abs_nonneg c) (fun _ _ _ _ => le_rfl)

lemma PolynomialJetFamily.sub {ι : Type*} {P : ι → Prop} {T : Set ℝ} {F G : ι → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily P T F) (hg : PolynomialJetFamily P T G) :
    PolynomialJetFamily P T (fun i t x => F i t x-G i t x) := by
  simpa only [neg_one_mul,sub_eq_add_neg] using hf.add (hg.const_mul (-1))

lemma PolynomialJetFamily.mul {ι : Type*} {P : ι → Prop} {T : Set ℝ} {F G : ι → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily P T F) (hg : PolynomialJetFamily P T G) :
    PolynomialJetFamily P T (fun i t x => F i t x*G i t x) := by
  refine ⟨fun i hi => (hf.smooth i hi).mul (hg.smooth i hi),fun n => ?_⟩
  have hb : FamilyGrowth P T (fun i t x => ∑ k∈Finset.range (n+1),
      (n.choose k:ℝ)*iteratedDeriv k (F i t) x*iteratedDeriv (n-k) (G i t) x) := by
    apply FamilyGrowth.finset_sum
    intro k hk
    exact ((hf.bounds k).const_mul (n.choose k:ℝ)).mul (hg.bounds (n-k))
  apply hb.congr
  intro i hi t ht x
  exact (iteratedDeriv_fun_mul ((hf.smooth i hi).1 t ht |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))).contDiffAt
    ((hg.smooth i hi).1 t ht |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))).contDiffAt).symm

end Higher
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Parameter

def dd1 (F : ℝ → ℝ) (a b : ℝ) : ℝ := (F b-F a)/(b-a)
def dd2 (F : ℝ → ℝ) (a b c : ℝ) : ℝ := (dd1 F b c-dd1 F a b)/(c-a)
def dd3 (F : ℝ → ℝ) (a b c d : ℝ) : ℝ := (dd2 F b c d-dd2 F a b c)/(d-a)

lemma dd1_sub_slope (F : ℝ → ℝ) {a b c : ℝ}
    (hab : a≠b) (hac : a≠c) (hbc : b≠c) :
    dd1 F a b-dd1 F a c=(b-c)*dd2 F a b c := by
  simp only [dd2,dd1]
  field_simp [sub_ne_zero.mpr hab.symm,sub_ne_zero.mpr hac.symm,sub_ne_zero.mpr hbc.symm]
  ring

lemma dd2_sub_last (F : ℝ → ℝ) {a b c d : ℝ}
    (hab : a≠b) (hac : a≠c) (had : a≠d) (hbc : b≠c) (hbd : b≠d) (hcd : c≠d) :
    dd2 F a b c-dd2 F a b d=(c-d)*dd3 F a b c d := by
  simp only [dd3,dd2,dd1]
  field_simp [sub_ne_zero.mpr hab.symm,sub_ne_zero.mpr hac.symm,sub_ne_zero.mpr had.symm,
    sub_ne_zero.mpr hbc.symm,sub_ne_zero.mpr hbd.symm,sub_ne_zero.mpr hcd.symm]
  ring

lemma dd1_square (F : ℝ → ℝ) (a b : ℝ) :
    dd1 (fun x => (F x)^2) a b=(F a+F b)*dd1 F a b := by unfold dd1; ring

lemma dd2_square (F : ℝ → ℝ) {a b c : ℝ}
    (hab : a≠b) (hac : a≠c) (hbc : b≠c) :
    dd2 (fun x => (F x)^2) a b c=(F a+F c)*dd2 F a b c+dd1 F a b*dd1 F b c := by
  simp only [dd2,dd1]
  field_simp [sub_ne_zero.mpr hab.symm,sub_ne_zero.mpr hac.symm,sub_ne_zero.mpr hbc.symm]
  ring

lemma dd3_square (F : ℝ → ℝ) {a b c d : ℝ}
    (hab : a≠b) (hac : a≠c) (had : a≠d) (hbc : b≠c) (hbd : b≠d) (hcd : c≠d) :
    dd3 (fun x => (F x)^2) a b c d=(F a+F d)*dd3 F a b c d+
      dd1 F a b*dd2 F b c d+dd2 F a b c*dd1 F c d := by
  simp only [dd3,dd2,dd1]
  field_simp [sub_ne_zero.mpr hab.symm,sub_ne_zero.mpr hac.symm,sub_ne_zero.mpr had.symm,
    sub_ne_zero.mpr hbc.symm,sub_ne_zero.mpr hbd.symm,sub_ne_zero.mpr hcd.symm]
  ring

lemma dd1_affine_mul (F : ℝ → ℝ) (A B : ℝ) {a b : ℝ} (hab : a≠b) :
    dd1 (fun x => (A+x*B)*F x) a b=(A+a*B)*dd1 F a b+B*F b := by
  unfold dd1
  field_simp [sub_ne_zero.mpr hab.symm]
  ring

lemma dd2_affine_mul (F : ℝ → ℝ) (A B : ℝ) {a b c : ℝ}
    (hab : a≠b) (hac : a≠c) (hbc : b≠c) :
    dd2 (fun x => (A+x*B)*F x) a b c=(A+a*B)*dd2 F a b c+B*dd1 F b c := by
  simp only [dd2,dd1]
  field_simp [sub_ne_zero.mpr hab.symm,sub_ne_zero.mpr hac.symm,sub_ne_zero.mpr hbc.symm]
  ring

lemma dd3_affine_mul (F : ℝ → ℝ) (A B : ℝ) {a b c d : ℝ}
    (hab : a≠b) (hac : a≠c) (had : a≠d) (hbc : b≠c) (hbd : b≠d) (hcd : c≠d) :
    dd3 (fun x => (A+x*B)*F x) a b c d=(A+a*B)*dd3 F a b c d+B*dd2 F b c d := by
  simp only [dd3,dd2,dd1]
  field_simp [sub_ne_zero.mpr hab.symm,sub_ne_zero.mpr hac.symm,sub_ne_zero.mpr had.symm,
    sub_ne_zero.mpr hbc.symm,sub_ne_zero.mpr hbd.symm,sub_ne_zero.mpr hcd.symm]
  ring

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Parameter
open Higher

structure Nodes2 (I : Set ℝ) where
  a : ℝ
  b : ℝ
  ha : a∈I
  hb : b∈I
  hab : a≠b

structure Nodes3 (I : Set ℝ) extends Nodes2 I where
  c : ℝ
  hc : c∈I
  hac : a≠c
  hbc : b≠c

structure Nodes4 (I : Set ℝ) extends Nodes3 I where
  d : ℝ
  hd : d∈I
  had : a≠d
  hbd : b≠d
  hcd : c≠d

def Nodes3.bc {I : Set ℝ} (p : Nodes3 I) : Nodes2 I := ⟨p.b,p.c,p.hb,p.hc,p.hbc⟩
def Nodes4.bcd {I : Set ℝ} (p : Nodes4 I) : Nodes3 I := ⟨p.toNodes3.bc,p.d,p.hd,p.hbd,p.hcd⟩
def Nodes4.cd {I : Set ℝ} (p : Nodes4 I) : Nodes2 I := ⟨p.c,p.d,p.hc,p.hd,p.hcd⟩

def field1 (F : ℝ → ℝ → ℝ → ℝ) (a b t x : ℝ) : ℝ := dd1 (fun e => F e t x) a b
def field2 (F : ℝ → ℝ → ℝ → ℝ) (a b c t x : ℝ) : ℝ := dd2 (fun e => F e t x) a b c
def field3 (F : ℝ → ℝ → ℝ → ℝ) (a b c d t x : ℝ) : ℝ := dd3 (fun e => F e t x) a b c d

lemma divided_smooth {T : Set ℝ} {F G : ℝ → ℝ → ℝ}
    (hf : JointSpatialSmooth T F) (hg : JointSpatialSmooth T G) (c : ℝ) :
    JointSpatialSmooth T (fun t x => (G t x-F t x)/c) := by
  simpa only [div_eq_mul_inv,mul_comm] using (hg.sub hf).coeff_mul (a:=fun _ => c⁻¹) continuousOn_const

lemma divided_jet (n : ℕ) {F G : ℝ → ℝ}
    (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) F)
    (hg : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) G) (c x : ℝ) :
    iteratedDeriv n (fun y => (G y-F y)/c) x = (iteratedDeriv n G x-iteratedDeriv n F x)/c := by
  have hf' : ContDiff ℝ (n : WithTop ℕ∞) F := hf.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
  have hg' : ContDiff ℝ (n : WithTop ℕ∞) G := hg.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
  simp only [div_eq_mul_inv,mul_comm _ c⁻¹]
  rw [iteratedDeriv_const_mul_field,iteratedDeriv_fun_sub hg'.contDiffAt hf'.contDiffAt]

lemma field1_smooth {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : ∀ e∈I,JointSpatialSmooth T (F e)) (p : Nodes2 I) : JointSpatialSmooth T (field1 F p.a p.b) :=
  divided_smooth (hf p.a p.ha) (hf p.b p.hb) (p.b-p.a)

lemma field2_smooth {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : ∀ e∈I,JointSpatialSmooth T (F e)) (p : Nodes3 I) : JointSpatialSmooth T (field2 F p.a p.b p.c) :=
  divided_smooth (field1_smooth hf p.toNodes2) (field1_smooth hf p.bc) (p.c-p.a)

lemma field3_smooth {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : ∀ e∈I,JointSpatialSmooth T (F e)) (p : Nodes4 I) : JointSpatialSmooth T (field3 F p.a p.b p.c p.d) :=
  divided_smooth (field2_smooth hf p.toNodes3) (field2_smooth hf p.bcd) (p.d-p.a)

lemma field1_jet {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : ∀ e∈I,JointSpatialSmooth T (F e)) (p : Nodes2 I) (n : ℕ) {t : ℝ} (ht : t∈T) (x : ℝ) :
    iteratedDeriv n (field1 F p.a p.b t) x=dd1 (fun e => iteratedDeriv n (F e t) x) p.a p.b :=
  divided_jet n ((hf p.a p.ha).1 t ht) ((hf p.b p.hb).1 t ht) (p.b-p.a) x

lemma field2_jet {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : ∀ e∈I,JointSpatialSmooth T (F e)) (p : Nodes3 I) (n : ℕ) {t : ℝ} (ht : t∈T) (x : ℝ) :
    iteratedDeriv n (field2 F p.a p.b p.c t) x=dd2 (fun e => iteratedDeriv n (F e t) x) p.a p.b p.c := by
  change iteratedDeriv n (fun y => (field1 F p.b p.c t y-field1 F p.a p.b t y)/(p.c-p.a)) x=_
  have hh := divided_jet n ((field1_smooth hf p.toNodes2).1 t ht) ((field1_smooth hf p.bc).1 t ht) (p.c-p.a) x
  dsimp [Nodes3.bc] at hh
  rw [hh]
  have hb := field1_jet hf p.bc n ht x
  dsimp [Nodes3.bc] at hb
  rw [hb,field1_jet hf p.toNodes2 n ht]
  rfl

lemma field3_jet {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : ∀ e∈I,JointSpatialSmooth T (F e)) (p : Nodes4 I) (n : ℕ) {t : ℝ} (ht : t∈T) (x : ℝ) :
    iteratedDeriv n (field3 F p.a p.b p.c p.d t) x=dd3 (fun e => iteratedDeriv n (F e t) x) p.a p.b p.c p.d := by
  change iteratedDeriv n (fun y => (field2 F p.b p.c p.d t y-field2 F p.a p.b p.c t y)/(p.d-p.a)) x=_
  have hh := divided_jet n ((field2_smooth hf p.toNodes3).1 t ht) ((field2_smooth hf p.bcd).1 t ht) (p.d-p.a) x
  dsimp [Nodes4.bcd,Nodes3.bc] at hh
  rw [hh]
  have hb := field2_jet hf p.bcd n ht x
  dsimp [Nodes4.bcd,Nodes3.bc] at hb
  rw [hb,field2_jet hf p.toNodes3 n ht]
  rfl

lemma fixed_family {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily (fun e => e∈I) T F) {e : ℝ} (he : e∈I) :
    PolynomialJetFamily (fun _ : Unit => True) T (fun _ => F e) :=
  hf.comp (fun _ => e) (fun _ _ => he)

lemma field1_individual {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily (fun e => e∈I) T F) (p : Nodes2 I) :
    PolynomialJetFamily (fun _ : Unit => True) T (fun _ => field1 F p.a p.b) := by
  change PolynomialJetFamily (fun _ : Unit => True) T (fun _ t x => (F p.b t x-F p.a t x)/(p.b-p.a))
  have hh := ((fixed_family hf p.hb).sub (fixed_family hf p.ha)).const_mul ((p.b-p.a)⁻¹)
  simpa only [field1,dd1,div_eq_mul_inv,mul_comm (p.b-p.a)⁻¹] using hh

lemma field2_individual {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily (fun e => e∈I) T F) (p : Nodes3 I) :
    PolynomialJetFamily (fun _ : Unit => True) T (fun _ => field2 F p.a p.b p.c) := by
  change PolynomialJetFamily (fun _ : Unit => True) T (fun _ t x => (field1 F p.b p.c t x-field1 F p.a p.b t x)/(p.c-p.a))
  have hh := ((field1_individual hf p.bc).sub (field1_individual hf p.toNodes2)).const_mul ((p.c-p.a)⁻¹)
  simpa only [Nodes3.bc,field2,field1,dd2,div_eq_mul_inv,mul_comm (p.c-p.a)⁻¹] using hh

lemma field3_individual {I T : Set ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : PolynomialJetFamily (fun e => e∈I) T F) (p : Nodes4 I) :
    PolynomialJetFamily (fun _ : Unit => True) T (fun _ => field3 F p.a p.b p.c p.d) := by
  change PolynomialJetFamily (fun _ : Unit => True) T (fun _ t x => (field2 F p.b p.c p.d t x-field2 F p.a p.b p.c t x)/(p.d-p.a))
  have hh := ((field2_individual hf p.bcd).sub (field2_individual hf p.toNodes3)).const_mul ((p.d-p.a)⁻¹)
  simpa only [Nodes4.bcd,Nodes3.bc,field3,field2,dd3,div_eq_mul_inv,mul_comm (p.d-p.a)⁻¹] using hh

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
lemma rowSmooth_perturbation {Q : ℝ} {q η : ℝ → ℝ}
    (hq : RowSmoothProfile Q q)
    (hη : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) η) (hη0 : η 0=0) (hη1 : η 1=0) :
    ∃ r : ℝ, 0<r ∧ ∀ ε, |ε|<r → RowSmoothProfile Q (fun s => q s+ε*η s) := by
  have hqc : Continuous (deriv q) := (contDiff_infty_iff_deriv.mp hq.1).2.continuous
  have hηc : Continuous (deriv η) := (contDiff_infty_iff_deriv.mp hη).2.continuous
  obtain ⟨c,hc,hcmin⟩ := isCompact_Icc.exists_forall_le' hqc.continuousOn hq.2.2.2
  obtain ⟨s,hs,hmax⟩ := isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr (by norm_num : (0:ℝ)≤1)) hηc.abs.continuousOn
  let M := |deriv η s|+1
  have hM : 0<M := by dsimp [M]; positivity
  refine ⟨c/(2*M),div_pos hc (by positivity),fun ε hε => ?_⟩
  refine ⟨hq.1.add (contDiff_const.mul hη),?_,?_,?_⟩
  · simp [hq.2.1,hη0]
  · simp [hq.2.2.1,hη1]
  · intro t ht
    have hd := ((hq.1.differentiable (by simp) t).hasDerivAt.add
      ((hη.differentiable (by simp) t).hasDerivAt.const_mul ε)).deriv
    change 0 < deriv (q + fun y => ε*η y) t
    rw [hd]
    have hle : |deriv η t| ≤ M := (hmax ht).trans (by dsimp [M]; linarith)
    have hmul : |ε| *M<c/2 := by
      have hh := (lt_div_iff₀ (show 0<2*M by positivity)).mp hε
      nlinarith
    have hh := mul_le_mul_of_nonneg_left hle (abs_nonneg ε)
    have hb : |ε*deriv η t|<c/2 := by rw [abs_mul]; exact hh.trans_lt hmul
    linarith [neg_abs_le (ε*deriv η t),hcmin t ht]

 

lemma row_rank_neighborhood_existence {A B C κ Q : ℝ} {u q η : ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (hq : RowSmoothProfile Q q)
    (hη : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) η) (hη0 : η 0=0) (hη1 : η 1=0) :
    ∃ r : ℝ, 0<r ∧ ∃ f : ℝ → ℝ → ℝ → ℝ,
      ∀ ε, |ε|<r → RowClassicalRankSolution u (fun s => q s+ε*η s) (f ε) := by
  classical
  obtain ⟨r,hr,hrq⟩ := rowSmooth_perturbation hq hη hη0 hη1
  have hex : ∀ ε, ∃ f, |ε|<r → RowClassicalRankSolution u (fun s => q s+ε*η s) f := by
    intro ε
    by_cases he : |ε|<r
    · obtain ⟨f,hf,_⟩ := row_rank_existence_unique hQ hu (hrq ε he)
      exact ⟨f,fun _ => hf⟩
    · exact ⟨fun _ _ => 0,fun hh => (he hh).elim⟩
  choose f hf using hex
  exact ⟨r,hr,f,hf⟩
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming

lemma row_variance_jet_uniform {A B C κ Q : ℝ} {u : ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (k : ℕ) (hk : 2≤k) :
    ∃ H : ℝ,0≤H ∧ ∀ m : ℝ → ℝ,ContinuousOn m (Icc 0 Q) →
      (∀ t∈Icc 0 Q,0 ≤ m t ∧ m t≤1) → ∀ F : ℝ → ℝ → ℝ,
      RowClassicalVarianceSolution Q u m F →
      ∀ t∈Icc 0 Q,∀ x,|iteratedDeriv k (F t) x|≤H := by
  obtain ⟨H,hH,hbound⟩ := Higher.gaussianRowComposition_all_jets hQ hu k hk
  refine ⟨H,hH,fun m hm hmb F hF => ?_⟩
  obtain ⟨L,hL,hh⟩ := row_variance_existence A B C κ Q hQ hu.2.1 hu.2.2.1 hu.2.2.2.1 hu.2.2.2.2.1
  obtain ⟨G,hG,_,huniq,hconv⟩ := hh u hu m hm hmb
  obtain ⟨rs,hrs,hT,hrm⟩ := exists_gaussian_grid_approximation hQ hm hmb
  have hc : CylinderConvergence (fun n => gaussianStepPath (rs n) u) F (Icc 0 Q) := by
    intro R hR
    exact (hconv rs hrs hT hrm R hR).congr_right (fun p hp => huniq F hF p.1 hp.1 p.2)
  have hvalid (n : ℕ) (t : ℝ) (ht : t∈Icc 0 Q) :
      (∀ r∈gaussianStepRemainder (rs n) t,0≤r.1 ∧ r.1≤1 ∧ 0≤r.2) ∧
      gaussianStepTime (gaussianStepRemainder (rs n) t)≤Q := by
    obtain ⟨hv,he⟩ := gaussianStepRemainder_valid (hrs n) ht.1
    refine ⟨hv,?_⟩
    rw [he,hT,max_eq_left (by linarith [ht.2])]
    linarith [ht.1]
  have hs (n : ℕ) (t : ℝ) (ht : t∈Icc 0 Q) :
      ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (gaussianStepPath (rs n) u t) :=
    (Higher.gaussianRowComposition_smoothPolynomial hQ hu _ (hvalid n t ht).1 (hvalid n t ht).2).smooth
  have hb : ∀ l : ℕ,2≤l → ∃ J : ℝ,0≤J ∧ ∀ n t,t∈Icc 0 Q → ∀ x,
      |iteratedDeriv l (gaussianStepPath (rs n) u t) x|≤J := by
    intro l hl
    obtain ⟨J,hJ,hh⟩ := Higher.gaussianRowComposition_all_jets hQ hu l hl
    exact ⟨J,hJ,fun n t ht x => hh _ (hvalid n t ht).1 (hvalid n t ht).2 x⟩
  have hj := (hc.all_jets hs hb).1 k
  intro t ht x
  exact le_of_tendsto (hj.tendsto_at ht x).abs (Eventually.of_forall (fun n =>
    hbound _ (hvalid n t ht).1 (hvalid n t ht).2 x))

lemma row_rank_smooth {A B C κ Q : ℝ} {u q : ℝ → ℝ} {f : ℝ → ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (hq : RowSmoothProfile Q q)
    (hf : RowClassicalRankSolution u q f) : Higher.JointSpatialSmooth (Icc 0 1) f := by
  obtain ⟨m,hm,hmb,hinv,hleft⟩ := rowSmooth_inverse hq
  have hF := rowRank_to_variance hq hm hmb hinv hleft hf
  have hh := row_variance_all_jets hQ hu hm hmb hF
  have he (s : ℝ) (hs : s∈Icc (0:ℝ) 1) : m (q s)=s := hleft s hs
  refine ⟨fun s hs => ?_,fun n => ?_⟩
  · simpa only [he s hs] using hh.1 (q s) (hq.mapsTo hs)
  · have hc := (hh.2.1 n).comp
      (((hq.1.continuous.comp continuous_fst).prodMk continuous_snd).continuousOn)
      (fun (p : ℝ × ℝ) (hp : p∈Icc 0 1 ×ˢ univ) => (show (q p.1,p.2)∈Icc 0 Q ×ˢ univ from ⟨hq.mapsTo hp.1,mem_univ _⟩))
    apply hc.congr
    intro p hp
    change iteratedDeriv n (f p.1) p.2=iteratedDeriv n (f (m (q p.1))) p.2
    rw [he p.1 hp.1]

lemma row_rank_jets_time {A B C κ Q : ℝ} {u q : ℝ → ℝ} {f : ℝ → ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) (hq : RowSmoothProfile Q q)
    (hf : RowClassicalRankSolution u q f) :
    ∀ n : ℕ,∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (f s) x)
      (iteratedDeriv n (fun y => -(deriv q t)/2*(iteratedDeriv 2 (f t) y+t*(iteratedDeriv 1 (f t) y)^2)) x)
      (Ici t) t := by
  have hs := row_rank_smooth hQ hu hq hf
  have ha : ContinuousOn (fun t => deriv q t/2) (Icc (0:ℝ) 1) :=
    ((contDiff_infty_iff_deriv.mp hq.1).2.continuous.div_const 2).continuousOn
  have hg := hs.row_rhs ha continuousOn_id
  apply evolution_all_jets (by norm_num : (0:ℝ)<1) hf.1 (by simpa only [neg_div,id_eq] using hg.2)
    hs.1 (by simpa only [neg_div,id_eq] using hg.1)
  intro t ht x
  simpa only [iteratedDeriv_succ,iteratedDeriv_zero] using hf.2.2.2.2.1 t ht x

lemma row_rank_uniform_bounds {A B C κ Q : ℝ} {u : ℝ → ℝ}
    (hQ : 0<Q) (hu : RowAnalyticTerminal u A B C κ Q) :
    ∃ L : ℝ,0≤L ∧ ∃ H : ℕ → ℝ,(∀ n,0≤H n) ∧
      ∀ q : ℝ → ℝ,RowSmoothProfile Q q → ∀ f : ℝ → ℝ → ℝ,
      RowClassicalRankSolution u q f →
      (∀ t∈Icc (0:ℝ) 1,∀ x,|f t x|≤L*(1+x^2) ∧ |deriv (f t) x|≤L*(1+|x|)) ∧
      (∀ n : ℕ,2≤n → ∀ t∈Icc (0:ℝ) 1,∀ x,|iteratedDeriv n (f t) x|≤H n) := by
  classical
  obtain ⟨L,hL,hsolve⟩ := row_variance_existence A B C κ Q hQ hu.2.1 hu.2.2.1 hu.2.2.2.1 hu.2.2.2.2.1
  have hh : ∀ n : ℕ,∃ H : ℝ,0≤H ∧ ∀ m,ContinuousOn m (Icc 0 Q) →
      (∀ t∈Icc 0 Q,0 ≤ m t ∧ m t≤1) → ∀ F,RowClassicalVarianceSolution Q u m F →
      2≤n → ∀ t∈Icc 0 Q,∀ x,|iteratedDeriv n (F t) x|≤H := by
    intro n
    by_cases hn : 2≤n
    · obtain ⟨H,hH,hh⟩ := row_variance_jet_uniform hQ hu n hn
      exact ⟨H,hH,fun m hm hmb F hF _ => hh m hm hmb F hF⟩
    · exact ⟨0,le_refl _,fun _ _ _ _ _ h => (hn h).elim⟩
  choose H hH hHbound using hh
  let D := L+A*(1+Q)+|B|
  have hA : 0≤A := hu.2.1
  have hD : 0≤D := by dsimp [D]; positivity
  refine ⟨D,hD,H,hH,fun q hq f hf => ?_⟩
  obtain ⟨m,hm,hmb,hinv,hleft⟩ := rowSmooth_inverse hq
  have hF := rowRank_to_variance hq hm hmb hinv hleft hf
  obtain ⟨G,hG,hbd,huniq,_⟩ := hsolve u hu m hm hmb
  have he (t : ℝ) (htt : t∈Icc 0 Q) : G t=f (m t) := funext (fun x => huniq _ hF t htt x)
  have hb (t : ℝ) (htt : t∈Icc (0:ℝ) 1) (x : ℝ) := hbd (q t) (hq.mapsTo htt) x
  constructor
  · intro t htt x
    have hb' := hb t htt x
    rw [he (q t) (hq.mapsTo htt),hleft t htt] at hb'
    have hq0 := (hq.mapsTo htt).1
    have hval : |f t x| ≤ (A*(1+Q)+|B|)*(1+x^2) := by
      rw [abs_le]
      constructor
      · nlinarith [hb'.1,abs_nonneg B,mul_nonneg hA (sq_nonneg x),mul_nonneg (abs_nonneg B) (sq_nonneg x),mul_nonneg hA hq0,mul_nonneg (mul_nonneg hA hQ.le) (sq_nonneg x)]
      · nlinarith [hb'.2.1,le_abs_self B,abs_nonneg B,mul_nonneg (abs_nonneg B) (sq_nonneg x),mul_nonneg hA (sq_nonneg x),mul_nonneg (mul_nonneg hA hQ.le) (sq_nonneg x),mul_nonneg hA hQ.le]
    refine ⟨hval.trans (mul_le_mul_of_nonneg_right (by dsimp [D]; linarith) (by positivity)),?_⟩
    exact hb'.2.2.1.trans (mul_le_mul_of_nonneg_right (by dsimp [D]; linarith [mul_nonneg hA (show 0≤1+Q by linarith),abs_nonneg B]) (by positivity))
  · intro n hn t htt x
    simpa only [hleft t htt] using hHbound n m hm hmb _ hF hn (q t) (hq.mapsTo htt) x
end MicroscopicJamming

end

end OAI