| import Mathlib |
| import OAI.Probability.Ballisticity.Estimates.RecordIndexTime |
|
|
| namespace OAI |
|
|
| section |
| section |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Pointwise Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Pointwise Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical BoundedContinuousFunction |
| namespace DirectionalTransience |
|
|
| noncomputable def cappedExp (t : ℝ) (N : ℕ) : ℝ →ᵇ ℝ := |
| BoundedContinuousFunction.ofNormedAddCommGroup (fun x => min (N : ℝ) (Real.exp (t*x))) |
| (by fun_prop) N (fun x => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (le_min (Nat.cast_nonneg _) (Real.exp_pos _).le)] |
| exact min_le_left _ _) |
|
|
| lemma cappedExp_nonneg (t : ℝ) (N : ℕ) (x : ℝ) : 0 ≤ cappedExp t N x := |
| le_min (Nat.cast_nonneg _) (Real.exp_pos _).le |
|
|
| lemma integral_cappedExp_tendsto (m : ℝ) (v : ℝ≥0) (t : ℝ) : |
| Tendsto (fun N => ∫ x, cappedExp t N x ∂gaussianReal m v) atTop |
| (𝓝 (Real.exp (m*t+v*t^2/2))) := by |
| have hh := tendsto_integral_of_dominated_convergence (μ := gaussianReal m v) |
| (F := fun N : ℕ => fun x => cappedExp t N x) (f := fun x => Real.exp (t*x)) |
| (fun x => Real.exp (t*x)) (fun N => (cappedExp t N).continuous.measurable.aestronglyMeasurable) |
| (integrable_exp_mul_gaussianReal t) (fun N => ae_of_all _ (fun x => by |
| rw [Real.norm_eq_abs,abs_of_nonneg (cappedExp_nonneg _ _ _)] |
| exact min_le_right _ _)) (ae_of_all _ (fun x => by |
| apply tendsto_const_nhds.congr' |
| filter_upwards [tendsto_natCast_atTop_atTop.eventually (eventually_ge_atTop (Real.exp (t*x)))] with N hN |
| exact (min_eq_right hN).symm)) |
| have he : (∫ x, Real.exp (t*x) ∂gaussianReal m v) = Real.exp (m*t+v*t^2/2) := by |
| simpa only [mgf,id_eq] using (mgf_gaussianReal (p := gaussianReal m v) (X := id) (μ := m) (v := v) (by simp) t) |
| rwa [he] at hh |
|
|
| lemma gaussian_mean_eq_of_test_domination (m₁ m₂ : ℝ) (v : ℝ≥0) {p : ℝ} (hp : 0 < p) |
| (h : ∀ f : ℝ →ᵇ ℝ, (∀ x, 0 ≤ f x) → |
| p*(∫ x, f x ∂gaussianReal m₁ v) ≤ ∫ x, f x ∂gaussianReal m₂ v) : m₁ = m₂ := by |
| have hmgf (t : ℝ) : Real.log p + m₁*t ≤ m₂*t := by |
| have hh := le_of_tendsto_of_tendsto ((integral_cappedExp_tendsto m₁ v t).const_mul p) |
| (integral_cappedExp_tendsto m₂ v t) |
| (Eventually.of_forall (fun N => h (cappedExp t N) (cappedExp_nonneg t N))) |
| rw [← Real.exp_log hp,← Real.exp_add] at hh |
| have := Real.exp_le_exp.mp hh |
| linarith |
| by_contra hne |
| have hh := hmgf ((1-Real.log p)/(m₁-m₂)) |
| have he : (m₁-m₂)*((1-Real.log p)/(m₁-m₂)) = 1-Real.log p := |
| mul_div_cancel₀ _ (sub_ne_zero.mpr hne) |
| nlinarith |
|
|
| lemma weak_test_domination {μ ν : ℕ → ProbabilityMeasure ℝ} {M N : ProbabilityMeasure ℝ} |
| (hμ : Tendsto μ atTop (𝓝 M)) (hν : Tendsto ν atTop (𝓝 N)) {p : ℝ} (hp : 0 ≤ p) |
| (hdom : ∀ i, ENNReal.ofReal p • (μ i : Measure ℝ) ≤ (ν i : Measure ℝ)) |
| (f : ℝ →ᵇ ℝ) (hf : ∀ x, 0 ≤ f x) : |
| p*(∫ x, f x ∂(M : Measure ℝ)) ≤ ∫ x, f x ∂(N : Measure ℝ) := by |
| apply le_of_tendsto_of_tendsto |
| ((ProbabilityMeasure.tendsto_iff_forall_integral_tendsto.mp hμ f).const_mul p) |
| (ProbabilityMeasure.tendsto_iff_forall_integral_tendsto.mp hν f) |
| apply Eventually.of_forall |
| intro i |
| have h := integral_mono_measure (hdom i) (ae_of_all _ hf) (f.integrable (ν i)) |
| simpa only [integral_smul_measure,ENNReal.toReal_ofReal hp,smul_eq_mul] using h |
|
|
| end DirectionalTransience |
|
|
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
| namespace DirectionalTransience |
|
|
| abbrev RecordWord {d : ℕ} (ℓ : Vector d) (k : ℕ) := |
| {w : List (Direction d) |
|
|
| lemma recordWord_prefix {d : ℕ} (ℓ : Vector d) (k : ℕ) (w : RecordWord ℓ k) |
| {X : Path d} (hX : X ∈ wordCylinder 0 w.val) : X ∈ RecordIndexPrefix ℓ k w.val.length := |
| (recordIndexPrefix_prefix ℓ k w.val.length X (wordPath 0 w.val) hX).mpr w.property |
|
|
| lemma recordWord_position {d : ℕ} (ℓ : Vector d) (k : ℕ) (w : RecordWord ℓ k) |
| {X : Path d} (hX : X ∈ wordCylinder 0 w.val) : |
| recordIndexPosition ℓ k X = wordPath 0 w.val w.val.length := by |
| rw [recordIndexPosition,recordIndexTime_eq ℓ k w.val.length X (recordWord_prefix ℓ k w hX)] |
| exact hX _ le_rfl |
|
|
| lemma recordWord_cylinders_disjoint {d : ℕ} (ℓ : Vector d) (k : ℕ) : |
| Pairwise (fun u v : RecordWord ℓ k => Disjoint (wordCylinder 0 u.val) (wordCylinder 0 v.val)) := by |
| intro u v huv |
| apply Set.disjoint_left.mpr |
| intro X hu hv |
| have h1 := recordWord_prefix ℓ k u hu |
| have h2 := recordWord_prefix ℓ k v hv |
| by_cases hlen : u.val.length = v.val.length |
| · exact huv (Subtype.ext (word_eq_of_cylinders 0 u.val v.val X hu hv hlen)) |
| · exact Set.disjoint_left.mp (recordIndexPrefix_disjoint ℓ k hlen) h1 h2 |
|
|
| lemma conditioned_recordWord_cover {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (htrans : DirectionallyTransient ν ℓ) {k : ℕ} (hk : 0 < k) : |
| ∀ᵐ X ∂conditionedLaw ν ℓ, ∃ w : RecordWord ℓ k, X ∈ wordCylinder 0 w.val := by |
| filter_upwards [conditioned_recordIndexPrefix_exists ν ℓ htrans hk, |
| (conditionedLaw_absolutelyContinuous ν ℓ).ae_le (annealed_nearest_neighbor ν), |
| (conditionedLaw_absolutelyContinuous ν ℓ).ae_le (annealed_initial ν)] with X hrec hnn h0 |
| obtain ⟨n,hn⟩ := hrec |
| obtain ⟨w,hw,hcy⟩ := exists_word_prefix X hnn n |
| rw [h0] at hcy |
| have hp : wordPath 0 w ∈ RecordIndexPrefix ℓ k w.length := by |
| apply (recordIndexPrefix_prefix ℓ k w.length X (wordPath 0 w) hcy).mp |
| simpa only [hw] using hn |
| exact ⟨⟨w,hp⟩,hcy⟩ |
|
|
| lemma recordWord_position_add {d : ℕ} (ℓ : Vector d) (k j : ℕ) (w : RecordWord ℓ k) |
| {X : Path d} (hX : X ∈ wordCylinder 0 w.val) |
| (hD : (fun i => X (w.val.length+i)-wordPath 0 w.val w.val.length) ∈ NoDrop ℓ 0) |
| (hR : ∃ m, (fun i => X (w.val.length+i)-wordPath 0 w.val w.val.length) ∈ RecordIndexPrefix ℓ j m) : |
| recordIndexPosition ℓ (k+j) X = wordPath 0 w.val w.val.length + |
| recordIndexPosition ℓ j (fun i => X (w.val.length+i)-wordPath 0 w.val w.val.length) := by |
| let n := w.val.length |
| let Z : Path d := fun i => X (n+i)-X n |
| have he : (fun i => X (w.val.length+i)-wordPath 0 w.val w.val.length) = Z := by |
| funext i |
| rw [show wordPath 0 w.val w.val.length = X n from (hX _ le_rfl).symm] |
| rw [he] at hD hR ⊢ |
| obtain ⟨m,hm⟩ := hR |
| have hpre := recordWord_prefix ℓ k w hX |
| have hDX : X ∈ NoDrop ℓ 0 := recordIndexPrefix_noDrop ℓ k n |
| ⟨hpre,(suffix_noDrop_iff ℓ X n).mp hD⟩ |
| have ha : X ∈ RecordIndexPrefix ℓ (k+j) (n+m) := by |
| refine ⟨Nat.add_pos_left hpre.1 m,?_,?_,fun i _ => hDX i⟩ |
| · exact (strictRecord_suffix_iff ℓ X hpre.2.1 hm.1).mp hm.2.1 |
| · rw [recordCount_add ℓ X hpre.2.1,hpre.2.2.1,hm.2.2.1] |
| rw [recordIndexPosition,recordIndexTime_eq ℓ (k+j) (n+m) X ha, |
| recordIndexPosition,recordIndexTime_eq ℓ j m Z hm] |
| change X (n+m) = wordPath 0 w.val w.val.length+(X (n+m)-X n) |
| rw [← hX n le_rfl] |
| abel |
|
|
| lemma conditioned_prefix_mass_le_raw {d : ℕ} (ν : Measure (Row d)) [IsProbabilityMeasure ν] |
| (ℓ : Vector d) (hp : annealedLaw ν (NoDrop ℓ 0) ≠ 0) |
| (A : Set (Path d)) (hA : MeasurableSet A) : |
| annealedLaw ν (NoDrop ℓ 0) * conditionedLaw ν ℓ A ≤ annealedLaw ν A := by |
| rw [conditionedLaw,Measure.smul_apply,smul_eq_mul,Measure.restrict_apply hA,← mul_assoc, |
| ENNReal.mul_inv_cancel hp (measure_ne_top _ _),one_mul] |
| exact measure_mono Set.inter_subset_left |
|
|
| lemma conditioned_record_convolution_domination {d : ℕ} (ν : Measure (Row d)) |
| [IsProbabilityMeasure ν] (ℓ : Vector d) (htrans : DirectionallyTransient ν ℓ) |
| {k j : ℕ} (hk : 0 < k) (hj : 0 < j) : |
| annealedLaw ν (NoDrop ℓ 0) • |
| (independentConditionedPairLaw ν ℓ).map (fun P => |
| recordIndexPosition ℓ k P.1 + recordIndexPosition ℓ j P.2) ≤ |
| (conditionedLaw ν ℓ).map (recordIndexPosition ℓ (k+j)) := by |
| let μ := conditionedLaw ν ℓ |
| let p := annealedLaw ν (NoDrop ℓ 0) |
| have hp : p ≠ 0 := ne_of_gt (noDrop_positive_of_directionallyTransient ν ℓ htrans) |
| let : IsProbabilityMeasure μ := conditionedLaw_probability ν ℓ hp |
| apply Measure.le_iff.mpr |
| intro A hA |
| let B := fun w : RecordWord ℓ k => |
| (fun Y => wordPath 0 w.val w.val.length + recordIndexPosition ℓ j Y) ⁻¹' A |
| have hB (w : RecordWord ℓ k) : MeasurableSet (B w) := |
| hA.preimage (measurable_const.add (measurable_recordIndexPosition ℓ j)) |
| let R : Set (Path d) := (⋃ m, RecordIndexPrefix ℓ j m) ∩ NoDrop ℓ 0 |
| have hRm : MeasurableSet R := |
| (MeasurableSet.iUnion (measurableSet_recordIndexPrefix ℓ j)).inter (measurableSet_noDrop ℓ 0) |
| have hR : ∀ᵐ Y ∂μ, Y ∈ R := by |
| filter_upwards [conditioned_recordIndexPrefix_exists ν ℓ htrans hj, |
| conditionedLaw_noDrop ν ℓ] with Y hY hD |
| exact ⟨Set.mem_iUnion.mpr hY,hD⟩ |
| let E := fun w : RecordWord ℓ k => |
| (fun X : Path d => fun i => X (w.val.length+i)-wordPath 0 w.val w.val.length) ⁻¹' |
| (B w ∩ R) ∩ wordCylinder 0 w.val |
| have hEm (w : RecordWord ℓ k) : MeasurableSet (E w) := |
| ((hB w).inter hRm).preimage (by fun_prop) |>.inter (measurableSet_wordCylinder 0 w.val) |
| have hEd : Pairwise (fun u v : RecordWord ℓ k => Disjoint (E u) (E v)) := |
| fun u v huv => (recordWord_cylinders_disjoint ℓ k huv).mono Set.inter_subset_right Set.inter_subset_right |
| have hEsub (w : RecordWord ℓ k) : E w ⊆ (recordIndexPosition ℓ (k+j)) ⁻¹' A := by |
| intro X hX |
| have hadd := recordWord_position_add ℓ k j w hX.2 hX.1.2.2 |
| (Set.mem_iUnion.mp hX.1.2.1) |
| change recordIndexPosition ℓ (k+j) X ∈ A |
| rw [hadd] |
| exact hX.1.1 |
| have hmass (w : RecordWord ℓ k) : μ (E w) = annealedLaw ν (wordCylinder 0 w.val)*μ (B w) := by |
| have he : μ (B w ∩ R) = μ (B w) := measure_congr (hR.mono fun Y hY => propext ⟨fun h => h.1,fun h => ⟨h,hY⟩⟩) |
| rw [show μ (E w) = annealedLaw ν (wordCylinder 0 w.val)*μ (B w ∩ R) from |
| conditioned_record_word_factor ν ℓ w.val w.property.2.1 w.property.2.2.2 |
| (B w ∩ R) ((hB w).inter hRm) (fun _ h => h.2.2),he] |
| have hCd : Pairwise (fun u v : RecordWord ℓ k => |
| Disjoint (wordCylinder 0 u.val ×ˢ B u) (wordCylinder 0 v.val ×ˢ B v)) := by |
| intro u v huv |
| apply Set.disjoint_left.mpr |
| exact fun P hu hv => Set.disjoint_left.mp (recordWord_cylinders_disjoint ℓ k huv) hu.1 hv.1 |
| have heq : (μ.prod μ) ((fun P => recordIndexPosition ℓ k P.1 + recordIndexPosition ℓ j P.2) ⁻¹' A) = |
| ∑' w : RecordWord ℓ k, μ (wordCylinder 0 w.val)*μ (B w) := by |
| simp_rw [← Measure.prod_prod] |
| rw [← measure_iUnion hCd (fun w => (measurableSet_wordCylinder 0 w.val).prod (hB w))] |
| apply measure_congr |
| filter_upwards [Measure.quasiMeasurePreserving_fst.ae (conditioned_recordWord_cover ν ℓ htrans hk)] with P hP |
| obtain ⟨w,hw⟩ := hP |
| apply propext |
| constructor |
| · intro h |
| change recordIndexPosition ℓ k P.1 + recordIndexPosition ℓ j P.2 ∈ A at h |
| exact Set.mem_iUnion.mpr ⟨w,hw,by simpa only [B,Set.mem_preimage,← recordWord_position ℓ k w hw] using h⟩ |
| · intro h |
| obtain ⟨v,hv,hBv⟩ := Set.mem_iUnion.mp h |
| change recordIndexPosition ℓ k P.1 + recordIndexPosition ℓ j P.2 ∈ A |
| simpa only [B,Set.mem_preimage,← recordWord_position ℓ k v hv] using hBv |
| rw [Measure.smul_apply,smul_eq_mul,Measure.map_apply |
| (show Measurable (fun P : Path d × Path d => recordIndexPosition ℓ k P.1 + recordIndexPosition ℓ j P.2) from |
| ((measurable_recordIndexPosition ℓ k).comp measurable_fst).add |
| ((measurable_recordIndexPosition ℓ j).comp measurable_snd)) hA, |
| Measure.map_apply (measurable_recordIndexPosition ℓ (k+j)) hA] |
| change p * (μ.prod μ) _ ≤ μ _ |
| rw [heq,← ENNReal.tsum_mul_left] |
| calc |
| _ ≤ ∑' w : RecordWord ℓ k, μ (E w) := by |
| apply ENNReal.tsum_le_tsum |
| intro w |
| rw [hmass,← mul_assoc] |
| gcongr |
| exact conditioned_prefix_mass_le_raw ν ℓ hp _ (measurableSet_wordCylinder 0 w.val) |
| _ = μ (⋃ w : RecordWord ℓ k, E w) := (measure_iUnion hEd hEm).symm |
| _ ≤ _ := measure_mono (Set.iUnion_subset hEsub) |
|
|
| end DirectionalTransience |
|
|
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical BoundedContinuousFunction |
|
|
| end |
| end |
|
|
| end OAI |
|
|
