| import Mathlib |
| import OAI.Probability.ParisiFinite.Splice |
|
|
| namespace OAI |
|
|
| /-! Global Dyadic Field Error. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| namespace ParisiFinite |
|
|
| lemma global_dyadic_field_error (β : ℝ≥0) (hβ : 0<β) {γ : ℝ≥0 → ℝ≥0} |
| (hγ : Monotone γ) (hb : ∀ t,γ t ≤ β) (r : ℝ≥0) (hr : r<1) (n : ℕ) (x : ℝ) : |
| |(finiteTimeField β hβ (dyadicSchedule γ false 0 1 n) 0 r).val x-field β γ r x| ≤ |
| (β:ℝ)*dyadicMesh 1 n := by |
| have hh := dyadic_suffix_value_error β hβ hγ hb 0 1 n r hr x |
| rw [←zero_add (r:ℝ),finiteTimeField_suffix_val] |
| simpa only [zero_add,field] using hh |
|
|
| lemma global_dyadic_field_tendstoUniformly (β : ℝ≥0) (hβ : 0<β) {γ : ℝ≥0 → ℝ≥0} |
| (hγ : Monotone γ) (hb : ∀ t,γ t ≤ β) (r : ℝ≥0) (hr : r<1) : |
| TendstoUniformly (fun n => (finiteTimeField β hβ (dyadicSchedule γ false 0 1 n) 0 r).val) |
| (field β γ r) atTop := by |
| have he : Tendsto (fun n => (β:ℝ)*(dyadicMesh 1 n:ℝ)) atTop (𝓝 (0:ℝ)) := by |
| simpa only [mul_zero] using (dyadicMesh_tendsto 1).const_mul (β:ℝ) |
| rw [Metric.tendstoUniformly_iff] |
| intro ε hε |
| filter_upwards [he.eventually (gt_mem_nhds hε)] with n hn x |
| rw [Real.dist_eq,abs_sub_comm] |
| exact (global_dyadic_field_error β hβ hγ hb r hr n x).trans_lt hn |
|
|
| lemma global_dyadic_gradient_tendstoUniformly (β : ℝ≥0) (hβ : 0<β) {γ : ℝ≥0 → ℝ≥0} |
| (hγ : Monotone γ) (hb : ∀ t,γ t ≤ β) (r : ℝ≥0) (hr : r<1) : |
| TendstoUniformly (fun n => (finiteTimeField β hβ (dyadicSchedule γ false 0 1 n) 0 r).d1) |
| (fieldGradient β γ r) atTop := by |
| obtain ⟨m,hu,hd,_,_⟩ := exists_uniform_derivative_limit |
| (fun n => finiteTimeField_curvature β hβ _ (dyadicSchedule_coeff_bound hb false 0 1 n) 0 r) |
| (global_dyadic_field_tendstoUniformly β hβ hγ hb r hr) |
| have he : m=fieldGradient β γ r := funext fun x => (hd x).deriv.symm |
| rwa [he] at hu |
|
|
| lemma finiteTimeCoefficient_scheduleValue (ls : Schedule) (s : ℝ) (r : ℝ≥0) : |
| finiteTimeCoefficient ls s (s+r)=(scheduleValue ls r:ℝ) := by |
| induction ls generalizing s r with |
| | nil => rfl |
| | cons l ls ih => |
| rcases l with ⟨a,d⟩ |
| have hc : s+(r:ℝ)<s+(d:ℝ) ↔ r<d := by exact_mod_cast add_lt_add_iff_left s |
| simp only [finiteTimeCoefficient,scheduleValue,hc] |
| split_ifs with hrd |
| · rfl |
| · have he : s+(r:ℝ)=(s+d)+(r-d:ℝ≥0) := by |
| rw [NNReal.coe_sub (le_of_not_gt hrd)] |
| ring |
| rw [he,ih] |
|
|
| lemma dyadicSchedule_low_sample (γ : ℝ≥0 → ℝ≥0) (t d : ℝ≥0) (n : ℕ) |
| (r : ℝ≥0) (hr : r<d) : |
| ∃ y : ℝ≥0,scheduleValue (dyadicSchedule γ false t d n) r=γ y ∧ |
| y ≤ t+r ∧ t+r ≤ y+dyadicMesh d n := by |
| induction n generalizing t d r with |
| | zero => |
| refine ⟨t,?_,le_add_of_nonneg_right zero_le,?_⟩ |
| · simp [dyadicSchedule,scheduleValue,hr] |
| · simpa only [dyadicMesh,pow_zero,div_one] using add_le_add_right hr.le t |
| | succ n ih => |
| simp only [dyadicSchedule] |
| by_cases hrd : r<d/2 |
| · rw [scheduleValue_append_left _ _ r (by rwa [dyadicSchedule_nnwidth])] |
| simpa only [dyadicMesh_succ] using ih t (d/2) r hrd |
| · have hd : d/2 ≤ r := le_of_not_gt hrd |
| have he : d/2+(r-d/2)=r := add_tsub_cancel_of_le hd |
| have ht : r-d/2<d/2 := by |
| apply (tsub_lt_iff_left hd).mpr |
| simpa only [add_halves] using hr |
| have hlo := scheduleValue_append_right |
| (dyadicSchedule γ false t (d/2) n) |
| (dyadicSchedule γ false (t+d/2) (d/2) n) (r-d/2) |
| rw [dyadicSchedule_nnwidth,he] at hlo |
| rw [hlo] |
| simpa only [dyadicMesh_succ,add_assoc,he] using ih (t+d/2) (d/2) (r-d/2) ht |
|
|
| lemma dyadicSchedule_low_value_tendsto (γ : ℝ≥0 → ℝ≥0) (t d r : ℝ≥0) |
| (hr : r<d) (hc : ContinuousAt γ (t+r)) : |
| Tendsto (fun n => scheduleValue (dyadicSchedule γ false t d n) r) atTop (𝓝 (γ (t+r))) := by |
| choose y hy hlo hhi using fun n => dyadicSchedule_low_sample γ t d n r hr |
| have ht : Tendsto y atTop (𝓝 (t+r)) := by |
| rw [←NNReal.tendsto_coe] |
| apply tendsto_of_tendsto_of_tendsto_of_le_of_le |
| (by simpa only [sub_zero] using (tendsto_const_nhds.sub (dyadicMesh_tendsto d))) |
| tendsto_const_nhds |
| · intro n |
| have hh : (t+r:ℝ≥0) ≤ (y n:ℝ)+(dyadicMesh d n:ℝ) := by exact_mod_cast hhi n |
| linarith |
| · intro n; exact_mod_cast hlo n |
| simpa only [hy,Function.comp_def] using hc.tendsto.comp ht |
|
|
| lemma dyadicSchedule_low_value_coe_tendsto (γ : ℝ≥0 → ℝ≥0) (t d r : ℝ≥0) |
| (hr : r<d) (hc : ContinuousAt (fun s : ℝ => (γ (Real.toNNReal s):ℝ)) (t+r:ℝ≥0)) : |
| Tendsto (fun n => (scheduleValue (dyadicSchedule γ false t d n) r:ℝ)) |
| atTop (𝓝 (γ (t+r):ℝ)) := by |
| have hc' : ContinuousAt γ (t+r) := by |
| change Tendsto γ (𝓝 (t+r)) (𝓝 (γ (t+r))) |
| rw [←NNReal.tendsto_coe] |
| simpa only [Function.comp_def,Real.toNNReal_coe] using |
| (hc.comp NNReal.continuous_coe.continuousAt).tendsto |
| exact NNReal.continuous_coe.continuousAt.tendsto.comp |
| (dyadicSchedule_low_value_tendsto γ t d r hr hc') |
|
|
| lemma global_dyadic_coefficient_tendsto_ae {γ : ℝ≥0 → ℝ≥0} (hγ : Monotone γ) : |
| ∀ᵐ t ∂volume,t ∈ Ioo (0:ℝ) 1 → |
| Tendsto (fun n => finiteTimeCoefficient (dyadicSchedule γ false 0 1 n) 0 t) |
| atTop (𝓝 (γ (Real.toNNReal t):ℝ)) := by |
| let c (s : ℝ) : ℝ := γ (Real.toNNReal s) |
| have hm : Monotone c := fun s t h => |
| NNReal.coe_le_coe.mpr (hγ (Real.toNNReal_le_toNNReal h)) |
| have hc : ∀ᵐ t ∂volume,ContinuousAt c t := by |
| rw [ae_iff] |
| exact hm.countable_not_continuousAt.measure_zero volume |
| filter_upwards [hc] with t ht hmem |
| have hr : Real.toNNReal t < 1 := by |
| exact_mod_cast (show (Real.toNNReal t:ℝ)<1 by rw [Real.coe_toNNReal _ hmem.1.le];exact hmem.2) |
| have hh := dyadicSchedule_low_value_coe_tendsto γ 0 1 (Real.toNNReal t) hr |
| (by simpa only [zero_add,Real.coe_toNNReal _ hmem.1.le,c] using ht) |
| simpa only [zero_add,←finiteTimeCoefficient_scheduleValue _ (0:ℝ), |
| Real.coe_toNNReal _ hmem.1.le] using hh |
|
|
| end ParisiFinite |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| namespace ParisiFinite |
| open ParisiPath |
|
|
| namespace ThirdJet |
| variable {f : SmoothField} |
|
|
| lemma continuous_transformD3_joint (j : ThirdJet f) (a : ℝ) : |
| Continuous (fun p : ℝ×ℝ => j.transformD3 a p.1 p.2) := by |
| have hb : ∀ y,|j.expThird a y|≤ |
| (j.bound3+3*Real.nnabs a*(f.bound1*f.bound2)+(Real.nnabs a)^2*f.bound1^3:ℝ≥0) := by |
| intro y |
| simpa only [NNReal.coe_add,NNReal.coe_mul,NNReal.coe_ofNat,Real.coe_nnabs, |
| NNReal.coe_pow,sq_abs] using j.expThird_bound a y |
| exact ((continuous_tiltedMean_joint f.lipschitz (j.continuous_expThird a) hb a).sub |
| (((continuous_transform_d1 f a).mul (continuous_transform_d2 f a)).const_mul (3*a))).sub |
| (((continuous_transform_d1 f a).pow 3).const_mul (a^2)) |
|
|
| def slabD3 (j : ThirdJet f) (a b t x : ℝ) : ℝ := |
| j.transformD3 a (Real.sqrt (b-t)) x |
|
|
| lemma continuous_slabD3 (j : ThirdJet f) (a b : ℝ) : |
| Continuous (uncurry (j.slabD3 a b)) := |
| (j.continuous_transformD3_joint a).comp |
| (((continuous_const.sub continuous_fst).sqrt).prodMk continuous_snd) |
|
|
| lemma slabD3_bound (j : ThirdJet f) (a b t x : ℝ) : |
| |j.slabD3 a b t x|≤(j.transform a 0).bound3 := |
| (j.transform a (Real.sqrt (b-t))).normD3 x |
|
|
| def gradientDt (j : ThirdJet f) (a b t x : ℝ) : ℝ := |
| if t<b then -(1/2:ℝ)*(j.slabD3 a b t x+ |
| 2*a*(fieldOnInterval f a b t).d1 x*(fieldOnInterval f a b t).d2 x) else 0 |
|
|
| def gradientTimeBound (j : ThirdJet f) (a : ℝ) : ℝ≥0 := |
| ((j.transform a 0).bound3+2*Real.nnabs a*f.bound1*(f.transform a 0).bound2)/2 |
|
|
| lemma gradientDt_bound (j : ThirdJet f) (a b t x : ℝ) : |
| ‖j.gradientDt a b t x‖≤j.gradientTimeBound a := by |
| unfold gradientDt |
| split_ifs |
| · simp only [norm_mul,Real.norm_eq_abs,abs_neg,abs_of_nonneg (by norm_num : (0:ℝ)≤1/2)] |
| have hp : |2*a*(fieldOnInterval f a b t).d1 x*(fieldOnInterval f a b t).d2 x|≤ |
| 2*|a| *(f.bound1:ℝ)*(f.transform a 0).bound2 := by |
| rw [abs_mul,abs_mul,abs_mul,abs_of_nonneg (by norm_num : (0:ℝ)≤2)] |
| gcongr <;> first | exact (fieldOnInterval f a b t).normD1 x | exact (fieldOnInterval f a b t).normD2 x |
| have hh := (abs_add_le _ _).trans (add_le_add (j.slabD3_bound a b t x) hp) |
| simp only [gradientTimeBound,NNReal.coe_div,NNReal.coe_add,NNReal.coe_mul, |
| NNReal.coe_ofNat,Real.coe_nnabs] |
| linarith |
| · simp |
|
|
| lemma measurable_gradientDt (j : ThirdJet f) (a b : ℝ) : |
| Measurable (uncurry (j.gradientDt a b)) := |
| Measurable.ite (measurableSet_lt measurable_fst measurable_const) |
| (((j.continuous_slabD3 a b).add |
| (((continuous_fieldOnInterval_d1 f a b).const_mul (2*a)).mul |
| (continuous_fieldOnInterval_d2 f a b))).const_mul (-(1/2:ℝ))).measurable |
| measurable_const |
|
|
| lemma continuous_gradientDt (j : ThirdJet f) (a b t : ℝ) : |
| Continuous (j.gradientDt a b t) := by |
| unfold gradientDt |
| split_ifs |
| · exact (((j.continuous_slabD3 a b).comp (continuous_const.prodMk continuous_id)).add |
| (((fieldOnInterval f a b t).continuousD1.const_mul (2*a)).mul |
| (fieldOnInterval f a b t).continuousD2)).const_mul _ |
| · exact continuous_const |
|
|
| lemma hasDerivAt_fieldOnInterval_dt (j : ThirdJet f) (a b t x : ℝ) : |
| HasDerivAt (fieldOnInterval_dt f a b t) (j.gradientDt a b t x) x := by |
| unfold fieldOnInterval_dt gradientDt |
| split_ifs |
| · convert (((j.transform a (Real.sqrt (b-t))).hasD3 x).add |
| (((fieldOnInterval f a b t).hasD2 x).pow 2 |>.const_mul a)).const_mul (-(1/2:ℝ)) using 1 <;> |
| first | rfl | (dsimp only [slabD3,transform]; ring) |
| · exact hasDerivAt_const x 0 |
|
|
| lemma gradient_integral_time (j : ThirdJet f) (a b u v x : ℝ) : |
| ∫ t in u..v,j.gradientDt a b t x= |
| (fieldOnInterval f a b v).d1 x-(fieldOnInterval f a b u).d1 x := by |
| have hd := intervalIntegral.hasDerivAt_integral_of_dominated_loc_of_deriv_le |
| (F := fun x t => fieldOnInterval_dt f a b t x) |
| (F' := fun x t => j.gradientDt a b t x) (x₀ := x) |
| (s := Set.univ) (bound := fun _ => (j.gradientTimeBound a:ℝ)) |
| (μ := volume) (a := u) (b := v) (Filter.univ_mem) |
| (Eventually.of_forall fun x => ((measurable_fieldOnInterval_dt f a b).comp |
| (measurable_id.prodMk measurable_const)).aestronglyMeasurable) |
| (integrable_fieldOnInterval_dt f a b u v x) |
| (((j.measurable_gradientDt a b).comp (measurable_id.prodMk measurable_const)).aestronglyMeasurable) |
| (ae_of_all _ fun t _ x _ => j.gradientDt_bound a b t x) |
| intervalIntegrable_const |
| (ae_of_all _ fun t _ x _ => j.hasDerivAt_fieldOnInterval_dt a b t x) |
| have he : (fun x => ∫ t in u..v,fieldOnInterval_dt f a b t x)= |
| (fun x => (fieldOnInterval f a b v).val x-(fieldOnInterval f a b u).val x) := |
| funext fun x => fieldOnInterval_integral_time f a b u v x |
| rw [he] at hd |
| exact hd.2.unique (((fieldOnInterval f a b v).hasD1 x).sub |
| ((fieldOnInterval f a b u).hasD1 x)) |
| |
| def slabGradientTest (j : ThirdJet f) (a b : ℝ) : TimeQuadraticTest where |
| val := fun t x => (fieldOnInterval f a b t).d1 x |
| d1 := fun t x => (fieldOnInterval f a b t).d2 x |
| d2 := j.slabD3 a b |
| dt := j.gradientDt a b |
| hasD1 := fun t => (fieldOnInterval f a b t).hasD2 |
| hasD2 := fun t => (j.transform a (Real.sqrt (b-t))).hasD3 |
| continuousD2 := fun t => (j.transform a (Real.sqrt (b-t))).continuousD3 |
| c1 := (f.transform a 0).bound2 |
| c2 := (j.transform a 0).bound3 |
| ct := j.gradientTimeBound a |
| bound1 := fun t x => by simpa only [Real.norm_eq_abs,fieldOnInterval,SmoothField.transform] using (fieldOnInterval f a b t).normD2 x |
| bound2 := fun t x => by simpa only [Real.norm_eq_abs] using j.slabD3_bound a b t x |
| boundT := j.gradientDt_bound a b |
| measT := j.measurable_gradientDt a b |
| continuousT := j.continuous_gradientDt a b |
| jointD1 := ae_of_all _ fun _ _ _ => (continuous_fieldOnInterval_d2 f a b).continuousAt |
| jointD2 := ae_of_all _ fun _ _ _ => (j.continuous_slabD3 a b).continuousAt |
| integralT := fun u _ v _ x => (j.gradient_integral_time a b u v x).symm |
| |
| end ThirdJet |
| end ParisiFinite |
| |
| |
| |
| |
| |
| |
| |
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| namespace ParisiFinite |
| open ParisiPath |
| |
| namespace ThirdJet |
| variable {f : SmoothField} |
| |
| lemma intervalIntegrable_gradientDt (j : ThirdJet f) (a b u v x : ℝ) : |
| IntervalIntegrable (fun t => j.gradientDt a b t x) volume u v := by |
| apply (intervalIntegrable_const (c := (j.gradientTimeBound a:ℝ))).mono_fun' |
| (((j.measurable_gradientDt a b).comp (show Measurable (fun u : ℝ => (u,x)) by fun_prop)).aestronglyMeasurable) |
| exact ae_of_all _ fun t => j.gradientDt_bound a b t x |
|
|
| lemma gradientDt_rightContinuous (j : ThirdJet f) (a b t x : ℝ) : |
| ContinuousWithinAt (fun u => j.gradientDt a b u x) (Ici t) t := by |
| by_cases ht : t<b |
| · apply ContinuousAt.continuousWithinAt |
| have hc := (((j.continuous_slabD3 a b).add |
| (((continuous_fieldOnInterval_d1 f a b).const_mul (2*a)).mul |
| (continuous_fieldOnInterval_d2 f a b))).const_mul (-(1/2:ℝ))).comp |
| (show Continuous (fun u : ℝ => (u,x)) by fun_prop) |
| apply hc.continuousAt.congr_of_eventuallyEq |
| filter_upwards [Iio_mem_nhds ht] with u hu |
| exact ite_eq_left hu |
| · have he : (fun u => j.gradientDt a b u x) =ᶠ[𝓝[Ici t] t] (fun _ => (0:ℝ)) := by |
| filter_upwards [self_mem_nhdsWithin] with u hu |
| exact ite_eq_right (not_lt.mpr ((le_of_not_gt ht).trans hu)) |
| exact continuousWithinAt_const.congr_of_eventuallyEq he (he.self_of_nhdsWithin (by simp)) |
|
|
| lemma hasDerivWithinAt_gradient_time (j : ThirdJet f) (a b t x : ℝ) : |
| HasDerivWithinAt (fun u => (fieldOnInterval f a b u).d1 x) |
| (j.gradientDt a b t x) (Ici t) t := by |
| have hm := ((j.measurable_gradientDt a b).comp |
| (show Measurable (fun u : ℝ => (u,x)) by fun_prop)).stronglyMeasurable.stronglyMeasurableAtFilter |
| (l := 𝓝[Ioi t] t) (μ := volume) |
| have hd := intervalIntegral.integral_hasDerivWithinAt_right |
| (s := Ici t) (t := Ioi t) (j.intervalIntegrable_gradientDt a b 0 t x) hm |
| ((j.gradientDt_rightContinuous a b t x).mono Ioi_subset_Ici_self) |
| have he : (fun v => ∫ u in (0:ℝ)..v,j.gradientDt a b u x)= |
| (fun v => (fieldOnInterval f a b v).d1 x-(fieldOnInterval f a b 0).d1 x) := |
| funext fun v => j.gradient_integral_time a b 0 v x |
| rw [he] at hd |
| simpa only [sub_add_cancel] using hd.add_const ((fieldOnInterval f a b 0).d1 x) |
|
|
| lemma gradient_square_integral_time (j : ThirdJet f) (a b u v x : ℝ) : |
| ∫ t in u..v,2*(fieldOnInterval f a b t).d1 x*j.gradientDt a b t x= |
| ((fieldOnInterval f a b v).d1 x)^2-((fieldOnInterval f a b u).d1 x)^2 := by |
| have hm := ((continuous_fieldOnInterval_d1 f a b).comp |
| (show Continuous (fun u : ℝ => (u,x)) by fun_prop)) |
| apply intervalIntegral.integral_eq_sub_of_hasDeriv_right (hm.pow 2).continuousOn |
| · intro t _ |
| have hd := (j.hasDerivWithinAt_gradient_time a b t x).pow 2 |
| convert hd.mono (Ioi_subset_Ici_self) using 1 <;> first | rfl | norm_num |
| · apply (intervalIntegrable_const (c := 2*(f.bound1:ℝ)*(j.gradientTimeBound a:ℝ))).mono_fun' |
| ((hm.measurable.const_mul 2).mul ((j.measurable_gradientDt a b).comp |
| (show Measurable (fun u : ℝ => (u,x)) by fun_prop))).aestronglyMeasurable |
| exact ae_of_all _ fun t => by |
| change ‖2*(fieldOnInterval f a b t).d1 x*j.gradientDt a b t x‖≤_ |
| rw [norm_mul,norm_mul,Real.norm_eq_abs,abs_of_nonneg (by norm_num : (0:ℝ)≤2)] |
| change 2*‖(fieldOnInterval f a b t).d1 x‖*‖j.gradientDt a b t x‖≤ |
| 2*(f.bound1:ℝ)*(j.gradientTimeBound a:ℝ) |
| exact mul_le_mul (mul_le_mul_of_nonneg_left |
| (by simpa only [Real.norm_eq_abs,fieldOnInterval,SmoothField.transform] using (fieldOnInterval f a b t).normD1 x) zero_le_two) |
| (j.gradientDt_bound a b t x) (norm_nonneg _) (by positivity) |
| |
| def squareGradientField (j : ThirdJet f) : SmoothField where |
| val := fun x => (f.d1 x)^2 |
| d1 := fun x => 2*f.d1 x*f.d2 x |
| d2 := fun x => 2*(f.d2 x)^2+2*f.d1 x*j.d3 x |
| hasD1 := fun x => by |
| convert (f.hasD2 x).pow 2 using 1 |
| first | rfl | norm_num |
| hasD2 := fun x => by |
| convert ((f.hasD2 x).const_mul 2).mul (j.hasD3 x) using 1 |
| first | rfl | ring |
| continuousD2 := ((f.continuousD2.pow 2).const_mul 2).add |
| ((f.continuousD1.const_mul 2).mul j.continuousD3) |
| bound1 := 2*f.bound1*f.bound2 |
| bound2 := 2*f.bound2^2+2*f.bound1*j.bound3 |
| normD1 := fun x => by |
| simp only [abs_mul,abs_of_nonneg (by norm_num : (0:ℝ)≤2),NNReal.coe_mul,NNReal.coe_ofNat] |
| gcongr <;> first | exact f.normD1 x | exact f.normD2 x |
| normD2 := fun x => by |
| apply (abs_add_le _ _).trans |
| simp only [abs_mul,abs_pow,abs_of_nonneg (by norm_num : (0:ℝ)≤2),NNReal.coe_mul, |
| NNReal.coe_add,NNReal.coe_ofNat,NNReal.coe_pow] |
| gcongr <;> first | exact f.normD1 x | exact f.normD2 x | exact j.normD3 x |
| |
| def slabSquareGradientTest (j : ThirdJet f) (a b : ℝ) : TimeQuadraticTest where |
| val := fun t x => ((fieldOnInterval f a b t).d1 x)^2 |
| d1 := fun t x => 2*(fieldOnInterval f a b t).d1 x*(fieldOnInterval f a b t).d2 x |
| d2 := fun t x => 2*((fieldOnInterval f a b t).d2 x)^2+ |
| 2*(fieldOnInterval f a b t).d1 x*j.slabD3 a b t x |
| dt := fun t x => 2*(fieldOnInterval f a b t).d1 x*j.gradientDt a b t x |
| hasD1 := fun t => (j.transform a (Real.sqrt (b-t))).squareGradientField.hasD1 |
| hasD2 := fun t => (j.transform a (Real.sqrt (b-t))).squareGradientField.hasD2 |
| continuousD2 := fun t => (j.transform a (Real.sqrt (b-t))).squareGradientField.continuousD2 |
| c1 := (j.transform a 0).squareGradientField.bound1 |
| c2 := (j.transform a 0).squareGradientField.bound2 |
| ct := 2*f.bound1*j.gradientTimeBound a |
| bound1 := fun t x => by |
| simpa only [Real.norm_eq_abs,fieldOnInterval,squareGradientField,transform,SmoothField.transform] |
| using (j.transform a (Real.sqrt (b-t))).squareGradientField.normD1 x |
| bound2 := fun t x => by |
| simpa only [Real.norm_eq_abs,fieldOnInterval,squareGradientField,transform,SmoothField.transform,slabD3] |
| using (j.transform a (Real.sqrt (b-t))).squareGradientField.normD2 x |
| boundT := fun t x => by |
| rw [norm_mul,norm_mul,Real.norm_eq_abs,abs_of_nonneg (by norm_num : (0:ℝ)≤2)] |
| simp only [NNReal.coe_mul,NNReal.coe_ofNat] |
| gcongr |
| · exact (fieldOnInterval f a b t).normD1 x |
| · exact j.gradientDt_bound a b t x |
| measT := ((continuous_fieldOnInterval_d1 f a b).measurable.const_mul 2).mul |
| (j.measurable_gradientDt a b) |
| continuousT := fun t => ((fieldOnInterval f a b t).continuousD1.const_mul 2).mul |
| (j.continuous_gradientDt a b t) |
| jointD1 := ae_of_all _ fun _ _ _ => |
| (((continuous_fieldOnInterval_d1 f a b).const_mul 2).mul |
| (continuous_fieldOnInterval_d2 f a b)).continuousAt |
| jointD2 := ae_of_all _ fun _ _ _ => |
| ((((continuous_fieldOnInterval_d2 f a b).pow 2).const_mul 2).add |
| (((continuous_fieldOnInterval_d1 f a b).const_mul 2).mul |
| (j.continuous_slabD3 a b))).continuousAt |
| integralT := fun u _ v _ x => (j.gradient_square_integral_time a b u v x).symm |
| |
| end ThirdJet |
| end ParisiFinite |
| |
| |
| |
| |
| |
| |
| |
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| namespace ParisiFinite |
| open ParisiPath |
| |
| lemma SmoothField.d1_eq_of_val_eq {f g : SmoothField} (h : f.val=g.val) (x : ℝ) : |
| f.d1 x=g.d1 x := by |
| exact (h ▸ f.hasD1 x).unique (g.hasD1 x) |
| |
| structure ScheduleGradientSquare (β : ℝ≥0) (hβ : 0<β) (ls : Schedule) (s : ℝ) where |
| test : TimeQuadraticTest |
| val_eq : ∀ t x,test.val t x=((finiteTimeField β hβ ls s t).d1 x)^2 |
| d1_eq : ∀ t x,test.d1 t x=2*(finiteTimeField β hβ ls s t).d1 x* |
| (finiteTimeField β hβ ls s t).d2 x |
| cancel : ∀ t,s≤t → t<s+width ls → ∀ x z, |
| test.dt t x+test.d1 t x*z+test.d2 t x/2= |
| ((finiteTimeField β hβ ls s t).d2 x)^2+ |
| 2*(finiteTimeField β hβ ls s t).d1 x*(finiteTimeField β hβ ls s t).d2 x* |
| (z-finiteTimeCoefficient ls s t*(finiteTimeField β hβ ls s t).d1 x) |
| |
| def scheduleGradientSquare (β : ℝ≥0) (hβ : 0<β) (ls : Schedule) |
| (s : ℝ) (hs : 0 ≤ s) (he : s+width ls≤1) : ScheduleGradientSquare β hβ ls s := by |
| induction ls generalizing s with |
| | nil => |
| refine ⟨(terminalThird β hβ).squareGradientField.staticTimeTest, |
| fun _ _ => rfl,fun _ _ => rfl,?_⟩ |
| intro t ht ht' |
| simp only [width,List.map_nil,List.sum_nil,add_zero] at ht' |
| exact False.elim (not_lt_of_ge ht ht') |
| | cons l ls ih => |
| rcases l with ⟨a,d⟩ |
| let c : ℝ := s+d |
| have hc0 : 0≤c := add_nonneg hs d.coe_nonneg |
| have hend : c+width ls≤1 := by |
| dsimp only [c] |
| rw [width_cons] at he |
| linarith |
| have hc1 : c≤1 := by linarith [schedule_width_nonneg ls] |
| let tail := ih c hc0 hend |
| let slab := (recursionThird β hβ ls).slabSquareGradientTest a c |
| have hval : (fieldOnInterval (smoothRecursion β hβ ls) a c c).val= |
| (finiteTimeField β hβ ls c c).val := by |
| funext x |
| rw [fieldOnInterval_right,finiteTimeField_start,smoothRecursion_val] |
| have hmatch (x : ℝ) : slab.val c x=tail.test.val c x := by |
| change ((fieldOnInterval (smoothRecursion β hβ ls) a c c).d1 x)^2=tail.test.val c x |
| rw [tail.val_eq,SmoothField.d1_eq_of_val_eq hval] |
| refine ⟨slab.glue tail.test c ⟨hc0,hc1⟩ hmatch,?_,?_,?_⟩ |
| · intro t x |
| simp only [TimeQuadraticTest.glue,TimeQuadraticTest.splice,finiteTimeField, |
| ThirdJet.slabSquareGradientTest,slab,c] |
| split_ifs |
| · rfl |
| · exact tail.val_eq t x |
| · intro t x |
| simp only [TimeQuadraticTest.glue,TimeQuadraticTest.splice,finiteTimeField, |
| ThirdJet.slabSquareGradientTest,slab,c] |
| split_ifs |
| · rfl |
| · exact tail.d1_eq t x |
| · intro t ht ht' x z |
| simp only [TimeQuadraticTest.glue,TimeQuadraticTest.splice,finiteTimeField, |
| finiteTimeCoefficient,ThirdJet.slabSquareGradientTest,slab,c] |
| split_ifs with hcut |
| · rw [ThirdJet.gradientDt,ite_eq_left hcut] |
| ring |
| · exact tail.cancel t (le_of_not_gt hcut) (by rw [width_cons] at ht';dsimp only [c];linarith) x z |
|
|
| lemma finiteTimeField_d1_start (β : ℝ≥0) (hβ : 0<β) (ls : Schedule) (s x : ℝ) : |
| (finiteTimeField β hβ ls s s).d1 x=(smoothRecursion β hβ ls).d1 x := |
| SmoothField.d1_eq_of_val_eq (funext fun x => |
| (finiteTimeField_start β hβ ls s x).trans (congrFun (smoothRecursion_val β hβ ls) x).symm) x |
|
|
| lemma finiteTimeField_d1_after (β : ℝ≥0) (hβ : 0<β) (ls : Schedule) (s t x : ℝ) |
| (ht : s+width ls≤t) : (finiteTimeField β hβ ls s t).d1 x=(terminalField β hβ).d1 x := |
| SmoothField.d1_eq_of_val_eq (funext fun x => finiteTimeField_after β hβ ls s t x ht) x |
|
|
| end ParisiFinite |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| namespace ParisiFinite |
|
|
| lemma scheduleSuffix_ordered {β a : ℝ} {ls : Schedule} |
| (h : ParisiGuerra.OrderedFrom β a ls) (r : ℝ≥0) : |
| ParisiGuerra.OrderedFrom β a (scheduleSuffix ls r) := by |
| induction ls generalizing a r with |
| | nil => exact h |
| | cons l ls ih => |
| simp only [scheduleSuffix] |
| split_ifs |
| · exact h |
| · exact ordered_lower h.1 (ih h.2 _) |
|
|
| lemma SmoothField.d2_eq_of_val_eq {f g : SmoothField} (h : f.val=g.val) (x : ℝ) : |
| f.d2 x=g.d2 x := by |
| have hd : f.d1=g.d1 := funext (SmoothField.d1_eq_of_val_eq h) |
| exact (hd ▸ f.hasD2 x).unique (g.hasD2 x) |
|
|
| lemma finiteTimeField_suffix_d2 (β : ℝ≥0) (hβ : 0<β) (ls : Schedule) |
| (s : ℝ) (r : ℝ≥0) : |
| (finiteTimeField β hβ ls s (s+r)).d2=(smoothRecursion β hβ (scheduleSuffix ls r)).d2 := by |
| apply funext |
| exact SmoothField.d2_eq_of_val_eq (funext fun x => |
| (finiteTimeField_suffix_val β hβ ls s r x).trans (congrFun (smoothRecursion_val β hβ _) x).symm) |
|
|
| lemma finiteTimeField_curvature_lipschitz (β : ℝ≥0) (hβ : 0<β) (ls : Schedule) |
| (h : ParisiGuerra.OrderedFrom β 0 ls) (s : ℝ) (r : ℝ≥0) : |
| LipschitzWith (5*β^2) (finiteTimeField β hβ ls s (s+r)).d2 := by |
| rw [finiteTimeField_suffix_d2] |
| exact recursion_curvature_lipschitz β hβ _ (scheduleSuffix_ordered h r) |
|
|
| lemma global_dyadic_curvature_tendstoUniformly (β : ℝ≥0) (hβ : 0<β) {γ : ℝ≥0 → ℝ≥0} |
| (hγ : Monotone γ) (hb : ∀ t,γ t≤β) (r : ℝ≥0) (hr : r<1) : |
| TendstoUniformly (fun n => (finiteTimeField β hβ (dyadicSchedule γ false 0 1 n) 0 r).d2) |
| (fieldCurvature β γ r) atTop := by |
| have hl (n : ℕ) : LipschitzWith (5*β^2) |
| (finiteTimeField β hβ (dyadicSchedule γ false 0 1 n) 0 r).d2 := by |
| simpa only [zero_add] using finiteTimeField_curvature_lipschitz β hβ _ |
| (ordered_lower (γ 0).coe_nonneg (ordered_upper |
| (show (γ (0+1):ℝ)≤β by exact_mod_cast hb _) (dyadicSchedule_ordered hγ false 0 1 n))) 0 r |
| obtain ⟨g,hu,hd,hg⟩ := exists_uniform_derivative_lipschitz_limit |
| (fun n => (finiteTimeField β hβ (dyadicSchedule γ false 0 1 n) 0 r).hasD2) hl |
| (global_dyadic_gradient_tendstoUniformly β hβ hγ hb r hr) |
| have he : g=fieldCurvature β γ r := funext (fun x => (hd x).deriv.symm) |
| rwa [he] at hu |
|
|
| end ParisiFinite |
|
|
| |
|
|
| |
|
|
| |
|
|
| open MeasureTheory ProbabilityTheory Filter Function Set |
| open scoped Topology NNReal |
| namespace ParisiPath |
| variable {K M : ℝ≥0} {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {W : ℝ≥0 → Ω → ℝ} |
|
|
| lemma generatorC2_bound (f : QuadraticTest) (b : Drift K M) (t x : ℝ) : |
| ‖generatorC2 f b t x‖ ≤ (f.c1:ℝ)*(M:ℝ)+(f.c2:ℝ)/2 := by |
| exact le_of_tendsto (mollify_generator_tendsto b f t x).norm |
| (Eventually.of_forall fun n => generator_bound _ b t x) |
|
|
| lemma generatorC2_integrable (hW : IsBrownianReal W P) (b : Drift K M) |
| (f : QuadraticTest) (t : ℝ) : |
| Integrable (fun ω => generatorC2 f b t (extend (solution b (brownianPath W ω)) t)) P := by |
| let : IsProbabilityMeasure P := (hW.hasLaw_eval 0).isProbabilityMeasure |
| have hX := aemeasurable_solution_eval b (brownianPath W) (brownianPath_aemeasurable_eval hW) |
| (projIcc 0 1 zero_le_one t) |
| apply Integrable.of_bound (C := (f.c1:ℝ)*(M:ℝ)+(f.c2:ℝ)/2) |
| · exact (((f.continuous_d1.mul (b.lipschitz t).continuous).add |
| (continuous_const.mul f.continuousD2)).measurable.comp_aemeasurable hX).aestronglyMeasurable |
| · exact ae_of_all _ fun ω => generatorC2_bound f b t _ |
|
|
| lemma timeDerivativeC2_integrable_inner (hW : IsBrownianReal W P) (b : Drift K M) |
| (f : TimeQuadraticTest) (t : ℝ) : |
| Integrable (fun ω => f.dt t (extend (solution b (brownianPath W ω)) t)) P := by |
| let : IsProbabilityMeasure P := (hW.hasLaw_eval 0).isProbabilityMeasure |
| have hX := aemeasurable_solution_eval b (brownianPath W) (brownianPath_aemeasurable_eval hW) |
| (projIcc 0 1 zero_le_one t) |
| exact Integrable.of_bound ((f.continuousT t).measurable.comp_aemeasurable hX).aestronglyMeasurable |
| (C := f.ct) (ae_of_all _ fun ω => f.boundT t _) |
|
|
| lemma timeGeneratorC2_aestronglyMeasurable (hW : IsBrownianReal W P) |
| (b : Drift K M) (f : TimeQuadraticTest) |
| (hc : ∀ᵐ t ∂volume,t ∈ Icc (0:ℝ) 1 → ∀ x,ContinuousAt (uncurry b.val) (t,x)) : |
| AEStronglyMeasurable (timeGeneratorC2 P W b f) (volume.restrict (Ioc (0:ℝ) 1)) := by |
| exact aestronglyMeasurable_of_tendsto_ae atTop |
| (fun n => timeGenerator_aestronglyMeasurable hW b (f.mollify (shrinkingBump n)) hc) |
| (ae_of_all _ fun t => mollify_timeGenerator_tendsto hW b f t) |
|
|
| lemma timeDerivativeC2_aestronglyMeasurable (hW : IsBrownianReal W P) |
| (b : Drift K M) (f : TimeQuadraticTest) |
| (hc : ∀ᵐ t ∂volume,t ∈ Icc (0:ℝ) 1 → ∀ x,ContinuousAt (uncurry b.val) (t,x)) : |
| AEStronglyMeasurable (timeDerivativeC2 P W b f) (volume.restrict (Ioc (0:ℝ) 1)) := by |
| exact aestronglyMeasurable_of_tendsto_ae atTop |
| (fun n => timeDerivative_aestronglyMeasurable hW b (f.mollify (shrinkingBump n)) hc) |
| (ae_of_all _ fun t => mollify_timeDerivative_tendsto hW b f t) |
|
|
| lemma timeGeneratorC2_intervalIntegrable (hW : IsBrownianReal W P) |
| (b : Drift K M) (f : TimeQuadraticTest) |
| (hc : ∀ᵐ t ∂volume,t ∈ Icc (0:ℝ) 1 → ∀ x,ContinuousAt (uncurry b.val) (t,x)) : |
| IntervalIntegrable (timeGeneratorC2 P W b f) volume 0 1 := by |
| rw [intervalIntegrable_iff_integrableOn_Ioc_of_le zero_le_one] |
| apply Integrable.of_bound (timeGeneratorC2_aestronglyMeasurable hW b f hc) |
| (C := (f.c1:ℝ)*(M:ℝ)+(f.c2:ℝ)/2) |
| exact ae_of_all _ fun t => le_of_tendsto (mollify_timeGenerator_tendsto hW b f t).norm |
| (Eventually.of_forall fun n => expectedGenerator_bound hW b ((f.mollify (shrinkingBump n)).slice t) t) |
|
|
| lemma timeDerivativeC2_intervalIntegrable (hW : IsBrownianReal W P) |
| (b : Drift K M) (f : TimeQuadraticTest) |
| (hc : ∀ᵐ t ∂volume,t ∈ Icc (0:ℝ) 1 → ∀ x,ContinuousAt (uncurry b.val) (t,x)) : |
| IntervalIntegrable (timeDerivativeC2 P W b f) volume 0 1 := by |
| rw [intervalIntegrable_iff_integrableOn_Ioc_of_le zero_le_one] |
| apply Integrable.of_bound (timeDerivativeC2_aestronglyMeasurable hW b f hc) (C := f.ct) |
| exact ae_of_all _ fun t => le_of_tendsto (mollify_timeDerivative_tendsto hW b f t).norm |
| (Eventually.of_forall fun n => timeDerivative_bound hW b (f.mollify (shrinkingBump n)) t) |
|
|
| end ParisiPath |
| namespace ParisiFinite |
| open ParisiPath |
| variable {K M : ℝ≥0} {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} {W : ℝ≥0 → Ω → ℝ} |
|
|
| |
|
|
| theorem finite_schedule_verification (hW : IsBrownianReal W P) |
| (b : Drift K M) |
| (hc : ∀ᵐ t ∂volume,t ∈ Icc (0:ℝ) 1 → ∀ x,ContinuousAt (uncurry b.val) (t,x)) |
| (β : ℝ≥0) (hβ : 0 < β) (ls : Schedule) (hw : width ls = 1) : |
| (∫ ω,terminal β (solution b (brownianPath W ω) ⟨1,by simp⟩) ∂P)-recursion β ls 0 = |
| ∫ t in (0:ℝ)..1,∫ ω, |
| (finiteTimeField β hβ ls 0 t).d1 (extend (solution b (brownianPath W ω)) t) * |
| b.val t (extend (solution b (brownianPath W ω)) t) - |
| (finiteTimeCoefficient ls 0 t)/2 * |
| ((finiteTimeField β hβ ls 0 t).d1 (extend (solution b (brownianPath W ω)) t))^2 ∂P := by |
| let r := scheduleTimeRealization β hβ ls 0 le_rfl (by rw [hw]; norm_num) |
| have hh := brownian_solution_time_generator_identity_C2 hW b r.test hc |
| have hj := timeGeneratorC2_intervalIntegrable hW b r.test hc |
| have ht := timeDerivativeC2_intervalIntegrable hW b r.test hc |
| have h1 (x : ℝ) : r.test.val 1 x = terminal β x := by |
| rw [r.val_eq,finiteTimeField_after β hβ ls 0 1 x (by rw [hw]; norm_num)] |
| have h0 : r.test.val 0 0 = recursion β ls 0 := by rw [r.val_eq,finiteTimeField_start] |
| simp_rw [h1,h0] at hh |
| rw [hh,←intervalIntegral.integral_add hj ht] |
| apply intervalIntegral.integral_congr_Ioo_of_le zero_le_one |
| intro t ht |
| change (∫ ω,generatorC2 (r.test.slice t) b t (extend (solution b (brownianPath W ω)) t) ∂P)+ |
| (∫ ω,r.test.dt t (extend (solution b (brownianPath W ω)) t) ∂P)=_ |
| rw [←integral_add (generatorC2_integrable hW b _ t) (timeDerivativeC2_integrable_inner hW b r.test t)] |
| apply integral_congr_ae |
| filter_upwards [] with ω |
| simp only [generatorC2,TimeQuadraticTest.slice,r.d1_eq,r.d2_eq,r.dt_eq] |
| rw [finiteTimeField_PDE β hβ ls 0 t _ ht.1.le (by simpa only [hw,zero_add] using ht.2)] |
| ring |
|
|
| end ParisiFinite |
|
|
| end |
|
|
| end OAI |
|
|
