| import OAI.NumberTheory.Jacobsthal.Estimates.PairedBlockContraction |
|
|
| namespace OAI |
|
|
| namespace Erdos970 |
|
|
| section |
|
|
| namespace NumberTheoryLean.PairedCostProcess |
|
|
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal |
| open TransitionKernels FinitePathGeometry FinitePathMeasures KernelDensityBridge |
| open JointMinorization RegenerationTails PairedHitting |
|
|
| abbrev OddCost := OddState × ℝ |
|
|
| noncomputable def pairedDraws : Kernel OddState (EvenState × OddState) := |
| oddToEven ⊗ₖ evenToOdd.prodMkLeft OddState |
| |
| instance pairedDraws_isMarkovKernel : IsMarkovKernel pairedDraws := by unfold pairedDraws; infer_instance |
| |
| noncomputable def pairUpdate (x : OddCost × (EvenState × OddState)) : OddCost := |
| (x.2.2, x.1.2 + cost x.2.1.1 + cost x.2.2.1) |
| |
| theorem pairUpdate_measurable : Measurable pairUpdate := |
| (measurable_snd.comp measurable_snd).prodMk |
| (((measurable_snd.comp measurable_fst).add |
| (cost_measurable.comp (measurable_subtype_coe.comp (measurable_fst.comp measurable_snd)))).add |
| (cost_measurable.comp (measurable_subtype_coe.comp (measurable_snd.comp measurable_snd)))) |
| |
| noncomputable def pairedCostKernel : Kernel OddCost OddCost := |
| (Kernel.id ×ₖ pairedDraws.prodMkRight ℝ).map pairUpdate |
| |
| instance pairedCostKernel_isMarkovKernel : IsMarkovKernel pairedCostKernel := |
| Kernel.IsMarkovKernel.map _ pairUpdate_measurable |
| |
| theorem pairedCostKernel_apply (z : OddCost) {B : Set OddCost} (hB : MeasurableSet B) : |
| pairedCostKernel z B = pairedDraws z.1 {x | (x.2, z.2 + cost x.1.1 + cost x.2.1) ∈ B} := by |
| rw [pairedCostKernel, Kernel.map_apply' _ pairUpdate_measurable _ hB, |
| Kernel.prod_apply' _ _ _ (pairUpdate_measurable hB), Kernel.id_apply, lintegral_dirac'] |
| · rfl |
| · exact measurable_measure_prodMk_left (pairUpdate_measurable hB) |
| |
| theorem pairedCost_map_state (z : OddCost) : (pairedCostKernel z).map Prod.fst = pairedOdd z.1 := by |
| ext B hB |
| rw [Measure.map_apply measurable_fst hB, pairedCostKernel_apply _ (measurable_fst hB), |
| pairedOdd, Kernel.comp_eq_snd_compProd, Kernel.snd_apply' _ _ hB] |
| rfl |
| |
| theorem pairedCost_map_ratio_cost (z : OddCost) : |
| (pairedCostKernel z).map (fun x => (x.1.1, x.2)) = oddJointKernel z.2 z.1 := by |
| have hm : Measurable (fun x : OddCost => (x.1.1, x.2)) := |
| (measurable_subtype_coe.comp measurable_fst).prodMk measurable_snd |
| have hp : Measurable (fun x : EvenState × OddState => (x.1.1, x.2.1)) := |
| (measurable_subtype_coe.comp measurable_fst).prodMk (measurable_subtype_coe.comp measurable_snd) |
| ext B hB |
| rw [Measure.map_apply hm hB, pairedCostKernel_apply _ (hm hB), |
| oddJointKernel, Kernel.map_apply _ (pairCost_measurable z.2), |
| Measure.map_apply (pairCost_measurable z.2) hB, oddTwoStep, Kernel.map_apply _ hp, |
| Measure.map_apply hp ((pairCost_measurable z.2) hB)] |
| rfl |
| |
| theorem pairedDraws_regeneration (s : OddState) (hs : s.1 ≤ 3) : |
| pairedDraws s = pairedDraws regenerationState := by |
| have hf : oddToEven s = oddToEven regenerationState := by |
| rw [oddToEven, Kernel.comapRight_apply, Kernel.comapRight_apply, oddKernel_regeneration s hs] |
| ext B hB |
| rw [pairedDraws, Kernel.compProd_apply hB, Kernel.compProd_apply hB] |
| change (∫⁻ t : EvenState, evenToOdd t (Prod.mk t ⁻¹' B) ∂oddToEven s) = |
| ∫⁻ t : EvenState, evenToOdd t (Prod.mk t ⁻¹' B) ∂oddToEven regenerationState |
| rw [hf] |
| |
| theorem pairedCost_regeneration (s : OddState) (hs : s.1 ≤ 3) (T : ℝ) : |
| pairedCostKernel (s, T) = pairedCostKernel (regenerationState, T) := by |
| ext B hB |
| rw [pairedCostKernel_apply _ hB, pairedCostKernel_apply _ hB] |
| exact congrArg (fun μ : Measure (EvenState × OddState) => |
| μ {x | (x.2, T + cost x.1.1 + cost x.2.1) ∈ B}) (pairedDraws_regeneration s hs) |
| |
| def shiftCost (T : ℝ) (z : OddCost) : OddCost := (z.1, z.2 + T) |
| |
| theorem shiftCost_measurable (T : ℝ) : Measurable (shiftCost T) := |
| measurable_fst.prodMk (measurable_snd.add measurable_const) |
| |
| theorem pairedCost_translation (s : OddState) (T a : ℝ) : |
| (pairedCostKernel (s, T)).map (shiftCost a) = pairedCostKernel (s, T + a) := by |
| ext B hB |
| rw [Measure.map_apply (shiftCost_measurable a) hB, |
| pairedCostKernel_apply _ ((shiftCost_measurable a) hB), pairedCostKernel_apply _ hB] |
| congr 1 |
| ext x |
| change (x.2, (T + cost x.1.1 + cost x.2.1) + a) ∈ B ↔ |
| (x.2, (T + a) + cost x.1.1 + cost x.2.1) ∈ B |
| have heq : (T + cost x.1.1 + cost x.2.1) + a = (T + a) + cost x.1.1 + cost x.2.1 := by ring |
| rw [heq] |
| |
| end NumberTheoryLean.PairedCostProcess |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal |
| open NumberTheoryLean.TransitionKernels NumberTheoryLean.FinitePathGeometry |
| open NumberTheoryLean.PairedCostProcess NumberTheoryLean.RegenerationTails |
| |
| noncomputable def sourceMark (t : EvenState) : Bool := if (209/100:ℝ) ≤ t.1 ∧ t.1 ≤ 213/100 then true else false |
| |
| lemma sourceMark_measurable : Measurable sourceMark := by |
| unfold sourceMark |
| exact Measurable.ite (measurableSet_Icc.preimage measurable_subtype_coe) measurable_const measurable_const |
| |
| abbrev MarkedOddCost := Bool × OddCost |
| |
| noncomputable def markedPairUpdate (x : OddCost × (EvenState × OddState)) : MarkedOddCost := |
| (sourceMark x.2.1,pairUpdate x) |
| |
| lemma markedPairUpdate_measurable : Measurable markedPairUpdate := |
| (sourceMark_measurable.comp (measurable_fst.comp measurable_snd)).prodMk pairUpdate_measurable |
| |
| noncomputable def markedPairKernel : Kernel OddCost MarkedOddCost := |
| (Kernel.id ×ₖ pairedDraws.prodMkRight ℝ).map markedPairUpdate |
| |
| instance markedPairKernel_isMarkovKernel : IsMarkovKernel markedPairKernel := |
| Kernel.IsMarkovKernel.map _ markedPairUpdate_measurable |
| |
| lemma markedPairKernel_apply (z : OddCost) {B : Set MarkedOddCost} (hB : MeasurableSet B) : |
| markedPairKernel z B = pairedDraws z.1 |
| {x | (sourceMark x.1,(x.2,z.2+cost x.1.1+cost x.2.1)) ∈ B} := by |
| rw [markedPairKernel,Kernel.map_apply' _ markedPairUpdate_measurable _ hB, |
| Kernel.prod_apply' _ _ _ (markedPairUpdate_measurable hB),Kernel.id_apply,lintegral_dirac'] |
| · rfl |
| · exact measurable_measure_prodMk_left (markedPairUpdate_measurable hB) |
| |
| lemma markedPair_forget (z : OddCost) : (markedPairKernel z).map Prod.snd = pairedCostKernel z := by |
| ext B hB |
| rw [Measure.map_apply measurable_snd hB,markedPairKernel_apply _ (measurable_snd hB), |
| pairedCostKernel_apply _ hB] |
| rfl |
| |
| lemma markedPair_regeneration (s : OddState) (hs : s.1 ≤ 3) (T : ℝ) : |
| markedPairKernel (s,T) = markedPairKernel (regenerationState,T) := by |
| ext B hB |
| rw [markedPairKernel_apply _ hB,markedPairKernel_apply _ hB,pairedDraws_regeneration s hs] |
| |
| def markedShift (a : ℝ) (z : MarkedOddCost) : MarkedOddCost := (z.1,shiftCost a z.2) |
| |
| lemma markedShift_measurable (a : ℝ) : Measurable (markedShift a) := |
| measurable_fst.prodMk ((shiftCost_measurable a).comp measurable_snd) |
| |
| lemma markedPair_translation (s : OddState) (T a : ℝ) : |
| (markedPairKernel (s,T)).map (markedShift a) = markedPairKernel (s,T+a) := by |
| ext B hB |
| rw [Measure.map_apply (markedShift_measurable a) hB, |
| markedPairKernel_apply _ ((markedShift_measurable a) hB),markedPairKernel_apply _ hB] |
| congr 1 |
| ext x |
| change (sourceMark x.1,(x.2,(T+cost x.1.1+cost x.2.1)+a)) ∈ B ↔ |
| (sourceMark x.1,(x.2,(T+a)+cost x.1.1+cost x.2.1)) ∈ B |
| rw [show (T+cost x.1.1+cost x.2.1)+a=(T+a)+cost x.1.1+cost x.2.1 by ring] |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| section |
| |
| namespace NumberTheoryLean.CostReturnLaw |
| |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal Topology |
| open TransitionKernels PairedHitting PairedBlockContraction PairedCostProcess |
| |
| def returnSet : Set OddCost := Prod.fst ⁻¹' pairedRegeneration |
| |
| theorem returnSet_measurable : MeasurableSet returnSet := |
| pairedRegeneration_measurable.preimage measurable_fst |
| |
| noncomputable def costKilled : Kernel OddCost OddCost := pairedCostKernel.restrict returnSet_measurable.compl |
| noncomputable def costCaptured : Kernel OddCost OddCost := pairedCostKernel.restrict returnSet_measurable |
| |
| instance costKilled_isFiniteKernel : IsFiniteKernel costKilled := by unfold costKilled; infer_instance |
| instance costCaptured_isFiniteKernel : IsFiniteKernel costCaptured := by unfold costCaptured; infer_instance |
| |
| instance costKilled_pow_isFiniteKernel (n : ℕ) : IsFiniteKernel (costKilled ^ n) := by |
| induction n with |
| | zero => change IsFiniteKernel (Kernel.id : Kernel OddCost OddCost); infer_instance |
| | succ n ih => |
| rw [pow_succ'] |
| change IsFiniteKernel (costKilled ∘ₖ (costKilled ^ n)) |
| infer_instance |
| |
| theorem costKilled_map_state (z : OddCost) : (costKilled z).map Prod.fst = pairedKilled z.1 := by |
| rw [costKilled, Kernel.restrict_apply] |
| change ((pairedCostKernel z).restrict (Prod.fst ⁻¹' pairedRegeneration)ᶜ).map Prod.fst = _ |
| rw [← preimage_compl, ← Measure.restrict_map measurable_fst pairedRegeneration_measurable.compl, |
| pairedCost_map_state] |
| rfl |
| |
| theorem costKilled_pow_map_state (n : ℕ) (z : OddCost) : |
| ((costKilled ^ n) z).map Prod.fst = (pairedKilled ^ n) z.1 := by |
| induction n generalizing z with |
| | zero => |
| change (Measure.dirac z).map Prod.fst = Measure.dirac z.1 |
| exact Measure.map_dirac' measurable_fst z |
| | succ n ih => |
| apply Measure.ext_of_lintegral |
| intro H hH |
| rw [lintegral_map hH measurable_fst] |
| have hp : costKilled ^ (n + 1) = (costKilled ^ n) ∘ₖ costKilled := pow_succ costKilled n |
| have hq : pairedKilled ^ (n + 1) = (pairedKilled ^ n) ∘ₖ pairedKilled := pow_succ pairedKilled n |
| rw [hp, hq, Kernel.lintegral_comp _ _ _ (g := fun z : OddCost => H z.1) (hH.comp measurable_fst), |
| Kernel.lintegral_comp _ _ _ hH] |
| have hi : ∀ y : OddCost, (∫⁻ w : OddCost, H w.1 ∂(costKilled ^ n) y) = |
| ∫⁻ t, H t ∂(pairedKilled ^ n) y.1 := by |
| intro y |
| rw [← ih y, lintegral_map hH measurable_fst] |
| simp_rw [hi] |
| have hJ : Measurable (fun t : OddState => ∫⁻ u, H u ∂(pairedKilled ^ n) t) := hH.lintegral_kernel |
| rw [← costKilled_map_state z, lintegral_map hJ measurable_fst] |
| |
| theorem costKilled_mass (n : ℕ) (z : OddCost) : |
| (costKilled ^ n) z univ = (pairedKilled ^ n) z.1 univ := by |
| have h := congrArg (fun μ : Measure OddState => μ univ) (costKilled_pow_map_state n z) |
| rwa [Measure.map_apply measurable_fst MeasurableSet.univ, preimage_univ] at h |
| |
| theorem cost_survival_tendsto_zero (z : OddCost) : |
| Tendsto (fun n => (costKilled ^ n) z univ) atTop (𝓝 0) := by |
| apply (paired_survival_tendsto_zero z.1).congr |
| intro n |
| exact (costKilled_mass n z).symm |
| |
| noncomputable def firstReturn (n : ℕ) : Kernel OddCost OddCost := costCaptured ∘ₖ (costKilled ^ n) |
| |
| instance firstReturn_isFiniteKernel (n : ℕ) : IsFiniteKernel (firstReturn n) := by unfold firstReturn; infer_instance |
| |
| noncomputable def returnLaw : Kernel OddCost OddCost := Kernel.sum firstReturn |
| |
| theorem costCaptured_add_costKilled : costCaptured + costKilled = pairedCostKernel := by |
| ext z : 1 |
| change (pairedCostKernel z).restrict returnSet + (pairedCostKernel z).restrict returnSetᶜ = pairedCostKernel z |
| exact Measure.restrict_add_restrict_compl returnSet_measurable |
| |
| theorem return_mass_step (n : ℕ) (z : OddCost) : |
| firstReturn n z univ + (costKilled ^ (n + 1)) z univ = (costKilled ^ n) z univ := by |
| have hp : costKilled ^ (n + 1) = costKilled ∘ₖ (costKilled ^ n) := pow_succ' costKilled n |
| calc |
| _ = ((costCaptured + costKilled) ∘ₖ (costKilled ^ n)) z univ := by |
| rw [Kernel.comp_add_left, add_apply, Measure.add_apply, hp] |
| rfl |
| _ = (pairedCostKernel ∘ₖ (costKilled ^ n)) z univ := by rw [costCaptured_add_costKilled] |
| _ = _ := by rw [Kernel.comp_apply' _ _ _ MeasurableSet.univ]; simp |
| |
| theorem return_finite_mass (n : ℕ) (z : OddCost) : |
| (costKilled ^ n) z univ + ∑ k ∈ Finset.range n, firstReturn k z univ = 1 := by |
| induction n with |
| | zero => |
| change (Measure.dirac z) univ + 0 = 1 |
| simp |
| | succ n ih => |
| rw [Finset.sum_range_succ] |
| calc |
| _ = (∑ k ∈ Finset.range n, firstReturn k z univ) + |
| (firstReturn n z univ + (costKilled ^ (n + 1)) z univ) := by ac_rfl |
| _ = (∑ k ∈ Finset.range n, firstReturn k z univ) + (costKilled ^ n) z univ := by rw [return_mass_step] |
| _ = 1 := by simpa only [add_comm] using ih |
| |
| instance returnLaw_isMarkovKernel : IsMarkovKernel returnLaw := by |
| constructor |
| intro z |
| constructor |
| rw [returnLaw, Kernel.sum_apply' _ _ MeasurableSet.univ] |
| have h := (cost_survival_tendsto_zero z).add (ENNReal.tendsto_nat_tsum (fun n => firstReturn n z univ)) |
| simp only [zero_add, return_finite_mass] at h |
| exact tendsto_nhds_unique h tendsto_const_nhds |
| |
| theorem costCaptured_off_returnSet (z : OddCost) : costCaptured z returnSetᶜ = 0 := by |
| rw [costCaptured, Kernel.restrict_apply' _ _ _ returnSet_measurable.compl, compl_inter_self, measure_empty] |
| |
| theorem firstReturn_off_returnSet (n : ℕ) (z : OddCost) : firstReturn n z returnSetᶜ = 0 := by |
| rw [firstReturn, Kernel.comp_apply' _ _ _ returnSet_measurable.compl] |
| simp only [costCaptured_off_returnSet, lintegral_zero] |
| |
| theorem returnLaw_off_returnSet (z : OddCost) : returnLaw z returnSetᶜ = 0 := by |
| rw [returnLaw, Kernel.sum_apply' _ _ returnSet_measurable.compl] |
| simp only [firstReturn_off_returnSet, tsum_zero] |
| |
| noncomputable def cycleCostLaw : Measure ℝ := (returnLaw (RegenerationTails.regenerationState, 0)).map Prod.snd |
| |
| instance cycleCostLaw_isProbabilityMeasure : IsProbabilityMeasure cycleCostLaw := |
| (Measure.isProbabilityMeasure_map_iff (μ := returnLaw (RegenerationTails.regenerationState, 0)) |
| measurable_snd.aemeasurable).mpr inferInstance |
| |
| end NumberTheoryLean.CostReturnLaw |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal |
| open NumberTheoryLean.TransitionKernels NumberTheoryLean.RegenerationTails |
| open NumberTheoryLean.DerivativeWeights NumberTheoryLean.WeightFutureIntegrals |
| open NumberTheoryLean.FinitePathMeasures NumberTheoryLean.PairedCostProcess |
| open NumberTheoryLean.KernelDensityBridge |
| |
| lemma regeneration_density_eq {t : ℝ} (ht : 2 ≤ t) : |
| oddDensity regenerationState t = W t*phiEven t/phiOdd 1 := by |
| simp [oddDensity,tailDensity,regenerationState,ht] |
| |
| lemma regeneration_interval_positive {a b : ℝ} (ha : 2 ≤ a) (hab : a < b) : |
| 0 < oddKernel regenerationState (Icc a b) := by |
| have hp : ∀ t ∈ Icc a b, 0 < oddDensity regenerationState t := by |
| intro t ht |
| rw [regeneration_density_eq (ha.trans ht.1)] |
| exact div_pos (mul_pos (W_pos (by linarith [ht.1])) (phiEven_pos (by linarith [ht.1]))) (phiOdd_pos 1) |
| have hf : ContinuousOn (fun t => W t*phiEven t/phiOdd 1) (Icc a b) := by |
| intro t ht |
| have ht0 : t ≠ 0 := by linarith [ht.1] |
| have ht2 : t^2 ≠ 0 := pow_ne_zero 2 ht0 |
| have hW : ContinuousAt W t := by unfold W; fun_prop |
| exact ((hW.mul (phiEven_continuousAt (by linarith [ht.1]))).div_const _).continuousWithinAt |
| have hc : ContinuousOn (oddDensity regenerationState) (Icc a b) := hf.congr |
| (fun t ht => regeneration_density_eq (ha.trans ht.1)) |
| have hi := intervalIntegral.integral_pos hab hc (fun t ht => (hp t ⟨ht.1.le,ht.2⟩).le) |
| ⟨a,⟨le_rfl,hab.le⟩,hp a ⟨le_rfl,hab.le⟩⟩ |
| rw [oddKernel_apply,← ofReal_integral_eq_lintegral_ofReal |
| (oddDensity_integrable regenerationState).integrableOn |
| (Filter.Eventually.of_forall (oddDensity_nonneg regenerationState))] |
| apply ENNReal.ofReal_pos.mpr |
| rw [integral_Icc_eq_integral_Ioc,← intervalIntegral.integral_of_le hab.le] |
| exact hi |
| |
| noncomputable def markProbability : ℝ≥0∞ := |
| oddKernel regenerationState (Icc (209/100:ℝ) (213/100)) |
| |
| lemma markProbability_pos : 0 < markProbability := |
| regeneration_interval_positive (by norm_num) (by norm_num) |
| |
| lemma markProbability_lt_one : markProbability < 1 := by |
| let J := Icc (5/2:ℝ) (13/5) |
| have hJ : 0 < oddKernel regenerationState J := regeneration_interval_positive (by norm_num) (by norm_num) |
| have hdisj : Disjoint (Icc (209/100:ℝ) (213/100)) J := by |
| apply Set.disjoint_left.mpr |
| intro t ht hj |
| dsimp [J] at hj |
| linarith [ht.2,hj.1] |
| have hsum : markProbability+oddKernel regenerationState J ≤ 1 := by |
| rw [markProbability,← measure_union hdisj measurableSet_Icc] |
| exact prob_le_one |
| exact (ENNReal.lt_add_right (measure_ne_top _ _) hJ.ne').trans_le hsum |
| |
| lemma sourceMark_true (t : EvenState) : sourceMark t = true ↔ t.1 ∈ Icc (209/100:ℝ) (213/100) := by |
| simp [sourceMark] |
| |
| lemma markedPair_mark_mass (s : OddState) (hs : s.1 ≤ 3) (T : ℝ) : |
| markedPairKernel (s,T) {z | z.1=true} = markProbability := by |
| have hm : MeasurableSet {z : MarkedOddCost | z.1=true} := measurable_fst (measurableSet_singleton true) |
| rw [markedPair_regeneration s hs T,markedPairKernel_apply _ hm] |
| have he : {x : EvenState × OddState | sourceMark x.1=true} = |
| Prod.fst ⁻¹' {t : EvenState | t.1 ∈ Icc (209/100:ℝ) (213/100)} := by |
| ext x |
| exact sourceMark_true x.1 |
| change pairedDraws regenerationState {x : EvenState × OddState | sourceMark x.1=true} = _ |
| rw [he] |
| let E : Set EvenState := {t | t.1 ∈ Icc (209/100:ℝ) (213/100)} |
| have hE : MeasurableSet E := measurable_subtype_coe measurableSet_Icc |
| have hfst : pairedDraws.fst regenerationState E = |
| pairedDraws regenerationState {p | p.1 ∈ E} := Kernel.fst_apply' _ _ hE |
| change pairedDraws regenerationState {p | p.1 ∈ E} = _ |
| rw [← hfst,pairedDraws,Kernel.fst_compProd] |
| have hmap := oddToEven_map_ratio regenerationState |
| have hmeasure := congrArg (fun μ : Measure ℝ => μ (Icc (209/100:ℝ) (213/100))) hmap |
| rw [Measure.map_apply measurable_subtype_coe measurableSet_Icc] at hmeasure |
| exact hmeasure |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set |
| open scoped Topology |
| open NumberTheoryLean.TransitionKernels NumberTheoryLean.FinitePathGeometry |
| |
| noncomputable def gapAt (r T : ℝ) : ℝ := r*Real.exp (-T) |
| |
| lemma gapAt_pathCost {i : Side} {s r : ℝ} {ts : List ℝ} |
| (hs : Valid i s) (ht : Admissible i s ts) : gapAt r (pathCost ts) = finalGap r ts := |
| (finalGap_eq_cost hs ht).symm |
| |
| lemma nextExponent_scale (a r t : ℝ) : nextExponent (a*r) t = a*nextExponent r t := by |
| unfold nextExponent |
| ring |
| |
| lemma nextGap_scale (a r t : ℝ) : nextGap (a*r) t = a*nextGap r t := by |
| unfold nextGap |
| ring |
| |
| lemma marked_draw_slack {b0 b1 r t : ℝ} (hb0 : 0 < b0) |
| (hr0 : 10*b0 ≤ r) (hr1 : r ≤ b1) (ht0 : 209/100 ≤ t) (ht1 : t ≤ 213/100) : |
| 10*b0/(313/100) ≤ nextExponent r t ∧ nextExponent r t ≤ b1/(309/100) ∧ |
| 2*b0 ≤ nextExponent r t ∧ nextExponent r t ≤ b1/2 ∧ |
| 6*b0 < nextGap r t ∧ nextGap r t/nextExponent r t=t := by |
| have hr : 0 < r := by linarith |
| have ht : 0 < t := by linarith |
| have htp : 0 < t+1 := by linarith |
| have hlow : 10*b0/(313/100) ≤ nextExponent r t := by |
| unfold nextExponent |
| exact div_le_div₀ (by positivity) hr0 htp (by linarith) |
| have hhi : nextExponent r t ≤ b1/(309/100) := by |
| unfold nextExponent |
| exact div_le_div₀ (hr.le.trans hr1) hr1 (by norm_num) (by linarith) |
| have hlo2 : 2*b0 ≤ nextExponent r t := by |
| apply (le_div_iff₀ htp).mpr |
| nlinarith |
| have hhi2 : nextExponent r t ≤ b1/2 := by |
| unfold nextExponent |
| exact div_le_div₀ (hr.le.trans hr1) hr1 (by norm_num) (by linarith) |
| have hgap : 6*b0 < nextGap r t := by |
| unfold nextGap |
| apply (lt_div_iff₀ htp).mpr |
| have hm := mul_le_mul_of_nonneg_right hr0 ht.le |
| nlinarith |
| exact ⟨hlow,hhi,hlo2,hhi2,hgap,nextRatio_identity hr ht⟩ |
| |
| lemma gapAt_le_iff {r B : ℝ} (hr : 0 < r) (hB : 0 < B) (T : ℝ) : |
| gapAt r T ≤ B ↔ Real.log (r/B) ≤ T := by |
| rw [gapAt,Real.exp_neg,← div_eq_mul_inv,div_le_iff₀ (Real.exp_pos T), |
| Real.log_le_iff_le_exp (div_pos hr hB),div_le_iff₀ hB] |
| simp only [mul_comm] |
| |
| lemma le_gapAt_iff {r A : ℝ} (hr : 0 < r) (hA : 0 < A) (T : ℝ) : |
| A ≤ gapAt r T ↔ T ≤ Real.log (r/A) := by |
| rw [gapAt,Real.exp_neg,← div_eq_mul_inv,le_div_iff₀ (Real.exp_pos T), |
| Real.le_log_iff_exp_le (div_pos hr hA),le_div_iff₀ hA] |
| simp only [mul_comm] |
| |
| lemma marked_cost_window {r b0 b1 : ℝ} (hr : 0 < r) (hb0 : 0 < b0) (hb1 : 0 < b1) (T : ℝ) : |
| 10*b0 ≤ gapAt r T ∧ gapAt r T ≤ b1 ↔ |
| Real.log (r/b1) ≤ T ∧ T ≤ Real.log (r/b1)+Real.log (b1/(10*b0)) := by |
| have he : Real.log (r/(10*b0)) = Real.log (r/b1)+Real.log (b1/(10*b0)) := by |
| rw [Real.log_div hr.ne' (by positivity),Real.log_div hr.ne' hb1.ne', |
| Real.log_div hb1.ne' (by positivity)] |
| ring |
| rw [le_gapAt_iff hr (by positivity),gapAt_le_iff hr hb1,he,and_comm] |
| |
| lemma proportional_window_width {rho b0 : ℝ} (hrho : 0 < rho) (hb0 : 0 < b0) : |
| Real.log ((rho*b0)/(10*b0)) = Real.log (rho/10) := by |
| congr 1 |
| field_simp |
| |
| lemma moving_window_cost_threshold {K rho : ℝ} (hK : 0 < K) (hrho : 0 < rho) (M : ℝ) : |
| ∀ᶠ w : ℝ in atTop, 3 ≤ w ∧ ∀ r : ℝ, w ≤ r → |
| M ≤ Real.log (r/(rho*K*(Real.log w)^2)) := by |
| have ht : Tendsto (fun w:ℝ => (Real.log w)^2/w) atTop (𝓝 0) := by |
| simpa only [one_mul,add_zero] using Real.tendsto_pow_log_div_mul_add_atTop (1:ℝ) 0 2 one_ne_zero |
| have hl : Tendsto (fun w:ℝ => (Real.exp M*rho*K)*((Real.log w)^2/w)) atTop (𝓝 0) := by |
| simpa only [mul_zero] using ht.const_mul (Real.exp M*rho*K) |
| filter_upwards [eventually_ge_atTop (3:ℝ),hl.eventually (gt_mem_nhds (show (0:ℝ)<1 by norm_num))] |
| with w hw hs |
| refine ⟨hw,?_⟩ |
| intro r hr |
| have hw0 : 0 < w := by linarith |
| have hr0 : 0 < r := hw0.trans_le hr |
| have hlog : 0 < Real.log w := Real.log_pos (by linarith) |
| have hden : 0 < rho*K*(Real.log w)^2 := by positivity |
| apply (Real.le_log_iff_exp_le (div_pos hr0 hden)).mpr |
| apply (le_div_iff₀ hden).mpr |
| have he := (div_le_iff₀ hw0).mp (show (Real.exp M*rho*K*(Real.log w)^2)/w ≤ 1 by simpa only [mul_div_assoc] using hs.le) |
| nlinarith |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| end Erdos970 |
| |
| end OAI |
| |
