| import Mathlib.Data.List.OfFn |
| import OAI.NumberTheory.Jacobsthal.Paths.WindowHitWords |
|
|
| namespace OAI |
|
|
| namespace Erdos970 |
|
|
| section |
|
|
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal Classical |
| open NumberTheoryLean.PairedCostProcess |
|
|
| noncomputable def allowedCycleInputs (b : Bool) (v H : ℝ) : Set OddCost := |
| Prod.snd ⁻¹' allowedCycleCosts b v H |
|
|
| lemma allowedCycleInputs_measurable (b : Bool) (v H : ℝ) : MeasurableSet (allowedCycleInputs b v H) := |
| (allowedCycleCosts_measurable b v H).preimage measurable_snd |
|
|
| noncomputable def permittedCycleBranch (b : Bool) (v H : ℝ) : Kernel OddCost OddCost := |
| cycleBranchKernel b ∘ₖ stateFilter (allowedCycleInputs_measurable b v H) |
| |
| instance permittedCycleBranch_isFiniteKernel (b : Bool) (v H : ℝ) : IsFiniteKernel (permittedCycleBranch b v H) := by |
| unfold permittedCycleBranch |
| infer_instance |
| |
| lemma permittedCycleBranch_false (v H : ℝ) : permittedCycleBranch false v H=cycleBranchKernel false := by |
| ext z : 1 |
| rw [permittedCycleBranch,stateFilter_input] |
| simp [allowedCycleInputs,allowedCycleCosts] |
| |
| lemma permittedCycleBranch_true (v H : ℝ) : |
| permittedCycleBranch true v H=cycleBranchKernel true ∘ₖ stateFilter (ordinaryCostWindow_measurable v H).compl := rfl |
| |
| lemma permittedCycleBranch_sum (v H : ℝ) : (∑ b : Bool, permittedCycleBranch b v H)=ordinaryWindowContinue v H := by |
| rw [Fintype.sum_bool,permittedCycleBranch_false,permittedCycleBranch_true,ordinaryWindowContinue,add_comm] |
| |
| noncomputable def sourceHitWordKernel : List Bool → ℝ → ℝ → Kernel OddCost OddCost |
| | [], v, H => ordinaryWindowCapture v H |
| | b::w, v, H => sourceHitWordKernel w v H ∘ₖ permittedCycleBranch b v H |
| |
| instance sourceHitWordKernel_isFiniteKernel (w : List Bool) (v H : ℝ) : IsFiniteKernel (sourceHitWordKernel w v H) := by |
| induction w with |
| | nil => change IsFiniteKernel (ordinaryWindowCapture v H); infer_instance |
| | cons b w ih => rw [sourceHitWordKernel]; infer_instance |
| |
| lemma sourceHitWordKernel_mass (w : List Bool) (v H : ℝ) : ∀ z, |
| sourceHitWordMass w v H z=sourceHitWordKernel w v H z univ := by |
| induction w with |
| | nil => intro z; exact sourceHitWordMass_nil v H z |
| | cons b w ih => |
| intro z |
| rw [sourceHitWordMass_cons,sourceHitWordKernel,permittedCycleBranch,← Kernel.comp_assoc,stateFilter_input] |
| change (if z.2 ∈ allowedCycleCosts b v H then ∫⁻ y, sourceHitWordMass w v H y ∂cycleBranchKernel b z else 0) = |
| (if z.2 ∈ allowedCycleCosts b v H then (sourceHitWordKernel w v H ∘ₖ cycleBranchKernel b) z else 0) univ |
| by_cases hz : z.2 ∈ allowedCycleCosts b v H |
| · rw [ite_eq_left hz,ite_eq_left hz,Kernel.comp_apply' _ _ _ MeasurableSet.univ] |
| exact lintegral_congr ih |
| · simp [hz] |
| |
| lemma kernel_comp_finset_sum_left {ι α β γ : Type*} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] |
| (s : Finset ι) (K : ι → Kernel α β) (D : Kernel γ α) : |
| (∑ i ∈ s, K i) ∘ₖ D = ∑ i ∈ s, K i ∘ₖ D := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert i s hi ih => simp only [Finset.sum_insert hi,Kernel.comp_add_left,ih] |
| |
| lemma kernel_comp_finset_sum_right {ι α β γ : Type*} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] |
| (s : Finset ι) (K : Kernel β γ) (D : ι → Kernel α β) : |
| K ∘ₖ (∑ i ∈ s, D i) = ∑ i ∈ s, K ∘ₖ D i := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp |
| | @insert i s hi ih => simp only [Finset.sum_insert hi,Kernel.comp_add_right,ih] |
| |
| theorem sourceHitWordKernel_sum_length (v H : ℝ) (n : ℕ) : |
| (∑ f : Fin n → Bool, sourceHitWordKernel (List.ofFn f) v H) = |
| ordinaryWindowCapture v H ∘ₖ ((ordinaryWindowContinue v H)^n) := by |
| induction n with |
| | zero => |
| simp [List.ofFn_zero,sourceHitWordKernel] |
| exact (Kernel.comp_id _).symm |
| | succ n ih => |
| rw [← (Fin.consEquiv (fun _ : Fin (n+1) => Bool)).sum_comp |
| (fun f => sourceHitWordKernel (List.ofFn f) v H)] |
| simp only [Fintype.sum_prod_type] |
| change (∑ b : Bool, ∑ f : Fin n → Bool, sourceHitWordKernel (List.ofFn (Fin.cons b f)) v H) = _ |
| simp_rw [List.ofFn_cons,sourceHitWordKernel] |
| simp_rw [← kernel_comp_finset_sum_left,ih] |
| rw [← kernel_comp_finset_sum_right,permittedCycleBranch_sum,pow_succ] |
| exact Kernel.comp_assoc _ _ _ |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal Classical |
| open NumberTheoryLean.PairedCostProcess NumberTheoryLean.PairedCostGrouping |
| open NumberTheoryLean.KernelPotential |
| |
| abbrev RawMarkedHitTrace (a : ℕ) := |
| Σ n : ℕ, Σ f : Fin n → Bool, RawCycleWordTrace a (List.ofFn f++[true]).length |
| |
| def packRawMarkedHitTrace (a n : ℕ) (f : Fin n → Bool) |
| (t : RawCycleWordTrace a (List.ofFn f++[true]).length) : RawMarkedHitTrace a := |
| @Sigma.mk ℕ (fun m => Σ g : Fin m → Bool, RawCycleWordTrace a (List.ofFn g++[true]).length) n |
| (@Sigma.mk (Fin n → Bool) (fun g => RawCycleWordTrace a (List.ofFn g++[true]).length) f t) |
| |
| lemma packRawMarkedHitTrace_measurable (a n : ℕ) (f : Fin n → Bool) : |
| Measurable (packRawMarkedHitTrace a n f) := |
| (measurableSigmaMk (X := fun m : ℕ => Σ g : Fin m → Bool, RawCycleWordTrace a (List.ofFn g++[true]).length) n).comp |
| (measurableSigmaMk (X := fun g : Fin n → Bool => RawCycleWordTrace a (List.ofFn g++[true]).length) f) |
| |
| noncomputable def rawMarkedFirstHitKernel (a : ℕ) (v H : ℝ) : Kernel (RawHistory a) (RawMarkedHitTrace a) := |
| Kernel.sum (fun n : ℕ => Kernel.sum (fun f : Fin n → Bool => |
| (rawHitWordKernel a (List.ofFn f) v H).map (packRawMarkedHitTrace a n f))) |
| |
| instance rawMarkedFirstHitKernel_isSFiniteKernel (a : ℕ) (v H : ℝ) : IsSFiniteKernel (rawMarkedFirstHitKernel a v H) := by |
| unfold rawMarkedFirstHitKernel |
| infer_instance |
| |
| theorem rawMarkedFirstHit_mass (a : ℕ) (v H : ℝ) (h : RawHistory a) (z : OddCost) |
| (hz : rawLast a h=embedOdd z) : |
| rawMarkedFirstHitKernel a v H h univ=ordinaryMarkedHit v H z univ := by |
| rw [rawMarkedFirstHitKernel,Kernel.sum_apply' _ _ MeasurableSet.univ, |
| ordinaryMarkedHit,potential,Kernel.sum_apply' _ _ MeasurableSet.univ] |
| apply tsum_congr |
| intro n |
| rw [Kernel.sum_apply' _ _ MeasurableSet.univ] |
| calc |
| _ = ∑' f : Fin n → Bool, sourceHitWordKernel (List.ofFn f) v H z univ := by |
| apply tsum_congr |
| intro f |
| rw [Kernel.map_apply' _ (packRawMarkedHitTrace_measurable a n f) _ MeasurableSet.univ, |
| preimage_univ,rawHitWord_mass a (List.ofFn f) v H h z hz,sourceHitWordKernel_mass] |
| _ = (∑ f : Fin n → Bool, sourceHitWordKernel (List.ofFn f) v H) z univ := by |
| rw [tsum_fintype,Kernel.finsetSum_apply'] |
| _ = _ := by rw [sourceHitWordKernel_sum_length] |
| |
| noncomputable def rawMarkedHitEvent (a : ℕ) (v H : ℝ) : Set (RawMarkedHitTrace a) := |
| {r | rawCycleWordSignature a (List.ofFn r.2.1++[true]).length r.2.2 ∈ hitWordEvent (List.ofFn r.2.1) v H} |
| |
| lemma rawMarkedHitEvent_measurable (a : ℕ) (v H : ℝ) : MeasurableSet (rawMarkedHitEvent a v H) := by |
| apply MeasurableSpace.measurableSet_iInf.mpr |
| intro n |
| apply MeasurableSpace.measurableSet_iInf.mpr |
| intro f |
| exact (hitWordEvent_measurable (List.ofFn f) v H).preimage (rawCycleWordSignature_measurable _ a) |
| |
| theorem rawMarkedFirstHit_ae_event (a : ℕ) (v H : ℝ) (h : RawHistory a) : |
| ∀ᵐ r ∂rawMarkedFirstHitKernel a v H h, r ∈ rawMarkedHitEvent a v H := by |
| rw [rawMarkedFirstHitKernel,Kernel.sum_apply,Measure.ae_sum_iff] |
| intro n |
| rw [Kernel.sum_apply,Measure.ae_sum_iff] |
| intro f |
| rw [Kernel.map_apply _ (packRawMarkedHitTrace_measurable a n f)] |
| apply (ae_map_iff (packRawMarkedHitTrace_measurable a n f).aemeasurable (rawMarkedHitEvent_measurable a v H)).mpr |
| rw [rawHitWordKernel,Kernel.restrict_apply] |
| exact ae_restrict_mem ((hitWordEvent_measurable (List.ofFn f) v H).preimage (rawCycleWordSignature_measurable _ a)) |
| |
| noncomputable def rawRegMarkedFirstHitKernel (a : ℕ) (v H : ℝ) : Kernel (RawHistory a) (RawMarkedHitTrace a) := |
| rawMarkedFirstHitKernel a v H ∘ₖ stateFilter (lastRegeneration_measurable a) |
| |
| lemma rawRegMarkedFirstHit_mass_le_one (a : ℕ) (v H : ℝ) (h : RawHistory a) : |
| rawRegMarkedFirstHitKernel a v H h univ ≤ 1 := by |
| rw [rawRegMarkedFirstHitKernel,stateFilter_input] |
| by_cases hReg : h ∈ lastRegeneration a |
| · rw [ite_eq_left hReg] |
| let z := decodeReturnedOdd (rawLast a h) |
| have hz : rawLast a h=embedOdd z := (embed_decodeReturnedOdd_of_regeneration _ hReg).symm |
| rw [rawMarkedFirstHit_mass a v H h z hz] |
| exact ordinaryMarkedHit_mass_le_one v H z |
| · simp [hReg] |
| |
| instance rawRegMarkedFirstHitKernel_isFiniteKernel (a : ℕ) (v H : ℝ) : IsFiniteKernel (rawRegMarkedFirstHitKernel a v H) := |
| ⟨⟨1,by simp,rawRegMarkedFirstHit_mass_le_one a v H⟩⟩ |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal |
| open NumberTheoryLean.KernelPotential |
| |
| variable {α β : Type*} [MeasurableSpace α] [MeasurableSpace β] |
| |
| lemma kernel_power_sfinite (K : Kernel α α) [IsSFiniteKernel K] (n : ℕ) : IsSFiniteKernel (K^n) := by |
| induction n with |
| | zero => change IsSFiniteKernel (Kernel.id : Kernel α α); infer_instance |
| | succ n ih => rw [pow_succ']; change IsSFiniteKernel (K ∘ₖ (K^n)); infer_instance |
| |
| lemma kernel_power_support (K : Kernel α α) [IsSFiniteKernel K] {S : Set α} (hS : MeasurableSet S) |
| (hK : ∀ x, ∀ᵐ y ∂K x, y ∈ S) (n : ℕ) (x : α) (hx : x ∈ S) : |
| ∀ᵐ y ∂(K^n) x, y ∈ S := by |
| have (m : ℕ) : IsSFiniteKernel (K^m) := kernel_power_sfinite K m |
| cases n with |
| | zero => change ∀ᵐ y ∂Measure.dirac x, y ∈ S; exact (ae_dirac_iff hS).mpr hx |
| | succ n => |
| rw [pow_succ'] |
| change ∀ᵐ y ∂(K ∘ₖ (K^n)) x, y ∈ S |
| exact Kernel.ae_comp_of_ae_ae hS (Eventually.of_forall hK) |
| |
| lemma supported_projection_power (K : Kernel α α) (L : Kernel β β) [IsSFiniteKernel K] [IsSFiniteKernel L] |
| {S : Set α} (_hS : MeasurableSet S) (hSupp : ∀ x, ∀ᵐ y ∂K x, y ∈ S) |
| {f : α → β} (hf : Measurable f) (hKL : ∀ x ∈ S, (K x).map f=L (f x)) |
| (n : ℕ) (x : α) (hx : x ∈ S) : ((K^n) x).map f=(L^n) (f x) := by |
| have (m : ℕ) : IsSFiniteKernel (K^m) := kernel_power_sfinite K m |
| have (m : ℕ) : IsSFiniteKernel (L^m) := kernel_power_sfinite L m |
| induction n generalizing x with |
| | zero => change (Measure.dirac x).map f=Measure.dirac (f x); exact Measure.map_dirac' hf x |
| | succ n ih => |
| apply Measure.ext_of_lintegral |
| intro F hF |
| have hp : K^(n+1)=(K^n) ∘ₖ K := pow_succ _ _ |
| have hq : L^(n+1)=(L^n) ∘ₖ L := pow_succ _ _ |
| rw [lintegral_map hF hf,hp,hq,Kernel.lintegral_comp _ _ _ (g := fun z => F (f z)) (hF.comp hf), |
| Kernel.lintegral_comp _ _ _ hF] |
| have he : (fun y => ∫⁻ z, F (f z) ∂(K^n) y) =ᵐ[K x] fun y => ∫⁻ z, F z ∂(L^n) (f y) := by |
| filter_upwards [hSupp x] with y hy |
| rw [← lintegral_map (g := f) hF hf,ih y hy] |
| rw [lintegral_congr_ae he] |
| have hJ : Measurable (fun y : β => ∫⁻ z, F z ∂(L^n) y) := hF.lintegral_kernel |
| rw [← lintegral_map (g := f) hJ hf,hKL x hx] |
| |
| lemma supported_projection_potential (K B : Kernel α α) (L C : Kernel β β) |
| [IsSFiniteKernel K] [IsSFiniteKernel B] [IsSFiniteKernel L] [IsSFiniteKernel C] |
| {S : Set α} (hS : MeasurableSet S) (hSupp : ∀ x, ∀ᵐ y ∂K x, y ∈ S) |
| {f : α → β} (hf : Measurable f) (hKL : ∀ x ∈ S, (K x).map f=L (f x)) |
| (hBC : ∀ x ∈ S, (B x).map f=C (f x)) (x : α) (hx : x ∈ S) : |
| (potential B K x).map f=potential C L (f x) := by |
| have (m : ℕ) : IsSFiniteKernel (K^m) := kernel_power_sfinite K m |
| have (m : ℕ) : IsSFiniteKernel (L^m) := kernel_power_sfinite L m |
| rw [potential,Kernel.sum_apply,Measure.map_sum (f := f) hf.aemeasurable,potential,Kernel.sum_apply] |
| apply congrArg Measure.sum |
| funext n |
| apply Measure.ext_of_lintegral |
| intro F hF |
| rw [lintegral_map hF hf,Kernel.lintegral_comp _ _ _ (g := fun z => F (f z)) (hF.comp hf), |
| Kernel.lintegral_comp _ _ _ hF] |
| have he : (fun y => ∫⁻ z, F (f z) ∂B y) =ᵐ[(K^n) x] fun y => ∫⁻ z, F z ∂C (f y) := by |
| filter_upwards [kernel_power_support K hS hSupp n x hx] with y hy |
| rw [← lintegral_map (g := f) hF hf,hBC y hy] |
| rw [lintegral_congr_ae he] |
| have hJ : Measurable (fun y : β => ∫⁻ z, F z ∂C y) := hF.lintegral_kernel |
| rw [← lintegral_map (g := f) hJ hf,supported_projection_power K L hS hSupp hf hKL n x hx] |
| |
| noncomputable def kernelScale (p : ℝ≥0∞) (B : Kernel α β) [IsSFiniteKernel B] : Kernel α β := |
| B.withDensity (fun _ _ => p) |
| |
| lemma kernelScale_apply (p : ℝ≥0∞) (B : Kernel α β) [IsSFiniteKernel B] (x : α) : |
| kernelScale p B x=p • B x := by |
| rw [kernelScale,Kernel.withDensity_apply _ (f := fun _ _ => p) measurable_const,withDensity_const] |
| |
| lemma kernelScale_isSFinite (p : ℝ≥0∞) (hp : p ≠ ∞) (B : Kernel α β) [IsSFiniteKernel B] : |
| IsSFiniteKernel (kernelScale p B) := Kernel.IsSFiniteKernel.withDensity B (fun _ _ => hp) |
| |
| lemma potential_scale_base (p : ℝ≥0∞) (hp : p ≠ ∞) (B : Kernel α β) (K : Kernel α α) |
| [IsSFiniteKernel B] [IsSFiniteKernel K] (x : α) : |
| potential (kernelScale p B) K x=p • potential B K x := by |
| have : IsSFiniteKernel (kernelScale p B) := kernelScale_isSFinite p hp B |
| have (n : ℕ) : IsSFiniteKernel (K^n) := kernel_power_sfinite K n |
| ext S hS |
| rw [potential,Kernel.sum_apply' _ _ hS,Measure.smul_apply,smul_eq_mul, |
| potential,Kernel.sum_apply' _ _ hS,← ENNReal.tsum_mul_left] |
| apply tsum_congr |
| intro n |
| rw [Kernel.comp_apply' _ _ _ hS,Kernel.comp_apply' _ _ _ hS] |
| simp_rw [kernelScale_apply,Measure.smul_apply,smul_eq_mul] |
| exact lintegral_const_mul' _ _ hp |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal Classical |
| open NumberTheoryLean.PairedCostProcess NumberTheoryLean.CostReturnLaw |
| open NumberTheoryLean.KernelPotential |
| |
| noncomputable def costWindowFilter (v H : ℝ) : Kernel ℝ ℝ := |
| stateFilter (S := Icc v (v+H)) measurableSet_Icc |
| |
| noncomputable def costOutsideFilter (v H : ℝ) : Kernel ℝ ℝ := |
| stateFilter (S := (Icc v (v+H))ᶜ) measurableSet_Icc.compl |
| |
| instance costWindowFilter_isFiniteKernel (v H : ℝ) : IsFiniteKernel (costWindowFilter v H) := by |
| unfold costWindowFilter |
| infer_instance |
| instance costOutsideFilter_isFiniteKernel (v H : ℝ) : IsFiniteKernel (costOutsideFilter v H) := by |
| unfold costOutsideFilter |
| infer_instance |
| |
| noncomputable def costMarkedLoop (v H : ℝ) : Kernel ℝ ℝ := markedClockKernel ∘ₖ costOutsideFilter v H |
| instance costMarkedLoop_isFiniteKernel (v H : ℝ) : IsFiniteKernel (costMarkedLoop v H) := by |
| unfold costMarkedLoop |
| infer_instance |
| |
| noncomputable def costCurrentHit (v H : ℝ) : Kernel ℝ ℝ := |
| potential (costWindowFilter v H) (costMarkedLoop v H) |
| instance costCurrentHit_isSFiniteKernel (v H : ℝ) : IsSFiniteKernel (costCurrentHit v H) := by |
| unfold costCurrentHit |
| infer_instance |
| |
| instance costWindow_stopping_isMarkov (v H : ℝ) : IsMarkovKernel (costWindowFilter v H+costMarkedLoop v H) := by |
| unfold costWindowFilter costMarkedLoop costOutsideFilter |
| infer_instance |
| |
| lemma costCurrentHit_mass_le_one (v H T : ℝ) : costCurrentHit v H T univ ≤ 1 := |
| capturePotential_mass_le_one _ _ T |
| |
| noncomputable def ordinaryMarkedLoop (v H : ℝ) : Kernel OddCost OddCost := |
| rawBeginningKernel ∘ₖ stateFilter (ordinaryCostWindow_measurable v H).compl |
| instance ordinaryMarkedLoop_isSFiniteKernel (v H : ℝ) : IsSFiniteKernel (ordinaryMarkedLoop v H) := by |
| unfold ordinaryMarkedLoop |
| infer_instance |
| |
| lemma rawBeginning_total_cost (z : OddCost) (hz : z ∈ returnSet) : |
| (rawBeginningKernel z).map Prod.snd=markedClockKernel z.2 := by |
| rw [markedClockKernel_apply] |
| calc |
| _ = ((rawBeginningKernel z).map (fun y => y.2-z.2)).map (fun G : ℝ => z.2+G) := by |
| rw [Measure.map_map (g := fun G : ℝ => z.2+G) (f := fun y : OddCost => y.2-z.2) |
| (measurable_const.add measurable_id) (measurable_snd.sub measurable_const)] |
| congr 1 |
| funext y |
| simp only [Function.comp_def,add_sub_cancel] |
| _ = _ := by rw [rawBeginning_cost_law z hz] |
| |
| lemma ordinaryMarkedLoop_support (v H : ℝ) (z : OddCost) : |
| ∀ᵐ y ∂ordinaryMarkedLoop v H z, y ∈ returnSet := by |
| rw [ordinaryMarkedLoop,stateFilter_input] |
| split_ifs |
| · exact rawBeginning_ae_regeneration z |
| · simp |
| |
| lemma ordinaryMarkedLoop_cost (v H : ℝ) (z : OddCost) (hz : z ∈ returnSet) : |
| (ordinaryMarkedLoop v H z).map Prod.snd=costMarkedLoop v H z.2 := by |
| rw [ordinaryMarkedLoop,costMarkedLoop,costOutsideFilter,stateFilter_input,stateFilter_input] |
| by_cases h : z.2 ∈ Icc v (v+H) |
| · rw [ite_eq_right (show z ∉ (ordinaryCostWindow v H)ᶜ from fun hn => hn h), |
| ite_eq_right (show z.2 ∉ (Icc v (v+H))ᶜ from fun hn => hn h),Measure.map_zero] |
| · rw [ite_eq_left (show z ∈ (ordinaryCostWindow v H)ᶜ from h), |
| ite_eq_left (show z.2 ∈ (Icc v (v+H))ᶜ from h)] |
| exact rawBeginning_total_cost z hz |
| |
| lemma cost_filter_projection (v H : ℝ) (z : OddCost) : |
| (stateFilter (ordinaryCostWindow_measurable v H) z).map Prod.snd=costWindowFilter v H z.2 := by |
| rw [stateFilter,costWindowFilter,stateFilter,Kernel.restrict_apply,Kernel.restrict_apply,Kernel.id_apply,Kernel.id_apply] |
| change ((Measure.dirac z).restrict (Prod.snd ⁻¹' Icc v (v+H))).map Prod.snd = |
| (Measure.dirac z.2).restrict (Icc v (v+H)) |
| rw [← Measure.restrict_map measurable_snd measurableSet_Icc,Measure.map_dirac' measurable_snd] |
| |
| lemma ordinaryWindowCapture_on_regeneration (v H : ℝ) (z : OddCost) (hz : z ∈ returnSet) : |
| ordinaryWindowCapture v H z=markProbability • stateFilter (ordinaryCostWindow_measurable v H) z := by |
| have hp : nextMarkWeight z=markProbability := cycleBranch_true_mass z hz |
| rw [ordinaryWindowCapture,Kernel.restrict_apply,markInputWeightKernel_apply,hp,Measure.restrict_smul] |
| rfl |
| |
| lemma ordinaryWindowCapture_cost (v H : ℝ) (z : OddCost) (hz : z ∈ returnSet) : |
| (ordinaryWindowCapture v H z).map Prod.snd=kernelScale markProbability (costWindowFilter v H) z.2 := by |
| rw [ordinaryWindowCapture_on_regeneration v H z hz,Measure.map_smul _ measurable_snd.aemeasurable,cost_filter_projection,kernelScale_apply] |
| |
| theorem ordinaryMarkedPotential_cost (v H : ℝ) (z : OddCost) (hz : z ∈ returnSet) : |
| (potential (ordinaryWindowCapture v H) (ordinaryMarkedLoop v H) z).map Prod.snd = |
| markProbability • costCurrentHit v H z.2 := by |
| have : IsSFiniteKernel (kernelScale markProbability (costWindowFilter v H)) := |
| kernelScale_isSFinite markProbability markProbability_ne_top _ |
| rw [supported_projection_potential (ordinaryMarkedLoop v H) (ordinaryWindowCapture v H) |
| (costMarkedLoop v H) (kernelScale markProbability (costWindowFilter v H)) |
| returnSet_measurable (ordinaryMarkedLoop_support v H) measurable_snd |
| (ordinaryMarkedLoop_cost v H) (ordinaryWindowCapture_cost v H) z hz, |
| potential_scale_base markProbability markProbability_ne_top] |
| rfl |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| section |
| |
| namespace Erdos970Dependency.MarkedVisits |
| open Filter Set MeasureTheory ProbabilityTheory |
| open scoped ProbabilityTheory ENNReal |
| open NumberTheoryLean.PairedCostProcess NumberTheoryLean.CostReturnLaw |
| open NumberTheoryLean.InitialRegeneration NumberTheoryLean.TransitionKernels |
| open NumberTheoryLean.KernelPotential |
| |
| lemma unmarkedStar_support (z : OddCost) (hz : z ∈ returnSet) : |
| ∀ᵐ y ∂unmarkedStar z, y ∈ returnSet := by |
| rw [unmarkedStar,potential,Kernel.sum_apply,Measure.ae_sum_iff] |
| intro n |
| rw [Kernel.id_comp] |
| exact cycleBranch_pow_ae_regeneration false n z hz |
| |
| lemma ordinaryMarkedPotential_mass (v H : ℝ) (z : OddCost) (hz : z ∈ returnSet) : |
| potential (ordinaryWindowCapture v H) (ordinaryMarkedLoop v H) z univ = |
| markProbability*costCurrentHit v H z.2 univ := by |
| have he := congrArg (fun μ : Measure ℝ => μ univ) (ordinaryMarkedPotential_cost v H z hz) |
| rw [Measure.map_apply measurable_snd MeasurableSet.univ,preimage_univ,Measure.smul_apply,smul_eq_mul] at he |
| exact he |
| |
| theorem ordinaryMarkedHit_first_mark_reduction (v H : ℝ) (z : OddCost) (hz : z ∈ returnSet) : |
| ordinaryMarkedHit v H z univ = |
| ∫⁻ y, costCurrentHit v H y.2 univ ∂rawFirstMarkedBeginning z := by |
| have hQ : Measurable (fun y : OddCost => costCurrentHit v H y.2 univ) := |
| ((costCurrentHit v H).measurable_coe MeasurableSet.univ).comp measurable_snd |
| rw [ordinaryMarkedHit_denested,Kernel.comp_apply' _ _ _ MeasurableSet.univ, |
| rawFirstMarkedBeginning,Kernel.withDensity_apply _ (f := fun _ y : OddCost => nextMarkWeight y) |
| (nextMarkWeight_measurable.comp measurable_snd), |
| lintegral_withDensity_eq_lintegral_mul _ nextMarkWeight_measurable hQ] |
| change (∫⁻ y, potential (ordinaryWindowCapture v H) (ordinaryMarkedLoop v H) y univ ∂unmarkedStar z) = |
| ∫⁻ y, nextMarkWeight y*costCurrentHit v H y.2 univ ∂unmarkedStar z |
| apply lintegral_congr_ae |
| filter_upwards [unmarkedStar_support z hz] with y hy |
| rw [ordinaryMarkedPotential_mass v H y hy] |
| have hp : nextMarkWeight y=markProbability := cycleBranch_true_mass y hy |
| rw [hp] |
| |
| noncomputable def ordinaryInitialHitMass (s : EvenState) (v H : ℝ) : ℝ≥0∞ := |
| ∫⁻ z, ordinaryMarkedHit v H z univ ∂delayedRegeneration s |
| |
| lemma ordinaryInitialHitMass_le_one (s : EvenState) (v H : ℝ) : ordinaryInitialHitMass s v H ≤ 1 := by |
| calc |
| _ ≤ ∫⁻ _z, (1:ℝ≥0∞) ∂delayedRegeneration s := lintegral_mono (ordinaryMarkedHit_mass_le_one v H) |
| _ = 1 := by simp |
| |
| theorem ordinaryInitialHit_cost_law (s : EvenState) (v H : ℝ) : |
| ordinaryInitialHitMass s v H = ∫⁻ T, costCurrentHit v H T univ ∂initialMarkedCostLaw s := by |
| have hQ : Measurable (fun y : OddCost => costCurrentHit v H y.2 univ) := |
| ((costCurrentHit v H).measurable_coe MeasurableSet.univ).comp measurable_snd |
| rw [ordinaryInitialHitMass,initialMarkedCostLaw, |
| lintegral_map ((costCurrentHit v H).measurable_coe MeasurableSet.univ) measurable_snd, |
| initialMarkedBeginning,Kernel.lintegral_comp _ _ _ hQ] |
| apply lintegral_congr_ae |
| filter_upwards [delayedRegeneration_ae_regeneration s] with z hz |
| exact ordinaryMarkedHit_first_mark_reduction v H z hz |
| |
| end Erdos970Dependency.MarkedVisits |
| |
| end |
| |
| end Erdos970 |
| |
| end OAI |
| |
