| import OAI.Probability.FreeIsing.Brownian.ContinuousExistence |
| import OAI.Probability.FreeIsing.Estimates.UniformSampler |
| import OAI.Probability.FreeIsing.Factors.Transfer |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped NNReal Topology |
|
|
| namespace Problem367.WienerSampler |
|
|
| abbrev Path := C(ℝ≥0, ℝ) |
|
|
| instance pathMeasurableSpace : MeasurableSpace Path := borel Path |
| instance pathBorelSpace : BorelSpace Path := ⟨rfl⟩ |
|
|
| theorem measurableEmbedding_denseEval : MeasurableEmbedding |
| (fun f : Path => fun n : ℕ => f (TopologicalSpace.denseSeq ℝ≥0 n)) := by |
| apply Measurable.measurableEmbedding |
| · exact Measurable.of_eval fun index => (continuous_eval_const _).measurable |
| · intro f g h |
| apply ContinuousMap.coe_injective |
| exact (TopologicalSpace.denseRange_denseSeq ℝ≥0).equalizer f.continuous g.continuous h |
|
|
| theorem measurable_path_of_eval {Ω : Type*} [MeasurableSpace Ω] |
| {F : Ω → Path} (hF : ∀ t, Measurable (fun ω => F ω t)) : Measurable F := by |
| apply measurableEmbedding_denseEval.measurable_comp_iff.mp |
| exact Measurable.of_eval fun index => hF _ |
|
|
| theorem exists_measurable_path_version {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) (B : ℝ≥0 → Ω → ℝ) |
| (hm : ∀ t, Measurable (B t)) |
| (hc : ∀ᵐ ω ∂μ, Continuous (fun t => B t ω)) : |
| ∃ F : Ω → Path, Measurable F ∧ ∀ᵐ ω ∂μ, ∀ t, F ω t = B t ω := by |
| classical |
| obtain ⟨N, hNsub, hNm, hNzero⟩ := exists_measurable_superset_of_null (ae_iff.mp hc) |
| have hcont (ω : Ω) (hω : ω ∉ N) : Continuous (fun t => B t ω) := by |
| by_contra h |
| exact hω (hNsub h) |
| let F : Ω → Path := fun ω => if hω : ω ∈ N then 0 else ⟨fun t => B t ω, hcont ω hω⟩ |
| refine ⟨F, ?_, ?_⟩ |
| · apply measurable_path_of_eval |
| intro t |
| have heq : (fun ω => F ω t) = N.piecewise (fun _ => 0) (B t) := by |
| funext ω |
| by_cases hω : ω ∈ N <;> simp [F, hω, Set.piecewise] |
| rw [heq] |
| exact measurable_const.piecewise hNm (hm t) |
| · have hgood : ∀ᵐ ω ∂μ, ω ∉ N := by simpa only [ae_iff, not_not, Set.ofPred_mem_eq] using hNzero |
| filter_upwards [hgood] with ω hω t |
| simp [F, hω] |
|
|
| theorem measurable_brownian_version (t : ℝ≥0) : Measurable |
| (BrownianContinuousExistence.version (fun s (ω : ℝ≥0 → ℝ) => ω s) t) := by |
| exact (StronglyMeasurable.limUnder (fun n => |
| (measurable_pi_apply (Real.toNNReal (ContinuousModification.dyadicLeft t n))).stronglyMeasurable)).measurable |
|
|
| theorem isBrownian_eval_map {Ω : Type*} [MeasurableSpace Ω] |
| {μ : Measure Ω} {B : ℝ≥0 → Ω → ℝ} (hB : IsPreBrownianReal B μ) |
| {F : Ω → Path} (hF : Measurable F) |
| (heq : ∀ᵐ ω ∂μ, ∀ t, F ω t = B t ω) : |
| IsBrownianReal (fun t (f : Path) => f t) (μ.map F) where |
| hasLaw I := by |
| have hI : Measurable (fun f : Path => I.restrict (fun t => f t)) := |
| Measurable.of_eval fun index => (continuous_eval_const index.1).measurable |
| refine ⟨hI.aemeasurable, ?_⟩ |
| rw [Measure.map_map hI hF] |
| have he : (fun ω => I.restrict (fun t => F ω t)) =ᵐ[μ] |
| (fun ω => I.restrict (fun t => B t ω)) := by |
| filter_upwards [heq] with ω hω |
| exact funext (fun i => hω i.1) |
| exact (Measure.map_congr he).trans (hB.hasLaw I).map_eq |
| cont := Filter.Eventually.of_forall (fun f => f.continuous) |
|
|
| theorem exists_wienerMeasure : |
| ∃ ν : Measure Path, IsProbabilityMeasure ν ∧ |
| IsBrownianReal (fun t (f : Path) => f t) ν := by |
| let B := BrownianContinuousExistence.version (fun t (ω : ℝ≥0 → ℝ) => ω t) |
| have hB : IsBrownianReal B BrownianExistence.preWienerMeasure := |
| BrownianContinuousExistence.isBrownianReal_version |
| BrownianExistence.coordinate_isPreBrownianReal |
| obtain ⟨F, hF, heq⟩ := exists_measurable_path_version |
| BrownianExistence.preWienerMeasure B measurable_brownian_version hB.cont |
| exact ⟨BrownianExistence.preWienerMeasure.map F, |
| inferInstance, |
| isBrownian_eval_map hB.toIsPreBrownianReal hF heq⟩ |
|
|
| def wienerMeasure : Measure Path := Classical.choose exists_wienerMeasure |
|
|
| instance wienerProbability : IsProbabilityMeasure wienerMeasure := |
| (Classical.choose_spec exists_wienerMeasure).1 |
|
|
| theorem coordinate_isBrownianReal : |
| IsBrownianReal (fun t (f : Path) => f t) wienerMeasure := |
| (Classical.choose_spec exists_wienerMeasure).2 |
|
|
| theorem exists_uniform01_wiener_sampler : |
| ∃ ξ : ℝ → Path, Measurable ξ ∧ Measure.map ξ uniform01 = wienerMeasure := |
| exists_uniform01_sampler wienerMeasure |
|
|
| theorem isBrownianReal_of_sampler {ξ : ℝ → Path} (hξ : Measurable ξ) |
| (hξlaw : Measure.map ξ uniform01 = wienerMeasure) : |
| IsBrownianReal (fun t u => ξ u t) uniform01 where |
| hasLaw I := (coordinate_isBrownianReal.hasLaw I).comp ⟨hξ.aemeasurable, hξlaw⟩ |
| cont := Filter.Eventually.of_forall (fun u => (ξ u).continuous) |
|
|
| def sample : ℝ → Path := Classical.choose exists_uniform01_wiener_sampler |
|
|
| theorem measurable_sample : Measurable sample := |
| (Classical.choose_spec exists_uniform01_wiener_sampler).1 |
|
|
| theorem map_sample : Measure.map sample uniform01 = wienerMeasure := |
| (Classical.choose_spec exists_uniform01_wiener_sampler).2 |
|
|
| theorem sample_isBrownianReal : IsBrownianReal (fun t u => sample u t) uniform01 := |
| isBrownianReal_of_sampler measurable_sample map_sample |
|
|
| theorem measurable_sample_eval : |
| Measurable (fun p : ℝ≥0 × ℝ => sample p.2 p.1) := by |
| exact continuous_eval.measurable.comp |
| ((measurable_sample.comp measurable_snd).prodMk measurable_fst) |
|
|
| theorem wiener_starts_zero : ∀ᵐ f ∂wienerMeasure, f 0 = 0 := |
| coordinate_isBrownianReal.toIsPreBrownianReal.eval_zero_ae_eq_zero |
|
|
| def array (d : ℕ) : (TreeVertex d → ℝ) → (TreeVertex d → Path) := |
| vertexSampler sample |
|
|
| theorem measurable_array (d : ℕ) : Measurable (array d) := |
| measurable_vertexSampler measurable_sample |
|
|
| theorem map_array (d : ℕ) : |
| Measure.map (array d) (labelMeasure d) = |
| Measure.infinitePi (fun _ : TreeVertex d => wienerMeasure) := by |
| rw [array, map_vertexSampler_labelMeasure measurable_sample, map_sample] |
|
|
| theorem array_relabel {d : ℕ} (g : TreeAut d) (u : TreeVertex d → ℝ) : |
| array d (relabel g u) = relabel g (array d u) := rfl |
|
|
| theorem array_iIndepFun (d : ℕ) : |
| iIndepFun (fun v (u : TreeVertex d → ℝ) => array d u v) (labelMeasure d) := by |
| exact iIndepFun_infinitePi (fun _ => measurable_sample) |
|
|
| theorem array_isBrownianReal {d : ℕ} (v : TreeVertex d) : |
| IsBrownianReal (fun t u => array d u v t) (labelMeasure d) where |
| hasLaw I := by |
| apply (sample_isBrownianReal.hasLaw I).comp |
| exact ⟨(measurable_pi_apply v).aemeasurable, |
| Measure.infinitePi_map_eval (fun _ : TreeVertex d => uniform01) v⟩ |
| cont := Filter.Eventually.of_forall (fun u => (array d u v).continuous) |
|
|
| end Problem367.WienerSampler |
|
|
| end |
|
|
| end OAI |
|
|
