Download data/lean/OAI/Probability/JammingConcavity/RowParameterData.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 32.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/JammingConcavity/RowParameterData.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/JammingConcavity/RowParameterData.lean
-
curl -L -o RowParameterData.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/JammingConcavity/RowParameterData.lean
32.1 kB
| 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 | |