| import OAI.Probability.DirectionalWalk.Avoidance |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Filter Preorder |
| open scoped ENNReal BigOperators Topology |
|
|
| namespace DirectionalZeroOne |
|
|
| def height {d : ℕ} (v : Fin d → ℝ) (x : Site d) : ℝ := ∑ i, (x i : ℝ) * v i |
|
|
| lemma height_zero {d : ℕ} (v : Fin d → ℝ) : height v 0 = 0 := by simp [height] |
|
|
| lemma height_add {d : ℕ} (v : Fin d → ℝ) (x y : Site d) : |
| height v (x+y) = height v x + height v y := by |
| simp only [height, Pi.add_apply, Int.cast_add, add_mul, Finset.sum_add_distrib] |
|
|
| lemma height_neg {d : ℕ} (v : Fin d → ℝ) (x : Site d) : |
| height v (-x) = -height v x := by simp [height, Finset.sum_neg_distrib] |
|
|
| def neverBelow {d : ℕ} (v : Fin d → ℝ) (a : ℝ) : Set (Path d) := |
| {X | ∀ n, a ≤ height v (X n)} |
|
|
| def nonBacktracking {d : ℕ} (v : Fin d → ℝ) : Set (Path d) := neverBelow v 0 |
|
|
| lemma measurableSet_neverBelow {d : ℕ} (v : Fin d → ℝ) (a : ℝ) : |
| MeasurableSet (neverBelow v a) := by |
| simp only [neverBelow, Set.ofPred_forall] |
| exact MeasurableSet.iInter (fun n => measurableSet_le measurable_const |
| ((measurable_of_countable (height v)).comp (measurable_pi_apply n))) |
|
|
| lemma measurableSet_nonBacktracking {d : ℕ} (v : Fin d → ℝ) : |
| MeasurableSet (nonBacktracking v) := measurableSet_neverBelow v 0 |
|
|
| lemma shiftPath_preimage_neverBelow {d : ℕ} (v : Fin d → ℝ) (z : Site d) : |
| shiftPath z ⁻¹' neverBelow v (height v z) = nonBacktracking v := by |
| ext X |
| simp only [Set.mem_preimage, neverBelow, nonBacktracking, Set.mem_ofPred_eq, |
| shiftPath, height_add, le_add_iff_nonneg_left] |
|
|
| lemma annealed_neverBelow_start {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (x : Site d) : |
| annealed μ x (neverBelow v (height v x)) = annealed μ 0 (nonBacktracking v) := by |
| have h := congrArg (fun ξ : Measure (Path d) => ξ (neverBelow v (height v x))) |
| (annealed_shift μ 0 x) |
| rw [Measure.map_apply (measurable_shiftPath x) (measurableSet_neverBelow v _), |
| shiftPath_preimage_neverBelow, zero_add] at h |
| exact h.symm |
|
|
| lemma annealed_prefix_tail_null {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (x : Site d) (n : ℕ) (γ : Path d) {E : Set (Path d)} (hE : MeasurableSet E) |
| (hzero : annealed μ (γ n) E = 0) : |
| annealed μ x (pathCylinder n γ ∩ tailPath n ⁻¹' E) = 0 := by |
| have hae : ∀ᵐ ω ∂environmentLaw μ, quenchedKernel d (ω,γ n) E = 0 := by |
| apply (lintegral_eq_zero_iff |
| ((Kernel.measurable_coe _ hE).comp (measurable_id.prodMk measurable_const))).mp |
| change (∫⁻ ω, quenchedKernel d (ω,γ n) E ∂environmentLaw μ) = 0 |
| rw [← annealed_apply μ (γ n) hE] |
| exact hzero |
| rw [annealed_apply μ x ((measurableSet_pathCylinder n γ).inter ((measurable_tailPath n) hE))] |
| calc |
| _ = ∫⁻ _ : Environment d, (0 : ℝ≥0∞) ∂environmentLaw μ := by |
| apply lintegral_congr_ae |
| filter_upwards [hae] with ω hω |
| rw [quenched_prefix_tail_apply _ _ _ _ hE, hω, mul_zero] |
| _ = 0 := lintegral_zero |
|
|
| def extendPrefix {d : ℕ} (n : ℕ) (a : Finset.Iic n → Site d) : Path d := |
| fun i => if hi : i ∈ Finset.Iic n then a ⟨i,hi⟩ else 0 |
|
|
| lemma extendPrefix_apply {d : ℕ} (n : ℕ) (a : Finset.Iic n → Site d) {i : ℕ} (hi : i ≤ n) : |
| extendPrefix n a i = a ⟨i, Finset.mem_Iic.mpr hi⟩ := by |
| simp only [extendPrefix, dite_eq_left (Finset.mem_Iic.mpr hi)] |
|
|
| lemma restrict_extendPrefix {d : ℕ} (n : ℕ) (a : Finset.Iic n → Site d) : |
| frestrictLe n (extendPrefix n a) = a := by |
| funext i |
| exact extendPrefix_apply n a (Finset.mem_Iic.mp i.property) |
|
|
| lemma set_eq_iUnion_prefix_inter {d : ℕ} (E : Set (Path d)) (n : ℕ) : |
| E = ⋃ a : Finset.Iic n → Site d, E ∩ pathCylinder n (extendPrefix n a) := by |
| ext X |
| simp only [Set.mem_iUnion, Set.mem_inter_iff] |
| constructor |
| · intro hX |
| refine ⟨frestrictLe n X, hX, fun i hi => ?_⟩ |
| rw [extendPrefix_apply n _ hi] |
| rfl |
| · rintro ⟨a,hX,_⟩ |
| exact hX |
|
|
| lemma measure_zero_of_prefix_inter {d : ℕ} (μ : Measure (Path d)) (n : ℕ) |
| (E : Set (Path d)) (h : ∀ a : Finset.Iic n → Site d, |
| μ (E ∩ pathCylinder n (extendPrefix n a)) = 0) : μ E = 0 := by |
| rw [set_eq_iUnion_prefix_inter E n] |
| exact measure_iUnion_null h |
|
|
| lemma annealed_tail_start_null {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (y x : Site d) (n : ℕ) {E : Set (Path d)} (hE : MeasurableSet E) |
| (hzero : annealed μ x E = 0) : |
| annealed μ y ({X | X n = x} ∩ tailPath n ⁻¹' E) = 0 := by |
| classical |
| apply measure_zero_of_prefix_inter _ n |
| intro a |
| let γ := extendPrefix n a |
| by_cases hx : γ n = x |
| · apply measure_mono_null _ (annealed_prefix_tail_null μ y n γ hE (by simpa [hx] using hzero)) |
| rintro X ⟨⟨_,hX⟩,hC⟩ |
| exact ⟨hC,hX⟩ |
| · have he : ({X : Path d | X n = x} ∩ tailPath n ⁻¹' E) ∩ pathCylinder n γ = ∅ := by |
| apply Set.eq_empty_iff_forall_notMem.mpr |
| rintro X ⟨⟨hX,_⟩,hC⟩ |
| exact hx ((hC n le_rfl).symm.trans hX) |
| rw [he, measure_empty] |
|
|
| lemma escape_subset_globalMinimum_suffix {d : ℕ} (v : Fin d → ℝ) : |
| escape v ⊆ ⋃ n : ℕ, ⋃ x : Site d, |
| {X | X n = x} ∩ tailPath n ⁻¹' neverBelow v (height v x) := by |
| intro X hX |
| have ht : Tendsto (fun n => height v (X n)) cofinite atTop := by |
| simpa only [Nat.cofinite_eq_atTop, height] using (show Tendsto (fun n => ∑ i, (X n i : ℝ) * v i) atTop atTop from hX) |
| obtain ⟨n,hn⟩ := ht.exists_forall_le |
| apply Set.mem_iUnion.mpr |
| refine ⟨n, Set.mem_iUnion.mpr ⟨X n, rfl, ?_⟩⟩ |
| intro k |
| exact hn (n+k) |
|
|
| lemma positive_nonBacktracking {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (hescape : 0 < annealed μ 0 (escape v)) : |
| 0 < annealed μ 0 (nonBacktracking v) := by |
| by_contra h |
| have hz : annealed μ 0 (nonBacktracking v) = 0 := |
| le_antisymm (le_of_not_gt h) (zero_le) |
| have hnull : annealed μ 0 (⋃ n : ℕ, ⋃ x : Site d, |
| {X | X n = x} ∩ tailPath n ⁻¹' neverBelow v (height v x)) = 0 := by |
| apply measure_iUnion_null |
| intro n |
| apply measure_iUnion_null |
| intro x |
| apply annealed_tail_start_null μ 0 x n (measurableSet_neverBelow v _) |
| rw [annealed_neverBelow_start, hz] |
| exact (ne_of_gt hescape) (measure_mono_null (escape_subset_globalMinimum_suffix v) hnull) |
|
|
| lemma annealed_record_tail {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (x : Site d) (n : ℕ) (γ : Path d) |
| (hrec : ∀ i < n, height v (γ i) < height v (γ n)) |
| {E : Set (Path d)} (hE : MeasurableSet E) |
| (hD : E ⊆ neverBelow v (height v (γ n))) : |
| annealed μ x (pathCylinder n γ ∩ tailPath n ⁻¹' E) = |
| annealed μ x (pathCylinder n γ) * annealed μ (γ n) E := by |
| let K : Set (Site d) := {y | height v y < height v (γ n)} |
| have hav : E ⊆ avoids K := by |
| intro X hX i hi |
| exact (not_lt_of_ge (hD hX i)) hi |
| have hEq : E ∩ avoids K = E := Set.inter_eq_left.mpr hav |
| simpa only [hEq] using annealed_fresh_prefix_tail μ K x n γ hrec hE |
|
|
| lemma annealed_record_relative_tail {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (x : Site d) (n : ℕ) (γ : Path d) |
| (hrec : ∀ i < n, height v (γ i) < height v (γ n)) |
| {E : Set (Path d)} (hE : MeasurableSet E) : |
| annealed μ x (pathCylinder n γ ∩ |
| tailPath n ⁻¹' (shiftPath (-(γ n)) ⁻¹' (E ∩ nonBacktracking v))) = |
| annealed μ x (pathCylinder n γ) * annealed μ 0 (E ∩ nonBacktracking v) := by |
| have hF := hE.inter (measurableSet_nonBacktracking v) |
| rw [annealed_record_tail μ v x n γ hrec ((measurable_shiftPath _) hF)] |
| · congr 1 |
| have h := congrArg (fun ξ : Measure (Path d) => |
| ξ (shiftPath (-(γ n)) ⁻¹' (E ∩ nonBacktracking v))) (annealed_shift μ 0 (γ n)) |
| rw [Measure.map_apply (measurable_shiftPath _) ((measurable_shiftPath _) hF), zero_add] at h |
| have heq : shiftPath (γ n) ⁻¹' (shiftPath (-(γ n)) ⁻¹' (E ∩ nonBacktracking v)) = |
| E ∩ nonBacktracking v := by |
| ext X |
| simp only [Set.mem_preimage] |
| have hs : shiftPath (-(γ n)) (shiftPath (γ n) X) = X := by |
| funext i |
| simp [shiftPath] |
| rw [hs] |
| rw [heq] at h |
| exact h.symm |
| · intro X hX i |
| have hi := hX.2 i |
| change 0 ≤ height v (X i + -(γ n)) at hi |
| rw [height_add, height_neg] at hi |
| linarith |
|
|
| def pathFiltration (d : ℕ) : Filtration ℕ (inferInstance : MeasurableSpace (Path d)) := |
| Filtration.piLE |
|
|
| lemma pathFiltration_eq {d : ℕ} (n : ℕ) : pathFiltration d n = |
| MeasurableSpace.comap (frestrictLe n : Path d → _) inferInstance := |
| Filtration.piLE_eq_comap_frestrictLe n |
|
|
| lemma pathCylinder_eq_fiber {d : ℕ} (n : ℕ) (X : Path d) : |
| pathCylinder n X = (frestrictLe n : Path d → (Finset.Iic n → Site d)) ⁻¹' {frestrictLe n X} := by |
| ext Y |
| simp only [Set.mem_preimage, Set.mem_singleton_iff] |
| constructor |
| · intro h |
| funext i |
| exact h i (Finset.mem_Iic.mp i.property) |
| · intro h i hi |
| exact congr_fun h ⟨i,Finset.mem_Iic.mpr hi⟩ |
|
|
| lemma measurableSet_pathCylinder_filtration {d : ℕ} (n : ℕ) (X : Path d) : |
| MeasurableSet[pathFiltration d n] (pathCylinder n X) := by |
| rw [pathFiltration_eq, pathCylinder_eq_fiber] |
| exact ⟨_, measurableSet_singleton _, rfl⟩ |
|
|
| lemma pathFiltration_iSup (d : ℕ) : (⨆ n, pathFiltration d n) = |
| (inferInstance : MeasurableSpace (Path d)) := by |
| apply le_antisymm (iSup_le (pathFiltration d).le) |
| have hi : @Measurable (Path d) (Path d) (⨆ n, pathFiltration d n) _ id := by |
| apply @Measurable.of_eval (Path d) ℕ (fun _ => Site d) (⨆ n, pathFiltration d n) _ |
| intro n |
| have hn : Measurable[pathFiltration d n] (fun X : Path d => X n) := by |
| rw [pathFiltration_eq] |
| exact (show Measurable (fun a : Finset.Iic n → Site d => a ⟨n, Finset.mem_Iic.mpr le_rfl⟩) |
| from measurable_pi_apply _).comp (Measurable.of_comap_le |
| (f := (frestrictLe n : Path d → (Finset.Iic n → Site d))) le_rfl) |
| exact hn.mono (le_iSup _ n) le_rfl |
| simpa using hi.comap_le |
|
|
| lemma ae_pathCylinder_ne_zero {d : ℕ} (μ : Measure (Path d)) : |
| ∀ᵐ X ∂μ, ∀ n, μ (pathCylinder n X) ≠ 0 := by |
| have ha (n : ℕ) (a : Finset.Iic n → Site d) : |
| ∀ᵐ X ∂μ, X ∈ pathCylinder n (extendPrefix n a) → |
| μ (pathCylinder n (extendPrefix n a)) ≠ 0 := by |
| by_cases hz : μ (pathCylinder n (extendPrefix n a)) = 0 |
| · have hh : ∀ᵐ X ∂μ, X ∉ pathCylinder n (extendPrefix n a) := by |
| rw [ae_iff] |
| simpa using hz |
| filter_upwards [hh] with X hX using fun hx => (hX hx).elim |
| · exact ae_of_all _ (fun _ _ => hz) |
| filter_upwards [ae_all_iff.mpr (fun n => ae_all_iff.mpr (ha n))] with X hX |
| intro n |
| have heq : pathCylinder n (extendPrefix n (frestrictLe n X)) = pathCylinder n X := by |
| rw [pathCylinder_eq_fiber, restrict_extendPrefix, ← pathCylinder_eq_fiber] |
| have hmem : X ∈ pathCylinder n X := fun _ _ => rfl |
| simpa only [heq] using hX n (frestrictLe n X) (heq.symm ▸ hmem) |
|
|
| lemma condExp_indicator_cylinder {d : ℕ} (μ : Measure (Path d)) [IsFiniteMeasure μ] |
| {E : Set (Path d)} (hE : MeasurableSet E) (n : ℕ) (X : Path d) : |
| μ.real (pathCylinder n X) * (μ[E.indicator (fun _ => (1 : ℝ)) | pathFiltration d n]) X = |
| μ.real (E ∩ pathCylinder n X) := by |
| let f := μ[E.indicator (fun _ => (1 : ℝ)) | pathFiltration d n] |
| have hf : StronglyMeasurable[MeasurableSpace.comap (frestrictLe n) inferInstance] f := by |
| rw [← pathFiltration_eq] |
| exact stronglyMeasurable_condExp |
| have hconst : ∫ Y in pathCylinder n X, f Y ∂μ = |
| μ.real (pathCylinder n X) * f X := by |
| calc |
| _ = ∫ _ in pathCylinder n X, f X ∂μ := by |
| apply setIntegral_congr_fun (measurableSet_pathCylinder n X) |
| intro Y hY |
| apply hf.factorsThrough |
| simpa only [pathCylinder_eq_fiber, Set.mem_preimage, Set.mem_singleton_iff] using hY |
| _ = _ := by rw [setIntegral_const, smul_eq_mul] |
| rw [← hconst, setIntegral_condExp ((pathFiltration d).le n) (integrable_const 1 |>.indicator hE) |
| (measurableSet_pathCylinder_filtration n X)] |
| rw [setIntegral_indicator hE, setIntegral_const, smul_eq_mul, mul_one, Set.inter_comm] |
|
|
| lemma null_of_prefix_contraction {d : ℕ} (μ : Measure (Path d)) [IsFiniteMeasure μ] |
| {E : Set (Path d)} (hE : MeasurableSet E) (c : ℝ) (hc : c < 1) |
| (hcontract : ∀ X ∈ E, ∃ᶠ n in atTop, |
| μ.real (E ∩ pathCylinder n X) ≤ c * μ.real (pathCylinder n X)) : μ E = 0 := by |
| have hint : Integrable (E.indicator (fun _ => (1 : ℝ))) μ := |
| (integrable_const 1).indicator hE |
| have hmeas : StronglyMeasurable[⨆ n, pathFiltration d n] |
| (E.indicator (fun _ => (1 : ℝ))) := by |
| rw [pathFiltration_iSup] |
| exact stronglyMeasurable_const.indicator hE |
| have ht := hint.tendsto_ae_condExp (ℱ := pathFiltration d) hmeas |
| rw [measure_eq_zero_iff_ae_notMem] |
| filter_upwards [ht, ae_pathCylinder_ne_zero μ] with X hX hpos |
| intro hXE |
| have htX : Tendsto (fun n => (μ[E.indicator (fun _ => (1 : ℝ)) | pathFiltration d n]) X) |
| atTop (𝓝 (1 : ℝ)) := by simpa [hXE] using hX |
| have hlow : ∃ᶠ n in atTop, |
| (μ[E.indicator (fun _ => (1 : ℝ)) | pathFiltration d n]) X ≤ c := by |
| apply (hcontract X hXE).mono |
| intro n hn |
| rw [← condExp_indicator_cylinder μ hE n X, mul_comm c] at hn |
| exact (mul_le_mul_iff_right₀ (ENNReal.toReal_pos (hpos n) (measure_ne_top _ _))).mp hn |
| have hhigh : ∀ᶠ n in atTop, |
| c < (μ[E.indicator (fun _ => (1 : ℝ)) | pathFiltration d n]) X := |
| htX.eventually (lt_mem_nhds hc) |
| exact (hlow.and_eventually hhigh).exists.elim (fun _ hh => (not_lt_of_ge hh.1) hh.2) |
|
|
| lemma real_contraction_of_disjoint_success {Ω : Type*} [MeasurableSpace Ω] |
| (μ : Measure Ω) [IsFiniteMeasure μ] {E C S : Set Ω} |
| (hC : MeasurableSet C) (hS : MeasurableSet S) |
| (hd : Disjoint (E ∩ C) (C ∩ S)) (q : ℝ) |
| (hq : μ.real (C ∩ S) = q * μ.real C) : |
| μ.real (E ∩ C) ≤ (1-q) * μ.real C := by |
| have hu : (E ∩ C) ∪ (C ∩ S) ⊆ C := by |
| rintro x (hx | hx) |
| · exact hx.2 |
| · exact hx.1 |
| have hh := measureReal_mono (μ := μ) hu |
| rw [measureReal_union hd (hC.inter hS), hq] at hh |
| linarith |
|
|
| end DirectionalZeroOne |
|
|
| end OAI |
|
|
