| import OAI.Probability.FKMaps.HeightBounds |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.TreeCoding |
|
|
| def codeEmbedding (N : ℕ) : Code N ↪ (Fin N → ℕ) := |
| ⟨fun d => bridgeEmbedding N ⟨d.val,d.property.1⟩, fun _ _ h => |
| Subtype.ext (congrArg (fun b : Bridge N => b.val) ((bridgeEmbedding N).injective h))⟩ |
|
|
| lemma CriticalEvenOffspring.code_probability_le_stream (p : CriticalEvenOffspring) (n : ℕ) |
| (E : Set (Code (2*n+1))) (A : Set (ℕ → ℕ)) |
| (hEA : ∀ d ∈ E, ∀ x, streamPrefix (2*n+1) x=codeEmbedding (2*n+1) d → x∈A) : |
| (p.codeLaw n).real E ≤ p.streamLaw.real A / codePartition p (2*n+1) := by |
| classical |
| let N := 2*n+1 |
| let C : Code N → Set (ℕ → ℕ) := fun d => if d∈E then |
| streamPrefix N ⁻¹' {codeEmbedding N d} else ∅ |
| have hm (d) : MeasurableSet (C d) := by |
| dsimp [C] |
| split_ifs |
| · exact (measurableSet_singleton _).preimage (measurable_streamPrefix N) |
| · exact MeasurableSet.empty |
| have hd : Pairwise (fun d e => Disjoint (C d) (C e)) := by |
| intro d e hde |
| dsimp [C] |
| split_ifs <;> try simp |
| exact (Set.disjoint_singleton.mpr ((codeEmbedding N).injective.ne hde)).preimage _ |
| have he (d : Code N) : p.streamLaw.real (C d) = if d∈E then codeWeight p d else 0 := by |
| dsimp [C] |
| split_ifs |
| · rw [(p.streamPrefix_hasLaw N).measurePreserving (measurable_streamPrefix N) |>.measureReal_preimage |
| (measurableSet_singleton _).nullMeasurableSet] |
| exact p.iid_bridge_singleton ⟨d.val,d.property.1⟩ |
| · simp |
| have hb : (∑ d : Code N, if d∈E then codeWeight p d else 0) ≤ p.streamLaw.real A := by |
| rw [← show p.streamLaw.real (⋃ d, C d)=∑ d : Code N, if d∈E then codeWeight p d else 0 by |
| rw [measureReal_iUnion_fintype hd hm]; simp only [he]] |
| apply measureReal_mono (h₂ := measure_ne_top _ _) |
| rintro x ⟨_,⟨d,rfl⟩,hx⟩ |
| dsimp [C] at hx |
| split_ifs at hx with hE |
| · exact hEA d hE x hx |
| · exact hx.elim |
| rw [← integral_indicator_one (μ := p.codeLaw n) (show MeasurableSet E from trivial),p.code_integral] |
| apply (le_div_iff₀ (codePartition_odd_pos p n)).mpr |
| have heq : (∑ d : Code (2*n+1), (codeWeight p d/codePartition p (2*n+1)) * |
| E.indicator (fun _ => (1:ℝ)) d)*codePartition p (2*n+1)= |
| ∑ d : Code (2*n+1), if d∈E then codeWeight p d else 0 := by |
| rw [Finset.sum_mul] |
| apply Finset.sum_congr rfl |
| intro d _ |
| dsimp [Set.indicator] |
| split_ifs |
| · field_simp [(codePartition_odd_pos p n).ne'] |
| · simp |
| change (∑ d : Code (2*n+1), (codeWeight p d/codePartition p (2*n+1)) * |
| E.indicator (fun _ => (1:ℝ)) d)*codePartition p (2*n+1) ≤ _ |
| rw [heq] |
| exact hb |
|
|
| lemma recordHeight_congr_prefix {S T : ℕ → ℤ} {N j : ℕ} (hj : j ≤ N) |
| (hST : ∀ k ≤ N, S k=T k) : recordHeight S 0 j=recordHeight T 0 j := by |
| unfold recordHeight |
| congr 1 |
| ext k |
| simp only [mem_reverseRecords] |
| constructor <;> rintro ⟨hk0,hkj,hk⟩ <;> refine ⟨hk0,hkj,?_⟩ <;> intro r hkr hrj |
| · rw [← hST k (by omega),← hST r (by omega)] |
| exact hk r hkr hrj |
| · rw [hST k (by omega),hST r (by omega)] |
| exact hk r hkr hrj |
|
|
| def codeHeightModulusFailure {N : ℕ} (m : ℕ) (c : ℝ) : Set (Code N) := |
| {d | ∃ a b, a ≤ b ∧ b ≤ N ∧ |
| (∀ u v, a ≤ u → u ≤ b → a ≤ v → v ≤ b → (walk d.val u:ℝ)-(walk d.val v:ℝ)<c) ∧ |
| ¬(height d.val b ≤ height d.val a+m ∧ height d.val a ≤ height d.val b+m)} |
|
|
| lemma codeHeightModulusFailure_stream {N m : ℕ} {c : ℝ} {d : Code N} |
| (hd : d∈codeHeightModulusFailure m c) {x : ℕ → ℕ} |
| (hx : streamPrefix N x=codeEmbedding N d) : x∈heightModulusFailure N m c := by |
| have hS (k : ℕ) (hk : k ≤ N) : integerSum x k=walk d.val k := by |
| rw [← integerSum_arrayStream_prefix N x hk,hx] |
| exact integerSum_arrayStream_bridge ⟨d.val,d.property.1⟩ hk |
| have hH (k : ℕ) (hk : k ≤ N) : recordHeight (integerSum x) 0 k=height d.val k := |
| (recordHeight_congr_prefix hk hS).trans (height_eq_recordHeight d.val hk).symm |
| obtain ⟨a,b,hab,hb,hosc,hbad⟩ := hd |
| refine ⟨a,b,hab,hb,?_,?_⟩ |
| · intro u v hau hub hav hvb |
| rw [hS u (by omega),hS v (by omega)] |
| exact hosc u v hau hub hav hvb |
| · simpa only [hH b hb,hH a (hab.trans hb)] using hbad |
|
|
| lemma CriticalEvenOffspring.code_height_modulus_bound (p : CriticalEvenOffspring) : |
| ∃ c ρ : ℝ, 0<c ∧ 0<ρ ∧ ρ<1 ∧ ∀ n m : ℕ, |
| (p.codeLaw n).real (codeHeightModulusFailure m (c*m)) ≤ |
| ((2*n+1:ℕ)+1:ℝ)*ρ^m/codePartition p (2*n+1) := by |
| obtain ⟨c,ρ,hc,hr0,hr1,hb⟩ := p.height_modulus_probability |
| refine ⟨c,ρ,hc,hr0,hr1,fun n m => ?_⟩ |
| apply (p.code_probability_le_stream n _ _ (fun _ hd _ hx => codeHeightModulusFailure_stream hd hx)).trans |
| apply div_le_div_of_nonneg_right _ (codePartition_nonneg p _) |
| have hnn : 0 ≤ ((2*n+1:ℕ)+1:ℝ)*ρ^m := by positivity |
| have hh' : p.streamLaw (heightModulusFailure (2*n+1) m (c*m)) ≤ |
| ENNReal.ofReal (((2*n+1:ℕ)+1:ℝ)*ρ^m) := by |
| rw [ENNReal.ofReal_mul (by positivity : 0 ≤ ((2*n+1:ℕ)+1:ℝ)), |
| show ((2*n+1:ℕ):ℝ)+1=((2*n+1+1:ℕ):ℝ) by push_cast; rfl, |
| ENNReal.ofReal_natCast] |
| exact hb (2*n+1) m |
| have hh := ENNReal.toReal_mono ENNReal.ofReal_ne_top hh' |
| simpa only [measureReal_def,ENNReal.toReal_ofReal hnn] using hh |
|
|
| lemma CriticalEvenOffspring.code_geometric_vanish (p : CriticalEvenOffspring) |
| {ε ρ : ℝ} (hε : 0<ε) (hρ : 0 ≤ ρ) (hρ1 : ρ<1) : |
| Tendsto (fun n => ((2*n+1:ℕ)+1:ℝ)*ρ^⌈ε*Real.sqrt ((2*n+1:ℕ):ℝ)⌉₊ / |
| codePartition p (2*n+1)) atTop (𝓝 0) := by |
| let s : ℕ → ℝ := fun n => Real.sqrt ((2*n+1:ℕ):ℝ) |
| have hs0 (n) : 0 ≤ s n := Real.sqrt_nonneg _ |
| have h5 := polynomial_geometric_ceil odd_sqrt_tendsto hs0 hε hρ hρ1 5 |
| have h3 := polynomial_geometric_ceil odd_sqrt_tendsto hs0 hε hρ hρ1 3 |
| have hpos : 0 < 2/(p.sigma*Real.sqrt (2*Real.pi)) := |
| div_pos (by norm_num) (mul_pos p.sigma_pos (Real.sqrt_pos.mpr (by positivity))) |
| have ht := (h5.add h3).div p.codePartition_asymptotic hpos.ne' |
| simp only [zero_add,zero_div] at ht |
| convert ht using 1 |
| funext n |
| have hs : s n^2=((2*n+1:ℕ):ℝ) := Real.sq_sqrt (by positivity) |
| have hsne : s n≠0 := (Real.sqrt_pos.mpr (by positivity : (0:ℝ)<((2*n+1:ℕ):ℝ))).ne' |
| dsimp only [Pi.div_apply] |
| rw [show (2*n+1:ℝ)=((2*n+1:ℕ):ℝ) by push_cast; rfl] |
| change (((2*n+1:ℕ):ℝ)+1)*ρ^⌈ε*s n⌉₊/codePartition p (2*n+1)= |
| ((s n)^5*ρ^⌈ε*s n⌉₊+(s n)^3*ρ^⌈ε*s n⌉₊)/ |
| (((2*n+1:ℕ):ℝ)*s n*codePartition p (2*n+1)) |
| have he : (s n)^5*ρ^⌈ε*s n⌉₊+(s n)^3*ρ^⌈ε*s n⌉₊ = |
| (((2*n+1:ℕ):ℝ)+1)*ρ^⌈ε*s n⌉₊ * (((2*n+1:ℕ):ℝ)*s n) := by |
| calc |
| _ = ((s n)^2+1)*ρ^⌈ε*s n⌉₊*((s n)^2*s n) := by ring |
| _ = _ := by rw [hs] |
| rw [he] |
| push_cast |
| rw [mul_comm _ (codePartition p (2*n+1)),mul_div_mul_right] |
| exact mul_ne_zero (by positivity) hsne |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.TreeCoding |
|
|
| abbrev ClosePairs (δ : ℝ) := {st : unitInterval × unitInterval // dist st.1 st.2 ≤ δ} |
|
|
| instance (δ : ℝ) : CompactSpace (ClosePairs δ) := |
| isCompact_iff_compactSpace.mp ((isClosed_le (continuous_fst.dist continuous_snd) continuous_const).isCompact) |
|
|
| def oscillationPath (δ : ℝ) (f : C(unitInterval,ℝ)) : C(ClosePairs δ,ℝ) := |
| ⟨fun st => f st.val.1-f st.val.2, by fun_prop⟩ |
|
|
| def pathOscillation (δ : ℝ) (f : C(unitInterval,ℝ)) : ℝ := ‖oscillationPath δ f‖ |
|
|
| lemma pathOscillation_nonneg (δ : ℝ) (f : C(unitInterval,ℝ)) : 0 ≤ pathOscillation δ f := norm_nonneg _ |
|
|
| lemma pathOscillation_le {δ M : ℝ} (hM : 0 ≤ M) (f : C(unitInterval,ℝ)) |
| (h : ∀ s t, dist s t ≤ δ → |f s-f t| ≤ M) : pathOscillation δ f ≤ M := by |
| apply (ContinuousMap.norm_le _ hM).mpr |
| intro st |
| exact h st.val.1 st.val.2 st.property |
|
|
| lemma sub_le_pathOscillation {δ : ℝ} (f : C(unitInterval,ℝ)) {s t : unitInterval} |
| (hst : dist s t ≤ δ) : |f s-f t| ≤ pathOscillation δ f := |
| (oscillationPath δ f).norm_coe_le_norm ⟨(s,t),hst⟩ |
|
|
| lemma pathOscillation_lipschitz (δ : ℝ) : LipschitzWith 2 (pathOscillation δ) := by |
| apply LipschitzWith.of_dist_le_mul |
| intro f g |
| apply (dist_norm_norm_le (oscillationPath δ f) (oscillationPath δ g)).trans |
| rw [dist_eq_norm] |
| apply (ContinuousMap.norm_le _ (by positivity)).mpr |
| intro st |
| change |(f st.val.1-f st.val.2)-(g st.val.1-g st.val.2)| ≤ (2:ℝ≥0)*‖f-g‖ |
| have h1 := (f-g).norm_coe_le_norm st.val.1 |
| have h2 := (f-g).norm_coe_le_norm st.val.2 |
| change |f st.val.1-g st.val.1| ≤ ‖f-g‖ at h1 |
| change |f st.val.2-g st.val.2| ≤ ‖f-g‖ at h2 |
| have ht := abs_sub ((f-g) st.val.1) ((f-g) st.val.2) |
| simp only [ContinuousMap.sub_apply] at ht |
| have he : (f st.val.1-f st.val.2)-(g st.val.1-g st.val.2)= |
| (f st.val.1-g st.val.1)-(f st.val.2-g st.val.2) := by ring |
| rw [he] |
| change _ ≤ 2*‖f-g‖ |
| linarith |
|
|
| lemma pathOscillation_vanish (f : C(unitInterval,ℝ)) : |
| Tendsto (fun j : ℕ => pathOscillation (1/(j+1:ℝ)) f) atTop (𝓝 0) := by |
| rw [Metric.tendsto_nhds] |
| intro ε hε |
| obtain ⟨δ,hδ,hd⟩ := Metric.uniformContinuous_iff.mp |
| (CompactSpace.uniformContinuous_of_continuous f.continuous) (ε/2) (by positivity) |
| have ht : Tendsto (fun j : ℕ => 1/(j+1:ℝ)) atTop (𝓝 0) := |
| tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds) |
| filter_upwards [ht.eventually (gt_mem_nhds hδ)] with j hj |
| rw [Real.dist_eq,sub_zero,abs_of_nonneg (pathOscillation_nonneg _ _)] |
| apply lt_of_le_of_lt (pathOscillation_le (by positivity : 0 ≤ ε/2) f ?_) (by linarith) |
| intro s t hst |
| exact (hd (hst.trans_lt hj)).le |
|
|
|
|
| local instance : MeasurableSpace C(unitInterval,ℝ) := borel _ |
| local instance : BorelSpace C(unitInterval,ℝ) := ⟨rfl⟩ |
|
|
| def oscillationGauge (δ ε : ℝ) (f : C(unitInterval,ℝ)) := min 1 (pathOscillation δ f/ε) |
|
|
| lemma oscillationGauge_continuous (δ ε : ℝ) : Continuous (oscillationGauge δ ε) := |
| continuous_const.min ((pathOscillation_lipschitz δ).continuous.div_const ε) |
|
|
| lemma oscillationGauge_nonneg (δ : ℝ) {ε : ℝ} (hε : 0 ≤ ε) (f : C(unitInterval,ℝ)) : |
| 0 ≤ oscillationGauge δ ε f := le_min (by norm_num) (div_nonneg (pathOscillation_nonneg _ _) hε) |
|
|
| lemma oscillationGauge_abs_le (δ : ℝ) {ε : ℝ} (hε : 0 ≤ ε) (f : C(unitInterval,ℝ)) : |
| |oscillationGauge δ ε f| ≤ 1 := by |
| rw [abs_of_nonneg (oscillationGauge_nonneg δ hε f)] |
| exact min_le_left _ _ |
|
|
| lemma oscillationGauge_integral_vanish {Ω : Type*} [MeasurableSpace Ω] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {X : Ω → C(unitInterval,ℝ)} |
| (hX : AEMeasurable X μ) {ε : ℝ} (hε : 0<ε) : |
| Tendsto (fun j : ℕ => ∫ ω, oscillationGauge (1/(j+1:ℝ)) ε (X ω) ∂μ) atTop (𝓝 0) := by |
| have hh := tendsto_integral_of_dominated_convergence (fun _ : Ω => (1:ℝ)) |
| (F := fun j ω => oscillationGauge (1/(j+1:ℝ)) ε (X ω)) (f := fun _=>0) |
| (fun j => ((oscillationGauge_continuous _ ε).measurable.comp_aemeasurable hX).aestronglyMeasurable) |
| (integrable_const _) (fun _ => ae_of_all μ (fun _ => oscillationGauge_abs_le _ hε.le _)) (by |
| apply ae_of_all |
| intro ω |
| have ht := tendsto_const_nhds.min ((pathOscillation_vanish (X ω)).div_const ε) |
| (f := fun _ : ℕ => (1:ℝ)) |
| simpa only [oscillationGauge,zero_div,min_eq_right (by norm_num : (0:ℝ) ≤ 1)] using ht) |
| simpa only [integral_zero] using hh |
|
|
| lemma oscillation_probability_le_gauge {Ω : Type*} [MeasurableSpace Ω] |
| {μ : Measure Ω} [IsProbabilityMeasure μ] {X : Ω → C(unitInterval,ℝ)} |
| (hX : Measurable X) (δ : ℝ) {ε : ℝ} (hε : 0<ε) : |
| μ.real {ω | ε<pathOscillation δ (X ω)} ≤ ∫ ω,oscillationGauge δ ε (X ω) ∂μ := by |
| have hg : Integrable (fun ω => oscillationGauge δ ε (X ω)) μ := |
| Integrable.of_bound ((oscillationGauge_continuous _ _).measurable.comp hX).aestronglyMeasurable 1 |
| (ae_of_all μ (fun _ => oscillationGauge_abs_le _ hε.le _)) |
| let E := {ω | ε<pathOscillation δ (X ω)} |
| have hE : MeasurableSet E := measurableSet_lt measurable_const ((pathOscillation_lipschitz δ).continuous.measurable.comp hX) |
| rw [← integral_indicator_one hE] |
| apply integral_mono ((integrable_const (1:ℝ)).indicator hE) hg |
| intro ω |
| by_cases hω : ω∈E |
| · rw [Set.indicator_of_mem hω] |
| exact le_min le_rfl ((le_div_iff₀ hε).mpr (by simpa using hω.le)) |
| · rw [Set.indicator_of_notMem hω] |
| exact oscillationGauge_nonneg δ hε.le _ |
|
|
| lemma continuousPath_modulus_tight {Ω : ℕ → Type*} {Ω' : Type*} |
| [∀ n, MeasurableSpace (Ω n)] [MeasurableSpace Ω'] |
| {μ : ∀ n, Measure (Ω n)} {ν : Measure Ω'} [∀ n, IsProbabilityMeasure (μ n)] [IsProbabilityMeasure ν] |
| {X : ∀ n, Ω n → C(unitInterval,ℝ)} {Y : Ω' → C(unitInterval,ℝ)} |
| (h : TendstoInDistribution X atTop Y μ ν) (hXm : ∀ n, Measurable (X n)) |
| {ε η : ℝ} (hε : 0<ε) (hη : 0<η) : |
| ∃ δ : ℝ, 0<δ ∧ ∀ᶠ n in atTop, |
| (μ n).real {ω | ε<pathOscillation δ (X n ω)} ≤ η := by |
| obtain ⟨j,hj⟩ := ((oscillationGauge_integral_vanish h.aemeasurable_limit hε).eventually |
| (gt_mem_nhds (half_pos hη))).exists |
| refine ⟨1/(j+1:ℝ),by positivity,?_⟩ |
| have ht := integral_tendsto_of_tendstoInDistribution h (oscillationGauge_continuous (1/(j+1:ℝ)) ε) |
| (oscillationGauge_abs_le _ hε.le) |
| filter_upwards [ht.eventually (gt_mem_nhds (hj.trans (half_lt_self hη)))] with n hn |
| exact (oscillation_probability_le_gauge (hXm n) _ hε).trans hn.le |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.TreeCoding |
|
|
| lemma height_pair_control {N m a b : ℕ} {c : ℝ} {d : Code N} |
| (hgood : d∉codeHeightModulusFailure m c) (hb : b ≤ N) |
| (hosc : ∀ u v, a ≤ u → u ≤ b → a ≤ v → v ≤ b → (walk d.val u:ℝ)-(walk d.val v:ℝ)<c) |
| {u v : ℕ} (hau : a ≤ u) (hub : u ≤ b) (hav : a ≤ v) (hvb : v ≤ b) : |
| |(height d.val u:ℝ)-(height d.val v:ℝ)| ≤ m := by |
| have hh {j k : ℕ} (hjk : j ≤ k) (haj : a ≤ j) (hkb : k ≤ b) : |
| height d.val k ≤ height d.val j+m ∧ height d.val j ≤ height d.val k+m := by |
| by_contra hn |
| exact hgood ⟨j,k,hjk,hkb.trans hb,fun s t hjs hsk hjt htk => |
| hosc s t (haj.trans hjs) (hsk.trans hkb) (haj.trans hjt) (htk.trans hkb),hn⟩ |
| obtain h₁|h₁ := le_total u v |
| · have hh' := hh h₁ hau hvb |
| have h2 : (height d.val v:ℝ) ≤ height d.val u+m := by exact_mod_cast hh'.1 |
| have h3 : (height d.val u:ℝ) ≤ height d.val v+m := by exact_mod_cast hh'.2 |
| exact abs_le.mpr ⟨by linarith,by linarith⟩ |
| · have hh' := hh h₁ hav hub |
| have h2 : (height d.val u:ℝ) ≤ height d.val v+m := by exact_mod_cast hh'.1 |
| have h3 : (height d.val v:ℝ) ≤ height d.val u+m := by exact_mod_cast hh'.2 |
| exact abs_le.mpr ⟨by linarith,by linarith⟩ |
|
|
| lemma error_le_error_add {w₁ w₂ h₁ h₂ ν a b : ℝ} (hν : 0 ≤ ν) |
| (hw : |w₁-w₂| ≤ a) (hh : |h₁-h₂| ≤ b) : |
| |w₁-ν*h₁| ≤ |w₂-ν*h₂|+a+ν*b := by |
| have he : w₁-ν*h₁=(w₂-ν*h₂)+(w₁-w₂)-ν*(h₁-h₂) := by ring |
| rw [he] |
| have ht := (abs_sub ((w₂-ν*h₂)+(w₁-w₂)) (ν*(h₁-h₂))).trans |
| (add_le_add (abs_add_le (w₂-ν*h₂) (w₁-w₂)) le_rfl) |
| rw [abs_mul,abs_of_nonneg hν] at ht |
| nlinarith |
|
|
| lemma badHeightFraction_interval_lower {N r a : ℕ} (har : a+r ≤ N) |
| {ν t : ℝ} (d : Code N) |
| (hbad : ∀ k<r, t< |(walk d.val (a+k):ℝ)-ν*height d.val (a+k)|) : |
| (r:ℝ)/(N:ℝ) ≤ badHeightFraction ν t d := by |
| classical |
| let f : Fin r → Fin N := fun k => ⟨a+k.val,by omega⟩ |
| let S := Finset.univ.filter (fun k : Fin N => t< |(walk d.val k.val:ℝ)-ν*height d.val k.val|) |
| have hm : ∀ k : Fin r, f k∈S := fun k => Finset.mem_filter.mpr ⟨Finset.mem_univ _,hbad k.val k.isLt⟩ |
| have hf : Function.Injective f := by |
| intro i j hij |
| have hh := congrArg Fin.val hij |
| dsimp [f] at hh |
| exact Fin.ext (by omega) |
| have hc : r ≤ S.card := by |
| have hh := Finset.card_le_card (show Finset.univ.image f ⊆ S by |
| intro k hk |
| obtain ⟨i,_,rfl⟩ := Finset.mem_image.mp hk |
| exact hm i) |
| simpa only [Finset.card_image_of_injective _ hf,Finset.card_univ,Fintype.card_fin] using hh |
| unfold badHeightFraction |
| apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg N) |
| rw [← Finset.sum_filter] |
| simpa only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_one] using (show (r:ℝ) ≤ S.card by exact_mod_cast hc) |
|
|
| lemma uniform_error_of_average {N m r : ℕ} {ν c a t : ℝ} (d : Code N) |
| (hν : 0 ≤ ν) (hr : r ≤ N) (hgood : d∉codeHeightModulusFailure m c) |
| (hosc : ∀ u v, u ≤ N → v ≤ N → (u:ℤ)-v ≤ r → (v:ℤ)-u ≤ r → |
| |(walk d.val u:ℝ)-(walk d.val v:ℝ)| ≤ a) |
| (hac : a<c) |
| (havg : badHeightFraction ν t d < (r:ℝ)/(N:ℝ)) : |
| ∀ j<N, |(walk d.val j:ℝ)-ν*height d.val j| ≤ t+a+ν*m := by |
| intro j hj |
| by_contra hn |
| have hjbad : t+a+ν*m< |(walk d.val j:ℝ)-ν*height d.val j| := lt_of_not_ge hn |
| let b := min j (N-r) |
| have hbj : b ≤ j := min_le_left _ _ |
| have hbr : b+r ≤ N := by have := min_le_right j (N-r); dsimp [b]; omega |
| have hjbr : j ≤ b+r := by dsimp [b]; omega |
| have hw (u v : ℕ) (hbu : b ≤ u) (hub : u ≤ b+r) (hbv : b ≤ v) (hvb : v ≤ b+r) : |
| |(walk d.val u:ℝ)-(walk d.val v:ℝ)| ≤ a := hosc u v (by omega) (by omega) (by omega) (by omega) |
| have hlocal : ∀ u v, b ≤ u → u ≤ b+r → b ≤ v → v ≤ b+r → |
| (walk d.val u:ℝ)-(walk d.val v:ℝ)<c := by |
| intro u v hbu hub hbv hvb |
| exact (le_abs_self _).trans_lt ((hw u v hbu hub hbv hvb).trans_lt hac) |
| have hfrac := badHeightFraction_interval_lower (ν := ν) (t := t) hbr d (fun k hk => ?_) |
| · exact (not_lt_of_ge hfrac) havg |
| have hH := height_pair_control hgood hbr hlocal hbj hjbr (by omega : b ≤ b+k) (by omega : b+k ≤ b+r) |
| have hW := hw j (b+k) hbj hjbr (by omega) (by omega) |
| have he := error_le_error_add hν hW hH |
| linarith |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
|
|
| 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⟩ |
|
|
| lemma CriticalEvenOffspring.codeWalk_converges (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P) : |
| TendstoInDistribution (fun n (d : Code (2*n+1)) => walkPolygon p.sigma d.val) atTop |
| (fun ω => vervaat (bridgePath B ω)) p.codeLaw P := by |
| have hX (n : ℕ) : AEMeasurable (fun d : Code (2*n+1) => walkPolygon p.sigma d.val) (p.codeLaw n) := |
| (measurable_of_countable _).aemeasurable |
| have hY := (p.iidVervaat_CLT hB).aemeasurable_limit |
| refine ⟨hX,hY,?_⟩ |
| apply ProbabilityMeasure.tendsto_iff_forall_integral_tendsto.mpr |
| intro F |
| change Tendsto (fun n => ∫ f,F f ∂(p.codeLaw n).map (fun d => walkPolygon p.sigma d.val)) atTop |
| (𝓝 (∫ f,F f ∂P.map (fun ω => vervaat (bridgePath B ω)))) |
| simp_rw [integral_map (hX _) F.continuous.aestronglyMeasurable, |
| integral_map hY F.continuous.aestronglyMeasurable,p.code_integral] |
| exact p.codeWalk_CLT hB F |
|
|
| lemma gridPoint_dist_le {N r u v : ℕ} (_hN : 0<N) (hu : u ≤ N) (hv : v ≤ N) |
| (huv : (u:ℤ)-v ≤ r) (hvu : (v:ℤ)-u ≤ r) : |
| dist (gridPoint N ⟨u,by omega⟩) (gridPoint N ⟨v,by omega⟩) ≤ (r:ℝ)/(N:ℝ) := by |
| change |(u:ℝ)/(N:ℝ)-(v:ℝ)/(N:ℝ)| ≤ (r:ℝ)/(N:ℝ) |
| rw [← sub_div,abs_div,abs_of_nonneg (Nat.cast_nonneg N : (0:ℝ) ≤ (N:ℝ))] |
| apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg N) |
| apply abs_le.mpr |
| constructor |
| · have hh : (v:ℝ)-(u:ℝ) ≤ r := by exact_mod_cast hvu |
| linarith |
| · exact_mod_cast huv |
|
|
| lemma walk_grid_oscillation {N r : ℕ} (hN : 0<N) {σ δ θ : ℝ} (hσ : 0<σ) |
| (d : Code N) (hr : (r:ℝ)/(N:ℝ) ≤ δ) |
| (hosc : pathOscillation δ (walkPolygon σ d.val) ≤ θ) : |
| ∀ u v, u ≤ N → v ≤ N → (u:ℤ)-v ≤ r → (v:ℤ)-u ≤ r → |
| |(walk d.val u:ℝ)-(walk d.val v:ℝ)| ≤ θ*(σ*Real.sqrt N) := by |
| intro u v hu hv huv hvu |
| have hp := (sub_le_pathOscillation (walkPolygon σ d.val) ((gridPoint_dist_le hN hu hv huv hvu).trans hr)).trans hosc |
| simp only [walkPolygon,interpolation_gridPoint hN] at hp |
| rw [← sub_div,abs_div,abs_of_pos (mul_pos hσ (Real.sqrt_pos.mpr (Nat.cast_pos.mpr hN)))] at hp |
| exact (div_le_iff₀ (mul_pos hσ (Real.sqrt_pos.mpr (Nat.cast_pos.mpr hN)))).mp hp |
|
|
| lemma floor_fraction_bounds {δ : ℝ} (hδ : 0<δ) (hδ1 : δ ≤ 1) {N : ℕ} (hN : 0<N) |
| (hlarge : 2 ≤ δ*N) : |
| ⌊δ*N⌋₊ ≤ N ∧ (⌊δ*N⌋₊:ℝ)/(N:ℝ) ≤ δ ∧ δ/2 ≤ (⌊δ*N⌋₊:ℝ)/(N:ℝ) := by |
| have hN0 : (0:ℝ)<N := Nat.cast_pos.mpr hN |
| have hfloor := Nat.floor_le (mul_nonneg hδ.le hN0.le) |
| have hfloor' := Nat.lt_floor_add_one (δ*N) |
| constructor |
| · exact_mod_cast hfloor.trans (mul_le_of_le_one_left hN0.le hδ1) |
| constructor |
| · exact (div_le_iff₀ hN0).mpr hfloor |
| · apply (le_div_iff₀ hN0).mpr |
| linarith |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
|
|
| 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⟩ |
|
|
| lemma CriticalEvenOffspring.bad_fraction_markov (p : CriticalEvenOffspring) (n : ℕ) (ν a : ℝ) |
| {t : ℝ} (ht : 0<t) : |
| (p.codeLaw n).real {d | t ≤ badHeightFraction ν a d} ≤ |
| (∫ d,badHeightFraction ν a d ∂p.codeLaw n)/t := by |
| apply (le_div_iff₀ ht).mpr |
| have hh := mul_meas_ge_le_integral_of_nonneg |
| (μ := p.codeLaw n) (f := badHeightFraction ν a) |
| (ae_of_all _ (fun d => badHeightFraction_nonneg ν a d)) (Integrable.of_finite) t |
| simpa only [mul_comm] using hh |
|
|
| /-- Exact conditioned critical finite-variance height/walk coupling, uniformly |
| at every depth-first vertex. Only the stated second moment is used. -/ |
| theorem CriticalEvenOffspring.uniform_height_error_limit (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P) {ε : ℝ} (hε : 0<ε) : |
| Tendsto (fun n => (p.codeLaw n).real {d | ∃ j<2*n+1, |
| ε*Real.sqrt ((2*n+1:ℕ):ℝ)< |(walk d.val j:ℝ)-(p.variance/2)*height d.val j|}) |
| atTop (𝓝 0) := by |
| obtain ⟨c,ρ,hc,hρ,hρ1,hmod⟩ := p.code_height_modulus_bound |
| let ν := p.variance/2 |
| have hν : 0<ν := half_pos p.variance_pos |
| let κ := ε/(8*ν) |
| have hκ : 0<κ := div_pos hε (by positivity) |
| have hκeq : ν*κ=ε/8 := by dsimp [κ]; field_simp |
| let θ := min (ε/(4*p.sigma)) (c*κ/(2*p.sigma)) |
| have hσ := p.sigma_pos |
| have hθ : 0<θ := lt_min (div_pos hε (by positivity)) (div_pos (mul_pos hc hκ) (by positivity)) |
| have hθε : θ*p.sigma ≤ ε/4 := by |
| calc |
| _ ≤ (ε/(4*p.sigma))*p.sigma := mul_le_mul_of_nonneg_right (min_le_left _ _) hσ.le |
| _ = _ := by field_simp |
| have hθc : θ*p.sigma ≤ c*κ/2 := by |
| calc |
| _ ≤ (c*κ/(2*p.sigma))*p.sigma := mul_le_mul_of_nonneg_right (min_le_right _ _) hσ.le |
| _ = _ := by field_simp |
| have hgeo := p.code_geometric_vanish hκ hρ.le hρ1 |
| apply tendsto_order.2 |
| constructor |
| · intro a ha |
| exact Eventually.of_forall fun _ => ha.trans_le measureReal_nonneg |
| intro η hη |
| obtain ⟨δ₀,hδ₀,hwalk⟩ := continuousPath_modulus_tight (p.codeWalk_converges hB) |
| (fun _ => measurable_of_countable _) hθ (by positivity : 0<η/3) |
| let δ := min δ₀ 1 |
| have hδ : 0<δ := lt_min hδ₀ (by norm_num) |
| have hδ1 : δ ≤ 1 := min_le_right _ _ |
| have hδδ₀ : δ ≤ δ₀ := min_le_left _ _ |
| have hmean := (p.average_height_error_limit (by positivity : 0<ε/4)).div_const (δ/2) |
| simp only [zero_div] at hmean |
| have hlargeν : ∀ᶠ n in atTop, ν ≤ ε/8*Real.sqrt ((2*n+1:ℕ):ℝ) := |
| (odd_sqrt_tendsto.const_mul_atTop (by positivity : 0<ε/8)).eventually_ge_atTop ν |
| have hlarger : ∀ᶠ n in atTop, 2 ≤ δ*((2*n+1:ℕ):ℝ) := |
| ((tendsto_natCast_atTop_atTop.comp odd_size_tendsto).const_mul_atTop hδ).eventually_ge_atTop 2 |
| filter_upwards [hwalk,hlargeν,hlarger, |
| hgeo.eventually (gt_mem_nhds (by positivity : (0:ℝ)<η/3)), |
| hmean.eventually (gt_mem_nhds (by positivity : (0:ℝ)<η/3))] with n hwn hνn hrn hgn han |
| let N := 2*n+1 |
| let s := Real.sqrt (N:ℝ) |
| let m := ⌈κ*s⌉₊ |
| let r := ⌊δ*N⌋₊ |
| have hN : 0<N := by dsimp [N]; omega |
| have hs : 0<s := Real.sqrt_pos.mpr (Nat.cast_pos.mpr hN) |
| have hmν : ν*m ≤ ε/4*s := by |
| have hm := (Nat.ceil_lt_add_one (mul_nonneg hκ.le hs.le)).le |
| have hh := mul_le_mul_of_nonneg_left hm hν.le |
| have he := congrArg (fun t : ℝ => t*s) hκeq |
| change ν ≤ ε/8*s at hνn |
| dsimp [m] |
| nlinarith |
| have hcm : θ*(p.sigma*s)<c*m := by |
| have hm : κ*s ≤ (m:ℝ) := Nat.le_ceil _ |
| have hh := mul_le_mul_of_nonneg_left hm hc.le |
| have hth := mul_le_mul_of_nonneg_right hθc hs.le |
| have hcs : 0<c*κ*s := by positivity |
| nlinarith |
| have hθεs : θ*(p.sigma*s) ≤ ε/4*s := by nlinarith [mul_le_mul_of_nonneg_right hθε hs.le] |
| have hr := floor_fraction_bounds hδ hδ1 hN hrn |
| let A := {d : Code N | θ<pathOscillation δ₀ (walkPolygon p.sigma d.val)} |
| let C := codeHeightModulusFailure m (c*m) (N := N) |
| let D := {d : Code N | δ/2 ≤ badHeightFraction ν (ε/4*s) d} |
| have hsub : {d : Code N | ∃ j<N, ε*s< |(walk d.val j:ℝ)-ν*height d.val j|} ⊆ (A ∪ C) ∪ D := by |
| intro d hd |
| by_contra hn |
| have hh : ¬d∈A ∧ ¬d∈C ∧ ¬d∈D := by simpa only [Set.mem_union,not_or,and_assoc] using hn |
| have hw : pathOscillation δ₀ (walkPolygon p.sigma d.val) ≤ θ := not_lt.mp hh.1 |
| have havg : badHeightFraction ν (ε/4*s) d < (r:ℝ)/(N:ℝ) := |
| (lt_of_not_ge hh.2.2).trans_le hr.2.2 |
| have hu := uniform_error_of_average d hν.le hr.1 hh.2.1 |
| (walk_grid_oscillation hN p.sigma_pos d (hr.2.1.trans hδδ₀) hw) hcm havg |
| obtain ⟨j,hj,hjbad⟩ := hd |
| have hjle := hu j hj |
| linarith |
| have hb := (measureReal_mono (μ := p.codeLaw n) hsub (measure_ne_top _ _)).trans |
| ((measureReal_union_le (A ∪ C) D).trans (add_le_add (measureReal_union_le A C) le_rfl)) |
| have hA : (p.codeLaw n).real A ≤ η/3 := hwn |
| have hC : (p.codeLaw n).real C < η/3 := (hmod n m).trans_lt hgn |
| have hD : (p.codeLaw n).real D < η/3 := |
| (p.bad_fraction_markov n ν (ε/4*s) (half_pos hδ)).trans_lt han |
| exact hb.trans_lt (by linarith) |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
|
|
| 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⟩ |
| local instance : MeasurableSpace C(unitInterval,ℝ×ℝ) := borel _ |
| local instance : BorelSpace C(unitInterval,ℝ×ℝ) := ⟨rfl⟩ |
|
|
| /-- Converging together with varying sample spaces and actual probability laws. -/ |
| theorem tendstoInDistribution_of_close {E Ω' : Type*} {Ω : ℕ → Type*} |
| [PseudoMetricSpace E] [MeasurableSpace E] [BorelSpace E] [SecondCountableTopology E] |
| [∀ n, MeasurableSpace (Ω n)] [MeasurableSpace Ω'] |
| {μ : ∀ n, Measure (Ω n)} {ν : Measure Ω'} [∀ n, IsProbabilityMeasure (μ n)] |
| [IsProbabilityMeasure ν] {X Y : ∀ n, Ω n → E} {Z : Ω' → E} |
| (hXZ : TendstoInDistribution X atTop Z μ ν) |
| (hY : ∀ n, AEMeasurable (Y n) (μ n)) |
| (hclose : ∀ ε>0, Tendsto (fun n => (μ n).real {ω | ε < dist (X n ω) (Y n ω)}) atTop (𝓝 0)) : |
| TendstoInDistribution Y atTop Z μ ν := by |
| refine ⟨hY,hXZ.aemeasurable_limit,?_⟩ |
| apply tendsto_iff_forall_lipschitz_integral_tendsto.mpr |
| rintro F ⟨M,hM⟩ ⟨L,hL⟩ |
| have hZ := hXZ.aemeasurable_limit |
| have hmid := tendsto_iff_forall_lipschitz_integral_tendsto.mp hXZ.tendsto F ⟨M,hM⟩ ⟨L,hL⟩ |
| change Tendsto (fun n => ∫ x,F x ∂(μ n).map (Y n)) atTop (𝓝 (∫ x,F x ∂ν.map Z)) |
| change Tendsto (fun n => ∫ x,F x ∂(μ n).map (X n)) atTop (𝓝 (∫ x,F x ∂ν.map Z)) at hmid |
| simp_rw [integral_map (hY _) hL.continuous.aestronglyMeasurable, |
| integral_map hZ hL.continuous.aestronglyMeasurable] |
| simp_rw [integral_map (hXZ.forall_aemeasurable _) hL.continuous.aestronglyMeasurable, |
| integral_map hZ hL.continuous.aestronglyMeasurable] at hmid |
| have hM0 : 0≤M := by |
| obtain ⟨ω⟩ := nonempty_of_isProbabilityMeasure ν |
| simpa using hM (Z ω) (Z ω) |
| rw [Metric.tendsto_nhds] |
| intro ε hε |
| let δ := ε/(4*((L:ℝ)+1)) |
| have hδ : 0<δ := by dsimp [δ]; positivity |
| have hLd : (L:ℝ)*δ ≤ ε/4 := by |
| dsimp [δ]; rw [← mul_div_assoc,div_le_iff₀ (by positivity : 0<4*((L:ℝ)+1))] |
| nlinarith [L.coe_nonneg] |
| have htail := (hclose (δ/2) (half_pos hδ)).const_mul M |
| simp only [mul_zero] at htail |
| filter_upwards [htail.eventually (gt_mem_nhds (by positivity : (0:ℝ)<ε/4)), |
| (Metric.tendsto_nhds.mp hmid) (ε/4) (by positivity)] with n hn hnmid |
| have he := integral_lipschitz_approx_bound (hY n) (hXZ.forall_aemeasurable n) hM hL hδ.le |
| have hs : (μ n).real {ω | δ ≤ dist (Y n ω) (X n ω)} ≤ |
| (μ n).real {ω | δ/2 < dist (X n ω) (Y n ω)} := by |
| apply measureReal_mono _ (measure_ne_top _ _) |
| intro ω hω |
| change δ ≤ dist (Y n ω) (X n ω) at hω |
| change δ/2 < dist (X n ω) (Y n ω) |
| rw [dist_comm] at hω |
| exact lt_of_lt_of_le (by linarith) hω |
| have hh := mul_le_mul_of_nonneg_left hs hM0 |
| have ht := abs_sub_le (∫ ω,F (Y n ω) ∂μ n) (∫ ω,F (X n ω) ∂μ n) (∫ ω,F (Z ω) ∂ν) |
| rw [Real.dist_eq] at hnmid ⊢ |
| linarith |
|
|
| def diagonalPath (f : C(unitInterval,ℝ)) : C(unitInterval,ℝ×ℝ) := f.prodMk f |
|
|
| lemma diagonalPath_lipschitz : LipschitzWith 1 diagonalPath := by |
| apply LipschitzWith.of_dist_le_mul |
| intro f g |
| simp only [NNReal.coe_one,one_mul] |
| apply (ContinuousMap.dist_le (dist_nonneg)).mpr |
| intro t |
| change max (dist (f t) (g t)) (dist (f t) (g t)) ≤ dist f g |
| simpa only [max_self] using ContinuousMap.dist_apply_le_dist (f := f) (g := g) t |
|
|
| lemma jointCode_close {N : ℕ} (hN : 0<N) (p : CriticalEvenOffspring) (d : Code N) |
| {ε : ℝ} (hε : 0≤ε) |
| (h : ∀ j≤N, |(walk d.val j:ℝ)-(p.variance/2)*height d.val j| ≤ ε*p.sigma*Real.sqrt N) : |
| dist (diagonalPath (walkPolygon p.sigma d.val)) (jointCode p.sigma d) ≤ ε := by |
| have hs := p.sigma_pos |
| have hsqrt : 0<Real.sqrt (N:ℝ) := Real.sqrt_pos.mpr (Nat.cast_pos.mpr hN) |
| have hsq : p.sigma^2=p.variance := Real.sq_sqrt p.variance_pos.le |
| have hb := interpolation_diff_bound N |
| (fun i => (walk d.val i.val:ℝ)/(p.sigma*Real.sqrt N)) |
| (fun i => p.sigma*height d.val i.val/(2*Real.sqrt N)) hε (fun i => ?_) |
| · apply (ContinuousMap.dist_le hε).mpr |
| intro t |
| change max (dist (walkPolygon p.sigma d.val t) (walkPolygon p.sigma d.val t)) |
| (dist (walkPolygon p.sigma d.val t) |
| (interpolation N (fun i => p.sigma*height d.val i.val/(2*Real.sqrt N)) t)) ≤ ε |
| rw [dist_self,max_eq_right (dist_nonneg)] |
| exact (ContinuousMap.dist_apply_le_dist t).trans (by simpa only [walkPolygon,dist_eq_norm] using hb) |
| have he : (walk d.val i.val:ℝ)/(p.sigma*Real.sqrt N)- |
| p.sigma*height d.val i.val/(2*Real.sqrt N) = |
| ((walk d.val i.val:ℝ)-(p.variance/2)*height d.val i.val)/(p.sigma*Real.sqrt N) := by |
| field_simp |
| nlinarith [congrArg (fun x : ℝ => x*(height d.val i.val:ℝ)) hsq] |
| rw [he,abs_div,abs_of_pos (mul_pos hs hsqrt)] |
| apply (div_le_iff₀ (mul_pos hs hsqrt)).mpr |
| simpa only [mul_assoc] using h i.val (Nat.le_of_lt_succ i.isLt) |
|
|
| lemma CriticalEvenOffspring.joint_diagonal_close (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P) {ε : ℝ} (hε : 0<ε) : |
| Tendsto (fun n => (p.codeLaw n).real {d | ε < |
| dist (diagonalPath (walkPolygon p.sigma d.val)) (jointCode p.sigma d)}) atTop (𝓝 0) := by |
| have hsmall := p.uniform_height_error_limit hB (mul_pos hε p.sigma_pos) |
| apply squeeze_zero' (Eventually.of_forall (fun _ => measureReal_nonneg)) _ hsmall |
| have hlarge : ∀ᶠ n in atTop, 1 ≤ (ε*p.sigma)*Real.sqrt ((2*n+1:ℕ):ℝ) := |
| (odd_sqrt_tendsto.const_mul_atTop (mul_pos hε p.sigma_pos)).eventually_ge_atTop 1 |
| filter_upwards [hlarge] with n hn |
| apply measureReal_mono _ (measure_ne_top _ _) |
| intro d hd |
| by_contra hh |
| have he : ∀ j<2*n+1, |(walk d.val j:ℝ)-(p.variance/2)*height d.val j| ≤ |
| (ε*p.sigma)*Real.sqrt ((2*n+1:ℕ):ℝ) := by simpa only [Set.mem_ofPred_eq,not_exists,not_and,not_lt] using hh |
| apply not_lt_of_ge (jointCode_close (by omega) p d hε.le (fun j hj => ?_)) hd |
| by_cases hj' : j<2*n+1 |
| · exact he j hj' |
| · have hjj : j=2*n+1 := by omega |
| subst j |
| simpa only [d.property.1,height_terminal,Nat.cast_zero,mul_zero,sub_zero,Int.cast_neg, |
| Int.cast_one,abs_neg,abs_one] using hn |
|
|
| /-- Full joint walk/height convergence to the same Vervaat bridge excursion. |
| Identification with the standard Bessel3 excursion uses its finite-dimensional laws. -/ |
| theorem CriticalEvenOffspring.jointCode_vervaat_CLT (p : CriticalEvenOffspring) |
| {Ω : Type*} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B P) : |
| TendstoInDistribution (fun n (d : Code (2*n+1)) => jointCode p.sigma d) atTop |
| (fun ω => diagonalPath (vervaat (bridgePath B ω))) p.codeLaw P := by |
| have hc := (p.codeWalk_converges hB).continuous_comp diagonalPath_lipschitz.continuous |
| exact tendstoInDistribution_of_close hc (fun _ => (measurable_of_countable _).aemeasurable) |
| (fun _ hε => p.joint_diagonal_close hB hε) |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
| end OAI |
|
|
