lean/OAI/Probability/JammingConcavity/RowParameterData.lean

import Mathlib
import OAI.Probability.JammingConcavity.RowIntegralJets

namespace OAI

/-! Row Parameter Data. -/

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
open scoped Topology

namespace MicroscopicJamming
namespace Parameter
open Higher

structure RankFamilyData (I : Set ℝ) (A B : ℝ → ℝ) (F : ℝ → ℝ → ℝ → ℝ) : Prop where
  Acont : ContinuousOn A (Icc 0 1)
  Bcont : ContinuousOn B (Icc 0 1)
  coeff : ∃ D : ℝ,0≤D ∧ (∀ e∈I,∀ t∈Icc (0:ℝ) 1,0≤A t+e*B t ∧ A t+e*B t≤D) ∧
    ∀ t∈Icc (0:ℝ) 1,|B t|≤D
  smooth : ∀ e∈I,JointSpatialSmooth (Icc 0 1) (F e)
  lower : ∃ L : ℝ,0≤L ∧ ∀ e∈I,∀ t∈Icc (0:ℝ) 1,∀ x,
    |F e t x|≤L*(1+x^2) ∧ |deriv (F e t) x|≤L*(1+|x|)
  higher : ∀ n : ℕ,2≤n → ∃ H : ℝ,0≤H ∧ ∀ e∈I,∀ t∈Icc (0:ℝ) 1,∀ x,|iteratedDeriv n (F e t) x|≤H
  time : ∀ e∈I,∀ t∈Ioo (0:ℝ) 1,∀ x,HasDerivAt (fun s => F e s x)
    (-(A t+e*B t)*(iteratedDeriv 2 (F e t) x+t*(iteratedDeriv 1 (F e t) x)^2)) t
  terminal : ∀ e∈I,∀ e'∈I,∀ x,F e 1 x=F e' 1 x

lemma RankFamilyData.poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) : PolynomialJetFamily (fun e => e∈I) (Icc 0 1) F := by
  refine ⟨hf.smooth,fun n => ?_⟩
  obtain ⟨L,hL,hb⟩ := hf.lower
  rcases n with _|(_|n)
  · exact FamilyGrowth.of_quadratic_bound hL (fun e he t ht x => (hb e he t ht x).1)
  · simpa only [iteratedDeriv_succ,iteratedDeriv_zero] using
      FamilyGrowth.of_linear_bound hL (fun e he t ht x => (hb e he t ht x).2)
  · obtain ⟨H,hH,hh⟩ := hf.higher (n+2) (by omega)
    exact FamilyGrowth.of_bound hH hh

lemma RankFamilyData.diffusion_cont {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) (e : ℝ) : ContinuousOn (fun t => A t+e*B t) (Icc 0 1) :=
  hf.Acont.add (continuousOn_const.mul hf.Bcont)

lemma RankFamilyData.endpoint_linear {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) {ι : Type*} (l r : ι → ℝ) (hl : ∀ i,l i∈I) (hr : ∀ i,r i∈I)
    {U H : ι → ℝ → ℝ → ℝ}
    (hs : ∀ i,JointSpatialSmooth (Icc 0 1) (U i))
    (hg : ∀ i,∀ n : ℕ,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv n (U i t)))
    (hH : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) H)
    (ht : ∀ i,∀ t∈Ioo (0:ℝ) 1,∀ x,HasDerivAt (fun s => U i s x)
      (H i t x-(A t+l i*B t)*iteratedDeriv 2 (U i t) x-
        ((A t+l i*B t)*t*(iteratedDeriv 1 (F (l i) t) x+iteratedDeriv 1 (F (r i) t) x))*iteratedDeriv 1 (U i t) x) t)
    (hterm : ∀ i,∀ x,U i 1 x=0) : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) U := by
  obtain ⟨D,hD,hcoef,hB⟩ := hf.coeff
  obtain ⟨L,hL,hlo⟩ := hf.lower
  let a := fun i t => A t+l i*B t
  let b := fun i t x => a i t*t*(iteratedDeriv 1 (F (l i) t) x+iteratedDeriv 1 (F (r i) t) x)
  have hc (i : ι) : ContinuousOn (fun t => a i t*t) (Icc 0 1) := (hf.diffusion_cont (l i)).mul continuousOn_id
  have hfac (i : ι) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) : |a i t*t|≤D := by
    rw [abs_mul,abs_of_nonneg (hcoef (l i) (hl i) t ht).1,abs_of_nonneg ht.1]
    exact (mul_le_mul_of_nonneg_right (hcoef (l i) (hl i) t ht).2 ht.1).trans (by nlinarith [ht.2])
  have hb (i : ι) : JointSpatialSmooth (Icc 0 1) (b i) :=
    (((hf.smooth (l i) (hl i)).jet 1).add ((hf.smooth (r i) (hr i)).jet 1)).coeff_mul (hc i)
  have hbb : ∀ n : ℕ,1≤n → ∃ E : ℝ,0≤E ∧ ∀ i,True → ∀ t∈Icc (0:ℝ) 1,∀ x,|iteratedDeriv n (b i t) x|≤E := by
    intro n hn
    obtain ⟨E,hE,he⟩ := hf.higher (n+1) (by omega)
    refine ⟨D*(E+E),by positivity,fun i _ t ht x => ?_⟩
    have hlc := ((hf.smooth (l i) (hl i)).jet 1).1 t ht
    have hrc := ((hf.smooth (r i) (hr i)).jet 1).1 t ht
    have hlc' : ContDiff ℝ (n:WithTop ℕ∞) (iteratedDeriv 1 (F (l i) t)) := hlc.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
    have hrc' : ContDiff ℝ (n:WithTop ℕ∞) (iteratedDeriv 1 (F (r i) t)) := hrc.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤))
    dsimp [b]
    rw [iteratedDeriv_const_mul_field,iteratedDeriv_fun_add hlc'.contDiffAt hrc'.contDiffAt]
    simp only [iteratedDeriv_iteratedDeriv]
    rw [abs_mul]
    exact mul_le_mul (hfac i ht) ((abs_add_le _ _).trans (add_le_add (he (l i) (hl i) t ht x) (he (r i) (hr i) t ht x))) (abs_nonneg _) hD
  refine ⟨fun i _ => hs i,?_⟩
  apply linear_all_jets_growth (a:=a) (b:=b) (H:=H) (by norm_num : (0:ℝ)<1)
    (show 0≤D*(L+L) by positivity) hD (fun i _ => hs i)
    (fun i _ t ht => hcoef (l i) (hl i) t ht) _ hbb (fun i _ n => hg i n) hH.bounds _ (fun i _ => hterm i)
  · intro i _ t ht x
    dsimp [b]
    rw [abs_mul]
    apply (mul_le_mul (hfac i ht) (le_refl _) (abs_nonneg _) hD).trans
    calc
      D*|iteratedDeriv 1 (F (l i) t) x+iteratedDeriv 1 (F (r i) t) x| ≤
          D*(L*(1+|x|)+L*(1+|x|)) := by
        apply mul_le_mul_of_nonneg_left _ hD
        simpa only [iteratedDeriv_succ,iteratedDeriv_zero] using
          (abs_add_le (deriv (F (l i) t) x) (deriv (F (r i) t) x)).trans (add_le_add (hlo (l i) (hl i) t ht x).2 (hlo (r i) (hr i) t ht x).2)
      _ = _ := by ring
  · intro i _
    exact linear_evolution_jets (by norm_num) (hs i) (hb i) (hH.smooth i trivial)
      (hf.diffusion_cont (l i)) (ht i)

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Parameter
open Higher

