| import OAI.Probability.DirectionalWalk.HittingWords |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Filter Preorder |
| open scoped ENNReal BigOperators Topology |
|
|
| namespace DirectionalZeroOne |
|
|
| open scoped Classical |
|
|
| def oppositeStep {d : ℕ} (e : Step d) : Step d := (e.1,!e.2) |
|
|
| lemma axisDirection_opposite {d : ℕ} (e : Step d) : |
| axisDirection (oppositeStep e) = -axisDirection e := by |
| ext i |
| rcases e with ⟨j,b⟩ |
| cases b <;> simp [axisDirection,oppositeStep,Pi.single_apply] <;> split_ifs <;> norm_num |
|
|
| lemma axisHeight_opposite {d : ℕ} (e : Step d) (x : Site d) : |
| axisHeight (oppositeStep e) x = -axisHeight e x := by |
| rcases e with ⟨i,b⟩ |
| cases b <;> simp [axisHeight,oppositeStep] |
|
|
| lemma axisHeight_neg {d : ℕ} (e : Step d) (x : Site d) : |
| axisHeight e (-x) = -axisHeight e x := by |
| rcases e with ⟨i,b⟩ |
| cases b <;> simp [axisHeight] |
|
|
| lemma axisHeight_sum {d : ℕ} {ι : Type*} (e : Step d) (s : Finset ι) (f : ι → Site d) : |
| axisHeight e (∑ i ∈ s, f i) = ∑ i ∈ s, axisHeight e (f i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp [axisHeight_zero] |
| | @insert i s hi ih => simp [Finset.sum_insert hi,axisHeight_add,ih] |
|
|
| lemma axisHeight_step_self {d : ℕ} (e : Step d) : axisHeight e (stepVector e) = 1 := by |
| rcases e with ⟨i,b⟩ |
| cases b <;> simp [axisHeight,stepVector] |
|
|
| lemma axisHeight_wordEnd {d : ℕ} (e : Step d) (a : Word d) |
| (ha : RegenerationWord (axisDirection e) a) : |
| axisHeight e (wordEnd a) = (slabRecords (axisDirection e) a : ℤ) := by |
| have h := axis_slabWidth_eq_records e a ha |
| change height (axisDirection e) (wordEnd a) = _ at h |
| rw [height_axisDirection] at h |
| exact_mod_cast h |
|
|
| lemma axisHeight_word_interior {d : ℕ} (e : Step d) (a : Word d) |
| (ha : RegenerationWord (axisDirection e) a) (i : ℕ) (hi : i < a.1) : |
| 0 ≤ axisHeight e (wordPath a i) ∧ |
| axisHeight e (wordPath a i) < (slabRecords (axisDirection e) a : ℤ) := by |
| have h := ha.2.2.2.1 i hi |
| have hh := axisHeight_wordEnd e a ha |
| change axisHeight e (wordPath a a.1) = _ at hh |
| rw [height_axisDirection,height_axisDirection,hh] at h |
| exact ⟨by exact_mod_cast h.1,by exact_mod_cast h.2⟩ |
|
|
| def placedAxis {d : ℕ} (e : Step d) (b : Bool) : Step d := if b then oppositeStep e else e |
|
|
| noncomputable def placedWidth {d : ℕ} (e : Step d) (b : Bool) : Word d → ℕ := |
| slabRecords (axisDirection (placedAxis e b)) |
|
|
| def opposedAnchor {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) (b : Bool) (i : ℕ) : Site d := |
| if b then -stepVector e + ∑ j ∈ Finset.range i, wordEnd (Z (true,j)) |
| else -(∑ j ∈ Finset.range (i+1), wordEnd (Z (false,j))) |
|
|
| def opposedSite {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) (b : Bool) (i t : ℕ) : Site d := |
| opposedAnchor e Z b i + wordPath (Z (b,i)) t |
|
|
| def opposedDeparture {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) (b : Bool) (y : Site d) : Prop := |
| ∃ i, ∃ t < (Z (b,i)).1, opposedSite e Z b i t = y |
|
|
| def contactAt {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) (y : Site d) : Prop := |
| opposedDeparture e Z false y ∧ opposedDeparture e Z true y |
|
|
| def contactDepth {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) (h : ℕ) : Prop := |
| ∃ y, contactAt e Z y ∧ -axisHeight e y = (h : ℤ) |
|
|
| lemma opposedAnchor_height {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) |
| (hZ : ∀ b i, RegenerationWord (axisDirection (placedAxis e b)) (Z (b,i))) |
| (b : Bool) (i : ℕ) : |
| -axisHeight e (opposedAnchor e Z b i) = |
| if b then 1 + (tapeHeight (placedWidth e true) (fun j => Z (true,j)) i : ℤ) |
| else (tapeHeight (placedWidth e false) (fun j => Z (false,j)) (i+1) : ℤ) := by |
| have hp (j : ℕ) : axisHeight e (wordEnd (Z (false,j))) = (placedWidth e false (Z (false,j)) : ℤ) := |
| axisHeight_wordEnd e _ (hZ false j) |
| have hm (j : ℕ) : axisHeight e (wordEnd (Z (true,j))) = -(placedWidth e true (Z (true,j)) : ℤ) := by |
| have hh := axisHeight_wordEnd (oppositeStep e) _ (hZ true j) |
| rw [axisHeight_opposite] at hh |
| exact neg_eq_iff_eq_neg.mp hh |
| cases b <;> simp [opposedAnchor,axisHeight_neg,axisHeight_add,axisHeight_sum, |
| axisHeight_step_self,hp,hm,tapeHeight,Finset.sum_neg_distrib,add_comm] |
|
|
| lemma opposed_departure_band {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) |
| (hZ : ∀ b i, RegenerationWord (axisDirection (placedAxis e b)) (Z (b,i))) |
| (b : Bool) (i t : ℕ) (ht : t < (Z (b,i)).1) : |
| let s := tapeHeight (placedWidth e b) (fun j => Z (b,j)) i |
| let L := placedWidth e b (Z (b,i)) |
| (s : ℤ) < -axisHeight e (opposedSite e Z b i t) ∧ |
| -axisHeight e (opposedSite e Z b i t) ≤ (s+L : ℕ) := by |
| have hc := axisHeight_word_interior (placedAxis e b) (Z (b,i)) (hZ b i) t ht |
| have ha := opposedAnchor_height e Z hZ b i |
| dsimp only |
| unfold opposedSite |
| rw [axisHeight_add] |
| cases b |
| · simp only [placedAxis,Bool.false_eq_true,↓reduceIte] at hc ha |
| simp only [tapeHeight,Finset.sum_range_succ,Nat.cast_add] at ha ⊢ |
| simp only [placedWidth,placedAxis,Bool.false_eq_true,↓reduceIte] at * |
| omega |
| · simp only [placedAxis,↓reduceIte,axisHeight_opposite] at hc ha |
| simp only [placedWidth,placedAxis,↓reduceIte] at * |
| push_cast |
| omega |
|
|
| lemma axial_step_unique {d : ℕ} (e f : Step d) (h : axisHeight e (stepVector f) = 1) : |
| f = e := by |
| rcases e with ⟨i,b⟩ |
| rcases f with ⟨j,c⟩ |
| by_cases hij : i = j |
| · subst j |
| cases b <;> cases c <;> simp_all [axisHeight,stepVector] |
| · cases b <;> cases c <;> simp [axisHeight,stepVector,hij] at h |
|
|
| lemma axis_word_last_step {d : ℕ} (e : Step d) (a : Word d) |
| (ha : RegenerationWord (axisDirection e) a) : |
| wordEnd a = wordPath a (a.1-1) + stepVector e := by |
| have hp : a.1-1 < a.1 := by have := ha.1; omega |
| have hh := axisHeight_word_interior e a ha (a.1-1) hp |
| obtain ⟨f,hf⟩ := ha.2.2.1 (a.1-1) hp |
| rw [Nat.sub_add_cancel (by omega : 1 ≤ a.1)] at hf |
| have he : axisHeight e (stepVector f) = 1 := by |
| have htt := axisHeight_wordEnd e a ha |
| change axisHeight e (wordPath a a.1) = _ at htt |
| rw [hf,axisHeight_add] at htt |
| have hle := axisHeight_step_le e f |
| omega |
| rw [axial_step_unique e f he] at hf |
| exact hf |
|
|
| lemma opposed_forced_contact {d : ℕ} (e : Step d) (Z : TwoTape (Word d)) |
| (hZ : ∀ b i, RegenerationWord (axisDirection (placedAxis e b)) (Z (b,i))) : |
| contactAt e Z (-stepVector e) ∧ contactDepth e Z 1 := by |
| have hc : contactAt e Z (-stepVector e) := by |
| constructor |
| · refine ⟨0,(Z (false,0)).1-1,by have := (hZ false 0).1; omega,?_⟩ |
| have ht := axis_word_last_step e (Z (false,0)) (hZ false 0) |
| simp only [opposedSite,opposedAnchor,Bool.false_eq_true,↓reduceIte, |
| zero_add,Finset.sum_range_one,ht] |
| abel |
| · refine ⟨0,0,(hZ true 0).1,?_⟩ |
| simp only [opposedSite,opposedAnchor,↓reduceIte,Finset.sum_range_zero,add_zero, |
| (hZ true 0).2.1] |
| refine ⟨hc,⟨-stepVector e,hc,?_⟩⟩ |
| rw [axisHeight_neg,axisHeight_step_self] |
| norm_num |
|
|
| def axisLower {d : ℕ} (e : Step d) (k : ℤ) : Set (Site d) := {y | axisHeight e y < k} |
| def axisUpper {d : ℕ} (e : Step d) (k : ℤ) : Set (Site d) := {y | k ≤ axisHeight e y} |
|
|
| lemma axis_barriers_disjoint {d : ℕ} (e : Step d) {k N : ℤ} (hkN : k ≤ N) : |
| Disjoint (axisLower e k) (axisUpper e N) := by |
| apply Set.disjoint_left.mpr |
| intro y hy hz |
| exact (not_lt_of_ge (hkN.trans hz)) hy |
|
|
| lemma hitBefore_axis_eq_reach {d : ℕ} (e : Step d) (H : ℕ) (X : Path d) |
| (h0 : X 0 = 0) (hX : nearestNeighbour X) : |
| X ∈ hitBefore (axisUpper e H) (axisLower e 0) ↔ X ∈ reachAxis e H := by |
| constructor |
| · rintro ⟨n,hn,hb⟩ |
| obtain ⟨j,hjn,hj,_⟩ := integer_first_crossing (fun i => axisHeight e (X i)) n H |
| (fun i _ => axisHeight_nn_le e X hX i) (by simp [h0,axisHeight_zero]) hn |
| exact ⟨j,hj,fun i hi => le_of_not_gt (hb i (hi.trans hjn))⟩ |
| · rintro ⟨n,hn,hb⟩ |
| exact ⟨n,hn.ge,fun i hi => not_lt_of_ge (hb i hi)⟩ |
|
|
| lemma annealed_axis_exit {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) (x : Site d) (k N : ℤ) : |
| ∀ᵐ X ∂annealed μ x, ∃ n, X n ∈ axisLower e k ∪ axisUpper e N := by |
| filter_upwards [annealed_exit_band μ hell x (axisDirection e) (axisDirection_ne_zero e) |
| (k : ℝ) (N-1 : ℤ)] with X hX |
| obtain ⟨n,hn⟩ := hX |
| refine ⟨n,?_⟩ |
| simp only [height_axisDirection,Set.mem_Icc,not_and,not_le] at hn |
| change axisHeight e (X n) < k ∨ N ≤ axisHeight e (X n) |
| by_cases h : axisHeight e (X n) < k |
| · exact Or.inl h |
| · right |
| have hh := hn (by exact_mod_cast le_of_not_gt h) |
| have : N-1 < axisHeight e (X n) := by exact_mod_cast hh |
| omega |
|
|
| lemma annealed_axis_return_probability {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) {r N : ℕ} (hrN : r ≤ N) : |
| annealed μ 0 (hitBefore (axisUpper e r) (axisLower e 0) ∩ |
| hitBefore (axisLower e 0) (axisUpper e N)) = axisReachProb μ e r - axisReachProb μ e N := by |
| have hAE := annealed_axis_exit μ hell e 0 0 N |
| have hd := hitBefore_disjoint (axisLower e 0) (axisUpper e N) |
| have he : (hitBefore (axisUpper e r) (axisLower e 0) ∩ |
| hitBefore (axisLower e 0) (axisUpper e N) : Set (Path d)) =ᵐ[annealed μ 0] |
| (reachAxis e r \ reachAxis e N : Set (Path d)) := by |
| filter_upwards [ae_start_and_nearestNeighbour μ 0,hAE] with X hX hx |
| have hb : X ∈ hitBefore (axisLower e 0) (axisUpper e N) ∪ |
| hitBefore (axisUpper e N) (axisLower e 0) := by |
| rw [hitBefore_union_eq_eventual _ _ (axis_barriers_disjoint e (by positivity))] |
| exact hx |
| have h1 := hitBefore_axis_eq_reach e r X hX.1 hX.2 |
| have h2 := hitBefore_axis_eq_reach e N X hX.1 hX.2 |
| apply propext |
| constructor |
| · rintro ⟨ha,hb⟩ |
| exact ⟨h1.mp ha,fun hc => Set.disjoint_left.mp hd hb (h2.mpr hc)⟩ |
| · rintro ⟨ha,hc⟩ |
| exact ⟨h1.mpr ha,hb.resolve_right (fun hh => hc (h2.mp hh))⟩ |
| have he' : (reachAxis e r ∪ reachAxis e N : Set (Path d)) =ᵐ[annealed μ 0] reachAxis e r := by |
| filter_upwards [ae_start_and_nearestNeighbour μ 0] with X hX |
| apply propext |
| exact ⟨fun h => h.elim id (reachAxis_antitone e X hX.1 hX.2 hrN),Or.inl⟩ |
| rw [measure_congr he,measure_sdiff' _ (measurableSet_reachAxis e N).nullMeasurableSet |
| (measure_ne_top _ _),measure_congr he'] |
| rfl |
|
|
| lemma annealed_axis_visitAfter_bound {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) {r N : ℕ} (hrN : r ≤ N) |
| (a : ℝ≥0∞) (A : Environment d → Set (Site d)) |
| (hA : ∀ᵐ ω ∂environmentLaw μ, ∀ y ∈ A ω, |
| a ≤ quenchedKernel d (ω,y) (hitBefore (axisLower e 0) (axisUpper e N))) : |
| a * (∫⁻ ω, quenchedKernel d (ω,0) |
| (visitAfter (axisUpper e r) (A ω) (axisLower e 0 ∪ axisUpper e N)) ∂environmentLaw μ) ≤ |
| axisReachProb μ e r - axisReachProb μ e N := by |
| rw [← annealed_axis_return_probability μ hell e hrN, |
| annealed_apply μ 0 ((measurableSet_hitBefore _ _).inter (measurableSet_hitBefore _ _))] |
| apply (lintegral_const_mul_le _ _).trans |
| apply lintegral_mono_ae |
| filter_upwards [hA] with ω hω |
| exact quenched_visitAfter_bound ω 0 _ _ _ _ a hω |
|
|
| end DirectionalZeroOne |
|
|
| end OAI |
|
|
