lean/OAI/Dynamics/StandardMap/Coding/CenteredDecoder.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Coding.FixedWindowTower

namespace OAI

section
namespace HyperbolicCoding
open MeasureTheory Set Filter StandardMapEntropy.Entropy
open scoped BigOperators ENNReal Topology
variable {X A B : Type*} [MeasurableSpace X]
  [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B]

lemma centeredWindow_orbit_shift [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (e : X ≃ᵐ X) (p : X → A) (R : ℕ) (x : X) :
    centeredWindow R (orbitName e p (e^[R] x))=word e p (2*R+1) x := by
  funext i
  change p (integerIterate e ((i.val : ℤ)-R) (e^[R] x))=p (e^[i.val] x)
  rw [←integerIterate_nat e R x,←integerIterate_add,sub_add_cancel,integerIterate_nat]

variable [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]

lemma centered_decoder_error_eq (μ : Measure X) (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (α : X → B) (p : X → A) (hα : Measurable α) (hp : Measurable p)
    (R : ℕ) (D : (Fin (2*R+1) → A) → B) :
    μ.real {x | α x≠D (centeredWindow R (orbitName e p x))}=
      μ.real {x | α (e^[R] x)≠D (word e p (2*R+1) x)} := by
  have hD : Measurable (fun x => D (centeredWindow R (orbitName e p x))) :=
    (measurable_of_countable D).comp ((measurable_centeredWindow R).comp (measurable_orbitName e hp))
  have hset : {x | α (e^[R] x)≠D (word e p (2*R+1) x)}=
      (e^[R]) ⁻¹' {x | α x≠D (centeredWindow R (orbitName e p x))} := by
    ext x
    simp only [mem_ofPred_eq,mem_preimage,centeredWindow_orbit_shift]
  have hm : MeasurableSet {x | α x≠D (centeredWindow R (orbitName e p x))} := (measurableSet_eq_fun hα hD).compl
  rw [hset,Measure.real,Measure.real,(he.iterate R).measure_preimage hm.nullMeasurableSet]

lemma centered_decoder_perturbation [StandardBorelSpace X] [Nonempty A]
    (μ : Measure X) [IsFiniteMeasure μ] (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (α : X → B) (p q : X → A) (hα : Measurable α) (hp : Measurable p) (hq : Measurable q)
    (R : ℕ) (D : (Fin (2*R+1) → A) → B) :
    μ.real {x | α x≠D (centeredWindow R (orbitName e q x))}≤
      μ.real {x | α x≠D (centeredWindow R (orbitName e p x))}+
        (2*R+1 : ℕ)*μ.real {x | p x≠q x} := by
  rw [centered_decoder_error_eq μ e he α q hα hq R D,
    centered_decoder_error_eq μ e he α p hα hp R D]
  exact finite_decoder_perturbation μ e he p q hp hq (fun x => α (e^[R] x)) _ D
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 exact_iid_decoder_density (μ : 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 < η) :
    ∃ q : X → A,∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → B,Measurable q ∧
      MeasurePreserving (orbitName e q) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) ∧
      μ.real {x | p x≠q x} < η ∧
      μ.real {x | α x≠D (centeredWindow R (orbitName e q x))} < η := by
  obtain ⟨R,D,hproduce⟩ := fixed_decoder_arbitrary_tests μ e he htotal p hp β hβ hβsum hβentropy
    H hcode α hα happrox zero one h01 (half_pos hη)
  let c : ℝ := η/(4*((2*R+1 : ℕ)+1))
  have hc : 0 < c := by dsimp [c]; positivity
  obtain ⟨L,δ,hδ,hcomplete⟩ := seeded_exact_iid_limit μ e he htotal β hβ hβsum hβentropy H zero one h01 hc
  obtain ⟨q₀,hq₀,hpaint,hfixed,hlaw,hrate⟩ := hproduce L δ δ hδ hδ
  obtain ⟨q,hq,hcodeq,hclose⟩ := hcomplete q₀ hq₀ hlaw hrate.le
  have hwidth : (0 : ℝ)≤(2*R+1 : ℕ) := Nat.cast_nonneg _
  have hceq : c*(4*((2*R+1 : ℕ)+1))=η := by dsimp [c]; field_simp
  have hcη : c≤η/4 := by nlinarith only [hceq,hc,hwidth]
  have hWc : (2*R+1 : ℕ)*c≤η/4 := by nlinarith only [hceq,hc,hwidth]
  refine ⟨q,R,D,hq,hcodeq,?_,?_⟩
  · have hh := disagreement_triangle μ p q₀ q
    linarith only [hh,hpaint,hclose,hcη,hη]
  · rw [centered_decoder_error_eq μ e he.toMeasurePreserving α q hα hq R D]
    have hh := finite_decoder_perturbation μ e he.toMeasurePreserving q₀ q hq₀ hq (fun x => α (e^[R] x)) (2*R+1) D
    have hd := mul_le_mul_of_nonneg_left hclose.le hwidth
    linarith only [hh,hfixed,hd,hWc,hη]

theorem exact_iid_decoder_density_of_separating_wb (μ : Measure X) [IsProbabilityMeasure μ]
    [NullSingletonClass μ] [μ.OuterRegular] (e : X ≃ᵐ X) (he : Ergodic e μ)
    (htotal : ∀ m : ℕ,0 < m → Ergodic (e^[m]) μ)
    (ξ : ℕ → ℕ → X → Bool) (hξ : ∀ i j,Measurable (ξ i j))
    (hsep : Function.Injective (fun x => fun i j => ξ i j x))
    (hwb : ∀ M,WeakBernoulliProcess μ e (joinedBinary ξ 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 α) (zero one : A) (h01 : zero≠one) {η : ℝ} (hη : 0 < η) :
    ∃ q : X → A,∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → B,Measurable q ∧
      MeasurePreserving (orbitName e q) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) ∧
      μ.real {x | p x≠q x} < η ∧
      μ.real {x | α x≠D (centeredWindow R (orbitName e q x))} < η := by
  apply exact_iid_decoder_density μ e he htotal p hp β hβ hβsum hβentropy H hcode α hα _ zero one h01 hη
  intro ε hε
  obtain ⟨r,hr,hwr,herr⟩ := separating_wb_approximation μ e ξ hξ hsep hwb
    (fun x => (p x,α x)) (hp.prodMk hα) hε
  refine ⟨r,hr,hwr,?_⟩
  rwa [disagreement_symm]
end HyperbolicCoding

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

lemma budget_geometric_decay (b : ℕ → ℝ) (hb : ∀ n,b (n+1)≤b n/2) (n k : ℕ) :
    b (n+k)≤b n*(1/2 : ℝ)^k := by
  induction k with
  | zero => simp
  | succ k ih =>
    rw [Nat.add_succ,pow_succ]
    have hh := hb (n+k)
    nlinarith only [ih,hh]

lemma geometric_tail_distance (μ : Measure X) [IsFiniteMeasure μ]
    (q : ℕ → X → A) (b : ℕ → ℝ) (hpos : ∀ n,0≤b n)
    (hb : ∀ n,b (n+1)≤b n/2)
    (hpaint : ∀ n,μ.real {x | q n x≠q (n+1) x}≤b n/2) (n k : ℕ) :
    μ.real {x | q n x≠q (n+k) x}≤b n := by
  let η : ℕ → ℝ := fun j => b n/2*(1/2 : ℝ)^j
  have hstep (j : ℕ) : μ.real {x | q (n+j) x≠q (n+(j+1)) x}≤η j := by
    have h := hpaint (n+j)
    have hh := budget_geometric_decay b hb n j
    dsimp [η]
    rw [Nat.add_succ]
    nlinarith only [h,hh]
  have hh := sequence_distance_le_sum μ (fun j => q (n+j)) η hstep k
  simp only [Nat.add_zero] at hh
  apply hh.trans
  simp only [η,←Finset.mul_sum]
  have hs := mul_le_mul_of_nonneg_left (sum_geometric_two_le k) (show 0≤b n/2 from div_nonneg (hpos n) (by norm_num))
  nlinarith only [hs]

lemma geometric_tail_limit [MeasurableEq A]
    (μ : Measure X) [IsFiniteMeasure μ] (q : ℕ → X → A) (p : X → A)
    (hq : ∀ n,Measurable (q n)) (hp : Measurable p)
    (hlim : ∀ᵐ x ∂μ,∀ᶠ n : ℕ in atTop,q n x=p x)
    (b : ℕ → ℝ) (hpos : ∀ n,0≤b n) (hb : ∀ n,b (n+1)≤b n/2)
    (hpaint : ∀ n,μ.real {x | q n x≠q (n+1) x}≤b n/2) (n : ℕ) :
    μ.real {x | q n x≠p x}≤b n := by
  have ht : Tendsto (fun j : ℕ => n+j) atTop atTop := by
    simpa only [Nat.add_comm] using tendsto_add_atTop_nat n
  have hl : ∀ᵐ x ∂μ,∀ᶠ j : ℕ in atTop,q (n+j) x=p x :=
    hlim.mono (fun x hx => ht.eventually hx)
  exact partition_limit_distance_bound μ (fun j => q (n+j)) p (q n) (fun j => hq _) hp hl
    (fun k => geometric_tail_distance μ q b hpos hb hpaint n k)
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set Filter StandardMapEntropy.Entropy
open scoped BigOperators ENNReal Topology

lemma exists_post_decoder_budget (W : ℕ) {ε c : ℝ} (hε : 0 < ε) (hc : 0 < c) :
    ∃ b : ℝ,0 < b ∧ b≤c ∧ (W : ℝ)*b≤ε := by
  let b := min c (ε/((W : ℝ)+1))
  have hW : (0 : ℝ)≤W := Nat.cast_nonneg W
  have hb : 0 < b := lt_min hc (by positivity)
  have hsmall : b≤ε/((W : ℝ)+1) := min_le_right _ _
  have hh := (le_div_iff₀ (by positivity : (0 : ℝ)<(W : ℝ)+1)).mp hsmall
  exact ⟨b,hb,min_le_left _ _,by nlinarith only [hh,hb]⟩
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]
  [TopologicalSpace A] [DiscreteTopology A] [BorelSpace A]

structure GeneratingIIDStage (μ : Measure X) (e : X ≃ᵐ X) (β : A → ℝ)
    (α : ℕ → ℕ → X → Bool) (n : ℕ) where
  partition : X → A
  measurable_partition : Measurable partition
  iid : MeasurePreserving (orbitName e partition) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β))
  radius : ℕ
  decoder : (Fin (2*radius+1) → A) → ((Fin (n+1) × Fin (n+1)) → Bool)
  error : μ.real {x | joinedBinary α (n+1) x≠decoder (centeredWindow radius (orbitName e partition x))} <
    (1/2 : ℝ)^(n+2)
  budget : ℝ
  budget_pos : 0 < budget
  budget_small : (2*radius+1 : ℕ)*budget≤(1/2 : ℝ)^(n+2)