lemma actual_parameter_family {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 : ℝ → ℝ → ℝ → ℝ,
      (∀ e,|e|<r → RowClassicalRankSolution u (fun s => q s+e*η s) (F e)) ∧
      RankFamilyData (Ioo (-r) r) (fun t => deriv q t/2) (fun t => deriv η t/2) F := by
  classical
  obtain ⟨r,hr,hrq⟩ := rowSmooth_perturbation hq hη hη0 hη1
  have hex : ∀ e,∃ f,|e|<r → RowClassicalRankSolution u (fun s => q s+e*η s) f := by
    intro e
    by_cases he : |e|<r
    · obtain ⟨f,hf,_⟩ := row_rank_existence_unique hQ hu (hrq e he)
      exact ⟨f,fun _ => hf⟩
    · exact ⟨fun _ _ => 0,fun h => (he h).elim⟩
  choose F hF using hex
  have hi (e : ℝ) (he : e∈Ioo (-r) r) : |e|<r := abs_lt.mpr he
  obtain ⟨L,hL,H,hH,hbounds⟩ := row_rank_uniform_bounds hQ hu
  have hqc := (contDiff_infty_iff_deriv.mp hq.1).2.continuous
  have hηc := (contDiff_infty_iff_deriv.mp hη).2.continuous
  obtain ⟨tq,htq,hqmax⟩ := isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr (by norm_num : (0:ℝ)≤1)) hqc.abs.continuousOn
  obtain ⟨tη,htη,hηmax⟩ := isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr (by norm_num : (0:ℝ)≤1)) hηc.abs.continuousOn
  have heder (e t : ℝ) : deriv (fun s => q s+e*η s) t=deriv q t+e*deriv η t := by
    exact (((hq.1.differentiable (by simp) t).hasDerivAt).add
      ((hη.differentiable (by simp) t).hasDerivAt.const_mul e)).deriv
  refine ⟨r,hr,F,hF,?_⟩
  refine ⟨(hqc.div_const 2).continuousOn,(hηc.div_const 2).continuousOn,?_,?_,?_,?_,?_,?_⟩
  · let D : ℝ := |deriv q tq|/2+r*(|deriv η tη|/2)+|deriv η tη|/2
    refine ⟨D,by dsimp [D]; positivity,?_,?_⟩
    · intro e he t ht
      have hpos := (hrq e (hi e he)).2.2.2 t ht
      rw [heder] at hpos
      refine ⟨by linarith,?_⟩
      have hab : |e|≤r := (hi e he).le
      have hm := mul_le_mul hab ((div_le_div_iff_of_pos_right (by norm_num : (0:ℝ)<2)).mpr (hηmax ht)) (by positivity) hr.le
      calc
        deriv q t/2+e*(deriv η t/2) ≤ |deriv q t|/2+|e| *(|deriv η t|/2) := by
          have ht1 := le_abs_self (deriv q t)
          have ht2 := le_abs_self (e*(deriv η t/2))
          rw [abs_mul,abs_div,abs_of_pos (by norm_num : (0:ℝ)<2)] at ht2
          linarith
        _ ≤ |deriv q tq|/2+r*(|deriv η tη|/2) := add_le_add (by
          have hqbd : |deriv q t| ≤ |deriv q tq| := hqmax ht
          linarith) hm
        _ ≤ D := by dsimp [D]; linarith [abs_nonneg (deriv η tη)]
    · intro t ht
      rw [abs_div,abs_of_pos (by norm_num : (0:ℝ)<2)]
      have hh : |deriv η t| ≤ |deriv η tη| := hηmax ht
      dsimp [D]
      nlinarith [abs_nonneg (deriv q tq),abs_nonneg (deriv η tη),mul_nonneg hr.le (abs_nonneg (deriv η tη))]
  · intro e he
    exact row_rank_smooth hQ hu (hrq e (hi e he)) (hF e (hi e he))
  · exact ⟨L,hL,fun e he => (hbounds _ (hrq e (hi e he)) _ (hF e (hi e he))).1⟩
  · intro n hn
    exact ⟨H n,hH n,fun e he => (hbounds _ (hrq e (hi e he)) _ (hF e (hi e he))).2 n hn⟩
  · intro e he t ht x
    have hh := (hF e (hi e he)).2.2.2.2.1 t ht x
    rw [heder] at hh
    convert hh using 1
    simp only [iteratedDeriv_succ,iteratedDeriv_zero]
    ring
  · intro e he e' he' x
    exact ((hF e (hi e he)).2.2.2.2.2.1 x).trans ((hF e' (hi e' he')).2.2.2.2.2.1 x).symm

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Parameter

lemma dd1_add (F G : ℝ → ℝ) (a b : ℝ) : dd1 (fun e => F e+G e) a b=dd1 F a b+dd1 G a b := by unfold dd1; ring
lemma dd2_add (F G : ℝ → ℝ) (a b c : ℝ) : dd2 (fun e => F e+G e) a b c=dd2 F a b c+dd2 G a b c := by unfold dd2; rw [dd1_add,dd1_add]; ring
lemma dd3_add (F G : ℝ → ℝ) (a b c d : ℝ) : dd3 (fun e => F e+G e) a b c d=dd3 F a b c d+dd3 G a b c d := by unfold dd3; rw [dd2_add,dd2_add]; ring
lemma dd1_mul (F : ℝ → ℝ) (k a b : ℝ) : dd1 (fun e => k*F e) a b=k*dd1 F a b := by unfold dd1; ring
lemma dd2_mul (F : ℝ → ℝ) (k a b c : ℝ) : dd2 (fun e => k*F e) a b c=k*dd2 F a b c := by unfold dd2; rw [dd1_mul,dd1_mul]; ring
lemma dd3_mul (F : ℝ → ℝ) (k a b c d : ℝ) : dd3 (fun e => k*F e) a b c d=k*dd3 F a b c d := by unfold dd3; rw [dd2_mul,dd2_mul]; ring

lemma dd1_rhs (X Y : ℝ → ℝ) (A B t : ℝ) {a b : ℝ} (hab : a≠b) :
    dd1 (fun e => -(A+e*B)*(Y e+t*(X e)^2)) a b =
    -B*(Y b+t*(X b)^2)-(A+a*B)*dd1 Y a b-
      ((A+a*B)*t*(X a+X b))*dd1 X a b := by
  have he : (fun e => -(A+e*B)*(Y e+t*(X e)^2)) = fun e => -1*((A+e*B)*(Y e+t*(X e)^2)) := by funext e; ring
  rw [he,dd1_mul,dd1_affine_mul _ _ _ hab,dd1_add,dd1_mul,dd1_square]
  ring

lemma dd2_rhs (X Y : ℝ → ℝ) (A B t : ℝ) {a b c : ℝ}
    (hab : a≠b) (hac : a≠c) (hbc : b≠c) :
    dd2 (fun e => -(A+e*B)*(Y e+t*(X e)^2)) a b c =
    (-(A+a*B)*t*dd1 X a b*dd1 X b c-B*(dd1 Y b c+t*(X b+X c)*dd1 X b c))-
      (A+a*B)*dd2 Y a b c-((A+a*B)*t*(X a+X c))*dd2 X a b c := by
  have he : (fun e => -(A+e*B)*(Y e+t*(X e)^2)) = fun e => -1*((A+e*B)*(Y e+t*(X e)^2)) := by funext e; ring
  rw [he,dd2_mul,dd2_affine_mul _ _ _ hab hac hbc,dd2_add,dd2_mul,dd2_square _ hab hac hbc,
    dd1_add,dd1_mul,dd1_square]
  ring

lemma dd3_rhs (X Y : ℝ → ℝ) (A B t : ℝ) {a b c d : ℝ}
    (hab : a≠b) (hac : a≠c) (had : a≠d) (hbc : b≠c) (hbd : b≠d) (hcd : c≠d) :
    dd3 (fun e => -(A+e*B)*(Y e+t*(X e)^2)) a b c d =
    (-(A+a*B)*t*(dd1 X a b*dd2 X b c d+dd2 X a b c*dd1 X c d)-
      B*(dd2 Y b c d+t*((X b+X d)*dd2 X b c d+dd1 X b c*dd1 X c d)))-
      (A+a*B)*dd3 Y a b c d-((A+a*B)*t*(X a+X d))*dd3 X a b c d := by
  have he : (fun e => -(A+e*B)*(Y e+t*(X e)^2)) = fun e => -1*((A+e*B)*(Y e+t*(X e)^2)) := by funext e; ring
  rw [he,dd3_mul,dd3_affine_mul _ _ _ hab hac had hbc hbd hcd,dd3_add,dd3_mul,
    dd3_square _ hab hac had hbc hbd hcd,dd2_add,dd2_mul,dd2_square _ hbc hbd hcd]
  ring

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Parameter
open Higher

lemma field1_time {I : Set ℝ} {F : ℝ → ℝ → ℝ} {D : ℝ → ℝ} {t : ℝ}
    (hf : ∀ e∈I,HasDerivAt (F e) (D e) t) (p : Nodes2 I) :
    HasDerivAt (fun s => dd1 (fun e => F e s) p.a p.b) (dd1 D p.a p.b) t :=
  ((hf p.b p.hb).sub (hf p.a p.ha)).div_const (p.b-p.a)

lemma field2_time {I : Set ℝ} {F : ℝ → ℝ → ℝ} {D : ℝ → ℝ} {t : ℝ}
    (hf : ∀ e∈I,HasDerivAt (F e) (D e) t) (p : Nodes3 I) :
    HasDerivAt (fun s => dd2 (fun e => F e s) p.a p.b p.c) (dd2 D p.a p.b p.c) t :=
  ((field1_time hf p.bc).sub (field1_time hf p.toNodes2)).div_const (p.c-p.a)

lemma field3_time {I : Set ℝ} {F : ℝ → ℝ → ℝ} {D : ℝ → ℝ} {t : ℝ}
    (hf : ∀ e∈I,HasDerivAt (F e) (D e) t) (p : Nodes4 I) :
    HasDerivAt (fun s => dd3 (fun e => F e s) p.a p.b p.c p.d) (dd3 D p.a p.b p.c p.d) t :=
  ((field2_time hf p.bcd).sub (field2_time hf p.toNodes3)).div_const (p.d-p.a)

def source1 {I : Set ℝ} (F : ℝ → ℝ → ℝ → ℝ) (B : ℝ → ℝ) (p : Nodes2 I) (t x : ℝ) : ℝ :=
  -B t*(iteratedDeriv 2 (F p.b t) x+t*(iteratedDeriv 1 (F p.b t) x)^2)

def source2 {I : Set ℝ} (F : ℝ → ℝ → ℝ → ℝ) (A B : ℝ → ℝ) (p : Nodes3 I) (t x : ℝ) : ℝ :=
  -(A t+p.a*B t)*t*iteratedDeriv 1 (field1 F p.a p.b t) x*iteratedDeriv 1 (field1 F p.b p.c t) x-
  B t*(iteratedDeriv 2 (field1 F p.b p.c t) x+
  t*(iteratedDeriv 1 (F p.b t) x+iteratedDeriv 1 (F p.c t) x)*iteratedDeriv 1 (field1 F p.b p.c t) x)

def source3 {I : Set ℝ} (F : ℝ → ℝ → ℝ → ℝ) (A B : ℝ → ℝ) (p : Nodes4 I) (t x : ℝ) : ℝ :=
  -(A t+p.a*B t)*t*(iteratedDeriv 1 (field1 F p.a p.b t) x*iteratedDeriv 1 (field2 F p.b p.c p.d t) x+
    iteratedDeriv 1 (field2 F p.a p.b p.c t) x*iteratedDeriv 1 (field1 F p.c p.d t) x)-
  B t*(iteratedDeriv 2 (field2 F p.b p.c p.d t) x+t*(
    (iteratedDeriv 1 (F p.b t) x+iteratedDeriv 1 (F p.d t) x)*iteratedDeriv 1 (field2 F p.b p.c p.d t) x+
    iteratedDeriv 1 (field1 F p.b p.c t) x*iteratedDeriv 1 (field1 F p.c p.d t) x))

lemma field1_equation {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) (p : Nodes2 I) {t : ℝ} (ht : t∈Ioo (0:ℝ) 1) (x : ℝ) :
    HasDerivAt (fun s => field1 F p.a p.b s x)
    (source1 F B p t x-(A t+p.a*B t)*iteratedDeriv 2 (field1 F p.a p.b t) x-
      ((A t+p.a*B t)*t*(iteratedDeriv 1 (F p.a t) x+iteratedDeriv 1 (F p.b t) x))*iteratedDeriv 1 (field1 F p.a p.b t) x) t := by
  have hh := field1_time (fun e he => hf.time e he t ht x) p
  have htc : t∈Icc (0:ℝ) 1 := ⟨ht.1.le,ht.2.le⟩
  rw [dd1_rhs _ _ _ _ _ p.hab] at hh
  simpa only [field1_jet hf.smooth p 2 htc x,field1_jet hf.smooth p 1 htc x,source1,field1] using hh

lemma field2_equation {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) (p : Nodes3 I) {t : ℝ} (ht : t∈Ioo (0:ℝ) 1) (x : ℝ) :
    HasDerivAt (fun s => field2 F p.a p.b p.c s x)
    (source2 F A B p t x-(A t+p.a*B t)*iteratedDeriv 2 (field2 F p.a p.b p.c t) x-
      ((A t+p.a*B t)*t*(iteratedDeriv 1 (F p.a t) x+iteratedDeriv 1 (F p.c t) x))*iteratedDeriv 1 (field2 F p.a p.b p.c t) x) t := by
  have hh := field2_time (fun e he => hf.time e he t ht x) p
  have htc : t∈Icc (0:ℝ) 1 := ⟨ht.1.le,ht.2.le⟩
  rw [dd2_rhs _ _ _ _ _ p.hab p.hac p.hbc] at hh
  unfold source2
  rw [field2_jet hf.smooth p 2 htc x,field2_jet hf.smooth p 1 htc x,
    field1_jet hf.smooth p.toNodes2 1 htc x]
  have hbc1 := field1_jet hf.smooth p.bc 1 htc x
  have hbc2 := field1_jet hf.smooth p.bc 2 htc x
  dsimp [Nodes3.bc] at hbc1 hbc2
  rw [hbc1,hbc2]
  exact hh

lemma field3_equation {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) (p : Nodes4 I) {t : ℝ} (ht : t∈Ioo (0:ℝ) 1) (x : ℝ) :
    HasDerivAt (fun s => field3 F p.a p.b p.c p.d s x)
    (source3 F A B p t x-(A t+p.a*B t)*iteratedDeriv 2 (field3 F p.a p.b p.c p.d t) x-
      ((A t+p.a*B t)*t*(iteratedDeriv 1 (F p.a t) x+iteratedDeriv 1 (F p.d t) x))*iteratedDeriv 1 (field3 F p.a p.b p.c p.d t) x) t := by
  have hh := field3_time (fun e he => hf.time e he t ht x) p
  have htc : t∈Icc (0:ℝ) 1 := ⟨ht.1.le,ht.2.le⟩
  rw [dd3_rhs _ _ _ _ _ p.hab p.hac p.had p.hbc p.hbd p.hcd] at hh
  unfold source3
  rw [field3_jet hf.smooth p 2 htc x,field3_jet hf.smooth p 1 htc x,
    field1_jet hf.smooth p.toNodes3.toNodes2 1 htc x,field2_jet hf.smooth p.toNodes3 1 htc x]
  have hbc1 := field1_jet hf.smooth p.toNodes3.bc 1 htc x
  have hcd1 := field1_jet hf.smooth p.cd 1 htc x
  have hbcd1 := field2_jet hf.smooth p.bcd 1 htc x
  have hbcd2 := field2_jet hf.smooth p.bcd 2 htc x
  dsimp [Nodes3.bc,Nodes4.cd,Nodes4.bcd] at hbc1 hcd1 hbcd1 hbcd2
  rw [hbc1,hcd1,hbcd1,hbcd2]
  exact hh

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
namespace Parameter
open Higher

lemma family_mul_time {ι : Type*} {G : ι → ℝ → ℝ → ℝ}
    (hG : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) G) :
    PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) (fun i t x => t*G i t x) :=
  hG.coeff_mul (fun _ _ => continuousOn_id) (by norm_num : (0:ℝ)≤1)
    (fun _ _ _ ht => by rw [abs_of_nonneg ht.1]; exact ht.2)

