| import OAI.Probability.FreeIsing.Brownian.IntegralContinuitySupport |
| import OAI.Probability.FreeIsing.Martingales.L2Closure |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter Set |
| open scoped NNReal Topology |
|
|
| namespace Problem367.BrownianIntegralProcess |
|
|
| variable {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} |
|
|
| omit mΩ in |
| theorem stoppedUniformSum_terminal (B H : ℝ≥0 → Ω → ℝ) (T : ℝ≥0) (n : ℕ) : |
| stoppedUniformSum B H T n T = BrownianGrid.uniformSum B H T n := by |
| funext ω |
| unfold stoppedUniformSum BrownianGrid.uniformSum BrownianGrid.integralSum |
| apply Finset.sum_congr rfl |
| intro i hi |
| have hin : i < n := Finset.mem_range.mp hi |
| have hn : 0 < n := lt_of_le_of_lt (Nat.zero_le i) hin |
| have ha := BrownianGrid.uniformGrid_le_horizon T hn hin.le |
| have hb := BrownianGrid.uniformGrid_le_horizon T hn hin |
| simp only [StoppedSimpleIntegral.intervalSum, min_eq_right ha, min_eq_right hb] |
|
|
| theorem integral_sq_sub_tendsto_of_L2_tendsto |
| {X : ℕ → Ω → ℝ} {L : Ω → ℝ} |
| (hX : ∀ n, MemLp (X n) 2 P) (hL : MemLp L 2 P) |
| (hlim : Tendsto (fun n => (hX n).toLp (X n)) atTop (𝓝 (hL.toLp L))) : |
| Tendsto (fun n => ∫ ω, (X n ω - L ω) ^ 2 ∂P) atTop (𝓝 0) := by |
| have hdist := (tendsto_iff_dist_tendsto_zero.mp hlim).pow 2 |
| simpa only [MartingaleSquareMaximal.dist_toLp_sq, zero_pow (by decide : 2 ≠ 0)] using hdist |
|
|
| theorem exists_continuous_stopped_uniform_integral |
| {B H : ℝ≥0 → Ω → ℝ} {F : Filtration ℝ≥0 mΩ} |
| (hB : IsPreBrownianReal B P) (hAd : StronglyAdapted F B) |
| (hind : ∀ s t, s ≤ t → Indep |
| (MeasurableSpace.comap (fun ω => B t ω - B s ω) inferInstance) (F s) P) |
| (hBc : ∀ᵐ ω ∂P, Continuous (fun t => B t ω)) |
| (hH : StronglyAdapted F H) |
| (hc : ∀ᵐ ω ∂P, Continuous (fun t => H t ω)) |
| {C : ℝ} (hC : 0 ≤ C) (hb : ∀ᵐ ω ∂P, ∀ t, |H t ω| ≤ C) (T : ℝ≥0) : |
| ∃ I : ℝ≥0 → Ω → ℝ, IsStronglyPredictable F I ∧ Martingale I F P ∧ |
| (∀ᵐ ω ∂P, Continuous (fun t => I t ω)) ∧ |
| (∀ t, MemLp (I t) 2 P) ∧ I 0 =ᵐ[P] 0 ∧ |
| (∀ t, (∫ ω, I t ω ∂P) = 0) ∧ |
| (∀ᵐ ω ∂P, ∀ t, T ≤ t → I t ω = I T ω) ∧ |
| (∫ ω, (I T ω) ^ 2 ∂P) = |
| (∫ t in (0 : ℝ)..(T : ℝ), ∫ ω, (H t.toNNReal ω) ^ 2 ∂P) ∧ |
| (∀ t, Tendsto (fun n => ∫ ω, |
| (stoppedUniformSum B H T n t ω - I t ω) ^ 2 ∂P) atTop (𝓝 0)) := by |
| let : IsProbabilityMeasure P := hB.isGaussianProcess.isProbabilityMeasure |
| have hH2 (t : ℝ≥0) : MemLp (H t) 2 P := by |
| apply MemLp.of_bound ((hH t).mono (F.le t)).aestronglyMeasurable C |
| filter_upwards [hb] with ω hω |
| simpa only [Real.norm_eq_abs] using hω t |
| have hS2 (n : ℕ) (t : ℝ≥0) : MemLp (stoppedUniformSum B H T n t) 2 P := |
| BrownianFiltration.stopped_predictable_sum_memLp_two hB hind |
| (BrownianGrid.uniformGrid T n) (BrownianGrid.uniformGrid_mono T n) |
| (fun i => H (BrownianGrid.uniformGrid T n i)) (fun i => hH _) (fun i => hH2 _) |
| (Finset.range n) t |
| have hSM (n : ℕ) : Martingale (stoppedUniformSum B H T n) F P := by |
| apply BrownianFiltration.stopped_predictable_sum_martingale hB hAd hind |
| (BrownianGrid.uniformGrid T n) (BrownianGrid.uniformGrid_mono T n) |
| (fun i => H (BrownianGrid.uniformGrid T n i)) (fun i => hH _) (fun _ => C) |
| (fun i => ?_) (Finset.range n) |
| filter_upwards [hb] with ω hω |
| simpa only [Real.norm_eq_abs] using hω (BrownianGrid.uniformGrid T n i) |
| have hSC : CauchySeq (fun n => (hS2 n T).toLp (stoppedUniformSum B H T n T)) := by |
| have hclass : (fun n => (hS2 n T).toLp (stoppedUniformSum B H T n T)) = |
| BrownianFiltrationGrid.uniformSumLp hB hAd hind H hH hH2 T := by |
| funext n |
| apply Lp.ext |
| exact (hS2 n T).coeFn_toLp.trans |
| ((stoppedUniformSum_terminal B H T n).eventuallyEq.trans |
| (BrownianFiltrationGrid.coe_uniformSumLp hB hAd hind H hH hH2 T n).symm) |
| rw [hclass] |
| exact BrownianFiltrationGrid.cauchySeq_uniformSumLp hB hAd hind H hH hH2 T |
| (fun ε hε => MeanSquareContinuity.uniform_integral_sq_sub_le |
| (fun t => (hH2 t).aestronglyMeasurable) hc hC hb T hε) |
| obtain ⟨L, hLp, hLc, hLlim⟩ := |
| MartingaleSquareMaximal.exists_predictable_continuous_L2_limit hSM hS2 |
| (ae_continuous_stoppedUniformSum hBc T) T hSC |
| obtain ⟨M, hM, hM2, hMzero, hMstop, hMiso, hMlim⟩ := |
| exists_stopped_uniform_integral_process hB hAd hind hH hc hC hb T |
| have hLM (t : ℝ≥0) (ht : t ≤ T) : L t =ᵐ[P] M t := by |
| obtain ⟨hL2, hlim⟩ := hLlim t ht |
| exact BrownianGrid.ae_eq_of_mean_square_limits (fun n => hS2 n t) hL2 (hM2 t) |
| (integral_sq_sub_tendsto_of_L2_tendsto (fun n => hS2 n t) hL2 hlim) (hMlim t) |
| let R : ℝ≥0 → Ω → ℝ := fun t => L (min t T) |
| have hRad : StronglyAdapted F R := fun t => |
| (hLp.stronglyAdapted (min t T)).mono (F.mono (min_le_left _ _)) |
| have hRc : ∀ᵐ ω ∂P, Continuous (fun t => R t ω) := by |
| filter_upwards [hLc] with ω hω |
| exact hω.comp_continuous (continuous_id.min continuous_const) (fun t => min_le_right t T) |
| let I := PredictableMesh.repair R |
| have hIp : IsStronglyPredictable F I := PredictableMesh.repair_isStronglyPredictable hRad |
| have hIR : ∀ᵐ ω ∂P, ∀ t, I t ω = R t ω := by |
| filter_upwards [hRc] with ω hω |
| intro t |
| exact PredictableMesh.repair_eq_of_continuousOn (T := t) hω.continuousOn le_rfl |
| have hIM (t : ℝ≥0) : I t =ᵐ[P] M t := by |
| filter_upwards [hIR, hLM (min t T) (min_le_right _ _)] with ω hIω hω |
| rw [hIω t] |
| change L (min t T) ω = M t ω |
| rw [hω] |
| by_cases ht : t ≤ T |
| · rw [min_eq_left ht] |
| · rw [min_eq_right (le_of_not_ge ht), hMstop t (le_of_not_ge ht)] |
| refine ⟨I, hIp, hM.congr hIp.stronglyAdapted (fun t => (hIM t).symm), ?_, |
| (fun t => (hM2 t).ae_eq (hIM t).symm), ?_, ?_, ?_, ?_, ?_⟩ |
| · filter_upwards [hIR, hRc] with ω hIω hω |
| exact hω.congr (fun t => (hIω t).symm) |
| · exact (hIM 0).trans (initial_zero_of_stopped_uniform_limit T (hM2 0) (hMlim 0)) |
| · intro t |
| exact (integral_congr_ae (hIM t)).trans (hMzero t) |
| · filter_upwards [hIR] with ω hω |
| intro t ht |
| rw [hω t, hω T] |
| dsimp [R] |
| rw [min_eq_right ht, min_self] |
| · rw [← hMiso] |
| apply integral_congr_ae |
| filter_upwards [hIM T] with ω hω |
| rw [hω] |
| · intro t |
| apply (hMlim t).congr' |
| apply Filter.Eventually.of_forall |
| intro n |
| apply integral_congr_ae |
| filter_upwards [hIM t] with ω hω |
| rw [hω] |
| |
| end Problem367.BrownianIntegralProcess |
| |
| end |
| |
| end OAI |
| |
