| import OAI.Probability.FreeIsing.Brownian.Observation |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory Filter |
| open scoped NNReal |
|
|
| namespace Problem367 |
|
|
| theorem intervalIntegrable_of_measurable_norm_le_const |
| {f : ℝ → ℝ} (hf : Measurable f) {C : ℝ} |
| (hbound : ∀ t, ‖f t‖ ≤ C) (a b : ℝ) : |
| IntervalIntegrable f volume a b := by |
| apply (intervalIntegrable_const (c := C)).mono_fun' hf.aestronglyMeasurable |
| exact Filter.Eventually.of_forall hbound |
|
|
| theorem lipschitzWith_intervalPrimitive_of_bound |
| {f : ℝ → ℝ} (hf : Measurable f) {C : ℝ≥0} |
| (hbound : ∀ t, ‖f t‖ ≤ (C : ℝ)) (a : ℝ) : |
| LipschitzWith C (fun t : ℝ => ∫ r in a..t, f r) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| rw [Real.dist_eq, ← Real.norm_eq_abs, intervalIntegral.integral_interval_sub_left |
| (intervalIntegrable_of_measurable_norm_le_const hf hbound a s) |
| (intervalIntegrable_of_measurable_norm_le_const hf hbound a t)] |
| simpa only [Real.dist_eq] using |
| intervalIntegral.norm_integral_le_of_norm_le_const (fun r _ => hbound r) |
|
|
| theorem intervalIntegrable_nnreal_process_of_bound |
| {Ω : Type*} {m : ℝ≥0 → Ω → ℝ} |
| (hm : ∀ ω, Measurable (fun t => m t ω)) {C : ℝ} |
| (hbound : ∀ t ω, ‖m t ω‖ ≤ C) (ω : Ω) (a b : ℝ) : |
| IntervalIntegrable (fun r => m r.toNNReal ω) volume a b := |
| intervalIntegrable_of_measurable_norm_le_const |
| ((hm ω).comp measurable_real_toNNReal) (fun _ => hbound _ ω) a b |
|
|
| theorem lipschitzWith_nnrealTimePrimitive |
| {Ω : Type*} {m : ℝ≥0 → Ω → ℝ} |
| (hm : ∀ ω, Measurable (fun t => m t ω)) {C : ℝ≥0} |
| (hbound : ∀ t ω, ‖m t ω‖ ≤ (C : ℝ)) (ω : Ω) : |
| LipschitzWith C (fun t => nnrealTimePrimitive m t ω) := by |
| have h := lipschitzWith_intervalPrimitive_of_bound |
| ((hm ω).comp measurable_real_toNNReal) (fun r => hbound _ ω) 0 |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| exact h.dist_le_mul (s : ℝ) (t : ℝ) |
|
|
| theorem norm_nnrealTimePrimitive_sub_le |
| {Ω : Type*} {m : ℝ≥0 → Ω → ℝ} |
| (hm : ∀ ω, Measurable (fun t => m t ω)) {C : ℝ≥0} |
| (hbound : ∀ t ω, ‖m t ω‖ ≤ (C : ℝ)) (ω : Ω) (s t : ℝ≥0) : |
| ‖nnrealTimePrimitive m t ω - nnrealTimePrimitive m s ω‖ ≤ |
| (C : ℝ) * |(t : ℝ) - (s : ℝ)| := by |
| exact (lipschitzWith_nnrealTimePrimitive hm hbound ω).dist_le_mul t s |
|
|
| theorem innovationCorrection_lipschitzWith |
| {Ω : Type*} {m : ℝ≥0 → Ω → ℝ} {σ : Ω → ℝ} |
| (hm : ∀ ω, Measurable (fun t => m t ω)) {C D : ℝ≥0} |
| (hbound : ∀ t ω, ‖m t ω‖ ≤ (C : ℝ)) |
| (hσ : ∀ ω, ‖σ ω‖ ≤ (D : ℝ)) (ω : Ω) : |
| LipschitzWith (D + C) |
| (fun t : ℝ≥0 => (t : ℝ) * σ ω - nnrealTimePrimitive m t ω) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro s t |
| calc |
| dist ((s : ℝ) * σ ω - nnrealTimePrimitive m s ω) |
| ((t : ℝ) * σ ω - nnrealTimePrimitive m t ω) |
| ≤ dist ((s : ℝ) * σ ω) ((t : ℝ) * σ ω) + |
| dist (nnrealTimePrimitive m s ω) (nnrealTimePrimitive m t ω) := |
| dist_sub_sub_le _ _ _ _ |
| _ ≤ (D : ℝ) * dist s t + (C : ℝ) * dist s t := by |
| apply add_le_add |
| · rw [Real.dist_eq, ← sub_mul, abs_mul] |
| calc |
| |(s : ℝ) - (t : ℝ)| * |σ ω| ≤ |
| |(s : ℝ) - (t : ℝ)| * D := |
| mul_le_mul_of_nonneg_left (hσ ω) (abs_nonneg _) |
| _ = (D : ℝ) * dist s t := by rw [mul_comm]; rfl |
| · exact (lipschitzWith_nnrealTimePrimitive hm hbound ω).dist_le_mul s t |
| _ = ((D + C : ℝ≥0) : ℝ) * dist s t := by |
| push_cast |
| ring |
|
|
| theorem measurable_path_of_isStronglyProgressive |
| {Ω : Type*} [mΩ : MeasurableSpace Ω] |
| {F : Filtration ℝ≥0 mΩ} {m : ℝ≥0 → Ω → ℝ} |
| (hm : IsStronglyProgressive F m) (ω : Ω) : |
| Measurable (fun t => m t ω) := by |
| have hstop (n : ℕ) : StronglyMeasurable |
| (fun t : ℝ≥0 => m (min t (n : ℝ≥0)) ω) := by |
| let : MeasurableSpace Ω := F n |
| have htime : Measurable (fun t : ℝ≥0 => |
| (⟨min t (n : ℝ≥0), by simp⟩ : Set.Iic (n : ℝ≥0))) := |
| (measurable_id.min measurable_const).subtype_mk |
| exact (hm n).comp_measurable (htime.prodMk measurable_const) |
| apply (stronglyMeasurable_of_tendsto atTop hstop ?_).measurable |
| apply tendsto_pi_nhds.mpr |
| intro t |
| apply tendsto_const_nhds.congr' |
| obtain ⟨N, hN⟩ := exists_nat_ge t |
| filter_upwards [eventually_ge_atTop N] with n hn |
| have htn : t ≤ (n : ℝ≥0) := hN.trans (by exact_mod_cast hn) |
| simp [min_eq_left htn] |
|
|
| theorem lipschitzWith_nnrealTimePrimitive_of_progressive |
| {Ω : Type*} [mΩ : MeasurableSpace Ω] |
| {F : Filtration ℝ≥0 mΩ} {m : ℝ≥0 → Ω → ℝ} |
| (hm : IsStronglyProgressive F m) {C : ℝ≥0} |
| (hbound : ∀ t ω, ‖m t ω‖ ≤ (C : ℝ)) (ω : Ω) : |
| LipschitzWith C (fun t => nnrealTimePrimitive m t ω) := |
| lipschitzWith_nnrealTimePrimitive (measurable_path_of_isStronglyProgressive hm) |
| hbound ω |
|
|
| theorem innovationCorrection_two_lipschitzWith |
| {Ω : Type*} [mΩ : MeasurableSpace Ω] |
| {F : Filtration ℝ≥0 mΩ} {m : ℝ≥0 → Ω → ℝ} {σ : Ω → ℝ} |
| (hm : IsStronglyProgressive F m) |
| (hbound : ∀ t ω, ‖m t ω‖ ≤ 1) (hσ : ∀ ω, ‖σ ω‖ ≤ 1) (ω : Ω) : |
| LipschitzWith 2 |
| (fun t : ℝ≥0 => (t : ℝ) * σ ω - nnrealTimePrimitive m t ω) := by |
| have h := innovationCorrection_lipschitzWith |
| (measurable_path_of_isStronglyProgressive hm) |
| (C := 1) (D := 1) hbound hσ ω |
| norm_num at h ⊢ |
| exact h |
|
|
| def unitClip (x : ℝ) : ℝ := max (-1) (min 1 x) |
|
|
| theorem continuous_unitClip : Continuous unitClip := |
| continuous_const.max (continuous_const.min continuous_id) |
|
|
| theorem norm_unitClip_le (x : ℝ) : ‖unitClip x‖ ≤ 1 := by |
| rw [Real.norm_eq_abs] |
| apply abs_le.mpr |
| constructor |
| · exact le_max_left _ _ |
| · exact max_le (by norm_num) (min_le_left _ _) |
|
|
| theorem unitClip_eq_of_norm_le {x : ℝ} (h : ‖x‖ ≤ 1) : unitClip x = x := by |
| have hx := abs_le.mp h |
| simp only [unitClip, min_eq_right hx.2, max_eq_right hx.1] |
|
|
| theorem isStronglyProgressive_unitClip |
| {Ω : Type*} [mΩ : MeasurableSpace Ω] |
| {F : Filtration ℝ≥0 mΩ} {m : ℝ≥0 → Ω → ℝ} |
| (hm : IsStronglyProgressive F m) : |
| IsStronglyProgressive F (fun t ω => unitClip (m t ω)) := |
| fun t => continuous_unitClip.comp_stronglyMeasurable (hm t) |
|
|
| theorem unitClip_posterior_version |
| {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} |
| {F : Filtration ℝ≥0 mΩ} {m : ℝ≥0 → Ω → ℝ} {σ : Ω → ℝ} |
| (hσ : ∀ᵐ ω ∂P, ‖σ ω‖ ≤ 1) |
| (hposterior : ∀ t, m t =ᵐ[P] P[σ | F t]) (t : ℝ≥0) : |
| (fun ω => unitClip (m t ω)) =ᵐ[P] P[σ | F t] := by |
| have hb : ∀ᵐ ω ∂P, ‖P[σ | F t] ω‖ ≤ 1 := |
| ae_bdd_norm_condExp_of_ae_bdd_norm hσ |
| filter_upwards [hposterior t, hb] with ω heq hbω |
| rw [heq, unitClip_eq_of_norm_le hbω] |
|
|
| theorem exists_pointwise_bounded_progressive_posterior |
| {Ω : Type*} [mΩ : MeasurableSpace Ω] {P : Measure Ω} |
| {F : Filtration ℝ≥0 mΩ} {m : ℝ≥0 → Ω → ℝ} {σ : Ω → ℝ} |
| (hm : IsStronglyProgressive F m) |
| (hσ : ∀ᵐ ω ∂P, ‖σ ω‖ ≤ 1) |
| (hposterior : ∀ t, m t =ᵐ[P] P[σ | F t]) : |
| ∃ m' : ℝ≥0 → Ω → ℝ, IsStronglyProgressive F m' ∧ |
| (∀ t ω, ‖m' t ω‖ ≤ 1) ∧ |
| (∀ t, m' t =ᵐ[P] P[σ | F t]) ∧ |
| (∀ ω, LipschitzWith 1 (fun t => nnrealTimePrimitive m' t ω)) := by |
| refine ⟨fun t ω => unitClip (m t ω), isStronglyProgressive_unitClip hm, |
| fun t ω => norm_unitClip_le _, unitClip_posterior_version hσ hposterior, ?_⟩ |
| intro ω |
| exact lipschitzWith_nnrealTimePrimitive_of_progressive |
| (isStronglyProgressive_unitClip hm) (C := 1) (fun t ω => norm_unitClip_le _) ω |
|
|
| end Problem367 |
|
|
| end |
|
|
| end OAI |
|
|