lemma RankFamilyData.mul_B {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) {ι : Type*} {G : ι → ℝ → ℝ → ℝ}
    (hG : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) G) :
    PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) (fun i t x => B t*G i t x) := by
  obtain ⟨D,hD,_,hB⟩ := hf.coeff
  exact hG.coeff_mul (fun _ _ => hf.Bcont) hD (fun _ _ => hB)

lemma RankFamilyData.mul_at {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) {ι : Type*} (l : ι → ℝ) (hl : ∀ i,l i∈I) {G : ι → ℝ → ℝ → ℝ}
    (hG : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) G) :
    PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) (fun i t x => (A t+l i*B t)*t*G i t x) := by
  obtain ⟨D,hD,ha,_⟩ := hf.coeff
  apply hG.coeff_mul (fun i _ => (hf.diffusion_cont (l i)).mul continuousOn_id) hD
  intro i _ t ht
  change |(A t+l i*B t)*t|≤D
  rw [abs_mul,abs_of_nonneg (ha (l i) (hl i) t ht).1,abs_of_nonneg ht.1]
  exact (mul_le_mul_of_nonneg_right (ha (l i) (hl i) t ht).2 ht.1).trans (by nlinarith [ht.2])

lemma source1_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) : PolynomialJetFamily (fun _ : Nodes2 I => True) (Icc 0 1) (source1 F B) := by
  have hbase := hf.poly.comp (R:=fun _ => True) (fun p : Nodes2 I => p.b) (fun p _ => p.hb)
  have hh := (hf.mul_B ((hbase.jet 2).add (family_mul_time ((hbase.jet 1).mul (hbase.jet 1))))).const_mul (-1)
  convert hh using 1
  funext p t x
  dsimp only [source1]
  ring

