import OAI.Dynamics.StandardMap.EntropyEndpoint import OAI.Dynamics.StandardMap.Coding.FixedWindowCost namespace OAI section namespace HyperbolicCoding open MeasureTheory Set StandardMapEntropy.Entropy open scoped BigOperators ENNReal variable {X A B C : Type*} lemma blockWindow_word [MeasurableSpace X] [StandardBorelSpace X] [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] (e : X → X) (q : X → A) {k t R : ℕ} (x : X) (i : Fin (k-2*R)) : blockWindow (word e q (k+t) x) i=word e q (2*R+1) (e^[i.val] x) := by funext j simp only [blockWindow,word] rw [Nat.add_comm i.val j.val,Function.iterate_add_apply] lemma integrable_wordCost [MeasurableSpace X] [StandardBorelSpace X] [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] (μ : Measure X) [IsFiniteMeasure μ] (e : X → X) (he : Measurable e) (p : X → C) (q : X → A) (hp : Measurable p) (hq : Measurable q) (k n : ℕ) (c : (Fin k → C) → (Fin n → A) → ℝ) : Integrable (fun x => c (word e p k x) (word e q n x)) μ := integrable_finite_observation μ (fun x => (word e p k x,word e q n x)) ((word_measurable e he p hp k).prodMk (word_measurable e he q hq n)) (fun a => c a.1 a.2) lemma fixedWindowCost_scale [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] {k t R : ℕ} (hn : 0 Disjoint ((e^[i.val]) '' U) ((e^[j.val]) '' U))) (p : X → C) (q : X → A) (hp : Measurable p) (hq : Measurable q) (F : C → A) (H : C → B) (D : (Fin (2*R+1) → A) → B) : let I := ∫ x in U,fixedWindowCost F H D (word e p k x) (word e q (k+t) x) ∂μ (μ.real {x | F (p x)≠q x}≤μ.real (⋃ i : Fin (k+t),(e^[i.val]) '' U)ᶜ+ (t : ℝ)/(k+t : ℕ)+2*(k+t : ℕ)*I) ∧ (μ.real {x | H (p (e^[R] x))≠D (word e q (2*R+1) x)}≤ μ.real (⋃ i : Fin (k+t),(e^[i.val]) '' U)ᶜ+ ((t+2*R : ℕ) : ℝ)/(k+t : ℕ)+2*(k+t : ℕ)*I) := by intro I have hc := integrable_wordCost (μ.restrict U) e e.measurable p q hp hq k (k+t) (fixedWindowCost F H D) have hpref := integrable_wordCost (μ.restrict U) e e.measurable p q hp hq k (k+t) (prefixNameCost F) have hdec := integrable_wordCost (μ.restrict U) e e.measurable p q hp hq k (k+t) (decoderNameCost H D) have hscale : (∫ x in U,prefixNameCost F (word e p k x) (word e q (k+t) x) ∂μ)+ (∫ x in U,decoderNameCost H D (word e p k x) (word e q (k+t) x) ∂μ)=2*(k+t : ℕ)*I := by rw [←integral_add hpref hdec] change (∫ x in U,prefixNameCost F (word e p k x) (word e q (k+t) x)+decoderNameCost H D (word e p k x) (word e q (k+t) x) ∂μ)=_ simp_rw [←fixedWindowCost_scale hn F H D] exact integral_const_mul _ _ have hpre0 := integral_nonneg (f:=fun x => prefixNameCost F (word e p k x) (word e q (k+t) x)) (fun x => prefixNameCost_nonneg F (word e p k x) (word e q (k+t) x)) (μ:=μ.restrict U) have hdec0 := integral_nonneg (f:=fun x => decoderNameCost H D (word e p k x) (word e q (k+t) x)) (fun x => decoderNameCost_nonneg H D (word e p k x) (word e q (k+t) x)) (μ:=μ.restrict U) constructor · have hb := tower_error_integral μ e he hU k (F ∘ p) q ((measurable_of_countable F).comp hp) hq have hc := tower_interior_compl_bound μ e he hU hn (show t≤k+t by omega) hd have hsub : k+t-t=k := by omega rw [hsub] at hc change μ.real {x | F (p x)≠q x}≤μ.real (⋃ i : Fin k,(e^[i.val]) '' U)ᶜ+ ∫ x in U,prefixNameCost F (word e p k x) (word e q (k+t) x) ∂μ at hb linarith · have hH : Measurable (fun x => H (p (e^[R] x))) := (measurable_of_countable H).comp (hp.comp (e.measurable.iterate _)) have hD : Measurable (fun x => D (word e q (2*R+1) x)) := (measurable_of_countable D).comp (word_measurable e e.measurable q hq _) have hb := tower_error_integral μ e he hU (k-2*R) _ _ hH hD have hc := tower_interior_compl_bound μ e he hU hn (show t+2*R≤k+t by omega) hd have hsub : k+t-(t+2*R)=k-2*R := by omega rw [hsub] at hc have heq (x : X) : (∑ i : Fin (k-2*R),symbolCost (H (p (e^[R] (e^[i.val] x)))) (D (word e q (2*R+1) (e^[i.val] x))))=decoderNameCost H D (word e p k x) (word e q (k+t) x) := by unfold decoderNameCost apply Finset.sum_congr rfl intro i _ rw [blockWindow_word] dsimp only [blockCenter,word] rw [Nat.add_comm i.val R,Function.iterate_add_apply] simp only [heq] at hb linarith end HyperbolicCoding end section namespace HyperbolicCoding open MeasureTheory Set Filter StandardMapEntropy.Entropy open scoped BigOperators ENNReal Topology variable {X A B C : Type*} [MeasurableSpace X] [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X] [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [MeasurableSpace C] [Fintype C] [DecidableEq C] [MeasurableSingletonClass C] [Nonempty C] theorem actual_fixed_window_copy (μ : Measure X) [IsProbabilityMeasure μ] [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) (p : X → C) (hp : Measurable p) (F : C → A) (H : C → B) (R : ℕ) (D : (Fin (2*R+1) → A) → B) (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) (hβentropy : 0 < weightEntropy β) (hrate : rate μ e p≤weightEntropy β) (zero one : A) (h01 : zero≠one) (l : ℕ) {ε : ℝ} (hε : 0 < ε) : ∃ K r m : ℕ,0 < K ∧ 0 < r ∧ 0 < m ∧ ∀ᶠ n : ℕ in atTop, 0 < n ∧ ∀ W : MatrixCoupling (mass μ (word e p (n*K*m))) (productWordWeight β (n*K*m+n*m)), ∃ (q : X → A) (s : ℤ) (M : ℕ) (G : (Fin M → A) → C),Measurable q ∧ μ.real {x | F (p x)≠q x} < 2*W.cost (fixedWindowCost F H D)+ε ∧ μ.real {x | H (p (e^[R] x))≠D (word e q (2*R+1) x)} < 2*W.cost (fixedWindowCost F H D)+ε ∧ LawClose (μ.map (word e q l)) (Measure.pi (fun _ : Fin l => finiteWeightLaw β)) ε ∧ μ.real {x | G (word e q M (integerIterate e s x))≠p x} < ε := by have hR0 : (0 : ℝ)≤R := Nat.cast_nonneg R have hl0 : (0 : ℝ)≤l := Nat.cast_nonneg l let θ := ε/(100*((R : ℝ)+(l : ℝ)+3)) have hθ : 0 < θ := by dsimp [θ]; positivity have hθeq : 100*((R : ℝ)+(l : ℝ)+3)*θ=ε := by dsimp [θ]; field_simp have hθ0 : 0≤θ := hθ.le obtain ⟨K,r,m,hK,hr,hm,hcopy⟩ := synchronized_cost_producer μ e he.toMeasurePreserving htotal p hp β hβ hβsum hβentropy hrate zero one hθ obtain ⟨Z,hZ⟩ := exists_nat_gt (max ((2*R : ℕ) : ℝ) (max (l : ℝ) (100*((l : ℝ)+2*R)/ε))+1) refine ⟨K,r,m,hK,hr,hm,?_⟩ filter_upwards [hcopy,eventually_ge_atTop Z] with n hn hnZ obtain ⟨hnpos,hrN,htail,hres,hc⟩ := hn have hN : 0 < n*K*m+n*m := lt_trans hr hrN have hNreal : (0 : ℝ) < (n*K*m+n*m : ℕ) := Nat.cast_pos.mpr hN have hnK : n≤n*K*m := (Nat.le_mul_of_pos_right n hK).trans (Nat.le_mul_of_pos_right (n*K) hm) have hnN : n≤n*K*m+n*m := hnK.trans (Nat.le_add_right _ _) have hZN : (Z : ℝ)≤(n*K*m+n*m : ℕ) := by exact_mod_cast hnZ.trans hnN have hZK : (Z : ℝ)≤(n*K*m : ℕ) := by exact_mod_cast hnZ.trans hnK have hRk : 2*R≤n*K*m := by have hh : ((2*R : ℕ) : ℝ) < (n*K*m : ℕ) := lt_of_le_of_lt (le_max_left _ _) ((lt_trans (lt_add_one _) hZ).trans_le hZK) exact_mod_cast hh.le have hlN : l < n*K*m+n*m := by have hh : (l : ℝ) < (n*K*m+n*m : ℕ) := lt_of_le_of_lt ((le_max_left _ _).trans (le_max_right _ _)) ((lt_trans (lt_add_one _) hZ).trans_le hZN) exact_mod_cast hh have hfrac : ((l : ℝ)+2*R)/(n*K*m+n*m : ℕ) < ε/100 := by apply (div_lt_iff₀ hNreal).mpr have hh : 100*((l : ℝ)+2*R)/ε < (n*K*m+n*m : ℕ) := lt_of_le_of_lt ((le_max_right _ _).trans (le_max_right _ _)) ((lt_trans (lt_add_one _) hZ).trans_le hZN) have hh' := (div_lt_iff₀ hε).mp hh nlinarith have hfracL : (l : ℝ)/(n*K*m+n*m : ℕ) < ε/100 := lt_of_le_of_lt (div_le_div_of_nonneg_right (by linarith only [hR0,hl0]) hNreal.le) hfrac have hfracR : (2*(R : ℝ))/(n*K*m+n*m : ℕ) < ε/100 := lt_of_le_of_lt (div_le_div_of_nonneg_right (by linarith only [hR0,hl0]) hNreal.le) hfrac refine ⟨hnpos,?_⟩ intro W obtain ⟨E,V,hE,hV⟩ := hc W (fixedWindowCost F H D) (fixedWindowCost_nonneg F H D) (fixedWindowCost_le_one hN F H D) (((2*R+2 : ℕ) : ℝ)*(Marker.reserved (n*K*m+n*m) r).card/(2*(n*K*m+n*m : ℕ))) (fun a b => fixedWindowCost_markWord F H D a b r zero one) have hmarkbudget : ((2*R+2 : ℕ) : ℝ)*(Marker.reserved (n*K*m+n*m) r).card/(2*(n*K*m+n*m : ℕ))≤((R : ℝ)+1)*θ := by have hh := mul_le_mul_of_nonneg_left hres.le (by positivity : (0 : ℝ)≤(R : ℝ)+1) have heq : ((2*R+2 : ℕ) : ℝ)*(Marker.reserved (n*K*m+n*m) r).card/(2*(n*K*m+n*m : ℕ))= ((R : ℝ)+1)*((Marker.reserved (n*K*m+n*m) r).card/(n*K*m+n*m : ℕ)) := by have h2 : ((2*R+2 : ℕ) : ℝ)=2*((R : ℝ)+1) := by push_cast; ring rw [h2] field_simp rwa [heq] have hVcost : V.cost (fixedWindowCost F H D) < W.cost (fixedWindowCost F H D)+((R : ℝ)+2)*θ := by linarith only [hV,hmarkbudget] obtain ⟨U,q,hU,hUp,hq,hd,hcover,hbase,hcost,_hoff,hdecode⟩ := lift_cost_transport μ e he hN hrN p hp F _ V (fixedWindowCost F H D) (fixedWindowCost_nonneg F H D) (fixedWindowCost_le_one hN F H D) zero one h01 (marked_pushWeight_support _ hr hrN zero one) E (Classical.arbitrary C) hθ let I := ∫ x in U,fixedWindowCost F H D (word e p (n*K*m) x) (word e q (n*K*m+n*m) x) ∂μ have hI : 2*(n*K*m+n*m : ℕ)*I≤2*(V.cost (fixedWindowCost F H D)+θ) := by have hmass := tower_real_mass_le_one μ e he.toMeasurePreserving hU (n*K*m+n*m) hd have hc0 := V.cost_nonneg (fixedWindowCost F H D) (fixedWindowCost_nonneg F H D) have hh := mul_le_mul_of_nonneg_right hmass (show 0≤V.cost (fixedWindowCost F H D)+θ by linarith) have hh' := mul_le_mul_of_nonneg_left hcost hNreal.le dsimp [I] nlinarith only [hh,hh'] obtain ⟨hpaint,hfixed⟩ := fixed_window_tower_bounds μ e he.toMeasurePreserving hU hN hRk hd p q hp hq F H D let G := Marker.decodeWindow hN hrN zero one (extendPrefixDecoder E (Classical.arbitrary C)) let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum let ν := Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β) have hmap : ∀ w,mass (μ.restrict U) (word e q (n*K*m+n*m)) w= μ.real U*pushWeight (mass ν (word iidShift (fun z : ℤ → A => z 0) (n*K*m+n*m))) (Marker.markWord r zero one) w := by intro w simpa only [ν,funext (iid_word_mass β hβ hβsum (n*K*m+n*m))] using hbase w have hLaw := marked_tower_short_word_lawClose μ ν e he.toMeasurePreserving iidShift (iidShift_preserving _) hU hUp q (fun z : ℤ → A => z 0) hq (measurable_pi_apply 0) hlN hd zero one hmap hcover have hLaw' : LawClose (μ.map (word e q l)) (Measure.pi (fun _ : Fin l => finiteWeightLaw β)) (θ+(l : ℝ)/(n*K*m+n*m : ℕ)+(l : ℝ)*(Marker.reserved (n*K*m+n*m) r).card/(n*K*m+n*m : ℕ)) := by simpa only [ν,iid_word_law] using hLaw refine ⟨q,-((n*K*m+n*m : ℕ) : ℤ),2*(n*K*m+n*m),G,hq,?_,?_,?_,?_⟩ · change _≤_+_+2*(n*K*m+n*m : ℕ)*I at hpaint nlinarith only [hpaint,hcover,htail,hI,hVcost,hθeq,hθ,hR0,hl0] · have hsplit : ((n*m+2*R : ℕ) : ℝ)/(n*K*m+n*m : ℕ)= ((n*m : ℕ) : ℝ)/(n*K*m+n*m : ℕ)+2*(R : ℝ)/(n*K*m+n*m : ℕ) := by push_cast; ring rw [hsplit] at hfixed change _≤_+_+2*(n*K*m+n*m : ℕ)*I at hfixed nlinarith only [hfixed,hcover,htail,hI,hVcost,hfracR,hθeq,hθ,hR0,hl0] · apply hLaw'.mono have hres' := mul_le_mul_of_nonneg_left hres.le (Nat.cast_nonneg l) rw [←mul_div_assoc] at hres' nlinarith only [hres',hfracL,hθeq,hθ,hR0,hl0] · change μ.real {x | Marker.decodeWindow _ _ zero one _ (word e q (2*(n*K*m+n*m)) (integerIterate e (-((n*K*m+n*m : ℕ) : ℤ)) x))≠p x} < ε nlinarith only [hdecode,hE,htail,hθeq,hθ,hR0,hl0] end HyperbolicCoding end section namespace HyperbolicCoding open MeasureTheory Set Filter StandardMapEntropy.Entropy open scoped BigOperators ENNReal Topology variable {X A B C : Type*} [MeasurableSpace X] [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X] [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [MeasurableSpace C] [Fintype C] [DecidableEq C] [MeasurableSingletonClass C] [Nonempty C] theorem actual_fixed_window_rate_copy (μ : Measure X) [IsProbabilityMeasure μ] [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) (p : X → C) (hp : Measurable p) (F : C → A) (H : C → B) (R : ℕ) (D : (Fin (2*R+1) → A) → B) (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) (hβentropy : 0 < weightEntropy β) (hrate : rate μ e p≤weightEntropy β) (zero one : A) (h01 : zero≠one) (l : ℕ) {ε ρ : ℝ} (hε : 0 < ε) (hρ : 0 < ρ) : ∃ K r m : ℕ,0 < K ∧ 0 < r ∧ 0 < m ∧ ∀ᶠ n : ℕ in atTop, 0 < n ∧ ∀ W : MatrixCoupling (mass μ (word e p (n*K*m))) (productWordWeight β (n*K*m+n*m)), ∃ q : X → A,Measurable q ∧ μ.real {x | F (p x)≠q x} < 2*W.cost (fixedWindowCost F H D)+ε ∧ μ.real {x | H (p (e^[R] x))≠D (word e q (2*R+1) x)} < 2*W.cost (fixedWindowCost F H D)+ε ∧ LawClose (μ.map (word e q l)) (Measure.pi (fun _ : Fin l => finiteWeightLaw β)) ε ∧ rate μ e p-ρ < rate μ e q := by obtain ⟨η,hη,hsmall⟩ := rate_lower_of_small_window_error (B:=A) μ e he.toMeasurePreserving p hp hρ obtain ⟨K,r,m,hK,hr,hm,hn⟩ := actual_fixed_window_copy μ e he htotal p hp F H R D β hβ hβsum hβentropy hrate zero one h01 l (lt_min hε hη) refine ⟨K,r,m,hK,hr,hm,?_⟩ filter_upwards [hn] with n hn refine ⟨hn.1,?_⟩ intro W obtain ⟨q,s,M,G,hq,hpaint,hfixed,hlaw,hdecode⟩ := hn.2 W have heq : mass μ (errorObs p (G ∘ word e q M ∘ integerIterate e s)) true= μ.real {x | G (word e q M (integerIterate e s x))≠p x} := by simp only [mass,Measure.real] congr 2 ext x simp only [mem_preimage,mem_singleton_iff,errorObs,decide_eq_true_eq, mem_ofPred_eq,Function.comp_apply] exact ne_comm refine ⟨q,hq,lt_of_lt_of_le hpaint (add_le_add_right (min_le_left _ _) _), lt_of_lt_of_le hfixed (add_le_add_right (min_le_left _ _) _),hlaw.mono (min_le_left _ _),?_⟩ apply hsmall q hq s M G rw [heq] exact hdecode.trans_le (min_le_right _ _) end HyperbolicCoding end section namespace HyperbolicCoding open MeasureTheory Set Filter StandardMapEntropy.Entropy open scoped BigOperators ENNReal Topology variable {X A B : Type*} [MeasurableSpace X] [StandardBorelSpace X] [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X] [MeasurableSpace A] [Fintype A] [DecidableEq A] [MeasurableSingletonClass A] [Nonempty A] [TopologicalSpace A] [DiscreteTopology A] [BorelSpace A] [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] [Nonempty B] theorem fixed_decoder_arbitrary_tests (μ : Measure X) [IsProbabilityMeasure μ] [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ) (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ) (p : X → A) (hp : Measurable p) (β : A → ℝ) (hβ : ∀ a,0≤β a) (hβsum : ∑ a,β a=1) (hβentropy : 0 < weightEntropy β) (H : FiniteRateSupremum μ e (weightEntropy β)) (hcode : MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β))) (α : X → B) (hα : Measurable α) (happrox : ∀ ε : ℝ,0 < ε → ∃ r : X → A×B,Measurable r ∧ WeakBernoulliProcess μ e r ∧ μ.real {x | (p x,α x)≠r x} < ε) (zero one : A) (h01 : zero≠one) {η : ℝ} (hη : 0 < η) : ∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → B, ∀ l : ℕ,∀ ε ρ : ℝ,0 < ε → 0 < ρ → ∃ q : X → A,Measurable q ∧ μ.real {x | p x≠q x} < η ∧ μ.real {x | α (e^[R] x)≠D (word e q (2*R+1) x)} < η ∧ LawClose (μ.map (word e q l)) (Measure.pi (fun _ : Fin l => finiteWeightLaw β)) ε ∧ weightEntropy β-ρ < rate μ e q := by classical obtain ⟨R,D,s,hs,hfd⟩ := fixed_window_fd_graph μ e he p hp β hβ hβsum hβentropy H hcode α hα happrox (by positivity : 0 < η/8) let P : X → A×B := fun x => (p x,α x) have hP : Measurable P := hp.prodMk hα have hrateP : rate μ e P=weightEntropy β := by apply le_antisymm (H.upper P hP) rw [←rate_of_iid_factor μ e he.toMeasurePreserving p hp β hβ hβsum hcode] exact rate_pair_ge_left μ e he.toMeasurePreserving p α hp hα refine ⟨R,D,?_⟩ intro l ε ρ hε hρ obtain ⟨K,r,m,hK,_hr,hm,hcopy⟩ := actual_fixed_window_rate_copy μ e he htotal P hP Prod.fst Prod.snd R D β hβ hβsum hβentropy (H.upper P hP) zero one h01 l (lt_min hε (half_pos hη)) hρ have htend : Tendsto (fun n : ℕ => n*s) atTop atTop := by apply tendsto_atTop.2 intro b filter_upwards [eventually_ge_atTop b] with n hn exact hn.trans (Nat.le_mul_of_pos_right n hs) obtain ⟨n,hn⟩ := (htend.eventually hcopy).exists have hN : 0 < n*s*K*m+n*s*m := add_pos (Nat.mul_pos (Nat.mul_pos hn.1 hK) hm) (Nat.mul_pos hn.1 hm) have hlen : (n*K*m+n*m)*s=n*s*K*m+n*s*m := by ring have hST := hfd (n*K*m+n*m) rw [hlen] at hST obtain ⟨S,hS⟩ := hST let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum let ν := Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β) have hRT := lift_joint_graph_transport (k:=n*s*K*m) (t:=n*s*m) μ e e.measurable P hP ν D S have hiid : mass ν (word iidShift (fun y : ℤ → A => y 0) (n*s*K*m+n*s*m))= productWordWeight β (n*s*K*m+n*s*m) := funext (iid_word_mass β hβ hβsum _) rw [hiid] at hRT obtain ⟨T,hT⟩ := hRT have hcost : T.cost (fixedWindowCost Prod.fst Prod.snd D)≤η/8 := hT.trans ((div_le_iff₀ (Nat.cast_pos.mpr hN)).mpr hS) obtain ⟨q,hq,hpaint,hfixed,hlaw,hrate⟩ := hn.2 T refine ⟨q,hq,?_,?_,hlaw.mono (min_le_left _ _),?_⟩ · change μ.real {x | p x≠q x} < _ at hpaint linarith only [hpaint,hcost,min_le_right ε (η/2),hη] · change μ.real {x | α (e^[R] x)≠D (word e q (2*R+1) x)} < _ at hfixed linarith only [hfixed,hcost,min_le_right ε (η/2),hη] · rwa [hrateP] at hrate end HyperbolicCoding end section namespace HyperbolicCoding open MeasureTheory Set Filter StandardMapEntropy.Entropy open scoped BigOperators ENNReal Topology variable {X A B : Type*} [MeasurableSpace X] [MeasurableSpace B] lemma disagreement_triangle [MeasurableSpace A] (μ : Measure X) [IsFiniteMeasure μ] (p q r : X → A) : μ.real {x | p x≠r x}≤μ.real {x | p x≠q x}+μ.real {x | q x≠r x} := by apply (measureReal_mono (μ:=μ) (show {x | p x≠r x}⊆{x | p x≠q x} ∪ {x | q x≠r x} from ?_)).trans · exact measureReal_union_le _ _ · intro x hx by_cases h : p x=q x · exact Or.inr (by simpa only [mem_ofPred_eq,h] using hx) · exact Or.inl h lemma disagreement_symm [MeasurableSpace A] (μ : Measure X) (p q : X → A) : μ.real {x | p x≠q x}=μ.real {x | q x≠p x} := by congr 1 ext x exact ne_comm variable [MeasurableSpace A] lemma sequence_distance_le_sum (μ : Measure X) [IsFiniteMeasure μ] (q : ℕ → X → A) (η : ℕ → ℝ) (hη : ∀ n,μ.real {x | q n x≠q (n+1) x}≤η n) (n : ℕ) : μ.real {x | q 0 x≠q n x}≤∑ j∈Finset.range n,η j := by induction n with | zero => simp | succ n ih => rw [Finset.sum_range_succ] exact (disagreement_triangle μ (q 0) (q n) (q (n+1))).trans (add_le_add ih (hη n)) lemma partition_limit_distance_bound [MeasurableEq A] (μ : Measure X) [IsFiniteMeasure μ] (q : ℕ → X → A) (p r : X → A) (hq : ∀ n,Measurable (q n)) (hp : Measurable p) (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x) {δ : ℝ} (hδ : ∀ n,μ.real {x | r x≠q n x}≤δ) : μ.real {x | r x≠p x}≤δ := by have hz := measureReal_tendsto_zero_of_ae_eventually_notMem μ (fun n => {x | q n x≠p x}) (fun n => (measurableSet_eq_fun (hq n) hp).compl) (hlim.mono (fun x hx => hx.mono (fun n hn => by simpa using hn))) have ht : Tendsto (fun n => μ.real {x | r x≠p x}-μ.real {x | q n x≠p x}) atTop (𝓝 (μ.real {x | r x≠p x})) := by simpa using tendsto_const_nhds.sub hz apply le_of_tendsto ht filter_upwards [] with n have h := disagreement_triangle μ r (q n) p linarith [hδ n] lemma finite_decoder_perturbation [StandardBorelSpace X] [Fintype A] [Nonempty A] [MeasurableSingletonClass A] (μ : Measure X) [IsFiniteMeasure μ] (e : X → X) (he : MeasurePreserving e μ μ) (p q : X → A) (hp : Measurable p) (hq : Measurable q) (α : X → B) (n : ℕ) (D : (Fin n → A) → B) : μ.real {x | α x≠D (word e q n x)}≤μ.real {x | α x≠D (word e p n x)}+ (n : ℝ)*μ.real {x | p x≠q x} := by classical apply (disagreement_triangle μ α (D ∘ word e p n) (D ∘ word e q n)).trans apply add_le_add_right have hsub : {x | (D ∘ word e p n) x≠(D ∘ word e q n) x}⊆{x | word e p n x≠word e q n x} := by intro x h heq exact h (congrArg D heq) exact (measureReal_mono (μ:=μ) hsub).trans (word_disagreement_le μ e he p q hp hq n) end HyperbolicCoding end section namespace HyperbolicCoding open MeasureTheory Set Filter StandardMapEntropy.Entropy open scoped BigOperators ENNReal NNReal 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] theorem seeded_exact_iid_limit (μ : 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 < ε) : ∃ L : ℕ,∃ δ : ℝ,0 < δ ∧ ∀ q₀ : X → A,Measurable q₀ → LawClose (μ.map (word e q₀ L)) (Measure.pi (fun _ : Fin L => finiteWeightLaw β)) δ → weightEntropy β-δ≤rate μ e q₀ → ∃ p : X → A,Measurable p ∧ MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) ∧ μ.real {x | q₀ x≠p x} < ε := by let θ : ℝ := min (ε/4) (1/4) have hθ : 0 < θ := lt_min (by positivity) (by norm_num) have hθε : 2*θ < ε := by have hh := min_le_left (ε/4) (1/4 : ℝ); dsimp [θ]; linarith have hθ1 : θ≤1 := (min_le_right _ _).trans (by norm_num) let η : ℕ → ℝ := fun n => θ*(1/2 : ℝ)^n have hη (n : ℕ) : 0 < η n := by dsimp [η]; positivity 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) refine ⟨max (T 0).length 0,min (T 0).tolerance 1,lt_min (T 0).tolerance_pos zero_lt_one,?_⟩ intro q₀ hq₀ hl₀ hr₀ have hg₀ : GoodIIDStage μ e β (T 0) 0 q₀ := by refine ⟨hq₀,?_,hr₀.trans' ?_⟩ · simpa only [Nat.cast_zero,zero_add,div_one] using hl₀ · linarith only [min_le_left (T 0).tolerance (1 : ℝ)] 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₀,hg₀⟩ next n let q : ℕ → X → A := fun n => (z n).val have hq (n : ℕ) : Measurable (q n) := (z n).property.1 have hpaint (n : ℕ) : μ.real {x | q n x≠q (n+1) x} < η n := (Classical.choose_spec (hnext n (z n))).2 have hgeom (n : ℕ) : μ.real {x | q (n+1) x≠q n x} < ((1/2 : ℝ≥0)^n : ℝ) := by rw [disagreement_symm] apply (hpaint n).trans_le change θ*(1/2 : ℝ)^n≤_ simpa only [NNReal.coe_pow,NNReal.coe_div,NNReal.coe_one,NNReal.coe_ofNat,one_mul] using mul_le_mul_of_nonneg_right hθ1 (by positivity : 0≤(1/2 : ℝ)^n) obtain ⟨p,hp,hlim⟩ := exists_partition_limit μ q hq (geometric_repainting_summable μ q hgeom) have hlaw (n : ℕ) : LawClose (μ.map (word e (q n) n)) (Measure.pi (fun _ : Fin n => finiteWeightLaw β)) (1/(n+1 : ℝ)) := (iid_lawClose_prefix μ e (q n) (hq n) β hβ hβsum (le_max_right _ _) (z n).property.2.1).mono (min_le_right _ _) let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum 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 refine ⟨p,hp,hcode,lt_of_le_of_lt ?_ hθε⟩ apply partition_limit_distance_bound μ q p q₀ hq hp hlim intro n have hh := sequence_distance_le_sum μ q η (fun j => (hpaint j).le) n have hsum : (∑ j∈Finset.range n,η j)≤2*θ := by simp only [η,←Finset.mul_sum] have h := mul_le_mul_of_nonneg_left (sum_geometric_two_le n) hθ.le nlinarith only [h] exact hh.trans hsum end HyperbolicCoding end end OAI