| import OAI.Probability.DirectionalWalk.BridgeWords |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Filter Preorder |
| open scoped ENNReal BigOperators Topology |
|
|
| namespace DirectionalZeroOne |
|
|
| open scoped Classical |
|
|
| def wordCylinder {d : ℕ} (a : Word d) : Set (Path d) := pathCylinder a.1 (wordPath a) |
|
|
| def wordEnd {d : ℕ} (a : Word d) : Site d := wordPath a a.1 |
|
|
| def wordDepartures {d : ℕ} (a : Word d) : Set (Site d) := |
| {y | ∃ i < a.1, wordPath a i = y} |
|
|
| def PrefixFreeWords {d : ℕ} (A : Set (Word d)) : Prop := |
| Pairwise (fun (a b : A) => Disjoint (wordCylinder a.val) (wordCylinder b.val)) |
|
|
| def firstHitWord {d : ℕ} (K : Set (Site d)) (a : Word d) : Prop := |
| wordEnd a ∈ K ∧ ∀ i < a.1, wordPath a i ∉ K |
|
|
| lemma firstHitWords_prefixFree {d : ℕ} (K : Set (Site d)) : |
| PrefixFreeWords {a | firstHitWord K a} := by |
| intro a b hab |
| apply Set.disjoint_left.mpr |
| intro X hXa hXb |
| have hn : a.val.1 = b.val.1 := by |
| apply le_antisymm |
| · by_contra h |
| have hlt : b.val.1 < a.val.1 := by omega |
| apply a.property.2 _ hlt |
| rw [← hXa _ hlt.le,hXb _ (le_refl _)] |
| exact b.property.1 |
| · by_contra h |
| have hlt : a.val.1 < b.val.1 := by omega |
| apply b.property.2 _ hlt |
| rw [← hXb _ hlt.le,hXa _ (le_refl _)] |
| exact a.property.1 |
| apply hab |
| apply Subtype.ext |
| have ha := (prefixWord_eq_iff a.val.1 X a.val).mpr ⟨rfl,hXa⟩ |
| have hb := (prefixWord_eq_iff a.val.1 X b.val).mpr ⟨hn,hXb⟩ |
| exact ha.symm.trans hb |
|
|
| lemma PrefixFreeWords.mono {d : ℕ} {A B : Set (Word d)} (hA : PrefixFreeWords A) |
| (hBA : B ⊆ A) : PrefixFreeWords B := by |
| intro a b hab |
| exact hA (i := ⟨a.val,hBA a.property⟩) (j := ⟨b.val,hBA b.property⟩) |
| (fun he => hab (Subtype.ext (congrArg (fun u : A => u.val) he))) |
|
|
| lemma quenched_restart_word {d : ℕ} (ω : Environment d) (x : Site d) (a : Word d) |
| {E : Set (Path d)} (hE : MeasurableSet E) : |
| quenchedKernel d (ω,x) (wordCylinder a ∩ tailPath a.1 ⁻¹' E) = |
| quenchedKernel d (ω,x) (wordCylinder a) * quenchedKernel d (ω,wordEnd a) E := by |
| rw [wordCylinder,quenched_prefix_tail_apply ω x a.1 (wordPath a) hE,quenchedKernel_cylinder] |
| rfl |
|
|
| lemma quenched_prefix_family {d : ℕ} (ω : Environment d) (x : Site d) (A : Set (Word d)) |
| (hA : PrefixFreeWords A) (E : Word d → Set (Path d)) (hE : ∀ a ∈ A, MeasurableSet (E a)) : |
| quenchedKernel d (ω,x) (⋃ a : A, wordCylinder a ∩ tailPath a.val.1 ⁻¹' E a) = |
| ∑' a : A, quenchedKernel d (ω,x) (wordCylinder a) * |
| quenchedKernel d (ω,wordEnd a) (E a) := by |
| rw [measure_iUnion (fun a b hab => (hA hab).mono Set.inter_subset_left Set.inter_subset_left) |
| (fun a : A => (measurableSet_pathCylinder a.val.1 (wordPath a.val)).inter ((measurable_tailPath _) (hE a.val a.property)))] |
| apply tsum_congr |
| intro a |
| exact quenched_restart_word ω x a (hE a a.property) |
|
|
| lemma quenched_prefix_family_bound {d : ℕ} (ω : Environment d) (x : Site d) |
| (A : Set (Word d)) (hA : PrefixFreeWords A) (E : Word d → Set (Path d)) |
| (hE : ∀ a ∈ A, MeasurableSet (E a)) (B : Set (Path d)) (c : ℝ≥0∞) |
| (hc : ∀ a ∈ A, c ≤ quenchedKernel d (ω,wordEnd a) (E a)) |
| (hsub : ∀ a ∈ A, wordCylinder a ∩ tailPath a.1 ⁻¹' E a ⊆ B) : |
| c * quenchedKernel d (ω,x) (⋃ a : A, wordCylinder a) ≤ quenchedKernel d (ω,x) B := by |
| rw [measure_iUnion (f := fun a : A => wordCylinder a.val) hA |
| (fun _ => measurableSet_pathCylinder _ _),← ENNReal.tsum_mul_left] |
| calc |
| ∑' a : A, c * quenchedKernel d (ω,x) (wordCylinder a) ≤ |
| ∑' a : A, quenchedKernel d (ω,x) (wordCylinder a) * |
| quenchedKernel d (ω,wordEnd a) (E a) := by |
| apply ENNReal.tsum_le_tsum |
| intro a |
| rw [mul_comm c] |
| exact mul_le_mul_right (hc a a.property) _ |
| _ = quenchedKernel d (ω,x) (⋃ a : A, wordCylinder a ∩ tailPath a.val.1 ⁻¹' E a) := |
| (quenched_prefix_family ω x A hA E hE).symm |
| _ ≤ _ := measure_mono (Set.iUnion_subset (fun a => hsub a a.property)) |
|
|
| lemma word_contact_transfer {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (a : Word d) (x : Site d) {E : Set (Path d)} (hE : MeasurableSet E) : |
| (∫⁻ ω, pathWeight a.1 (wordPath a) ω * |
| quenchedKernel d (ω,x) (E ∩ avoids (wordDepartures a)) ∂environmentLaw μ) = |
| (∫⁻ ω, pathWeight a.1 (wordPath a) ω ∂environmentLaw μ) * |
| annealed μ x (E ∩ avoids (wordDepartures a)) := by |
| let r : Row d := Classical.choice (nonempty_of_isProbabilityMeasure μ) |
| rw [path_departure_transfer μ (wordDepartures a) a.1 (wordPath a) |
| (fun i hi => ⟨i,hi,rfl⟩) _ (measurable_quenched_avoids_on_rows _ r _ hE), |
| annealed_apply μ x (hE.inter (measurableSet_avoids _))] |
|
|
| lemma annealed_ae_quenched {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (x : Site d) {E : Set (Path d)} (hE : MeasurableSet E) |
| (h : ∀ᵐ X ∂annealed μ x, X ∈ E) : |
| ∀ᵐ ω ∂environmentLaw μ, ∀ᵐ X ∂quenchedKernel d (ω,x), X ∈ E := by |
| have hz : annealed μ x Eᶜ = 0 := by |
| rw [ae_iff] at h |
| exact h |
| rw [annealed_apply μ x hE.compl] at hz |
| have hm : Measurable (fun ω : Environment d => quenchedKernel d (ω,x) Eᶜ) := |
| ((quenchedKernel d).measurable_coe hE.compl).comp (measurable_id.prodMk measurable_const) |
| filter_upwards [(lintegral_eq_zero_iff hm).mp hz] with ω hω |
| rw [ae_iff] |
| exact hω |
|
|
| lemma annealed_exit_band {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (x : Site d) (v : Fin d → ℝ) (hv : v ≠ 0) (a b : ℝ) : |
| ∀ᵐ X ∂annealed μ x, ∃ n, height v (X n) ∉ Set.Icc a b := by |
| filter_upwards [finite_supremum μ hell x v hv] with X hX |
| by_contra h |
| have hb : ∀ n, height v (X n) ∈ Set.Icc a b := by simpa only [not_exists,not_not] using h |
| have ht := tendsto_atBot.mp (hX ⟨b,fun n => (hb n).2⟩) (a-1) |
| obtain ⟨n,hn⟩ := ht.exists |
| have ha := (hb n).1 |
| linarith |
|
|
| lemma measurableSet_exit_band {d : ℕ} (v : Fin d → ℝ) (a b : ℝ) : |
| MeasurableSet {X : Path d | ∃ n, height v (X n) ∉ Set.Icc a b} := by |
| simp only [Set.ofPred_exists] |
| exact MeasurableSet.iUnion (fun n => |
| (((measurable_of_countable (height v)).comp (measurable_pi_apply n)) measurableSet_Icc).compl) |
|
|
| lemma quenched_exit_all_integer_bands {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) : |
| ∀ᵐ ω ∂environmentLaw μ, ∀ (x : Site d) (a b : ℤ), |
| ∀ᵐ X ∂quenchedKernel d (ω,x), ∃ n, height v (X n) ∉ Set.Icc (a : ℝ) (b : ℝ) := by |
| simp only [ae_all_iff] |
| intro x a b |
| exact annealed_ae_quenched μ x (measurableSet_exit_band v a b) |
| (annealed_exit_band μ hell x v hv a b) |
|
|
| def hitBefore {d : ℕ} (A B : Set (Site d)) : Set (Path d) := |
| {X | ∃ n, X n ∈ A ∧ ∀ i ≤ n, X i ∉ B} |
|
|
| lemma measurableSet_hitBefore {d : ℕ} (A B : Set (Site d)) : MeasurableSet (hitBefore A B) := by |
| simp only [hitBefore,Set.ofPred_exists,Set.ofPred_and,Set.ofPred_forall] |
| apply MeasurableSet.iUnion |
| intro n |
| exact (((Set.to_countable A).measurableSet).preimage (measurable_pi_apply n)).inter |
| (MeasurableSet.iInter (fun i => MeasurableSet.iInter (fun _ => |
| (((Set.to_countable B).measurableSet).preimage (measurable_pi_apply i)).compl))) |
|
|
| lemma hitBefore_disjoint {d : ℕ} (A B : Set (Site d)) : Disjoint (hitBefore A B) (hitBefore B A) := by |
| apply Set.disjoint_left.mpr |
| rintro X ⟨n,hn,hB⟩ ⟨m,hm,hA⟩ |
| rcases le_total n m with h | h |
| · exact hA n h hn |
| · exact hB m h hm |
|
|
| lemma hitBefore_union_eq_eventual {d : ℕ} (A B : Set (Site d)) (hAB : Disjoint A B) : |
| hitBefore A B ∪ hitBefore B A = {X | ∃ n, X n ∈ A ∪ B} := by |
| ext X |
| constructor |
| · rintro (⟨n,hn,_⟩ | ⟨n,hn,_⟩) |
| · exact ⟨n,Or.inl hn⟩ |
| · exact ⟨n,Or.inr hn⟩ |
| · intro h |
| let n := Nat.find h |
| have hn := Nat.find_spec h |
| have hp (i : ℕ) (hi : i < n) : X i ∉ A ∪ B := Nat.find_min h hi |
| rcases hn with ha | hb |
| · left |
| refine ⟨n,ha,fun i hi hm => ?_⟩ |
| rcases lt_or_eq_of_le hi with hir | rfl |
| · exact hp i hir (Or.inr hm) |
| · exact Set.disjoint_left.mp hAB ha hm |
| · right |
| refine ⟨n,hb,fun i hi hm => ?_⟩ |
| rcases lt_or_eq_of_le hi with hir | rfl |
| · exact hp i hir (Or.inl hm) |
| · exact Set.disjoint_left.mp hAB hm hb |
|
|
| lemma hitBefore_tail_subset {d : ℕ} (A B : Set (Site d)) (n : ℕ) (γ : Path d) |
| (hB : ∀ i < n, γ i ∉ B) : |
| pathCylinder n γ ∩ tailPath n ⁻¹' hitBefore A B ⊆ hitBefore A B := by |
| rintro X ⟨hX,m,hm,hbm⟩ |
| refine ⟨n+m,hm,fun i hi hbi => ?_⟩ |
| by_cases hin : i < n |
| · exact hB i hin (by rwa [hX i hin.le] at hbi) |
| · have hn : n ≤ i := by omega |
| obtain ⟨j,rfl⟩ := Nat.exists_eq_add_of_le hn |
| exact hbm j (by omega) hbi |
|
|
| lemma prefixWord_of_wordCylinder {d : ℕ} (a : Word d) (X : Path d) |
| (hX : X ∈ wordCylinder a) (j : ℕ) (hj : j ≤ a.1) : |
| prefixWord j X = prefixWord j (wordPath a) := by |
| apply (prefixWord_eq_iff j X _).mpr |
| refine ⟨rfl,fun i hi => ?_⟩ |
| rw [wordPath_prefixWord j _ hi] |
| exact hX i (hi.trans hj) |
|
|
| def firstPrefixWord {d : ℕ} (P : Word d → Prop) (a : Word d) : Prop := |
| P a ∧ ∀ j < a.1, ¬ P (prefixWord j (wordPath a)) |
|
|
| lemma firstPrefixWords_prefixFree {d : ℕ} (P : Word d → Prop) : |
| PrefixFreeWords {a | firstPrefixWord P a} := by |
| intro a b hab |
| apply Set.disjoint_left.mpr |
| intro X ha hb |
| have hea : prefixWord a.val.1 X = a.val := (prefixWord_eq_iff _ _ _).mpr ⟨rfl,ha⟩ |
| have heb : prefixWord b.val.1 X = b.val := (prefixWord_eq_iff _ _ _).mpr ⟨rfl,hb⟩ |
| have hn : a.val.1 = b.val.1 := by |
| apply le_antisymm |
| · by_contra h |
| have hlt : b.val.1 < a.val.1 := by omega |
| apply a.property.2 _ hlt |
| rw [← prefixWord_of_wordCylinder a.val X ha _ hlt.le,heb] |
| exact b.property.1 |
| · by_contra h |
| have hlt : a.val.1 < b.val.1 := by omega |
| apply b.property.2 _ hlt |
| rw [← prefixWord_of_wordCylinder b.val X hb _ hlt.le,hea] |
| exact a.property.1 |
| apply hab |
| apply Subtype.ext |
| rw [← hea,← heb,hn] |
|
|
| lemma firstPrefixWords_union {d : ℕ} (P : Word d → Prop) : |
| (⋃ a : {a | firstPrefixWord P a}, wordCylinder a.val) = |
| {X : Path d | ∃ n, P (prefixWord n X)} := by |
| ext X |
| constructor |
| · rintro ⟨_,⟨a,rfl⟩,ha⟩ |
| refine ⟨a.val.1,?_⟩ |
| rw [(prefixWord_eq_iff _ _ _).mpr ⟨rfl,ha⟩] |
| exact a.property.1 |
| · intro h |
| let n := Nat.find h |
| have hn : P (prefixWord n X) := Nat.find_spec h |
| have ha : firstPrefixWord P (prefixWord n X) := by |
| refine ⟨hn,fun j hj hh => ?_⟩ |
| have hX : X ∈ wordCylinder (prefixWord n X) := by |
| intro i hi |
| exact (wordPath_prefixWord n X hi).symm |
| rw [← prefixWord_of_wordCylinder _ X hX j hj.le] at hh |
| exact Nat.find_min h hj hh |
| apply Set.mem_iUnion.mpr |
| refine ⟨⟨prefixWord n X,ha⟩,?_⟩ |
| intro i hi |
| exact (wordPath_prefixWord n X hi).symm |
|
|
| def visitAfterWord {d : ℕ} (R A K : Set (Site d)) (a : Word d) : Prop := |
| wordEnd a ∈ A ∧ (∃ j ≤ a.1, wordPath a j ∈ R) ∧ ∀ j ≤ a.1, wordPath a j ∉ K |
|
|
| def visitAfter {d : ℕ} (R A K : Set (Site d)) : Set (Path d) := |
| {X | ∃ n, X n ∈ A ∧ (∃ j ≤ n, X j ∈ R) ∧ ∀ j ≤ n, X j ∉ K} |
|
|
| lemma visitAfter_eq_firstPrefix {d : ℕ} (R A K : Set (Site d)) : |
| visitAfter R A K = ⋃ a : {a | firstPrefixWord (visitAfterWord R A K) a}, wordCylinder a.val := by |
| rw [firstPrefixWords_union] |
| ext X |
| change (∃ n, X n ∈ A ∧ (∃ j ≤ n, X j ∈ R) ∧ ∀ j ≤ n, X j ∉ K) ↔ |
| ∃ n, wordPath (prefixWord n X) n ∈ A ∧ |
| (∃ j ≤ n, wordPath (prefixWord n X) j ∈ R) ∧ ∀ j ≤ n, wordPath (prefixWord n X) j ∉ K |
| apply exists_congr |
| intro n |
| rw [wordPath_prefixWord n X le_rfl] |
| constructor |
| · rintro ⟨ha,⟨j,hj,hr⟩,hk⟩ |
| refine ⟨ha,⟨j,hj,?_⟩,fun j hj => ?_⟩ |
| · rwa [wordPath_prefixWord n X hj] |
| · rw [wordPath_prefixWord n X hj] |
| exact hk j hj |
| · rintro ⟨ha,⟨j,hj,hr⟩,hk⟩ |
| refine ⟨ha,⟨j,hj,?_⟩,fun j hj => ?_⟩ |
| · rwa [wordPath_prefixWord n X hj] at hr |
| · have hh := hk j hj |
| rwa [wordPath_prefixWord n X hj] at hh |
|
|
| lemma measurableSet_visitAfter {d : ℕ} (R A K : Set (Site d)) : MeasurableSet (visitAfter R A K) := by |
| rw [visitAfter_eq_firstPrefix] |
| exact MeasurableSet.iUnion (fun _ => measurableSet_pathCylinder _ _) |
|
|
| lemma quenched_visitAfter_bound {d : ℕ} (ω : Environment d) (x : Site d) |
| (R A B C : Set (Site d)) (c : ℝ≥0∞) |
| (hc : ∀ y ∈ A, c ≤ quenchedKernel d (ω,y) (hitBefore B C)) : |
| c * quenchedKernel d (ω,x) (visitAfter R A (B ∪ C)) ≤ |
| quenchedKernel d (ω,x) (hitBefore R B ∩ hitBefore B C) := by |
| rw [visitAfter_eq_firstPrefix] |
| apply quenched_prefix_family_bound ω x _ (firstPrefixWords_prefixFree _) (fun _ => hitBefore B C) |
| (fun _ _ => measurableSet_hitBefore B C) _ c |
| · intro a ha |
| exact hc (wordEnd a) ha.1.1 |
| · intro a ha X hX |
| have hp := ha.1 |
| constructor |
| · obtain ⟨j,hj,hr⟩ := hp.2.1 |
| refine ⟨j,?_,fun i hi hbi => ?_⟩ |
| · rwa [hX.1 j hj] |
| · exact hp.2.2 i (hi.trans hj) (Or.inl (by rwa [← hX.1 i (hi.trans hj)])) |
| · exact hitBefore_tail_subset B C a.1 (wordPath a) |
| (fun i hi hci => hp.2.2 i hi.le (Or.inr hci)) hX |
|
|
| end DirectionalZeroOne |
|
|
| end OAI |
|
|