lemma field1_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) :
    PolynomialJetFamily (fun _ : Nodes2 I => True) (Icc 0 1) (fun p => field1 F p.a p.b) := by
  apply hf.endpoint_linear (fun p : Nodes2 I => p.a) (fun p => p.b) (fun p => p.ha) (fun p => p.hb)
    (field1_smooth hf.smooth) (fun p n => ((field1_individual hf.poly p).bounds n).individual (i:=()) trivial)
    (source1_poly hf) (fun p t ht x => field1_equation hf p ht x)
  intro p x
  unfold field1 dd1
  dsimp only
  rw [hf.terminal p.b p.hb p.a p.ha x]
  simp

lemma source2_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) : PolynomialJetFamily (fun _ : Nodes3 I => True) (Icc 0 1) (source2 F A B) := by
  have hab := (field1_poly hf).comp (R:=fun _ => True) (fun p : Nodes3 I => p.toNodes2) (fun _ _ => trivial)
  have hbc := (field1_poly hf).comp (R:=fun _ => True) (fun p : Nodes3 I => p.bc) (fun _ _ => trivial)
  have hb := hf.poly.comp (R:=fun _ => True) (fun p : Nodes3 I => p.b) (fun p _ => p.hb)
  have hc := hf.poly.comp (R:=fun _ => True) (fun p : Nodes3 I => p.c) (fun p _ => p.hc)
  have hleft := (hf.mul_at (fun p : Nodes3 I => p.a) (fun p => p.ha) ((hab.jet 1).mul (hbc.jet 1))).const_mul (-1)
  have hright := hf.mul_B ((hbc.jet 2).add (family_mul_time (((hb.jet 1).add (hc.jet 1)).mul (hbc.jet 1))))
  convert hleft.sub hright using 1
  funext p t x
  dsimp only [source2,Nodes3.bc]
  ring

