| import Mathlib |
| import OAI.Probability.Ballisticity.Estimates.OrderedTimes |
| import OAI.Probability.Ballisticity.Estimates.MartingaleExponentialSubmartingale |
|
|
| namespace OAI |
|
|
| section |
|
|
| section |
|
|
| open MeasureTheory ProbabilityTheory Filter |
| open scoped ENNReal NNReal BigOperators Topology Classical |
|
|
| namespace DirectionalTransience |
|
|
| lemma gaussian_independent_sum_range_law {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) [IsProbabilityMeasure μ] (X : ℕ → Ω → ℝ) |
| (hXm : ∀ n, Measurable (X n)) (hind : iIndepFun X μ) |
| (v : ℕ → ℝ≥0) (hLaw : ∀ n, μ.map (X n) = gaussianReal 0 (v n)) (n : ℕ) : |
| μ.map (fun ω => ∑ j ∈ Finset.range n, X j ω) = |
| gaussianReal 0 (∑ j ∈ Finset.range n, v j) := by |
| induction n with |
| | zero => simp [gaussianReal_zero_var] |
| | succ n ih => |
| have he : (∑ j ∈ Finset.range n, X j) = (fun ω => ∑ j ∈ Finset.range n, X j ω) := by |
| funext ω |
| simp |
| have hi' : μ.map (∑ j ∈ Finset.range n, X j) = |
| gaussianReal 0 (∑ j ∈ Finset.range n, v j) := by rw [he]; exact ih |
| have hh := gaussianReal_add_gaussianReal_of_indepFun |
| (hind.indepFun_finsetSum_of_notMem hXm (Finset.notMem_range_self (n := n))) |
| ⟨by rw [he]; fun_prop, hi'⟩ ⟨(hXm n).aemeasurable, hLaw n⟩ |
| rw [he] at hh |
| convert hh using 1 |
| · congr 1 |
| funext ω |
| simp [Finset.sum_range_succ] |
| · simp only [zero_add, Finset.sum_range_succ] |
|
|
| lemma gaussian_martingale_maximal_le {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) [IsProbabilityMeasure μ] (F : Filtration ℕ ‹MeasurableSpace Ω›) |
| (X : ℕ → Ω → ℝ) (hX : Martingale X F μ) (v : ℕ → ℝ≥0) |
| (hLaw : ∀ n, μ.map (X n) = gaussianReal 0 (v n)) |
| (n : ℕ) (V : ℝ) (hV : 0 < V) (hv : (v n : ℝ) ≤ V) (a : ℝ) (ha : 0 < a) : |
| μ.real {ω | ∃ k ≤ n, a ≤ X k ω} ≤ Real.exp (-a^2/(2*V)) := by |
| let c := a/V |
| have hc : 0 < c := div_pos ha hV |
| have hXm (j : ℕ) : Measurable (X j) := (hX.stronglyMeasurable j).measurable.mono (F.le j) le_rfl |
| have hi (j : ℕ) : Integrable (fun ω => Real.exp (c*X j ω)) μ := by |
| have hh : Integrable (fun z : ℝ => Real.exp (c*z)) (μ.map (X j)) := by |
| rw [hLaw j] |
| exact integrable_exp_mul_gaussianReal c |
| exact (integrable_map_measure (by fun_prop) (hXm j).aemeasurable).mp hh |
| have hh := martingale_exponential_maximal μ F (c • X) (hX.smul c) hi n (c*a) |
| have hs : {ω | ∃ k ≤ n, c*a ≤ (c • X) k ω} = {ω | ∃ k ≤ n, a ≤ X k ω} := by |
| ext ω |
| simp only [Set.mem_ofPred_eq, Pi.smul_apply, smul_eq_mul, mul_le_mul_iff_right₀ hc] |
| rw [hs] at hh |
| have he : (∫ ω, Real.exp ((c • X) n ω) ∂μ) = Real.exp ((v n:ℝ)*c^2/2) := by |
| simpa only [mgf, Pi.smul_apply, smul_eq_mul, zero_mul, zero_add] using |
| mgf_gaussianReal ⟨(hXm n).aemeasurable, hLaw n⟩ c |
| rw [he, ← Real.exp_add] at hh |
| refine hh.trans (Real.exp_le_exp.mpr ?_) |
| calc |
| -(c*a) + (v n:ℝ)*c^2/2 ≤ -(c*a) + V*c^2/2 := by gcongr |
| _ = -a^2/(2*V) := by dsimp [c]; field_simp; ring |
|
|
| lemma gaussian_martingale_abs_maximal_le {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) [IsProbabilityMeasure μ] (F : Filtration ℕ ‹MeasurableSpace Ω›) |
| (X : ℕ → Ω → ℝ) (hX : Martingale X F μ) (v : ℕ → ℝ≥0) |
| (hLaw : ∀ n, μ.map (X n) = gaussianReal 0 (v n)) |
| (n : ℕ) (V : ℝ) (hV : 0 < V) (hv : (v n : ℝ) ≤ V) (a : ℝ) (ha : 0 < a) : |
| μ.real {ω | ∃ k ≤ n, a ≤ |X k ω|} ≤ 2*Real.exp (-a^2/(2*V)) := by |
| have hneg (j : ℕ) : μ.map ((-X) j) = gaussianReal 0 (v j) := by |
| have hm : AEMeasurable (X j) μ := |
| ((hX.stronglyMeasurable j).measurable.mono (F.le j) le_rfl).aemeasurable |
| simpa only [neg_zero, Pi.neg_apply] using |
| (gaussianReal_neg (show HasLaw (X j) (gaussianReal 0 (v j)) μ from ⟨hm,hLaw j⟩)).map_eq |
| have hp := gaussian_martingale_maximal_le μ F X hX v hLaw n V hV hv a ha |
| have hn := gaussian_martingale_maximal_le μ F (-X) hX.neg v hneg n V hV hv a ha |
| have hs : {ω | ∃ k ≤ n, a ≤ |X k ω|} = |
| {ω | ∃ k ≤ n, a ≤ X k ω} ∪ {ω | ∃ k ≤ n, a ≤ (-X) k ω} := by |
| ext ω |
| simp only [Set.mem_ofPred_eq, Set.mem_union, le_abs, Pi.neg_apply] |
| aesop |
| rw [hs] |
| exact (measureReal_union_le _ _).trans (by simpa only [two_mul] using add_le_add hp hn) |
|
|
| lemma fin_sum_Iic_eq_range {M : Type*} [AddCommMonoid M] {n : ℕ} |
| (x : ℕ → M) (k : Fin n) : |
| (∑ j ≤ k, x j) = ∑ j ∈ Finset.range (k+1), x j := by |
| apply Finset.sum_bij (fun j _ => j.val) |
| · intro j hj |
| simp only [Finset.mem_Iic] at hj |
| exact Finset.mem_range.mpr (Nat.lt_succ_of_le hj) |
| · intro j hj j' hj' he |
| exact Fin.ext he |
| · intro j hj |
| have hjk : j ≤ k.val := Nat.lt_succ_iff.mp (Finset.mem_range.mp hj) |
| exact ⟨⟨j, hjk.trans_lt k.isLt⟩, Finset.mem_Iic.mpr hjk, rfl⟩ |
| · intros; rfl |
|
|
| lemma gaussian_pi_prefix_maximal {n : ℕ} (v : Fin n → ℝ≥0) |
| (V : ℝ) (hV : 0 < V) (hv : (∑ j, (v j : ℝ)) ≤ V) (a : ℝ) (ha : 0 < a) : |
| (Measure.pi (fun j => gaussianReal 0 (v j))).real |
| {x | ∃ k : Fin n, a ≤ |∑ j ≤ k, x j|} ≤ 2*Real.exp (-a^2/(2*V)) := by |
| let w : ℕ → ℝ≥0 := fun j => if hj : j < n then v ⟨j,hj⟩ else 0 |
| let μ := Measure.infinitePi (fun j => gaussianReal 0 (w j)) |
| let X : ℕ → (ℕ → ℝ) → ℝ := fun j x => x j |
| have hXm (j : ℕ) : Measurable (X j) := measurable_pi_apply j |
| have hLaw (j : ℕ) : μ.map (X j) = gaussianReal 0 (w j) := |
| Measure.infinitePi_map_eval _ j |
| have hHasLaw (j : ℕ) : HasLaw (X j) (gaussianReal 0 (w j)) μ := |
| ⟨(hXm j).aemeasurable, hLaw j⟩ |
| have hi (j : ℕ) : Integrable (X j) μ := (hHasLaw j).hasGaussianLaw.integrable |
| have hmean (j : ℕ) : ∫ x, X j x ∂μ = 0 := by |
| rw [(hHasLaw j).integral_eq] |
| exact integral_id_gaussianReal |
| have hind : iIndepFun X μ := iIndepFun_infinitePi (X := fun _ x => x) (by fun_prop) |
| have hM := independent_centered_sum_martingale μ X hXm hi hind hmean |
| have hsum (j : ℕ) := gaussian_independent_sum_range_law μ X hXm hind w hLaw (j+1) |
| have htotal : ((∑ j ∈ Finset.range (n+1), w j : ℝ≥0) : ℝ) ≤ V := by |
| rw [Finset.sum_range_succ] |
| have hw : w n = 0 := by simp [w] |
| rw [hw, add_zero] |
| have hs : ∑ j ∈ Finset.range n, w j = ∑ j, v j := by |
| symm |
| exact Finset.sum_fin_eq_sum_range _ |
| rw [hs] |
| simpa only [NNReal.coe_sum] using hv |
| have hh := gaussian_martingale_abs_maximal_le μ _ _ hM |
| (fun j => ∑ k ∈ Finset.range (j+1), w k) hsum n V hV htotal a ha |
| let π : (ℕ → ℝ) → (Fin n → ℝ) := fun x j => x j |
| have hm : μ.map π = Measure.pi (fun j => gaussianReal 0 (v j)) := by |
| have hh := Measure.map_infinitePi_infinitePi_of_inj |
| (P := fun j => gaussianReal 0 (w j)) (f := fun j : Fin n => j.val) Fin.val_injective |
| rw [Measure.infinitePi_eq_pi (fun j : Fin n => gaussianReal 0 (w j))] at hh |
| simpa only [w, dite_eq_left (Fin.isLt _)] using hh |
| rw [← hm, measureReal_def, Measure.map_apply (by fun_prop) |
| (by measurability)] |
| apply le_trans (measureReal_mono (show π ⁻¹' {x | ∃ k : Fin n, a ≤ |∑ j ≤ k, x j|} ⊆ |
| {x | ∃ k ≤ n, a ≤ |∑ j ∈ Finset.range (k+1), X j x|} from ?_)) hh |
| rintro x ⟨k,hk⟩ |
| refine ⟨k,k.isLt.le,?_⟩ |
| simpa only [π, X, fin_sum_Iic_eq_range] using hk |
|
|
| lemma gaussianPathFiniteLaw_abs_maximal (V : ℝ) (hV : 0 < V) |
| (I : Finset unitInterval) (a : ℝ) (ha : 0 < a) : |
| (gaussianPathFiniteLaw V I).real {x | ∃ i : I, a ≤ |x i|} ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| let v : Fin I.card → ℝ≥0 := fun j => |
| Real.toNNReal (V*((orderedTimes I j.succ : ℝ)-orderedTimes I j.castSucc)) |
| have hv : (∑ j, (v j : ℝ)) ≤ V := by |
| have hn (j : Fin I.card) : 0 ≤ V*((orderedTimes I j.succ : ℝ)-orderedTimes I j.castSucc) := |
| mul_nonneg hV.le (sub_nonneg.mpr (orderedTimes_monotone I (Fin.castSucc_le_succ j))) |
| simp only [v, Real.coe_toNNReal _ (hn _)] |
| by_cases hI : I.card = 0 |
| · have he : I = ∅ := Finset.card_eq_zero.mp hI |
| subst I |
| have : IsEmpty (Fin ((∅ : Finset unitInterval).card)) := by |
| change IsEmpty (Fin 0) |
| infer_instance |
| rw [Finset.univ_eq_empty, Finset.sum_empty] |
| exact hV.le |
| · let k : Fin I.card := ⟨I.card-1, by omega⟩ |
| have hk : Finset.Iic k = Finset.univ := by |
| ext j |
| simp only [Finset.mem_Iic, Finset.mem_univ, iff_true] |
| change j.val ≤ I.card-1 |
| have := j.isLt |
| omega |
| rw [← Finset.mul_sum, ← hk, Fin.sum_Iic_sub k (fun j => (orderedTimes I j : ℝ))] |
| have hz : (orderedTimes I 0 : ℝ) = 0 := by simp [orderedTimes] |
| rw [hz, sub_zero] |
| exact (mul_le_mul_of_nonneg_left (orderedTimes I k.succ).2.2 hV.le).trans_eq (mul_one V) |
| have hh := gaussian_pi_prefix_maximal v V hV hv a ha |
| unfold gaussianPathFiniteLaw |
| rw [measureReal_def, Measure.map_apply (by fun_prop) |
| (show MeasurableSet {x : I → ℝ | ∃ i : I, a ≤ |x i|} from by |
| simp only [Set.ofPred_exists] |
| exact MeasurableSet.iUnion fun i => measurableSet_le measurable_const (measurable_pi_apply i).abs)] |
| apply le_trans (measureReal_mono (show (incrementCumsum I) ⁻¹' {x | ∃ i : I, a ≤ |x i|} ⊆ |
| {x | ∃ k : Fin I.card, a ≤ |∑ j ≤ k, x j|} from ?_)) hh |
| rintro x ⟨i,hi⟩ |
| exact ⟨(I.orderIsoOfFin rfl).symm i, hi⟩ |
|
|
| lemma wiener_path_finite_abs_maximal (W : ProbabilityMeasure C(unitInterval,ℝ)) |
| (V : ℝ) (hV : 0 < V) |
| (hW : ∀ I : Finset unitInterval, |
| (W : Measure C(unitInterval,ℝ)).map (fun g : C(unitInterval,ℝ) => I.restrict g) = |
| gaussianPathFiniteLaw V I) |
| (I : Finset unitInterval) (a : ℝ) (ha : 0 < a) : |
| (W : Measure C(unitInterval,ℝ)).real {g | ∃ t ∈ I, a ≤ |g t|} ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| have hh := gaussianPathFiniteLaw_abs_maximal V hV I a ha |
| rw [← hW I, measureReal_def, Measure.map_apply (continuous_path_restrict I).measurable |
| (show MeasurableSet {x : I → ℝ | ∃ i : I, a ≤ |x i|} from by |
| simp only [Set.ofPred_exists] |
| exact MeasurableSet.iUnion fun i => measurableSet_le measurable_const (measurable_pi_apply i).abs)] at hh |
| have hs : (fun g : C(unitInterval,ℝ) => I.restrict g) ⁻¹' {x | ∃ i : I, a ≤ |x i|} = |
| {g | ∃ t ∈ I, a ≤ |g t|} := by |
| ext g |
| constructor |
| · rintro ⟨⟨t,ht⟩,hg⟩ |
| exact ⟨t,ht,hg⟩ |
| · rintro ⟨t,ht,hg⟩ |
| exact ⟨⟨t,ht⟩,hg⟩ |
| rw [hs] at hh |
| exact hh |
|
|
| lemma wiener_path_countable_abs_maximal (W : ProbabilityMeasure C(unitInterval,ℝ)) |
| (V : ℝ) (hV : 0 < V) |
| (hW : ∀ I : Finset unitInterval, |
| (W : Measure C(unitInterval,ℝ)).map (fun g : C(unitInterval,ℝ) => I.restrict g) = |
| gaussianPathFiniteLaw V I) |
| (t : ℕ → unitInterval) (a : ℝ) (ha : 0 < a) : |
| (W : Measure C(unitInterval,ℝ)).real {g | ∃ k, a ≤ |g (t k)|} ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| let E := fun n => {g : C(unitInterval,ℝ) | ∃ k ∈ Finset.range n, a ≤ |g (t k)|} |
| have hm : Monotone E := by |
| intro i j hij g |
| rintro ⟨k,hk,hka⟩ |
| exact ⟨k,Finset.mem_range.mpr ((Finset.mem_range.mp hk).trans_le hij),hka⟩ |
| have hu : {g : C(unitInterval,ℝ) | ∃ k, a ≤ |g (t k)|} = ⋃ n, E n := by |
| ext g |
| simp only [Set.mem_ofPred_eq,Set.mem_iUnion,E] |
| constructor |
| · rintro ⟨k,hk⟩; exact ⟨k+1,k,Finset.mem_range.mpr (Nat.lt_succ_self k),hk⟩ |
| · rintro ⟨n,k,_,hk⟩; exact ⟨k,hk⟩ |
| have hb n : (W : Measure C(unitInterval,ℝ)) (E n) ≤ |
| ENNReal.ofReal (2*Real.exp (-a^2/(2*V))) := by |
| have hh := wiener_path_finite_abs_maximal W V hV hW ((Finset.range n).image t) a ha |
| have he : {g : C(unitInterval,ℝ) | ∃ z ∈ (Finset.range n).image t, a ≤ |g z|} = E n := by |
| ext g |
| simp only [Set.mem_ofPred_eq,Finset.mem_image,E] |
| aesop |
| rw [he] at hh |
| rw [← ofReal_measureReal] |
| exact ENNReal.ofReal_le_ofReal hh |
| have hbound : (W : Measure C(unitInterval,ℝ)) {g | ∃ k, a ≤ |g (t k)|} ≤ |
| ENNReal.ofReal (2*Real.exp (-a^2/(2*V))) := by |
| rw [hu,hm.measure_iUnion] |
| exact iSup_le hb |
| have hh := ENNReal.toReal_mono ENNReal.ofReal_ne_top hbound |
| simpa only [measureReal_def,ENNReal.toReal_ofReal |
| (by positivity : 0 ≤ 2*Real.exp (-a^2/(2*V)))] using hh |
|
|
| lemma wiener_path_abs_gt_maximal (W : ProbabilityMeasure C(unitInterval,ℝ)) |
| (V : ℝ) (hV : 0 < V) |
| (hW : ∀ I : Finset unitInterval, |
| (W : Measure C(unitInterval,ℝ)).map (fun g : C(unitInterval,ℝ) => I.restrict g) = |
| gaussianPathFiniteLaw V I) |
| (a : ℝ) (ha : 0 < a) : |
| (W : Measure C(unitInterval,ℝ)).real {g | ∃ t, a < |g t|} ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| let u := TopologicalSpace.denseSeq unitInterval |
| have hu : DenseRange u := TopologicalSpace.denseRange_denseSeq _ |
| have hh := wiener_path_countable_abs_maximal W V hV hW u a ha |
| refine (measureReal_mono (show {g : C(unitInterval,ℝ) | ∃ t, a < |g t|} ⊆ |
| {g | ∃ k, a ≤ |g (u k)|} from ?_)).trans hh |
| rintro g ⟨t,hat⟩ |
| obtain ⟨k,hk⟩ := hu.exists_mem_open (isOpen_lt continuous_const g.continuous.abs) ⟨t,hat⟩ |
| exact ⟨k,hk.le⟩ |
|
|
| lemma wiener_path_abs_maximal (W : ProbabilityMeasure C(unitInterval,ℝ)) |
| (V : ℝ) (hV : 0 < V) |
| (hW : ∀ I : Finset unitInterval, |
| (W : Measure C(unitInterval,ℝ)).map (fun g : C(unitInterval,ℝ) => I.restrict g) = |
| gaussianPathFiniteLaw V I) |
| (a : ℝ) (ha : 0 < a) : |
| (W : Measure C(unitInterval,ℝ)).real {g | ∃ t, a ≤ |g t|} ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| let b : ℕ → ℝ := fun n => a-a/((n:ℝ)+2) |
| have hbpos n : 0 < b n := by |
| have hd : a/((n:ℝ)+2) < a := (div_lt_iff₀ (by positivity)).2 (by nlinarith [Nat.cast_nonneg (α:=ℝ) n]) |
| dsimp [b]; linarith |
| have hblt n : b n < a := by dsimp [b]; exact sub_lt_self a (div_pos ha (by positivity)) |
| have hb : Tendsto b atTop (𝓝 a) := by |
| have hd := (tendsto_const_div_atTop_nhds_zero_nat a).comp (tendsto_add_atTop_nat 2) |
| simpa only [Function.comp_def,Nat.cast_add,Nat.cast_ofNat,sub_zero] using tendsto_const_nhds.sub hd |
| have hlim : Tendsto (fun n => 2*Real.exp (-(b n)^2/(2*V))) atTop |
| (𝓝 (2*Real.exp (-a^2/(2*V)))) := by |
| exact tendsto_const_nhds.mul (Real.continuous_exp.tendsto _ |>.comp ((hb.pow 2).neg.div_const (2*V))) |
| apply ge_of_tendsto hlim |
| filter_upwards [] with n |
| have hh := wiener_path_abs_gt_maximal W V hV hW (b n) (hbpos n) |
| refine (measureReal_mono (show {g : C(unitInterval,ℝ) | ∃ t, a ≤ |g t|} ⊆ |
| {g | ∃ t, b n < |g t|} from ?_)).trans hh |
| rintro g ⟨t,hat⟩ |
| exact ⟨t,(hblt n).trans_le hat⟩ |
|
|
| lemma wiener_path_norm_maximal (W : ProbabilityMeasure C(unitInterval,ℝ)) |
| (V : ℝ) (hV : 0 < V) |
| (hW : ∀ I : Finset unitInterval, |
| (W : Measure C(unitInterval,ℝ)).map (fun g : C(unitInterval,ℝ) => I.restrict g) = |
| gaussianPathFiniteLaw V I) |
| (a : ℝ) (ha : 0 < a) : |
| (W : Measure C(unitInterval,ℝ)).real {g | a ≤ ‖g‖} ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| have hs : {g : C(unitInterval,ℝ) | a ≤ ‖g‖} = {g | ∃ t, a ≤ |g t|} := by |
| ext g |
| simp only [Set.mem_ofPred_eq, ← not_lt, g.norm_lt_iff ha, Real.norm_eq_abs, not_forall] |
| rw [hs] |
| exact wiener_path_abs_maximal W V hV hW a ha |
|
|
| lemma distribution_path_norm_limsup {Ω : Type*} [MeasurableSpace Ω] |
| (μ : ℕ → Measure Ω) [∀ i, IsProbabilityMeasure (μ i)] |
| (F : ℕ → Ω → C(unitInterval,ℝ)) (hF : ∀ i, Measurable (F i)) |
| (W : ProbabilityMeasure C(unitInterval,ℝ)) |
| (hlim : TendstoInDistribution F atTop id μ W) |
| (V : ℝ) (hV : 0 < V) |
| (hW : ∀ I : Finset unitInterval, |
| (W : Measure C(unitInterval,ℝ)).map (fun g : C(unitInterval,ℝ) => I.restrict g) = |
| gaussianPathFiniteLaw V I) |
| (a : ℝ) (ha : 0 < a) : |
| limsup (fun i => (μ i).real {ω | a ≤ ‖F i ω‖}) atTop ≤ |
| 2*Real.exp (-a^2/(2*V)) := by |
| let P : ℕ → ProbabilityMeasure C(unitInterval,ℝ) := fun i => |
| ⟨(μ i).map (F i),inferInstance⟩ |
| have hp : Tendsto P atTop (𝓝 (⟨(W : Measure C(unitInterval,ℝ)),inferInstance⟩ : ProbabilityMeasure C(unitInterval,ℝ))) := by |
| simpa only [Measure.map_id] using hlim.tendsto |
| have hA : IsClosed {g : C(unitInterval,ℝ) | a ≤ ‖g‖} := |
| isClosed_le continuous_const continuous_norm |
| have hh := ProbabilityMeasure.limsup_measure_closed_le_of_tendsto hp hA |
| change limsup (fun i => ((μ i).map (F i)) {g | a ≤ ‖g‖}) atTop ≤ |
| (W : Measure C(unitInterval,ℝ)) {g | a ≤ ‖g‖} at hh |
| simp only [Measure.map_apply (hF _) hA.measurableSet] at hh |
| have he : limsup (fun i => (μ i).real {ω | a ≤ ‖F i ω‖}) atTop = |
| (limsup (fun i => μ i {ω | a ≤ ‖F i ω‖}) atTop).toReal := by |
| exact ENNReal.limsup_toReal_eq (by norm_num : (1 : ℝ≥0∞) ≠ ∞) |
| (Eventually.of_forall fun i => prob_le_one) |
| rw [he] |
| exact (ENNReal.toReal_mono (measure_ne_top _ _) hh).trans |
| (wiener_path_norm_maximal W V hV hW a ha) |
|
|
| end DirectionalTransience |
|
|
| end |
|
|
| end |
|
|
| end OAI |
|
|
