| import OAI.Probability.FKMaps.Offspring |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.TreeCoding |
|
|
| local instance : MeasurableSpace C(unitInterval, ℝ) := borel _ |
| local instance : BorelSpace C(unitInterval, ℝ) := ⟨rfl⟩ |
|
|
| def bridgePath {Ω : Type*} (B : ℝ≥0 → Ω → ℝ) (ω : Ω) : C(unitInterval, ℝ) := |
| brownianPath B ω - B 1 ω • ⟨fun t => (t:ℝ), continuous_subtype_val⟩ |
|
|
| lemma bridgePath_aemeasurable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B μ) : |
| AEMeasurable (bridgePath B) μ := |
| (brownianPath_aemeasurable hB).sub ((hB.aemeasurable 1).smul aemeasurable_const) |
|
|
| lemma bridgePath_ae_eq {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B μ) : |
| ∀ᵐ ω ∂μ, ∀ t : unitInterval, |
| bridgePath B ω t = B ⟨(t:ℝ),t.property.1⟩ ω - (t:ℝ)*B 1 ω := by |
| filter_upwards [brownianPath_ae_eq hB] with ω hω |
| intro t |
| simp only [bridgePath, ContinuousMap.sub_apply, ContinuousMap.smul_apply, |
| ContinuousMap.coe_mk, smul_eq_mul, hω, mul_comm] |
|
|
| lemma bridge_joint_gaussian {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsPreBrownianReal B μ) : |
| IsGaussianProcess (Sum.elim |
| (fun (t : unitInterval) ω => B ⟨(t:ℝ),t.property.1⟩ ω-(t:ℝ)*B 1 ω) |
| (fun (_ : Unit) ω => B 1 ω)) μ := by |
| classical |
| apply hB.isGaussianProcess.of_isGaussianProcess |
| intro s |
| cases s with |
| | inl t => |
| let u : ℝ≥0 := ⟨(t:ℝ),t.property.1⟩ |
| refine ⟨{u,1}, |
| { toFun x := x ⟨u, by simp⟩ - (t:ℝ) * x ⟨1, by simp⟩ |
| map_add' x y := by simp only [Pi.add_apply]; ring |
| map_smul' c x := by simp only [Pi.smul_apply, smul_eq_mul, RingHom.id_apply]; ring }, ?_⟩ |
| intro ω |
| rfl |
| | inr t => |
| refine ⟨{1}, |
| { toFun x := x ⟨1, by simp⟩ |
| map_add' := by simp |
| map_smul' := by simp }, ?_⟩ |
| intro ω |
| rfl |
|
|
| lemma bridge_covariance_endpoint {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsPreBrownianReal B μ) (t : unitInterval) : |
| cov[fun ω => B ⟨(t:ℝ),t.property.1⟩ ω-(t:ℝ)*B 1 ω, B 1; μ] = 0 := by |
| have := hB.isGaussianProcess.isProbabilityMeasure |
| let u : ℝ≥0 := ⟨(t:ℝ), unitInterval.nonneg t⟩ |
| change cov[fun ω => B u ω - (t:ℝ) * B 1 ω, B 1; μ] = 0 |
| rw [covariance_fun_sub_left (hB.isGaussianProcess.hasGaussianLaw_eval _).memLp_two |
| ((hB.isGaussianProcess.hasGaussianLaw_eval _).memLp_two.const_mul _) |
| (hB.isGaussianProcess.hasGaussianLaw_eval _).memLp_two, |
| covariance_const_mul_left, hB.covariance_eval, hB.covariance_eval] |
| simp only [min_self, NNReal.coe_one, mul_one] |
| change min (t:ℝ) (1:ℝ) - (t:ℝ) = 0 |
| rw [min_eq_left t.property.2, sub_self] |
|
|
| lemma bridge_process_indep_endpoint {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsPreBrownianReal B μ) : |
| IndepFun (fun ω (t : unitInterval) => |
| B ⟨(t:ℝ),t.property.1⟩ ω-(t:ℝ)*B 1 ω) (B 1) μ := by |
| have h := (bridge_joint_gaussian hB).indepFun_of_covariance_eq_zero |
| (fun t => (hB.aemeasurable _).sub ((hB.aemeasurable 1).const_mul _)) |
| (fun _ => hB.aemeasurable 1) (fun t _ => bridge_covariance_endpoint hB t) |
| exact h.comp measurable_id (measurable_pi_apply ()) |
|
|
| lemma indepFun_of_measurableEmbedding_left {Ω E F G : Type*} |
| [MeasurableSpace Ω] [MeasurableSpace E] [MeasurableSpace F] [MeasurableSpace G] |
| {μ : Measure Ω} {X : Ω → E} {Y : Ω → F} {f : E → G} |
| (hf : MeasurableEmbedding f) (h : IndepFun (f ∘ X) Y μ) : IndepFun X Y μ := by |
| simp only [IndepFun, Kernel.IndepFun] at h ⊢ |
| rw [← MeasurableSpace.comap_comp, hf.comap_eq] at h |
| exact h |
|
|
| lemma bridgePath_indep_endpoint {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B μ) : |
| IndepFun (bridgePath B) (B 1) μ := by |
| let D := TopologicalSpace.denseSeq unitInterval |
| let f : C(unitInterval,ℝ) → (ℕ → ℝ) := fun g n => g (D n) |
| have hf : MeasurableEmbedding f := by |
| apply Continuous.measurableEmbedding |
| · apply continuous_pi |
| intro n |
| fun_prop |
| · intro a b hab |
| apply ContinuousMap.ext |
| exact congrFun ((TopologicalSpace.denseRange_denseSeq unitInterval).equalizer |
| a.continuous b.continuous hab) |
| apply indepFun_of_measurableEmbedding_left hf |
| have h := (bridge_process_indep_endpoint hB.toIsPreBrownianReal).comp |
| (φ := fun a : unitInterval → ℝ => fun n : ℕ => a (D n)) |
| (by fun_prop) measurable_id |
| apply h.congr ?_ (Filter.EventuallyEq.rfl) |
| filter_upwards [bridgePath_ae_eq hB] with ω hω |
| funext n |
| exact (hω (D n)).symm |
|
|
| lemma gaussian_softCutoff_pos {ε : ℝ} (hε : 0 < ε) : |
| 0 < ∫ x, softCutoff ε x ∂gaussianReal 0 1 := by |
| rw [integral_pos_iff_support_of_nonneg (softCutoff_nonneg ε) |
| (softCutoff_integrable aemeasurable_id hε), softCutoff_support hε, pos_iff_ne_zero] |
| intro h |
| have hv := gaussianReal_absolutelyContinuous' 0 (v := 1) (by norm_num) h |
| rw [Real.volume_Ioo, ENNReal.ofReal_eq_zero] at hv |
| linarith |
|
|
| lemma brownian_softCutoff_pos {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsPreBrownianReal B μ) {ε : ℝ} (hε : 0 < ε) : |
| 0 < ∫ ω, softCutoff ε (B 1 ω) ∂μ := by |
| change 0 < ∫ ω, (softCutoff ε ∘ B 1) ω ∂μ |
| rw [(hB.hasLaw_eval 1).integral_comp (softCutoff_continuous ε).aestronglyMeasurable] |
| exact gaussian_softCutoff_pos hε |
|
|
| lemma brownian_dist_bridge_le {Ω : Type*} (B : ℝ≥0 → Ω → ℝ) (ω : Ω) : |
| dist (brownianPath B ω) (bridgePath B ω) ≤ |B 1 ω| := by |
| rw [dist_eq_norm] |
| change ‖brownianPath B ω - |
| (brownianPath B ω - B 1 ω • (⟨fun t : unitInterval => (t:ℝ),continuous_subtype_val⟩ : C(unitInterval,ℝ)))‖ ≤ _ |
| rw [sub_sub_cancel, norm_smul,Real.norm_eq_abs] |
| apply mul_le_of_le_one_right (abs_nonneg _) |
| apply (ContinuousMap.norm_le _ (by norm_num : (0:ℝ) ≤ 1)).mpr |
| intro t |
| simp only [ContinuousMap.coe_mk, Real.norm_eq_abs, abs_of_nonneg t.property.1] |
| exact t.property.2 |
|
|
| theorem brownian_soft_bridge_bound {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| [IsProbabilityMeasure μ] {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B μ) |
| {F : C(unitInterval,ℝ) → ℝ} {M : ℝ} {L : ℝ≥0} |
| (hFM : ∀ f, |F f| ≤ M) (hF : LipschitzWith L F) {ε : ℝ} (hε : 0 < ε) : |
| |(∫ ω, F (brownianPath B ω)*softCutoff ε (B 1 ω) ∂μ) / |
| (∫ ω, softCutoff ε (B 1 ω) ∂μ) - |
| ∫ ω, F (bridgePath B ω) ∂μ| ≤ (L:ℝ)*ε := by |
| have hM : 0 ≤ M := (abs_nonneg (F 0)).trans (hFM 0) |
| have hX := brownianPath_aemeasurable hB |
| have hY := bridgePath_aemeasurable hB |
| have hg := softCutoff_integrable (hB.aemeasurable 1) hε |
| have hFg (Z : Ω → C(unitInterval,ℝ)) (hZ : AEMeasurable Z μ) : |
| Integrable (fun ω => F (Z ω)*softCutoff ε (B 1 ω)) μ := by |
| apply (hg.norm.const_mul M).mono' |
| ((hF.continuous.aestronglyMeasurable.comp_aemeasurable hZ).mul hg.aestronglyMeasurable) |
| filter_upwards [] with ω |
| change ‖F (Z ω)*softCutoff ε (B 1 ω)‖ ≤ M*‖softCutoff ε (B 1 ω)‖ |
| simp only [Real.norm_eq_abs,abs_mul] |
| exact mul_le_mul_of_nonneg_right (hFM _) (abs_nonneg _) |
| have hdiff : Integrable (fun ω => |
| (F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω)) μ := by |
| have h := (hFg _ hX).sub (hFg _ hY) |
| apply h.congr |
| filter_upwards [] with ω |
| change F (brownianPath B ω)*softCutoff ε (B 1 ω) - |
| F (bridgePath B ω)*softCutoff ε (B 1 ω) = _ |
| ring |
| have heq := (bridgePath_indep_endpoint hB).integral_fun_comp_mul_comp |
| hY (hB.aemeasurable 1) hF.continuous.aestronglyMeasurable |
| (softCutoff_continuous ε).aestronglyMeasurable |
| have hb : |∫ ω, (F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω) ∂μ| ≤ |
| (L:ℝ)*ε * ∫ ω, softCutoff ε (B 1 ω) ∂μ := by |
| calc |
| _ ≤ ∫ ω, |(F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω)| ∂μ := by |
| simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm |
| (fun ω => (F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω)) |
| _ ≤ ∫ ω, ((L:ℝ)*ε)*softCutoff ε (B 1 ω) ∂μ := by |
| apply integral_mono_ae hdiff.norm (hg.const_mul _) |
| filter_upwards [] with ω |
| change |(F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω)| ≤ _ |
| rw [abs_mul,abs_of_nonneg (softCutoff_nonneg _ _)] |
| by_cases hgω : softCutoff ε (B 1 ω) = 0 |
| · simp only [hgω,mul_zero,le_refl] |
| apply mul_le_mul_of_nonneg_right _ (softCutoff_nonneg _ _) |
| have heω : |B 1 ω| < ε := (softCutoff_pos_iff hε).mp |
| (lt_of_le_of_ne (softCutoff_nonneg _ _) (Ne.symm hgω)) |
| calc |
| _ ≤ (L:ℝ)*dist (brownianPath B ω) (bridgePath B ω) := by |
| simpa only [Real.dist_eq] using hF.dist_le_mul (brownianPath B ω) (bridgePath B ω) |
| _ ≤ (L:ℝ)*ε := mul_le_mul_of_nonneg_left |
| ((brownian_dist_bridge_le B ω).trans heω.le) L.coe_nonneg |
| _ = _ := integral_const_mul _ _ |
| rw [show (∫ ω, (F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω) ∂μ) = |
| (∫ ω, F (brownianPath B ω)*softCutoff ε (B 1 ω) ∂μ) - |
| (∫ ω, F (bridgePath B ω) ∂μ)*(∫ ω, softCutoff ε (B 1 ω) ∂μ) by |
| rw [show (fun ω => (F (brownianPath B ω)-F (bridgePath B ω))*softCutoff ε (B 1 ω)) = |
| (fun ω => F (brownianPath B ω)*softCutoff ε (B 1 ω) - |
| F (bridgePath B ω)*softCutoff ε (B 1 ω)) by funext ω; ring, |
| integral_sub (hFg _ hX) (hFg _ hY),heq]] at hb |
| have hpos := brownian_softCutoff_pos hB.toIsPreBrownianReal hε |
| have hform : |
| (∫ ω, F (brownianPath B ω)*softCutoff ε (B 1 ω) ∂μ) / |
| (∫ ω, softCutoff ε (B 1 ω) ∂μ) - (∫ ω, F (bridgePath B ω) ∂μ) = |
| ((∫ ω, F (brownianPath B ω)*softCutoff ε (B 1 ω) ∂μ) - |
| (∫ ω, F (bridgePath B ω) ∂μ)*(∫ ω, softCutoff ε (B 1 ω) ∂μ)) / |
| (∫ ω, softCutoff ε (B 1 ω) ∂μ) := by |
| rw [sub_div,mul_div_cancel_right₀ _ hpos.ne'] |
| rw [hform,abs_div,abs_of_pos hpos] |
| exact (div_le_iff₀ hpos).mpr hb |
|
|
| lemma integral_tendsto_of_tendstoInDistribution |
| {ι E Ω' : Type*} {Ω : ι → Type*} [∀ i, MeasurableSpace (Ω i)] [MeasurableSpace Ω'] |
| [TopologicalSpace E] [MeasurableSpace E] [BorelSpace E] |
| {μ : ∀ i, Measure (Ω i)} {ν : Measure Ω'} [∀ i, IsProbabilityMeasure (μ i)] |
| [IsProbabilityMeasure ν] {l : Filter ι} {X : ∀ i, Ω i → E} {Y : Ω' → E} |
| (h : TendstoInDistribution X l Y μ ν) {F : E → ℝ} |
| (hF : Continuous F) {M : ℝ} (hM : ∀ x, |F x| ≤ M) : |
| Tendsto (fun i => ∫ ω, F (X i ω) ∂μ i) l (𝓝 (∫ ω, F (Y ω) ∂ν)) := by |
| let f : BoundedContinuousFunction E ℝ := BoundedContinuousFunction.ofNormedAddCommGroup F hF M hM |
| have hh := ProbabilityMeasure.tendsto_iff_forall_integral_tendsto.mp h.tendsto f |
| change Tendsto (fun i => ∫ x, f x ∂(μ i).map (X i)) l |
| (𝓝 (∫ x, f x ∂ν.map Y)) at hh |
| simp_rw [integral_map (h.forall_aemeasurable _) f.continuous.aestronglyMeasurable, |
| integral_map h.aemeasurable_limit f.continuous.aestronglyMeasurable] at hh |
| exact hh |
|
|
| theorem soft_weighted_tendsto |
| {ι E Ω' : Type*} {Ω : ι → Type*} [∀ i, MeasurableSpace (Ω i)] [MeasurableSpace Ω'] |
| [TopologicalSpace E] [MeasurableSpace E] [BorelSpace E] |
| {μ : ∀ i, Measure (Ω i)} {ν : Measure Ω'} [∀ i, IsProbabilityMeasure (μ i)] |
| [IsProbabilityMeasure ν] {l : Filter ι} {X : ∀ i, Ω i → E} {Y : Ω' → E} |
| (h : TendstoInDistribution X l Y μ ν) {F g : E → ℝ} |
| (hF : Continuous F) (hg : Continuous g) {M ε : ℝ} |
| (hM : ∀ x, |F x| ≤ M) (hε : 0 < ε) |
| (hD : 0 < ∫ ω, softCutoff ε (g (Y ω)) ∂ν) : |
| Tendsto (fun i => (∫ ω, F (X i ω)*softCutoff ε (g (X i ω)) ∂μ i) / |
| (∫ ω, softCutoff ε (g (X i ω)) ∂μ i)) l |
| (𝓝 ((∫ ω, F (Y ω)*softCutoff ε (g (Y ω)) ∂ν) / |
| (∫ ω, softCutoff ε (g (Y ω)) ∂ν))) := by |
| apply Tendsto.div _ _ hD.ne' |
| · apply integral_tendsto_of_tendstoInDistribution h (hF.mul ((softCutoff_continuous ε).comp hg)) (M := M) |
| intro x |
| change |F x * softCutoff ε (g x)| ≤ M |
| rw [abs_mul,abs_of_nonneg (softCutoff_nonneg ε _)] |
| exact (mul_le_of_le_one_right (abs_nonneg _) (softCutoff_le_one hε _)).trans (hM x) |
| · exact integral_tendsto_of_tendstoInDistribution h ((softCutoff_continuous ε).comp hg) (M := 1) |
| (fun x => by change |softCutoff ε (g x)| ≤ 1; rw [abs_of_nonneg (softCutoff_nonneg ε _)]; exact softCutoff_le_one hε _) |
|
|
| lemma tendsto_of_soft_windows {A : ℕ → ℝ} {S : ℝ → ℕ → ℝ} {b : ℝ} {T : ℝ → ℝ} |
| {C D : ℝ} (hC : 0 ≤ C) (hD : 0 ≤ D) |
| (hd : ∀ ε > 0, ∀ δ > 0, ∀ᶠ n in atTop, |A n-S ε n| ≤ C*ε+δ) |
| (hs : ∀ ε > 0, Tendsto (S ε) atTop (𝓝 (T ε))) |
| (ht : ∀ ε > 0, |T ε-b| ≤ D*ε) : Tendsto A atTop (𝓝 b) := by |
| rw [Metric.tendsto_nhds] |
| intro η hη |
| let ε := η/(4*(C+D+1)) |
| have hε : 0 < ε := by dsimp [ε]; positivity |
| have hbound : (C+D)*ε ≤ η/4 := by |
| dsimp [ε] |
| rw [← mul_div_assoc, div_le_iff₀ (by positivity : 0 < 4*(C+D+1))] |
| nlinarith |
| have hmid := (Metric.tendsto_nhds.mp (hs ε hε)) (η/4) (by positivity) |
| filter_upwards [hd ε hε (η/4) (by positivity),hmid] with n hn hm |
| rw [Real.dist_eq] at hm ⊢ |
| have h₁ := abs_sub_le (A n) (S ε n) b |
| have h₂ := abs_sub_le (S ε n) (T ε) b |
| have h₃ := ht ε hε |
| nlinarith |
|
|
| lemma CriticalEvenOffspring.iid_endpoint_positive (p : CriticalEvenOffspring) (n : ℕ) : |
| 0 < (p.iidLaw (2*n+1)).real {d | totalStep d = -1} := by |
| have hlen : 2*n+1 = n+(n+1) := by omega |
| rw [hlen] |
| let d : Fin (n+(n+1)) → ℕ := (iidSplit n (n+1)).symm (fun _ => 2,fun _ => 0) |
| have hd : iidSplit n (n+1) d = (fun _ => 2,fun _ => 0) := |
| (iidSplit n (n+1)).apply_symm_apply _ |
| have htotal : totalStep d = -1 := by |
| rw [totalStep_split,hd] |
| simp [totalStep] |
| have hval (i : Fin (n+(n+1))) : d i=2 ∨ d i=0 := by |
| refine Fin.addCases (fun j => ?_) (fun j => ?_) i |
| · exact Or.inl (congrFun (congrArg Prod.fst hd) j) |
| · exact Or.inr (congrFun (congrArg Prod.snd hd) j) |
| have hsing : 0 < (p.iidLaw (n+(n+1))) {d} := by |
| rw [iidLaw,Measure.pi_singleton] |
| apply pos_iff_ne_zero.mpr |
| apply Finset.prod_ne_zero_iff.mpr |
| intro i _ |
| apply ne_of_gt |
| rw [p.law_singleton,ENNReal.ofReal_pos] |
| rcases hval i with h|h |
| · simpa only [h] using p.two_pos |
| · simpa only [h] using p.zero_pos |
| have hpos : 0 < (p.iidLaw (n+(n+1))) {d | totalStep d = -1} := by |
| apply hsing.trans_le |
| exact measure_mono (Set.singleton_subset_iff.mpr htotal) |
| exact ENNReal.toReal_pos hpos.ne' (measure_ne_top _ _) |
|
|
| def CriticalEvenOffspring.iidBridgeLaw (p : CriticalEvenOffspring) (n : ℕ) : |
| Measure (Fin (2*n+1) → ℕ) := cond (p.iidLaw (2*n+1)) {d | totalStep d = -1} |
|
|
| instance (p : CriticalEvenOffspring) (n : ℕ) : IsProbabilityMeasure (p.iidBridgeLaw n) := by |
| apply cond_isProbabilityMeasure |
| exact fun h => (p.iid_endpoint_positive n).ne' (by simp [measureReal_def,h]) |
|
|
| def CriticalEvenOffspring.bridgeConstant (p : CriticalEvenOffspring) : ℝ := |
| Real.sqrt (2*Real.pi)/(p.sigma*Real.pi) |
|
|
| lemma CriticalEvenOffspring.bridgeConstant_pos (p : CriticalEvenOffspring) : |
| 0 < p.bridgeConstant := div_pos (Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos)) |
| (mul_pos p.sigma_pos Real.pi_pos) |
|
|
| lemma CriticalEvenOffspring.iid_endpoint_limit (p : CriticalEvenOffspring) : |
| Tendsto (fun n : ℕ => Real.sqrt ((2*n+1:ℕ):ℝ) * |
| (p.iidLaw (2*n+1)).real {d | totalStep d = -1}) atTop (𝓝 p.bridgeConstant) := by |
| obtain ⟨E,hE,hEt,hb⟩ := p.uniform_local_limit |
| have hN : Tendsto (fun n : ℕ => 2*n+1) atTop atTop := |
| tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id |
| have h2 : Tendsto (fun n : ℕ => 2*n) atTop atTop := |
| tendsto_atTop_mono (fun n => by dsimp; omega) tendsto_id |
| have hden : Tendsto (fun n : ℕ => p.sigma*Real.sqrt ((2*n+1:ℕ):ℝ)) atTop atTop := |
| (Real.tendsto_sqrt_atTop.comp (tendsto_natCast_atTop_atTop.comp hN)).const_mul_atTop p.sigma_pos |
| have hx : Tendsto (fun n : ℕ => (-1:ℝ)/(p.sigma*Real.sqrt ((2*n+1:ℕ):ℝ))) atTop (𝓝 0) := |
| tendsto_const_nhds.div_atTop hden |
| have harg : Tendsto (fun n : ℕ => -((-1:ℝ)/(p.sigma*Real.sqrt ((2*n+1:ℕ):ℝ)))^2/2) atTop (𝓝 0) := by |
| simpa only [zero_pow (by norm_num : (2:ℕ)≠0),neg_zero,zero_div] using (hx.pow 2).neg.div_const 2 |
| have hp := ((Real.continuous_exp.tendsto 0).comp harg).const_mul p.bridgeConstant |
| rw [Real.exp_zero,mul_one] at hp |
| let A : ℕ → ℝ := fun n => Real.sqrt ((2*n+1:ℕ):ℝ) * |
| (p.iidLaw (2*n+1)).real {d | totalStep d = -1} |
| let G : ℕ → ℝ := fun n => p.bridgeConstant * |
| Real.exp (-((-1:ℝ)/(p.sigma*Real.sqrt ((2*n+1:ℕ):ℝ)))^2/2) |
| have herr : ∀ n, |A n-G n| ≤ E (2*n) := by |
| intro n |
| have hpar : Even (((2*n+1:ℕ):ℤ)+(-1)) := by |
| refine ⟨(n:ℤ),?_⟩ |
| push_cast |
| ring |
| have hh := hb (2*n) (-1) hpar |
| simpa only [A,G,bridgeConstant,Nat.cast_add,Nat.cast_mul,Nat.cast_ofNat,Nat.cast_one, |
| Int.cast_neg,Int.cast_one] using hh |
| have he : Tendsto (fun n => A n-G n) atTop (𝓝 0) := by |
| apply (tendsto_zero_iff_abs_tendsto_zero _).mpr |
| exact squeeze_zero (fun _ => abs_nonneg _) herr (hEt.comp h2) |
| have hadd := he.add (show Tendsto G atTop (𝓝 p.bridgeConstant) from hp) |
| simpa only [sub_add_cancel,zero_add] using hadd |
|
|
| lemma bridge_soft_numeric {M E B σ S T P K ε : ℝ} |
| (hM : 0 ≤ M) (hE : 0 ≤ E) (hB : 0 < B) (hσ : 0 < σ) |
| (hS : 0 < S) (hT : 0 < T) (hK : 0 < K) (hε : 0 ≤ ε) |
| (hden : B/2 ≤ S*P) (hratio : S ≤ K*T) : |
| 2*M*((2*E+B*(1+ε*(σ*S))/(σ*T))/T)/P ≤ |
| (4*M*K/B)*(2*E+(B/σ)/T)+4*M*K^2*ε := by |
| have hP : 0 < P := (mul_pos_iff_of_pos_left hS).mp ((half_pos hB).trans_le hden) |
| have hTP : 0 < T*P := mul_pos hT hP |
| have hi : 1/(T*P) ≤ 2*K/B := by |
| rw [div_le_div_iff₀ hTP hB] |
| have hh := mul_le_mul_of_nonneg_right hratio hP.le |
| nlinarith |
| have hn : 2*E+B*(1+ε*(σ*S))/(σ*T) ≤ 2*E+(B/σ)/T+B*ε*K := by |
| have hh : S/T ≤ K := (div_le_iff₀ hT).mpr hratio |
| have hm := mul_le_mul_of_nonneg_left hh (mul_nonneg hB.le hε) |
| have he : B*(1+ε*(σ*S))/(σ*T) = (B/σ)/T+B*ε*(S/T) := by |
| field_simp |
| rw [he] |
| linarith |
| have hn0 : 0 ≤ 2*E+B*(1+ε*(σ*S))/(σ*T) := by positivity |
| calc |
| _ = (2*M)*(2*E+B*(1+ε*(σ*S))/(σ*T))*(1/(T*P)) := by ring |
| _ ≤ (2*M)*(2*E+B*(1+ε*(σ*S))/(σ*T))*(2*K/B) := |
| mul_le_mul_of_nonneg_left hi (mul_nonneg (by positivity) hn0) |
| _ ≤ (2*M)*(2*E+(B/σ)/T+B*ε*K)*(2*K/B) := by |
| exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hn (by positivity)) (by positivity) |
| _ = _ := by field_simp [hB.ne']; ring |
|
|
| lemma exists_bridge_cutoff (t : unitInterval) (ht : (t:ℝ) < 1) : |
| ∃ k : ℕ, 2 ≤ k ∧ (k:ℝ)*(t:ℝ) ≤ (k:ℝ)-1 := by |
| obtain ⟨n,hn⟩ := exists_nat_one_div_lt (sub_pos.mpr ht) |
| let k := n+2 |
| have hk : 2 ≤ k := by omega |
| have hnk : 1/(k:ℝ) ≤ 1/((n:ℝ)+1) := by |
| apply one_div_le_one_div_of_le (by positivity) |
| dsimp [k] |
| push_cast |
| linarith |
| have hh : 1/(k:ℝ) < 1-(t:ℝ) := hnk.trans_lt hn |
| have hkr : 0 < (k:ℝ) := by exact_mod_cast (show 0 < k by omega) |
| have hx := (div_lt_iff₀ hkr).mp hh |
| refine ⟨k,hk,?_⟩ |
| nlinarith |
|
|
| lemma bridge_split_parameters {t : unitInterval} {k N : ℕ} |
| (hk : 2 ≤ k) (ht : (k:ℝ)*(t:ℝ) ≤ (k:ℝ)-1) (hN : k ≤ N) : |
| (N-N/k)+(N/k-1+1)=N ∧ |
| (N:ℝ)*(t:ℝ) ≤ (N-N/k:ℕ) ∧ |
| Real.sqrt (N:ℝ) ≤ (k:ℝ)*Real.sqrt ((N/k-1+1:ℕ):ℝ) := by |
| have hk0 : 0 < k := by omega |
| have hkr : 0 < (k:ℝ) := by positivity |
| have hq : 1 ≤ N/k := (Nat.le_div_iff_mul_le hk0).mpr (by simpa using hN) |
| have hqN : N/k ≤ N := Nat.div_le_self N k |
| have hqr : N/k-1+1=N/k := by omega |
| refine ⟨by omega,?_,?_⟩ |
| · have hmul : (k:ℝ)*((N/k:ℕ):ℝ) ≤ N := by |
| exact_mod_cast Nat.mul_div_le N k |
| have htN := mul_le_mul_of_nonneg_left ht (Nat.cast_nonneg N (α := ℝ)) |
| have hm : ((N-N/k:ℕ):ℝ) = (N:ℝ)-((N/k:ℕ):ℝ) := Nat.cast_sub hqN |
| rw [hm] |
| nlinarith |
| · rw [hqr] |
| have hlt : N < k*(N/k+1) := by |
| have hh := Nat.mod_lt N hk0 |
| have he := Nat.mod_add_div N k |
| nlinarith |
| have hh : N ≤ 2*k*(N/k) := by nlinarith |
| have hNR : (N:ℝ) ≤ 2*(k:ℝ)*((N/k:ℕ):ℝ) := by exact_mod_cast hh |
| have hkr2 : (2:ℝ) ≤ k := by exact_mod_cast hk |
| have hq0 : (0:ℝ) ≤ ((N/k:ℕ):ℝ) := by positivity |
| have hsq := Real.sq_sqrt (Nat.cast_nonneg N (α := ℝ)) |
| have hsq' := Real.sq_sqrt hq0 |
| have hKsq : (2*(k:ℝ)) ≤ (k:ℝ)^2 := by nlinarith |
| have hNN := hNR.trans (mul_le_mul_of_nonneg_right hKsq hq0) |
| have hpos : 0 ≤ (k:ℝ)*Real.sqrt ((N/k:ℕ):ℝ) := by positivity |
| nlinarith [Real.sqrt_nonneg (N:ℝ)] |
|
|
| lemma bridge_suffix_tendsto {k : ℕ} (hk : 0 < k) : |
| Tendsto (fun n : ℕ => (2*n+1)/k-1) atTop atTop := by |
| apply tendsto_atTop.2 |
| intro b |
| filter_upwards [eventually_ge_atTop (k*(b+2))] with n hn |
| have hq : b+2 ≤ (2*n+1)/k := (Nat.le_div_iff_mul_le hk).mpr (by nlinarith) |
| omega |
|
|
| theorem CriticalEvenOffspring.stopped_soft_error (p : CriticalEvenOffspring) |
| (t : unitInterval) (ht : (t:ℝ)<1) {F : C(unitInterval,ℝ) → ℝ} {M : ℝ} |
| (hM : 0 ≤ M) (hF : ∀ f, |F f| ≤ M) : |
| ∃ C : ℝ, 0 ≤ C ∧ ∀ ε > 0, ∀ δ > 0, ∀ᶠ n in atTop, |
| |(∫ d, F (stopPath t (p.iidWalk (2*n+1) d)) ∂p.iidBridgeLaw n) - |
| (∫ d, F (stopPath t (p.iidWalk (2*n+1) d))* |
| softCutoff ε (p.iidWalk (2*n+1) d 1) ∂p.iidLaw (2*n+1)) / |
| (∫ d, softCutoff ε (p.iidWalk (2*n+1) d 1) ∂p.iidLaw (2*n+1))| ≤ C*ε+δ := by |
| obtain ⟨k,hk,hkt⟩ := exists_bridge_cutoff t ht |
| obtain ⟨E,hE,hEt,hb⟩ := p.prefix_soft_bound |
| let r : ℕ → ℕ := fun n => (2*n+1)/k-1 |
| have hr : Tendsto r atTop atTop := bridge_suffix_tendsto (by omega) |
| have hT : Tendsto (fun n => Real.sqrt ((r n+1:ℕ):ℝ)) atTop atTop := |
| Real.tendsto_sqrt_atTop.comp (tendsto_natCast_atTop_atTop.comp (tendsto_add_atTop_nat 1 |>.comp hr)) |
| have hres : Tendsto (fun n => (4*M*(k:ℝ)/p.bridgeConstant)* |
| (2*E (r n)+(p.bridgeConstant/p.sigma)/Real.sqrt ((r n+1:ℕ):ℝ))) atTop (𝓝 0) := by |
| have hh := ((hEt.comp hr).const_mul 2).add |
| (hT.const_div_atTop (p.bridgeConstant/p.sigma)) |
| simpa only [mul_zero,add_zero,Function.comp_apply] using hh.const_mul (4*M*(k:ℝ)/p.bridgeConstant) |
| refine ⟨4*M*(k:ℝ)^2,by positivity,?_⟩ |
| intro ε hε δ hδ |
| have hN : Tendsto (fun n : ℕ => 2*n+1) atTop atTop := |
| tendsto_atTop_mono (fun n => by dsimp;omega) tendsto_id |
| have hscale : Tendsto (fun n : ℕ => ε*(p.sigma*Real.sqrt ((2*n+1:ℕ):ℝ))) atTop atTop := |
| ((Real.tendsto_sqrt_atTop.comp (tendsto_natCast_atTop_atTop.comp hN)).const_mul_atTop |
| p.sigma_pos).const_mul_atTop hε |
| have hden := p.iid_endpoint_limit.eventually (eventually_ge_nhds |
| (show p.bridgeConstant/2 < p.bridgeConstant by linarith [p.bridgeConstant_pos])) |
| have hsmall := hres.eventually (eventually_lt_nhds hδ) |
| filter_upwards [hN.eventually (eventually_ge_atTop k),hscale.eventually (eventually_gt_atTop 1), |
| hden,hsmall] with n hn hw hp he |
| let m := (2*n+1)-(2*n+1)/k |
| obtain ⟨hlen,htm,hratio⟩ := bridge_split_parameters hk hkt hn |
| change m+(r n+1)=2*n+1 at hlen |
| change ((2*n+1:ℕ):ℝ)*(t:ℝ) ≤ m at htm |
| change Real.sqrt ((2*n+1:ℕ):ℝ) ≤ (k:ℝ)*Real.sqrt ((r n+1:ℕ):ℝ) at hratio |
| have htm' : ((m+(r n+1):ℕ):ℝ)*(t:ℝ) ≤ m := by simpa only [hlen] using htm |
| have hpar : Even (((m+(r n+1):ℕ):ℤ)-1) := by |
| rw [hlen] |
| refine ⟨(n:ℤ),?_⟩ |
| push_cast |
| ring |
| have hw' : 1 < ε*(p.sigma*Real.sqrt (m+(r n+1))) := by |
| simpa only [Nat.cast_add,Nat.cast_one] using (show 1 < ε*(p.sigma*Real.sqrt ((m+(r n+1):ℕ):ℝ)) from hlen ▸ hw) |
| have hp' : 0 < (p.iidLaw (m+(r n+1))).real {d | totalStep d = -1} := by |
| rw [hlen] |
| exact p.iid_endpoint_positive n |
| have hh := hb m (r n) ε hε hpar hw' hp' |
| (fun a => F (p.prefixWalk m (r n+1) t a)) M hM (fun a => hF _) |
| simp_rw [p.prefixWalk_eq m (r n+1) htm'] at hh |
| have hcast : (m:ℝ)+((r n:ℝ)+1)=((2*n+1:ℕ):ℝ) := by exact_mod_cast hlen |
| rw [hcast] at hh |
| rw [hlen] at hh |
| simp_rw [← p.iidWalk_endpoint (by omega : 0 < 2*n+1)] at hh |
| have hcast' : (r n:ℝ)+1=((r n+1:ℕ):ℝ) := by norm_cast |
| rw [hcast'] at hh |
| change |_ - _| ≤ 2*M*((2*E (r n)+p.bridgeConstant* |
| (1+ε*(p.sigma*Real.sqrt ((2*n+1:ℕ):ℝ)))/ |
| (p.sigma*Real.sqrt ((r n+1:ℕ):ℝ)))/Real.sqrt ((r n+1:ℕ):ℝ)) / |
| (p.iidLaw (2*n+1)).real {d | totalStep d = -1} at hh |
| apply hh.trans |
| have hnumb := bridge_soft_numeric hM (hE (r n)) p.bridgeConstant_pos p.sigma_pos |
| (Real.sqrt_pos.mpr (by positivity : 0 < ((2*n+1:ℕ):ℝ))) |
| (Real.sqrt_pos.mpr (by positivity : 0 < ((r n+1:ℕ):ℝ))) |
| (by exact_mod_cast (show 0 < k by omega)) hε.le hp hratio |
| exact hnumb.trans (by linarith) |
|
|
| theorem CriticalEvenOffspring.stopped_bridge_integral_limit (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω} [IsProbabilityMeasure ν] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B ν) |
| (t : unitInterval) (ht : (t:ℝ)<1) {F : C(unitInterval,ℝ) → ℝ} |
| {M : ℝ} {L : ℝ≥0} (hFM : ∀ f, |F f| ≤ M) (hF : LipschitzWith L F) : |
| Tendsto (fun n => ∫ d, F (stopPath t (p.iidWalk (2*n+1) d)) ∂p.iidBridgeLaw n) |
| atTop (𝓝 (∫ ω, F (stopPath t (bridgePath B ω)) ∂ν)) := by |
| have hM : 0 ≤ M := (abs_nonneg (F 0)).trans (hFM 0) |
| obtain ⟨C,hC,he⟩ := p.stopped_soft_error t ht hM hFM |
| let G : C(unitInterval,ℝ) → ℝ := F ∘ stopPath t |
| have hG : LipschitzWith L G := by |
| simpa only [mul_one] using hF.comp (stopPath_lipschitz t) |
| have hGM : ∀ f, |G f| ≤ M := fun f => hFM _ |
| have hN : Tendsto (fun n : ℕ => 2*n+1) atTop atTop := |
| tendsto_atTop_mono (fun n => by dsimp;omega) tendsto_id |
| have hclt := p.iidWalk_CLT hB |
| have hodd : TendstoInDistribution (fun n => p.iidWalk (2*n+1)) atTop |
| (brownianPath B) (fun n => p.iidLaw (2*n+1)) ν := |
| ⟨fun n => hclt.forall_aemeasurable (2*n+1),hclt.aemeasurable_limit,hclt.tendsto.comp hN⟩ |
| have hep : (fun ω => brownianPath B ω 1) =ᵐ[ν] (fun ω => B 1 ω) := by |
| filter_upwards [brownianPath_ae_eq hB] with ω hω |
| exact hω 1 |
| have hden (ε : ℝ) : (∫ ω, softCutoff ε (brownianPath B ω 1) ∂ν) = |
| ∫ ω, softCutoff ε (B 1 ω) ∂ν := |
| integral_congr_ae (hep.fun_comp (softCutoff ε)) |
| have hnum (ε : ℝ) : (∫ ω, G (brownianPath B ω)*softCutoff ε (brownianPath B ω 1) ∂ν) = |
| ∫ ω, G (brownianPath B ω)*softCutoff ε (B 1 ω) ∂ν := by |
| apply integral_congr_ae |
| filter_upwards [hep] with ω hω |
| rw [hω] |
| apply tendsto_of_soft_windows hC L.coe_nonneg he |
| (T := fun ε => (∫ ω, G (brownianPath B ω)*softCutoff ε (B 1 ω) ∂ν) / |
| (∫ ω, softCutoff ε (B 1 ω) ∂ν)) |
| · intro ε hε |
| have hh := soft_weighted_tendsto hodd hG.continuous |
| (show Continuous (fun f : C(unitInterval,ℝ) => f 1) from by fun_prop) hGM hε |
| (show 0 < ∫ ω, softCutoff ε (brownianPath B ω 1) ∂ν from by |
| rw [hden]; exact brownian_softCutoff_pos hB.toIsPreBrownianReal hε) |
| rw [hnum,hden] at hh |
| exact hh |
| · intro ε hε |
| exact brownian_soft_bridge_bound hB hGM hG hε |
|
|
| theorem CriticalEvenOffspring.stopped_bridge_CLT (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω} [IsProbabilityMeasure ν] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B ν) |
| (t : unitInterval) (ht : (t:ℝ)<1) : |
| TendstoInDistribution (fun n d => stopPath t (p.iidWalk (2*n+1) d)) atTop |
| (fun ω => stopPath t (bridgePath B ω)) p.iidBridgeLaw ν := by |
| have hX (n : ℕ) : AEMeasurable (fun d => stopPath t (p.iidWalk (2*n+1) d)) (p.iidBridgeLaw n) := |
| ((continuous_stopPath t).measurable.comp (p.iidWalk_measurable _)).aemeasurable |
| have hY : AEMeasurable (fun ω => stopPath t (bridgePath B ω)) ν := |
| (continuous_stopPath t).measurable.comp_aemeasurable (bridgePath_aemeasurable hB) |
| refine ⟨hX,hY,?_⟩ |
| apply tendsto_iff_forall_lipschitz_integral_tendsto.mpr |
| rintro F ⟨M,hM⟩ ⟨L,hL⟩ |
| change Tendsto (fun n => ∫ f, F f ∂(p.iidBridgeLaw n).map (fun d => stopPath t (p.iidWalk (2*n+1) d))) |
| atTop (𝓝 (∫ f, F f ∂ν.map (fun ω => stopPath t (bridgePath B ω)))) |
| simp_rw [integral_map (hX _) hL.continuous.aestronglyMeasurable, |
| integral_map hY hL.continuous.aestronglyMeasurable] |
| apply p.stopped_bridge_integral_limit hB t ht (M := |F 0|+M) (L := L) _ hL |
| intro f |
| have hh := hM f 0 |
| rw [Real.dist_eq] at hh |
| linarith [abs_sub_abs_le_abs_sub (F f) (F 0)] |
|
|
| lemma hat_reverse (N : ℕ) (i : Fin (N+1)) (t : unitInterval) : |
| hat N i.rev.val (unitInterval.symm t) = hat N i.val t := by |
| change max 0 (1-|(N:ℝ)*(1-(t:ℝ))-(i.rev.val:ℝ)|) = _ |
| have hi : i.rev.val=N-i.val := by simp [Fin.val_rev] |
| have hile : i.val ≤ N := Nat.le_of_lt_succ i.isLt |
| rw [hi,Nat.cast_sub hile] |
| have he : (N:ℝ)*(1-(t:ℝ))-((N:ℝ)-i.val) = -((N:ℝ)*(t:ℝ)-i.val) := by ring |
| rw [he,abs_neg] |
| rfl |
|
|
| lemma interpolation_reverse (N : ℕ) (a : Fin (N+1) → ℝ) (c : ℝ) |
| (t : unitInterval) : |
| interpolation N (fun i => c-a i.rev) t = c-interpolation N a (unitInterval.symm t) := by |
| rw [interpolation_apply,interpolation_apply] |
| have hs : (∑ i : Fin (N+1), a i*hat N i.val (unitInterval.symm t)) = |
| ∑ i : Fin (N+1), a i.rev*hat N i.val t := by |
| rw [← Equiv.sum_comp Fin.revPerm (fun i : Fin (N+1) => a i*hat N i.val (unitInterval.symm t))] |
| apply Finset.sum_congr rfl |
| intro i _ |
| simp only [Fin.revPerm_apply,hat_reverse] |
| rw [hs] |
| simp_rw [sub_mul] |
| rw [Finset.sum_sub_distrib,← Finset.mul_sum,hat_sum,mul_one] |
|
|
| lemma reverse_partial_sum (N : ℕ) (x : Fin N → ℝ) (i : Fin (N+1)) : |
| (∑ j : Fin N, if j.val < i.val then x j.rev else 0) = |
| (∑ j : Fin N, x j)-(∑ j : Fin N, if j.val < i.rev.val then x j else 0) := by |
| rw [← Equiv.sum_comp Fin.revPerm (fun j : Fin N => if j.val < i.val then x j.rev else 0), |
| ← Finset.sum_sub_distrib] |
| apply Finset.sum_congr rfl |
| intro j _ |
| simp only [Fin.revPerm_apply,Fin.rev_rev] |
| have hi : i.rev.val=N-i.val := by simp [Fin.val_rev] |
| have hj : j.rev.val=N-1-j.val := by simp [Fin.val_rev];omega |
| have hb : j.rev.val < i.val ↔ ¬ j.val < i.rev.val := by rw [hi,hj];omega |
| by_cases h : j.val < i.rev.val <;> simp only [hb,h,not_true_eq_false,not_false_eq_true,ite_true,ite_false,sub_self,sub_zero] |
|
|
| lemma interpolation_increments_reverse (N : ℕ) (x : Fin N → ℝ) (a : ℝ) |
| (t : unitInterval) : |
| interpolation N (fun i => (∑ j : Fin N, if j.val < i.val then x j.rev else 0)/a) t = |
| (∑ j : Fin N, x j)/a - |
| interpolation N (fun i => (∑ j : Fin N, if j.val < i.val then x j else 0)/a) |
| (unitInterval.symm t) := by |
| simp_rw [reverse_partial_sum,sub_div] |
| exact interpolation_reverse N (fun i : Fin (N+1) => (∑ j : Fin N, if j.val < i.val then x j else 0)/a) ((∑ j : Fin N, x j)/a) t |
|
|
| lemma measurePreserving_cond {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω} |
| {e : Ω → Ω} (he : MeasurePreserving e μ μ) {s : Set Ω} |
| (hs : MeasurableSet s) (hes : e ⁻¹' s=s) : |
| MeasurePreserving e (cond μ s) (cond μ s) := by |
| refine ⟨he.measurable,?_⟩ |
| apply Measure.ext |
| intro A hA |
| rw [Measure.map_apply he.measurable hA,cond_apply hs,cond_apply hs] |
| congr 1 |
| calc |
| μ (s ∩ e ⁻¹' A) = μ (e ⁻¹' (s ∩ A)) := by rw [Set.preimage_inter,hes] |
| _ = μ (s ∩ A) := he.measure_preimage (hs.inter hA).nullMeasurableSet |
|
|
| def reverseArray (N : ℕ) : (Fin N → ℕ) ≃ᵐ (Fin N → ℕ) := |
| MeasurableEquiv.piCongrLeft (fun _ : Fin N => ℕ) Fin.revPerm |
|
|
| lemma reverseArray_apply (N : ℕ) (d : Fin N → ℕ) (i : Fin N) : |
| reverseArray N d i = d i.rev := by |
| simpa only [Fin.revPerm_apply,Fin.rev_rev,reverseArray] using |
| MeasurableEquiv.piCongrLeft_apply_apply Fin.revPerm (β := fun _ : Fin N => ℕ) d i.rev |
|
|
| lemma reverseArray_preserving (μ : Measure ℕ) [SigmaFinite μ] (N : ℕ) : |
| MeasurePreserving (reverseArray N) (Measure.pi (fun _ : Fin N => μ)) |
| (Measure.pi (fun _ : Fin N => μ)) := |
| measurePreserving_piCongrLeft (fun _ : Fin N => μ) Fin.revPerm |
|
|
| lemma reverseArray_sum (N : ℕ) (d : Fin N → ℕ) (f : ℕ → ℤ) : |
| (∑ i : Fin N, f (reverseArray N d i)) = ∑ i : Fin N, f (d i) := by |
| simpa only [reverseArray_apply,Fin.revPerm_apply] using Equiv.sum_comp Fin.revPerm (fun i : Fin N => f (d i)) |
|
|
| lemma reverseArray_cond_preserving (μ : Measure ℕ) [SigmaFinite μ] (N : ℕ) |
| (f : ℕ → ℤ) (j : ℤ) : |
| MeasurePreserving (reverseArray N) |
| (cond (Measure.pi (fun _ : Fin N => μ)) {d | (∑ i : Fin N, f (d i))=j}) |
| (cond (Measure.pi (fun _ : Fin N => μ)) {d | (∑ i : Fin N, f (d i))=j}) := by |
| apply measurePreserving_cond (reverseArray_preserving μ N) (by measurability) |
| ext d |
| simp only [Set.mem_preimage,Set.mem_ofPred_eq,reverseArray_sum] |
|
|
| lemma stopPath_one (f : C(unitInterval,ℝ)) : stopPath 1 f=f := by |
| ext s |
| rw [stopPath_apply,min_eq_left (show s ≤ (1:unitInterval) from s.property.2)] |
|
|
| lemma stopPath_zero (f : C(unitInterval,ℝ)) : stopPath 0 f=ContinuousMap.const _ (f 0) := by |
| ext s |
| simp [stopPath_apply] |
|
|
| lemma continuous_stopPath_time (f : C(unitInterval,ℝ)) : Continuous (fun t => stopPath t f) := by |
| apply ContinuousMap.continuous_of_continuous_uncurry |
| exact f.continuous.comp (continuous_snd.min continuous_fst) |
|
|
| lemma dist_stop_reverse_le (f g : C(unitInterval,ℝ)) (c : ℝ) |
| (hfg : ∀ u, g u=c-f (unitInterval.symm u)) (t : unitInterval) : |
| dist f (stopPath t f) ≤ 2*‖stopPath (unitInterval.symm t) g‖ := by |
| apply (ContinuousMap.dist_le (by positivity)).mpr |
| intro u |
| have hval (v : unitInterval) (hv : v ≤ unitInterval.symm t) : |
| |g v| ≤ ‖stopPath (unitInterval.symm t) g‖ := by |
| have hh := ContinuousMap.norm_coe_le_norm (stopPath (unitInterval.symm t) g) v |
| simpa only [stopPath_apply,min_eq_left hv,Real.norm_eq_abs] using hh |
| rw [stopPath_apply,Real.dist_eq] |
| by_cases hu : u ≤ t |
| · simp only [min_eq_left hu,sub_self,abs_zero] |
| positivity |
| · have htu : t ≤ u := le_of_not_ge hu |
| rw [min_eq_right htu] |
| have hv := hval (unitInterval.symm u) ((unitInterval.symm_le_symm).mpr htu) |
| have ht' := hval (unitInterval.symm t) le_rfl |
| have hdiff : f u-f t = g (unitInterval.symm t)-g (unitInterval.symm u) := by |
| rw [hfg,hfg,unitInterval.symm_symm,unitInterval.symm_symm] |
| ring |
| rw [hdiff] |
| exact (abs_sub _ _).trans (by linarith) |
|
|
| def earlyTime (j : ℕ) : unitInterval := |
| ⟨1/((j:ℝ)+2),by constructor <;> (try positivity); apply (div_le_one (by positivity)).mpr; linarith [Nat.cast_nonneg j (α := ℝ)]⟩ |
|
|
| lemma earlyTime_pos (j : ℕ) : (0:ℝ)<earlyTime j := by dsimp [earlyTime];positivity |
|
|
| lemma earlyTime_lt_one (j : ℕ) : (earlyTime j:ℝ)<1 := by |
| dsimp [earlyTime] |
| apply (div_lt_one (by positivity)).mpr |
| linarith [Nat.cast_nonneg j (α := ℝ)] |
|
|
| lemma earlyTime_tendsto : Tendsto earlyTime atTop (𝓝 0) := by |
| apply tendsto_subtype_rng.mpr |
| change Tendsto (fun j : ℕ => 1/((j:ℝ)+2)) atTop (𝓝 0) |
| exact (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds).const_div_atTop 1 |
|
|
| lemma lateTime_tendsto : Tendsto (fun j => unitInterval.symm (earlyTime j)) atTop (𝓝 1) := by |
| simpa only [unitInterval.symm_zero,Function.comp_def] using unitInterval.continuous_symm.tendsto 0 |>.comp earlyTime_tendsto |
|
|
| lemma norm_stop_early_tendsto (f : C(unitInterval,ℝ)) (hf : f 0=0) : |
| Tendsto (fun j => ‖stopPath (earlyTime j) f‖) atTop (𝓝 0) := by |
| have h := ((continuous_stopPath_time f).tendsto 0 |>.comp earlyTime_tendsto).norm |
| simpa only [stopPath_zero,hf,ContinuousMap.const_zero,norm_zero,Function.comp_def] using h |
|
|
| lemma stop_late_tendsto (f : C(unitInterval,ℝ)) : |
| Tendsto (fun j => stopPath (unitInterval.symm (earlyTime j)) f) atTop (𝓝 f) := by |
| simpa only [stopPath_one,Function.comp_def] using (continuous_stopPath_time f).tendsto 1 |>.comp lateTime_tendsto |
|
|
| def freezeGauge (M : ℝ) (L : ℝ≥0) (f : C(unitInterval,ℝ)) : ℝ := |
| min (2*M) (2*(L:ℝ)*‖f‖) |
|
|
| lemma freezeGauge_continuous (M : ℝ) (L : ℝ≥0) : Continuous (freezeGauge M L) := by |
| unfold freezeGauge |
| fun_prop |
|
|
| lemma freezeGauge_nonneg {M : ℝ} (hM : 0 ≤ M) (L : ℝ≥0) (f : C(unitInterval,ℝ)) : |
| 0 ≤ freezeGauge M L f := by unfold freezeGauge;positivity |
|
|
| lemma freezeGauge_abs_le {M : ℝ} (hM : 0 ≤ M) (L : ℝ≥0) (f : C(unitInterval,ℝ)) : |
| |freezeGauge M L f| ≤ 2*M := by |
| rw [abs_of_nonneg (freezeGauge_nonneg hM L f)] |
| exact min_le_left _ _ |
|
|
| lemma integral_reverse_freeze_bound {Ω : Type*} [MeasurableSpace Ω] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {e : Ω ≃ᵐ Ω} |
| (he : MeasurePreserving e μ μ) {X : Ω → C(unitInterval,ℝ)} |
| (hX : AEMeasurable X μ) (c : Ω → ℝ) |
| (hrev : ∀ ω u, X (e ω) u=c ω-X ω (unitInterval.symm u)) |
| {F : C(unitInterval,ℝ) → ℝ} {M : ℝ} {L : ℝ≥0} |
| (hFM : ∀ f, |F f| ≤ M) (hF : LipschitzWith L F) (t : unitInterval) : |
| |(∫ ω, F (X ω) ∂μ)-(∫ ω, F (stopPath t (X ω)) ∂μ)| ≤ |
| ∫ ω, freezeGauge M L (stopPath (unitInterval.symm t) (X ω)) ∂μ := by |
| have hM : 0 ≤ M := (abs_nonneg (F 0)).trans (hFM 0) |
| have hi (Z : Ω → C(unitInterval,ℝ)) (hZ : AEMeasurable Z μ) : Integrable (fun ω => F (Z ω)) μ := |
| Integrable.of_bound (hF.continuous.measurable.comp_aemeasurable hZ).aestronglyMeasurable M |
| (ae_of_all μ (fun ω => hFM _)) |
| have hstop : AEMeasurable (fun ω => stopPath t (X ω)) μ := |
| (continuous_stopPath t).measurable.comp_aemeasurable hX |
| have hg : Integrable (fun ω => freezeGauge M L (stopPath (unitInterval.symm t) (X (e ω)))) μ := by |
| apply Integrable.of_bound _ (2*M) (ae_of_all μ (fun ω => freezeGauge_abs_le hM L _)) |
| exact ((freezeGauge_continuous M L).measurable.comp_aemeasurable |
| ((continuous_stopPath _).measurable.comp_aemeasurable |
| (hX.comp_quasiMeasurePreserving he.quasiMeasurePreserving))).aestronglyMeasurable |
| rw [← integral_sub (hi _ hX) (hi _ hstop)] |
| apply (show |∫ ω, F (X ω)-F (stopPath t (X ω)) ∂μ| ≤ |
| ∫ ω, |F (X ω)-F (stopPath t (X ω))| ∂μ by |
| simpa only [Real.norm_eq_abs] using norm_integral_le_integral_norm |
| (fun ω => F (X ω)-F (stopPath t (X ω)))).trans |
| calc |
| _ ≤ ∫ ω, freezeGauge M L (stopPath (unitInterval.symm t) (X (e ω))) ∂μ := by |
| apply integral_mono ((hi _ hX).sub (hi _ hstop)).norm hg |
| intro ω |
| change |F (X ω)-F (stopPath t (X ω))| ≤ |
| min (2*M) (2*(L:ℝ)*‖stopPath (unitInterval.symm t) (X (e ω))‖) |
| apply le_min |
| · linarith [abs_sub (F (X ω)) (F (stopPath t (X ω))),hFM (X ω),hFM (stopPath t (X ω))] |
| · have hb := dist_stop_reverse_le (X ω) (X (e ω)) (c ω) (hrev ω) t |
| have hl := hF.dist_le_mul (X ω) (stopPath t (X ω)) |
| rw [Real.dist_eq] at hl |
| calc |
| _ ≤ (L:ℝ)*dist (X ω) (stopPath t (X ω)) := hl |
| _ ≤ (L:ℝ)*(2*‖stopPath (unitInterval.symm t) (X (e ω))‖) := |
| mul_le_mul_of_nonneg_left hb L.coe_nonneg |
| _ = _ := by ring |
| _ = _ := he.integral_comp' (fun ω => freezeGauge M L (stopPath (unitInterval.symm t) (X ω))) |
|
|
| lemma early_gauge_integral_tendsto {Ω : Type*} [MeasurableSpace Ω] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {X : Ω → C(unitInterval,ℝ)} |
| (hX : AEMeasurable X μ) (hz : ∀ᵐ ω ∂μ, X ω 0=0) {M : ℝ} (hM : 0 ≤ M) (L : ℝ≥0) : |
| Tendsto (fun j => ∫ ω, freezeGauge M L (stopPath (earlyTime j) (X ω)) ∂μ) atTop (𝓝 0) := by |
| have hh := tendsto_integral_of_dominated_convergence (fun _ : Ω => 2*M) |
| (F := fun j ω => freezeGauge M L (stopPath (earlyTime j) (X ω))) (f := fun _ => 0) |
| (fun j => ((freezeGauge_continuous M L).measurable.comp_aemeasurable |
| ((continuous_stopPath _).measurable.comp_aemeasurable hX)).aestronglyMeasurable) |
| (integrable_const _) (fun j => ae_of_all μ (fun ω => freezeGauge_abs_le hM L _)) (by |
| filter_upwards [hz] with ω hω |
| have h := tendsto_const_nhds.min ((norm_stop_early_tendsto (X ω) hω).const_mul (2*(L:ℝ))) (f := fun _ : ℕ => 2*M) |
| simpa only [freezeGauge,mul_zero,min_eq_right (by positivity : 0 ≤ 2*M)] using h) |
| simpa only [integral_zero] using hh |
|
|
| lemma late_integral_tendsto {Ω : Type*} [MeasurableSpace Ω] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {X : Ω → C(unitInterval,ℝ)} |
| (hX : AEMeasurable X μ) {F : C(unitInterval,ℝ) → ℝ} (hF : Continuous F) |
| {M : ℝ} (hFM : ∀ f, |F f| ≤ M) : |
| Tendsto (fun j => ∫ ω, F (stopPath (unitInterval.symm (earlyTime j)) (X ω)) ∂μ) atTop |
| (𝓝 (∫ ω, F (X ω) ∂μ)) := by |
| exact tendsto_integral_of_dominated_convergence (fun _ : Ω => M) |
| (fun j => (hF.measurable.comp_aemeasurable |
| ((continuous_stopPath _).measurable.comp_aemeasurable hX)).aestronglyMeasurable) |
| (integrable_const _) (fun j => ae_of_all μ (fun ω => hFM _)) |
| (ae_of_all μ (fun ω => (hF.tendsto (X ω)).comp (stop_late_tendsto (X ω)))) |
|
|
| lemma CriticalEvenOffspring.iidWalk_reverse (p : CriticalEvenOffspring) (N : ℕ) |
| (d : Fin N → ℕ) (t : unitInterval) : |
| p.iidWalk N (reverseArray N d) t = |
| (∑ j : Fin N, p.standardStep (d j))/Real.sqrt N- |
| p.iidWalk N d (unitInterval.symm t) := by |
| unfold iidWalk |
| simp_rw [reverseArray_apply] |
| exact interpolation_increments_reverse N (fun j => p.standardStep (d j)) (Real.sqrt N) t |
|
|
| lemma CriticalEvenOffspring.bridge_reverse_preserving (p : CriticalEvenOffspring) (n : ℕ) : |
| MeasurePreserving (reverseArray (2*n+1)) (p.iidBridgeLaw n) (p.iidBridgeLaw n) := |
| reverseArray_cond_preserving p.law.toMeasure (2*n+1) (fun k => (k:ℤ)-1) (-1) |
|
|
| lemma bridgePath_zero_ae {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω} |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B ν) : |
| ∀ᵐ ω ∂ν, bridgePath B ω 0=0 := by |
| filter_upwards [bridgePath_ae_eq hB,hB.eval_zero_ae_eq_zero] with ω hω hz |
| rw [hω] |
| change B 0 ω-(0:ℝ)*B 1 ω=0 |
| simp [hz] |
|
|
| theorem CriticalEvenOffspring.bridge_integral_limit (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω} [IsProbabilityMeasure ν] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B ν) |
| {F : C(unitInterval,ℝ) → ℝ} {M : ℝ} {L : ℝ≥0} |
| (hFM : ∀ f, |F f| ≤ M) (hF : LipschitzWith L F) : |
| Tendsto (fun n => ∫ d, F (p.iidWalk (2*n+1) d) ∂p.iidBridgeLaw n) atTop |
| (𝓝 (∫ ω, F (bridgePath B ω) ∂ν)) := by |
| have hM : 0 ≤ M := (abs_nonneg (F 0)).trans (hFM 0) |
| let A : ℕ → ℝ := fun n => ∫ d, F (p.iidWalk (2*n+1) d) ∂p.iidBridgeLaw n |
| let S : ℕ → ℕ → ℝ := fun j n => ∫ d, |
| F (stopPath (unitInterval.symm (earlyTime j)) (p.iidWalk (2*n+1) d)) ∂p.iidBridgeLaw n |
| let b : ℝ := ∫ ω, F (bridgePath B ω) ∂ν |
| let a : ℕ → ℝ := fun j => ∫ ω, |
| F (stopPath (unitInterval.symm (earlyTime j)) (bridgePath B ω)) ∂ν |
| let R : ℕ → ℕ → ℝ := fun j n => ∫ d, |
| freezeGauge M L (stopPath (earlyTime j) (p.iidWalk (2*n+1) d)) ∂p.iidBridgeLaw n |
| let r : ℕ → ℝ := fun j => ∫ ω, |
| freezeGauge M L (stopPath (earlyTime j) (bridgePath B ω)) ∂ν |
| have hlate (j : ℕ) : ((unitInterval.symm (earlyTime j):unitInterval):ℝ)<1 := by |
| rw [unitInterval.coe_symm_eq] |
| linarith [earlyTime_pos j] |
| have hS (j : ℕ) : Tendsto (S j) atTop (𝓝 (a j)) := |
| p.stopped_bridge_integral_limit hB _ (hlate j) hFM hF |
| have hR (j : ℕ) : Tendsto (R j) atTop (𝓝 (r j)) := by |
| exact integral_tendsto_of_tendstoInDistribution (p.stopped_bridge_CLT hB _ (earlyTime_lt_one j)) |
| (freezeGauge_continuous M L) (freezeGauge_abs_le hM L) |
| have hr : Tendsto r atTop (𝓝 0) := |
| early_gauge_integral_tendsto (bridgePath_aemeasurable hB) (bridgePath_zero_ae hB) hM L |
| have ha : Tendsto a atTop (𝓝 b) := |
| late_integral_tendsto (bridgePath_aemeasurable hB) hF.continuous hFM |
| have he (j n : ℕ) : |A n-S j n| ≤ R j n := by |
| have hh := integral_reverse_freeze_bound (p.bridge_reverse_preserving n) |
| (p.iidWalk_measurable (2*n+1)).aemeasurable |
| (fun d => (∑ i : Fin (2*n+1), p.standardStep (d i))/Real.sqrt ((2*n+1:ℕ):ℝ)) |
| (p.iidWalk_reverse (2*n+1)) hFM hF (unitInterval.symm (earlyTime j)) |
| simpa only [unitInterval.symm_symm] using hh |
| change Tendsto A atTop (𝓝 b) |
| rw [Metric.tendsto_nhds] |
| intro ε hε |
| obtain ⟨j,hj,hja⟩ := ((Metric.tendsto_nhds.mp hr (ε/4) (by positivity)).and |
| (Metric.tendsto_nhds.mp ha (ε/4) (by positivity))).exists |
| rw [Real.dist_eq,sub_zero] at hj |
| rw [Real.dist_eq] at hja |
| have hSn := Metric.tendsto_nhds.mp (hS j) (ε/4) (by positivity) |
| have hRn := (hR j).eventually (eventually_lt_nhds (show r j < r j+ε/4 by linarith)) |
| filter_upwards [hSn,hRn] with n hn hnr |
| rw [Real.dist_eq] at hn ⊢ |
| have h₁ := abs_sub_le (A n) (S j n) b |
| have h₂ := abs_sub_le (S j n) (a j) b |
| have h₃ := he j n |
| linarith [le_abs_self (r j)] |
|
|
| theorem CriticalEvenOffspring.iidBridge_CLT (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {ν : Measure Ω} [IsProbabilityMeasure ν] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B ν) : |
| TendstoInDistribution (fun n => p.iidWalk (2*n+1)) atTop |
| (bridgePath B) p.iidBridgeLaw ν := by |
| have hX (n : ℕ) : AEMeasurable (p.iidWalk (2*n+1)) (p.iidBridgeLaw n) := |
| (p.iidWalk_measurable _).aemeasurable |
| have hY := bridgePath_aemeasurable hB |
| refine ⟨hX,hY,?_⟩ |
| apply tendsto_iff_forall_lipschitz_integral_tendsto.mpr |
| rintro F ⟨M,hM⟩ ⟨L,hL⟩ |
| change Tendsto (fun n => ∫ f, F f ∂(p.iidBridgeLaw n).map (p.iidWalk (2*n+1))) atTop |
| (𝓝 (∫ f, F f ∂ν.map (bridgePath B))) |
| simp_rw [integral_map (hX _) hL.continuous.aestronglyMeasurable, |
| integral_map hY hL.continuous.aestronglyMeasurable] |
| apply p.bridge_integral_limit hB (M := |F 0|+M) (L := L) _ hL |
| intro f |
| have hh := hM f 0 |
| rw [Real.dist_eq] at hh |
| linarith [abs_sub_abs_le_abs_sub (F f) (F 0)] |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
| end OAI |
|
|