lemma field2_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) :
    PolynomialJetFamily (fun _ : Nodes3 I => True) (Icc 0 1) (fun p => field2 F p.a p.b p.c) := by
  apply hf.endpoint_linear (fun p : Nodes3 I => p.a) (fun p => p.c) (fun p => p.ha) (fun p => p.hc)
    (field2_smooth hf.smooth) (fun p n => ((field2_individual hf.poly p).bounds n).individual (i:=()) trivial)
    (source2_poly hf) (fun p t ht x => field2_equation hf p ht x)
  intro p x
  unfold field2 dd2 dd1
  dsimp only
  rw [hf.terminal p.b p.hb p.a p.ha x,hf.terminal p.c p.hc p.a p.ha x]
  simp

lemma source3_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) : PolynomialJetFamily (fun _ : Nodes4 I => True) (Icc 0 1) (source3 F A B) := by
  have hab := (field1_poly hf).comp (R:=fun _ => True) (fun p : Nodes4 I => p.toNodes3.toNodes2) (fun _ _ => trivial)
  have hbc := (field1_poly hf).comp (R:=fun _ => True) (fun p : Nodes4 I => p.toNodes3.bc) (fun _ _ => trivial)
  have hcd := (field1_poly hf).comp (R:=fun _ => True) (fun p : Nodes4 I => p.cd) (fun _ _ => trivial)
  have habc := (field2_poly hf).comp (R:=fun _ => True) (fun p : Nodes4 I => p.toNodes3) (fun _ _ => trivial)
  have hbcd := (field2_poly hf).comp (R:=fun _ => True) (fun p : Nodes4 I => p.bcd) (fun _ _ => trivial)
  have hb := hf.poly.comp (R:=fun _ => True) (fun p : Nodes4 I => p.b) (fun p _ => p.hb)
  have hd := hf.poly.comp (R:=fun _ => True) (fun p : Nodes4 I => p.d) (fun p _ => p.hd)
  have hleft := (hf.mul_at (fun p : Nodes4 I => p.a) (fun p => p.ha)
    (((hab.jet 1).mul (hbcd.jet 1)).add ((habc.jet 1).mul (hcd.jet 1)))).const_mul (-1)
  have hright := hf.mul_B ((hbcd.jet 2).add (family_mul_time
    ((((hb.jet 1).add (hd.jet 1)).mul (hbcd.jet 1)).add ((hbc.jet 1).mul (hcd.jet 1)))))
  convert hleft.sub hright using 1
  funext p t x
  dsimp only [source3,Nodes3.bc,Nodes4.cd,Nodes4.bcd]
  ring

