| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Towers.ScaledFiniteCoupling |
|
|
| namespace OAI |
|
|
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A B : Type*} [MeasurableSpace X] [StandardBorelSpace X] [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [Nonempty B] |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] in |
| lemma finite_map_eq_of_mass (μ : Measure X) [IsFiniteMeasure μ] |
| (ν : Measure Y) [IsFiniteMeasure ν] (p : X → A) (q : Y → A) |
| (hp : Measurable p) (hq : Measurable q) (h : ∀ a,mass μ p a=mass ν q a) : |
| μ.map p=ν.map q := by |
| apply Measure.ext_of_singleton |
| intro a |
| apply (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) (measure_ne_top _ _)).mp |
| rw [Measure.map_apply hp (measurableSet_singleton a),Measure.map_apply hq (measurableSet_singleton a)] |
| exact h a |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] [Fintype A] in |
| lemma mass_eq_of_map_eq (μ : Measure X) (ν : Measure Y) (p : X → A) (q : Y → A) |
| (hp : Measurable p) (hq : Measurable q) (h : μ.map p=ν.map q) (a : A) : |
| mass μ p a=mass ν q a := by |
| have hh := congrArg (fun ξ : Measure A => (ξ {a}).toReal) h |
| simpa only [Measure.map_apply hp (measurableSet_singleton a), |
| Measure.map_apply hq (measurableSet_singleton a),mass] using hh |
|
|
| omit [StandardBorelSpace X] in |
| lemma relative_finite_realization (μ : Measure X) [IsFiniteMeasure μ] |
| (ν : Measure Y) [IsFiniteMeasure ν] [NullSingletonClass ν] |
| (p : X → A) (α : X → B) (q : Y → A) |
| (hp : Measurable p) (hα : Measurable α) (hq : Measurable q) |
| (hfirst : μ.map p=ν.map q) : |
| ∃ b : Y → B,Measurable b ∧ |
| ν.map (fun y => (q y,b y))=μ.map (fun x => (p x,α x)) := by |
| let S := MatrixCoupling.observations μ p α hp hα |
| let R : MatrixCoupling (mass ν q) (mass μ α) := { |
| weight := S.weight |
| nonneg := S.nonneg |
| row := fun a => (S.row a).trans (mass_eq_of_map_eq μ ν p q hp hq hfirst a) |
| col := S.col } |
| obtain ⟨b,hb,hR⟩ := realize_finite_coupling_finite ν q hq (mass μ α) R |
| refine ⟨b,hb,finite_map_eq_of_mass ν μ _ _ (hq.prodMk hb) (hp.prodMk hα) ?_⟩ |
| rintro ⟨a,c⟩ |
| exact hR a c |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] in |
| lemma map_restrict_factor (μ : Measure X) (ν : Measure Y) |
| (π : X → Y) (hπ : MeasurePreserving π μ ν) {U : Set Y} (hU : MeasurableSet U) : |
| (μ.restrict (π ⁻¹' U)).map π=ν.restrict U := by |
| rw [←hπ.map_eq,Measure.restrict_map hπ.measurable hU] |
|
|
| omit [MeasurableSpace X] [StandardBorelSpace X] [MeasurableSpace Y] [StandardBorelSpace Y] in |
| lemma factor_iterate (e : X → X) (f : Y → Y) (π : X → Y) |
| (h : ∀ x,π (e x)=f (π x)) (i : ℕ) (x : X) : π (e^[i] x)=f^[i] (π x) := by |
| induction i with |
| | zero => rfl |
| | succ i ih => rw [Function.iterate_succ_apply',h,ih,Function.iterate_succ_apply'] |
|
|
| omit [MeasurableSpace X] [StandardBorelSpace X] [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] in |
| lemma factor_word (e : X → X) (f : Y → Y) (π : X → Y) |
| (h : ∀ x,π (e x)=f (π x)) (p : Y → A) (n : ℕ) : |
| word e (p ∘ π) n=word f p n ∘ π := by |
| funext x j |
| exact congrArg p (factor_iterate e f π h j.val x) |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] in |
| lemma factor_tower_level (e : X ≃ᵐ X) (f : Y ≃ᵐ Y) (π : X → Y) |
| (h : ∀ x,π (e x)=f (π x)) (U : Set Y) (i : ℕ) : |
| (e^[i]) '' (π ⁻¹' U)=π ⁻¹' ((f^[i]) '' U) := by |
| ext x |
| constructor |
| · rintro ⟨z,hz,rfl⟩ |
| exact ⟨π z,hz,(factor_iterate e f π h i z).symm⟩ |
| · rintro ⟨y,hy,hxy⟩ |
| let z := (iterateEquiv e i).symm x |
| have hzx : e^[i] z=x := (iterateEquiv e i).apply_symm_apply x |
| refine ⟨z,?_,hzx⟩ |
| have hh : f^[i] (π z)=f^[i] y := by rw [←factor_iterate e f π h,hzx,hxy] |
| have hz := (iterateEquiv f i).injective hh |
| change π z∈U |
| rwa [hz] |
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A B : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [Nonempty B] |
|
|
| omit [StandardBorelSpace X] in |
| lemma relative_tower_base_copy (μ : Measure X) [IsFiniteMeasure μ] |
| (ν : Measure Y) [IsFiniteMeasure ν] [NullSingletonClass ν] |
| (e : X ≃ᵐ X) (f : Y ≃ᵐ Y) (π : X → Y) (hπ : MeasurePreserving π μ ν) |
| (hcomm : ∀ x,π (e x)=f (π x)) |
| (p : Y → A) (α : X → B) (hp : Measurable p) (hα : Measurable α) |
| {U : Set Y} (hU : MeasurableSet U) (N : ℕ) |
| (hd : Pairwise (fun i j : Fin N => Disjoint ((f^[i.val]) '' U) ((f^[j.val]) '' U))) : |
| ∃ b : Y → B,Measurable b ∧ |
| (ν.restrict U).map (word f (fun y => (p y,b y)) N)= |
| (μ.restrict (π ⁻¹' U)).map (word e (fun x => (p (π x),α x)) N) := by |
| let V := π ⁻¹' U |
| have hV : MeasurableSet V := hπ.measurable hU |
| have hP : Measurable (word e (p ∘ π) N) := |
| word_measurable e e.measurable _ (hp.comp hπ.measurable) N |
| have hQ : Measurable (word f p N) := word_measurable f f.measurable p hp N |
| have hA : Measurable (word e α N) := word_measurable e e.measurable α hα N |
| have hfirst : (μ.restrict V).map (word e (p ∘ π) N)=(ν.restrict U).map (word f p N) := by |
| rw [factor_word e f π hcomm p N,←Measure.map_map hQ hπ.measurable,map_restrict_factor μ ν π hπ hU] |
| obtain ⟨C,hC,hjoint⟩ := relative_finite_realization (μ.restrict V) (ν.restrict U) |
| (word e (p ∘ π) N) (word e α N) (word f p N) hP hA hQ hfirst |
| let b := paintTower f U N C (fun _ => Classical.arbitrary B) |
| have hb : Measurable b := measurable_paintTower f hU N hd hC measurable_const |
| refine ⟨b,hb,?_⟩ |
| let zip : (Fin N → A) × (Fin N → B) → (Fin N → A×B) := fun ab i => (ab.1 i,ab.2 i) |
| have hzip : Measurable zip := measurable_of_finite zip |
| have heq : (ν.restrict U).map (word f (fun y => (p y,b y)) N)= |
| (ν.restrict U).map (zip ∘ fun y => (word f p N y,C y)) := by |
| apply Measure.map_congr |
| filter_upwards [ae_restrict_mem hU] with y hy |
| have hh : word f b N y=C y := paintTower_word f U N hd C _ hy |
| funext i |
| exact congrArg (fun c => (p (f^[i.val] y),c i)) hh |
| rw [heq,←Measure.map_map hzip (hQ.prodMk hC),hjoint, |
| Measure.map_map hzip (hP.prodMk hA)] |
| rfl |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] in |
| lemma equal_base_level_laws (μ : Measure X) [IsFiniteMeasure μ] |
| (ν : Measure Y) [IsFiniteMeasure ν] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) |
| (f : Y ≃ᵐ Y) (hf : MeasurePreserving f ν ν) |
| (V : Set X) (U : Set Y) (p : X → A) (q : Y → A) (hp : Measurable p) (hq : Measurable q) |
| {N m : ℕ} (hbase : (μ.restrict V).map (word e p N)=(ν.restrict U).map (word f q N)) |
| (i : ℕ) (hi : i+m≤N) : |
| (μ.restrict ((e^[i]) '' V)).map (word e p m)= |
| (ν.restrict ((f^[i]) '' U)).map (word f q m) := by |
| have heI : MeasurePreserving (iterateEquiv e i) μ μ := by |
| simpa only [funext (iterateEquiv_apply e i)] using he.iterate i |
| have hfI : MeasurePreserving (iterateEquiv f i) ν ν := by |
| simpa only [funext (iterateEquiv_apply f i)] using hf.iterate i |
| have hpw := word_measurable e e.measurable p hp m |
| have hqw := word_measurable f f.measurable q hq m |
| change (μ.restrict ((iterateEquiv e i) '' V)).map (word e p m)= |
| (ν.restrict ((iterateEquiv f i) '' U)).map (word f q m) |
| rw [map_restrict_image_equiv μ (iterateEquiv e i) heI V _ hpw, |
| map_restrict_image_equiv ν (iterateEquiv f i) hfI U _ hqw] |
| have hcomp (g : X ≃ᵐ X) : word g p m ∘ iterateEquiv g i=wordWindow i hi ∘ word g p N := by |
| funext x |
| exact (wordWindow_word g p i hi x).symm |
| rw [hcomp e] |
| have hcomp' : word f q m ∘ iterateEquiv f i=wordWindow i hi ∘ word f q N := by |
| funext y |
| exact (wordWindow_word f q i hi y).symm |
| rw [hcomp',←Measure.map_map (measurable_of_countable (wordWindow (A:=A) i hi)) |
| (word_measurable e e.measurable p hp N),hbase, |
| Measure.map_map (measurable_of_countable (wordWindow (A:=A) i hi)) |
| (word_measurable f f.measurable q hq N)] |
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace Y] [StandardBorelSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] [Fintype A] [MeasurableSingletonClass A] in |
| lemma lawClose_of_common_restriction (μ : Measure X) [IsProbabilityMeasure μ] |
| (ν : Measure Y) [IsProbabilityMeasure ν] |
| {V : Set X} {U : Set Y} (_ : MeasurableSet V) (_ : MeasurableSet U) |
| (p : X → A) (q : Y → A) (hp : Measurable p) (hq : Measurable q) |
| (hc : (μ.restrict V).map p=(ν.restrict U).map q) : |
| LawClose (μ.map p) (ν.map q) (μ.real Vᶜ+ν.real Uᶜ) := by |
| intro D hD |
| rw [map_measureReal_apply hp hD,map_measureReal_apply hq hD] |
| have hcommon := congrArg (fun ξ : Measure A => (ξ D).toReal) hc |
| simp only [Measure.map_apply hp hD,Measure.map_apply hq hD, |
| Measure.restrict_apply (hp hD),Measure.restrict_apply (hq hD)] at hcommon |
| change μ.real ((p ⁻¹' D)∩V)=ν.real ((q ⁻¹' D)∩U) at hcommon |
| have hp₀ : μ.real ((p ⁻¹' D)∩V)≤μ.real (p ⁻¹' D) := measureReal_mono inter_subset_left |
| have hq₀ : ν.real ((q ⁻¹' D)∩U)≤ν.real (q ⁻¹' D) := measureReal_mono inter_subset_left |
| have hp₁ : μ.real (p ⁻¹' D)≤μ.real ((p ⁻¹' D)∩V)+μ.real Vᶜ := by |
| apply (measureReal_mono (μ:=μ) (show p ⁻¹' D⊆((p ⁻¹' D)∩V)∪Vᶜ by |
| intro x hx; by_cases hv : x∈V |
| · exact Or.inl ⟨hx,hv⟩ |
| · exact Or.inr hv)).trans |
| exact measureReal_union_le _ _ |
| have hq₁ : ν.real (q ⁻¹' D)≤ν.real ((q ⁻¹' D)∩U)+ν.real Uᶜ := by |
| apply (measureReal_mono (μ:=ν) (show q ⁻¹' D⊆((q ⁻¹' D)∩U)∪Uᶜ by |
| intro x hx; by_cases hu : x∈U |
| · exact Or.inl ⟨hx,hu⟩ |
| · exact Or.inr hu)).trans |
| exact measureReal_union_le _ _ |
| rw [abs_le] |
| constructor <;> linarith [measureReal_nonneg (μ:=μ) (s:=Vᶜ),measureReal_nonneg (μ:=ν) (s:=Uᶜ)] |
|
|
| omit [StandardBorelSpace X] in |
| lemma tower_disjoint_mono (e : X ≃ᵐ X) (V : Set X) {N M : ℕ} (hm : M≤N) |
| (hd : Pairwise (fun i j : Fin N => Disjoint ((e^[i.val]) '' V) ((e^[j.val]) '' V))) : |
| Pairwise (fun i j : Fin M => Disjoint ((e^[i.val]) '' V) ((e^[j.val]) '' V)) := by |
| intro i j hij |
| apply hd (i:=⟨i.val,i.isLt.trans_le hm⟩) (j:=⟨j.val,j.isLt.trans_le hm⟩) |
| intro hh |
| exact hij (Fin.ext (congrArg (fun z : Fin N => z.val) hh)) |
|
|
| omit [StandardBorelSpace X] [StandardBorelSpace Y] in |
| lemma equal_base_interior_laws (μ : Measure X) [IsFiniteMeasure μ] |
| (ν : Measure Y) [IsFiniteMeasure ν] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) |
| (f : Y ≃ᵐ Y) (hf : MeasurePreserving f ν ν) |
| {V : Set X} {U : Set Y} (hV : MeasurableSet V) (hU : MeasurableSet U) |
| (p : X → A) (q : Y → A) (hp : Measurable p) (hq : Measurable q) |
| {N m : ℕ} |
| (hdV : Pairwise (fun i j : Fin N => Disjoint ((e^[i.val]) '' V) ((e^[j.val]) '' V))) |
| (hdU : Pairwise (fun i j : Fin N => Disjoint ((f^[i.val]) '' U) ((f^[j.val]) '' U))) |
| (hbase : (μ.restrict V).map (word e p N)=(ν.restrict U).map (word f q N)) : |
| (μ.restrict (⋃ i : Fin (N-m),(e^[i.val]) '' V)).map (word e p m)= |
| (ν.restrict (⋃ i : Fin (N-m),(f^[i.val]) '' U)).map (word f q m) := by |
| rw [map_restrict_finite_iUnion μ (fun i : Fin (N-m) => (e^[i.val]) '' V) (fun i => measurableSet_iterate_image e hV i.val) |
| (tower_disjoint_mono e V (Nat.sub_le N m) hdV) _ (word_measurable e e.measurable p hp m), |
| map_restrict_finite_iUnion ν (fun i : Fin (N-m) => (f^[i.val]) '' U) (fun i => measurableSet_iterate_image f hU i.val) |
| (tower_disjoint_mono f U (Nat.sub_le N m) hdU) _ (word_measurable f f.measurable q hq m)] |
| apply Finset.sum_congr rfl |
| intro i _ |
| exact equal_base_level_laws μ ν e he f hf V U p q hp hq hbase i.val (by omega) |
|
|
| omit [StandardBorelSpace X] in |
| lemma tower_interior_compl_bound (μ : Measure X) [IsProbabilityMeasure μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) {U : Set X} (hU : MeasurableSet U) |
| {N m : ℕ} (hN : 0<N) (hm : m≤N) |
| (hd : Pairwise (fun i j : Fin N => Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) : |
| μ.real (⋃ i : Fin (N-m),(e^[i.val]) '' U)ᶜ≤ |
| μ.real (⋃ i : Fin N,(e^[i.val]) '' U)ᶜ+(m : ℝ)/(N : ℝ) := by |
| have hc := congrArg ENNReal.toReal (tower_measure μ e he hU (N-m) |
| (tower_disjoint_mono e U (Nat.sub_le N m) hd)) |
| have ht := congrArg ENNReal.toReal (tower_measure μ e he hU N hd) |
| simp only [ENNReal.toReal_mul,ENNReal.toReal_natCast,Nat.cast_sub hm] at hc ht |
| change μ.real (⋃ i : Fin (N-m),(e^[i.val]) '' U)=((N : ℝ)-m)*μ.real U at hc |
| change μ.real (⋃ i : Fin N,(e^[i.val]) '' U)=(N : ℝ)*μ.real U at ht |
| have hC := measureReal_add_measureReal_compl (μ:=μ) |
| (MeasurableSet.iUnion (fun i : Fin (N-m) => measurableSet_iterate_image e hU i.val)) |
| have hT := measureReal_add_measureReal_compl (μ:=μ) |
| (MeasurableSet.iUnion (fun i : Fin N => measurableSet_iterate_image e hU i.val)) |
| have hu : μ.real univ=1 := by simp [Measure.real] |
| rw [hu,hc] at hC |
| rw [hu,ht] at hT |
| have hmass : (N : ℝ)*μ.real U≤1 := by |
| linarith [measureReal_nonneg (μ:=μ) (s:=(⋃ i : Fin N,(e^[i.val]) '' U)ᶜ)] |
| have hbound : (m : ℝ)*μ.real U≤(m : ℝ)/(N : ℝ) := by |
| apply (le_div_iff₀ (Nat.cast_pos.mpr hN)).mpr |
| nlinarith [mul_le_mul_of_nonneg_left hmass (Nat.cast_nonneg m)] |
| linarith |
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal |
| variable {X Y A B : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [MeasurableSpace Y] [StandardBorelSpace Y] |
| [TopologicalSpace Y] [SecondCountableTopology Y] [OpensMeasurableSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
| [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [Nonempty B] |
|
|
| omit [StandardBorelSpace X] in |
| theorem relative_measurable_graph_approx (μ : Measure X) [IsProbabilityMeasure μ] |
| (ν : Measure Y) [IsProbabilityMeasure ν] [NullSingletonClass ν] [ν.OuterRegular] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (f : Y ≃ᵐ Y) (hf : Ergodic f ν) |
| (π : X → Y) (hπ : MeasurePreserving π μ ν) (hcomm : ∀ x,π (e x)=f (π x)) |
| (p : Y → A) (α : X → B) (hp : Measurable p) (hα : Measurable α) |
| (m : ℕ) {ε : ℝ} (hε : 0<ε) : |
| ∃ b : Y → B,Measurable b ∧ |
| LawClose (μ.map (word e (fun x => (p (π x),α x)) m)) |
| (ν.map (word f (fun y => (p y,b y)) m)) ε := by |
| obtain ⟨N,hN⟩ := exists_nat_gt (max (m : ℝ) (4*(m : ℝ)/ε)+1) |
| have hNm : m<N := by exact_mod_cast (lt_of_le_of_lt (le_max_left _ _) (by linarith : max (m : ℝ) (4*(m : ℝ)/ε)<N)) |
| have hNp : 0<N := lt_of_le_of_lt (Nat.zero_le m) hNm |
| have hfrac : (m : ℝ)/(N : ℝ)<ε/4 := by |
| apply (div_lt_iff₀ (Nat.cast_pos.mpr hNp)).mpr |
| have hh : 4*(m : ℝ)/ε<(N : ℝ) := by linarith [le_max_right (m : ℝ) (4*(m : ℝ)/ε)] |
| have hh' := (div_lt_iff₀ hε).mp hh |
| linarith |
| obtain ⟨U,hU,hdU,hcover⟩ := exists_rohlin_tower ν f hf hNp (show 0<ε/4 by positivity) |
| let V := π ⁻¹' U |
| have hV : MeasurableSet V := hπ.measurable hU |
| have hlevels (i : ℕ) : (e^[i]) '' V=π ⁻¹' ((f^[i]) '' U) := factor_tower_level e f π hcomm U i |
| have hdV : Pairwise (fun i j : Fin N => Disjoint ((e^[i.val]) '' V) ((e^[j.val]) '' V)) := by |
| intro i j hij |
| rw [hlevels,hlevels] |
| exact (hdU i j hij).preimage π |
| obtain ⟨b,hb,hbase⟩ := relative_tower_base_copy μ ν e f π hπ hcomm p α hp hα hU N hdU |
| refine ⟨b,hb,?_⟩ |
| have hi := equal_base_interior_laws μ ν e he f hf.toMeasurePreserving hV hU |
| (fun x => (p (π x),α x)) (fun y => (p y,b y)) ((hp.comp hπ.measurable).prodMk hα) |
| (hp.prodMk hb) (m:=m) hdV hdU hbase.symm |
| have hc := lawClose_of_common_restriction μ ν |
| (MeasurableSet.iUnion (fun i : Fin (N-m) => measurableSet_iterate_image e hV i.val)) |
| (MeasurableSet.iUnion (fun i : Fin (N-m) => measurableSet_iterate_image f hU i.val)) |
| _ _ (word_measurable e e.measurable _ ((hp.comp hπ.measurable).prodMk hα) m) |
| (word_measurable f f.measurable _ (hp.prodMk hb) m) hi |
| have hcU : ν.real (⋃ i : Fin N,(f^[i.val]) '' U)ᶜ<ε/4 := by |
| have hh := (ENNReal.toReal_lt_toReal (measure_ne_top ν _) ENNReal.ofReal_ne_top).mpr hcover |
| rwa [ENNReal.toReal_ofReal (by positivity)] at hh |
| have hunion : (⋃ i : Fin N,(e^[i.val]) '' V)=π ⁻¹' (⋃ i : Fin N,(f^[i.val]) '' U) := by |
| simp only [hlevels,preimage_iUnion] |
| have hcV : μ.real (⋃ i : Fin N,(e^[i.val]) '' V)ᶜ=ν.real (⋃ i : Fin N,(f^[i.val]) '' U)ᶜ := by |
| rw [hunion,←preimage_compl] |
| exact congrArg ENNReal.toReal (hπ.measure_preimage |
| (MeasurableSet.iUnion (fun i : Fin N => measurableSet_iterate_image f hU i.val)).compl.nullMeasurableSet) |
| have h₁ := tower_interior_compl_bound μ e he hV hNp hNm.le hdV |
| have h₂ := tower_interior_compl_bound ν f hf.toMeasurePreserving hU hNp hNm.le hdU |
| exact hc.mono (by linarith) |
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set StandardMapEntropy.Entropy |
| open scoped ENNReal BigOperators symmDiff |
| variable {X : Type*} [mX : MeasurableSpace X] |
|
|
| lemma finite_sigma_set_approx (μ : Measure X) [IsFiniteMeasure μ] |
| (m : ℕ → MeasurableSpace X) (hm : Monotone m) (hgen : ‹MeasurableSpace X›=⨆ n,m n) |
| {s : Set X} (hs : MeasurableSet s) {ε : ℝ≥0∞} (hε : 0<ε) : |
| ∃ n : ℕ,∃ t : Set X,MeasurableSet[m n] t ∧ μ (t ∆ s)<ε := by |
| let C : Set (Set X) := {t | ∃ n,MeasurableSet[m n] t} |
| have hC : IsSetRing C := { |
| empty_mem := ⟨0,@MeasurableSet.empty X (m 0)⟩ |
| union_mem := by |
| rintro s t ⟨i,hi⟩ ⟨j,hj⟩ |
| exact ⟨max i j,((hm (le_max_left _ _)) _ hi).union ((hm (le_max_right _ _)) _ hj)⟩ |
| sdiff_mem := by |
| rintro s t ⟨i,hi⟩ ⟨j,hj⟩ |
| exact ⟨max i j,((hm (le_max_left _ _)) _ hi).diff ((hm (le_max_right _ _)) _ hj)⟩ } |
| have he : (⨆ n,m n)=MeasurableSpace.generateFrom C := by |
| apply le_antisymm |
| · apply iSup_le |
| intro n t ht |
| exact MeasurableSpace.measurableSet_generateFrom ⟨n,ht⟩ |
| · apply MeasurableSpace.generateFrom_le |
| rintro t ⟨n,ht⟩ |
| exact (le_iSup m n) _ ht |
| have hc : ∃ D : Set (Set X),D.Countable ∧ D⊆C ∧ μ (⋃₀ D)ᶜ=0 := by |
| refine ⟨{univ},countable_singleton _,?_,?_⟩ |
| · intro t ht |
| rcases mem_singleton_iff.mp ht with rfl |
| exact ⟨0,@MeasurableSet.univ X (m 0)⟩ |
| · simp |
| obtain ⟨t,⟨n,hn⟩,ht⟩ := exists_measure_symmDiff_lt_of_generateFrom_isSetRing hC hc |
| (hgen.trans he) hs hε |
| exact ⟨n,t,hn,ht⟩ |
|
|
| theorem finite_factor_approx (μ : Measure X) [IsProbabilityMeasure μ] |
| (F : ℕ → Type*) [∀ n,Fintype (F n)] [∀ n,MeasurableSpace (F n)] |
| [∀ n,MeasurableSingletonClass (F n)] (f : (n : ℕ) → X → F n) |
| (hm : Monotone (fun n => MeasurableSpace.comap (f n) inferInstance)) |
| (hgen : ‹MeasurableSpace X›=⨆ n,MeasurableSpace.comap (f n) inferInstance) |
| {A : Type*} [Fintype A] [Nonempty A] [MeasurableSpace A] [MeasurableSingletonClass A] |
| (p : X → A) (hp : Measurable p) {ε : ℝ} (hε : 0<ε) : |
| ∃ N : ℕ,∃ D : F N → A,μ.real {x | D (f N x)≠p x}<ε := by |
| classical |
| let δ := ε/((Fintype.card A : ℝ)+1) |
| have hδ : 0<δ := div_pos hε (by positivity) |
| have ha (a : A) := finite_sigma_set_approx μ |
| (fun n => MeasurableSpace.comap (f n) inferInstance) hm hgen |
| (hp (measurableSet_singleton a)) (ENNReal.ofReal_pos.mpr hδ) |
| choose n t ht hclose using ha |
| let N := Finset.univ.sup n |
| have hn (a : A) : n a≤N := Finset.le_sup (Finset.mem_univ a) |
| have ht' (a : A) : MeasurableSet[MeasurableSpace.comap (f N) inferInstance] (t a) := |
| (hm (hn a)) _ (ht a) |
| have hu (a : A) := MeasurableSpace.measurableSet_comap.mp (ht' a) |
| choose U hUm hUt using hu |
| let D : F N → A := fun y => if h : ∃ a,y∈U a then h.choose else Classical.ofNonempty |
| have hbad : {x | D (f N x)≠p x}⊆⋃ a : A,t a ∆ (p ⁻¹' {a}) := by |
| intro x hx |
| by_contra hn |
| have hnot (a : A) : x∉t a ∆ (p ⁻¹' {a}) := by |
| intro ha |
| exact hn (mem_iUnion.mpr ⟨a,ha⟩) |
| have he (a : A) : f N x∈U a ↔ p x=a := by |
| have hiff : x∈t a ↔ x∈p ⁻¹' {a} := by |
| have hh := hnot a |
| simp only [mem_symmDiff] at hh |
| tauto |
| rw [←hUt a] at hiff |
| exact hiff |
| have hex : ∃ a,f N x∈U a := ⟨p x,(he _).mpr rfl⟩ |
| exact hx (by simpa only [D,dite_eq_left hex] using ((he hex.choose).mp hex.choose_spec).symm) |
| have hc (a : A) : μ.real (t a ∆ (p ⁻¹' {a}))≤δ := by |
| have hh := (ENNReal.toReal_lt_toReal (measure_ne_top μ _) ENNReal.ofReal_ne_top).mpr (hclose a) |
| rw [ENNReal.toReal_ofReal hδ.le] at hh |
| exact hh.le |
| refine ⟨N,D,lt_of_le_of_lt ((measureReal_mono hbad).trans |
| ((measureReal_iUnion_fintype_le _).trans (Finset.sum_le_sum (fun a _ => hc a)))) ?_⟩ |
| simp only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul] |
| have he : ((Fintype.card A : ℝ)+1)*δ=ε := mul_div_cancel₀ ε (ne_of_gt (by positivity)) |
| nlinarith |
|
|
| omit mX in |
| lemma joinedBinary_comap_monotone (α : ℕ → ℕ → X → Bool) : |
| Monotone (fun N => MeasurableSpace.comap (joinedBinary α N) inferInstance) := by |
| intro i j hij |
| let r : ((Fin j×Fin j) → Bool) → ((Fin i×Fin i) → Bool) := |
| fun w p => w (p.1.castLE hij,p.2.castLE hij) |
| have hF : Measurable[MeasurableSpace.comap (joinedBinary α j) inferInstance] |
| (joinedBinary α j) := measurable_iff_comap_le.mpr le_rfl |
| have hr := (measurable_of_countable r).comp hF |
| exact measurable_iff_comap_le.mp hr |
|
|
| lemma joinedBinary_generates [StandardBorelSpace X] |
| (α : ℕ → ℕ → X → Bool) (hα : ∀ i j,Measurable (α i j)) |
| (hsep : Function.Injective (fun x => fun i j => α i j x)) : |
| ‹MeasurableSpace X›=⨆ N,MeasurableSpace.comap (joinedBinary α N) inferInstance := by |
| let F : X → ℕ → ℕ → Bool := fun x i j => α i j x |
| have hF : Measurable F := Measurable.of_eval (fun index => Measurable.of_eval (hα index)) |
| have hFE : MeasurableEmbedding F := hF.measurableEmbedding hsep |
| have heq : MeasurableSpace.comap F inferInstance = mX := hFE.comap_eq |
| have hupper : (⨆ N,MeasurableSpace.comap (joinedBinary α N) inferInstance) ≤ mX := by |
| apply iSup_le |
| intro N |
| exact measurable_iff_comap_le.mp (measurable_joinedBinary hα N) |
| let m : MeasurableSpace X := ⨆ N,MeasurableSpace.comap (joinedBinary α N) inferInstance |
| have hlarge (i j : ℕ) : @Measurable X Bool m inferInstance (α i j) := by |
| let N := max i j+1 |
| let a : Fin N×Fin N := (⟨i,by dsimp [N]; omega⟩,⟨j,by dsimp [N]; omega⟩) |
| have hN : @Measurable X ((Fin N×Fin N) → Bool) m inferInstance (joinedBinary α N) := |
| measurable_iff_comap_le.mpr |
| (le_iSup (fun n => MeasurableSpace.comap (joinedBinary α n) inferInstance) N) |
| exact (measurable_pi_apply a).comp hN |
| have hsup : @Measurable X (ℕ → ℕ → Bool) m inferInstance F := |
| Measurable.of_eval (fun index => Measurable.of_eval (hlarge index)) |
| apply le_antisymm |
| · have hle : MeasurableSpace.comap F inferInstance ≤ m := measurable_iff_comap_le.mp hsup |
| exact (le_of_eq heq.symm).trans hle |
| · exact hupper |
|
|
| theorem joinedBinary_approximates [StandardBorelSpace X] |
| (μ : Measure X) [IsProbabilityMeasure μ] |
| (α : ℕ → ℕ → X → Bool) (hα : ∀ i j,Measurable (α i j)) |
| (hsep : Function.Injective (fun x => fun i j => α i j x)) |
| {A : Type*} [Fintype A] [Nonempty A] [MeasurableSpace A] [MeasurableSingletonClass A] |
| (p : X → A) (hp : Measurable p) {ε : ℝ} (hε : 0<ε) : |
| ∃ N : ℕ,∃ D : ((Fin N×Fin N) → Bool) → A, |
| μ.real {x | D (joinedBinary α N x)≠p x}<ε := |
| finite_factor_approx μ (fun N => (Fin N×Fin N) → Bool) (joinedBinary α) |
| (joinedBinary_comap_monotone α) (joinedBinary_generates α hα hsep) p hp hε |
| end HyperbolicCoding |
|
|
| end |
|
|
| end OAI |
|
|