lemma generating_iid_stage (μ : 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 β))
    (α : ℕ → ℕ → X → Bool) (hα : ∀ i j,Measurable (α i j))
    (hsep : Function.Injective (fun x => fun i j => α i j x))
    (hwb : ∀ M,WeakBernoulliProcess μ e (joinedBinary α M))
    (zero one : A) (h01 : zero≠one)
    (p : X → A) (hp : Measurable p)
    (hcode : MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)))
    (n : ℕ) {η c : ℝ} (hη : 0 < η) (hc : 0 < c) :
    ∃ S : GeneratingIIDStage μ e β α n,
      μ.real {x | p x≠S.partition x} < η ∧ S.budget≤c := by
  have hε : 0 < (1/2 : ℝ)^(n+2) := by positivity
  obtain ⟨q,R,D,hq,hcodeq,hpaint,hdecode⟩ := exact_iid_decoder_density_of_separating_wb μ e he htotal
    α hα hsep hwb p hp β hβ hβsum hβentropy H hcode (joinedBinary α (n+1))
    (measurable_joinedBinary hα _) zero one h01 (lt_min hη hε)
  obtain ⟨b,hb,hbc,hbudget⟩ := exists_post_decoder_budget (2*R+1) hε hc
  refine ⟨⟨q,hq,hcodeq,R,D,hdecode.trans_le (min_le_right _ _),b,hb,hbudget⟩,?_,hbc⟩
  exact hpaint.trans_le (min_le_left _ _)

