| import Mathlib | |
| import OAI.Probability.JammingConcavity.RowParameterData | |
| namespace OAI | |
| /-! Row Derivative Approx. -/ | |
| noncomputable section | |
| open MeasureTheory ProbabilityTheory Set | |
| open scoped NNReal ENNReal | |
| open Set Filter | |
| open scoped Topology | |
| open MeasureTheory ProbabilityTheory Filter Set | |
| open scoped ENNReal NNReal Topology BigOperators | |
| open MeasureTheory Filter Set | |
| open scoped ENNReal NNReal BigOperators | |
| open MeasureTheory ProbabilityTheory Set Filter | |
| open scoped ENNReal NNReal Topology | |
| open scoped NNReal ENNReal Topology | |
| open scoped NNReal Topology | |
| open Set | |
| open Set Filter MeasureTheory | |
| open scoped BigOperators | |
| open scoped Topology NNReal | |
| open Set Filter | |
| open scoped Topology NNReal | |
| namespace MicroscopicJamming | |
| namespace Parameter | |
| lemma second_remainder_representation {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₃) : | |
| ∃ g : ℝ → ℝ, LipschitzWith ⟨M₃,hM₃⟩ g ∧ | |
| (∀ k∈I, F k=F 0+deriv F 0*k+g k*k^2) ∧ deriv (deriv F) 0=2*g 0 := by | |
| have hd := differentiable_of_dd2_bound hI hM₂ hb₂ | |
| 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 | |
| refine ⟨g,hg,?_,(hasDerivAt_iff_tendsto_slope.mpr hsl).deriv⟩ | |
| intro k hk | |
| by_cases hk0 : k=0 | |
| · simp [hk0] | |
| · exact hrepr k ⟨hk,hk0⟩ | |
| lemma first_derivative_error {F : ℝ → ℝ} {I : Set ℝ} (hI : IsOpen I) (h0 : (0:ℝ)∈I) | |
| {M : ℝ} (hM : 0≤M) | |
| (hb : ∀ a∈I,∀ b∈I,∀ c∈I,a≠b → a≠c → b≠c → |dd2 F a b c|≤M) | |
| {h : ℝ} (hh : h∈I) (hh0 : h≠0) : |dd1 F 0 h-deriv F 0|≤M*|h| := by | |
| have hd := differentiable_of_dd2_bound hI hM hb 0 h0 | |
| have ht : Tendsto (fun k => |dd1 F 0 h-dd1 F 0 k|) (𝓝[≠] 0) (𝓝 |dd1 F 0 h-deriv F 0|) := by | |
| have he : (fun k => dd1 F 0 k)=slope F 0 := funext (fun k => (slope_def_field F 0 k).symm) | |
| have hh1 : Tendsto (fun k => dd1 F 0 k) (𝓝[≠] 0) (𝓝 (deriv F 0)) := by | |
| rw [he]; exact hd.hasDerivAt.tendsto_slope | |
| exact (tendsto_const_nhds.sub hh1).abs | |
| have hr : Tendsto (fun k : ℝ => M*|h-k|) (𝓝[≠] 0) (𝓝 (M*|h|)) := by | |
| simpa using ((tendsto_const_nhds.sub (tendsto_id.mono_left nhdsWithin_le_nhds)).abs.const_mul M : | |
| Tendsto (fun k : ℝ => M*|h-k|) (𝓝[≠] 0) (𝓝 (M*|h-0|))) | |
| apply le_of_tendsto_of_tendsto ht hr | |
| 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 hh0.symm)] with k hk hk0 hkh | |
| rw [dd1_sub_slope F hh0.symm (show (0:ℝ)≠k from (show k≠0 from hk0).symm) hkh.symm,abs_mul] | |
| calc | |
| |h-k| *|dd2 F 0 h k|≤|h-k| *M := mul_le_mul_of_nonneg_left | |
| (hb 0 h0 h hh k hk hh0.symm (show (0:ℝ)≠k from (show k≠0 from hk0).symm) hkh.symm) (abs_nonneg _) | |
| _ = M*|h-k| := mul_comm _ _ | |
| lemma second_derivative_error {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₃) | |
| {h : ℝ} (hh : h∈I) (hh2 : 2*h∈I) (hh0 : h≠0) : | |
| |dd2 F 0 h (2*h)-deriv (deriv F) 0/2|≤5*M₃*|h| := by | |
| obtain ⟨g,hg,he,hd⟩ := second_remainder_representation hI h0 hM₂ hM₃ hb₂ hb₃ | |
| have hid : dd2 F 0 h (2*h)=2*g (2*h)-g h := by | |
| unfold dd2 dd1 | |
| rw [he h hh,he (2*h) hh2] | |
| field_simp | |
| ring | |
| rw [hid,hd] | |
| have h1 := hg.dist_le_mul h 0 | |
| have h2 := hg.dist_le_mul (2*h) 0 | |
| change |g h-g 0|≤M₃*|h-0| at h1 | |
| change |g (2*h)-g 0|≤M₃*|2*h-0| at h2 | |
| simp only [sub_zero,abs_mul,abs_of_pos (by norm_num : (0:ℝ)<2)] at h1 h2 | |
| calc | |
| |2*g (2*h)-g h-2*g 0/2|=|2*(g (2*h)-g 0)-(g h-g 0)| := by congr 1; ring | |
| _ ≤ |2*(g (2*h)-g 0)|+|g h-g 0| := abs_sub _ _ | |
| _ = 2*|g (2*h)-g 0|+|g h-g 0| := by rw [abs_mul,abs_of_pos (by norm_num : (0:ℝ)<2)] | |
| _ ≤ 5*M₃*|h| := by linarith | |
| end Parameter | |
| end MicroscopicJamming | |
| open Set Filter | |
| open scoped Topology | |
| namespace MicroscopicJamming | |
| open Higher | |
| lemma cylinder_of_poly_error {S : Set ℝ} {f : ℕ → ℝ → ℝ → ℝ} {F : ℝ → ℝ → ℝ} | |
| {e : ℕ → ℝ} (he : Tendsto e atTop (𝓝 0)) {d : ℕ} {C : ℝ} (_hC : 0≤C) | |
| (hbd : ∀ n t,t∈S → ∀ x,|f n t x-F t x|≤e n*C*(1+|x|)^d) : | |
| CylinderConvergence f F S := by | |
| intro R hR | |
| rw [Metric.tendstoUniformlyOn_iff] | |
| intro ε hε | |
| have hc : Tendsto (fun n => e n*C*(1+R)^d) atTop (𝓝 0) := by | |
| simpa using (he.mul_const C).mul_const ((1+R)^d) | |
| filter_upwards [hc.eventually (gt_mem_nhds hε)] with n hn p hp | |
| rw [Real.dist_eq,abs_sub_comm] | |
| have hx : |p.2|≤R := abs_le.mpr hp.2 | |
| have hepos : 0≤e n*C := by | |
| have hh := (abs_nonneg _).trans (hbd n p.1 hp.1 0) | |
| simpa using hh | |
| exact ((hbd n p.1 hp.1 p.2).trans (mul_le_mul_of_nonneg_left | |
| (pow_le_pow_left₀ (by positivity) (by linarith) d) hepos)).trans_lt hn | |
| lemma smooth_limit_of_all_jet_convergence {S : Set ℝ} {f : ℕ → ℝ → ℝ → ℝ} | |
| {G : ℕ → ℝ → ℝ → ℝ} (hs : ∀ n,JointSpatialSmooth S (f n)) | |
| (hv : ∀ k,CylinderConvergence (fun n t => iteratedDeriv k (f n t)) (G k) S) : | |
| JointSpatialSmooth S (G 0) ∧ ∀ k t,t∈S → iteratedDeriv k (G 0 t)=G k t := by | |
| have hd (k : ℕ) : ∀ t∈S,∀ x,HasDerivAt (G k t) (G (k+1) t x) x := by | |
| apply cylinder_limit_hasDerivAt (hv k) | |
| (by simpa only [← iteratedDeriv_succ] using hv (k+1)) | |
| intro n t ht | |
| exact (contDiff_iff_iteratedDeriv.mp ((hs n).1 t ht)).2 k (by simp) | |
| have hj : ∀ k t,t∈S → iteratedDeriv k (G 0 t)=G k t := by | |
| intro k | |
| induction k with | |
| | zero => intro t ht; rfl | |
| | succ k ih => | |
| intro t ht | |
| rw [iteratedDeriv_succ,ih t ht] | |
| exact funext (fun x => (hd k t ht x).deriv) | |
| refine ⟨⟨?_,?_⟩,hj⟩ | |
| · intro t ht | |
| apply contDiff_of_differentiable_iteratedDeriv | |
| intro k _ | |
| rw [hj k t ht] | |
| exact fun x => (hd k t ht x).differentiableAt | |
| · intro k | |
| apply (cylinder_limit_continuous (f:=fun n t => iteratedDeriv k (f n t)) (F:=G k) (fun n => (hs n).2 k) (hv k)).congr | |
| intro p hp | |
| exact congrFun (hj k p.1 hp.1) p.2 | |
| lemma growth_limit {S : Set ℝ} {f : ℕ → ℝ → ℝ → ℝ} {F : ℝ → ℝ → ℝ} | |
| (hf : FamilyGrowth (fun _ : ℕ => True) S f) | |
| (hv : ∀ t∈S,∀ x,Tendsto (fun n => f n t x) atTop (𝓝 (F t x))) : | |
| ∃ d : ℕ,∃ C : ℝ,0≤C ∧ ∀ t∈S,∀ x,|F t x|≤C*(1+|x|)^d := by | |
| obtain ⟨d,C,hC,hb⟩ := hf | |
| exact ⟨d,C,hC,fun t ht x => le_of_tendsto (hv t ht x).abs (Eventually.of_forall (fun n => hb n trivial t ht x))⟩ | |
| end MicroscopicJamming | |
| open Set Filter | |
| open scoped Topology | |
| namespace MicroscopicJamming | |
| namespace Parameter | |
| open Higher | |
| def pjet (F : ℝ → ℝ → ℝ → ℝ) (k : ℕ) (t x : ℝ) : ℝ := | |
| deriv (fun e => iteratedDeriv k (F e t) x) 0 | |
| def pjet2 (F : ℝ → ℝ → ℝ → ℝ) (k : ℕ) (t x : ℝ) : ℝ := | |
| deriv (deriv (fun e => iteratedDeriv k (F e t) x)) 0/2 | |
| def paramSeq (r : ℝ) (n : ℕ) : ℝ := (r/4)*(1/((n:ℝ)+1)) | |
| lemma paramSeq_pos {r : ℝ} (hr : 0<r) (n : ℕ) : 0<paramSeq r n := by unfold paramSeq; positivity | |
| lemma paramSeq_bound {r : ℝ} (hr : 0<r) (n : ℕ) : paramSeq r n≤r/4 := by | |
| unfold paramSeq | |
| apply mul_le_of_le_one_right (by positivity) | |
| exact (div_le_one (by positivity)).mpr (by linarith [Nat.cast_nonneg (α:=ℝ) n]) | |
| lemma paramSeq_tendsto (r : ℝ) : Tendsto (paramSeq r) atTop (𝓝 0) := by | |
| unfold paramSeq | |
| simpa only [mul_zero] using tendsto_one_div_add_atTop_nhds_zero_nat.const_mul (r/4) | |
| lemma paramSeq_mem {r : ℝ} (hr : 0<r) (n : ℕ) : paramSeq r n∈Ioo (-r) r := | |
| ⟨by linarith [paramSeq_pos hr n],by linarith [paramSeq_bound hr n]⟩ | |
| lemma twice_paramSeq_mem {r : ℝ} (hr : 0<r) (n : ℕ) : 2*paramSeq r n∈Ioo (-r) r := | |
| ⟨by linarith [paramSeq_pos hr n],by linarith [paramSeq_bound hr n]⟩ | |
| def seqNodes2 {r : ℝ} (hr : 0<r) (n : ℕ) : Nodes2 (Ioo (-r) r) := | |
| ⟨0,paramSeq r n,⟨by linarith,hr⟩,paramSeq_mem hr n,(paramSeq_pos hr n).ne⟩ | |
| def seqNodes3 {r : ℝ} (hr : 0<r) (n : ℕ) : Nodes3 (Ioo (-r) r) := | |
| ⟨seqNodes2 hr n,2*paramSeq r n,twice_paramSeq_mem hr n,by dsimp [seqNodes2]; linarith [paramSeq_pos hr n],by dsimp [seqNodes2]; linarith [paramSeq_pos hr n]⟩ | |
| lemma RankFamilyData.bound_dd2 {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData I A B F) (k : ℕ) : | |
| ∃ d : ℕ,∃ C : ℝ,0≤C ∧ ∀ t∈Icc (0:ℝ) 1,∀ x, | |
| ∀ a∈I,∀ b∈I,∀ c∈I,a≠b → a≠c → b≠c → | |
| |dd2 (fun e => iteratedDeriv k (F e t) x) a b c|≤C*(1+|x|)^d := by | |
| obtain ⟨d,C,hC,hb⟩ := (field2_poly hf).bounds k | |
| refine ⟨d,C,hC,?_⟩ | |
| intro t ht x 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 k ht x] at hh | |
| exact hh | |
| lemma RankFamilyData.bound_dd3 {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData I A B F) (k : ℕ) : | |
| ∃ d : ℕ,∃ C : ℝ,0≤C ∧ ∀ t∈Icc (0:ℝ) 1,∀ x, | |
| ∀ a∈I,∀ b∈I,∀ c∈I,∀ z∈I,a≠b → a≠c → a≠z → b≠c → b≠z → c≠z → | |
| |dd3 (fun e => iteratedDeriv k (F e t) x) a b c z|≤C*(1+|x|)^d := by | |
| obtain ⟨d,C,hC,hb⟩ := (field3_poly hf).bounds k | |
| refine ⟨d,C,hC,?_⟩ | |
| intro t ht x a ha b hb' c hc e he hab hac hae hbc hbe hce | |
| let p : Nodes4 I := ⟨⟨⟨a,b,ha,hb',hab⟩,c,hc,hac,hbc⟩,e,he,hae,hbe,hce⟩ | |
| have hh := hb p trivial t ht x | |
| dsimp only at hh | |
| rw [field3_jet hf.smooth p k ht x] at hh | |
| exact hh | |
| lemma RankFamilyData.first_jet_limit {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) (k : ℕ) : | |
| CylinderConvergence (fun n t => iteratedDeriv k (field1 F 0 (paramSeq r n) t)) (pjet F k) (Icc 0 1) := by | |
| obtain ⟨d,C,hC,hb⟩ := hf.bound_dd2 k | |
| apply cylinder_of_poly_error (d:=d) (paramSeq_tendsto r) hC | |
| intro n t ht x | |
| have hj := field1_jet hf.smooth (seqNodes2 hr n) k ht x | |
| dsimp only [seqNodes2] at hj | |
| rw [hj] | |
| have hh := first_derivative_error isOpen_Ioo (show (0:ℝ)∈Ioo (-r) r from ⟨by linarith,hr⟩) | |
| (show 0≤C*(1+|x|)^d by positivity) (hb t ht x) (paramSeq_mem hr n) (paramSeq_pos hr n).ne' | |
| rw [abs_of_pos (paramSeq_pos hr n)] at hh | |
| have he : C*(1+|x|)^d*paramSeq r n=paramSeq r n*C*(1+|x|)^d := by ring | |
| exact he ▸ hh | |
| lemma RankFamilyData.second_jet_limit {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) (k : ℕ) : | |
| CylinderConvergence (fun n t => iteratedDeriv k (field2 F 0 (paramSeq r n) (2*paramSeq r n) t)) (pjet2 F k) (Icc 0 1) := by | |
| obtain ⟨d₂,C₂,hC₂,hb₂⟩ := hf.bound_dd2 k | |
| obtain ⟨d₃,C₃,hC₃,hb₃⟩ := hf.bound_dd3 k | |
| apply cylinder_of_poly_error (d:=d₃) (paramSeq_tendsto r) (show 0≤5*C₃ by positivity) | |
| intro n t ht x | |
| have hj := field2_jet hf.smooth (seqNodes3 hr n) k ht x | |
| dsimp only [seqNodes3,seqNodes2] at hj | |
| rw [hj] | |
| have hh := second_derivative_error isOpen_Ioo (show (0:ℝ)∈Ioo (-r) r from ⟨by linarith,hr⟩) | |
| (show 0≤C₂*(1+|x|)^d₂ by positivity) (show 0≤C₃*(1+|x|)^d₃ by positivity) | |
| (hb₂ t ht x) (hb₃ t ht x) (paramSeq_mem hr n) (twice_paramSeq_mem hr n) (paramSeq_pos hr n).ne' | |
| rw [abs_of_pos (paramSeq_pos hr n)] at hh | |
| have he : 5*(C₃*(1+|x|)^d₃)*paramSeq r n=paramSeq r n*(5*C₃)*(1+|x|)^d₃ := by ring | |
| exact he ▸ hh | |
| lemma RankFamilyData.parameter_jets {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) : | |
| (JointSpatialSmooth (Icc 0 1) (pjet F 0) ∧ ∀ k t,t∈Icc (0:ℝ) 1 → iteratedDeriv k (pjet F 0 t)=pjet F k t) ∧ | |
| (JointSpatialSmooth (Icc 0 1) (pjet2 F 0) ∧ ∀ k t,t∈Icc (0:ℝ) 1 → iteratedDeriv k (pjet2 F 0 t)=pjet2 F k t) := by | |
| constructor | |
| · exact smooth_limit_of_all_jet_convergence (fun n => field1_smooth hf.smooth (seqNodes2 hr n)) (hf.first_jet_limit hr) | |
| · exact smooth_limit_of_all_jet_convergence (fun n => field2_smooth hf.smooth (seqNodes3 hr n)) (hf.second_jet_limit hr) | |
| end Parameter | |
| end MicroscopicJamming | |
| open Set Filter | |
| open scoped Topology | |
| namespace MicroscopicJamming | |
| namespace Parameter | |
| open Higher | |
| def endpointRhs {ι : Type*} (A B : ℝ → ℝ) (F : ℝ → ℝ → ℝ → ℝ) | |
| (l r : ι → ℝ) (U H : ι → ℝ → ℝ → ℝ) (i : ι) (t 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 | |
| lemma RankFamilyData.endpoint_rhs_poly {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 : ι → ℝ → ℝ → ℝ} | |
| (hU : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) U) | |
| (hH : PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) H) : | |
| PolynomialJetFamily (fun _ : ι => True) (Icc 0 1) (endpointRhs A B F l r U H) := by | |
| obtain ⟨D,hD,ha,hB⟩ := hf.coeff | |
| have hd := (hU.jet 2).coeff_mul (fun i _ => hf.diffusion_cont (l i)) hD | |
| (fun i _ t ht => by rw [abs_of_nonneg (ha (l i) (hl i) t ht).1]; exact (ha (l i) (hl i) t ht).2) | |
| have hlp := hf.poly.comp (R:=fun _ => True) l (fun i _ => hl i) | |
| have hrp := hf.poly.comp (R:=fun _ => True) r (fun i _ => hr i) | |
| have hb := hf.mul_at l hl ((((hlp.jet 1).add (hrp.jet 1))).mul (hU.jet 1)) | |
| convert (hH.sub hd).sub hb using 1 | |
| funext i t x | |
| dsimp only [endpointRhs] | |
| ring | |
| def rhs1 {I : Set ℝ} (F : ℝ → ℝ → ℝ → ℝ) (A B : ℝ → ℝ) := | |
| endpointRhs A B F (fun p : Nodes2 I => p.a) (fun p => p.b) | |
| (fun p => field1 F p.a p.b) (source1 F B) | |
| def rhs2 {I : Set ℝ} (F : ℝ → ℝ → ℝ → ℝ) (A B : ℝ → ℝ) := | |
| endpointRhs A B F (fun p : Nodes3 I => p.a) (fun p => p.c) | |
| (fun p => field2 F p.a p.b p.c) (source2 F A B) | |
| lemma rhs1_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData I A B F) : PolynomialJetFamily (fun _ : Nodes2 I => True) (Icc 0 1) (rhs1 F A B) := | |
| hf.endpoint_rhs_poly (fun p : Nodes2 I => p.a) (fun p => p.b) (fun p => p.ha) (fun p => p.hb) (field1_poly hf) (source1_poly hf) | |
| lemma rhs2_poly {I : Set ℝ} {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData I A B F) : PolynomialJetFamily (fun _ : Nodes3 I => True) (Icc 0 1) (rhs2 F A B) := | |
| hf.endpoint_rhs_poly (fun p : Nodes3 I => p.a) (fun p => p.c) (fun p => p.ha) (fun p => p.hc) (field2_poly hf) (source2_poly hf) | |
| end Parameter | |
| end MicroscopicJamming | |
| open Set Filter MeasureTheory | |
| open scoped Topology | |
| namespace MicroscopicJamming | |
| lemma time_derivative_limit_dominated {f g : ℕ → ℝ → ℝ} {F G : ℝ → ℝ} {C : ℝ} | |
| (hfc : ∀ n,ContinuousOn (f n) (Icc 0 1)) | |
| (hgc : ∀ n,ContinuousOn (g n) (Icc 0 1)) | |
| (hG : ContinuousOn G (Icc 0 1)) | |
| (hd : ∀ n t,t∈Ioo (0:ℝ) 1 → HasDerivAt (f n) (g n t) t) | |
| (hfv : ∀ t∈Icc (0:ℝ) 1,Tendsto (fun n => f n t) atTop (𝓝 (F t))) | |
| (hgv : ∀ t∈Icc (0:ℝ) 1,Tendsto (fun n => g n t) atTop (𝓝 (G t))) | |
| (hgb : ∀ n t,t∈Icc (0:ℝ) 1 → |g n t|≤C) : | |
| ∀ t∈Ioo (0:ℝ) 1,HasDerivAt F (G t) t := by | |
| have hsub (t : ℝ) (ht : t∈Icc (0:ℝ) 1) : uIcc t 1⊆Icc 0 1 := by | |
| rw [uIcc_of_le ht.2]; exact Icc_subset_Icc ht.1 le_rfl | |
| have hrepr (t : ℝ) (ht : t∈Icc (0:ℝ) 1) : F t=F 1-∫ s in t..1,G s := by | |
| have hi : Tendsto (fun n => ∫ s in t..1,g n s) atTop (𝓝 (∫ s in t..1,G s)) := by | |
| apply intervalIntegral.tendsto_integral_filter_of_dominated_convergence (fun _ => C) | |
| · exact Eventually.of_forall (fun n => (((hgc n).mono (hsub t ht)).aestronglyMeasurable measurableSet_uIcc).mono_set uIoc_subset_uIcc) | |
| · exact Eventually.of_forall (fun n => Eventually.of_forall (fun s hs => by | |
| simpa only [Real.norm_eq_abs] using hgb n s (hsub t ht (uIoc_subset_uIcc hs)))) | |
| · exact intervalIntegrable_const | |
| · exact Eventually.of_forall (fun s hs => hgv s (hsub t ht (uIoc_subset_uIcc hs))) | |
| have he (n : ℕ) : (∫ s in t..1,g n s)=f n 1-f n t := by | |
| apply intervalIntegral.integral_eq_sub_of_hasDerivAt_of_le ht.2 | |
| · exact (hfc n).mono (Icc_subset_Icc ht.1 le_rfl) | |
| · exact fun s hs => hd n s ⟨lt_of_le_of_lt ht.1 hs.1,hs.2⟩ | |
| · exact ((hgc n).mono (hsub t ht)).intervalIntegrable | |
| have hh := tendsto_nhds_unique hi ((hfv 1 ⟨by norm_num,le_rfl⟩).sub (hfv t ht) |>.congr (fun n => (he n).symm)) | |
| linarith | |
| let E : ℝ → ℝ := fun t => G (projIcc 0 1 (by norm_num) t) | |
| have hE : Continuous E := (continuousOn_iff_continuous_domRestrict.mp hG).comp continuous_projIcc | |
| have hEe (t : ℝ) (ht : t∈Icc (0:ℝ) 1) : E t=G t := by | |
| dsimp only [E]; rw [projIcc_of_mem (by norm_num) ht] | |
| intro t ht | |
| have hh := (intervalIntegral.integral_hasDerivAt_left (hE.intervalIntegrable t 1) | |
| hE.aestronglyMeasurable.stronglyMeasurableAtFilter hE.continuousAt).const_sub (F 1) | |
| simp only [neg_neg,hEe t ⟨ht.1.le,ht.2.le⟩] at hh | |
| apply hh.congr_of_eventuallyEq | |
| filter_upwards [Ioo_mem_nhds ht.1 ht.2] with s hs | |
| rw [hrepr s ⟨hs.1.le,hs.2.le⟩] | |
| congr 1 | |
| apply intervalIntegral.integral_congr | |
| intro y hy | |
| exact (hEe y (hsub s ⟨hs.1.le,hs.2.le⟩ hy)).symm | |
| end MicroscopicJamming | |
| open Set Filter | |
| open scoped Topology | |
| namespace MicroscopicJamming | |
| namespace Parameter | |
| open Higher | |
| lemma RankFamilyData.base_jet_limit {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) (k : ℕ) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x c : ℝ) : | |
| Tendsto (fun n => iteratedDeriv k (F (c*paramSeq r n) t) x) atTop (𝓝 (iteratedDeriv k (F 0 t) x)) := by | |
| have hc := (MicroscopicJamming.RankFamilyData.parameter_C2 hf isOpen_Ioo ⟨by linarith,hr⟩ k t ht x).1.continuousAt | |
| exact hc.tendsto.comp (by simpa only [mul_zero] using (paramSeq_tendsto r).const_mul c) | |
| lemma RankFamilyData.offaxis_jet_limit {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) (k : ℕ) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : | |
| Tendsto (fun n => iteratedDeriv k (field1 F (paramSeq r n) (2*paramSeq r n) t) x) | |
| atTop (𝓝 (pjet F k t x)) := by | |
| have h0 := (hf.first_jet_limit hr k).tendsto_at ht x | |
| have h2 := (hf.second_jet_limit hr k).tendsto_at ht x | |
| have he (n : ℕ) : iteratedDeriv k (field1 F (paramSeq r n) (2*paramSeq r n) t) x= | |
| iteratedDeriv k (field1 F 0 (paramSeq r n) t) x+ | |
| (2*paramSeq r n)*iteratedDeriv k (field2 F 0 (paramSeq r n) (2*paramSeq r n) t) x := by | |
| have ha := field1_jet hf.smooth (seqNodes3 hr n).bc k ht x | |
| have hb := field1_jet hf.smooth (seqNodes2 hr n) k ht x | |
| have hc := field2_jet hf.smooth (seqNodes3 hr n) k ht x | |
| dsimp only [seqNodes2,seqNodes3,Nodes3.bc] at ha hb hc | |
| rw [ha,hb,hc] | |
| unfold dd2 | |
| have hn := (paramSeq_pos hr n).ne' | |
| field_simp | |
| ring | |
| have hh := h0.add (((paramSeq_tendsto r).const_mul 2).mul h2) | |
| simpa only [mul_zero,zero_mul,add_zero,← he] using hh | |
| def linearRhs (A B : ℝ → ℝ) (f v : ℝ → ℝ → ℝ) (t x : ℝ) : ℝ := | |
| -B t*(iteratedDeriv 2 (f t) x+t*(iteratedDeriv 1 (f t) x)^2)- | |
| A t*iteratedDeriv 2 (v t) x-2*A t*t*iteratedDeriv 1 (f t) x*iteratedDeriv 1 (v t) x | |
| def quadraticRhs (A B : ℝ → ℝ) (f v g : ℝ → ℝ → ℝ) (t x : ℝ) : ℝ := | |
| -A t*t*(iteratedDeriv 1 (v t) x)^2- | |
| B t*(iteratedDeriv 2 (v t) x+2*t*iteratedDeriv 1 (f t) x*iteratedDeriv 1 (v t) x)- | |
| A t*iteratedDeriv 2 (g t) x-2*A t*t*iteratedDeriv 1 (f t) x*iteratedDeriv 1 (g t) x | |
| lemma linearRhs_smooth {A B : ℝ → ℝ} {f v : ℝ → ℝ → ℝ} | |
| (hA : ContinuousOn A (Icc 0 1)) (hB : ContinuousOn B (Icc 0 1)) | |
| (hf : JointSpatialSmooth (Icc 0 1) f) (hv : JointSpatialSmooth (Icc 0 1) v) : | |
| JointSpatialSmooth (Icc 0 1) (linearRhs A B f v) := by | |
| have hh := (((hf.jet 2).add (((hf.jet 1).mul (hf.jet 1)).coeff_mul continuousOn_id)).coeff_mul hB.neg).sub | |
| ((hv.jet 2).coeff_mul hA) |>.sub ((((hf.jet 1).mul (hv.jet 1)).coeff_mul | |
| (((continuousOn_const (c:=(2:ℝ))).mul hA).mul continuousOn_id))) | |
| convert hh using 1 | |
| funext t x | |
| dsimp only [linearRhs,Pi.mul_apply,Pi.neg_apply,id_eq] | |
| ring | |
| lemma quadraticRhs_smooth {A B : ℝ → ℝ} {f v g : ℝ → ℝ → ℝ} | |
| (hA : ContinuousOn A (Icc 0 1)) (hB : ContinuousOn B (Icc 0 1)) | |
| (hf : JointSpatialSmooth (Icc 0 1) f) (hv : JointSpatialSmooth (Icc 0 1) v) | |
| (hg : JointSpatialSmooth (Icc 0 1) g) : | |
| JointSpatialSmooth (Icc 0 1) (quadraticRhs A B f v g) := by | |
| have hh := (((hv.jet 1).mul (hv.jet 1)).coeff_mul (hA.neg.mul continuousOn_id)).sub | |
| (((hv.jet 2).add (((hf.jet 1).mul (hv.jet 1)).coeff_mul ((continuousOn_const (c:=(2:ℝ))).mul continuousOn_id))).coeff_mul hB) |>.sub | |
| ((hg.jet 2).coeff_mul hA) |>.sub ((((hf.jet 1).mul (hg.jet 1)).coeff_mul | |
| (((continuousOn_const (c:=(2:ℝ))).mul hA).mul continuousOn_id))) | |
| convert hh using 1 | |
| funext t x | |
| dsimp only [quadraticRhs,Pi.mul_apply,Pi.neg_apply,id_eq] | |
| ring | |
| lemma RankFamilyData.rhs1_limit {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : | |
| Tendsto (fun n => rhs1 F A B (seqNodes2 hr n) t x) atTop | |
| (𝓝 (linearRhs A B (F 0) (pjet F 0) t x)) := by | |
| have hb (k) := hf.base_jet_limit hr k ht x 1 | |
| simp only [one_mul] at hb | |
| have hv (k) := (hf.first_jet_limit hr k).tendsto_at ht x | |
| have hj := (hf.parameter_jets hr).1.2 | |
| have hh := (((hb 2).add (((hb 1).pow 2).const_mul t)).const_mul (-B t)).sub | |
| ((hv 2).const_mul (A t)) |>.sub ((((tendsto_const_nhds (x:=iteratedDeriv 1 (F 0 t) x)).add (hb 1)).mul (hv 1)).const_mul (A t*t)) | |
| convert hh using 1 | |
| · funext n; dsimp [rhs1,endpointRhs,source1,seqNodes2]; ring | |
| · dsimp only [linearRhs,Pi.mul_apply,Pi.neg_apply,id_eq]; rw [hj 2 t ht,hj 1 t ht]; ring_nf | |
| lemma RankFamilyData.rhs2_limit {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) (x : ℝ) : | |
| Tendsto (fun n => rhs2 F A B (seqNodes3 hr n) t x) atTop | |
| (𝓝 (quadraticRhs A B (F 0) (pjet F 0) (pjet2 F 0) t x)) := by | |
| have hb (k) := hf.base_jet_limit hr k ht x 1 | |
| simp only [one_mul] at hb | |
| have hc (k) := hf.base_jet_limit hr k ht x 2 | |
| have hv (k) := (hf.first_jet_limit hr k).tendsto_at ht x | |
| have hw (k) := hf.offaxis_jet_limit hr k ht x | |
| have hg (k) := (hf.second_jet_limit hr k).tendsto_at ht x | |
| have hj := hf.parameter_jets hr | |
| have hh := (((hv 1).mul (hw 1)).const_mul (-A t*t)).sub | |
| (((hw 2).add ((((hb 1).add (hc 1)).mul (hw 1)).const_mul t)).const_mul (B t)) |>.sub | |
| ((hg 2).const_mul (A t)) |>.sub ((((tendsto_const_nhds (x:=iteratedDeriv 1 (F 0 t) x)).add (hc 1)).mul (hg 1)).const_mul (A t*t)) | |
| convert hh using 1 | |
| · funext n; dsimp [rhs2,endpointRhs,source2,seqNodes2,seqNodes3]; ring | |
| · dsimp only [quadraticRhs,Pi.mul_apply,Pi.neg_apply,id_eq]; rw [hj.1.2 2 t ht,hj.1.2 1 t ht,hj.2.2 2 t ht,hj.2.2 1 t ht]; ring_nf | |
| lemma RankFamilyData.parameter_equations {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) : | |
| (∀ t∈Ioo (0:ℝ) 1,∀ x,HasDerivAt (fun s => pjet F 0 s x) | |
| (linearRhs A B (F 0) (pjet F 0) t x) t) ∧ | |
| (∀ t∈Ioo (0:ℝ) 1,∀ x,HasDerivAt (fun s => pjet2 F 0 s x) | |
| (quadraticRhs A B (F 0) (pjet F 0) (pjet2 F 0) t x) t) := by | |
| have hj := hf.parameter_jets hr | |
| have h0 : (0:ℝ)∈Ioo (-r) r := ⟨by linarith,hr⟩ | |
| constructor | |
| · intro t ht x | |
| obtain ⟨d,C,hC,hb⟩ := (rhs1_poly hf).bounds 0 | |
| apply time_derivative_limit_dominated (C:=C*(1+|x|)^d) | |
| (fun n => ((field1_smooth hf.smooth (seqNodes2 hr n)).2 0).comp | |
| (continuousOn_id.prodMk continuousOn_const) (fun s hs => ⟨hs,mem_univ _⟩)) | |
| (fun n => ((rhs1_poly hf).smooth (seqNodes2 hr n) trivial).2 0 |>.comp | |
| (continuousOn_id.prodMk continuousOn_const) (fun s hs => ⟨hs,mem_univ _⟩)) | |
| ((linearRhs_smooth hf.Acont hf.Bcont (hf.smooth 0 h0) hj.1.1).2 0 |>.comp | |
| (continuousOn_id.prodMk continuousOn_const) (fun s hs => ⟨hs,mem_univ _⟩)) | |
| (fun n s hs => field1_equation hf (seqNodes2 hr n) hs x) | |
| (fun s hs => (hf.first_jet_limit hr 0).tendsto_at hs x) | |
| (fun s hs => hf.rhs1_limit hr hs x) | |
| (fun n s hs => hb (seqNodes2 hr n) trivial s hs x) t ht | |
| · intro t ht x | |
| obtain ⟨d,C,hC,hb⟩ := (rhs2_poly hf).bounds 0 | |
| apply time_derivative_limit_dominated (C:=C*(1+|x|)^d) | |
| (fun n => ((field2_smooth hf.smooth (seqNodes3 hr n)).2 0).comp | |
| (continuousOn_id.prodMk continuousOn_const) (fun s hs => ⟨hs,mem_univ _⟩)) | |
| (fun n => ((rhs2_poly hf).smooth (seqNodes3 hr n) trivial).2 0 |>.comp | |
| (continuousOn_id.prodMk continuousOn_const) (fun s hs => ⟨hs,mem_univ _⟩)) | |
| ((quadraticRhs_smooth hf.Acont hf.Bcont (hf.smooth 0 h0) hj.1.1 hj.2.1).2 0 |>.comp | |
| (continuousOn_id.prodMk continuousOn_const) (fun s hs => ⟨hs,mem_univ _⟩)) | |
| (fun n s hs => field2_equation hf (seqNodes3 hr n) hs x) | |
| (fun s hs => (hf.second_jet_limit hr 0).tendsto_at hs x) | |
| (fun s hs => hf.rhs2_limit hr hs x) | |
| (fun n s hs => hb (seqNodes3 hr n) trivial s hs x) t ht | |
| end Parameter | |
| end MicroscopicJamming | |
| open Set | |
| namespace MicroscopicJamming | |
| namespace Hessian | |
| structure Jet (u ux uxx ut : ℝ → ℝ → ℝ) : Prop where | |
| x : ∀ t∈Icc (0:ℝ) 1,∀ z,HasDerivAt (u t) (ux t z) z | |
| xx : ∀ t∈Icc (0:ℝ) 1,∀ z,HasDerivAt (ux t) (uxx t z) z | |
| time : ∀ t∈Ico (0:ℝ) 1,∀ z,HasDerivWithinAt (fun s => u s z) (ut t z) (Ici t) t | |
| lemma Jet.spatial_deriv {u ux uxx ut : ℝ → ℝ → ℝ} (h : Jet u ux uxx ut) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) : deriv (u t)=ux t := | |
| funext (fun z => (h.x t ht z).deriv) | |
| lemma Jet.spatial_deriv2 {u ux uxx ut : ℝ → ℝ → ℝ} (h : Jet u ux uxx ut) {t : ℝ} (ht : t∈Icc (0:ℝ) 1) : deriv (deriv (u t))=uxx t := by | |
| rw [h.spatial_deriv ht]; exact funext (fun z => (h.xx t ht z).deriv) | |
| lemma Jet.add {u ux uxx ut v vx vxx vt : ℝ → ℝ → ℝ} | |
| (h : Jet u ux uxx ut) (k : Jet v vx vxx vt) : | |
| Jet (fun t z => u t z+v t z) (fun t z => ux t z+vx t z) | |
| (fun t z => uxx t z+vxx t z) (fun t z => ut t z+vt t z) := | |
| ⟨fun t ht z => (h.x t ht z).add (k.x t ht z),fun t ht z => (h.xx t ht z).add (k.xx t ht z), | |
| fun t ht z => (h.time t ht z).add (k.time t ht z)⟩ | |
| lemma Jet.neg {u ux uxx ut : ℝ → ℝ → ℝ} (h : Jet u ux uxx ut) : | |
| Jet (fun t z => -u t z) (fun t z => -ux t z) (fun t z => -uxx t z) (fun t z => -ut t z) := | |
| ⟨fun t ht z => (h.x t ht z).neg,fun t ht z => (h.xx t ht z).neg,fun t ht z => (h.time t ht z).neg⟩ | |
| lemma Jet.mul {u ux uxx ut v vx vxx vt : ℝ → ℝ → ℝ} | |
| (h : Jet u ux uxx ut) (k : Jet v vx vxx vt) : | |
| Jet (fun t z => u t z*v t z) (fun t z => ux t z*v t z+u t z*vx t z) | |
| (fun t z => uxx t z*v t z+2*ux t z*vx t z+u t z*vxx t z) | |
| (fun t z => ut t z*v t z+u t z*vt t z) := by | |
| refine ⟨fun t ht z => (h.x t ht z).mul (k.x t ht z),fun t ht z => ?_, | |
| fun t ht z => (h.time t ht z).mul (k.time t ht z)⟩ | |
| exact (((h.xx t ht z).mul (k.x t ht z)).add ((h.x t ht z).mul (k.xx t ht z))).congr_deriv (by ring) | |
| lemma Jet.const (c : ℝ) : Jet (fun _ _ => c) (fun _ _ => 0) (fun _ _ => 0) (fun _ _ => 0) := | |
| ⟨fun _ _ z => hasDerivAt_const z c,fun _ _ z => hasDerivAt_const z 0, | |
| fun t _ _ => (hasDerivAt_const t c).hasDerivWithinAt⟩ | |
| lemma Jet.rank : Jet (fun t _ : ℝ => t) (fun _ _ => 0) (fun _ _ => 0) (fun _ _ => 1) := | |
| ⟨fun t _ z => hasDerivAt_const z t,fun _ _ z => hasDerivAt_const z 0, | |
| fun t _ _ => (hasDerivAt_id t).hasDerivWithinAt⟩ | |
| lemma Jet.coeff {a da : ℝ → ℝ} (ha : ∀ t∈Ico (0:ℝ) 1,HasDerivWithinAt a (da t) (Ici t) t) : | |
| Jet (fun t _ => a t) (fun _ _ => 0) (fun _ _ => 0) (fun t _ => da t) := | |
| ⟨fun t _ z => hasDerivAt_const z (a t),fun _ _ z => hasDerivAt_const z 0,fun t ht _ => ha t ht⟩ | |
| lemma Jet.inv {u ux uxx ut : ℝ → ℝ → ℝ} (h : Jet u ux uxx ut) | |
| (hn : ∀ t∈Icc (0:ℝ) 1,∀ z,u t z≠0) : | |
| Jet (fun t z => (u t z)⁻¹) (fun t z => -ux t z/(u t z)^2) | |
| (fun t z => 2*(ux t z)^2/(u t z)^3-uxx t z/(u t z)^2) | |
| (fun t z => -ut t z/(u t z)^2) := by | |
| refine ⟨fun t ht z => (h.x t ht z).inv (hn t ht z),fun t ht z => ?_, | |
| fun t ht z => (h.time t ht z).inv (hn t ⟨ht.1,ht.2.le⟩ z)⟩ | |
| exact ((h.xx t ht z).neg.div ((h.x t ht z).pow 2) (pow_ne_zero 2 (hn t ht z))).congr_deriv (by simp only [Pi.pow_apply,Pi.neg_apply]; field_simp [hn t ht z]; ring) | |
| end Hessian | |
| end MicroscopicJamming | |
| open Set Filter | |
| open scoped Topology BigOperators | |
| namespace MicroscopicJamming | |
| namespace Parameter | |
| open Higher | |
| lemma RankFamilyData.parameter_growth {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) : | |
| (∀ k,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv k (pjet F 0 t))) ∧ | |
| (∀ k,UniformPolynomialGrowth (Icc 0 1) (fun t => iteratedDeriv k (pjet2 F 0 t))) := by | |
| have hj := hf.parameter_jets hr | |
| constructor | |
| · intro k | |
| obtain ⟨d,C,hC,hb⟩ := growth_limit (((field1_poly hf).bounds k).comp (seqNodes2 hr) (fun _ _ => trivial)) | |
| (fun t ht x => (hf.first_jet_limit hr k).tendsto_at ht x) | |
| exact ⟨d,C,hC,fun t ht x => by dsimp only; rw [hj.1.2 k t ht]; exact hb t ht x⟩ | |
| · intro k | |
| obtain ⟨d,C,hC,hb⟩ := growth_limit (((field2_poly hf).bounds k).comp (seqNodes3 hr) (fun _ _ => trivial)) | |
| (fun t ht x => (hf.second_jet_limit hr k).tendsto_at ht x) | |
| exact ⟨d,C,hC,fun t ht x => by dsimp only; rw [hj.2.2 k t ht]; exact hb t ht x⟩ | |
| lemma RankFamilyData.parameter_terminal {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) : | |
| (∀ x,pjet F 0 1 x=0) ∧ (∀ x,pjet2 F 0 1 x=0) := by | |
| have h0 : (0:ℝ)∈Ioo (-r) r := ⟨by linarith,hr⟩ | |
| constructor | |
| · intro x | |
| apply tendsto_nhds_unique ((hf.first_jet_limit hr 0).tendsto_at (by norm_num : (1:ℝ)∈Icc 0 1) x) | |
| convert tendsto_const_nhds (x:=(0:ℝ)) using 1 | |
| funext n | |
| simp only [iteratedDeriv_zero,field1,dd1,hf.terminal _ (paramSeq_mem hr n) 0 h0 x,sub_self,zero_div] | |
| · intro x | |
| apply tendsto_nhds_unique ((hf.second_jet_limit hr 0).tendsto_at (by norm_num : (1:ℝ)∈Icc 0 1) x) | |
| convert tendsto_const_nhds (x:=(0:ℝ)) using 1 | |
| funext n | |
| simp only [iteratedDeriv_zero,field2,dd2,dd1,hf.terminal _ (paramSeq_mem hr n) 0 h0 x, | |
| hf.terminal _ (twice_paramSeq_mem hr n) 0 h0 x,sub_self,zero_div] | |
| lemma RankFamilyData.parameter_time_jets {r : ℝ} (hr : 0<r) {A B : ℝ → ℝ} {F : ℝ → ℝ → ℝ → ℝ} | |
| (hf : RankFamilyData (Ioo (-r) r) A B F) : | |
| (∀ n,∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (pjet F 0 s) x) | |
| (iteratedDeriv n (linearRhs A B (F 0) (pjet F 0) t) x) (Ici t) t) ∧ | |
| (∀ n,∀ t∈Ico (0:ℝ) 1,∀ x,HasDerivWithinAt (fun s => iteratedDeriv n (pjet2 F 0 s) x) | |
| (iteratedDeriv n (quadraticRhs A B (F 0) (pjet F 0) (pjet2 F 0) t) x) (Ici t) t) := by | |
| have hj := hf.parameter_jets hr | |
| have hd := hf.parameter_equations hr | |
| have h0 : (0:ℝ)∈Ioo (-r) r := ⟨by linarith,hr⟩ | |
| have hG := linearRhs_smooth hf.Acont hf.Bcont (hf.smooth 0 h0) hj.1.1 | |
| have hH := quadraticRhs_smooth hf.Acont hf.Bcont (hf.smooth 0 h0) hj.1.1 hj.2.1 | |
| exact ⟨evolution_all_jets (by norm_num) (hj.1.1.2 0) hG.2 hj.1.1.1 hG.1 hd.1, | |
| evolution_all_jets (by norm_num) (hj.2.1.2 0) hH.2 hj.2.1.1 hH.1 hd.2⟩ | |
| end Parameter | |
| end MicroscopicJamming | |
| open Set | |
| open scoped BigOperators | |
| namespace MicroscopicJamming | |
| namespace Hessian | |
| open Higher Parameter | |
| lemma smooth_jet {f : ℝ → ℝ} (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) f) (n : ℕ) : | |
| ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (iteratedDeriv n f) := by | |
| apply contDiff_of_differentiable_iteratedDeriv | |
| intro k _ | |
| simpa only [iteratedDeriv_iteratedDeriv] using (contDiff_iff_iteratedDeriv.mp hf).2 (k+n) (by simp) | |
| def ftime (A t : ℝ) (f : ℕ → ℝ) (n : ℕ) : ℝ := | |
| -A*(f (n+2)+t*∑ i∈Finset.range (n+1),(n.choose i:ℝ)*f (i+1)*f (n-i+1)) | |
| def vtime (A B t : ℝ) (f v : ℕ → ℝ) (n : ℕ) : ℝ := | |
| -B*(f (n+2)+t*∑ i∈Finset.range (n+1),(n.choose i:ℝ)*f (i+1)*f (n-i+1))- | |
| A*v (n+2)-2*A*t*∑ i∈Finset.range (n+1),(n.choose i:ℝ)*f (i+1)*v (n-i+1) | |
| def gtime (A B t : ℝ) (f v g : ℕ → ℝ) : ℝ := | |
| -A*t*(v 1)^2-B*(v 2+2*t*f 1*v 1)-A*g 2-2*A*t*f 1*g 1 | |
| lemma iterated_rhs (A t : ℝ) {f : ℝ → ℝ} | |
| (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) f) (n : ℕ) (x : ℝ) : | |
| iteratedDeriv n (fun y => -A*(iteratedDeriv 2 f y+t*(iteratedDeriv 1 f y)^2)) x= | |
| ftime A t (fun k => iteratedDeriv k f x) n := by | |
| have hc (k : ℕ) : ContDiff ℝ (n:WithTop ℕ∞) (iteratedDeriv k f) := | |
| smooth_jet hf k |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤)) | |
| rw [iteratedDeriv_const_mul_field] | |
| rw [iteratedDeriv_fun_add (hc 2).contDiffAt (contDiff_const.mul ((hc 1).pow 2)).contDiffAt] | |
| rw [iteratedDeriv_const_mul_field] | |
| simp only [pow_two] | |
| rw [iteratedDeriv_fun_mul (hc 1).contDiffAt (hc 1).contDiffAt] | |
| simp only [iteratedDeriv_iteratedDeriv,ftime] | |
| lemma iterated_linearRhs {A B : ℝ → ℝ} {f v : ℝ → ℝ → ℝ} {t : ℝ} | |
| (hf : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (f t)) | |
| (hv : ContDiff ℝ ((⊤ : ℕ∞) : WithTop ℕ∞) (v t)) (n : ℕ) (x : ℝ) : | |
| iteratedDeriv n (linearRhs A B f v t) x= | |
| vtime (A t) (B t) t (fun k => iteratedDeriv k (f t) x) (fun k => iteratedDeriv k (v t) x) n := by | |
| have hc (k : ℕ) : ContDiff ℝ (n:WithTop ℕ∞) (iteratedDeriv k (f t)) := | |
| smooth_jet hf k |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤)) | |
| have hd (k : ℕ) : ContDiff ℝ (n:WithTop ℕ∞) (iteratedDeriv k (v t)) := | |
| smooth_jet hv k |>.of_le (by exact_mod_cast (le_top : (n:ℕ∞)≤⊤)) | |
| have hbase := (contDiff_const (c:= -B t)).mul ((hc 2).add ((contDiff_const (c:=t)).mul ((hc 1).pow 2))) | |
| have hU := (contDiff_const (c:=A t)).mul (hd 2) | |
| have hV := ((contDiff_const (c:=2*A t*t)).mul (hc 1)).mul (hd 1) | |
| unfold linearRhs | |
| rw [iteratedDeriv_fun_sub (hbase.sub hU).contDiffAt hV.contDiffAt, | |
| iteratedDeriv_fun_sub hbase.contDiffAt hU.contDiffAt] | |
| rw [iterated_rhs (B t) t hf n x,iteratedDeriv_const_mul_field] | |
| have he : (fun y => 2*A t*t*iteratedDeriv 1 (f t) y*iteratedDeriv 1 (v t) y)= | |
| fun y => (2*A t*t)*(iteratedDeriv 1 (f t) y*iteratedDeriv 1 (v t) y) := by funext y; ring | |
| rw [he,iteratedDeriv_const_mul_field,iteratedDeriv_fun_mul (hc 1).contDiffAt (hd 1).contDiffAt] | |
| simp only [ftime,vtime,iteratedDeriv_iteratedDeriv] | |
| end Hessian | |
| end MicroscopicJamming | |
| end | |
| end OAI | |