| import OAI.Probability.FKMaps.GHPBounds |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open List Set MeasureTheory ProbabilityTheory Filter |
| open scoped BigOperators ENNReal Topology |
| namespace FKCRT.Inventory |
| open FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
|
|
| / |
| def crtScale (P : Parameters) : ℝ := (actualOffspring P).sigma/(2*Real.sqrt 2*metricMean P) |
| lemma crtScale_pos (P : Parameters) : 0<crtScale P := |
| div_pos (actualOffspring P).sigma_pos (by have h := metricMean_pos P; positivity) |
|
|
| def edgeScale (P : Parameters) (n : ℕ) : ℝ := crtScale P/Real.sqrt ((n:ℝ)+1) |
| lemma edgeScale_pos (P : Parameters) (n : ℕ) : 0<edgeScale P n := |
| div_pos (crtScale_pos P) (Real.sqrt_pos.mpr (by positivity)) |
|
|
| def heightFactor (n : ℕ) : ℝ := Real.sqrt (1+1/(2*((n:ℝ)+1))) |
| lemma heightFactor_pos (n : ℕ) : 0<heightFactor n := Real.sqrt_pos.mpr (by positivity) |
| lemma heightFactor_tendsto : Tendsto heightFactor atTop (𝓝 1) := by |
| have hh : Tendsto (fun n : ℕ => 1/(2*((n:ℝ)+1))) atTop (𝓝 0) := |
| tendsto_const_nhds.div_atTop ((tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds).const_mul_atTop (by norm_num)) |
| have hs := ((tendsto_const_nhds.add hh (a := (1:ℝ))).sqrt) |
| change Tendsto (fun n : ℕ => Real.sqrt (1+1/(2*((n:ℝ)+1)))) atTop (𝓝 1) |
| simpa only [add_zero,Real.sqrt_one] using hs |
|
|
| lemma sqrt_size_ratio (n : ℕ) : |
| Real.sqrt ((2*(n+1)+1:ℕ):ℝ)=heightFactor n*Real.sqrt 2*Real.sqrt ((n:ℝ)+1) := by |
| have hn : 0 ≤ (n:ℝ)+1 := by positivity |
| have hh : 0 ≤ 1+1/(2*((n:ℝ)+1)) := by positivity |
| have h₁ := Real.sq_sqrt (show 0 ≤ ((2*(n+1)+1:ℕ):ℝ) by positivity) |
| have h₂ := Real.sq_sqrt hh |
| have h₃ := Real.sq_sqrt (show (0:ℝ) ≤ 2 by norm_num) |
| have h₄ := Real.sq_sqrt hn |
| have he : (heightFactor n*Real.sqrt 2*Real.sqrt ((n:ℝ)+1))^2=((2*(n+1)+1:ℕ):ℝ) := by |
| rw [mul_pow,mul_pow,h₃,h₄] |
| change (Real.sqrt (1+1/(2*((n:ℝ)+1))))^2*2*((n:ℝ)+1)=_ |
| rw [h₂] |
| push_cast |
| field_simp |
| nlinarith [Real.sqrt_nonneg ((2*(n+1)+1:ℕ):ℝ),show 0 ≤ heightFactor n*Real.sqrt 2*Real.sqrt ((n:ℝ)+1) by |
| exact mul_nonneg (mul_nonneg (heightFactor_pos n).le (Real.sqrt_nonneg 2)) (Real.sqrt_nonneg _)] |
|
|
| lemma edgeScale_heightFactor (P : Parameters) (n : ℕ) : |
| edgeScale P n*metricMean P*2*Real.sqrt ((2*(n+1)+1:ℕ):ℝ)/(actualOffspring P).sigma=heightFactor n := by |
| rw [sqrt_size_ratio] |
| have hσ := (actualOffspring P).sigma_pos |
| have hβ := metricMean_pos P |
| have h₂ : 0<Real.sqrt (2:ℝ) := Real.sqrt_pos.mpr (by norm_num) |
| have hn : 0<Real.sqrt ((n:ℝ)+1) := Real.sqrt_pos.mpr (by positivity) |
| unfold edgeScale crtScale |
| field_simp |
|
|
| lemma edgeScale_sqrt_size_tendsto (P : Parameters) : |
| Tendsto (fun n => edgeScale P n*Real.sqrt ((2*(n+1)+1:ℕ):ℝ)) atTop |
| (𝓝 ((actualOffspring P).sigma/(2*metricMean P))) := by |
| have he (n : ℕ) : edgeScale P n*Real.sqrt ((2*(n+1)+1:ℕ):ℝ)= |
| heightFactor n*((actualOffspring P).sigma/(2*metricMean P)) := by |
| have h := edgeScale_heightFactor P n |
| have hσ := (actualOffspring P).sigma_pos |
| have hβ := metricMean_pos P |
| field_simp at h ⊢ |
| nlinarith |
| simp_rw [he] |
| simpa only [one_mul] using heightFactor_tendsto.mul_const ((actualOffspring P).sigma/(2*metricMean P)) |
|
|
| end FKCRT.Inventory |
| end |
|
|
|
|
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
|
|
| lemma distribution_smul_one {E Ω' : Type*} {Ω : ℕ → Type*} |
| [NormedAddCommGroup E] [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] |
| [SecondCountableTopology E] [∀ n,MeasurableSpace (Ω n)] [MeasurableSpace Ω'] |
| {μ : ∀ n,Measure (Ω n)} {ν : Measure Ω'} [∀ n,IsProbabilityMeasure (μ n)] [IsProbabilityMeasure ν] |
| {X : ∀ n,Ω n → E} {Z : Ω' → E} (h : TendstoInDistribution X atTop Z μ ν) |
| (hm : ∀ n,Measurable (X n)) {a : ℕ → ℝ} (ha : Tendsto a atTop (𝓝 1)) : |
| TendstoInDistribution (fun n x => a n • X n x) atTop Z μ ν := by |
| apply tendstoInDistribution_of_close h (fun n => ((hm n).const_smul (a n)).aemeasurable) |
| intro ε hε |
| rw [Metric.tendsto_nhds] |
| intro η hη |
| obtain ⟨C,hC,hbound⟩ := distribution_norm_tight h hm (half_pos hη) |
| have ha' : Tendsto (fun n => |1-a n|) atTop (𝓝 0) := by |
| simpa only [sub_self,abs_zero] using (tendsto_const_nhds.sub ha (a := (1:ℝ))).abs |
| filter_upwards [hbound,ha'.eventually (gt_mem_nhds (div_pos hε hC))] with n hn hn' |
| rw [Real.dist_eq,sub_zero,abs_of_nonneg measureReal_nonneg] |
| apply lt_of_le_of_lt _ (half_lt_self hη) |
| apply le_trans _ hn |
| apply measureReal_mono _ (measure_ne_top _ _) |
| intro x hx |
| change C<‖X n x‖ |
| change ε<dist (X n x) (a n • X n x) at hx |
| rw [dist_eq_norm,show X n x-a n • X n x=(1-a n) • X n x by rw [sub_smul,one_smul], |
| norm_smul,Real.norm_eq_abs] at hx |
| by_contra hbad |
| have hh := mul_le_mul_of_nonneg_left (le_of_not_gt hbad) (abs_nonneg (1-a n)) |
| have hh' := (lt_div_iff₀ hC).mp hn' |
| linarith |
| |
| lemma CriticalEvenOffspring.markedCodeLaw_map_fst (p : CriticalEvenOffspring) |
| {A : Type*} [MeasurableSpace A] (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)] (n : ℕ) : |
| (p.markedCodeLaw κ n).map Prod.fst=p.codeLaw n := by |
| apply Measure.ext |
| intro E hE |
| rw [Measure.map_apply measurable_fst hE,← ofReal_measureReal,← ofReal_measureReal] |
| exact congrArg ENNReal.ofReal (p.markedCodeLaw_fst κ n E) |
| |
| local instance : MeasurableSpace C(unitInterval,ℝ) := borel _ |
| local instance : BorelSpace C(unitInterval,ℝ) := ⟨rfl⟩ |
| |
| lemma CriticalEvenOffspring.marked_height_CLT (p : CriticalEvenOffspring) |
| {A : Type*} [MeasurableSpace A] (κ : ℕ → Measure A) [∀ k,IsProbabilityMeasure (κ k)] |
| {Ω : Type} [MeasurableSpace Ω] {P : Measure Ω} [IsProbabilityMeasure P] |
| {B : Fin 3 → ℝ≥0 → Ω → ℝ} (hB : ∀ i,IsBrownianReal (B i) P) |
| (hI : iIndepFun (fun i ω t => B i t ω) P) : |
| TendstoInDistribution (fun n (x : Code (2*n+1) × (Fin (2*n+1) → A)) => heightCode p x.1) |
| atTop (excursionPath B) (p.markedCodeLaw κ) P := by |
| have hh := p.heightCode_CLT hB hI |
| refine ⟨fun n => ((measurable_of_countable (heightCode p)).comp measurable_fst).aemeasurable, |
| hh.aemeasurable_limit,?_⟩ |
| have hmap (n : ℕ) : (p.markedCodeLaw κ n).map (fun x => heightCode p x.1)= |
| (p.codeLaw n).map (heightCode p) := by |
| change (p.markedCodeLaw κ n).map (heightCode p ∘ Prod.fst)=_ |
| rw [← Measure.map_map (measurable_of_countable _) measurable_fst,p.markedCodeLaw_map_fst] |
| simpa only [hmap] using hh.tendsto |
| |
| end FKCRT.TreeCoding |
| namespace FKCRT.Inventory |
| open FKCRT.TreeCoding |
| local instance : MeasurableSpace C(unitInterval,ℝ) := borel _ |
| local instance : BorelSpace C(unitInterval,ℝ) := ⟨rfl⟩ |
| |
| abbrev ActualDraw (n : ℕ) := Code (2*(n+1)+1) × (Fin (2*(n+1)+1) → CoreLabel) |
| abbrev actualDrawLaw (P : Parameters) (n : ℕ) : Measure (ActualDraw n) := |
| (actualOffspring P).markedCodeLaw (fun k => (CoreLabel.markLaw P k).toMeasure) (n+1) |
| def actualHeight (P : Parameters) (n : ℕ) (x : ActualDraw n) : C(unitInterval,ℝ) := |
| heightFactor n • heightCode (actualOffspring P) x.1 |
| |
| /-- The exact original-edge normalization of the same sampled marked tree |
| has the standard (not rescaled) three-bridge excursion limit. -/ |
| theorem actualHeight_CLT (P : Parameters) |
| {Ω : Type} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ] |
| {B : Fin 3 → ℝ≥0 → Ω → ℝ} (hB : ∀ i,IsBrownianReal (B i) μ) |
| (hI : iIndepFun (fun i ω t => B i t ω) μ) : |
| TendstoInDistribution (actualHeight P) atTop (excursionPath B) (actualDrawLaw P) μ := by |
| have hh := (actualOffspring P).marked_height_CLT |
| (fun k => (CoreLabel.markLaw P k).toMeasure) hB hI |
| have hr : TendstoInDistribution |
| (fun n (x : ActualDraw n) => heightCode (actualOffspring P) x.1) atTop |
| (excursionPath B) (actualDrawLaw P) μ := |
| ⟨fun n => hh.forall_aemeasurable (n+1),hh.aemeasurable_limit, |
| hh.tendsto.comp (tendsto_add_atTop_nat 1)⟩ |
| exact distribution_smul_one hr (fun _ => measurable_of_countable _) heightFactor_tendsto |
| |
| end FKCRT.Inventory |
| end |
| |
| |
| noncomputable section |
| open Set Filter MeasureTheory ProbabilityTheory |
| open scoped Topology BigOperators ENNReal NNReal |
| namespace FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
| |
| /-- A compact-cover transfer lemma for varying discrete approximations. The |
| local hypothesis is deterministic; only the stated error events vanish in |
| probability. No independent coupling or random-cut independence is used. -/ |
| theorem local_probability_transfer {E Ω' : Type*} {Ω : ℕ → Type*} |
| [MetricSpace E] [CompleteSpace E] [SecondCountableTopology E] |
| [MeasurableSpace E] [BorelSpace E] |
| [∀ n,MeasurableSpace (Ω n)] [MeasurableSpace Ω'] |
| {μ : ∀ n,Measure (Ω n)} {ν : Measure Ω'} [∀ n,IsProbabilityMeasure (μ n)] [IsProbabilityMeasure ν] |
| {X : ∀ n,Ω n → E} {Z : Ω' → E} (h : TendstoInDistribution X atTop Z μ ν) |
| (hm : ∀ n,Measurable (X n)) (Y : ∀ n,Ω n → ℝ) (G : E → ℝ) |
| (Bad : ∀ n,ℝ → Set (Ω n)) |
| (hBad : ∀ a,0<a → Tendsto (fun n => (μ n).real (Bad n a)) atTop (𝓝 0)) |
| (hloc : ∀ ε,0<ε → ∀ f : E,∃ r : ℝ,0<r ∧ ∃ a : ℝ,0<a ∧ ∃ N : ℕ, |
| ∀ n≥N,∀ x : Ω n,dist (X n x) f<r → x∉Bad n a → |Y n x-G (X n x)| ≤ ε) : |
| ∀ ε,0<ε → Tendsto (fun n => (μ n).real {x | ε < |Y n x-G (X n x)|}) atTop (𝓝 0) := by |
| intro ε hε |
| rw [Metric.tendsto_nhds] |
| intro η hη |
| have : IsProbabilityMeasure (ν.map Z) := inferInstance |
| obtain ⟨K,hK,hKμ⟩ := isTightMeasureSet_iff_exists_isCompact_measure_compl_le.mp |
| (isTightMeasureSet_singleton (μ := ν.map Z)) (ENNReal.ofReal (η/4)) (ENNReal.ofReal_pos.mpr (by positivity)) |
| have hKμ' := hKμ (ν.map Z) (Set.mem_singleton _) |
| choose r hr a ha N hfit using hloc ε hε |
| obtain ⟨S,hSK,hS,hcover⟩ := hK.elim_finite_subcover_image |
| (fun f (_ : f∈K) => Metric.isOpen_ball (x := f) (ε := r f)) (by |
| intro f hf |
| simp only [Set.mem_iUnion] |
| exact ⟨f,hf,Metric.mem_ball_self (hr f)⟩) |
| let I := hS.toFinset |
| let O : Set E := ⋃ f∈I,Metric.ball f (r f) |
| have hO : IsOpen O := isOpen_iUnion (fun f => isOpen_iUnion (fun _ => Metric.isOpen_ball)) |
| have hKO : K⊆O := by simpa only [O,I,Set.Finite.mem_toFinset] using hcover |
| have hclosed := ProbabilityMeasure.limsup_measure_closed_le_of_tendsto h.tendsto hO.isClosed_compl |
| have hlim : limsup (fun n => (μ n) ((X n) ⁻¹' Oᶜ)) atTop≤ENNReal.ofReal (η/4) := by |
| simpa only [ProbabilityMeasure.coe_mk,Measure.map_apply (hm _) hO.measurableSet.compl] using |
| hclosed.trans ((measure_mono (Set.compl_subset_compl.mpr hKO)).trans hKμ') |
| have hev : ∀ᶠ n in atTop,(μ n).real ((X n) ⁻¹' Oᶜ)<η/2 := by |
| have hh : ∀ᶠ n in atTop,(μ n) ((X n) ⁻¹' Oᶜ)<ENNReal.ofReal (η/2) := |
| eventually_lt_of_limsup_lt (hlim.trans_lt ((ENNReal.ofReal_lt_ofReal_iff (half_pos hη)).mpr (by linarith))) |
| filter_upwards [hh] with n hn |
| rw [← ofReal_measureReal] at hn |
| exact (ENNReal.ofReal_lt_ofReal_iff (by positivity)).mp hn |
| have hsum : Tendsto (fun n => ∑ f∈I,(μ n).real (Bad n (a f))) atTop (𝓝 0) := by |
| simpa only [Finset.sum_const_zero] using tendsto_finsetSum I (fun f _ => hBad (a f) (ha f)) |
| have hN : ∀ᶠ n in atTop,∀ f∈I,N f≤n := by |
| exact (eventually_all_finset I).mpr (fun f _ => eventually_ge_atTop (N f)) |
| filter_upwards [hev,hsum.eventually (gt_mem_nhds (half_pos hη)),hN] with n hn hn' hNn |
| rw [Real.dist_eq,sub_zero,abs_of_nonneg measureReal_nonneg] |
| have hs : {x | ε < |Y n x-G (X n x)|}⊆(X n) ⁻¹' Oᶜ ∪ ⋃ f∈I,Bad n (a f) := by |
| intro x hx |
| by_cases hxO : X n x∈O |
| · right |
| obtain ⟨f,hf,hxf⟩ := Set.mem_iUnion₂.mp hxO |
| apply Set.mem_iUnion₂.mpr |
| refine ⟨f,hf,?_⟩ |
| by_contra hbad |
| exact not_lt_of_ge (hfit f n (hNn f hf) x hxf hbad) hx |
| · exact Or.inl hxO |
| have hh := (measureReal_mono (μ := μ n) hs (measure_ne_top _ _)).trans |
| ((measureReal_union_le _ _).trans |
| (add_le_add le_rfl (measureReal_biUnion_finset_le I (fun f => Bad n (a f))))) |
| linarith |
|
|
| end FKCRT.TreeCoding |
| end |
|
|
|
|
| noncomputable section |
| open List Set MeasureTheory ProbabilityTheory Filter |
| open scoped BigOperators ENNReal Topology NNReal |
| namespace FKCRT.Inventory.CoreTree |
| open FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
|
|
| / |
| this avoids presuming a triangle inequality for the presentation distance. -/ |
| theorem marked_nearby_ghp_bound (P : Parameters) (n : ℕ) |
| (x : MarkedCode (2*(n+1)+1)) (f : C(unitInterval,ℝ)) (a r η δ : ℝ) (hδ : 0<δ) |
| (herr : ∀ j : Fin (2*(n+1)+1), |
| |markedSpineSum coreIncrement x.val.1 j.isLt.le x.val.2-metricMean P*height x.val.1.val j.val| ≤ |
| a*Real.sqrt ((2*(n+1)+1:ℕ):ℝ)) |
| (hprox : dist (actualHeight P n x.val) f ≤ r) |
| (hmod : ∀ s u,dist s u ≤ 1/(2*((n:ℝ)+1)) → |f s-f u| ≤ η) |
| (hsmall : 4*edgeScale P n*((ofMarkedCode x).maxDegree:ℝ)+ |
| 4*(edgeScale P n*a*Real.sqrt ((2*(n+1)+1:ℕ):ℝ)+r)+4*η ≤ 2*δ) : |
| FKCRT.ghpEDist (FKCRT.treeSpace f) |
| (FKCRT.mapSpace (edgeScale P n) ((FKCRT.rootedWordEquiv n).symm |
| ((successfulMarkedEquiv n).symm x)).1) ≤ ENNReal.ofReal δ := by |
| let t := ofMarkedCode x |
| have hsize := ofMarkedCode_size x |
| have hw := ofMarkedCode_word_successful n x |
| have hlen : t.word.length=2*(n+1) := by rw [hw,List.length_ofFn] |
| have he : ∀ v : t.Node,|(t.routeLength v:ℝ)-metricMean P*t.depth v| ≤ a*Real.sqrt t.labels.length := by |
| rw [hsize] |
| exact marked_route_error x _ _ herr |
| have hpath : ((edgeScale P n*metricMean P*2*Real.sqrt t.labels.length/(actualOffspring P).sigma) • |
| heightCode (actualOffspring P) t.toCode)=actualHeight P n x.val := by |
| simp only [t,hsize,marked_heightCode,edgeScale_heightFactor,actualHeight] |
| have hfit := t.route_heightCode_fit (actualOffspring P) (metricMean P) (edgeScale P n) a |
| (edgeScale_pos P n).le he |
| rw [hpath] at hfit |
| have hb : ∀ v : t.Node,|edgeScale P n*(t.routeLength v:ℝ)-f (t.nodePoint v)| ≤ |
| edgeScale P n*a*Real.sqrt t.labels.length+r := by |
| intro v |
| have hp := (ContinuousMap.dist_apply_le_dist (f := actualHeight P n x.val) (g := f) (t.nodePoint v)).trans hprox |
| rw [Real.dist_eq] at hp |
| exact (abs_sub_le _ _ _).trans (add_le_add (hfit v) hp) |
| obtain ⟨e,he',hp⟩ := t.realized_intertwine _ hw |
| apply t.ghp_tree_map_bound _ e (by omega) he' hp hlen f (edgeScale_pos P n) hδ hb |
| · intro s u hsu |
| apply hmod s u |
| simpa only [hlen,Nat.cast_mul,Nat.cast_ofNat,Nat.cast_add,Nat.cast_one] using hsu |
| · simpa only [t,hsize] using hsmall |
|
|
| end FKCRT.Inventory.CoreTree |
| namespace FKCRT.Inventory |
| open FKCRT.TreeCoding |
| attribute [local instance] Classical.propDecidable |
|
|
| / |
| comparison: impossible marks (a null set), a macroscopic core, and a large |
| uniform ancestral distance error. -/ |
| def metricBad (P : Parameters) (n : ℕ) (a : ℝ) : Set (ActualDraw n) := |
| {x | ¬∀ i,(x.2 i).arity=(x.1.val i).val} ∪ |
| {x | ∃ h : ∀ i,(x.2 i).arity=(x.1.val i).val, |
| a*Real.sqrt ((2*(n+1)+1:ℕ):ℝ)<((CoreTree.ofMarkedCode ⟨x,h⟩).maxDegree:ℝ)} ∪ |
| {x | ∃ j : Fin (2*(n+1)+1),a*Real.sqrt ((2*(n+1)+1:ℕ):ℝ) < |
| |markedSpineSum coreIncrement x.1 j.isLt.le x.2-metricMean P*height x.1.val j.val|} |
|
|
| lemma metricBad_limit (P : Parameters) |
| {Ω : Type} [MeasurableSpace Ω] {μ : Measure Ω} [IsProbabilityMeasure μ] |
| {B : ℝ≥0 → Ω → ℝ} (hB : IsBrownianReal B μ) {a : ℝ} (ha : 0<a) : |
| Tendsto (fun n => (actualDrawLaw P n).real (metricBad P n a)) atTop (𝓝 0) := by |
| have hcore := (actual_max_core P ha).comp (tendsto_add_atTop_nat 1) |
| have herr := (actual_uniform_metric_spine P hB ha).comp (tendsto_add_atTop_nat 1) |
| have ht := hcore.add herr |
| simp only [zero_add] at ht |
| apply squeeze_zero (fun _ => measureReal_nonneg) _ ht |
| intro n |
| have hc : (actualDrawLaw P n).real {x | ¬∀ i,(x.2 i).arity=(x.1.val i).val}=0 := by |
| unfold Measure.real |
| rw [ae_iff.mp (actual_marked_compatible P (n+1)),ENNReal.toReal_zero] |
| apply (measureReal_union_le _ _).trans |
| apply add_le_add _ le_rfl |
| apply (measureReal_union_le _ _).trans |
| rw [hc,zero_add] |
| exact le_rfl |
|
|
| / |
| the missing compact-cover interface, with the original map, exact degree |
| mass, positive source normalization, and true bad events. -/ |
| theorem metric_test_local (P : Parameters) (F : FKCRT.MetricMeasureData → ℝ) |
| (hF : FKCRT.IsGHPTest F) (ε : ℝ) (hε : 0<ε) (f : C(unitInterval,ℝ)) : |
| ∃ r : ℝ,0<r ∧ ∃ a : ℝ,0<a ∧ ∃ N : ℕ,∀ n≥N,∀ x : ActualDraw n, |
| dist (actualHeight P n x) f<r → x∉metricBad P n a → |
| |FKCRT.markedMapTest (edgeScale P n) n F x-F (FKCRT.treeSpace (actualHeight P n x))| ≤ ε := by |
| obtain ⟨δ,hδ,hcont⟩ := hF.2 (FKCRT.treeSpace f) (FKCRT.treeSpace_valid f.continuous) (ε/2) (half_pos hε) |
| obtain ⟨r₀,hr₀,hG⟩ := Metric.continuousAt_iff.mp (hF.continuous_treeSpace.continuousAt (x := f)) (ε/2) (half_pos hε) |
| let L := (actualOffspring P).sigma/(2*metricMean P)+1 |
| have hL : 0<L := by dsimp [L];have hβ := metricMean_pos P;have hσ := (actualOffspring P).sigma_pos; positivity |
| let r := min r₀ (δ/16) |
| let a := δ/(32*(L+1)) |
| have hr : 0<r := lt_min hr₀ (by positivity) |
| have ha : 0<a := by dsimp [a];positivity |
| have hLbound : ∀ᶠ n in atTop,edgeScale P n*Real.sqrt ((2*(n+1)+1:ℕ):ℝ) ≤ L := by |
| exact ((edgeScale_sqrt_size_tendsto P).eventually (gt_mem_nhds (by dsimp [L];linarith))).mono (fun _ h => h.le) |
| obtain ⟨ζ,hζ,hmod⟩ := Metric.uniformContinuous_iff.mp (CompactSpace.uniformContinuous_of_continuous f.continuous) (δ/16) (by positivity) |
| have hmesh : Tendsto (fun n : ℕ => 1/(2*((n:ℝ)+1))) atTop (𝓝 0) := |
| tendsto_const_nhds.div_atTop ((tendsto_natCast_atTop_atTop.atTop_add tendsto_const_nhds).const_mul_atTop (by norm_num)) |
| obtain ⟨N,hN⟩ := eventually_atTop.mp (hLbound.and (hmesh.eventually (gt_mem_nhds hζ))) |
| refine ⟨r,hr,a,ha,N,?_⟩ |
| intro n hn x hx hbad |
| have hcompat : ∀ i,(x.2 i).arity=(x.1.val i).val := by |
| by_contra hc |
| exact hbad (Or.inl (Or.inl hc)) |
| let y : CoreTree.MarkedCode (2*(n+1)+1) := ⟨x,hcompat⟩ |
| have hcore : ((CoreTree.ofMarkedCode y).maxDegree:ℝ) ≤ a*Real.sqrt ((2*(n+1)+1:ℕ):ℝ) := by |
| by_contra hc |
| exact hbad (Or.inl (Or.inr ⟨hcompat,lt_of_not_ge hc⟩)) |
| have herr : ∀ j : Fin (2*(n+1)+1),|markedSpineSum coreIncrement x.1 j.isLt.le x.2- |
| metricMean P*height x.1.val j.val| ≤ a*Real.sqrt ((2*(n+1)+1:ℕ):ℝ) := by |
| intro j |
| by_contra hc |
| exact hbad (Or.inr ⟨j,lt_of_not_ge hc⟩) |
| have hghp := CoreTree.marked_nearby_ghp_bound P n y f a r (δ/16) (δ/2) (half_pos hδ) herr hx.le |
| (fun s u hsu => by |
| have hh := hmod (hsu.trans_lt (hN n hn).2) |
| simpa only [Real.dist_eq] using hh.le) ?_ |
| · have htest := hcont _ (FKCRT.mapSpace_valid (edgeScale_pos P n) _) |
| (hghp.trans_lt ((ENNReal.ofReal_lt_ofReal_iff hδ).mpr (half_lt_self hδ))) |
| have htree := hG (hx.trans_le (min_le_left _ _)) |
| rw [Real.dist_eq] at htree |
| rw [FKCRT.markedMapTest,dite_eq_left hcompat] |
| have ht := abs_sub_le |
| (F (FKCRT.mapSpace (edgeScale P n) ((FKCRT.rootedWordEquiv n).symm ((CoreTree.successfulMarkedEquiv n).symm y)).1)) |
| (F (FKCRT.treeSpace f)) (F (FKCRT.treeSpace (actualHeight P n x))) |
| rw [abs_sub_comm (F (FKCRT.treeSpace f))] at ht |
| linarith |
| have hb₁ := mul_le_mul_of_nonneg_left hcore (edgeScale_pos P n).le |
| have hb₂ := mul_le_mul_of_nonneg_left (hN n hn).1 ha.le |
| have har : 8*a*L≤δ/4 := by |
| have hh : a*(32*(L+1))=δ := by |
| dsimp [a] |
| field_simp |
| nlinarith [mul_nonneg ha.le hL.le] |
| have hrδ : r≤δ/16 := min_le_right _ _ |
| nlinarith |
|
|
| end FKCRT.Inventory |
| end |
|
|
| end OAI |
|
|