lemma field3_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) :
    PolynomialJetFamily (fun _ : Nodes4 I => True) (Icc 0 1) (fun p => field3 F p.a p.b p.c p.d) := by
  apply hf.endpoint_linear (fun p : Nodes4 I => p.a) (fun p => p.d) (fun p => p.ha) (fun p => p.hd)
    (field3_smooth hf.smooth) (fun p n => ((field3_individual hf.poly p).bounds n).individual (i:=()) trivial)
    (source3_poly hf) (fun p t ht x => field3_equation hf p ht x)
  intro p x
  unfold field3 dd3 dd2 dd1
  dsimp only
  rw [hf.terminal p.b p.hb p.a p.ha x,hf.terminal p.c p.hc p.a p.ha x,hf.terminal p.d p.hd p.a p.ha x]
  simp

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology NNReal

namespace MicroscopicJamming
namespace Parameter

lemma differentiable_of_dd2_bound {F : ℝ → ℝ} {I : Set ℝ} (hI : IsOpen I)
    {M : ℝ} (hM : 0≤M)
    (hb : ∀ a∈I,∀ b∈I,∀ c∈I,a≠b → a≠c → b≠c → |dd2 F a b c|≤M) :
    ∀ a∈I,DifferentiableAt ℝ F a := by
  intro a ha
  let K : ℝ≥0 := ⟨M,hM⟩
  have hLip : LipschitzOnWith K (dd1 F a) (I\{a}) := by
    apply LipschitzOnWith.of_dist_le_mul
    intro b hb' c hc'
    by_cases hbc : b=c
    · simp [hbc]
    have hab : a≠b := (show b≠a from hb'.2).symm
    have hac : a≠c := (show c≠a from hc'.2).symm
    rw [Real.dist_eq,Real.dist_eq,dd1_sub_slope F hab hac hbc,abs_mul]
    calc
      |b-c| * |dd2 F a b c| ≤ |b-c| * M := mul_le_mul_of_nonneg_left (hb a ha b hb'.1 c hc'.1 hab hac hbc) (abs_nonneg _)
      _ = _ := by change |b-c| * M = M * |b-c|; ring
  obtain ⟨g,hg,he⟩ := hLip.extend_real
  have hd : HasDerivAt F (g a) a := by
    rw [hasDerivAt_iff_tendsto_slope]
    apply (hg.continuous.continuousAt.tendsto.mono_left nhdsWithin_le_nhds).congr'
    filter_upwards [Filter.Eventually.filter_mono nhdsWithin_le_nhds (hI.mem_nhds ha),self_mem_nhdsWithin] with y hy hya
    rw [slope_def_field]
    exact (he ⟨hy,hya⟩).symm
  exact hd.differentiableAt

lemma tendsto_dd2_left {F : ℝ → ℝ} (hF : DifferentiableAt ℝ F 0) {k : ℝ} (hk : k≠0) :
    Tendsto (fun h => dd2 F 0 h k) (𝓝[≠] 0) (𝓝 ((dd1 F 0 k-deriv F 0)/k)) := by
  have h1 : Tendsto (fun h => dd1 F h k) (𝓝[≠] 0) (𝓝 (dd1 F 0 k)) := by
    unfold dd1
    apply Tendsto.div
    · exact tendsto_const_nhds.sub (hF.continuousAt.tendsto.mono_left nhdsWithin_le_nhds)
    · exact tendsto_const_nhds.sub (tendsto_id.mono_left nhdsWithin_le_nhds)
    · simpa using hk
  have h2 : Tendsto (fun h => dd1 F 0 h) (𝓝[≠] 0) (𝓝 (deriv F 0)) := by
    have he : (fun h => dd1 F 0 h)=slope F 0 := funext (fun h => (slope_def_field F 0 h).symm)
    rw [he]
    exact hF.hasDerivAt.tendsto_slope
  simpa only [dd2,sub_zero] using (h1.sub h2).div_const k

lemma second_remainder_lipschitz {F : ℝ → ℝ} {I : Set ℝ} (hI : IsOpen I) (h0 : (0:ℝ)∈I)
    (hF : DifferentiableAt ℝ F 0) {M : ℝ} (hM : 0≤M)
    (hb : ∀ a∈I,∀ b∈I,∀ c∈I,∀ d∈I,
      a≠b → a≠c → a≠d → b≠c → b≠d → c≠d → |dd3 F a b c d|≤M) :
    LipschitzOnWith ⟨M,hM⟩ (fun k => (dd1 F 0 k-deriv F 0)/k) (I\{0}) := by
  apply LipschitzOnWith.of_dist_le_mul
  intro k hk l hl
  by_cases hkl : k=l
  · simp [hkl]
  have hk0 : k≠0 := hk.2
  have hl0 : l≠0 := hl.2
  rw [Real.dist_eq,Real.dist_eq]
  have hc := ((tendsto_dd2_left hF hk0).sub (tendsto_dd2_left hF hl0)).abs
  apply le_of_tendsto hc
  have heg : ∀ᶠ h in 𝓝[≠] (0:ℝ),h∈I ∧ h≠0 ∧ h≠k ∧ h≠l := by
    filter_upwards [Filter.Eventually.filter_mono nhdsWithin_le_nhds (hI.mem_nhds h0),self_mem_nhdsWithin,
      Filter.Eventually.filter_mono nhdsWithin_le_nhds (isOpen_ne.mem_nhds hk0.symm),
      Filter.Eventually.filter_mono nhdsWithin_le_nhds (isOpen_ne.mem_nhds hl0.symm)]
      with h hi hne hnk hnl
    exact ⟨hi,hne,hnk,hnl⟩
  filter_upwards [heg] with h hh
  rw [dd2_sub_last F hh.2.1.symm hk0.symm hl0.symm hh.2.2.1 hh.2.2.2 hkl,abs_mul]
  calc
    |k-l| * |dd3 F 0 h k l| ≤ |k-l| * M := mul_le_mul_of_nonneg_left
      (hb 0 h0 h hh.1 k hk.1 l hl.1 hh.2.1.symm hk0.symm hl0.symm hh.2.2.1 hh.2.2.2 hkl) (abs_nonneg _)
    _ = _ := by change |k-l| * M = M * |k-l|; ring

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology NNReal

namespace MicroscopicJamming
namespace Parameter

lemma twice_differentiable_of_dd_bounds {F : ℝ → ℝ} {I : Set ℝ} (hI : IsOpen I) (h0 : (0:ℝ)∈I)
    {M₂ M₃ : ℝ} (hM₂ : 0≤M₂) (hM₃ : 0≤M₃)
    (hb₂ : ∀ a∈I,∀ b∈I,∀ c∈I,a≠b → a≠c → b≠c → |dd2 F a b c|≤M₂)
    (hb₃ : ∀ a∈I,∀ b∈I,∀ c∈I,∀ d∈I,
      a≠b → a≠c → a≠d → b≠c → b≠d → c≠d → |dd3 F a b c d|≤M₃) :
    DifferentiableAt ℝ F 0 ∧ DifferentiableAt ℝ (deriv F) 0 := by
  have hd := differentiable_of_dd2_bound hI hM₂ hb₂
  refine ⟨hd 0 h0,?_⟩
  obtain ⟨g,hg,he⟩ := (second_remainder_lipschitz hI h0 (hd 0 h0) hM₃ hb₃).extend_real
  have hgm (k : ℝ) (hk : k∈I\{0}) :
      g k=(dd1 F 0 k-deriv F 0)/k := (he hk).symm
  have hgd (k : ℝ) (hk : k∈I\{0}) : DifferentiableAt ℝ g k := by
    have hk0 : k≠0 := hk.2
    have hr : DifferentiableAt ℝ (fun k => (dd1 F 0 k-deriv F 0)/k) k := by
      unfold dd1
      exact ((((hd k hk.1).sub_const _).div (differentiableAt_id.sub_const _) (by simpa using hk0)).sub_const _).div
        differentiableAt_id hk0
    apply hr.congr_of_eventuallyEq
    filter_upwards [(hI.sdiff isClosed_singleton).mem_nhds hk] with y hy
    exact hgm y hy
  have hrepr (k : ℝ) (hk : k∈I\{0}) : F k=F 0+deriv F 0*k+g k*k^2 := by
    rw [hgm k hk]
    unfold dd1
    have hk0 : k≠0 := hk.2
    simp only [sub_zero]
    field_simp
    ring
  have hder (k : ℝ) (hk : k∈I\{0}) :
      deriv F k=deriv F 0+deriv g k*k^2+g k*(2*k) := by
    have hh := ((hasDerivAt_const k (F 0)).add ((hasDerivAt_id k).const_mul (deriv F 0))).add
      ((hgd k hk).hasDerivAt.mul ((hasDerivAt_id k).pow 2))
    change HasDerivAt (fun y => F 0+deriv F 0*y+g y*y^2)
      (0+deriv F 0*1+(deriv g k*k^2+g k*(2*k^(2-1)*1))) k at hh
    norm_num only [Nat.reduceSub,pow_one,mul_one,zero_add] at hh
    have hhe : HasDerivAt F (deriv F 0+deriv g k*k^2+g k*(2*k)) k := by
      have ha : deriv F 0+(deriv g k*k^2+g k*(2*k))=deriv F 0+deriv g k*k^2+g k*(2*k) := by ring
      rw [ha] at hh
      apply hh.congr_of_eventuallyEq
      filter_upwards [(hI.sdiff isClosed_singleton).mem_nhds hk] with y hy
      exact hrepr y hy
    exact hhe.deriv
  have hb (k : ℝ) : |deriv g k|≤M₃ := by
    have hh := (norm_deriv_le_of_lipschitz hg : ‖deriv g k‖≤(⟨M₃,hM₃⟩:ℝ≥0))
    change |deriv g k|≤M₃ at hh
    exact hh
  have hv : Tendsto (fun k : ℝ => deriv g k*k) (𝓝 0) (𝓝 0) := by
    have hbound (k : ℝ) : ‖deriv g k*k‖≤M₃*|k| := by
      rw [Real.norm_eq_abs,abs_mul]
      exact mul_le_mul_of_nonneg_right (hb k) (abs_nonneg _)
    have hh : Tendsto (fun k : ℝ => M₃*|k|) (𝓝 0) (𝓝 0) := by
      have hc := (((continuous_const : Continuous (fun _ : ℝ => M₃)).mul continuous_abs).continuousAt (x:= (0:ℝ))).tendsto
      change Tendsto (fun k : ℝ => M₃*|k|) (𝓝 0) (𝓝 (M₃*|0|)) at hc
      simpa only [abs_zero,mul_zero] using hc
    exact squeeze_zero_norm hbound hh
  have hsl : Tendsto (slope (deriv F) 0) (𝓝[≠] 0) (𝓝 (2*g 0)) := by
    have hh : Tendsto (fun k : ℝ => deriv g k*k+2*g k) (𝓝[≠] 0) (𝓝 (0+2*g 0)) := (hv.mono_left nhdsWithin_le_nhds).add
      ((hg.continuous.continuousAt.tendsto.mono_left nhdsWithin_le_nhds).const_mul 2)
    simp only [zero_add] at hh
    apply hh.congr'
    filter_upwards [Filter.Eventually.filter_mono nhdsWithin_le_nhds (hI.mem_nhds h0),self_mem_nhdsWithin] with k hk hk0
    rw [slope_def_field,hder k ⟨hk,hk0⟩]
    have hkne : k≠0 := hk0
    simp only [sub_zero]
    field_simp
    ring
  exact (hasDerivAt_iff_tendsto_slope.mpr hsl).differentiableAt

end Parameter
end MicroscopicJamming

 
open Set Filter
open scoped Topology

namespace MicroscopicJamming
open Higher Parameter

lemma RankFamilyData.parameter_C2 {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ}
    (hf : RankFamilyData I A B F) (hI : IsOpen I) (h0 : (0:ℝ)∈I) :
    ∀ n : ℕ,∀ t∈Icc (0:ℝ) 1,∀ x,
      DifferentiableAt ℝ (fun e => iteratedDeriv n (F e t) x) 0 ∧
      DifferentiableAt ℝ (deriv (fun e => iteratedDeriv n (F e t) x)) 0 := by
  intro n t ht x
  obtain ⟨n₂,C₂,hC₂,hb₂⟩ := (field2_poly hf).bounds n
  obtain ⟨n₃,C₃,hC₃,hb₃⟩ := (field3_poly hf).bounds n
  apply twice_differentiable_of_dd_bounds hI h0 (show 0≤C₂*(1+|x|)^n₂ by positivity)
    (show 0≤C₃*(1+|x|)^n₃ by positivity)
  · intro a ha b hb c hc hab hac hbc
    let p : Nodes3 I := ⟨⟨a,b,ha,hb,hab⟩,c,hc,hac,hbc⟩
    have hh := hb₂ p trivial t ht x
    dsimp only at hh
    rw [field2_jet hf.smooth p n ht x] at hh
    exact hh
  · intro a ha b hb c hc d hd hab hac had hbc hbd hcd
    let p : Nodes4 I := ⟨⟨⟨a,b,ha,hb,hab⟩,c,hc,hac,hbc⟩,d,hd,had,hbd,hcd⟩
    have hh := hb₃ p trivial t ht x
    dsimp only at hh
    rw [field3_jet hf.smooth p n ht x] at hh
    exact hh

 

theorem row_parameter : RowParameterStatement := by
  intro u q η A B C κ Q hQ hu hq hη hη0 hη1
  obtain ⟨r,hr,F,hF,hdata⟩ := actual_parameter_family hQ hu hq hη hη0 hη1
  refine ⟨r,hr,F,hF,?_⟩
  exact RankFamilyData.parameter_C2 hdata isOpen_Ioo ⟨by linarith,hr⟩

end MicroscopicJamming

end

end OAI