| import Mathlib |
| import OAI.Probability.JammingConcavity.GaussianStepSlope |
|
|
| namespace OAI |
|
|
| /-! Gaussian Step Right. -/ |
|
|
| 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 MeasureTheory ProbabilityTheory Set Filter |
| open scoped Topology |
|
|
| namespace MicroscopicJamming |
|
|
| |
|
|
| def gaussianStepRightCoefficient : List (ℝ × ℝ) → ℝ → ℝ |
| | [], _ => 0 |
| | (a,T)::rs,t => if t < T then a else gaussianStepRightCoefficient rs (t-T) |
|
|
| lemma gaussianStepRightCoefficient_bounds {rs : List (ℝ × ℝ)} |
| (hrs : ∀ r ∈ rs, 0 ≤ r.1 ∧ r.1 ≤ 1 ∧ 0 ≤ r.2) (t : ℝ) : |
| 0 ≤ gaussianStepRightCoefficient rs t ∧ gaussianStepRightCoefficient rs t ≤ 1 := by |
| induction rs generalizing t with |
| | nil => simp [gaussianStepRightCoefficient] |
| | cons r rs ih => |
| have hr := hrs r (by simp) |
| have htail : ∀ v ∈ rs, 0 ≤ v.1 ∧ v.1 ≤ 1 ∧ 0 ≤ v.2 := fun v hv => hrs v (by simp [hv]) |
| by_cases h : t < r.2 |
| · simpa [gaussianStepRightCoefficient,h] using And.intro hr.1 hr.2.1 |
| · simpa [gaussianStepRightCoefficient,h] using ih htail (t-r.2) |
|
|
| lemma gaussianStepRightCoefficient_trace (rs : List (ℝ × ℝ)) (t : ℝ) : |
| ∃ ε : ℝ, 0 < ε ∧ ∀ s ∈ Ioo t (t+ε), |
| gaussianStepCoefficient rs s=gaussianStepRightCoefficient rs t := by |
| induction rs generalizing t with |
| | nil => exact ⟨1,by norm_num,fun _ _ => rfl⟩ |
| | cons r rs ih => |
| by_cases h : t < r.2 |
| · refine ⟨r.2-t,sub_pos.mpr h,?_⟩ |
| intro s hs |
| have hsT : s ≤ r.2 := by linarith [hs.2] |
| simp [gaussianStepCoefficient,gaussianStepRightCoefficient,h,hsT] |
| · obtain ⟨ε,hε,he⟩ := ih (t-r.2) |
| refine ⟨ε,hε,?_⟩ |
| intro s hs |
| have hsT : ¬s ≤ r.2 := by linarith [hs.1,le_of_not_gt h] |
| have hs' : s-r.2 ∈ Ioo (t-r.2) (t-r.2+ε) := by |
| constructor <;> linarith [hs.1,hs.2] |
| simpa [gaussianStepCoefficient,gaussianStepRightCoefficient,h,hsT] using he (s-r.2) hs' |
|
|
| lemma gaussianStepRightCoefficient_close {rs ss : List (ℝ × ℝ)} {Q δ : ℝ} |
| (hδ : ∀ t ∈ Icc 0 Q, |gaussianStepCoefficient rs t-gaussianStepCoefficient ss t| ≤ δ) |
| {t : ℝ} (ht : t ∈ Ico 0 Q) : |
| |gaussianStepRightCoefficient rs t-gaussianStepRightCoefficient ss t| ≤ δ := by |
| obtain ⟨r,hr,hrtrace⟩ := gaussianStepRightCoefficient_trace rs t |
| obtain ⟨s,hs,hstrace⟩ := gaussianStepRightCoefficient_trace ss t |
| let ε := min r (min s (Q-t)) |
| have hε : 0 < ε := lt_min hr (lt_min hs (sub_pos.mpr ht.2)) |
| have hεr : ε ≤ r := min_le_left _ _ |
| have hεs : ε ≤ s := (min_le_right _ _).trans (min_le_left _ _) |
| have hεQ : ε ≤ Q-t := (min_le_right _ _).trans (min_le_right _ _) |
| have hr' : t+ε/2 ∈ Ioo t (t+r) := by constructor <;> linarith |
| have hs' : t+ε/2 ∈ Ioo t (t+s) := by constructor <;> linarith |
| have ht' : t+ε/2 ∈ Icc 0 Q := by constructor <;> linarith [ht.1] |
| have hh := hδ (t+ε/2) ht' |
| rwa [hrtrace _ hr',hstrace _ hs'] at hh |
|
|
| lemma gaussianStepPath_cons_ge (r : ℝ × ℝ) (rs : List (ℝ × ℝ)) |
| (hrs : ∀ v ∈ rs, 0 ≤ v.2) (u : ℝ → ℝ) {t : ℝ} (ht : r.2 ≤ t) : |
| gaussianStepPath (r::rs) u t=gaussianStepPath rs u (t-r.2) := by |
| rcases ht.lt_or_eq with h | h |
| · exact gaussianStepPath_cons_gt r rs u h |
| · rw [← h,gaussianStepPath_cons_le r rs u le_rfl,sub_self,gaussianStepPath_zero hrs u] |
| funext x |
| exact gaussianRowOperator_zero _ _ _ |
|
|
| |
|
|
| lemma gaussianStepPath_right_pde {u : ℝ → ℝ} {A B C κ Q : ℝ} |
| (hQ : 0 < Q) (hu : RowAnalyticTerminal u A B C κ Q) |
| {rs : List (ℝ × ℝ)} (hrs : ∀ r ∈ rs, 0 ≤ r.1 ∧ r.1 ≤ 1 ∧ 0 ≤ r.2) |
| (hsum : gaussianStepTime rs ≤ Q) {t : ℝ} (ht : t ∈ Ico 0 (gaussianStepTime rs)) (x : ℝ) : |
| HasDerivWithinAt (fun s => gaussianStepPath rs u s x) |
| (-(1/2:ℝ)*(deriv (deriv (gaussianStepPath rs u t)) x+ |
| gaussianStepRightCoefficient rs t*(deriv (gaussianStepPath rs u t) x)^2)) (Ici t) t := by |
| induction rs generalizing t with |
| | nil => simp [gaussianStepTime] at ht |
| | cons r rs ih => |
| have hr := hrs r (by simp) |
| have htail : ∀ v ∈ rs, 0 ≤ v.1 ∧ v.1 ≤ 1 ∧ 0 ≤ v.2 := fun v hv => hrs v (by simp [hv]) |
| have htailT : ∀ v ∈ rs, 0 ≤ v.2 := fun v hv => (htail v hv).2.2 |
| have htot : gaussianStepTime (r::rs)=r.2+gaussianStepTime rs := by simp [gaussianStepTime] |
| have hR : gaussianStepTime rs ≤ Q := by rw [htot] at hsum; linarith |
| by_cases h : t < r.2 |
| · have htw := gaussian_composition_twice hQ hu htail hR |
| have hd0 := (Twice.gaussianRowOperator_calculus htw hr.1 (sub_pos.mpr h)).2.2 x |
| have hd := hd0.comp_const_sub r.2 t |
| have he : (fun s => gaussianStepPath (r::rs) u s x) =ᶠ[𝓝 t] |
| (fun s => gaussianRowOperator r.1 (r.2-s) (gaussianRowComposition rs u) x) := by |
| filter_upwards [eventually_lt_nhds h] with s hs |
| exact congrFun (gaussianStepPath_cons_le r rs u hs.le) x |
| have hh := hd.congr_of_eventuallyEq he |
| rw [gaussianStepPath_cons_le r rs u h.le] |
| simpa only [gaussianStepRightCoefficient,ite_eq_left h,neg_mul] using hh.hasDerivWithinAt (s := Ici t) |
| · have hge : r.2 ≤ t := le_of_not_gt h |
| have ht' : t-r.2 ∈ Ico 0 (gaussianStepTime rs) := by |
| rw [htot] at ht |
| constructor <;> linarith [ht.2] |
| have hi := ih htail hR ht' |
| have hdsub : HasDerivWithinAt (fun s : ℝ => s-r.2) 1 (Ici t) t := |
| ((hasDerivAt_id t).sub_const r.2).hasDerivWithinAt |
| have hmap : MapsTo (fun s : ℝ => s-r.2) (Ici t) (Ici (t-r.2)) := by |
| intro s hs |
| exact sub_le_sub_right hs r.2 |
| have hd := hi.scomp t hdsub hmap |
| have he : (fun s => gaussianStepPath (r::rs) u s x) =ᶠ[𝓝[Ici t] t] |
| (fun s => gaussianStepPath rs u (s-r.2) x) := by |
| filter_upwards [self_mem_nhdsWithin] with s hs |
| exact congrFun (gaussianStepPath_cons_ge r rs htailT u (hge.trans hs)) x |
| have hh := hd.congr_of_eventuallyEq_of_mem he (show t ∈ Ici t from by simp) |
| rw [gaussianStepPath_cons_ge r rs htailT u hge] |
| simpa only [Function.comp_def,one_smul,gaussianStepRightCoefficient,ite_eq_right h] using hh |
| end MicroscopicJamming |
|
|
| |
| |
|
|
| open Set Filter |
| open scoped Topology |
|
|
| namespace MicroscopicJamming |
|
|
| lemma localMax_second_deriv_nonpos {f : ℝ → ℝ} {x : ℝ} |
| (hf : Differentiable ℝ f) (hm : IsLocalMax f x) : deriv (deriv f) x ≤ 0 := by |
| by_contra hn |
| have hp : 0 < deriv (deriv f) x := lt_of_not_ge hn |
| have hzero : deriv f x=0 := hm.deriv_eq_zero |
| have hsign := eventually_nhdsWithin_sign_eq_of_deriv_pos hp hzero |
| have hright : ∀ᶠ y in 𝓝[>] x, 0 < deriv f y := |
| deriv_pos_right_of_sign_deriv (hsign.filter_mono nhdsWithin_le_nhds) |
| obtain ⟨r,hr,hh⟩ := Metric.mem_nhdsWithin_iff.mp hright |
| obtain ⟨s,hs,hmax⟩ := Metric.eventually_nhds_iff.mp hm |
| let y := x+min r s/2 |
| have hry : x<y := by dsimp [y]; linarith [lt_min hr hs] |
| have hdy : dist y x < r := by |
| rw [Real.dist_eq,abs_of_pos (sub_pos.mpr hry)] |
| dsimp [y]; linarith [min_le_left r s] |
| have hsy : dist y x < s := by |
| rw [Real.dist_eq,abs_of_pos (sub_pos.mpr hry)] |
| dsimp [y]; linarith [min_le_right r s] |
| have hmono : StrictMonoOn f (Icc x y) := by |
| apply strictMonoOn_of_deriv_pos (convex_Icc _ _) hf.continuous.continuousOn |
| intro z hz |
| rw [interior_Icc] at hz |
| apply hh ⟨?_,hz.1⟩ |
| rw [Metric.mem_ball,Real.dist_eq,abs_of_pos (sub_pos.mpr hz.1)] |
| have hd : y-x<r := by simpa [Real.dist_eq,abs_of_pos (sub_pos.mpr hry)] using hdy |
| linarith [hz.2] |
| exact (not_lt_of_ge (hmax hsy)) (hmono ⟨le_rfl,hry.le⟩ ⟨hry.le,le_rfl⟩ hry) |
|
|
| |
|
|
| lemma backward_strict_compact {Q R : ℝ} (hQ : 0 < Q) (hR : 0 < R) |
| {U b d : ℝ → ℝ → ℝ} |
| (hc : ContinuousOn (fun p : ℝ × ℝ => U p.1 p.2) (Icc 0 Q ×ˢ Icc (-R) R)) |
| (hx : ∀ t ∈ Icc 0 Q, Differentiable ℝ (U t)) |
| (ht : ∀ t ∈ Ico 0 Q, ∀ x, HasDerivWithinAt (fun s => U s x) (d t x) (Ici t) t) |
| (hp : ∀ t ∈ Ico 0 Q, ∀ x ∈ Ioo (-R) R, |
| 0 < d t x+(1/2:ℝ)*deriv (deriv (U t)) x+b t x*deriv (U t) x) |
| (hterm : ∀ x ∈ Icc (-R) R, U Q x ≤ 0) |
| (hleft : ∀ t ∈ Icc 0 Q, U t (-R) ≤ 0) |
| (hright : ∀ t ∈ Icc 0 Q, U t R ≤ 0) : |
| ∀ t ∈ Icc 0 Q, ∀ x ∈ Icc (-R) R, U t x ≤ 0 := by |
| have hne : (Icc 0 Q ×ˢ Icc (-R) R).Nonempty := |
| ⟨(0,0),⟨le_rfl,hQ.le⟩,by constructor <;> linarith⟩ |
| obtain ⟨p,hpS,hmax⟩ := (isCompact_Icc.prod isCompact_Icc).exists_isMaxOn hne hc |
| suffices h : U p.1 p.2 ≤ 0 by |
| intro t ht' x hx' |
| exact (hmax (show (t,x) ∈ Icc 0 Q ×ˢ Icc (-R) R from ⟨ht',hx'⟩)).trans h |
| by_contra hn |
| have hpos : 0 < U p.1 p.2 := lt_of_not_ge hn |
| have htQ : p.1 < Q := lt_of_le_of_ne hpS.1.2 (by |
| intro he |
| have hh := hterm p.2 hpS.2 |
| rw [← he] at hh |
| exact (not_le_of_gt hpos) hh) |
| have hxl : -R < p.2 := lt_of_le_of_ne hpS.2.1 (by |
| intro he |
| have hh := hleft p.1 hpS.1 |
| rw [he] at hh |
| exact (not_le_of_gt hpos) hh) |
| have hxr : p.2 < R := lt_of_le_of_ne hpS.2.2 (by |
| intro he |
| have hh := hright p.1 hpS.1 |
| rw [← he] at hh |
| exact (not_le_of_gt hpos) hh) |
| have hxmax : IsMaxOn (U p.1) (Icc (-R) R) p.2 := |
| fun x hx' => hmax (show (p.1,x) ∈ Icc 0 Q ×ˢ Icc (-R) R from ⟨hpS.1,hx'⟩) |
| have hxlocal : IsLocalMax (U p.1) p.2 := |
| hxmax.isLocalMax (Icc_mem_nhds hxl hxr) |
| have hzero := hxlocal.deriv_eq_zero |
| have hsecond := localMax_second_deriv_nonpos (hx p.1 hpS.1) hxlocal |
| have htmax : IsMaxOn (fun t => U t p.2) (Icc p.1 Q) p.1 := |
| fun t ht' => hmax (show (t,p.2) ∈ Icc 0 Q ×ˢ Icc (-R) R from ⟨⟨hpS.1.1.trans ht'.1,ht'.2⟩,hpS.2⟩) |
| have htan : Q-p.1 ∈ posTangentConeAt (Icc p.1 Q) p.1 := |
| sub_mem_posTangentConeAt_of_segment_subset (segment_eq_Icc htQ.le ▸ Subset.rfl) |
| have hd := (ht p.1 ⟨hpS.1.1,htQ⟩ p.2).mono (show Icc p.1 Q ⊆ Ici p.1 from fun _ h => h.1) |
| have hnonpos : (Q-p.1)*d p.1 p.2 ≤ 0 := by |
| simpa only [ContinuousLinearMap.smulRight_apply,ContinuousLinearMap.toSpanSingleton_apply,one_apply_eq_self,smul_eq_mul] using |
| htmax.isLocalMaxOn.hasFDerivWithinAt_nonpos hd htan |
| have hdt : d p.1 p.2 ≤ 0 := by nlinarith [sub_pos.mpr htQ] |
| have hstrict := hp p.1 ⟨hpS.1.1,htQ⟩ p.2 ⟨hxl,hxr⟩ |
| rw [hzero,mul_zero,add_zero] at hstrict |
| linarith |
|
|
| def quarticBarrier (ε c Q t x : ℝ) : ℝ := |
| ε*Real.exp (c*(Q-t))*(1+x^2)^2 |
|
|
| lemma quarticBarrier_space (ε c Q t x : ℝ) : |
| HasDerivAt (quarticBarrier ε c Q t) |
| (ε*Real.exp (c*(Q-t))*(4*x*(1+x^2))) x := by |
| unfold quarticBarrier |
| convert (((hasDerivAt_const x 1).add ((hasDerivAt_id x).pow 2)).pow 2).const_mul |
| (ε*Real.exp (c*(Q-t))) using 1 <;> first | rfl | (simp only [Pi.add_apply,Pi.pow_apply,id_eq]; ring) |
|
|
| lemma quarticBarrier_space2 (ε c Q t x : ℝ) : |
| HasDerivAt (deriv (quarticBarrier ε c Q t)) |
| (ε*Real.exp (c*(Q-t))*(4+12*x^2)) x := by |
| have he : deriv (quarticBarrier ε c Q t)= |
| fun y => ε*Real.exp (c*(Q-t))*(4*y*(1+y^2)) := |
| funext fun y => (quarticBarrier_space ε c Q t y).deriv |
| rw [he] |
| convert (((hasDerivAt_id x).const_mul 4).mul |
| ((hasDerivAt_const x 1).add ((hasDerivAt_id x).pow 2))).const_mul |
| (ε*Real.exp (c*(Q-t))) using 1 <;> first | rfl | (simp only [Pi.add_apply,Pi.pow_apply,id_eq]; ring) |
|
|
| lemma quarticBarrier_time (ε c Q t x : ℝ) : |
| HasDerivAt (fun s => quarticBarrier ε c Q s x) |
| (-c*quarticBarrier ε c Q t x) t := by |
| unfold quarticBarrier |
| convert ((((hasDerivAt_const t Q).sub (hasDerivAt_id t)).const_mul c).exp.const_mul ε).mul_const |
| ((1+x^2)^2) using 1 <;> first | rfl | (simp only [Pi.sub_apply,id_eq]; ring) |
|
|
| lemma quartic_transport_neg {K b x : ℝ} (hK : 0 ≤ K) |
| (hb : |b| ≤ K*(1+|x|)) : |
| -(8*K+8)*(1+x^2)^2+(1/2:ℝ)*(4+12*x^2)+b*(4*x*(1+x^2)) < 0 := by |
| have hnorm : (1+|x|)*|x| ≤ 2*(1+x^2) := by |
| nlinarith [sq_abs x,sq_nonneg (|x|-1)] |
| have hbx : b*x ≤ 2*K*(1+x^2) := calc |
| b*x ≤ |b*x| := le_abs_self _ |
| _ = |b| * |x| := abs_mul _ _ |
| _ ≤ K*(1+|x|)*|x| := mul_le_mul_of_nonneg_right hb (abs_nonneg _) |
| _ ≤ 2*K*(1+x^2) := by nlinarith [mul_le_mul_of_nonneg_left hnorm hK] |
| have ht := mul_le_mul_of_nonneg_left hbx (show 0 ≤ 4*(1+x^2) by positivity) |
| nlinarith [sq_nonneg x,sq_nonneg (x^2)] |
|
|
| lemma backward_quartic_bound {Q K C : ℝ} (hQ : 0 < Q) (hK : 0 ≤ K) (hC : 0 ≤ C) |
| {U b d : ℝ → ℝ → ℝ} |
| (hc : ContinuousOn (fun p : ℝ × ℝ => U p.1 p.2) (Icc 0 Q ×ˢ univ)) |
| (hx : ∀ t ∈ Icc 0 Q, Differentiable ℝ (U t) ∧ Differentiable ℝ (deriv (U t))) |
| (ht : ∀ t ∈ Ico 0 Q, ∀ x, HasDerivWithinAt (fun s => U s x) (d t x) (Ici t) t) |
| (hb : ∀ t ∈ Icc 0 Q, ∀ x, |b t x| ≤ K*(1+|x|)) |
| (hg : ∀ t ∈ Icc 0 Q, ∀ x, U t x ≤ C*(1+x^2)) |
| (hp : ∀ t ∈ Ico 0 Q, ∀ x, |
| 0 ≤ d t x+(1/2:ℝ)*deriv (deriv (U t)) x+b t x*deriv (U t) x) |
| (hterm : ∀ x, U Q x ≤ 0) |
| {ε : ℝ} (hε : 0 < ε) : |
| ∀ t ∈ Icc 0 Q, ∀ x, U t x ≤ quarticBarrier ε (8*K+8) Q t x := by |
| let c := 8*K+8 |
| have hcpos : 0 ≤ c := by dsimp [c]; positivity |
| let V : ℝ → ℝ → ℝ := fun t x => U t x-quarticBarrier ε c Q t x |
| let vd : ℝ → ℝ → ℝ := fun t x => d t x+c*quarticBarrier ε c Q t x |
| have hvx (t : ℝ) (ht' : t ∈ Icc 0 Q) (x : ℝ) : |
| HasDerivAt (V t) (deriv (U t) x-ε*Real.exp (c*(Q-t))*(4*x*(1+x^2))) x := |
| ((hx t ht').1 x).hasDerivAt.sub (quarticBarrier_space ε c Q t x) |
| have hvxx (t : ℝ) (ht' : t ∈ Icc 0 Q) (x : ℝ) : |
| deriv (deriv (V t)) x=deriv (deriv (U t)) x-ε*Real.exp (c*(Q-t))*(4+12*x^2) := by |
| have he : deriv (V t)=fun y => deriv (U t) y-deriv (quarticBarrier ε c Q t) y := by |
| ext y |
| rw [(hvx t ht' y).deriv,(quarticBarrier_space ε c Q t y).deriv] |
| rw [he] |
| exact (((hx t ht').2 x).hasDerivAt.sub (quarticBarrier_space2 ε c Q t x)).deriv |
| have hvtime (t : ℝ) (ht' : t ∈ Ico 0 Q) (x : ℝ) : |
| HasDerivWithinAt (fun s => V s x) (vd t x) (Ici t) t := by |
| convert (ht t ht' x).sub (quarticBarrier_time ε c Q t x).hasDerivWithinAt using 1; first | rfl | (dsimp [V,vd]; ring) |
| have hvp (t : ℝ) (ht' : t ∈ Ico 0 Q) (x : ℝ) : |
| 0 < vd t x+(1/2:ℝ)*deriv (deriv (V t)) x+b t x*deriv (V t) x := by |
| have htcc : t ∈ Icc 0 Q := ⟨ht'.1,ht'.2.le⟩ |
| rw [hvxx t htcc x,(hvx t htcc x).deriv] |
| have hneg := quartic_transport_neg hK (hb t htcc x) |
| have hneg' := mul_neg_of_pos_of_neg (mul_pos hε (Real.exp_pos (c*(Q-t)))) hneg |
| have hP := hp t ht' x |
| dsimp [vd,quarticBarrier,c] at * |
| nlinarith |
| intro t ht' x |
| let R := |x|+C/ε+1 |
| have hdiv : 0 ≤ C/ε := div_nonneg hC hε.le |
| have hR1 : 1 ≤ R := by dsimp [R]; linarith [abs_nonneg x] |
| have hR : 0 < R := by linarith |
| have hxR : x ∈ Icc (-R) R := by |
| dsimp [R]; constructor <;> linarith [le_abs_self x,neg_abs_le x] |
| have hCR : C ≤ ε*(1+R^2) := by |
| have hr : C/ε ≤ 1+R^2 := by dsimp [R] at hR1 ⊢; nlinarith [abs_nonneg x,sq_nonneg R] |
| have hh := (div_le_iff₀ hε).mp hr |
| nlinarith |
| have hB (s : ℝ) (hs : s ∈ Icc 0 Q) : |
| C*(1+R^2) ≤ quarticBarrier ε c Q s R := by |
| have he : 1 ≤ Real.exp (c*(Q-s)) := |
| Real.one_le_exp_iff.mpr (mul_nonneg hcpos (sub_nonneg.mpr hs.2)) |
| have hh := mul_le_mul_of_nonneg_right hCR (show 0 ≤ 1+R^2 by positivity) |
| have he' := mul_le_mul_of_nonneg_right he (show 0 ≤ ε*(1+R^2)^2 by positivity) |
| dsimp [quarticBarrier] |
| nlinarith |
| have hVc : ContinuousOn (fun p : ℝ × ℝ => V p.1 p.2) (Icc 0 Q ×ˢ Icc (-R) R) := by |
| apply (hc.mono (by intro p hp'; exact ⟨hp'.1,mem_univ _⟩)).sub |
| have hh : Continuous (fun p : ℝ × ℝ => quarticBarrier ε c Q p.1 p.2) := by |
| unfold quarticBarrier |
| fun_prop |
| exact hh.continuousOn |
| have hcomp := backward_strict_compact (b := b) hQ hR hVc |
| (fun s hs y => (hvx s hs y).differentiableAt) hvtime (fun s hs y _ => hvp s hs y) |
| (fun y _ => by |
| dsimp [V] |
| have hn : 0 ≤ quarticBarrier ε c Q Q y := by unfold quarticBarrier; positivity |
| linarith [hterm y]) |
| (fun s hs => by |
| dsimp [V] |
| have hh := hg s hs (-R) |
| have hh' := hB s hs |
| simp only [neg_sq] at hh |
| have he : quarticBarrier ε c Q s (-R)=quarticBarrier ε c Q s R := by simp [quarticBarrier] |
| rw [he] |
| linarith) |
| (fun s hs => by dsimp [V]; linarith [hg s hs R,hB s hs]) |
| have hh := hcomp t ht' x hxR |
| dsimp [V] at hh |
| linarith |
|
|
| def BackwardComparisonStatement : Prop := |
| ∀ (Q K C : ℝ), 0 < Q → 0 ≤ K → 0 ≤ C → |
| ∀ (U b d : ℝ → ℝ → ℝ), |
| ContinuousOn (fun p : ℝ × ℝ => U p.1 p.2) (Icc 0 Q ×ˢ univ) → |
| (∀ t ∈ Icc 0 Q, Differentiable ℝ (U t) ∧ Differentiable ℝ (deriv (U t))) → |
| (∀ t ∈ Ico 0 Q, ∀ x, HasDerivWithinAt (fun s => U s x) (d t x) (Ici t) t) → |
| (∀ t ∈ Icc 0 Q, ∀ x, |b t x| ≤ K*(1+|x|)) → |
| (∀ t ∈ Icc 0 Q, ∀ x, U t x ≤ C*(1+x^2)) → |
| (∀ t ∈ Ico 0 Q, ∀ x, |
| 0 ≤ d t x+(1/2:ℝ)*deriv (deriv (U t)) x+b t x*deriv (U t) x) → |
| (∀ x, U Q x ≤ 0) → |
| ∀ t ∈ Icc 0 Q, ∀ x, U t x ≤ 0 |
|
|
| theorem backward_comparison : BackwardComparisonStatement := by |
| intro Q K C hQ hK hC U b d hc hx ht hb hg hp hterm t ht' x |
| by_contra hn |
| have hpos : 0 < U t x := lt_of_not_ge hn |
| let M := Real.exp ((8*K+8)*(Q-t))*(1+x^2)^2 |
| have hM : 0 < M := by dsimp [M]; positivity |
| let ε := U t x/(2*M) |
| have hε : 0 < ε := div_pos hpos (by positivity) |
| have hh := backward_quartic_bound hQ hK hC hc hx ht hb hg hp hterm hε t ht' x |
| have he : quarticBarrier ε (8*K+8) Q t x=U t x/2 := by |
| dsimp only [quarticBarrier] |
| rw [mul_assoc] |
| change (U t x/(2*M))*M=U t x/2 |
| field_simp |
| rw [he] at hh |
| linarith |
|
|
| end MicroscopicJamming |
|
|
| |
| open Set Filter |
| open scoped Topology |
|
|
| namespace MicroscopicJamming |
|
|
| |
|
|
| def quadraticSourceBarrier (D c Q t x : ℝ) : ℝ := |
| D*(Q-t)*Real.exp (c*(Q-t))*(1+x^2) |
|
|
| lemma quadraticSourceBarrier_space (D c Q t x : ℝ) : |
| HasDerivAt (quadraticSourceBarrier D c Q t) |
| (D*(Q-t)*Real.exp (c*(Q-t))*(2*x)) x := by |
| unfold quadraticSourceBarrier |
| convert ((hasDerivAt_const x 1).add ((hasDerivAt_id x).pow 2)).const_mul |
| (D*(Q-t)*Real.exp (c*(Q-t))) using 1 <;> |
| first | rfl | (simp only [id_eq]; ring) |
|
|
| lemma quadraticSourceBarrier_space2 (D c Q t x : ℝ) : |
| HasDerivAt (deriv (quadraticSourceBarrier D c Q t)) |
| (2*D*(Q-t)*Real.exp (c*(Q-t))) x := by |
| have he : deriv (quadraticSourceBarrier D c Q t)= |
| fun y => D*(Q-t)*Real.exp (c*(Q-t))*(2*y) := |
| funext fun y => (quadraticSourceBarrier_space D c Q t y).deriv |
| rw [he] |
| convert ((hasDerivAt_id x).const_mul 2).const_mul |
| (D*(Q-t)*Real.exp (c*(Q-t))) using 1 <;> first | rfl | ring |
|
|
| lemma quadraticSourceBarrier_time (D c Q t x : ℝ) : |
| HasDerivAt (fun s => quadraticSourceBarrier D c Q s x) |
| (-D*Real.exp (c*(Q-t))*(1+c*(Q-t))*(1+x^2)) t := by |
| unfold quadraticSourceBarrier |
| have hs := (hasDerivAt_const t Q).sub (hasDerivAt_id t) |
| convert (((hs.const_mul D).mul (hs.const_mul c).exp).mul_const (1+x^2)) using 1 <;> |
| first | rfl | (simp only [Pi.sub_apply,id_eq]; ring) |
|
|
| lemma quadratic_transport_bound {D K Q t x b : ℝ} |
| (hD : 0 ≤ D) (hK : 0 ≤ K) (ht : t ≤ Q) (hb : |b| ≤ K*(1+|x|)) : |
| -D*Real.exp ((4*K+2)*(Q-t))*(1+(4*K+2)*(Q-t))*(1+x^2)+ |
| (1/2:ℝ)*(2*D*(Q-t)*Real.exp ((4*K+2)*(Q-t)))+ |
| b*(D*(Q-t)*Real.exp ((4*K+2)*(Q-t))*(2*x)) ≤ -D*(1+x^2) := by |
| have hnorm : (1+|x|)*|x| ≤ 2*(1+x^2) := by |
| nlinarith [sq_abs x,sq_nonneg (|x|-1)] |
| have hbx : b*x ≤ 2*K*(1+x^2) := calc |
| b*x ≤ |b*x| := le_abs_self _ |
| _ = |b| * |x| := abs_mul _ _ |
| _ ≤ K*(1+|x|)*|x| := mul_le_mul_of_nonneg_right hb (abs_nonneg _) |
| _ ≤ 2*K*(1+x^2) := by nlinarith [mul_le_mul_of_nonneg_left hnorm hK] |
| have hpoly : 1+2*b*x-(4*K+2)*(1+x^2) ≤ 0 := by nlinarith [sq_nonneg x] |
| have he : 1 ≤ Real.exp ((4*K+2)*(Q-t)) := |
| Real.one_le_exp_iff.mpr (mul_nonneg (by positivity) (sub_nonneg.mpr ht)) |
| have hx : 0 ≤ 1+x^2 := by positivity |
| have h1 := mul_nonpos_of_nonneg_of_nonpos |
| (show 0 ≤ D*(Q-t)*Real.exp ((4*K+2)*(Q-t)) by positivity) hpoly |
| have h2 := mul_le_mul_of_nonneg_left he (mul_nonneg hD hx) |
| nlinarith |
|
|
| def BackwardSourceComparisonStatement : Prop := |
| ∀ (Q K C D : ℝ), 0 < Q → 0 ≤ K → 0 ≤ C → 0 ≤ D → |
| ∀ (U b d : ℝ → ℝ → ℝ), |
| ContinuousOn (fun p : ℝ × ℝ => U p.1 p.2) (Icc 0 Q ×ˢ univ) → |
| (∀ t ∈ Icc 0 Q, Differentiable ℝ (U t) ∧ Differentiable ℝ (deriv (U t))) → |
| (∀ t ∈ Ico 0 Q, ∀ x, HasDerivWithinAt (fun s => U s x) (d t x) (Ici t) t) → |
| (∀ t ∈ Icc 0 Q, ∀ x, |b t x| ≤ K*(1+|x|)) → |
| (∀ t ∈ Icc 0 Q, ∀ x, U t x ≤ C*(1+x^2)) → |
| (∀ t ∈ Ico 0 Q, ∀ x, |
| -D*(1+x^2) ≤ d t x+(1/2:ℝ)*deriv (deriv (U t)) x+b t x*deriv (U t) x) → |
| (∀ x, U Q x ≤ 0) → |
| ∀ t ∈ Icc 0 Q, ∀ x, U t x ≤ quadraticSourceBarrier D (4*K+2) Q t x |
|
|
| theorem backward_source_comparison : BackwardSourceComparisonStatement := by |
| intro Q K C D hQ hK hC hD U b d hc hx ht hb hg hp hterm |
| let c := 4*K+2 |
| let V : ℝ → ℝ → ℝ := fun t x => U t x-quadraticSourceBarrier D c Q t x |
| let vd : ℝ → ℝ → ℝ := fun t x => d t x+ |
| D*Real.exp (c*(Q-t))*(1+c*(Q-t))*(1+x^2) |
| have hvx (t : ℝ) (ht' : t ∈ Icc 0 Q) (x : ℝ) : |
| HasDerivAt (V t) (deriv (U t) x-D*(Q-t)*Real.exp (c*(Q-t))*(2*x)) x := |
| ((hx t ht').1 x).hasDerivAt.sub (quadraticSourceBarrier_space D c Q t x) |
| have hvxx (t : ℝ) (ht' : t ∈ Icc 0 Q) (x : ℝ) : |
| HasDerivAt (deriv (V t)) (deriv (deriv (U t)) x-2*D*(Q-t)*Real.exp (c*(Q-t))) x := by |
| have he : deriv (V t)=fun y => deriv (U t) y-deriv (quadraticSourceBarrier D c Q t) y := by |
| ext y |
| rw [(hvx t ht' y).deriv,(quadraticSourceBarrier_space D c Q t y).deriv] |
| rw [he] |
| exact ((hx t ht').2 x).hasDerivAt.sub (quadraticSourceBarrier_space2 D c Q t x) |
| have hvtime (t : ℝ) (ht' : t ∈ Ico 0 Q) (x : ℝ) : |
| HasDerivWithinAt (fun s => V s x) (vd t x) (Ici t) t := by |
| convert (ht t ht' x).sub (quadraticSourceBarrier_time D c Q t x).hasDerivWithinAt using 1; |
| first | rfl | (dsimp [V,vd]; ring) |
| have hvp (t : ℝ) (ht' : t ∈ Ico 0 Q) (x : ℝ) : |
| 0 ≤ vd t x+(1/2:ℝ)*deriv (deriv (V t)) x+b t x*deriv (V t) x := by |
| have htcc : t ∈ Icc 0 Q := ⟨ht'.1,ht'.2.le⟩ |
| rw [(hvxx t htcc x).deriv,(hvx t htcc x).deriv] |
| have hneg := quadratic_transport_bound hD hK htcc.2 (hb t htcc x) |
| have hP := hp t ht' x |
| dsimp [vd,c] at * |
| linarith |
| have hVc : ContinuousOn (fun p : ℝ × ℝ => V p.1 p.2) (Icc 0 Q ×ˢ univ) := by |
| apply hc.sub |
| have hh : Continuous (fun p : ℝ × ℝ => quadraticSourceBarrier D c Q p.1 p.2) := by |
| unfold quadraticSourceBarrier |
| fun_prop |
| exact hh.continuousOn |
| have hVg (t : ℝ) (ht' : t ∈ Icc 0 Q) (x : ℝ) : V t x ≤ C*(1+x^2) := by |
| have hn : 0 ≤ quadraticSourceBarrier D c Q t x := by |
| unfold quadraticSourceBarrier |
| exact mul_nonneg (mul_nonneg (mul_nonneg hD (sub_nonneg.mpr ht'.2)) |
| (Real.exp_pos _).le) (by positivity) |
| dsimp [V] |
| linarith [hg t ht' x] |
| have hVterm (x : ℝ) : V Q x ≤ 0 := by |
| simpa [V,quadraticSourceBarrier] using hterm x |
| have hcomp := backward_comparison Q K C hQ hK hC V b vd hVc |
| (fun t ht' => ⟨fun x => (hvx t ht' x).differentiableAt, |
| fun x => (hvxx t ht' x).differentiableAt⟩) hvtime hb hVg hvp hVterm |
| intro t ht' x |
| have hh := hcomp t ht' x |
| dsimp [V,c] at hh |
| linarith |
| end MicroscopicJamming |
|
|
| |
| open Set Filter |
| open scoped Topology |
|
|
| namespace MicroscopicJamming |
|
|
| |
|
|
| lemma variance_difference_le {Q C L δ : ℝ} (hQ : 0 < Q) (hC : 0 ≤ C) |
| (hL : 0 ≤ L) (hδ : 0 ≤ δ) {F G : ℝ → ℝ → ℝ} {m n : ℝ → ℝ} |
| (hcF : ContinuousOn (fun p : ℝ × ℝ => F p.1 p.2) (Icc 0 Q ×ˢ univ)) |
| (hcG : ContinuousOn (fun p : ℝ × ℝ => G p.1 p.2) (Icc 0 Q ×ˢ univ)) |
| (hxF : ∀ t ∈ Icc 0 Q, Differentiable ℝ (F t) ∧ Differentiable ℝ (deriv (F t))) |
| (hxG : ∀ t ∈ Icc 0 Q, Differentiable ℝ (G t) ∧ Differentiable ℝ (deriv (G t))) |
| (htF : ∀ t ∈ Ico 0 Q, ∀ x, HasDerivWithinAt (fun s => F s x) |
| (-(1/2:ℝ)*(deriv (deriv (F t)) x+m t*(deriv (F t) x)^2)) (Ici t) t) |
| (htG : ∀ t ∈ Ico 0 Q, ∀ x, HasDerivWithinAt (fun s => G s x) |
| (-(1/2:ℝ)*(deriv (deriv (G t)) x+n t*(deriv (G t) x)^2)) (Ici t) t) |
| (hm : ∀ t ∈ Icc 0 Q, 0 ≤ m t ∧ m t ≤ 1) |
| (hclose : ∀ t ∈ Ico 0 Q, |m t-n t| ≤ δ) |
| (hboundF : ∀ t ∈ Icc 0 Q, ∀ x, |F t x| ≤ C*(1+x^2)) |
| (hboundG : ∀ t ∈ Icc 0 Q, ∀ x, |G t x| ≤ C*(1+x^2)) |
| (hgradF : ∀ t ∈ Icc 0 Q, ∀ x, |deriv (F t) x| ≤ L*(1+|x|)) |
| (hgradG : ∀ t ∈ Icc 0 Q, ∀ x, |deriv (G t) x| ≤ L*(1+|x|)) |
| (hterm : ∀ x, F Q x=G Q x) : |
| ∀ t ∈ Icc 0 Q, ∀ x, |
| F t x-G t x ≤ quadraticSourceBarrier (δ*L^2) (4*L+2) Q t x := by |
| let U : ℝ → ℝ → ℝ := fun t x => F t x-G t x |
| let b : ℝ → ℝ → ℝ := fun t x => m t*(deriv (F t) x+deriv (G t) x)/2 |
| let d : ℝ → ℝ → ℝ := fun t x => |
| -(1/2:ℝ)*(deriv (deriv (F t)) x+m t*(deriv (F t) x)^2)- |
| (-(1/2:ℝ)*(deriv (deriv (G t)) x+n t*(deriv (G t) x)^2)) |
| have hdx (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) : |
| HasDerivAt (U t) (deriv (F t) x-deriv (G t) x) x := |
| ((hxF t ht).1 x).hasDerivAt.sub ((hxG t ht).1 x).hasDerivAt |
| have hdx2 (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) : |
| HasDerivAt (deriv (U t)) (deriv (deriv (F t)) x-deriv (deriv (G t)) x) x := by |
| have he : deriv (U t)=fun y => deriv (F t) y-deriv (G t) y := |
| funext fun y => (hdx t ht y).deriv |
| rw [he] |
| exact ((hxF t ht).2 x).hasDerivAt.sub ((hxG t ht).2 x).hasDerivAt |
| have hc : ContinuousOn (fun p : ℝ × ℝ => U p.1 p.2) (Icc 0 Q ×ˢ univ) := hcF.sub hcG |
| have hx (t : ℝ) (ht : t ∈ Icc 0 Q) : |
| Differentiable ℝ (U t) ∧ Differentiable ℝ (deriv (U t)) := |
| ⟨fun x => (hdx t ht x).differentiableAt,fun x => (hdx2 t ht x).differentiableAt⟩ |
| have htime (t : ℝ) (ht : t ∈ Ico 0 Q) (x : ℝ) : |
| HasDerivWithinAt (fun s => U s x) (d t x) (Ici t) t := (htF t ht x).sub (htG t ht x) |
| have hb (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) : |b t x| ≤ L*(1+|x|) := by |
| have hsum : |deriv (F t) x+deriv (G t) x| ≤ 2*L*(1+|x|) := by |
| calc |
| _ ≤ |deriv (F t) x|+|deriv (G t) x| := abs_add_le _ _ |
| _ ≤ L*(1+|x|)+L*(1+|x|) := add_le_add (hgradF t ht x) (hgradG t ht x) |
| _ = _ := by ring |
| have hmul := mul_le_mul_of_nonneg_left hsum (hm t ht).1 |
| have hmul' := mul_le_mul_of_nonneg_right (hm t ht).2 (show 0 ≤ 2*L*(1+|x|) by positivity) |
| dsimp [b] |
| rw [abs_div,abs_mul,abs_of_nonneg (hm t ht).1,abs_of_pos (by norm_num : (0:ℝ)<2)] |
| linarith |
| have hg (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) : U t x ≤ (2*C)*(1+x^2) := by |
| dsimp [U] |
| have h1 := hboundF t ht x |
| have h2 := hboundG t ht x |
| nlinarith [le_abs_self (F t x),neg_abs_le (G t x)] |
| have hp (t : ℝ) (ht : t ∈ Ico 0 Q) (x : ℝ) : |
| -(δ*L^2)*(1+x^2) ≤ d t x+(1/2:ℝ)*deriv (deriv (U t)) x+b t x*deriv (U t) x := by |
| have htcc : t ∈ Icc 0 Q := ⟨ht.1,ht.2.le⟩ |
| rw [(hdx2 t htcc x).deriv,(hdx t htcc x).deriv] |
| have he : d t x+(1/2:ℝ)*(deriv (deriv (F t)) x-deriv (deriv (G t)) x)+ |
| b t x*(deriv (F t) x-deriv (G t) x)= |
| -(m t-n t)*(deriv (G t) x)^2/2 := by dsimp [d,b]; ring |
| rw [he] |
| have hsquare : (deriv (G t) x)^2 ≤ 2*L^2*(1+x^2) := by |
| have hs := pow_le_pow_left₀ (abs_nonneg (deriv (G t) x)) (hgradG t htcc x) 2 |
| rw [sq_abs] at hs |
| have hab : (1+|x|)^2 ≤ 2*(1+x^2) := by nlinarith [sq_abs x,sq_nonneg (|x|-1)] |
| have hh := mul_le_mul_of_nonneg_left hab (sq_nonneg L) |
| nlinarith |
| have h1 := mul_le_mul_of_nonneg_right (abs_le.mp (hclose t ht)).2 (sq_nonneg (deriv (G t) x)) |
| have h2 := mul_le_mul_of_nonneg_left hsquare hδ |
| nlinarith |
| have hterm' (x : ℝ) : U Q x ≤ 0 := by simp [U,hterm x] |
| exact backward_source_comparison Q L (2*C) (δ*L^2) hQ hL (by positivity) (by positivity) |
| U b d hc hx htime hb hg hp hterm' |
| end MicroscopicJamming |
|
|
| |
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped NNReal Topology |
|
|
| namespace MicroscopicJamming |
| |
|
|
| def GaussianStepStabilityStatement : Prop := |
| ∀ A B C κ Q : ℝ, 0 < Q → 0 ≤ A → 0 ≤ C → 0 ≤ κ → κ*Q < 1 → |
| ∃ L : ℝ, 0 ≤ L ∧ ∀ u : ℝ → ℝ, RowAnalyticTerminal u A B C κ Q → |
| ∀ rs ss : List (ℝ × ℝ), |
| (∀ r ∈ rs, 0 ≤ r.1 ∧ r.1 ≤ 1 ∧ 0 ≤ r.2) → |
| (∀ r ∈ ss, 0 ≤ r.1 ∧ r.1 ≤ 1 ∧ 0 ≤ r.2) → |
| gaussianStepTime rs=Q → gaussianStepTime ss=Q → |
| ∀ δ : ℝ, 0 ≤ δ → |
| (∀ t ∈ Icc 0 Q, |gaussianStepCoefficient rs t-gaussianStepCoefficient ss t| ≤ δ) → |
| ∀ t ∈ Icc 0 Q, ∀ x, |
| |gaussianStepPath rs u t x-gaussianStepPath ss u t x| ≤ δ*L*(1+x^2) |
|
|
| theorem gaussian_step_stability : GaussianStepStabilityStatement := by |
| intro A B C κ Q hQ hA hC hκ hκQ |
| obtain ⟨D,L,hD,hL,hpath⟩ := gaussian_step_path A B C κ Q hQ hA hC hκ hκQ |
| refine ⟨L^2*Q*Real.exp ((4*L+2)*Q),by positivity,?_⟩ |
| intro u hu rs ss hrs hss hTr hTs δ hδ hclose |
| obtain ⟨_,htermR,htimeR,hspaceR⟩ := hpath u hu rs hrs hTr.le |
| obtain ⟨_,htermS,htimeS,hspaceS⟩ := hpath u hu ss hss hTs.le |
| have hxr (t : ℝ) (ht : t ∈ Icc 0 Q) : |
| Differentiable ℝ (gaussianStepPath rs u t) ∧ Differentiable ℝ (deriv (gaussianStepPath rs u t)) := by |
| have hh := hspaceR t ht.1 (hTr ▸ ht.2) |
| exact ⟨hh.1,hh.2.1⟩ |
| have hxs (t : ℝ) (ht : t ∈ Icc 0 Q) : |
| Differentiable ℝ (gaussianStepPath ss u t) ∧ Differentiable ℝ (deriv (gaussianStepPath ss u t)) := by |
| have hh := hspaceS t ht.1 (hTs ▸ ht.2) |
| exact ⟨hh.1,hh.2.1⟩ |
| have hgr (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) : |
| |deriv (gaussianStepPath rs u t) x| ≤ L*(1+|x|) := |
| ((hspaceR t ht.1 (hTr ▸ ht.2)).2.2 x).1 |
| have hgs (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) : |
| |deriv (gaussianStepPath ss u t) x| ≤ L*(1+|x|) := |
| ((hspaceS t ht.1 (hTs ▸ ht.2)).2.2 x).1 |
| have hcr := gaussianStepPath_jointly_continuous hD hL hTr htimeR |
| (fun t ht htR => ⟨(hspaceR t ht htR).1,fun x => ((hspaceR t ht htR).2.2 x).1⟩) |
| have hcs := gaussianStepPath_jointly_continuous hD hL hTs htimeS |
| (fun t ht htS => ⟨(hspaceS t ht htS).1,fun x => ((hspaceS t ht htS).2.2 x).1⟩) |
| have hpr (t : ℝ) (ht : t ∈ Ico 0 Q) (x : ℝ) := |
| gaussianStepPath_right_pde hQ hu hrs hTr.le (hTr ▸ ht) x |
| have hps (t : ℝ) (ht : t ∈ Ico 0 Q) (x : ℝ) := |
| gaussianStepPath_right_pde hQ hu hss hTs.le (hTs ▸ ht) x |
| have hb : 0 ≤ |B|+A*(1+Q) := by positivity |
| have hvr (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) := |
| gaussianStepPath_global_value_bound hQ hu hrs hTr ht x |
| have hvs (t : ℝ) (ht : t ∈ Icc 0 Q) (x : ℝ) := |
| gaussianStepPath_global_value_bound hQ hu hss hTs ht x |
| have hmr (t : ℝ) (_ : t ∈ Icc 0 Q) := gaussianStepRightCoefficient_bounds hrs t |
| have hms (t : ℝ) (_ : t ∈ Icc 0 Q) := gaussianStepRightCoefficient_bounds hss t |
| have hδr (t : ℝ) (ht : t ∈ Ico 0 Q) := gaussianStepRightCoefficient_close hclose ht |
| have hδs (t : ℝ) (ht : t ∈ Ico 0 Q) : |
| |gaussianStepRightCoefficient ss t-gaussianStepRightCoefficient rs t| ≤ δ := by |
| rw [abs_sub_comm] |
| exact hδr t ht |
| have hterm (x : ℝ) : gaussianStepPath rs u Q x=gaussianStepPath ss u Q x := by |
| simpa only [hTr,hTs] using (htermR x).trans (htermS x).symm |
| have hr := variance_difference_le hQ hb hL hδ hcr hcs hxr hxs hpr hps hmr hδr hvr hvs hgr hgs hterm |
| have hs := variance_difference_le hQ hb hL hδ hcs hcr hxs hxr hps hpr hms hδs hvs hvr hgs hgr |
| (fun x => (hterm x).symm) |
| intro t ht x |
| have hab : |gaussianStepPath rs u t x-gaussianStepPath ss u t x| ≤ |
| quadraticSourceBarrier (δ*L^2) (4*L+2) Q t x := by |
| rw [abs_le] |
| constructor |
| · linarith [hs t ht x] |
| · exact hr t ht x |
| have he : Real.exp ((4*L+2)*(Q-t)) ≤ Real.exp ((4*L+2)*Q) := |
| Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (by linarith [ht.1]) (by positivity)) |
| have htq : (Q-t)*Real.exp ((4*L+2)*(Q-t)) ≤ Q*Real.exp ((4*L+2)*Q) := |
| mul_le_mul (by linarith [ht.1]) he (Real.exp_pos _).le hQ.le |
| calc |
| _ ≤ quadraticSourceBarrier (δ*L^2) (4*L+2) Q t x := hab |
| _ = (δ*L^2)*((Q-t)*Real.exp ((4*L+2)*(Q-t)))*(1+x^2) := by |
| unfold quadraticSourceBarrier |
| ring |
| _ ≤ (δ*L^2)*(Q*Real.exp ((4*L+2)*Q))*(1+x^2) := |
| mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left htq (by positivity)) (by positivity) |
| _ = δ*(L^2*Q*Real.exp ((4*L+2)*Q))*(1+x^2) := by ring |
| end MicroscopicJamming |
|
|
| |
| |
|
|
| namespace MicroscopicJamming |
|
|
| def GaussianStepThirdStatement : Prop := |
| ∀ (u : ℝ → ℝ) (A B C κ Q : ℝ), 0 < Q → RowAnalyticTerminal u A B C κ Q → |
| ∃ H : ℝ, 0 ≤ H ∧ |
| ∀ rs : List (ℝ × ℝ), (∀ r ∈ rs, 0 ≤ r.1 ∧ r.1 ≤ 1 ∧ 0 ≤ r.2) → |
| gaussianStepTime rs ≤ Q → ∀ t : ℝ, 0 ≤ t → t ≤ gaussianStepTime rs → |
| Differentiable ℝ (deriv (deriv (gaussianStepPath rs u t))) ∧ |
| ∀ x, |deriv (deriv (deriv (gaussianStepPath rs u t))) x| ≤ H |
| end MicroscopicJamming |
|
|
| end |
|
|
| end OAI |
|
|