theorem generating_iid_partition (μ : 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 β))
    (α : ℕ → ℕ → X → Bool) (hα : ∀ i j,Measurable (α i j))
    (hsep : Function.Injective (fun x => fun i j => α i j x))
    (hwb : ∀ M,WeakBernoulliProcess μ e (joinedBinary α M))
    (zero one : A) (h01 : zero≠one)
    (p₀ : X → A) (hp₀ : Measurable p₀)
    (hcode₀ : MeasurePreserving (orbitName e p₀) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β))) :
    ∃ p : X → A,Measurable p ∧
      MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) ∧
      ∀ n : ℕ,∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → ((Fin (n+1) × Fin (n+1)) → Bool),
        μ.real {x | joinedBinary α (n+1) x≠D (centeredWindow R (orbitName e p x))}≤2*(1/2 : ℝ)^(n+2) := by
  have hstart := generating_iid_stage μ e he htotal β hβ hβsum hβentropy H α hα hsep hwb
    zero one h01 p₀ hp₀ hcode₀ 0 zero_lt_one zero_lt_one
  let S₀ : GeneratingIIDStage μ e β α 0 := Classical.choose hstart
  have hnext (n : ℕ) (S : GeneratingIIDStage μ e β α n) :
      ∃ T : GeneratingIIDStage μ e β α (n+1),
        μ.real {x | S.partition x≠T.partition x} < S.budget/2 ∧ T.budget≤S.budget/2 :=
    generating_iid_stage μ e he htotal β hβ hβsum hβentropy H α hα hsep hwb
      zero one h01 S.partition S.measurable_partition S.iid (n+1) (half_pos S.budget_pos) (half_pos S.budget_pos)
  let next (n : ℕ) (S : GeneratingIIDStage μ e β α n) : GeneratingIIDStage μ e β α (n+1) :=
    Classical.choose (hnext n S)
  let z : (n : ℕ) → GeneratingIIDStage μ e β α n := fun n =>
    Nat.rec (motive:=fun n => GeneratingIIDStage μ e β α n) S₀ next n
  let q : ℕ → X → A := fun n => (z n).partition
  let b : ℕ → ℝ := fun n => (z n).budget
  have hq (n : ℕ) : Measurable (q n) := (z n).measurable_partition
  have hbpos (n : ℕ) : 0 < b n := (z n).budget_pos
  have hb0 : b 0≤1 := (Classical.choose_spec hstart).2
  have hb (n : ℕ) : b (n+1)≤b n/2 := (Classical.choose_spec (hnext n (z n))).2
  have hpaint (n : ℕ) : μ.real {x | q n x≠q (n+1) x} < b n/2 :=
    (Classical.choose_spec (hnext n (z n))).1
  have hgeom (n : ℕ) : μ.real {x | q (n+1) x≠q n x} < ((1/2 : ℝ≥0)^n : ℝ) := by
    rw [disagreement_symm]
    have hdecay := budget_geometric_decay b hb 0 n
    simp only [Nat.zero_add] at hdecay
    have hbn : b n≤(1/2 : ℝ)^n := hdecay.trans (by
      simpa only [one_mul] using mul_le_mul_of_nonneg_right hb0 (by positivity : 0≤(1/2 : ℝ)^n))
    have hh : b n/2≤b n := by linarith only [hbpos n]
    have hc := (hpaint n).trans_le (hh.trans hbn)
    simpa only [NNReal.coe_pow,NNReal.coe_div,NNReal.coe_one,NNReal.coe_ofNat] using hc
  obtain ⟨p,hp,hlim⟩ := exists_partition_limit μ q hq (geometric_repainting_summable μ q hgeom)
  let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum
  have hlaw (n : ℕ) : LawClose (μ.map (word e (q n) n))
      (Measure.pi (fun _ : Fin n => finiteWeightLaw β)) (1/(n+1 : ℝ)) := by
    rw [word_law_of_iid_factor μ e (q n) (hq n) (finiteWeightLaw β) (z n).iid]
    intro S hS
    simp only [sub_self,abs_zero]
    positivity
  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,?_⟩
  intro n
  refine ⟨(z n).radius,(z n).decoder,?_⟩
  have htail := geometric_tail_limit μ q p hq hp hlim b (fun n => (hbpos n).le) hb (fun n => (hpaint n).le) n
  have hh := centered_decoder_perturbation μ e he.toMeasurePreserving (joinedBinary α (n+1))
    (q n) p (measurable_joinedBinary hα _) (hq n) hp (z n).radius (z n).decoder
  have hd := mul_le_mul_of_nonneg_left htail (Nat.cast_nonneg (2*(z n).radius+1) : (0 : ℝ)≤_)
  have he := (z n).error
  have hb := (z n).budget_small
  change _≤_+_ at hh
  change _ < (1/2 : ℝ)^(n+2) at he
  change (2*(z n).radius+1 : ℕ)*b n≤(1/2 : ℝ)^(n+2) at hb
  linarith only [hh,hd,he,hb]
