| import Mathlib.Probability.Kernel.WithDensity |
| import OAI.NumberTheory.Jacobsthal.Partitions.BeginningWindowTransport |
|
|
| namespace OAI |
|
|
| namespace Erdos970 |
|
|
| section |
|
|
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped Topology ProbabilityTheory ENNReal |
| open NumberTheoryLean.PairedCostProcess NumberTheoryLean.CostReturnLaw |
| open NumberTheoryLean.InitialRegeneration NumberTheoryLean.TransitionKernels |
| open NumberTheoryLean.KernelPotential |
| open AbsorptionCutoff.Renewal |
|
|
| noncomputable def rawFirstMarkedBeginning : Kernel OddCost OddCost := |
| (potential Kernel.id (cycleBranchKernel false)).withDensity (fun _ y => nextMarkWeight y) |
|
|
| lemma nextMarkWeight_ne_top (z : OddCost) : nextMarkWeight z ≠ ∞ := |
| measure_ne_top (cycleBranchKernel true z) univ |
|
|
| instance rawFirstMarkedBeginning_isSFiniteKernel : IsSFiniteKernel rawFirstMarkedBeginning := by |
| unfold rawFirstMarkedBeginning |
| exact Kernel.IsSFiniteKernel.withDensity _ (fun _ y => nextMarkWeight_ne_top y) |
|
|
| lemma rawFirstMarkedBeginning_apply (z : OddCost) : |
| rawFirstMarkedBeginning z = |
| Measure.sum (fun n : ℕ => ((cycleBranchKernel false ^ n) z).withDensity nextMarkWeight) := by |
| rw [rawFirstMarkedBeginning,Kernel.withDensity_apply _ (f := fun _ y : OddCost => nextMarkWeight y) (nextMarkWeight_measurable.comp measurable_snd), |
| potential,Kernel.sum_apply] |
| simp only [Kernel.id_comp] |
| exact withDensity_sum _ _ |
|
|
| lemma rawFirstMarkedBeginning_increment (z : OddCost) (hz : z ∈ returnSet) : |
| (rawFirstMarkedBeginning z).map (fun y => y.2-z.2) = firstMarkWaitingLaw := by |
| rw [rawFirstMarkedBeginning_apply, |
| Measure.map_sum (f := fun y : OddCost => y.2-z.2) (measurable_snd.sub measurable_const).aemeasurable] |
| change actualWaitingLaw z = firstMarkWaitingLaw |
| rw [actualWaitingLaw_eq z hz,firstMarkWaitingLaw,actualWaitingLaw_eq] |
| norm_num [returnSet,NumberTheoryLean.PairedHitting.pairedRegeneration,NumberTheoryLean.RegenerationTails.regenerationState] |
|
|
| lemma rawFirstMarkedBeginning_mass (z : OddCost) (hz : z ∈ returnSet) : |
| rawFirstMarkedBeginning z univ = 1 := by |
| have he := congrArg (fun μ : Measure ℝ => μ univ) (rawFirstMarkedBeginning_increment z hz) |
| rw [Measure.map_apply (f := fun y : OddCost => y.2-z.2) (measurable_snd.sub measurable_const) MeasurableSet.univ,preimage_univ] at he |
| exact he.trans measure_univ |
|
|
| lemma rawFirstMarkedBeginning_ae_regeneration (z : OddCost) (hz : z ∈ returnSet) : |
| ∀ᵐ y ∂rawFirstMarkedBeginning z, y ∈ returnSet := by |
| rw [rawFirstMarkedBeginning_apply,Measure.ae_sum_iff] |
| intro n |
| exact (withDensity_absolutelyContinuous _ _).ae_le (cycleBranch_pow_ae_regeneration false n z hz) |
|
|
| lemma rawFirstMarkedBeginning_cost_integral (z : OddCost) (hz : z ∈ returnSet) |
| {F : ℝ → ℝ≥0∞} (hF : Measurable F) : |
| (∫⁻ y, F y.2 ∂rawFirstMarkedBeginning z) = ∫⁻ G, F (z.2+G) ∂firstMarkWaitingLaw := by |
| rw [← rawFirstMarkedBeginning_increment z hz, |
| lintegral_map (g := fun y : OddCost => y.2-z.2) (f := fun G : ℝ => F (z.2+G)) |
| (hF.comp (measurable_const.add measurable_id)) (measurable_snd.sub measurable_const)] |
| apply lintegral_congr |
| intro y |
| congr 1 |
| ring |
|
|
| noncomputable def initialMarkedBeginning : Kernel EvenState OddCost := |
| rawFirstMarkedBeginning ∘ₖ delayedRegeneration |
|
|
| instance initialMarkedBeginning_isMarkovKernel : IsMarkovKernel initialMarkedBeginning := by |
| constructor |
| intro s |
| constructor |
| rw [initialMarkedBeginning,Kernel.comp_apply' _ _ _ MeasurableSet.univ] |
| have he : (fun z => rawFirstMarkedBeginning z univ) =ᵐ[delayedRegeneration s] fun _ => 1 := by |
| filter_upwards [delayedRegeneration_ae_regeneration s] with z hz |
| exact rawFirstMarkedBeginning_mass z hz |
| rw [lintegral_congr_ae he] |
| simp |
| |
| lemma initialMarkedBeginning_ae_regeneration (s : EvenState) : |
| ∀ᵐ z ∂initialMarkedBeginning s, z ∈ returnSet := by |
| rw [initialMarkedBeginning] |
| apply Kernel.ae_comp_of_ae_ae returnSet_measurable |
| filter_upwards [delayedRegeneration_ae_regeneration s] with z hz |
| exact rawFirstMarkedBeginning_ae_regeneration z hz |
| |
| noncomputable def initialMarkedCostLaw (s : EvenState) : Measure ℝ := |
| (initialMarkedBeginning s).map Prod.snd |
| |
| instance initialMarkedCostLaw_isProbabilityMeasure (s : EvenState) : IsProbabilityMeasure (initialMarkedCostLaw s) := |
| (Measure.isProbabilityMeasure_map_iff measurable_snd.aemeasurable).mpr inferInstance |
| |
| lemma initialMarkedCostLaw_eq (s : EvenState) : |
| initialMarkedCostLaw s = delayedCostLaw s ∗ firstMarkWaitingLaw := by |
| apply Measure.ext_of_lintegral |
| intro F hF |
| rw [initialMarkedCostLaw,lintegral_map hF measurable_snd,initialMarkedBeginning, |
| Kernel.lintegral_comp _ _ _ (g := fun z : OddCost => F z.2) (hF.comp measurable_snd), |
| Measure.lintegral_conv hF,delayedCostLaw, |
| lintegral_map (g := Prod.snd) (f := fun x : ℝ => ∫⁻ y, F (x+y) ∂firstMarkWaitingLaw) |
| ((hF.comp measurable_add).lintegral_prod_right') measurable_snd] |
| apply lintegral_congr_ae |
| filter_upwards [delayedRegeneration_ae_regeneration s] with z hz |
| exact rawFirstMarkedBeginning_cost_integral z hz hF |
|
|
| lemma firstMarkWaiting_nonneg : ∀ᵐ G ∂firstMarkWaitingLaw, 0 ≤ G := by |
| rw [firstMarkWaitingLaw,actualWaitingLaw_eq _ (by norm_num [returnSet, |
| NumberTheoryLean.PairedHitting.pairedRegeneration,NumberTheoryLean.RegenerationTails.regenerationState])] |
| exact Measure.ae_smul_measure unmarkedPotential_ae_nonneg _ |
|
|
| lemma initialMarkedCost_nonneg (s : EvenState) : ∀ᵐ D ∂initialMarkedCostLaw s, 0 ≤ D := by |
| rw [initialMarkedCostLaw_eq] |
| have hd : ∀ᵐ T ∂delayedCostLaw s, 0 ≤ T := by |
| rw [delayedCostLaw] |
| exact (ae_map_iff measurable_snd.aemeasurable measurableSet_Ici).mpr (delayedRegeneration_cost_nonneg s) |
| simpa only [zero_add] using conv_ae_lower hd firstMarkWaiting_nonneg |
|
|
| lemma costTransform_mono {μ : Measure ℝ} (hμ : ∀ᵐ G ∂μ, 0 ≤ G) {a b : ℝ} (hab : a ≤ b) : |
| costTransform μ a ≤ costTransform μ b := by |
| apply lintegral_mono_ae |
| filter_upwards [hμ] with G hG |
| exact ENNReal.ofReal_le_ofReal (Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_right hab hG)) |
|
|
| theorem initialMarkedCost_uniform_exponential (S : ℝ) : ∃ eta B : ℝ, 0 < eta ∧ 0 ≤ B ∧ |
| ∀ s : EvenState, s.1 ≤ S → costTransform (initialMarkedCostLaw s) eta ≤ ENNReal.ofReal B := by |
| obtain ⟨a,A,ha,hA,hDelay⟩ := delayedCostLaw_uniform_exponential S |
| obtain ⟨b,hb,hWait,_⟩ := marked_waiting_common_exponential_moment |
| let eta := min a b |
| have heta : 0 < eta := lt_min ha hb |
| have hW : costTransform firstMarkWaitingLaw eta < ∞ := |
| (costTransform_mono firstMarkWaiting_nonneg (min_le_right a b)).trans_lt hWait |
| let W : ℝ := (costTransform firstMarkWaitingLaw eta).toReal |
| have hWreal : costTransform firstMarkWaitingLaw eta = ENNReal.ofReal W := |
| (ENNReal.ofReal_toReal hW.ne).symm |
| refine ⟨eta,A*W,heta,mul_nonneg hA ENNReal.toReal_nonneg,?_⟩ |
| intro s hs |
| have hd : ∀ᵐ T ∂delayedCostLaw s, 0 ≤ T := by |
| rw [delayedCostLaw] |
| exact (ae_map_iff measurable_snd.aemeasurable measurableSet_Ici).mpr (delayedRegeneration_cost_nonneg s) |
| rw [initialMarkedCostLaw_eq,costTransform_conv,hWreal,ENNReal.ofReal_mul hA] |
| exact mul_le_mul_left ((costTransform_mono hd (min_le_left a b)).trans (hDelay s hs)) _ |
|
|
| end Erdos970Dependency.MarkedVisits |
|
|
| end |
|
|
| section |
|
|
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped Topology ProbabilityTheory ENNReal |
| open NumberTheoryLean.PairedCostProcess NumberTheoryLean.CostReturnLaw |
| open NumberTheoryLean.TransitionKernels NumberTheoryLean.KernelPotential |
|
|
| noncomputable def initialBeginningReg : Kernel EvenState RegCost := |
| initialMarkedBeginning.comapRight (MeasurableEmbedding.subtype_coe returnSet_measurable) |
|
|
| instance initialBeginningReg_isMarkovKernel : IsMarkovKernel initialBeginningReg := by |
| apply Kernel.IsMarkovKernel.comapRight |
| intro s |
| have he := (ae_mem_iff_measure_eq (μ := initialMarkedBeginning s) |
| returnSet_measurable.nullMeasurableSet).mp (initialMarkedBeginning_ae_regeneration s) |
| rw [measure_univ] at he |
| convert! he using 1 |
| congr 1 |
| ext y |
| simp |
|
|
| lemma initialBeginningReg_map_state (s : EvenState) : |
| (initialBeginningReg s).map (Subtype.val : RegCost → OddCost) = initialMarkedBeginning s := by |
| calc |
| _ = (initialMarkedBeginning s).restrict returnSet := by |
| change (((initialMarkedBeginning s).comap (Subtype.val : RegCost → OddCost)).map Subtype.val) = _ |
| exact map_comap_subtype_coe (μ := initialMarkedBeginning s) returnSet_measurable |
| _ = _ := Measure.restrict_eq_self_of_ae_mem (initialMarkedBeginning_ae_regeneration s) |
|
|
| lemma initialBeginningReg_cost_law (s : EvenState) : |
| (initialBeginningReg s).map beginningCost = initialMarkedCostLaw s := by |
| rw [initialMarkedCostLaw,← initialBeginningReg_map_state s, |
| Measure.map_map measurable_snd measurable_subtype_coe] |
| rfl |
|
|
| lemma beginningBelow_shift (t v : ℝ) : beginningBelow t (v-t) = beginningBelow 0 v := by |
| unfold beginningBelow |
| congr 1 |
| ext z |
| simp only [mem_preimage,mem_Iio,relativeBeginningCost,sub_zero] |
| constructor <;> intro h <;> linarith |
|
|
| lemma beginningOver_shift (t v H : ℝ) : beginningOver t (v-t) H = beginningOver 0 v H := by |
| unfold beginningOver |
| congr 1 |
| ext z |
| simp only [mem_preimage,mem_Ioi,relativeBeginningCost,sub_zero] |
| constructor <;> intro h <;> linarith |
|
|
| lemma beginningWindow_shift (t v H : ℝ) : beginningWindow t (v-t) H = beginningWindow 0 v H := by |
| unfold beginningWindow |
| congr 1 |
| ext z |
| simp only [mem_preimage,mem_Icc,relativeBeginningCost,sub_zero] |
| constructor <;> rintro ⟨h1,h2⟩ <;> constructor <;> linarith |
|
|
| lemma absoluteBeginningOvershoot_eq (z : RegCost) (v H : ℝ) : |
| (potential (beginningOver 0 v H) (beginningBelow 0 v)) z univ = |
| beginningOvershoot z (v-beginningCost z) H := by |
| rw [beginningOvershoot,beginningOver_shift,beginningBelow_shift] |
|
|
| lemma absoluteBeginningWindowHit_eq (z : RegCost) (v H : ℝ) : |
| (potential (beginningWindow 0 v H) (beginningBelow 0 v)) z univ = |
| beginningWindowHit z (v-beginningCost z) H := by |
| rw [beginningWindowHit,beginningWindow_shift,beginningBelow_shift] |
|
|
| noncomputable def markedWindowSuccess (v H : ℝ) (z : RegCost) : ℝ≥0∞ := |
| if beginningCost z < v then (potential (beginningWindow 0 v H) (beginningBelow 0 v)) z univ |
| else if beginningCost z ≤ v+H then 1 else 0 |
|
|
| noncomputable def markedWindowFailure (v H : ℝ) (z : RegCost) : ℝ≥0∞ := |
| if beginningCost z < v then (potential (beginningOver 0 v H) (beginningBelow 0 v)) z univ |
| else if beginningCost z ≤ v+H then 0 else 1 |
|
|
| lemma markedWindowSuccess_measurable (v H : ℝ) : Measurable (markedWindowSuccess v H) := by |
| unfold markedWindowSuccess |
| exact Measurable.ite (measurableSet_lt beginningCost_measurable measurable_const) |
| ((potential _ _).measurable_coe MeasurableSet.univ) |
| (Measurable.ite (measurableSet_le beginningCost_measurable measurable_const) measurable_const measurable_const) |
|
|
| lemma markedWindowFailure_measurable (v H : ℝ) : Measurable (markedWindowFailure v H) := by |
| unfold markedWindowFailure |
| exact Measurable.ite (measurableSet_lt beginningCost_measurable measurable_const) |
| ((potential _ _).measurable_coe MeasurableSet.univ) |
| (Measurable.ite (measurableSet_le beginningCost_measurable measurable_const) measurable_const measurable_const) |
|
|
| lemma markedWindow_partition (z : RegCost) (v H : ℝ) (hH : 0 ≤ H) : |
| markedWindowSuccess v H z+markedWindowFailure v H z = 1 := by |
| unfold markedWindowSuccess markedWindowFailure |
| by_cases hz : beginningCost z < v |
| · rw [ite_eq_left hz,ite_eq_left hz,absoluteBeginningOvershoot_eq,absoluteBeginningWindowHit_eq] |
| exact beginningWindow_partition z (by linarith) hH |
| · rw [ite_eq_right hz,ite_eq_right hz] |
| split_ifs <;> simp |
|
|
| noncomputable def initialMarkedWindowSuccess (s : EvenState) (v H : ℝ) : ℝ≥0∞ := |
| ∫⁻ z, markedWindowSuccess v H z ∂initialBeginningReg s |
|
|
| noncomputable def initialMarkedWindowFailure (s : EvenState) (v H : ℝ) : ℝ≥0∞ := |
| ∫⁻ z, markedWindowFailure v H z ∂initialBeginningReg s |
|
|
| lemma initialMarkedWindow_partition (s : EvenState) (v H : ℝ) (hH : 0 ≤ H) : |
| initialMarkedWindowSuccess s v H+initialMarkedWindowFailure s v H = 1 := by |
| rw [initialMarkedWindowSuccess,initialMarkedWindowFailure, |
| ← lintegral_add_left (markedWindowSuccess_measurable v H)] |
| simp only [markedWindow_partition _ v H hH,lintegral_const,measure_univ,mul_one] |
|
|
| lemma cost_tail_le_transform (μ : Measure ℝ) {eta : ℝ} (heta : 0 ≤ eta) (v : ℝ) : |
| μ (Ici v) ≤ ENNReal.ofReal (Real.exp (-eta*v))*costTransform μ eta := by |
| calc |
| _ = ∫⁻ G, (Ici v).indicator (fun _ => (1:ℝ≥0∞)) G ∂μ := by |
| rw [lintegral_indicator measurableSet_Ici]; simp |
| _ ≤ ∫⁻ G, ENNReal.ofReal (Real.exp (-eta*v))*ENNReal.ofReal (Real.exp (eta*G)) ∂μ := by |
| apply lintegral_mono |
| intro G |
| by_cases hG : G ∈ Ici v |
| · rw [indicator_of_mem hG] |
| change (1:ℝ≥0∞) ≤ ENNReal.ofReal (Real.exp (-eta*v))*ENNReal.ofReal (Real.exp (eta*G)) |
| rw [← ENNReal.ofReal_mul (Real.exp_pos _).le,← Real.exp_add] |
| have he : (1:ℝ) ≤ Real.exp (-eta*v+eta*G) := Real.one_le_exp_iff.mpr (by change v≤G at hG; nlinarith) |
| simpa only [ENNReal.ofReal_one] using ENNReal.ofReal_le_ofReal he |
| · rw [indicator_of_notMem hG]; exact zero_le |
| _ = _ := lintegral_const_mul' _ _ ENNReal.ofReal_ne_top |
| |
| lemma initialMarkedWindowFailure_le (s : EvenState) (v H R : ℝ) |
| (hTail : ∀ z : RegCost, ∀ u : ℝ, 0 < u → beginningOvershoot z u H ≤ ENNReal.ofReal R) : |
| initialMarkedWindowFailure s v H ≤ ENNReal.ofReal R+initialMarkedCostLaw s (Ici v) := by |
| have hp (z : RegCost) : markedWindowFailure v H z ≤ ENNReal.ofReal R+ |
| (beginningCost ⁻¹' Ici v).indicator (fun _ => (1:ℝ≥0∞)) z := by |
| by_cases hz : beginningCost z < v |
| · rw [markedWindowFailure,ite_eq_left hz,absoluteBeginningOvershoot_eq, |
| indicator_of_notMem (show z ∉ beginningCost ⁻¹' Ici v from not_le_of_gt hz),add_zero] |
| exact hTail z _ (by linarith) |
| · rw [indicator_of_mem (show z ∈ beginningCost ⁻¹' Ici v from le_of_not_gt hz), |
| markedWindowFailure,ite_eq_right hz] |
| split_ifs |
| · exact zero_le |
| · exact le_add_left le_rfl |
| calc |
| _ ≤ ∫⁻ z, ENNReal.ofReal R+(beginningCost ⁻¹' Ici v).indicator (fun _ => (1:ℝ≥0∞)) z ∂initialBeginningReg s := |
| lintegral_mono hp |
| _ = ENNReal.ofReal R+initialBeginningReg s (beginningCost ⁻¹' Ici v) := by |
| rw [lintegral_add_left measurable_const,lintegral_const,measure_univ,mul_one, |
| lintegral_indicator (beginningCost_measurable measurableSet_Ici)] |
| simp |
| _ = _ := by |
| rw [← initialBeginningReg_cost_law s,Measure.map_apply beginningCost_measurable measurableSet_Ici] |
|
|
| theorem initialMarkedWindow_exponential (S : ℝ) : ∃ eta C eta0 B : ℝ, |
| 0 < eta ∧ 0 < C ∧ 0 < eta0 ∧ 0 ≤ B ∧ ∀ s : EvenState, s.1 ≤ S → ∀ v H : ℝ, |
| 0 ≤ H → initialMarkedWindowFailure s v H ≤ |
| ENNReal.ofReal (C*Real.exp (-eta*H)+B*Real.exp (-eta0*v)) := by |
| obtain ⟨eta,C,heta,hC,hTail⟩ := beginningWindow_exponential |
| obtain ⟨eta0,B,heta0,hB,hDelay⟩ := initialMarkedCost_uniform_exponential S |
| refine ⟨eta,C,eta0,B,heta,hC,heta0,hB,?_⟩ |
| intro s hs v H hH |
| calc |
| _ ≤ ENNReal.ofReal (C*Real.exp (-eta*H))+initialMarkedCostLaw s (Ici v) := |
| initialMarkedWindowFailure_le s v H _ (fun z u hu => (hTail z u H hu hH).1) |
| _ ≤ ENNReal.ofReal (C*Real.exp (-eta*H))+ |
| ENNReal.ofReal (Real.exp (-eta0*v))*costTransform (initialMarkedCostLaw s) eta0 := |
| add_le_add le_rfl (cost_tail_le_transform _ heta0.le v) |
| _ ≤ ENNReal.ofReal (C*Real.exp (-eta*H))+ENNReal.ofReal (Real.exp (-eta0*v))*ENNReal.ofReal B := |
| add_le_add le_rfl (mul_le_mul_right (hDelay s hs) _) |
| _ = _ := by rw [← ENNReal.ofReal_mul (Real.exp_pos _).le,mul_comm (Real.exp (-eta0*v)), |
| ← ENNReal.ofReal_add (mul_nonneg hC.le (Real.exp_pos _).le) (mul_nonneg hB (Real.exp_pos _).le)] |
|
|
| end Erdos970Dependency.MarkedVisits |
|
|
| end |
|
|
| section |
|
|
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped Topology ProbabilityTheory ENNReal |
| open NumberTheoryLean.TransitionKernels |
|
|
| lemma exponential_decay_tendsto {eta : ℝ} (heta : 0 < eta) (C : ℝ) : |
| Tendsto (fun H : ℝ => C*Real.exp (-eta*H)) atTop (𝓝 0) := by |
| have he : Tendsto (fun H : ℝ => Real.exp (-eta*H)) atTop (𝓝 0) := by |
| simpa only [Function.comp_def,id_eq,neg_mul] using |
| Real.tendsto_exp_neg_atTop_nhds_zero.comp (Tendsto.const_mul_atTop heta tendsto_id) |
| simpa only [mul_zero] using he.const_mul C |
|
|
| theorem moving_marked_window_capture {eps : ℝ} (heps : 0 < eps) : |
| ∃ rho : ℝ, 10 < rho ∧ ∀ K : ℝ, 0 < K → |
| ∀ᶠ w : ℝ in atTop, 3 ≤ w ∧ ∀ r : ℝ, w ≤ r → ∀ s : EvenState, |
| 199/100 ≤ s.1 → s.1 ≤ 23/10 → |
| initialMarkedWindowFailure s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) ≤ |
| ENNReal.ofReal eps ∧ |
| 1-ENNReal.ofReal eps ≤ |
| initialMarkedWindowSuccess s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) := by |
| obtain ⟨eta,C,eta0,B,heta,_hC,heta0,_hB,hBound⟩ := initialMarkedWindow_exponential (23/10) |
| have hHalf : 0 < eps/2 := by positivity |
| obtain ⟨H,hH,hSmall⟩ := ((eventually_gt_atTop (0:ℝ)).and |
| ((tendsto_order.mp (exponential_decay_tendsto heta C)).2 (eps/2) hHalf)).exists |
| obtain ⟨V,hV⟩ := eventually_atTop.mp |
| ((tendsto_order.mp (exponential_decay_tendsto heta0 B)).2 (eps/2) hHalf) |
| let rho : ℝ := 10*Real.exp H |
| have hrho : 10 < rho := by |
| have he := Real.one_lt_exp_iff.mpr hH |
| dsimp [rho] |
| linarith |
| have hWidth : Real.log (rho/10) = H := by |
| dsimp [rho] |
| rw [mul_div_cancel_left₀ _ (by norm_num : (10:ℝ) ≠ 0),Real.log_exp] |
| refine ⟨rho,hrho,?_⟩ |
| intro K hK |
| filter_upwards [moving_window_cost_threshold hK (by linarith : 0 < rho) V] with w hw |
| refine ⟨hw.1,?_⟩ |
| intro r hr s _hs0 hs1 |
| have hFailure : initialMarkedWindowFailure s |
| (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) ≤ ENNReal.ofReal eps := by |
| rw [hWidth] |
| apply (hBound s hs1 _ H hH.le).trans |
| apply ENNReal.ofReal_le_ofReal |
| have htail := hV _ (hw.2 r hr) |
| linarith |
| refine ⟨hFailure,?_⟩ |
| apply tsub_le_iff_right.mpr |
| have hp := initialMarkedWindow_partition s (Real.log (r/(rho*K*(Real.log w)^2))) |
| (Real.log (rho/10)) (by rw [hWidth]; exact hH.le) |
| calc |
| 1 = initialMarkedWindowSuccess s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10))+ |
| initialMarkedWindowFailure s (Real.log (r/(rho*K*(Real.log w)^2))) (Real.log (rho/10)) := hp.symm |
| _ ≤ _ := add_le_add le_rfl hFailure |
|
|
| end Erdos970Dependency.MarkedVisits |
|
|
| end |
|
|
| end Erdos970 |
|
|
| end OAI |
|
|
