| import OAI.Dynamics.StandardMap.EntropyEndpoint |
| import OAI.Dynamics.StandardMap.Coding.PartitionLimit |
| import OAI.Dynamics.StandardMap.Coding.SanitizedTowerLaw |
|
|
| namespace OAI |
|
|
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal Topology |
| variable {X A : Type*} [MeasurableSpace X] [StandardBorelSpace X] |
| [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X] |
| [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] |
|
|
| def FiniteRateSupremum (μ : Measure X) (f : X → X) (h : ℝ) : Prop := |
| (∀ r : ℕ,∀ p : X → Fin (r+1),Measurable p → rate μ f p≤h) ∧ |
| (∀ ε : ℝ,0 < ε → ∃ r : ℕ,∃ p : X → Fin (r+1),Measurable p ∧ h-ε < rate μ f p) |
|
|
| omit [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] |
| [OpensMeasurableSpace X] in |
| lemma FiniteRateSupremum.upper {μ : Measure X} [IsProbabilityMeasure μ] {f : X → X} {h : ℝ} |
| (H : FiniteRateSupremum μ f h) |
| {C : Type*} [Fintype C] [Nonempty C] [MeasurableSpace C] [MeasurableSingletonClass C] |
| (p : X → C) (hp : Measurable p) : rate μ f p≤h := by |
| have hc : Fintype.card C-1+1=Fintype.card C := Nat.sub_add_cancel Fintype.card_pos |
| let e : C ≃ Fin (Fintype.card C-1+1) := (Fintype.equivFin C).trans (finCongr hc.symm) |
| have he := H.1 (Fintype.card C-1) (e ∘ p) ((measurable_of_finite e).comp hp) |
| rwa [rate_equiv] at he |
|
|
| omit [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] |
| [OpensMeasurableSpace X] [DecidableEq A] [Nonempty A] in |
| lemma iid_lawClose_prefix (μ : Measure X) (e : X ≃ᵐ X) (p : X → A) (hp : Measurable p) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| {m n : ℕ} (hmn : m≤n) {δ : ℝ} |
| (h : LawClose (μ.map (word e p n)) |
| (Measure.pi (fun _ : Fin n => finiteWeightLaw β)) δ) : |
| LawClose (μ.map (word e p m)) |
| (Measure.pi (fun _ : Fin m => finiteWeightLaw β)) δ := by |
| let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum |
| let ν := Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β) |
| have h' : LawClose (μ.map (word e p n)) |
| (ν.map (word iidShift (fun w : ℤ → A => w 0) n)) δ := by |
| simpa only [ν,iid_word_law] using h |
| have hh := lawClose_prefix μ ν e iidShift e.measurable iidShift.measurable p |
| (fun w : ℤ → A => w 0) hp (measurable_pi_apply 0) hmn h' |
| simpa only [ν,iid_word_law] using hh |
|
|
| def GoodIIDStage (μ : Measure X) (e : X ≃ᵐ X) (β : A → ℝ) |
| {η : ℝ} (T : IIDCopyTest μ e β η) (n : ℕ) (q : X → A) : Prop := |
| Measurable q ∧ |
| LawClose (μ.map (word e q (max T.length n))) |
| (Measure.pi (fun _ : Fin (max T.length n) => finiteWeightLaw β)) |
| (min T.tolerance (1/(n+1 : ℝ))) ∧ |
| weightEntropy β-T.tolerance≤rate μ e q |
|
|
| lemma goodIIDStage_initial (μ : Measure X) [IsProbabilityMeasure μ] |
| [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) |
| (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| (hβentropy : 0 < weightEntropy β) (H : FiniteRateSupremum μ e (weightEntropy β)) |
| (zero one : A) (h01 : zero≠one) {η : ℝ} (T : IIDCopyTest μ e β η) (n : ℕ) : |
| ∃ q : X → A,GoodIIDStage μ e β T n q := by |
| obtain ⟨r,p,hp,hpnear⟩ := H.2 (T.tolerance/2) (half_pos T.tolerance_pos) |
| have hε : 0 < min T.tolerance (1/(n+1 : ℝ)) := lt_min T.tolerance_pos (by positivity) |
| obtain ⟨q,hq,hl,hr⟩ := initial_rate_controlled_copy μ e he htotal p hp β hβ hβsum |
| hβentropy (H.1 r p hp) zero one h01 (max T.length n) hε (half_pos T.tolerance_pos) |
| exact ⟨q,hq,hl,by linarith⟩ |
|
|
| lemma goodIIDStage_next (μ : Measure X) [IsProbabilityMeasure μ] |
| [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) |
| (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| (hβentropy : 0 < weightEntropy β) (H : FiniteRateSupremum μ e (weightEntropy β)) |
| (zero one : A) (h01 : zero≠one) {η ξ : ℝ} (hη : 0 < η) |
| (T : IIDCopyTest μ e β (η/2)) (U : IIDCopyTest μ e β ξ) |
| {n : ℕ} {q : X → A} (hq : GoodIIDStage μ e β T n q) : |
| ∃ q' : X → A,GoodIIDStage μ e β U (n+1) q' ∧ μ.real {x | q x≠q' x}<η := by |
| obtain ⟨r,p,hp,hpnear⟩ := H.2 (U.tolerance/2) (half_pos U.tolerance_pos) |
| let P : X → A × Fin (r+1) := fun x => (q x,p x) |
| have hP : Measurable P := hq.1.prodMk hp |
| have hrateP : rate μ e p≤rate μ e P := rate_factor μ e he.toMeasurePreserving P hP Prod.snd |
| have htest : LawClose (μ.map (word e (Prod.fst ∘ P) T.length)) |
| (Measure.pi (fun _ : Fin T.length => finiteWeightLaw β)) T.tolerance := |
| (iid_lawClose_prefix μ e q hq.1 β hβ hβsum (le_max_left _ _) hq.2.1).mono (min_le_left _ _) |
| have hε : 0 < min U.tolerance (1/((n+1)+1 : ℝ)) := lt_min U.tolerance_pos (by positivity) |
| obtain ⟨q',s,M,G,hq',hc,hl,_hd,hr⟩ := T.copy μ e he htotal β hβ hβsum hβentropy |
| zero one h01 hη P hP Prod.fst htest hq.2.2 (H.upper P hP) |
| (max U.length (n+1)) hε (half_pos U.tolerance_pos) |
| refine ⟨q',⟨hq',?_,by linarith⟩,hc⟩ |
| simpa only [Nat.cast_add,Nat.cast_one] using hl |
|
|
| theorem full_entropy_copy_sequence (μ : Measure X) [IsProbabilityMeasure μ] |
| [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) |
| (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| (hβentropy : 0 < weightEntropy β) (H : FiniteRateSupremum μ e (weightEntropy β)) |
| (zero one : A) (h01 : zero≠one) (η : ℕ → ℝ) (hη : ∀ n,0 < η n) : |
| ∃ q : ℕ → X → A,(∀ n,Measurable (q n)) ∧ |
| (∀ n,μ.real {x | q (n+1) x≠q n x}<η n) ∧ |
| (∀ n,LawClose (μ.map (word e (q n) n)) |
| (Measure.pi (fun _ : Fin n => finiteWeightLaw β)) (1/(n+1 : ℝ))) := by |
| have hT (n : ℕ) : Nonempty (IIDCopyTest μ e β (η n/2)) := |
| exists_iidCopyTest μ e he.toMeasurePreserving β hβ hβsum hβentropy (half_pos (hη n)) |
| let T (n : ℕ) : IIDCopyTest μ e β (η n/2) := Classical.choice (hT n) |
| obtain ⟨q₀,hq₀⟩ := goodIIDStage_initial μ e he htotal β hβ hβsum hβentropy H zero one h01 (T 0) 0 |
| have hnext (n : ℕ) (q : {q : X → A // GoodIIDStage μ e β (T n) n q}) : |
| ∃ q' : X → A,GoodIIDStage μ e β (T (n+1)) (n+1) q' ∧ |
| μ.real {x | q.val x≠q' x}<η n := |
| goodIIDStage_next μ e he htotal β hβ hβsum hβentropy H zero one h01 (hη n) |
| (T n) (T (n+1)) q.property |
| let next (n : ℕ) (q : {q : X → A // GoodIIDStage μ e β (T n) n q}) : |
| {q' : X → A // GoodIIDStage μ e β (T (n+1)) (n+1) q'} := |
| ⟨Classical.choose (hnext n q),(Classical.choose_spec (hnext n q)).1⟩ |
| let z : (n : ℕ) → {q : X → A // GoodIIDStage μ e β (T n) n q} := |
| fun n => Nat.rec (motive:=fun j => {q : X → A // GoodIIDStage μ e β (T j) j q}) |
| ⟨q₀,hq₀⟩ next n |
| refine ⟨fun n => (z n).val,fun n => (z n).property.1,?_,?_⟩ |
| · intro n |
| have h := (Classical.choose_spec (hnext n (z n))).2 |
| have h' : μ.real {x | (z n).val x≠(z (n+1)).val x}<η n := h |
| have hs : {x | (z (n+1)).val x≠(z n).val x}= |
| {x | (z n).val x≠(z (n+1)).val x} := Set.ext (fun _ => ne_comm) |
| rw [hs] |
| exact h' |
| · intro n |
| exact (iid_lawClose_prefix μ e (z n).val (z n).property.1 β hβ hβsum |
| (le_max_right _ _) (z n).property.2.1).mono (min_le_right _ _) |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal Topology |
| variable {X Y A : Type*} [MeasurableSpace X] [MeasurableSpace Y] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
|
|
| omit [Fintype A] [MeasurableSingletonClass A] in |
| lemma iidShift_integerIterate (n : ℤ) (w : ℤ → A) (i : ℤ) : |
| integerIterate iidShift n w i=w (i+n) := by |
| cases n with |
| | ofNat m => rw [Int.ofNat_eq_natCast,integerIterate_nat,iidShift_iterate] |
| | negSucc m => |
| have hn : Int.negSucc m= -((m+1 : ℕ) : ℤ) := by omega |
| rw [hn,integerIterate_neg_nat,iidShift_symm_iterate,sub_eq_add_neg] |
|
|
| omit [Fintype A] [MeasurableSingletonClass A] in |
| lemma iid_orbitName (w : ℤ → A) : orbitName iidShift (fun z : ℤ → A => z 0) w=w := by |
| funext i |
| exact (iidShift_integerIterate i w 0).trans (by rw [zero_add]) |
|
|
| lemma finite_integer_window (s : Finset ℤ) : |
| ∃ a : ℤ,∃ N : ℕ,∀ i∈s,0≤ i-a ∧ i-a < (N : ℤ) := by |
| let b := s.sup Int.natAbs |
| refine ⟨-(b : ℤ),2*b+1,?_⟩ |
| intro i hi |
| have hb : i.natAbs≤b := Finset.le_sup (f:=Int.natAbs) hi |
| have hb' : (i.natAbs : ℤ)≤b := by exact_mod_cast hb |
| have h1 : -i≤(i.natAbs : ℤ) := by simpa only [Int.natAbs_neg] using (Int.le_natAbs (a:=-i)) |
| have h2 := (Int.le_natAbs (a:=i)) |
| constructor <;> omega |
|
|
| lemma orbit_restrict_map_eq_window (μ : Measure X) (e : X ≃ᵐ X) |
| (he : MeasurePreserving e μ μ) (p : X → A) (hp : Measurable p) |
| (s : Finset ℤ) (a : ℤ) (N : ℕ) (hb : ∀ i∈s,0≤ i-a ∧ i-a < (N : ℤ)) : |
| μ.map (s.restrict ∘ orbitName e p)= |
| (μ.map (word e p N)).map (fun w : Fin N → A => fun i : s => |
| w ⟨(i.val-a).toNat,by have h := hb i.val i.property; omega⟩) := by |
| let W : (Fin N → A) → (s → A) := fun w i => |
| w ⟨(i.val-a).toNat,by have h := hb i.val i.property; omega⟩ |
| have hW : Measurable W := measurable_of_finite W |
| have hpN := word_measurable e e.measurable p hp N |
| have hfun : s.restrict ∘ orbitName e p=(W ∘ word e p N) ∘ integerIterate e a := by |
| funext x i |
| change p (integerIterate e i.val x) = p (e^[((i.val-a).toNat)] (integerIterate e a x)) |
| rw [←integerIterate_nat,←integerIterate_add] |
| have h := hb i.val i.property |
| congr 2 |
| omega |
| change μ.map (s.restrict ∘ orbitName e p)=(μ.map (word e p N)).map W |
| rw [hfun,←Measure.map_map (hW.comp hpN) (integerIterate_measurable e a), |
| (integerIterate_measurePreserving e he a).map_eq,Measure.map_map hW hpN] |
|
|
| lemma lawClose_orbit_restrict_of_word |
| (μ : Measure X) (ν : Measure Y) (e : X ≃ᵐ X) (d : Y ≃ᵐ Y) |
| (he : MeasurePreserving e μ μ) (hd : MeasurePreserving d ν ν) |
| (p : X → A) (q : Y → A) (hp : Measurable p) (hq : Measurable q) |
| (s : Finset ℤ) (a : ℤ) (N : ℕ) (hb : ∀ i∈s,0≤ i-a ∧ i-a < (N : ℤ)) |
| {δ : ℝ} (hl : LawClose (μ.map (word e p N)) (ν.map (word d q N)) δ) : |
| LawClose (μ.map (s.restrict ∘ orbitName e p)) |
| (ν.map (s.restrict ∘ orbitName d q)) δ := by |
| rw [orbit_restrict_map_eq_window μ e he p hp s a N hb, |
| orbit_restrict_map_eq_window ν d hd q hq s a N hb] |
| exact hl.map (measurable_of_finite _) |
|
|
| omit [Fintype A] [MeasurableSingletonClass A] in |
| lemma restricted_box_lawClose (μ : Measure X) (ν : Measure Y) |
| (e : X ≃ᵐ X) (d : Y ≃ᵐ Y) (p : X → A) (q : Y → A) |
| (hp : Measurable p) (hq : Measurable q) (s : Finset ℤ) |
| (t : ℤ → Set A) (ht : ∀ i,MeasurableSet (t i)) {δ : ℝ} |
| (h : LawClose (μ.map (s.restrict ∘ orbitName e p)) |
| (ν.map (s.restrict ∘ orbitName d q)) δ) : |
| |(μ.map (orbitName e p)).real (Set.pi s t)- |
| (ν.map (orbitName d q)).real (Set.pi s t)|≤δ := by |
| let D : Set (s → A) := Set.pi Set.univ (fun i => t i.val) |
| have hD : MeasurableSet D := MeasurableSet.pi Set.countable_univ (fun i _ => ht i.val) |
| have hpre : (s.restrict : (ℤ → A) → (s → A)) ⁻¹' D=Set.pi s t := by |
| ext w |
| simp only [D,mem_preimage,Set.mem_pi,mem_univ,true_implies,Finset.mem_coe,Finset.restrict] |
| exact ⟨fun h i hi => h ⟨i,hi⟩,fun h i => h i i.property⟩ |
| have hr : Measurable (s.restrict : (ℤ → A) → (s → A)) := measurable_restrict (s : Set ℤ) |
| have h1 : (μ.map (s.restrict ∘ orbitName e p)).real D= |
| (μ.map (orbitName e p)).real (Set.pi s t) := by |
| simp only [Measure.real] |
| rw [←Measure.map_map hr (measurable_orbitName e hp),Measure.map_apply hr hD,hpre] |
| have h2 : (ν.map (s.restrict ∘ orbitName d q)).real D= |
| (ν.map (orbitName d q)).real (Set.pi s t) := by |
| simp only [Measure.real] |
| rw [←Measure.map_map hr (measurable_orbitName d hq),Measure.map_apply hr hD,hpre] |
| simpa only [h1,h2] using h D hD |
|
|
| theorem iid_law_of_growing_forward_words [Nonempty A] |
| (μ : Measure X) [IsProbabilityMeasure μ] (e : X ≃ᵐ X) |
| (he : MeasurePreserving e μ μ) (q : ℕ → X → A) (hq : ∀ n,Measurable (q n)) |
| (p : X → A) (hp : Measurable p) |
| (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x) |
| (β : Measure A) [IsProbabilityMeasure β] (ε : ℕ → ℝ) |
| (hε : Tendsto ε atTop (𝓝 0)) |
| (hlaw : ∀ n,LawClose (μ.map (word e (q n) n)) |
| (Measure.pi (fun _ : Fin n => β)) (ε n)) : |
| MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => β)) := by |
| apply iid_law_of_partition_limit e he hq hp hlim β |
| intro s t ht |
| let ν := Measure.infinitePi (fun _ : ℤ => β) |
| obtain ⟨a,N,hN⟩ := finite_integer_window s |
| have htarget : (ν.map (orbitName iidShift (fun w : ℤ → A => w 0))).real (Set.pi s t)= |
| (∏ i∈s,β (t i)).toReal := by |
| rw [show orbitName iidShift (fun w : ℤ → A => w 0)=id from funext iid_orbitName, |
| Measure.map_id] |
| exact congrArg ENNReal.toReal (Measure.infinitePi_pi (fun _ : ℤ => β) (fun i _ => ht i)) |
| have hbound : ∀ᶠ n : ℕ in atTop, |
| |(μ.map (orbitName e (q n))).real (Set.pi s t)-(∏ i∈s,β (t i)).toReal|≤ε n := by |
| filter_upwards [eventually_ge_atTop N] with n hn |
| have hb : ∀ i∈s,0≤ i-a ∧ i-a < (n : ℤ) := by |
| intro i hi |
| have h := hN i hi |
| exact ⟨h.1,lt_of_lt_of_le h.2 (by exact_mod_cast hn)⟩ |
| have hl : LawClose (μ.map (word e (q n) n)) |
| (ν.map (word iidShift (fun w : ℤ → A => w 0) n)) (ε n) := by |
| simpa only [ν,iid_word_law] using hlaw n |
| have hr := lawClose_orbit_restrict_of_word μ ν e iidShift he (iidShift_preserving β) |
| (q n) (fun w : ℤ → A => w 0) (hq n) (measurable_pi_apply 0) s a n hb hl |
| have hh := restricted_box_lawClose μ ν e iidShift (q n) (fun w : ℤ → A => w 0) |
| (hq n) (measurable_pi_apply 0) s t ht hr |
| rwa [htarget] at hh |
| apply tendsto_iff_dist_tendsto_zero.mpr |
| simp only [Real.dist_eq] |
| exact squeeze_zero' (Eventually.of_forall (fun _ => abs_nonneg _)) hbound hε |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal NNReal Topology |
| variable {X A : Type*} [MeasurableSpace X] |
| [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] |
|
|
| omit [Fintype A] [MeasurableSingletonClass A] in |
| lemma word_law_of_iid_factor (μ : Measure X) (e : X ≃ᵐ X) (p : X → A) |
| (_hp : Measurable p) (β : Measure A) [IsProbabilityMeasure β] |
| (hcode : MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => β))) |
| (n : ℕ) : μ.map (word e p n)=Measure.pi (fun _ : Fin n => β) := by |
| have heq : word iidShift (fun w : ℤ → A => w 0) n ∘ orbitName e p=word e p n := by |
| funext x i |
| rw [Function.comp_apply,iid_word_eq] |
| exact congrArg p (integerIterate_nat e i.val x) |
| have hm := congrArg (fun ν => ν.map (word iidShift (fun w : ℤ → A => w 0) n)) hcode.map_eq |
| rw [Measure.map_map (word_measurable iidShift iidShift.measurable _ (measurable_pi_apply 0) n) |
| hcode.measurable,heq,iid_word_law] at hm |
| exact hm |
|
|
| lemma rate_of_iid_factor [DecidableEq A] (μ : Measure X) [IsProbabilityMeasure μ] |
| (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (p : X → A) (hp : Measurable p) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| (hcode : MeasurePreserving (orbitName e p) μ |
| (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β))) : |
| rate μ e p=weightEntropy β := by |
| let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum |
| have hword (n : ℕ) : obs μ (word e p n)=(n : ℝ)*weightEntropy β := by |
| have hmass : mass μ (word e p n)=productWordWeight β n := by |
| funext w |
| change μ.real ((word e p n) ⁻¹' {w})=_ |
| rw [←map_measureReal_apply (word_measurable e e.measurable p hp n) (measurableSet_singleton w), |
| word_law_of_iid_factor μ e p hp (finiteWeightLaw β) hcode, |
| Measure.real,Measure.pi_singleton] |
| simp only [finiteWeightLaw_singleton,ENNReal.toReal_prod,ENNReal.toReal_ofReal (hβ _), |
| productWordWeight] |
| rw [obs,hmass] |
| exact shannon_productWordWeight β hβsum n |
| apply tendsto_nhds_unique (rate_tendsto μ e he p hp) |
| apply tendsto_const_nhds.congr' |
| filter_upwards [eventually_gt_atTop 0] with n hn |
| rw [hword,mul_div_cancel_left₀ _ (Nat.cast_ne_zero.mpr hn.ne')] |
|
|
| omit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] in |
| lemma geometric_repainting_summable (μ : Measure X) [IsFiniteMeasure μ] |
| (q : ℕ → X → A) |
| (h : ∀ n,μ.real {x | q (n+1) x≠q n x}<((1/2 : ℝ≥0)^n : ℝ)) : |
| (∑' n : ℕ,μ {x | q (n+1) x≠q n x})≠⊤ := by |
| have hs : (∑' n : ℕ,(((1/2 : ℝ≥0)^n) : ℝ≥0∞))≠⊤ := by |
| apply ENNReal.tsum_coe_ne_top_iff_summable_coe.mpr |
| simpa only [NNReal.coe_pow,NNReal.coe_div,NNReal.coe_one,NNReal.coe_ofNat] using |
| (summable_geometric_of_lt_one (show (0 : ℝ)≤1/2 by norm_num) (by norm_num : (1/2 : ℝ) < 1)) |
| apply ne_top_of_le_ne_top hs |
| apply ENNReal.tsum_le_tsum |
| intro n |
| apply (ENNReal.toReal_le_toReal (measure_ne_top μ _) (by simp)).mp |
| simpa only [Measure.real,ENNReal.toReal_pow,ENNReal.coe_toReal,NNReal.coe_pow] using (h n).le |
|
|
| variable [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] |
| [OpensMeasurableSpace X] [DecidableEq A] [Nonempty A] |
|
|
| theorem full_entropy_iid_factor (μ : Measure X) [IsProbabilityMeasure μ] |
| [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) |
| (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) |
| (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) |
| (hβentropy : 0 < weightEntropy β) (H : FiniteRateSupremum μ e (weightEntropy β)) |
| (zero one : A) (h01 : zero≠one) : |
| ∃ p : X → A,Measurable p ∧ |
| MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) ∧ |
| rate μ e p=weightEntropy β ∧ |
| (∀ x,orbitName e p (e x)=fun i => orbitName e p x (i+1)) ∧ |
| (∀ r : ℕ,∀ α : X → Fin (r+1),Measurable α → |
| rate μ e (fun x => (p x,α x))=weightEntropy β) := by |
| let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum |
| obtain ⟨q,hq,hpaint,hlaw⟩ := full_entropy_copy_sequence μ e he htotal β hβ hβsum hβentropy |
| H zero one h01 (fun n => ((1/2 : ℝ≥0)^n : ℝ)) (fun _ => by positivity) |
| obtain ⟨p,hp,hlim⟩ := exists_partition_limit μ q hq (geometric_repainting_summable μ q hpaint) |
| have hcode := iid_law_of_growing_forward_words μ e he.toMeasurePreserving q hq p hp hlim |
| (finiteWeightLaw β) (fun n => 1/(n+1 : ℝ)) tendsto_one_div_add_atTop_nhds_zero_nat hlaw |
| have hrate := rate_of_iid_factor μ e he.toMeasurePreserving p hp β hβ hβsum hcode |
| refine ⟨p,hp,hcode,hrate,fun x => orbitName_shift e p x,?_⟩ |
| intro r α hα |
| apply le_antisymm (H.upper (fun x => (p x,α x)) (hp.prodMk hα)) |
| rw [←hrate] |
| exact rate_pair_ge_left μ e he.toMeasurePreserving p α hp hα |
|
|
| end HyperbolicCoding |
|
|
| end |
| section |
| namespace StandardMapEntropy.Entropy |
| open MeasureTheory Set Filter |
| open scoped BigOperators ENNReal Topology |
|
|
| lemma shannon_weighted_le {A : Type*} [Fintype A] |
| (p q : A → ℝ) (hp : ∀ a,0 ≤ p a) (hq : ∀ a,0 ≤ q a) |
| (hps : ∑ a,p a=1) (hqs : ∑ a,q a=1) |
| {c : ℝ} (hc : 0 < c) (hdom : ∀ a,c*p a ≤ q a) : |
| c*shannon p ≤ shannon q := by |
| have hs (a : A) (ha : p a≠0) : q a≠0 := by |
| have hp' : 0 < p a := lt_of_le_of_ne (hp a) (Ne.symm ha) |
| exact ne_of_gt ((mul_pos hc hp').trans_le (hdom a)) |
| have hh := mul_le_mul_of_nonneg_left |
| (shannon_le_cross p q hp hq hs (by rw [hps,hqs])) hc.le |
| apply hh.trans |
| rw [shannon,←Finset.sum_neg_distrib,Finset.mul_sum] |
| apply Finset.sum_le_sum |
| intro a _ |
| have hq1 : q a ≤ 1 := (Finset.single_le_sum (fun b _ => hq b) (Finset.mem_univ a)).trans_eq hqs |
| have hl : Real.log (q a) ≤ 0 := Real.log_nonpos (hq a) hq1 |
| have hh := mul_le_mul_of_nonpos_right (hdom a) hl |
| rw [Real.negMulLog] |
| nlinarith |
|
|
| variable {X A : Type*} [MeasurableSpace X] [MeasurableSpace A] |
| [Fintype A] [MeasurableSingletonClass A] |
| lemma obs_weighted_le (μ ν : Measure X) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] |
| {c : ℝ} (hc : 0 < c) (hdom : ∀ E : Set X,c*ν.real E ≤ μ.real E) |
| (p : X → A) (hp : Measurable p) : c*obs ν p ≤ obs μ p := |
| shannon_weighted_le (mass ν p) (mass μ p) (mass_nonneg _ _) (mass_nonneg _ _) |
| (by simpa only [measure_univ,ENNReal.toReal_one] using mass_sum ν p hp) |
| (by simpa only [measure_univ,ENNReal.toReal_one] using mass_sum μ p hp) hc (fun a => hdom _) |
|
|
| lemma rate_weighted_le (μ ν : Measure X) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] |
| {c : ℝ} (hc : 0 < c) (hdom : ∀ E : Set X,c*ν.real E ≤ μ.real E) |
| (f : X → X) (hμ : MeasurePreserving f μ μ) (hν : MeasurePreserving f ν ν) |
| (p : X → A) (hp : Measurable p) : c*rate ν f p ≤ rate μ f p := by |
| apply le_of_tendsto_of_tendsto |
| ((rate_tendsto ν f hν p hp).const_mul c) (rate_tendsto μ f hμ p hp) |
| apply Filter.Eventually.of_forall |
| intro n |
| have hh := div_le_div_of_nonneg_right |
| (obs_weighted_le μ ν hc hdom (word f p n) (word_measurable f hμ.measurable p hp n)) |
| (Nat.cast_nonneg n) |
| simpa only [mul_div_assoc] using hh |
| end StandardMapEntropy.Entropy |
|
|
| namespace StandardMapEntropy |
| open MeasureTheory Set Filter HyperbolicCoding |
| open scoped BigOperators ENNReal Topology |
| lemma area_weight_normalized (E : Set Torus) (hE : 0 < area E) (B : Set Torus) : |
| area.real E*(normalizedArea E).real B ≤ area.real B := by |
| have hc : area.real E≠0 := (ENNReal.toReal_pos hE.ne' (measure_ne_top area E)).ne' |
| have he : area.real E*(normalizedArea E).real B=(area.restrict E).real B := by |
| simp only [normalizedArea,Measure.real,Measure.smul_apply,smul_eq_mul, |
| ENNReal.toReal_mul,ENNReal.toReal_inv] |
| change area.real E*((area.real E)⁻¹*(area.restrict E).real B)=_ |
| rw [←mul_assoc,mul_inv_cancel₀ hc,one_mul] |
| rfl |
| rw [he] |
| exact ENNReal.toReal_mono (measure_ne_top area B) (Measure.restrict_le_self B) |
|
|
| lemma restricted_finite_rate_upper {A : Type*} [MeasurableSpace A] |
| [Fintype A] [MeasurableSingletonClass A] |
| (k : ℝ) (hk : 0 ≤ k) (n : ℕ) (E : Set Torus) (hE : 0 < area E) |
| (hinv : MeasurePreserving ((standardMap k)^[n]) (normalizedArea E) (normalizedArea E)) |
| (p : Torus → A) (hp : Measurable p) : |
| Entropy.rate (normalizedArea E) ((standardMap k)^[n]) p ≤ |
| (Real.log 1000+(∫ z,Real.log ‖standardDerivativeProduct k z n‖ ∂area))/(area.real E) := by |
| let := normalizedArea_probability hE |
| have hc : 0 < area.real E := ENNReal.toReal_pos hE.ne' (measure_ne_top area E) |
| have hweighted := Entropy.rate_weighted_le area (normalizedArea E) hc |
| (area_weight_normalized E hE) _ ((measurePreserving_standardMap k).iterate n) hinv p hp |
| have hu := (finite_rate_le_metricEntropy area _ ((measurePreserving_standardMap k).iterate n) p hp).trans |
| (metricEntropy_iterate_derivative_upper k hk n) |
| have hnonneg : 0 ≤ Real.log 1000+(∫ z,Real.log ‖standardDerivativeProduct k z n‖ ∂area) := by |
| apply add_nonneg (Real.log_nonneg (by norm_num)) |
| apply integral_nonneg |
| intro z |
| exact Real.log_nonneg (standardDerivativeProduct_norm_ge_one k z n) |
| have hh := (ENNReal.ofReal_le_ofReal_iff hnonneg).mp hu |
| apply (le_div_iff₀ hc).mpr |
| simpa only [mul_comm] using hweighted.trans hh |
| end StandardMapEntropy |
|
|
| end |
| section |
| namespace HyperbolicCoding |
| open MeasureTheory Set Filter StandardMapEntropy.Entropy |
| open scoped BigOperators ENNReal Topology |
| variable {X : Type*} [MeasurableSpace X] |
|
|
| theorem exists_finiteRateSupremum (μ : Measure X) (f : X → X) |
| (b : ℝ) (hb : ∀ r : ℕ,∀ p : X → Fin (r+1),Measurable p → rate μ f p ≤ b) : |
| ∃ h : ℝ,FiniteRateSupremum μ f h ∧ h ≤ b := by |
| let S : Set ℝ := {v | ∃ r : ℕ,∃ p : X → Fin (r+1),Measurable p ∧ v=rate μ f p} |
| have hne : S.Nonempty := ⟨rate μ f (fun _ => (0 : Fin 1)),0,fun _ => 0,measurable_const,rfl⟩ |
| have hbd : BddAbove S := ⟨b,by rintro v ⟨r,p,hp,rfl⟩; exact hb r p hp⟩ |
| refine ⟨sSup S,⟨?_,?_⟩,csSup_le hne (by rintro v ⟨r,p,hp,rfl⟩; exact hb r p hp)⟩ |
| · intro r p hp |
| exact le_csSup hbd ⟨r,p,hp,rfl⟩ |
| · intro ε hε |
| obtain ⟨v,hv,hlt⟩ := exists_lt_of_lt_csSup hne (show sSup S-ε < sSup S by linarith) |
| obtain ⟨r,p,hp,rfl⟩ := hv |
| exact ⟨r,p,hp,hlt⟩ |
| end HyperbolicCoding |
| end |
|
|
| end OAI |
|
|