end HyperbolicCoding

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

theorem binary_factors_of_joined_decoders (μ : Measure X) [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (p : X → A) (α : ℕ → ℕ → X → Bool)
    (hdecode : ∀ n : ℕ,∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → ((Fin (n+1) × Fin (n+1)) → Bool),
      μ.real {x | joinedBinary α (n+1) x≠D (centeredWindow R (orbitName e p x))}≤2*(1/2 : ℝ)^(n+2)) :
    ∀ i j : ℕ,∀ ε : ℝ,0 < ε → ∃ g : (ℤ → A) → Bool,Measurable g ∧
      μ {x | g (orbitName e p x)≠α i j x} < ENNReal.ofReal ε := by
  intro i j ε hε
  have hz : Tendsto (fun n : ℕ => 2*(1/2 : ℝ)^(n+2)) atTop (𝓝 0) := by
    have hp := tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num : (0 : ℝ)≤1/2) (by norm_num : (1/2 : ℝ) < 1)
    simpa using tendsto_const_nhds.mul (hp.comp (tendsto_add_atTop_nat 2))
  obtain ⟨n,hnε,hnlarge⟩ := ((hz.eventually (gt_mem_nhds hε)).and (eventually_ge_atTop (max i j))).exists
  obtain ⟨R,D,hD⟩ := hdecode n
  have hi : i < n+1 := by omega
  have hj : j < n+1 := by omega
  let ij : Fin (n+1) × Fin (n+1) := (⟨i,hi⟩,⟨j,hj⟩)
  let g : (ℤ → A) → Bool := fun w => D (centeredWindow R w) ij
  have hg : Measurable g := (measurable_pi_apply ij).comp
    ((measurable_of_countable D).comp (measurable_centeredWindow R))
  have hsub : {x | g (orbitName e p x)≠α i j x}⊆
      {x | joinedBinary α (n+1) x≠D (centeredWindow R (orbitName e p x))} := by
    intro x hx heq
    have hh := congrFun heq ij
    exact hx hh.symm
  have hh : μ.real {x | g (orbitName e p x)≠α i j x} < ε :=
    ((measureReal_mono (μ:=μ) hsub).trans hD).trans_lt hnε
  refine ⟨g,hg,?_⟩
  rw [←ENNReal.ofReal_toReal (measure_ne_top μ {x | g (orbitName e p x)≠α i j x})]
  exact (ENNReal.ofReal_lt_ofReal_iff hε).mpr hh
