| import OAI.Probability.DirectionalWalk.LatePrefixes |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Filter Preorder |
| open scoped ENNReal BigOperators Topology |
|
|
| namespace DirectionalZeroOne |
|
|
| open scoped Classical |
|
|
| def lateContactEvent {d ι : ℕ} (e : Step d) (k r N : ℕ) |
| (E : Fin ι → Set (Path d)) (z : Fin ι → Site d) : Set (Path d × Path d) := |
| {p | ∃ q, p.1 ∈ E q ∧ ∃ t τ, t ≤ τ ∧ |
| AxisBridgeWord e k (prefixWord t p.1) ∧ |
| (∀ j, t ≤ j → j ≤ τ → (k : ℤ) ≤ axisHeight e (p.1 j) ∧ axisHeight e (p.1 j) < (N : ℤ)) ∧ |
| (∃ j, t ≤ j ∧ j ≤ τ ∧ (r : ℤ) ≤ axisHeight e (p.1 j)) ∧ |
| (∃ j, p.2 j+z q = p.1 τ) ∧ |
| (∀ i, t ≤ i → i < τ → ∀ j, p.2 j+z q ≠ p.1 i)} |
|
|
| lemma lateContactEvent_bound {d ι : ℕ} [NeZero ι] |
| (μ : Measure (Row d)) [IsProbabilityMeasure μ] (hell : StrictEllipticity μ) |
| (e : Step d) (k r N m : ℕ) (hkr : k ≤ r) (hrN : r ≤ N) |
| (E : Fin ι → Set (Path d)) (hE : ∀ q, MeasurableSet (E q)) |
| (hdis : Pairwise (fun i j => Disjoint (E i) (E j))) |
| (z : Fin ι → Site d) (hz : ∀ q, axisHeight e (z q) = (N : ℤ)-1) |
| (hΔ : axisReachProb μ e (r-k)-axisReachProb μ e (N-k) ≤ ENNReal.ofReal ((1/2 : ℝ)^m)) : |
| ((annealed μ 0).prod (conditioned μ (axisDirection (oppositeStep e)))) |
| (lateContactEvent e k r N E z) ≤ |
| (annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))))⁻¹ * |
| ENNReal.ofReal ((24 / posteriorExponent)*Real.log (ι+1)*(m+1)^2*(1/2 : ℝ)^m) := by |
| refine (measure_mono (t := latePrefixEvent e k (r-k) (N-k) |
| (fun a q => prependRelative a ⁻¹' E q) (fun a q => z q-wordEnd a)) ?_).trans ?_ |
| · rintro ⟨X,Y⟩ ⟨q,hq,t,τ,htτ,ha,hband,hr,hh,hbefore⟩ |
| exact latePrefixEvent_of_contact e k r N hkr (hkr.trans hrN) E z X Y q hq t τ htτ ha hband hr hh hbefore |
| · apply latePrefixEvent_bound μ hell e k (r-k) (N-k) m (Nat.sub_le_sub_right hrN k) |
| _ (fun a q => measurable_prependRelative a (hE q)) |
| (fun a i j hij => (hdis hij).preimage _) _ _ hΔ |
| intro a ha q |
| rw [sub_eq_add_neg,axisHeight_add,axisHeight_neg,hz q,ha.1,Nat.cast_sub (hkr.trans hrN)] |
| omega |
|
|
| lemma conditioned_bridge_late_bound {d ι : ℕ} [NeZero ι] |
| (μ : Measure (Row d)) [IsProbabilityMeasure μ] (hell : StrictEllipticity μ) |
| (e : Step d) (k r N m : ℕ) (hkr : k ≤ r) (hrN : r ≤ N) |
| (E : Fin ι → Set (Path d)) (hE : ∀ q, MeasurableSet (E q)) |
| (hdis : Pairwise (fun i j => Disjoint (E i) (E j))) |
| (z : Fin ι → Site d) (hz : ∀ q, axisHeight e (z q) = (N : ℤ)-1) |
| (hΔ : axisReachProb μ e (r-k)-axisReachProb μ e (N-k) ≤ ENNReal.ofReal ((1/2 : ℝ)^m)) : |
| ((ProbabilityTheory.cond (annealed μ 0) (reachRecord (axisDirection e) N)).prod |
| (conditioned μ (axisDirection (oppositeStep e)))) (lateContactEvent e k r N E z) ≤ |
| (axisReachProb μ e N)⁻¹ * |
| (annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))))⁻¹ * |
| ENNReal.ofReal ((24 / posteriorExponent)*Real.log (ι+1)*(m+1)^2*(1/2 : ℝ)^m) := by |
| have : IsFiniteMeasure (conditioned μ (axisDirection (oppositeStep e))) := by |
| unfold conditioned |
| infer_instance |
| rw [ProbabilityTheory.cond,Measure.prod_smul_left,Measure.smul_apply,← axisReachProb_eq_record] |
| change (axisReachProb μ e N)⁻¹ * _ ≤ _ |
| rw [mul_assoc] |
| apply mul_le_mul_right |
| refine (Measure.prod_mono Measure.restrict_le_self le_rfl _).trans ?_ |
| exact lateContactEvent_bound μ hell e k r N m hkr hrN E hE hdis z hz hΔ |
|
|
| lemma iid_tape_strongLaw {α : Type*} [MeasurableSpace α] |
| (ν : Measure α) [IsProbabilityMeasure ν] (f : α → ℝ) |
| (hf : Measurable f) (hi : Integrable f ν) : |
| ∀ᵐ Z ∂Measure.infinitePi (fun _ : ℕ => ν), |
| Tendsto (fun n : ℕ => (∑ i ∈ Finset.range n, f (Z i))/n) atTop (𝓝 (∫ a, f a ∂ν)) := by |
| let P := Measure.infinitePi (fun _ : ℕ => ν) |
| have hid (k : ℕ) : IdentDistrib (fun Z : ℕ → α => f (Z k)) f P ν := by |
| refine ⟨(hf.comp (measurable_pi_apply k)).aemeasurable,hf.aemeasurable,?_⟩ |
| rw [show P.map (fun Z => f (Z k)) = (P.map (fun Z => Z k)).map f from |
| (Measure.map_map hf (measurable_pi_apply k)).symm,Measure.infinitePi_map_eval] |
| have hind := iIndepFun_infinitePi (P := fun _ : ℕ => ν) (X := fun _ => f) (fun _ => hf) |
| have hx := strong_law_ae_real (fun k (Z : ℕ → α) => f (Z k)) |
| ((hid 0).integrable_iff.mpr hi) (fun i j hij => hind.indepFun hij) |
| (fun k => (hid k).trans (hid 0).symm) |
| rwa [(hid 0).integral_eq] at hx |
|
|
| lemma tapeHeight_strongLaw {α : Type*} [Countable α] [MeasurableSpace α] |
| [MeasurableSingletonClass α] (ν : Measure α) [IsProbabilityMeasure ν] |
| (L : α → ℕ) (hi : Integrable (fun a => (L a : ℝ)) ν) : |
| ∀ᵐ Z ∂Measure.infinitePi (fun _ : ℕ => ν), |
| Tendsto (fun n : ℕ => (tapeHeight L Z n : ℝ)/n) atTop (𝓝 (∫ a, (L a : ℝ) ∂ν)) := by |
| simpa only [tapeHeight,Nat.cast_sum] using iid_tape_strongLaw ν _ (measurable_of_countable _) hi |
|
|
| lemma firstCommonBlock_height {α : Type*} (L : Bool → α → ℕ) (Z : TwoTape α) |
| (hZ : ∀ b i, 0 < L b (Z (b,i))) (he : ∃ H, 0 < H ∧ Z ∈ commonCut L H) : |
| chunkHeight L (firstCommonBlock L Z) = firstCommonWidth L Z := by |
| exact ((commonCutList_atom_iff L _ Z hZ (firstCommonBlock L Z)).mp |
| ⟨(firstCommonWidth_spec L Z he).2.1,rfl⟩).1 false |
|
|
| lemma commonDepth_strongLaw {α : Type*} [Countable α] [MeasurableSpace α] |
| [MeasurableSingletonClass α] (ν : Bool → Measure α) [∀ b, IsProbabilityMeasure (ν b)] |
| (L : Bool → α → ℕ) (hL : ∀ b, ∀ᵐ a ∂ν b, 0 < L b a) |
| (he : ∀ᵐ Z ∂twoTapeLaw ν, ∃ H, 0 < H ∧ Z ∈ commonCut L H) |
| (hi : Integrable (fun Z => (firstCommonWidth L Z : ℝ)) (twoTapeLaw ν)) : |
| ∀ᵐ Z ∂twoTapeLaw ν, |
| Tendsto (fun n : ℕ => (commonDepth L Z n : ℝ)/n) atTop |
| (𝓝 (∫ Z, (firstCommonWidth L Z : ℝ) ∂twoTapeLaw ν)) := by |
| have ha : (fun Z => (chunkHeight L (firstCommonBlock L Z) : ℝ)) =ᵐ[twoTapeLaw ν] |
| fun Z => (firstCommonWidth L Z : ℝ) := by |
| filter_upwards [ae_twoTape_prop ν (fun b a => 0 < L b a) |
| (fun b => measurableSet_lt measurable_const (measurable_of_countable (L b))) hL,he] with Z hZ he |
| exact_mod_cast firstCommonBlock_height L Z hZ he |
| have hii : Integrable (fun a => (chunkHeight L a : ℝ)) (commonBlockLaw ν L) := by |
| rw [commonBlockLaw,integrable_map_measure (measurable_of_countable _).aestronglyMeasurable |
| (measurable_firstCommonBlock L).aemeasurable] |
| exact hi.congr ha.symm |
| have hei : (∫ a, (chunkHeight L a : ℝ) ∂commonBlockLaw ν L) = |
| ∫ Z, (firstCommonWidth L Z : ℝ) ∂twoTapeLaw ν := by |
| rw [commonBlockLaw,integral_map (measurable_firstCommonBlock L).aemeasurable |
| (measurable_of_countable _).aestronglyMeasurable] |
| exact integral_congr_ae ha |
| let : IsProbabilityMeasure (commonBlockLaw ν L) := |
| probabilityMeasure_map (measurable_firstCommonBlock L).aemeasurable |
| have hh := iid_tape_strongLaw (commonBlockLaw ν L) (fun a => (chunkHeight L a : ℝ)) |
| (measurable_of_countable _) hii |
| rw [← commonBlocks_map ν L hL he] at hh |
| have hm : Measurable (commonBlocks L) := by |
| apply Measurable.of_eval |
| intro k |
| exact (measurable_firstCommonBlock L).comp ((measurable_commonRestart L).iterate k) |
| have ht := ae_of_ae_map hm.aemeasurable hh |
| rw [hei] at ht |
| filter_upwards [ht,ae_twoTape_prop ν (fun b a => 0 < L b a) |
| (fun b => measurableSet_lt measurable_const (measurable_of_countable (L b))) hL, |
| ae_common_iterates ν L hL he] with Z hZ hpos hiter |
| have hsum (n : ℕ) : (∑ i ∈ Finset.range n, (chunkHeight L (commonBlocks L Z i) : ℝ)) = |
| (commonDepth L Z n : ℝ) := by |
| simp only [commonDepth,Nat.cast_sum] |
| apply Finset.sum_congr rfl |
| intro i _ |
| have hposi : ∀ b j, 0 < L b (((commonRestart L)^[i] Z) (b,j)) := by |
| rw [← (commonDepth_spec L Z hpos hiter i).2.1] |
| exact fun b j => hpos b _ |
| exact_mod_cast firstCommonBlock_height L _ hposi (hiter i) |
| simpa only [hsum] using hZ |
|
|
| lemma placed_slab_positive {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) |
| (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) (b : Bool) : |
| ∀ᵐ a ∂slabLaw μ (axisDirection (placedAxis e b)), 0 < placedWidth e b a := by |
| filter_upwards [ae_slabLaw_regeneration μ hell _ (axisDirection_ne_zero _) (hp b)] with a ha |
| exact slabRecords_pos _ _ ha |
|
|
| lemma placed_common_lower {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) |
| (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) (H : ℕ) : |
| letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := |
| fun b => slabLaw_probability μ _ (hp b) |
| annealed μ 0 (nonBacktracking (axisDirection e)) * |
| annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))) ≤ |
| twoTapeLaw (fun b => slabLaw μ (axisDirection (placedAxis e b))) (commonCut (placedWidth e) H) := by |
| let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := |
| fun b => slabLaw_probability μ _ (hp b) |
| rw [commonCut_mass,show Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection (placedAxis e false))) |
| (renewalCut (placedWidth e false) H) = axisReachProb μ e H from axis_tapeCut_mass μ hell _ (hp false) H, |
| show Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection (placedAxis e true))) |
| (renewalCut (placedWidth e true) H) = axisReachProb μ (oppositeStep e) H from axis_tapeCut_mass μ hell _ (hp true) H] |
| exact mul_le_mul' (axisReachProb_lower μ hell e H) (axisReachProb_lower μ hell (oppositeStep e) H) |
| |
| lemma placed_common_data {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) |
| (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) : |
| letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := |
| fun b => slabLaw_probability μ _ (hp b) |
| (∀ᵐ Z ∂twoTapeLaw (fun b => slabLaw μ (axisDirection (placedAxis e b))), |
| ∃ H, 0 < H ∧ Z ∈ commonCut (placedWidth e) H) ∧ |
| Integrable (fun Z => (firstCommonWidth (placedWidth e) Z : ℝ)) |
| (twoTapeLaw (fun b => slabLaw μ (axisDirection (placedAxis e b)))) := by |
| let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) := |
| fun b => slabLaw_probability μ _ (hp b) |
| have hc := mul_ne_zero (ne_of_gt (hp false)) (ne_of_gt (hp true)) |
| exact ⟨ae_exists_commonCut _ _ (placed_slab_positive μ hell e hp) _ hc (placed_common_lower μ hell e hp), |
| integrable_firstCommonWidth _ _ (placed_slab_positive μ hell e hp) _ hc (placed_common_lower μ hell e hp)⟩ |
| |
| lemma placed_slabRadius_integrable {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) |
| (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) (b : Bool) : |
| Integrable slabRadius (slabLaw μ (axisDirection (placedAxis e b))) := by |
| have hn : annealed μ 0 (nonBacktracking (-axisDirection e)) > 0 := by |
| rw [← axisDirection_opposite] |
| exact hp true |
| have hh := integrable_slabRadius_normalized μ hell _ (axisDirection_ne_zero e) |
| (axisDirection_normalized e).1 (axisDirection_normalized e).2 (hp false) hn |
| cases b |
| · exact hh.1 |
| · simpa only [placedAxis,↓reduceIte,axisDirection_opposite] using hh.2 |
| |
| lemma placed_wordEnd_integrable {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (e : Step d) |
| (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) (b : Bool) (i : Fin d) : |
| Integrable (fun a => (wordEnd a i : ℝ)) (slabLaw μ (axisDirection (placedAxis e b))) := by |
| have hh := integrable_slabProjection μ hell _ (axisDirection_ne_zero _) (hp b) |
| (placed_slabRadius_integrable μ hell e hp b) (Pi.single i 1) |
| change Integrable (fun a => height (Pi.single i 1) (wordEnd a)) _ at hh |
| simpa [height,Pi.single_apply] using hh |
| |
| lemma concatenateWords_end {d : ℕ} (n : ℕ) (a : Fin n → Word d) : |
| wordEnd (concatenateWords n a) = ∑ i, wordEnd (a i) := by |
| induction n with |
| | zero => simp [concatenateWords,wordEnd,prefixWord,wordPath,extendPrefix] |
| | succ n ih => |
| change wordPath (appendWord (concatenateWords n (fun i => a i.castSucc)) (a (Fin.last n))) |
| ((concatenateWords n (fun i => a i.castSucc)).1+(a (Fin.last n)).1) = _ |
| rw [appendWord_after _ _ le_rfl] |
| change wordEnd (concatenateWords n _) + wordEnd (a (Fin.last n)) = _ |
| rw [ih,Fin.sum_univ_castSucc] |
| |
| lemma concatenateList_end {d : ℕ} (a : TapeList (Word d)) : |
| wordEnd (concatenateList a) = listTotal wordEnd a := concatenateWords_end a.1 a.2 |
| |
| lemma fin_prefix_sum_castSucc {G : Type*} [AddCommMonoid G] {n : ℕ} |
| (f : Fin (n+1) → G) (i : Fin n) : |
| (∑ j : Fin (n+1) with j < i.castSucc, f j) = ∑ j : Fin n with j < i, f j.castSucc := by |
| classical |
| simp only [Finset.sum_filter] |
| rw [Fin.sum_univ_castSucc] |
| simp [show ¬Fin.last n < i.castSucc by simp only [Fin.lt_def,Fin.val_last,Fin.val_castSucc];omega] |
| |
| lemma fin_prefix_sum_last {G : Type*} [AddCommMonoid G] {n : ℕ} |
| (f : Fin (n+1) → G) : |
| (∑ j : Fin (n+1) with j < Fin.last n, f j) = ∑ j : Fin n, f j.castSucc := by |
| classical |
| simp only [Finset.sum_filter] |
| rw [Fin.sum_univ_castSucc] |
| simp |
| |
| lemma concatenateWords_site {d n : ℕ} (a : Fin n → Word d) |
| (h0 : ∀ i, wordPath (a i) 0 = 0) (i : Fin n) (t : ℕ) (ht : t ≤ (a i).1) : |
| wordPath (concatenateWords n a) ((∑ j : Fin n with j < i, (a j).1)+t) = |
| (∑ j : Fin n with j < i, wordEnd (a j)) + wordPath (a i) t := by |
| classical |
| induction n with |
| | zero => exact Fin.elim0 i |
| | succ n ih => |
| revert ht |
| refine Fin.lastCases ?_ (fun i => ?_) i |
| · intro ht |
| rw [fin_prefix_sum_last,fin_prefix_sum_last] |
| change wordPath (appendWord (concatenateWords n (fun j => a j.castSucc)) (a (Fin.last n))) |
| ((∑ j : Fin n, (a j.castSucc).1)+t) = _ |
| rw [← concatenateWords_length,appendWord_after _ _ ht,← concatenateWords_end] |
| rfl |
| · intro ht |
| rw [fin_prefix_sum_castSucc,fin_prefix_sum_castSucc] |
| change wordPath (appendWord (concatenateWords n (fun j => a j.castSucc)) (a (Fin.last n))) _ = _ |
| rw [appendWord_before _ _ (h0 _) ?_] |
| · exact ih (fun j => a j.castSucc) (fun j => h0 _) i ht |
| · rw [concatenateWords_length] |
| have hs : (∑ j : Fin n with j < i, (a j.castSucc).1)+(a i.castSucc).1 ≤ |
| ∑ j : Fin n, (a j.castSucc).1 := by |
| rw [add_comm,← Finset.sum_insert (f := fun j : Fin n => (a j.castSucc).1) (a := i) (s := Finset.univ.filter (fun j : Fin n => j < i)) |
| (by simp)] |
| exact Finset.sum_le_sum_of_subset (by intro j hj;simp) |
| omega |
| |
| lemma fin_reverse_prefix_sum {G : Type*} [AddCommMonoid G] {n : ℕ} |
| (f : Fin n → G) (i : Fin n) : |
| (∑ j : Fin n with j < i.rev, f j.rev) + (∑ j : Fin n with j ≤ i, f j) = ∑ j, f j := by |
| classical |
| have he : (∑ j : Fin n with j < i.rev, f j.rev) = ∑ j : Fin n with ¬j ≤ i, f j := by |
| simp only [Finset.sum_filter] |
| have hh := Equiv.sum_comp Fin.revPerm (fun j : Fin n => if ¬j ≤ i then f j else 0) |
| simpa only [Fin.revPerm_apply,not_le,Fin.lt_rev_iff] using hh |
| rw [he,add_comm] |
| exact Finset.sum_filter_add_sum_filter_not _ _ _ |
| |
| lemma fin_prefix_sum_range {G : Type*} [AddCommMonoid G] {n : ℕ} |
| (f : ℕ → G) (k : ℕ) (hk : k ≤ n) : |
| (∑ j : Fin n with j.val < k, f j) = ∑ j ∈ Finset.range k, f j := by |
| classical |
| simp only [Finset.sum_filter] |
| rw [Fin.sum_univ_eq_sum_range (fun j => if j < k then f j else 0)] |
| rw [← Finset.sum_filter] |
| congr 1 |
| ext j |
| simp only [Finset.mem_filter,Finset.mem_range] |
| omega |
| |
| lemma reversePrefix_site {d n : ℕ} (Z : ℕ → Word d) |
| (h0 : ∀ j < n, wordPath (Z j) 0 = 0) (i : Fin n) (t : ℕ) (ht : t ≤ (Z i).1) : |
| wordPath (concatenateList (reverseTapeList (tapePrefix n Z))) |
| ((∑ j : Fin n with j < i.rev, (Z j.rev).1)+t) = |
| (∑ j ∈ Finset.range n, wordEnd (Z j)) - (∑ j ∈ Finset.range (i.val+1), wordEnd (Z j)) + |
| wordPath (Z i) t := by |
| have hs := concatenateWords_site (fun j : Fin n => Z j.rev) |
| (fun j => h0 _ j.rev.isLt) i.rev t (by simpa using ht) |
| simp only [Fin.rev_rev] at hs |
| change wordPath (concatenateList (reverseTapeList (tapePrefix n Z))) _ = _ at hs |
| rw [hs] |
| congr 1 |
| have hh := fin_reverse_prefix_sum (fun j : Fin n => wordEnd (Z j)) i |
| have he : (∑ j : Fin n with j ≤ i, wordEnd (Z j)) = ∑ j ∈ Finset.range (i.val+1), wordEnd (Z j) := by |
| have heq : Finset.univ.filter (fun j : Fin n => j ≤ i) = |
| Finset.univ.filter (fun j : Fin n => j.val < i.val+1) := by |
| ext j |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,Fin.le_def] |
| omega |
| rw [heq] |
| exact fin_prefix_sum_range (fun j => wordEnd (Z j)) (i.val+1) (by omega) |
| rw [he,Fin.sum_univ_eq_sum_range (fun j => wordEnd (Z j))] at hh |
| exact eq_sub_of_add_eq hh |
| |
| end DirectionalZeroOne |
| |
| end OAI |
| |
