| import OAI.Probability.DirectionalWalk.Widths |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Filter Preorder |
| open scoped ENNReal BigOperators Topology |
|
|
| namespace DirectionalZeroOne |
|
|
| open scoped Classical |
|
|
| def euclideanSite {d : ℕ} (x : Site d) : EuclideanSpace ℝ (Fin d) := |
| WithLp.toLp 2 (fun i => (x i : ℝ)) |
|
|
| lemma euclideanSite_add {d : ℕ} (x y : Site d) : |
| euclideanSite (x+y) = euclideanSite x + euclideanSite y := by |
| ext i |
| simp [euclideanSite] |
|
|
| lemma euclideanSite_zero {d : ℕ} : euclideanSite (0 : Site d) = 0 := by |
| ext i |
| simp [euclideanSite] |
|
|
| lemma euclideanSite_sub {d : ℕ} (x y : Site d) : |
| euclideanSite (x-y) = euclideanSite x - euclideanSite y := by |
| ext i |
| simp [euclideanSite] |
|
|
| noncomputable def slabRadius {d : ℕ} (γ : Word d) : ℝ := |
| (Finset.range (γ.1+1)).sup' ⟨0,Finset.mem_range.mpr (Nat.succ_pos _)⟩ |
| (fun j => ‖euclideanSite (wordPath γ j - wordPath γ 0)‖) |
|
|
| lemma norm_wordPath_le_radius {d : ℕ} (γ : Word d) {j : ℕ} (hj : j ≤ γ.1) : |
| ‖euclideanSite (wordPath γ j - wordPath γ 0)‖ ≤ slabRadius γ := |
| Finset.le_sup' (fun k => ‖euclideanSite (wordPath γ k - wordPath γ 0)‖) |
| (Finset.mem_range.mpr (Nat.lt_succ_of_le hj)) |
|
|
| lemma slabRadius_nonneg {d : ℕ} (γ : Word d) : 0 ≤ slabRadius γ := by |
| exact (norm_nonneg _).trans (norm_wordPath_le_radius γ (j := 0) (Nat.zero_le _)) |
|
|
| lemma slabs_identDistrib {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) |
| (hp : 0 < annealed μ 0 (nonBacktracking v)) (k : ℕ) : |
| IdentDistrib (fun X => slabs v X k) id (conditioned μ v) (slabLaw μ v) := by |
| refine ⟨((measurable_pi_apply k).comp (measurable_slabs v)).aemeasurable, |
| measurable_id.aemeasurable,?_⟩ |
| rw [Measure.map_id] |
| exact slabs_marginal μ hell v hv hp k |
|
|
| lemma slabObservable_strongLaw {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) |
| (hp : 0 < annealed μ 0 (nonBacktracking v)) (f : Word d → ℝ) |
| (hf : Integrable f (slabLaw μ v)) : |
| ∀ᵐ X ∂conditioned μ v, |
| Tendsto (fun n : ℕ => (∑ i ∈ Finset.range n, f (slabs v X i)) / n) |
| atTop (𝓝 (∫ γ, f γ ∂slabLaw μ v)) := by |
| have hind := (slabs_iid μ hell v hv hp).comp (fun _ => f) |
| (fun _ => measurable_of_countable _) |
| have hid (k : ℕ) := (slabs_identDistrib μ hell v hv hp k).comp |
| (measurable_of_countable f) |
| have hfi : Integrable (fun X => f (slabs v X 0)) (conditioned μ v) := |
| (hid 0).integrable_iff.mpr hf |
| have heq : (∫ X, f (slabs v X 0) ∂conditioned μ v) = ∫ γ, f γ ∂slabLaw μ v := |
| (hid 0).integral_eq |
| simpa only [Function.comp_apply, id_eq,heq] using strong_law_ae_real |
| (fun k X => f (slabs v X k)) hfi (fun i j hij => hind.indepFun hij) |
| (fun k => (hid k).trans (hid 0).symm) |
|
|
| lemma slabWidth_strongLaw {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) |
| (hvnorm : ∀ i, |v i| ≤ 1) (hp : 0 < annealed μ 0 (nonBacktracking v)) : |
| ∀ᵐ X ∂conditioned μ v, |
| Tendsto (fun n : ℕ => (∑ i ∈ Finset.range n, slabWidth v (slabs v X i)) / n) |
| atTop (𝓝 (∫ γ, slabWidth v γ ∂slabLaw μ v)) := |
| slabObservable_strongLaw μ hell v hv hp _ (integrable_slabWidth μ hell v hv hvnorm hp) |
|
|
| lemma slab_initial_average_bound {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) |
| (hp : 0 < annealed μ 0 (nonBacktracking v)) (f : Word d → ℝ) |
| (hf : Integrable f (slabLaw μ v)) (hf0 : ∀ γ, 0 ≤ f γ) |
| (a : ℝ) (ha : 0 < a) (n : ℕ) : |
| (conditioned μ v).real {X | ∃ k : ℕ, 0 < k ∧ k ≤ n ∧ |
| a * (k : ℝ) < ∑ j ∈ Finset.range k, f (slabs v X j)} ≤ |
| (∫ γ, f γ ∂slabLaw μ v) / a := by |
| let := conditioned_probability μ v hp |
| have hid := (slabs_identDistrib μ hell v hv hp 0).comp (measurable_of_countable f) |
| have hfi : Integrable (fun X => f (firstWord v X)) (conditioned μ v) := |
| hid.integrable_iff.mpr hf |
| have hfe : (∫ X, f (firstWord v X) ∂conditioned μ v) = ∫ γ, f γ ∂slabLaw μ v := |
| hid.integral_eq |
| have hh := stationary_initial_average_bound (conditioned μ v) (cutSuffix v) |
| (cutSuffix_measurePreserving μ hell v hv hp) (fun X => f (firstWord v X)) |
| ((measurable_of_countable f).comp (measurable_firstWord v)) hfi (fun X => hf0 _) a ha n |
| simpa only [initialAverageBad,slabs,hfe] using hh |
|
|
| noncomputable def slabTime {d : ℕ} (v : Fin d → ℝ) (X : Path d) (k : ℕ) : ℕ := |
| ∑ i ∈ Finset.range k, (slabs v X i).1 |
|
|
| lemma slabTime_zero {d : ℕ} (v : Fin d → ℝ) (X : Path d) : slabTime v X 0 = 0 := by |
| simp [slabTime] |
|
|
| lemma slabTime_succ {d : ℕ} (v : Fin d → ℝ) (X : Path d) (k : ℕ) : |
| slabTime v X (k+1) = slabTime v X k + (slabs v X k).1 := by |
| exact Finset.sum_range_succ _ _ |
|
|
| lemma iterated_cutSuffix {d : ℕ} (v : Fin d → ℝ) (X : Path d) (h0 : X 0 = 0) |
| (k n : ℕ) : (cutSuffix v)^[k] X n = X (slabTime v X k + n) - X (slabTime v X k) := by |
| induction k generalizing n with |
| | zero => simp [slabTime_zero,h0] |
| | succ k ih => |
| rw [Function.iterate_succ_apply'] |
| change ((cutSuffix v)^[k] X) (firstCutTime v ((cutSuffix v)^[k] X) + n) + |
| -((cutSuffix v)^[k] X (firstCutTime v ((cutSuffix v)^[k] X))) = _ |
| rw [ih,ih,slabTime_succ] |
| change X (slabTime v X k + ((slabs v X k).1+n)) - X (slabTime v X k) + |
| -(X (slabTime v X k + (slabs v X k).1) - X (slabTime v X k)) = _ |
| rw [← Nat.add_assoc] |
| abel |
|
|
| lemma slab_word_path {d : ℕ} (v : Fin d → ℝ) (X : Path d) (k : ℕ) |
| {j : ℕ} (hj : j ≤ (slabs v X k).1) : |
| wordPath (slabs v X k) j = (cutSuffix v)^[k] X j := |
| wordPath_prefixWord _ _ hj |
|
|
| def GoodSlabPath {d : ℕ} (v : Fin d → ℝ) (X : Path d) : Prop := |
| X 0 = 0 ∧ ∀ k, RegenerationWord v (slabs v X k) |
|
|
| lemma ae_goodSlabPath {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) |
| (hp : 0 < annealed μ 0 (nonBacktracking v)) : |
| ∀ᵐ X ∂conditioned μ v, GoodSlabPath v X := by |
| have h0 := (cond_absolutelyContinuous (s := nonBacktracking v) (μ := annealed μ 0)).ae_le |
| (ae_start_and_nearestNeighbour μ 0) |
| have hs : ∀ᵐ X ∂conditioned μ v, ∀ k, RegenerationWord v (slabs v X k) := by |
| rw [ae_all_iff] |
| intro k |
| exact ((cutSuffix_measurePreserving μ hell v hv hp).iterate k).quasiMeasurePreserving.ae |
| (ae_conditioned_firstWord μ hell v hv hp) |
| filter_upwards [h0,hs] with X hX hW |
| exact ⟨hX.1,hW⟩ |
|
|
| lemma slabTime_strictMono {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X) : |
| StrictMono (slabTime v X) := by |
| apply strictMono_nat_of_lt_succ |
| intro k |
| rw [slabTime_succ] |
| exact Nat.lt_add_of_pos_right (hX.2 k).1 |
|
|
| lemma slab_location {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X) |
| (n : ℕ) : ∃ k, slabTime v X k ≤ n ∧ n < slabTime v X (k+1) := by |
| have hex : ∃ k, n < slabTime v X (k+1) := |
| ⟨n,(Nat.lt_succ_self n).trans_le ((slabTime_strictMono v X hX).id_le (n+1))⟩ |
| refine ⟨Nat.find hex,?_,Nat.find_spec hex⟩ |
| by_cases hz : Nat.find hex = 0 |
| · rw [hz,slabTime_zero] |
| exact Nat.zero_le _ |
| · obtain ⟨j,hj⟩ := Nat.exists_eq_succ_of_ne_zero hz |
| have hh := Nat.find_min hex (show j < Nat.find hex by omega) |
| rw [hj] |
| exact not_lt.mp hh |
|
|
| noncomputable def slabHeightSum {d : ℕ} (v : Fin d → ℝ) (X : Path d) (k : ℕ) : ℝ := |
| ∑ i ∈ Finset.range k, slabWidth v (slabs v X i) |
|
|
| noncomputable def slabRadiusSum {d : ℕ} (v : Fin d → ℝ) (X : Path d) (k : ℕ) : ℝ := |
| ∑ i ∈ Finset.range k, slabRadius (slabs v X i) |
|
|
| lemma height_at_slabTime {d : ℕ} (v : Fin d → ℝ) (X : Path d) (h0 : X 0 = 0) |
| (k : ℕ) : height v (X (slabTime v X k)) = slabHeightSum v X k := by |
| induction k with |
| | zero => simp [slabTime_zero,slabHeightSum,h0,height_zero] |
| | succ k ih => |
| have hh := iterated_cutSuffix v X h0 k (slabs v X k).1 |
| rw [← slab_word_path v X k le_rfl,← slabTime_succ] at hh |
| have hh' := congrArg (height v) hh |
| rw [height_sub,ih] at hh' |
| change slabWidth v (slabs v X k) = height v (X (slabTime v X (k+1))) - _ at hh' |
| rw [slabHeightSum,Finset.sum_range_succ] |
| change height v (X (slabTime v X (k+1))) = slabHeightSum v X k + _ |
| linarith |
|
|
| lemma norm_at_slabTime_le {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X) |
| (k : ℕ) : ‖euclideanSite (X (slabTime v X k))‖ ≤ slabRadiusSum v X k := by |
| induction k with |
| | zero => simp [slabTime_zero,slabRadiusSum,hX.1,euclideanSite_zero] |
| | succ k ih => |
| have hh := iterated_cutSuffix v X hX.1 k (slabs v X k).1 |
| rw [← slab_word_path v X k le_rfl,← slabTime_succ] at hh |
| have heq : X (slabTime v X (k+1)) = X (slabTime v X k) + wordPath (slabs v X k) (slabs v X k).1 := by |
| rw [hh] |
| abel |
| rw [heq,euclideanSite_add] |
| have hb := norm_wordPath_le_radius (slabs v X k) (j := (slabs v X k).1) le_rfl |
| rw [(hX.2 k).2.1,sub_zero] at hb |
| rw [slabRadiusSum,Finset.sum_range_succ] |
| exact (norm_add_le _ _).trans (add_le_add ih hb) |
|
|
| lemma norm_in_slab_le {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X) |
| (k j : ℕ) (hj : j ≤ (slabs v X k).1) : |
| ‖euclideanSite (X (slabTime v X k + j))‖ ≤ slabRadiusSum v X (k+1) := by |
| have hh := iterated_cutSuffix v X hX.1 k j |
| rw [← slab_word_path v X k hj] at hh |
| have heq : X (slabTime v X k+j) = X (slabTime v X k) + wordPath (slabs v X k) j := by |
| rw [hh] |
| abel |
| rw [heq,euclideanSite_add] |
| have hb := norm_wordPath_le_radius (slabs v X k) hj |
| rw [(hX.2 k).2.1,sub_zero] at hb |
| rw [slabRadiusSum,Finset.sum_range_succ] |
| exact (norm_add_le _ _).trans (add_le_add (norm_at_slabTime_le v X hX k) hb) |
|
|
| lemma height_in_slab {d : ℕ} (v : Fin d → ℝ) (X : Path d) (hX : GoodSlabPath v X) |
| (k j : ℕ) (hj : j < (slabs v X k).1) : |
| slabHeightSum v X k ≤ height v (X (slabTime v X k+j)) ∧ |
| height v (X (slabTime v X k+j)) < slabHeightSum v X (k+1) := by |
| have hh := congrArg (height v) (iterated_cutSuffix v X hX.1 k j) |
| rw [← slab_word_path v X k hj.le,height_sub,height_at_slabTime v X hX.1] at hh |
| have hb := (hX.2 k).2.2.2.1 j hj |
| have heq : slabHeightSum v X (k+1) = slabHeightSum v X k + slabWidth v (slabs v X k) := |
| Finset.sum_range_succ _ _ |
| rw [heq] |
| change 0 ≤ height v (wordPath (slabs v X k) j) ∧ |
| height v (wordPath (slabs v X k) j) < slabWidth v (slabs v X k) at hb |
| constructor <;> linarith [hb.1,hb.2] |
|
|
| noncomputable def truncatedMoment {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) (f : Ω → ℝ) (t : ℝ) : ℝ := ∫ x, min (f x) t ∂P |
|
|
| lemma integrable_min_const {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) (t : ℝ) (ht : 0 ≤ t) : Integrable (fun x => min (f x) t) P := by |
| apply (integrable_const t).mono' (hfm.min measurable_const).aestronglyMeasurable |
| exact Eventually.of_forall (fun x => by |
| rw [Real.norm_eq_abs, abs_of_nonneg (le_min (hf x) ht)] |
| exact min_le_right _ _) |
|
|
| lemma truncatedMoment_nonneg {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) (f : Ω → ℝ) (hf : ∀ x, 0 ≤ f x) {t : ℝ} (ht : 0 ≤ t) : |
| 0 ≤ truncatedMoment P f t := integral_nonneg (fun x => le_min (hf x) ht) |
|
|
| lemma truncatedMoment_mono {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) {s t : ℝ} (hs : 0 ≤ s) (hst : s ≤ t) : |
| truncatedMoment P f s ≤ truncatedMoment P f t := |
| integral_mono (integrable_min_const P f hfm hf s hs) |
| (integrable_min_const P f hfm hf t (hs.trans hst)) (fun _ => min_le_min_left _ hst) |
|
|
| lemma min_mul_le_mul_min {r t C : ℝ} (hr : 0 ≤ r) (hC : 1 ≤ C) : |
| min r (C*t) ≤ C * min r t := by |
| by_cases hrt : r ≤ t |
| · rw [min_eq_left hrt] |
| exact (min_le_left _ _).trans (by nlinarith) |
| · rw [min_eq_right (le_of_not_ge hrt)] |
| exact min_le_right _ _ |
|
|
| lemma truncatedMoment_mul_le {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) {t C : ℝ} (ht : 0 ≤ t) (hC : 1 ≤ C) : |
| truncatedMoment P f (C*t) ≤ C * truncatedMoment P f t := by |
| unfold truncatedMoment |
| rw [← integral_const_mul] |
| exact integral_mono (integrable_min_const P f hfm hf _ (mul_nonneg (by linarith) ht)) |
| ((integrable_min_const P f hfm hf t ht).const_mul C) |
| (fun x => min_mul_le_mul_min (hf x) hC) |
|
|
| lemma truncatedMoment_sublinear {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) : |
| Tendsto (fun t : ℝ => truncatedMoment P f t / t) atTop (𝓝 0) := by |
| have hlim := tendsto_integral_filter_of_dominated_convergence (μ := P) |
| (F := fun t : ℝ => fun x => min (f x) t / t) (f := fun _ => (0 : ℝ)) |
| (fun _ => (1 : ℝ)) |
| (Eventually.of_forall (fun t => ((hfm.min measurable_const).div_const t).aestronglyMeasurable)) |
| (show ∀ᶠ t : ℝ in atTop, ∀ᵐ x ∂P, ‖min (f x) t / t‖ ≤ (1 : ℝ) from by |
| filter_upwards [eventually_gt_atTop (0 : ℝ)] with t ht |
| exact Eventually.of_forall (fun x => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (div_nonneg (le_min (hf x) ht.le) ht.le)] |
| exact (div_le_one ht).mpr (min_le_right _ _))) |
| (integrable_const (1 : ℝ)) |
| (Eventually.of_forall (fun x => by |
| apply Tendsto.congr' (f₁ := fun t : ℝ => f x / t) ?_ |
| (tendsto_const_nhds.div_atTop tendsto_id) |
| filter_upwards [eventually_ge_atTop (f x)] with t ht |
| rw [min_eq_left ht])) |
| simpa only [integral_div,integral_zero,truncatedMoment] using hlim |
|
|
| lemma integrable_of_truncatedMoment_bounded {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) (B : ℝ) |
| (hb : ∀ n : ℕ, truncatedMoment P f n ≤ B) : Integrable f P := by |
| have hlim : Tendsto (fun n : ℕ => ∫⁻ x, ENNReal.ofReal (min (f x) (n : ℝ)) ∂P) |
| atTop (𝓝 (∫⁻ x, ENNReal.ofReal (f x) ∂P)) := by |
| apply lintegral_tendsto_of_tendsto_of_monotone |
| · intro n |
| exact (hfm.min measurable_const).ennreal_ofReal.aemeasurable |
| · exact Eventually.of_forall (fun x n m hnm => |
| ENNReal.ofReal_le_ofReal (min_le_min_left _ (Nat.cast_le.mpr hnm))) |
| · exact Eventually.of_forall (fun x => by |
| apply tendsto_const_nhds.congr' |
| filter_upwards [(tendsto_natCast_atTop_atTop : Tendsto (fun n : ℕ => (n : ℝ)) atTop atTop) |
| (eventually_ge_atTop (f x))] with n hn |
| rw [min_eq_left hn]) |
| have hbound : (∫⁻ x, ENNReal.ofReal (f x) ∂P) ≤ ENNReal.ofReal B := by |
| apply le_of_tendsto hlim |
| exact Eventually.of_forall (fun n => by |
| rw [← ofReal_integral_eq_lintegral_ofReal |
| (integrable_min_const P f hfm hf (n : ℝ) (Nat.cast_nonneg _)) |
| (Eventually.of_forall (fun x => le_min (hf x) (Nat.cast_nonneg _)))] |
| exact ENNReal.ofReal_le_ofReal (hb n)) |
| refine ⟨hfm.aestronglyMeasurable, ?_⟩ |
| exact (hasFiniteIntegral_iff_ofReal (Eventually.of_forall hf)).mpr |
| (hbound.trans_lt ENNReal.ofReal_lt_top) |
|
|
| lemma exists_truncatedMoment_gt {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) (hnot : ¬Integrable f P) (B : ℝ) : |
| ∃ n : ℕ, B < truncatedMoment P f n := by |
| by_contra h |
| push Not at h |
| exact hnot (integrable_of_truncatedMoment_bounded P f hfm hf B h) |
|
|
| lemma truncatedMoment_scaled_sublinear {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) {C : ℝ} (hC : 0 < C) : |
| Tendsto (fun a : ℝ => truncatedMoment P f (C*a) / a) atTop (𝓝 0) := by |
| have ht : Tendsto (fun a : ℝ => C*a) atTop atTop := tendsto_id.const_mul_atTop hC |
| have hh := ((truncatedMoment_sublinear P f hfm hf).comp ht).const_mul C |
| simp only [mul_zero] at hh |
| apply hh.congr' |
| filter_upwards [eventually_gt_atTop (0 : ℝ)] with a ha |
| dsimp |
| field_simp |
|
|
| lemma exists_truncation_multiple {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) (hnot : ¬Integrable f P) {a b : ℝ} (ha : 0 < a) : |
| ∃ n : ℕ, 0 < n ∧ b ≤ truncatedMoment P f (a*n) := by |
| obtain ⟨j,hj⟩ := exists_truncatedMoment_gt P f hfm hf hnot b |
| obtain ⟨n,hn⟩ := exists_nat_gt ((j : ℝ)/a) |
| refine ⟨n+1,Nat.succ_pos _,hj.le.trans ?_⟩ |
| apply truncatedMoment_mono P f hfm hf (Nat.cast_nonneg _) |
| have hh : (j : ℝ) < (n : ℝ)*a := (div_lt_iff₀ ha).mp hn |
| push_cast |
| nlinarith |
|
|
| lemma radius_scales {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsFiniteMeasure P] (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) (hnot : ¬Integrable f P) {η : ℝ} (hη : 0 < η) |
| (M : ℕ) {D : ℝ} (hD : 0 < D) : |
| ∀ᶠ a : ℝ in atTop, 0 < a ∧ ∃ N : ℕ, max 2 M ≤ N ∧ |
| η*a ≤ truncatedMoment P f (a*N) ∧ truncatedMoment P f (a*N) < 2*η*a ∧ |
| truncatedMoment P f (D*a) < η*a/4 ∧ |
| ∀ m : ℕ, 0 < m → m < N → truncatedMoment P f (a*m) < η*a := by |
| let K := max 2 M |
| have hK : (0 : ℝ) < K := by dsimp [K]; exact_mod_cast (lt_of_lt_of_le (by decide : 0 < 2) (le_max_left 2 M)) |
| have hs := (truncatedMoment_scaled_sublinear P f hfm hf hK).eventually |
| (gt_mem_nhds hη) |
| have hsmall := (truncatedMoment_scaled_sublinear P f hfm hf hD).eventually |
| (gt_mem_nhds (show (0 : ℝ) < η/4 by positivity)) |
| filter_upwards [eventually_gt_atTop (0 : ℝ),hs,hsmall] with a ha hs hsmall |
| obtain hex := exists_truncation_multiple P f hfm hf hnot (b := η*a) ha |
| let N := Nat.find hex |
| have hN := Nat.find_spec hex |
| have hmin : ∀ m : ℕ, 0 < m → m < N → truncatedMoment P f (a*m) < η*a := by |
| intro m hm hmN |
| have hh := Nat.find_min hex hmN |
| exact lt_of_not_ge (fun h => hh ⟨hm,h⟩) |
| have hKN : K < N := by |
| by_contra hh |
| have hNK : N ≤ K := le_of_not_gt hh |
| have hhN := truncatedMoment_mono P f hfm hf (mul_nonneg ha.le (Nat.cast_nonneg N)) |
| (mul_le_mul_of_nonneg_left (Nat.cast_le.mpr hNK) ha.le) |
| have hhK : truncatedMoment P f (a*K) < η*a := by |
| rw [mul_comm a] |
| exact (div_lt_iff₀ ha).mp hs |
| exact (not_lt_of_ge hN.2) (hhN.trans_lt hhK) |
| have hN2 : 2 ≤ N := (le_max_left 2 M).trans hKN.le |
| have hNm : 0 < N-1 := by omega |
| have hm := hmin (N-1) hNm (by omega) |
| have hstep : truncatedMoment P f (a*N) ≤ 2*truncatedMoment P f (a*((N-1 : ℕ) : ℝ)) := by |
| apply (truncatedMoment_mono P f hfm hf (mul_nonneg ha.le (Nat.cast_nonneg N)) ?_).trans |
| (truncatedMoment_mul_le P f hfm hf (mul_nonneg ha.le (by positivity)) (by norm_num : (1 : ℝ) ≤ 2)) |
| have hNN : (N : ℝ) ≤ 2*((N-1 : ℕ) : ℝ) := by exact_mod_cast (show N ≤ 2*(N-1) by omega) |
| nlinarith |
| refine ⟨ha,N,hKN.le,hN.2,?_,?_,hmin⟩ |
| · nlinarith |
| · exact (div_lt_iff₀ ha).mp hsmall |>.trans_le (by ring_nf; exact le_rfl) |
|
|
| lemma stationary_truncated_average_bound {Ω : Type*} [MeasurableSpace Ω] |
| (P : Measure Ω) [IsProbabilityMeasure P] (T : Ω → Ω) |
| (hT : MeasurePreserving T P P) (f : Ω → ℝ) (hfm : Measurable f) |
| (hf : ∀ x, 0 ≤ f x) (a : ℝ) (ha : 0 < a) (n : ℕ) (hn : 0 < n) : |
| P.real (initialAverageBad T f a n) ≤ 2*truncatedMoment P f (a*n)/a := by |
| classical |
| let A : ℝ := a*n |
| have hA : 0 < A := mul_pos ha (Nat.cast_pos.mpr hn) |
| let g : Ω → ℝ := fun x => min (f x) A |
| have hgm : Measurable g := hfm.min measurable_const |
| have hgi : Integrable g P := integrable_min_const P f hfm hf A hA.le |
| have hg0 : ∀ x, 0 ≤ g x := fun x => le_min (hf x) hA.le |
| have htail : P.real {x | A < f x} ≤ truncatedMoment P f A / A := by |
| have hb := mul_meas_ge_le_integral_of_nonneg (Eventually.of_forall hg0) hgi A |
| have hm : P.real {x | A < f x} ≤ P.real {x | A ≤ g x} := by |
| refine measureReal_mono ?_ (measure_ne_top _ _) |
| intro x hx |
| change A < f x at hx |
| exact le_min hx.le le_rfl |
| apply (le_div_iff₀ hA).mpr |
| calc |
| P.real {x | A < f x} * A ≤ A * P.real {x | A ≤ g x} := by nlinarith |
| _ ≤ _ := hb |
| let B : Set Ω := ⋃ j ∈ Finset.range n, {x | A < f (T^[j] x)} |
| have hB : P.real B ≤ (n : ℝ)*truncatedMoment P f A/A := by |
| apply (measureReal_biUnion_finset_le (Finset.range n) _).trans |
| have heq (j : ℕ) : P.real {x | A < f (T^[j] x)} = P.real {x | A < f x} := by |
| apply congrArg ENNReal.toReal |
| exact (hT.iterate j).measure_preimage (measurableSet_lt measurable_const hfm).nullMeasurableSet |
| simp_rw [heq] |
| simpa [mul_div_assoc] using mul_le_mul_of_nonneg_left htail (Nat.cast_nonneg n) |
| have hsub : initialAverageBad T f a n ⊆ initialAverageBad T g a n ∪ B := by |
| intro x hx |
| by_cases hb : x ∈ B |
| · exact Or.inr hb |
| · left |
| obtain ⟨k,hk,hkn,hkw⟩ := hx |
| refine ⟨k,hk,hkn,?_⟩ |
| have heq : ∑ j ∈ Finset.range k, g (T^[j] x) = ∑ j ∈ Finset.range k, f (T^[j] x) := by |
| apply Finset.sum_congr rfl |
| intro j hj |
| apply min_eq_left |
| by_contra hbad |
| exact hb (Set.mem_iUnion.mpr ⟨j,Set.mem_iUnion.mpr ⟨Finset.mem_range.mpr |
| ((Finset.mem_range.mp hj).trans_le hkn),lt_of_not_ge hbad⟩⟩) |
| rwa [heq] |
| have havg := stationary_initial_average_bound P T hT g hgm hgi hg0 a ha n |
| calc |
| P.real (initialAverageBad T f a n) ≤ |
| P.real (initialAverageBad T g a n) + P.real B := |
| (measureReal_mono hsub).trans (measureReal_union_le _ _) |
| _ ≤ truncatedMoment P f A/a + (n : ℝ)*truncatedMoment P f A/A := add_le_add havg hB |
| _ = 2*truncatedMoment P f (a*n)/a := by dsimp [A]; field_simp; ring |
|
|
| lemma linear_envelope_of_tendsto (s : ℕ → ℝ) {m c C : ℝ} |
| (hm : Tendsto (fun n : ℕ => s n / n) atTop (𝓝 m)) (hc : c < m) (hC : m < C) : |
| ∃ b : ℝ, 0 ≤ b ∧ ∀ k : ℕ, c*k-b ≤ s k ∧ s k ≤ C*k+b := by |
| have hh : ∀ᶠ k : ℕ in atTop, 0 < k ∧ c*k ≤ s k ∧ s k ≤ C*k := by |
| filter_upwards [eventually_gt_atTop (0 : ℕ),hm (Ioo_mem_nhds hc hC)] with k hk hkm |
| have hk' : (0 : ℝ) < k := Nat.cast_pos.mpr hk |
| exact ⟨hk,(le_div_iff₀ hk').mp hkm.1.le,(div_le_iff₀ hk').mp hkm.2.le⟩ |
| obtain ⟨K,hK⟩ := eventually_atTop.mp hh |
| let b : ℝ := ∑ k ∈ Finset.range K, (|c*k-s k|+|s k-C*k|) |
| have hb : 0 ≤ b := Finset.sum_nonneg (fun _ _ => add_nonneg (abs_nonneg _) (abs_nonneg _)) |
| refine ⟨b,hb,?_⟩ |
| intro k |
| by_cases hk : K ≤ k |
| · obtain ⟨_,hl,hu⟩ := hK k hk |
| constructor <;> linarith |
| · have hkb : |c*k-s k|+|s k-C*k| ≤ b := by |
| dsimp [b] |
| exact Finset.single_le_sum (fun j _ => add_nonneg (abs_nonneg (c*j-s j)) |
| (abs_nonneg (s j-C*j))) (Finset.mem_range.mpr (Nat.lt_of_not_ge hk)) |
| constructor <;> linarith [le_abs_self (c*k-s k),le_abs_self (s k-C*k), |
| abs_nonneg (c*k-s k),abs_nonneg (s k-C*k)] |
|
|
| end DirectionalZeroOne |
|
|
| end OAI |
|
|
