lean/OAI/Dynamics/StandardMap/Coding/PartitionLimit.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Bernoulli.IntegerDynamics

namespace OAI

section
section
namespace HyperbolicCoding
open MeasureTheory MeasureTheory.Measure Set Filter
open scoped ENNReal Topology
variable {X A : Type*} [MeasurableSpace X]

theorem exists_partition_limit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A]
    (μ : Measure X) (q : ℕ → X → A) (hq : ∀ n,Measurable (q n))
    (hs : (∑' n : ℕ,μ {x | q (n+1) x≠q n x})≠⊤) :
    ∃ p : X → A,Measurable p ∧ ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x := by
  obtain ⟨p,hp,hlim⟩ := exists_eventual_decoder q hq
  have hh := ae_eventually_notMem hs
  refine ⟨p,hp,?_⟩
  filter_upwards [hh] with x hx
  obtain ⟨N,hN⟩ := eventually_atTop.mp hx
  have hconst : ∀ n,N≤n → q n x=q N x := by
    intro n hn
    induction n,hn using Nat.le_induction with
    | base => rfl
    | succ n hn ih => exact (not_ne_iff.mp (hN n hn)).trans ih
  have hc : ∀ᶠ n : ℕ in atTop,q n x=q N x := eventually_atTop.mpr ⟨N,hconst⟩
  rwa [hlim x (q N x) hc]

lemma measureReal_tendsto_zero_of_ae_eventually_notMem (μ : Measure X) [IsFiniteMeasure μ]
    (D : ℕ → Set X) (hD : ∀ n,MeasurableSet (D n))
    (ha : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,x∉D n) :
    Tendsto (fun n => μ.real (D n)) atTop (𝓝 0) := by
  let U (n : ℕ) : Set X := ⋃ j : ℕ,⋃ (_ : n≤j),D j
  have hU (n : ℕ) : MeasurableSet (U n) :=
    MeasurableSet.iUnion (fun j => MeasurableSet.iUnion (fun _ => hD j))
  have hanti : Antitone U := by
    intro n m hnm x hx
    obtain ⟨j,hx⟩ := mem_iUnion.mp hx
    obtain ⟨hj,hx⟩ := mem_iUnion.mp hx
    exact mem_iUnion.mpr ⟨j,mem_iUnion.mpr ⟨hnm.trans hj,hx⟩⟩
  have hi : μ (⋂ n,U n)=0 := by
    apply measure_eq_zero_iff_ae_notMem.mpr
    filter_upwards [ha] with x hx hmem
    obtain ⟨N,hN⟩ := eventually_atTop.mp hx
    obtain ⟨j,hmem⟩ := mem_iUnion.mp (mem_iInter.mp hmem N)
    obtain ⟨hj,hmem⟩ := mem_iUnion.mp hmem
    exact hN j hj hmem
  have ht := tendsto_measure_iInter_atTop (μ := μ) (fun n => (hU n).nullMeasurableSet)
    hanti ⟨0,measure_ne_top μ _⟩
  rw [hi] at ht
  have htr := (ENNReal.tendsto_toReal (by simp : (0 : ℝ≥0∞)≠⊤)).comp ht
  simp only [Function.comp_def,ENNReal.toReal_zero] at htr
  apply squeeze_zero (fun _ => measureReal_nonneg) (fun n => ?_) htr
  exact measureReal_mono (μ := μ) (fun x hx => mem_iUnion.mpr ⟨n,mem_iUnion.mpr ⟨le_rfl,hx⟩⟩) (measure_ne_top μ _)

lemma partition_limit_integer_names [MeasurableSpace A] {μ : Measure X} (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    {q : ℕ → X → A} {p : X → A}
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x) :
    ∀ᵐ x ∂μ,∀ s : Finset ℤ,∀ᶠ n : ℕ in atTop,∀ i∈s,
      orbitName e (q n) x i=orbitName e p x i := by
  have hh : ∀ i : ℤ,∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,
      q n (integerIterate e i x)=p (integerIterate e i x) :=
    fun i => (integerIterate_measurePreserving e he i).quasiMeasurePreserving.ae hlim
  filter_upwards [ae_all_iff.mpr hh] with x hx s
  have hall : ∀ᶠ n : ℕ in atTop,∀ i : s,
      q n (integerIterate e i x)=p (integerIterate e i x) :=
    Filter.eventually_all.2 (fun i => hx i)
  exact hall.mono (fun n hn i hi => hn ⟨i,hi⟩)

end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory MeasureTheory.Measure Set Filter
open scoped ENNReal Topology
variable {X A : Type*} [MeasurableSpace X] [MeasurableSpace A] [Fintype A]

lemma finite_code_error_tendsto_zero {μ : Measure X} [IsFiniteMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    [MeasurableEq A] {q : ℕ → X → A} {p : X → A}
    (hq : ∀ n,Measurable (q n)) (hp : Measurable p)
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x) (s : Finset ℤ) :
    Tendsto (fun n => μ.real {x | s.restrict (orbitName e (q n) x)≠s.restrict (orbitName e p x)})
      atTop (𝓝 0) := by
  apply measureReal_tendsto_zero_of_ae_eventually_notMem μ
  · intro n
    exact (measurableSet_eq_fun ((measurable_restrict (s : Set ℤ)).comp (measurable_orbitName e (hq n)))
      ((measurable_restrict (s : Set ℤ)).comp (measurable_orbitName e hp))).compl
  · filter_upwards [partition_limit_integer_names e he hlim] with x hx
    filter_upwards [hx s] with n hn
    simp only [not_ne_iff]
    funext i
    exact hn i i.property

lemma finite_box_law_tendsto {μ : Measure X} [IsFiniteMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    [MeasurableEq A] {q : ℕ → X → A} {p : X → A}
    (hq : ∀ n,Measurable (q n)) (hp : Measurable p)
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x)
    (s : Finset ℤ) (t : ℤ → Set A) (ht : ∀ i,MeasurableSet (t i)) :
    Tendsto (fun n => (μ.map (orbitName e (q n))).real (Set.pi s t)) atTop
      (𝓝 ((μ.map (orbitName e p)).real (Set.pi s t))) := by
  let D : Set (s → A) := Set.pi Set.univ (fun i => t i)
  have hD : MeasurableSet D := MeasurableSet.univ_pi (fun i => ht i)
  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 hdist (n : ℕ) :
      |(μ.map (orbitName e (q n))).real (Set.pi s t)-
       (μ.map (orbitName e p)).real (Set.pi s t)|≤
        μ.real {x | s.restrict (orbitName e (q n) x)≠s.restrict (orbitName e p x)} := by
    have hd := law_distance_le_disagreement μ
      ((measurable_restrict (s : Set ℤ)).comp (measurable_orbitName e (hq n)))
      ((measurable_restrict (s : Set ℤ)).comp (measurable_orbitName e hp)) hD
    have hr : Measurable (s.restrict : (ℤ → A) → (s → A)) := measurable_restrict (s : Set ℤ)
    have hmap (u : X → A) (hu : Measurable u) :
        (μ.map (s.restrict ∘ orbitName e u)).real D=
          (μ.map (orbitName e u)).real (Set.pi s t) := by
      simp only [Measure.real]
      rw [←Measure.map_map hr (measurable_orbitName e hu),Measure.map_apply hr hD,hpre]
    change |(μ.map (s.restrict ∘ orbitName e (q n))).real D-
      (μ.map (s.restrict ∘ orbitName e p)).real D|≤_ at hd
    rw [hmap (q n) (hq n),hmap p hp] at hd
    exact hd
  have hz := squeeze_zero (fun n => abs_nonneg _ ) hdist
    (finite_code_error_tendsto_zero e he hq hp hlim s)
  exact tendsto_iff_dist_tendsto_zero.mpr (by simpa only [Real.dist_eq] using hz)

theorem iid_law_of_partition_limit {μ : Measure X} [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    [MeasurableEq A] {q : ℕ → X → A} {p : X → A}
    (hq : ∀ n,Measurable (q n)) (hp : Measurable p)
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x)
    (β : Measure A) [IsProbabilityMeasure β]
    (hblock : ∀ (s : Finset ℤ) (t : ℤ → Set A),(∀ i,MeasurableSet (t i)) →
      Tendsto (fun n => (μ.map (orbitName e (q n))).real (Set.pi s t)) atTop
        (𝓝 ((∏ i∈s,β (t i)).toReal))) :
    MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => β)) := by
  refine ⟨measurable_orbitName e hp,Measure.eq_infinitePi _ ?_⟩
  intro s t ht
  have h := tendsto_nhds_unique (finite_box_law_tendsto e he hq hp hlim s t ht) (hblock s t ht)
  have hf : (∏ i∈s,β (t i))≠⊤ := by
    rw [←Measure.infinitePi_pi (fun _ : ℤ => β) (fun i _ => ht i)]
    exact measure_ne_top _ _
  exact (ENNReal.toReal_eq_toReal_iff' (measure_ne_top _ _) hf).mp h

end HyperbolicCoding

end
section
open MeasureTheory Set Filter

namespace HyperbolicCoding
variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [MeasurableSpace.CountablySeparated Y] [MeasurableEq Y]

theorem measurable_decoder_of_ae_point_separation [StandardBorelSpace X] (μ : Measure X) [IsProbabilityMeasure μ]
    (f : X → Y) (hf : Measurable f)
    (hsep : ∀ᵐ x ∂μ,∀ y,f y=f x → y=x) :
    ∃ d : Y → X,MeasurePreserving d (μ.map f) μ ∧
      (∀ᵐ x ∂μ,d (f x)=x) ∧ (∀ᵐ y ∂μ.map f,f (d y)=y) := by
  obtain ⟨S,hSae,hSm,hS⟩ := IsMeasurablyGenerated.exists_measurable_subset hsep
  let _ : StandardBorelSpace S := hSm.standardBorel
  have hAE : ∀ᵐ x ∂μ,x∈S := hSae
  let _ : Nonempty S := by obtain ⟨x,hx⟩ := hAE.exists; exact ⟨⟨x,hx⟩⟩
  let r : S → Y := fun x => f x
  have hr : MeasurableEmbedding r := (hf.comp measurable_subtype_coe).measurableEmbedding (by
    intro x y h
    exact Subtype.ext ((hS y.property) x h))
  let d : Y → X := fun y => (hr.invFun y).val
  have hd : Measurable d := measurable_subtype_coe.comp hr.measurable_invFun
  have hl : ∀ᵐ x ∂μ,d (f x)=x := by
    filter_upwards [hSae] with x hx
    exact congrArg Subtype.val (hr.leftInverse_invFun ⟨x,hx⟩)
  have hmp : MeasurePreserving d (μ.map f) μ := by
    refine ⟨hd,?_⟩
    rw [Measure.map_map hd hf]
    have hm : d ∘ f =ᵐ[μ] id := hl
    exact (Measure.map_congr hm).trans (Measure.map_id)
  refine ⟨d,hmp,hl,?_⟩
  apply (ae_map_iff hf.aemeasurable (measurableSet_eq_fun (hf.comp hd) measurable_id)).mpr
  filter_upwards [hl] with x hx
  exact congrArg f hx

theorem orbitName_shift_preserving [StandardBorelSpace X] {A : Type*} [MeasurableSpace A]
    (e : X ≃ᵐ X) {μ : Measure X} (he : MeasurePreserving e μ μ)
    (α : X → A) (hα : Measurable α) :
    MeasurePreserving (fun w : ℤ → A => fun i => w (i+1)) (μ.map (orbitName e α)) (μ.map (orbitName e α)) := by
  have hcode := measurable_orbitName e hα
  have hshift : Measurable (fun w : ℤ → A => fun i => w (i+1)) :=
    Measurable.of_eval (fun i => measurable_pi_apply (i+1))
  refine ⟨hshift,?_⟩
  rw [Measure.map_map hshift hcode]
  have heq : (fun w : ℤ → A => fun i => w (i+1)) ∘ orbitName e α=(orbitName e α) ∘ e :=
    funext (fun x => (orbitName_shift e α x).symm)
  rw [heq,←Measure.map_map hcode e.measurable,he.map_eq]

end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set Filter
open scoped ENNReal Topology
variable {X Y : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [StandardBorelSpace X] [MeasurableSpace.CountablySeparated Y] [MeasurableEq Y]

theorem measurable_decoder_of_conull_injective (μ : Measure X) [IsProbabilityMeasure μ]
    (f : X → Y) (hf : Measurable f) {S : Set X} (hS : MeasurableSet S)
    (hSae : ∀ᵐ x ∂μ,x∈S) (hinj : Set.InjOn f S) :
    ∃ d : Y → X,MeasurePreserving d (μ.map f) μ ∧
      (∀ᵐ x ∂μ,d (f x)=x) ∧ (∀ᵐ y ∂μ.map f,f (d y)=y) := by
  let _ : StandardBorelSpace S := hS.standardBorel
  let _ : Nonempty S := by obtain ⟨x,hx⟩ := hSae.exists; exact ⟨⟨x,hx⟩⟩
  let r : S → Y := fun x => f x
  have hr : MeasurableEmbedding r := (hf.comp measurable_subtype_coe).measurableEmbedding (by
    intro x y h
    exact Subtype.ext (hinj x.property y.property h))
  let d : Y → X := fun y => (hr.invFun y).val
  have hd : Measurable d := measurable_subtype_coe.comp hr.measurable_invFun
  have hl : ∀ᵐ x ∂μ,d (f x)=x := by
    filter_upwards [hSae] with x hx
    exact congrArg Subtype.val (hr.leftInverse_invFun ⟨x,hx⟩)
  have hmp : MeasurePreserving d (μ.map f) μ := by
    refine ⟨hd,?_⟩
    rw [Measure.map_map hd hf]
    have hm : d ∘ f =ᵐ[μ] id := hl
    exact (Measure.map_congr hm).trans (Measure.map_id)
  refine ⟨d,hmp,hl,?_⟩
  apply (ae_map_iff hf.aemeasurable (measurableSet_eq_fun (hf.comp hd) measurable_id)).mpr
  filter_upwards [hl] with x hx
  exact congrArg f hx

theorem measurable_decoder_of_countable_factors {I C : Type*} [Countable I]
    (μ : Measure X) [IsProbabilityMeasure μ] (f : X → Y) (hf : Measurable f)
    (α : I → X → C) (hsep : Function.Injective (fun x => fun i => α i x))
    (hfac : ∀ i,∃ g : Y → C,∀ᵐ x ∂μ,α i x=g (f x)) :
    ∃ d : Y → X,MeasurePreserving d (μ.map f) μ ∧
      (∀ᵐ x ∂μ,d (f x)=x) ∧ (∀ᵐ y ∂μ.map f,f (d y)=y) := by
  choose g hg using hfac
  have hAE : ∀ᵐ x ∂μ,∀ i,α i x=g i (f x) := ae_all_iff.mpr hg
  obtain ⟨S,hSae,hSm,hS⟩ := IsMeasurablyGenerated.exists_measurable_subset hAE
  apply measurable_decoder_of_conull_injective μ f hf hSm hSae
  intro x hx y hy hxy
  apply hsep
  funext i
  exact (hS hx i).trans ((congrArg (g i) hxy).trans (hS hy i).symm)

theorem measurable_decoder_of_generating_approximations {I C : Type*} [Countable I]
    [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] [Nonempty C]
    (μ : Measure X) [IsProbabilityMeasure μ] (f : X → Y) (hf : Measurable f)
    (α : I → X → C) (hsep : Function.Injective (fun x => fun i => α i x))
    (happ : ∀ i,∀ ε : ℝ,0<ε → ∃ g : Y → C,Measurable g ∧
      μ {x | g (f x)≠α i x}<ENNReal.ofReal ε) :
    ∃ d : Y → X,MeasurePreserving d (μ.map f) μ ∧
      (∀ᵐ x ∂μ,d (f x)=x) ∧ (∀ᵐ y ∂μ.map f,f (d y)=y) := by
  apply measurable_decoder_of_countable_factors μ f hf α hsep
  intro i
  obtain ⟨g,_hgm,hg⟩ := exists_factor_of_approx μ f (α i) (happ i)
  exact ⟨g,hg⟩

end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory MeasureTheory.Measure Set Filter
open scoped ENNReal Topology symmDiff
variable {X A C : Type*} [MeasurableSpace X] [MeasurableSpace A] [Fintype A]
    [MeasurableEq A] [MeasurableSpace C] [MeasurableEq C]

lemma decoder_error_tendsto {μ : Measure X} [IsFiniteMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    {q : ℕ → X → A} {p : X → A}
    (hq : ∀ n,Measurable (q n)) (hp : Measurable p)
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x)
    (s : Finset ℤ) (G : (s → A) → C) (hG : Measurable G)
    (α : X → C) (hα : Measurable α) :
    Tendsto (fun n => μ.real {x | G (s.restrict (orbitName e (q n) x))≠α x}) atTop
      (𝓝 (μ.real {x | G (s.restrict (orbitName e p x))≠α x})) := by
  have hm (u : X → A) (hu : Measurable u) :
      MeasurableSet {x | G (s.restrict (orbitName e u x))≠α x} :=
    (measurableSet_eq_fun (hG.comp ((measurable_restrict (s : Set ℤ)).comp (measurable_orbitName e hu))) hα).compl
  have hd (n : ℕ) :
      |μ.real {x | G (s.restrict (orbitName e (q n) x))≠α x}-
        μ.real {x | G (s.restrict (orbitName e p x))≠α x}|≤
          μ.real {x | s.restrict (orbitName e (q n) x)≠s.restrict (orbitName e p x)} := by
    apply (abs_measureReal_sub_le_measureReal_symmDiff
      (hm _ (hq n)).nullMeasurableSet (hm _ hp).nullMeasurableSet).trans
    apply ENNReal.toReal_mono (measure_ne_top μ _)
    apply measure_mono
    intro x hx hEq
    simp only [Set.mem_symmDiff,mem_ofPred_eq,hEq,and_not_self,or_self] at hx
  have hz := squeeze_zero (fun n => abs_nonneg _) hd (finite_code_error_tendsto_zero e he hq hp hlim s)
  exact tendsto_iff_dist_tendsto_zero.mpr (by simpa only [Real.dist_eq] using hz)

theorem approximate_decoders_pass_to_limit {μ : Measure X} [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    {q : ℕ → X → A} {p : X → A}
    (hq : ∀ n,Measurable (q n)) (hp : Measurable p)
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x)
    (α : X → C) (hα : Measurable α)
    (happ : ∀ ε : ℝ,0<ε → ∃ (s : Finset ℤ) (G : (s → A) → C),Measurable G ∧
      ∀ᶠ n : ℕ in atTop,μ.real {x | G (s.restrict (orbitName e (q n) x))≠α x}<ε) :
    ∀ ε : ℝ,0<ε → ∃ g : (ℤ → A) → C,Measurable g ∧
      μ {x | g (orbitName e p x)≠α x}<ENNReal.ofReal ε := by
  intro ε hε
  obtain ⟨s,G,hG,happ⟩ := happ (ε/2) (by positivity)
  refine ⟨G ∘ s.restrict,hG.comp (measurable_restrict (s : Set ℤ)),?_⟩
  have hle : μ.real {x | G (s.restrict (orbitName e p x))≠α x}≤ε/2 :=
    le_of_tendsto (decoder_error_tendsto e he hq hp hlim s G hG α hα) (happ.mono (fun n hn => hn.le))
  have hh : μ.real {x | G (s.restrict (orbitName e p x))≠α x}<ε := lt_of_le_of_lt hle (by linarith)
  change μ {x | G (s.restrict (orbitName e p x))≠α x}<ENNReal.ofReal ε
  rw [←ENNReal.ofReal_toReal (measure_ne_top μ _)]
  exact ENNReal.ofReal_lt_ofReal_iff hε |>.mpr hh

end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory MeasureTheory.Measure Set Filter
open scoped ENNReal Topology

theorem bernoulli_model_of_coherent_coding
    {X A I C : Type*} [MeasurableSpace X] [StandardBorelSpace X]
    [MeasurableSpace A] [StandardBorelSpace A] [Fintype A] [Nonempty A]
    [Countable I] [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] [Nonempty C]
    (μ : Measure X) [IsProbabilityMeasure μ] (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (α : I → X → C) (hα : ∀ i,Measurable (α i))
    (hsep : Function.Injective (fun x => fun i => α i x))
    (β : Measure A) [IsProbabilityMeasure β]
    (q : ℕ → X → A) (hq : ∀ n,Measurable (q n))
    (hs : (∑' n : ℕ,μ {x | q (n+1) x≠q n x})≠⊤)
    (hblock : ∀ (s : Finset ℤ) (t : ℤ → Set A),(∀ i,MeasurableSet (t i)) →
      Tendsto (fun n => (μ.map (orbitName e (q n))).real (Set.pi s t)) atTop
        (𝓝 ((∏ i∈s,β (t i)).toReal)))
    (hdecode : ∀ i,∀ ε : ℝ,0<ε → ∃ (s : Finset ℤ) (G : (s → A) → C),Measurable G ∧
      ∀ᶠ n : ℕ in atTop,μ.real {x | G (s.restrict (orbitName e (q n) x))≠α i x}<ε) :
    ∃ βR : Measure ℝ,IsProbabilityMeasure βR ∧
      ∃ (encode : X → (ℤ → ℝ)) (decode : (ℤ → ℝ) → X),
        MeasurePreserving encode μ (Measure.infinitePi (fun _ : ℤ => βR)) ∧
        MeasurePreserving decode (Measure.infinitePi (fun _ : ℤ => βR)) μ ∧
        (∀ᵐ x ∂μ,decode (encode x)=x) ∧
        (∀ᵐ w ∂Measure.infinitePi (fun _ : ℤ => βR),encode (decode w)=w) ∧
        (∀ᵐ x ∂μ,encode (e x)=fun i : ℤ => encode x (i+1)) := by
  obtain ⟨p,hp,hlim⟩ := exists_partition_limit μ q hq hs
  have hcode := iid_law_of_partition_limit e he hq hp hlim β hblock
  obtain ⟨d,hd,hl,_hr⟩ := measurable_decoder_of_generating_approximations μ (orbitName e p)
    (measurable_orbitName e hp) α hsep (fun i =>
      approximate_decoders_pass_to_limit e he hq hp hlim (α i) (hα i) (hdecode i))
  rw [hcode.map_eq] at hd
  let b : A → ℝ := embeddingReal A
  have hb : MeasurableEmbedding b := measurableEmbedding_embeddingReal A
  let βR := β.map b
  have : IsProbabilityMeasure βR := inferInstance
  let F : (ℤ → A) → (ℤ → ℝ) := fun w i => b (w i)
  let G : (ℤ → ℝ) → (ℤ → A) := fun w i => hb.invFun (w i)
  have hF : Measurable F := Measurable.of_eval (fun i => hb.measurable.comp (measurable_pi_apply i))
  have hG : Measurable G := Measurable.of_eval (fun i => hb.measurable_invFun.comp (measurable_pi_apply i))
  have hGF (w : ℤ → A) : G (F w)=w := funext (fun i => hb.leftInverse_invFun (w i))
  have hmpF : MeasurePreserving F (Measure.infinitePi (fun _ : ℤ => β))
      (Measure.infinitePi (fun _ : ℤ => βR)) :=
    ⟨hF,Measure.infinitePi_map_pi _ (fun _ => hb.measurable)⟩
  have hmpG : MeasurePreserving G (Measure.infinitePi (fun _ : ℤ => βR))
      (Measure.infinitePi (fun _ : ℤ => β)) := by
    refine ⟨hG,?_⟩
    rw [←hmpF.map_eq,Measure.map_map hG hF,show G ∘ F=id from funext hGF,Measure.map_id]
  let encode : X → (ℤ → ℝ) := F ∘ orbitName e p
  let decode : (ℤ → ℝ) → X := d ∘ G
  have hE : MeasurePreserving encode μ (Measure.infinitePi (fun _ : ℤ => βR)) := hmpF.comp hcode
  have hD : MeasurePreserving decode (Measure.infinitePi (fun _ : ℤ => βR)) μ := hd.comp hmpG
  have hleft : ∀ᵐ x ∂μ,decode (encode x)=x := by
    filter_upwards [hl] with x hx
    exact (congrArg d (hGF (orbitName e p x))).trans hx
  refine ⟨βR,inferInstance,encode,decode,hE,hD,hleft,?_,?_⟩
  · rw [←hE.map_eq]
    apply (ae_map_iff hE.measurable.aemeasurable
      (measurableSet_eq_fun (hE.measurable.comp hD.measurable) measurable_id)).mpr
    filter_upwards [hleft] with x hx
    exact congrArg encode hx
  · exact ae_of_all _ (fun x => funext (fun i => congrArg b (congrFun (orbitName_shift e p x) i)))

end HyperbolicCoding

end
end

end OAI