| import OAI.Probability.DirectionalWalk.RelativeEntropy |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Filter Preorder |
| open scoped ENNReal BigOperators Topology |
|
|
| namespace DirectionalZeroOne |
|
|
| open scoped Classical |
|
|
| def appendWord {d : ℕ} (a b : Word d) : Word d := |
| prefixWord (a.1+b.1) (concatPath a.1 (wordPath a) |
| (shiftPath (wordPath a a.1) (wordPath b))) |
|
|
| lemma appendWord_length {d : ℕ} (a b : Word d) : (appendWord a b).1 = a.1+b.1 := rfl |
|
|
| lemma appendWord_before {d : ℕ} (a b : Word d) (hb : wordPath b 0 = 0) |
| {i : ℕ} (hi : i ≤ a.1) : wordPath (appendWord a b) i = wordPath a i := by |
| rw [appendWord,wordPath_prefixWord (a.1+b.1) _ (by omega)] |
| apply concatPath_before _ _ _ _ hi |
| simp [shiftPath,hb] |
|
|
| lemma appendWord_after {d : ℕ} (a b : Word d) {i : ℕ} (hi : i ≤ b.1) : |
| wordPath (appendWord a b) (a.1+i) = wordPath a a.1 + wordPath b i := by |
| rw [appendWord,wordPath_prefixWord (a.1+b.1) _ (Nat.add_le_add_left hi _),concatPath_after] |
| exact add_comm _ _ |
|
|
| lemma appendWord_prefixWord {d : ℕ} (X : Path d) (n m : ℕ) : |
| appendWord (prefixWord n X) (prefixWord m (relativeTail n X)) = prefixWord (n+m) X := by |
| apply (prefixWord_eq_iff _ _ _).mpr |
| refine ⟨rfl,?_⟩ |
| intro i hi |
| change i ≤ n+m at hi |
| rw [wordPath_prefixWord (n+m) X hi] |
| change concatPath n (wordPath (prefixWord n X)) |
| (shiftPath (wordPath (prefixWord n X) n) (wordPath (prefixWord m (relativeTail n X)))) i = X i |
| by_cases hin : i ≤ n |
| · rw [concatPath_before _ _ _ _ hin,wordPath_prefixWord _ _ hin] |
| simp only [wordPath_prefixWord _ _ (le_refl _),wordPath_prefixWord _ _ (Nat.zero_le _), |
| shiftPath,relativeTail_apply,Nat.add_zero,sub_self,zero_add] |
| · have hn : n ≤ i := by omega |
| obtain ⟨j,rfl⟩ := Nat.exists_eq_add_of_le hn |
| rw [concatPath_after,shiftPath,wordPath_prefixWord _ _ (le_refl _), |
| wordPath_prefixWord _ _ (by omega),relativeTail_apply] |
| abel |
|
|
| def concatenateWords {d : ℕ} : (n : ℕ) → (Fin n → Word d) → Word d |
| | 0, _ => prefixWord 0 (fun _ => 0) |
| | n+1, a => appendWord (concatenateWords n (fun i => a i.castSucc)) (a (Fin.last n)) |
|
|
| def concatenateList {d : ℕ} (a : TapeList (Word d)) : Word d := concatenateWords a.1 a.2 |
|
|
| lemma concatenateWords_length {d : ℕ} (n : ℕ) (a : Fin n → Word d) : |
| (concatenateWords n a).1 = ∑ i : Fin n, (a i).1 := by |
| induction n with |
| | zero => simp [concatenateWords,prefixWord] |
| | succ n ih => simp only [concatenateWords,appendWord_length,ih,Fin.sum_univ_castSucc] |
|
|
| lemma concatenateList_prefix_slabs {d : ℕ} (v : Fin d → ℝ) (X : Path d) (h0 : X 0 = 0) (k : ℕ) : |
| concatenateList (tapePrefix k (slabs v X)) = prefixWord (slabTime v X k) X := by |
| induction k with |
| | zero => |
| apply (prefixWord_eq_iff _ _ _).mpr |
| refine ⟨rfl,?_⟩ |
| intro i hi |
| change i ≤ 0 at hi |
| have hi0 : i = 0 := Nat.eq_zero_of_le_zero hi |
| subst i |
| simp [wordPath_prefixWord,h0] |
| | succ k ih => |
| change appendWord (concatenateList (tapePrefix k (slabs v X))) (slabs v X k) = _ |
| rw [ih,slabTime_succ] |
| have he : slabs v X k = prefixWord (slabs v X k).1 (relativeTail (slabTime v X k) X) := by |
| change prefixWord (slabs v X k).1 ((cutSuffix v)^[k] X) = _ |
| rw [iterated_cutSuffix_eq_relativeTail v X h0 k] |
| rw [he] |
| exact appendWord_prefixWord X _ _ |
|
|
| lemma concatenateList_length {d : ℕ} (a : TapeList (Word d)) : |
| (concatenateList a).1 = listHeight (fun w => w.1) a := concatenateWords_length a.1 a.2 |
|
|
| noncomputable def recordWord {d : ℕ} (v : Fin d → ℝ) (H : ℕ) (X : Path d) : Word d := by |
| classical |
| exact if h : ∃ n, recordPrefix v H X n then prefixWord (Nat.find h) X else prefixWord 0 X |
|
|
| lemma recordWord_eq {d : ℕ} (v : Fin d → ℝ) (H : ℕ) (X : Path d) {n : ℕ} |
| (hn : recordPrefix v H X n) : recordWord v H X = prefixWord n X := by |
| classical |
| have hex : ∃ n, recordPrefix v H X n := ⟨n,hn⟩ |
| rw [recordWord,dite_eq_left hex] |
| rw [recordPrefix_unique v H X (Nat.find_spec hex) hn] |
|
|
| lemma recordWord_atom {d : ℕ} (v : Fin d → ℝ) (H : ℕ) (X : Path d) (a : Word d) : |
| (X ∈ reachRecord v H ∧ recordWord v H X = a) ↔ |
| recordPrefix v H (wordPath a) a.1 ∧ X ∈ pathCylinder a.1 (wordPath a) := by |
| constructor |
| · rintro ⟨hX,ha⟩ |
| obtain ⟨n,hn⟩ := Set.mem_iUnion.mp hX |
| rw [recordWord_eq v H X hn] at ha |
| obtain ⟨rfl,hpre⟩ := (prefixWord_eq_iff n X a).mp ha |
| exact ⟨recordPrefix_prefix v H hn (fun i hi => (hpre i hi).symm),hpre⟩ |
| · rintro ⟨ha,hX⟩ |
| have hr := recordPrefix_prefix v H ha hX |
| exact ⟨Set.mem_iUnion.mpr ⟨a.1,hr⟩, |
| (recordWord_eq v H X hr).trans ((prefixWord_eq_iff _ _ _).mpr ⟨rfl,hX⟩)⟩ |
|
|
| lemma measurable_recordWord {d : ℕ} (v : Fin d → ℝ) (H : ℕ) : Measurable (recordWord v H) := by |
| apply measurable_to_countable' |
| intro a |
| have he : recordWord v H ⁻¹' {a} = |
| (if recordPrefix v H (wordPath a) a.1 then pathCylinder a.1 (wordPath a) else ∅) ∪ |
| ((reachRecord v H)ᶜ ∩ prefixWord 0 ⁻¹' {a}) := by |
| classical |
| ext X |
| by_cases hX : X ∈ reachRecord v H |
| · have hh := recordWord_atom v H X a |
| simp only [Set.mem_preimage,Set.mem_singleton_iff,Set.mem_union,Set.mem_inter_iff, |
| Set.mem_compl_iff,hX,not_true_eq_false,false_and,or_false,true_and] at hh ⊢ |
| split_ifs <;> simp_all |
| · have hn : ¬∃ n, recordPrefix v H X n := by simpa only [reachRecord,Set.mem_iUnion,Set.mem_ofPred_eq] using hX |
| have hrw : recordWord v H X = prefixWord 0 X := by simp only [recordWord,dite_eq_right hn] |
| have hnot : recordPrefix v H (wordPath a) a.1 → X ∉ pathCylinder a.1 (wordPath a) := by |
| intro ha hc |
| exact hX ((recordWord_atom v H X a).mpr ⟨ha,hc⟩).1 |
| split_ifs <;> simp_all |
| rw [he] |
| apply MeasurableSet.union |
| · split_ifs |
| · exact measurableSet_pathCylinder _ _ |
| · exact MeasurableSet.empty |
| · exact (measurableSet_reachRecord v H).compl.inter ((measurable_prefixWord 0) (measurableSet_singleton _)) |
|
|
| lemma conditioned_recordWord_atom {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (hp : 0 < annealed μ 0 (nonBacktracking v)) (H : ℕ) (a : Word d) : |
| conditioned μ v (recordTailEvent v H Set.univ ∩ recordWord v H ⁻¹' {a}) = |
| annealed μ 0 (reachRecord v H ∩ recordWord v H ⁻¹' {a}) := by |
| let := conditioned_probability μ v hp |
| classical |
| have he0 : reachRecord v H ∩ recordWord v H ⁻¹' {a} = |
| if recordPrefix v H (wordPath a) a.1 then pathCylinder a.1 (wordPath a) else ∅ := by |
| ext X |
| simp only [Set.mem_inter_iff,Set.mem_preimage,Set.mem_singleton_iff,recordWord_atom] |
| split_ifs <;> simp_all |
| have he1 : recordTailEvent v H Set.univ ∩ recordWord v H ⁻¹' {a} = |
| if recordPrefix v H (wordPath a) a.1 then |
| pathCylinder a.1 (wordPath a) ∩ relativeTail a.1 ⁻¹' (Set.univ ∩ nonBacktracking v) else ∅ := by |
| ext X |
| simp only [Set.mem_inter_iff,Set.mem_preimage,Set.mem_singleton_iff] |
| split_ifs with ha |
| · constructor |
| · rintro ⟨hX,hw⟩ |
| obtain ⟨n,hn,hD⟩ := Set.mem_iUnion.mp hX |
| have hpre := ((recordWord_atom v H X a).mp ⟨Set.mem_iUnion.mpr ⟨n,hn⟩,hw⟩).2 |
| have hnn := recordPrefix_unique v H X hn (recordPrefix_prefix v H ha hpre) |
| subst n |
| exact ⟨hpre,hD⟩ |
| · rintro ⟨hpre,ht⟩ |
| have hr := recordPrefix_prefix v H ha hpre |
| refine ⟨Set.mem_iUnion.mpr ⟨a.1,hr,ht⟩,?_⟩ |
| exact ((recordWord_atom v H X a).mpr ⟨ha,hpre⟩).2 |
| · constructor |
| · rintro ⟨hX,hw⟩ |
| obtain ⟨n,hn,_⟩ := Set.mem_iUnion.mp hX |
| exact ha ((recordWord_atom v H X a).mp ⟨Set.mem_iUnion.mpr ⟨n,hn⟩,hw⟩).1 |
| · exact False.elim |
| rw [he0,he1] |
| split_ifs with ha |
| · rw [conditioned_recordCylinder μ v H a.1 (wordPath a) ha MeasurableSet.univ,measure_univ,mul_one] |
| · simp only [measure_empty] |
|
|
| noncomputable def rawBridgeMeasure {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (H : ℕ) : Measure (Word d) := |
| ((annealed μ 0).restrict (reachRecord v H)).map (recordWord v H) |
|
|
| lemma rawBridgeMeasure_conditioned {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (v : Fin d → ℝ) (hp : 0 < annealed μ 0 (nonBacktracking v)) (H : ℕ) : |
| ((conditioned μ v).restrict (recordTailEvent v H Set.univ)).map (recordWord v H) = |
| rawBridgeMeasure μ v H := by |
| apply Measure.ext_of_singleton |
| intro a |
| simp only [rawBridgeMeasure,Measure.map_apply (measurable_recordWord v H) (measurableSet_singleton _), |
| Measure.restrict_apply ((measurable_recordWord v H) (measurableSet_singleton _))] |
| simpa only [Set.inter_comm] using conditioned_recordWord_atom μ v hp H a |
|
|
| lemma concatenate_cutList_slabs {d : ℕ} (v : Fin d → ℝ) (H : ℕ) (X : Path d) |
| (hX : GoodSlabPath v X) (hH : slabs v X ∈ tapeCut v H) : |
| concatenateList (cutList (slabRecords v) H (slabs v X)) = recordWord v H X := by |
| obtain ⟨k,hk⟩ := hH |
| have hpos : ∀ i, 0 < slabRecords v (slabs v X i) := fun i => slabRecords_pos v _ (hX.2 i) |
| rw [cutList,cutListIndex_eq (slabRecords v) H (slabs v X) hpos hk, |
| concatenateList_prefix_slabs v X hX.1 k] |
| symm |
| apply recordWord_eq |
| refine ⟨(slabTime_boundary v X hX k).imp_right And.left,?_,fun i _ => ?_⟩ |
| · rw [recordCount_slabTime v X hX k] |
| exact hk |
| · exact goodSlabPath_height_nonneg v X hX i |
|
|
| lemma bridgeListMeasure_concatenate {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ] |
| (hell : StrictEllipticity μ) (v : Fin d → ℝ) (hv : v ≠ 0) |
| (hp : 0 < annealed μ 0 (nonBacktracking v)) (H : ℕ) : |
| letI := slabLaw_probability μ v hp |
| (bridgeListMeasure (slabLaw μ v) (slabRecords v) H).map concatenateList = |
| rawBridgeMeasure μ v H := by |
| let := slabLaw_probability μ v hp |
| let := conditioned_probability μ v hp |
| rw [← rawBridgeMeasure_conditioned μ v hp H] |
| apply Measure.ext_of_singleton |
| intro a |
| rw [Measure.map_apply (measurable_of_countable concatenateList) (measurableSet_singleton _), |
| bridgeListMeasure,Measure.map_apply (measurable_cutList (slabRecords v) H) |
| ((measurable_of_countable concatenateList) (measurableSet_singleton _)), |
| Measure.restrict_apply ((measurable_cutList (slabRecords v) H) |
| ((measurable_of_countable concatenateList) (measurableSet_singleton _))), |
| ← slabs_map_eq_infinitePi μ hell v hv hp, |
| Measure.map_apply (measurable_slabs v) |
| (((measurable_cutList (slabRecords v) H) |
| ((measurable_of_countable concatenateList) (measurableSet_singleton _))).inter |
| (measurableSet_renewalCut (slabRecords v) H)), |
| Measure.map_apply (measurable_recordWord v H) (measurableSet_singleton _), |
| Measure.restrict_apply ((measurable_recordWord v H) (measurableSet_singleton _))] |
| apply measure_congr |
| filter_upwards [ae_goodSlabPath μ hell v hv hp] with X hX |
| apply propext |
| change (concatenateList (cutList (slabRecords v) H (slabs v X)) = a ∧ |
| slabs v X ∈ tapeCut v H) ↔ (recordWord v H X = a ∧ X ∈ recordTailEvent v H Set.univ) |
| constructor |
| · rintro ⟨ha,hH⟩ |
| exact ⟨(concatenate_cutList_slabs v H X hX hH).symm.trans ha, |
| (tapeCut_iff_recordTailEvent v X hX H).mp hH⟩ |
| · rintro ⟨ha,hH⟩ |
| have hc := (tapeCut_iff_recordTailEvent v X hX H).mpr hH |
| exact ⟨(concatenate_cutList_slabs v H X hX hc).trans ha,hc⟩ |
|
|
| end DirectionalZeroOne |
|
|
| end OAI |
|
|