end HyperbolicCoding

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

theorem bernoulli_model_of_generating_iid (μ : Measure X) [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (p : X → A) (hp : Measurable p) (β : Measure A) [IsProbabilityMeasure β]
    (hcode : MeasurePreserving (orbitName e p) μ (Measure.infinitePi (fun _ : ℤ => β)))
    (α : ℕ → ℕ → X → Bool) (hsep : Function.Injective (fun x => fun i j => α i j x))
    (hdecode : ∀ n : ℕ,∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → ((Fin (n+1) × Fin (n+1)) → Bool),
      μ.real {x | joinedBinary α (n+1) x≠D (centeredWindow R (orbitName e p x))}≤2*(1/2 : ℝ)^(n+2)) :
    ∃ β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
  have hsep' : Function.Injective (fun x => fun i : ℕ × ℕ => α i.1 i.2 x) := by
    intro x y h
    apply hsep
    funext i j
    exact congrFun h (i,j)
  obtain ⟨d,hd,hl,_hr⟩ := measurable_decoder_of_generating_approximations μ (orbitName e p)
    (measurable_orbitName e hp) (fun i : ℕ × ℕ => α i.1 i.2) hsep'
    (fun i => binary_factors_of_joined_decoders μ e p α hdecode i.1 i.2)
  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 index => hb.measurable.comp (measurable_pi_apply index))
  have hG : Measurable G := Measurable.of_eval (fun index => hb.measurable_invFun.comp (measurable_pi_apply index))
  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 OAI