import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Coupling.ChunkNameCost

namespace OAI

section
section
namespace StandardMapEntropy.Entropy
open MeasureTheory Set HyperbolicCoding
open scoped BigOperators ENNReal
variable {X A B C : Type*} [MeasurableSpace X]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B]
    [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C]
variable (μ : Measure X) [IsProbabilityMeasure μ]

omit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
  [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B] in
lemma mass_factor_le (p : X → A) (g : A → B) (a : A) :
    mass μ p a≤ mass μ (g ∘ p) (g a) := by
  unfold mass
  apply ENNReal.toReal_mono (measure_ne_top μ _)
  apply measure_mono
  intro x hx
  exact congrArg g hx

noncomputable def refinementCopyWeights (p : X → A) (q : X → B) (c : A → C) (a : A) (b : B) : ℝ :=
  mass μ p a*mass μ (fun x => (c (p x),q x)) (c a,b)/mass μ (c ∘ p) (c a)

omit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
  [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B]
  [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] [IsProbabilityMeasure μ] in
lemma refinementCopyWeights_nonneg (p : X → A) (q : X → B) (c : A → C) (a : A) (b : B) :
    0≤refinementCopyWeights μ p q c a b :=
  div_nonneg (mul_nonneg (mass_nonneg _ _ _) (mass_nonneg _ _ _)) (mass_nonneg _ _ _)

omit [Fintype C] in
lemma refinementCopyWeights_row (p : X → A) (q : X → B) (c : A → C)
    (hp : Measurable p) (hq : Measurable q) (a : A) :
    (∑ b,refinementCopyWeights μ p q c a b)=mass μ p a := by
  have hc : Measurable (c ∘ p) := (measurable_of_countable c).comp hp
  by_cases hz : mass μ (c ∘ p) (c a)=0
  · have hp0 : mass μ p a=0 := le_antisymm ((mass_factor_le μ p c a).trans (le_of_eq hz)) (mass_nonneg _ _ _)
    simp only [refinementCopyWeights,hp0,zero_mul,zero_div,Finset.sum_const_zero]
  · have hrow : (∑ b,mass μ (fun x => (c (p x),q x)) (c a,b))=mass μ (c ∘ p) (c a) :=
      (mass_joint_row μ (c ∘ p) q hc hq (c a)).symm
    simp only [refinementCopyWeights,←Finset.sum_div,←Finset.mul_sum,hrow,mul_div_cancel_right₀ _ hz]

omit [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
  [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B]
  [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C] in
lemma refinementCopyWeights_support (p : X → A) (q : X → B) (c : A → C) (a : A) (b : B)
    (h : mass μ (fun x => (p x,q x)) (a,b)≠0) : refinementCopyWeights μ p q c a b≠0 := by
  have hu : 0 < mass μ (fun x => (p x,q x)) (a,b) := lt_of_le_of_ne (mass_nonneg _ _ _) (Ne.symm h)
  have hp : 0 < mass μ p a := hu.trans_le (mass_factor_le μ (fun x => (p x,q x)) Prod.fst (a,b))
  have hcb : 0 < mass μ (fun x => (c (p x),q x)) (c a,b) :=
    hu.trans_le (mass_factor_le μ (fun x => (p x,q x)) (fun ab => (c ab.1,ab.2)) (a,b))
  have hc : 0 < mass μ (c ∘ p) (c a) := hp.trans_le (mass_factor_le μ p c a)
  exact ne_of_gt (div_pos (mul_pos hp hcb) hc)

theorem refinement_relativeInformation (p : X → A) (q : X → B) (c : A → C)
    (hp : Measurable p) (hq : Measurable q) :
    relativeInformation (fun ab : A×B => mass μ (fun x => (p x,q x)) ab)
      (fun ab => refinementCopyWeights μ p q c ab.1 ab.2)=
        cond μ q (c ∘ p)-cond μ q p := by
  have hc : Measurable (c ∘ p) := (measurable_of_countable c).comp hp
  let pq : X → A×B := fun x => (p x,q x)
  let cq : X → C×B := fun x => (c (p x),q x)
  have hpq : Measurable pq := hp.prodMk hq
  have hcq : Measurable cq := hc.prodMk hq
  unfold relativeInformation
  rw [sum_mass_mul_integral μ pq hpq]
  have he : (fun x => Real.log (mass μ pq (pq x))-
      Real.log (refinementCopyWeights μ p q c (p x) (q x)))=ᵐ[μ]
      (fun x => -information μ pq x+information μ p x+information μ cq x-information μ (c ∘ p) x) := by
    filter_upwards [ae_mass_positive μ p,ae_mass_positive μ cq,ae_mass_positive μ (c ∘ p)] with x hx hcx hcpx
    dsimp only [refinementCopyWeights,information,pq,cq,Function.comp_apply] at *
    rw [Real.log_div (mul_pos hx hcx).ne' hcpx.ne',Real.log_mul hx.ne' hcx.ne']
    ring
  rw [integral_congr_ae he]
  rw [integral_sub (f:=fun x => -information μ pq x+information μ p x+information μ cq x)
    (g:=fun x => information μ (c ∘ p) x) (((information_integrable μ pq hpq).neg.add (information_integrable μ p hp)).add
    (information_integrable μ cq hcq)) (information_integrable μ (c ∘ p) hc)]
  rw [integral_add (f:=fun x => -information μ pq x+information μ p x) (g:=fun x => information μ cq x) ((information_integrable μ pq hpq).neg.add (information_integrable μ p hp))
      (information_integrable μ cq hcq),integral_add (f:=fun x => -information μ pq x) (g:=fun x => information μ p x) (information_integrable μ pq hpq).neg
      (information_integrable μ p hp),integral_neg]
  simp only [integral_information μ pq hpq,integral_information μ p hp,
    integral_information μ cq hcq,integral_information μ (c ∘ p) hc]
  unfold cond
  rw [obs_pair_swap μ q (c ∘ p),obs_pair_swap μ q p]
  dsimp only [pq,cq,Function.comp_apply]
  ring

end StandardMapEntropy.Entropy

end
section
namespace HyperbolicCoding
open MeasureTheory Set
open scoped BigOperators
variable {A : Type*} [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
variable (μ ν : Measure A) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]

lemma finite_l1_le_two_of_lawClose {ε : ℝ} (h : LawClose μ ν ε) :
    (∑ a,|μ.real {a}-ν.real {a}|)≤2*ε := by
  have he (a : A) : |μ.real {a}-ν.real {a}|=
      max (μ.real {a}-ν.real {a}) 0+max (ν.real {a}-μ.real {a}) 0 := by
    rcases le_total (μ.real {a}) (ν.real {a}) with ha|ha
    · rw [abs_of_nonpos (sub_nonpos.mpr ha),max_eq_right (sub_nonpos.mpr ha),max_eq_left (sub_nonneg.mpr ha)]
      ring
    · rw [abs_of_nonneg (sub_nonneg.mpr ha),max_eq_left (sub_nonneg.mpr ha),max_eq_right (sub_nonpos.mpr ha)]
      ring
  simp_rw [he,Finset.sum_add_distrib]
  linarith [positive_mass_difference_le μ ν h,positive_mass_difference_le ν μ h.symm]

lemma lawClose_of_finite_l1 {ε : ℝ} (h : (∑ a,|μ.real {a}-ν.real {a}|)≤ε) : LawClose μ ν ε := by
  classical
  intro D _hD
  let S : Finset A := Finset.univ.filter (fun a => a∈D)
  have he : (S : Set A)=D := by ext a; simp [S]
  have hμ : μ.real D=∑ a∈S,μ.real {a} := by rw [←he]; exact (sum_measureReal_singleton S).symm
  have hν : ν.real D=∑ a∈S,ν.real {a} := by rw [←he]; exact (sum_measureReal_singleton S).symm
  rw [hμ,hν,←Finset.sum_sub_distrib]
  apply le_trans (Finset.abs_sum_le_sum_abs _ _) (le_trans ?_ h)
  exact Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ S) (fun a _ _ => abs_nonneg _)

end HyperbolicCoding

end
section
namespace StandardMapEntropy.Entropy
open MeasureTheory Set HyperbolicCoding
open scoped BigOperators ENNReal
variable {X A B C : Type*} [MeasurableSpace X]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    [MeasurableSpace B] [Fintype B] [MeasurableSingletonClass B]
    [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C]
variable (μ : Measure X) [IsProbabilityMeasure μ]

lemma sum_mass_factor_mul (p : X → A) (hp : Measurable p) (c : A → C) (F : C → ℝ) :
    (∑ a,mass μ p a*F (c a))=∑ d,mass μ (c ∘ p) d*F d := by
  calc
    _ = ∫ x, (F ∘ c) (p x) ∂μ := sum_mass_mul_integral μ p hp (F ∘ c)
    _ = _ := (sum_mass_mul_integral μ (c ∘ p)
      ((measurable_of_countable c).comp hp) F).symm

omit [MeasurableSingletonClass B] in
lemma refinement_distance_eq (p : X → A) (q : X → B) (c : A → C)
    (hp : Measurable p) (_ : Measurable q) :
    (∑ a,∑ b,|refinementCopyWeights μ p q c a b-mass μ p a*mass μ q b|)=
      ∑ d,∑ b,|mass μ (fun x => (c (p x),q x)) (d,b)-mass μ (c ∘ p) d*mass μ q b| := by
  have he (a : A) (b : B) : |refinementCopyWeights μ p q c a b-mass μ p a*mass μ q b|=
      mass μ p a*|mass μ (fun x => (c (p x),q x)) (c a,b)/mass μ (c ∘ p) (c a)-mass μ q b| := by
    unfold refinementCopyWeights
    rw [mul_div_assoc,←mul_sub,abs_mul,abs_of_nonneg (mass_nonneg μ p a)]
  simp_rw [he]
  rw [Finset.sum_comm]
  have hec (b : B) := sum_mass_factor_mul μ p hp c
    (fun d => |mass μ (fun x => (c (p x),q x)) (d,b)/mass μ (c ∘ p) d-mass μ q b|)
  simp_rw [hec]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro d _
  apply Finset.sum_congr rfl
  intro b _
  let u := mass μ (c ∘ p) d
  let v := mass μ (fun x => (c (p x),q x)) (d,b)
  have hu : 0≤u := mass_nonneg _ _ _
  have hv : 0≤v := mass_nonneg _ _ _
  have hvu : v≤u := mass_factor_le μ (fun x => (c (p x),q x)) Prod.fst (d,b)
  change u*|v/u-mass μ q b|=|v-u*mass μ q b|
  by_cases hu0 : u=0
  · have hv0 : v=0 := le_antisymm (hvu.trans (le_of_eq hu0)) hv
    simp [hu0,hv0]
  · calc
      _ = |u*(v/u-mass μ q b)| := by rw [abs_mul,abs_of_nonneg hu]
      _ = _ := by congr 1; rw [mul_sub,mul_div_cancel₀ _ hu0]

theorem lawClose_of_coarse_independence (p : X → A) (q : X → B) (c : A → C)
    (hp : Measurable p) (hq : Measurable q) {ε δ : ℝ} (hδ : 0≤δ)
    (hclose : LawClose (μ.map (fun x => (c (p x),q x)))
      ((μ.map (c ∘ p)).prod (μ.map q)) ε)
    (hdef : 4*(cond μ q (c ∘ p)-cond μ q p)≤δ^2) :
    LawClose (μ.map (fun x => (p x,q x))) ((μ.map p).prod (μ.map q)) (δ+2*ε) := by
  have hc : Measurable (c ∘ p) := (measurable_of_countable c).comp hp
  have : IsProbabilityMeasure (μ.map p) := inferInstance
  have : IsProbabilityMeasure (μ.map q) := inferInstance
  have : IsProbabilityMeasure (μ.map (c ∘ p)) := inferInstance
  have : IsProbabilityMeasure (μ.map (fun x => (p x,q x))) := inferInstance
  have : IsProbabilityMeasure (μ.map (fun x => (c (p x),q x))) := inferInstance
  let u : A×B → ℝ := fun ab => mass μ (fun x => (p x,q x)) ab
  let v : A×B → ℝ := fun ab => refinementCopyWeights μ p q c ab.1 ab.2
  have hu1 : (∑ ab,u ab)=1 := by simp only [u,mass_sum μ _ (hp.prodMk hq),measure_univ,ENNReal.toReal_one]
  have hv1 : (∑ ab,v ab)=1 := by
    rw [Fintype.sum_prod_type]
    simp only [v,refinementCopyWeights_row μ p q c hp hq,mass_sum μ p hp,measure_univ,ENNReal.toReal_one]
  have hpen := finite_pinsker_sq u v (fun _ => mass_nonneg _ _ _)
    (fun ab => refinementCopyWeights_nonneg μ p q c ab.1 ab.2) hu1 hv1
    (fun ab => refinementCopyWeights_support μ p q c ab.1 ab.2)
  have hinfo : relativeInformation u v=cond μ q (c ∘ p)-cond μ q p :=
    refinement_relativeInformation μ p q c hp hq
  rw [hinfo] at hpen
  have hUV : (∑ ab,|u ab-v ab|)≤δ := by nlinarith [hpen.trans hdef]
  have hmap (a : A) (b : B) : (μ.map (fun x => (p x,q x))).real {(a,b)}=u (a,b) :=
    map_measureReal_apply (hp.prodMk hq) (measurableSet_singleton (a,b))
  have hmapC (d : C) (b : B) : (μ.map (fun x => (c (p x),q x))).real {(d,b)}=
      mass μ (fun x => (c (p x),q x)) (d,b) :=
    map_measureReal_apply (hc.prodMk hq) (measurableSet_singleton (d,b))
  have hprod (a : A) (b : B) : ((μ.map p).prod (μ.map q)).real {(a,b)}=mass μ p a*mass μ q b := by
    rw [←singleton_prod_singleton,Measure.real,Measure.prod_prod,ENNReal.toReal_mul]
    rw [←Measure.real,←Measure.real,map_measureReal_apply hp (measurableSet_singleton a),
      map_measureReal_apply hq (measurableSet_singleton b)]
    rfl
  have hprodC (d : C) (b : B) : ((μ.map (c ∘ p)).prod (μ.map q)).real {(d,b)}=
      mass μ (c ∘ p) d*mass μ q b := by
    rw [←singleton_prod_singleton,Measure.real,Measure.prod_prod,ENNReal.toReal_mul]
    rw [←Measure.real,←Measure.real,map_measureReal_apply hc (measurableSet_singleton d),
      map_measureReal_apply hq (measurableSet_singleton b)]
    rfl
  have hcoarse := finite_l1_le_two_of_lawClose _ _ hclose
  rw [Fintype.sum_prod_type] at hcoarse
  simp only [hmapC,hprodC] at hcoarse
  have hVP : (∑ ab : A×B,|v ab-mass μ p ab.1*mass μ q ab.2|)≤2*ε := by
    rw [Fintype.sum_prod_type]
    exact (refinement_distance_eq μ p q c hp hq).le.trans hcoarse
  apply lawClose_of_finite_l1
  rw [Fintype.sum_prod_type]
  simp only [hmap,hprod]
  rw [Fintype.sum_prod_type] at hUV hVP
  calc
    _≤∑ a,∑ b,(|u (a,b)-v (a,b)|+|v (a,b)-mass μ p a*mass μ q b|) :=
      Finset.sum_le_sum (fun a _ => Finset.sum_le_sum (fun b _ => abs_sub_le _ _ _))
    _=(∑ a,∑ b,|u (a,b)-v (a,b)|)+(∑ a,∑ b,|v (a,b)-mass μ p a*mass μ q b|) := by simp only [Finset.sum_add_distrib]
    _≤δ+2*ε := add_le_add hUV hVP

end StandardMapEntropy.Entropy

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

theorem uniform_remote_from_finite_entropy
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (k g L : ℕ) {ε δ : ℝ} (hδ : 0≤δ)
    (hclose : LawClose
      (μ.map (fun x => (word f p L (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word f p L (f^[k+g] x))).prod (μ.map (word f p k))) ε)
    (hdef : 4*(cond μ (word f p (k+g))
      (fun x => word f p L (f^[k+g] x))-(k+g : ℕ)*rate μ f p)≤δ^2) :
    ∀ M : ℕ,L≤M → LawClose
      (μ.map (fun x => (word f p M (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word f p M (f^[k+g] x))).prod (μ.map (word f p k))) (δ+2*ε) := by
  intro M hLM
  let rM : X → (Fin M → A) := fun x => word f p M (f^[k+g] x)
  let c : (Fin M → A) → (Fin L → A) := fun w i => w (Fin.castLE hLM i)
  let d : (Fin (k+g) → A) → (Fin k → A) := fun w i => w (Fin.castLE (Nat.le_add_right k g) i)
  have hrM : Measurable rM := (word_measurable f hf.measurable p hp M).comp (hf.measurable.iterate (k+g))
  have hc : c ∘ rM=(fun x => word f p L (f^[k+g] x)) := by funext x i; rfl
  have hd : d ∘ word f p (k+g)=word f p k := by funext x i; rfl
  have hdata := conditional_defect_data_processing μ rM (word f p (k+g)) c d
    hrM (word_measurable f hf.measurable p hp (k+g))
  rw [hd,hc] at hdata
  have hlower := rate_mul_le_cond_future μ f hf p hp (k+g) M
  have hdef' : 4*(cond μ (word f p k) (c ∘ rM)-cond μ (word f p k) rM)≤δ^2 := by
    rw [hc]
    change (k+g : ℕ)*rate μ f p≤cond μ (word f p (k+g)) rM at hlower
    linarith
  apply lawClose_of_coarse_independence μ rM (word f p k) c hrM
    (word_measurable f hf.measurable p hp k) hδ
  · exact hclose
  · exact hdef'

theorem eventually_finite_entropy_test
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (n : ℕ) {δ : ℝ} (hδ : 0<δ) :
    ∀ᶠ L : ℕ in atTop,4*(cond μ (word f p n)
      (fun x => word f p L (f^[n] x))-(n : ℝ)*rate μ f p)<δ^2 := by
  have ht := ((cond_future_tendsto μ f hf p hp n).sub_const ((n : ℝ)*rate μ f p)).const_mul 4
  have he : (4 : ℝ)*((n : ℝ)*rate μ f p-(n : ℝ)*rate μ f p)=0 := by ring
  rw [he] at ht
  exact ht.eventually (gt_mem_nhds (sq_pos_of_pos hδ))

end StandardMapEntropy.Entropy

end
section
namespace HyperbolicCoding
open MeasureTheory Set
open scoped ENNReal
variable {X Y A B : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [MeasurableSpace A] [MeasurableSpace B]

lemma independence_law_stable (μ : Measure X) (ν : Measure Y)
    [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (p : X → A) (q : X → B) (p' : Y → A) (q' : Y → B)
    (hp : Measurable p) (hq : Measurable q) (hp' : Measurable p') (hq' : Measurable q')
    {ε δ : ℝ}
    (h : LawClose (μ.map (fun x => (p x,q x))) (ν.map (fun y => (p' y,q' y))) δ)
    (hi : LawClose (μ.map (fun x => (p x,q x))) ((μ.map p).prod (μ.map q)) ε) :
    LawClose (ν.map (fun y => (p' y,q' y))) ((ν.map p').prod (ν.map q')) (ε+3*δ) := by
  have hleft := h.map measurable_fst
  have hright := h.map measurable_snd
  rw [Measure.map_map measurable_fst (hp.prodMk hq),Measure.map_map measurable_fst (hp'.prodMk hq')] at hleft
  rw [Measure.map_map measurable_snd (hp.prodMk hq),Measure.map_map measurable_snd (hp'.prodMk hq')] at hright
  change LawClose (μ.map p) (ν.map p') δ at hleft
  change LawClose (μ.map q) (ν.map q') δ at hright
  have : IsProbabilityMeasure (μ.map p) := inferInstance
  have : IsProbabilityMeasure (μ.map q) := inferInstance
  have : IsProbabilityMeasure (ν.map p') := inferInstance
  have : IsProbabilityMeasure (ν.map q') := inferInstance
  convert h.symm.triangle (hi.triangle (hleft.prod hright)) using 1; ring

end HyperbolicCoding

namespace StandardMapEntropy.Entropy
open MeasureTheory Set Filter HyperbolicCoding
open scoped ENNReal Topology
variable {X Y A : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
variable (μ : Measure X) [IsProbabilityMeasure μ]

omit [IsProbabilityMeasure μ] in
theorem finite_entropy_test_open (f : X → X) (hf : MeasurePreserving f μ μ)
    (p : X → A) (hp : Measurable p) (n L : ℕ) {r : ℝ}
    (hr : cond μ (word f p n) (fun x => word f p L (f^[n] x))-(n : ℝ)*rate μ f p<r) :
    ∃ δ : ℝ,0<δ ∧ ∀ (ν : Measure Y) (_ : IsProbabilityMeasure ν)
      (T : Y → Y) (_ : MeasurePreserving T ν ν) (q : Y → A),Measurable q →
      LawClose (μ.map (word f p (n+L))) (ν.map (word T q (n+L))) δ →
      rate μ f p-δ≤rate ν T q →
      cond ν (word T q n) (fun y => word T q L (T^[n] y))-(n : ℝ)*rate ν T q<r := by
  let D := cond μ (word f p n) (fun x => word f p L (f^[n] x))-(n : ℝ)*rate μ f p
  let γ := (r-D)/(2*((n : ℝ)+2))
  have hn : 0≤(n : ℝ) := Nat.cast_nonneg n
  have hγ : 0<γ := div_pos (sub_pos.mpr hr) (by positivity)
  obtain ⟨δW,hδW,hW⟩ := obs_continuity_in_law (Y:=Y) μ (word f p (n+L))
    (word_measurable f hf.measurable p hp (n+L)) hγ
  obtain ⟨δL,hδL,hL⟩ := obs_continuity_in_law (Y:=Y) μ (word f p L)
    (word_measurable f hf.measurable p hp L) hγ
  let δ := min γ (min δW δL)
  have hδ : 0<δ := lt_min hγ (lt_min hδW hδL)
  refine ⟨δ,hδ,?_⟩
  intro ν hν T hT q hq hclose hrate
  let : IsProbabilityMeasure ν := hν
  have hW' := hW ν (word T q (n+L)) (word_measurable T hT.measurable q hq (n+L))
    (hclose.mono ((min_le_right γ (min δW δL)).trans (min_le_left δW δL)))
  let c : (Fin (n+L) → A) → (Fin L → A) := fun w i => w (Fin.castLE (Nat.le_add_left L n) i)
  have hshort := hclose.map (measurable_of_countable c)
  rw [Measure.map_map (measurable_of_countable c) (word_measurable f hf.measurable p hp (n+L)),
    Measure.map_map (measurable_of_countable c) (word_measurable T hT.measurable q hq (n+L))] at hshort
  change LawClose (μ.map (word f p L)) (ν.map (word T q L)) δ at hshort
  have hL' := hL ν (word T q L) (word_measurable T hT.measurable q hq L)
    (hshort.mono ((min_le_right γ (min δW δL)).trans (min_le_right δW δL)))
  have hδγ : δ≤γ := min_le_left _ _
  have hmargin : ((n : ℝ)+2)*γ=(r-D)/2 := by dsimp [γ]; field_simp
  have hmul := mul_le_mul_of_nonneg_left (show rate μ f p-γ≤rate ν T q by linarith) hn
  obtain ⟨hWlo,hWhi⟩ := abs_lt.mp hW'
  obtain ⟨hLlo,hLhi⟩ := abs_lt.mp hL'
  rw [cond_word_future_eq ν T hT q hq]
  have hD : D=obs μ (word f p (n+L))-obs μ (word f p L)-(n : ℝ)*rate μ f p := by
    dsimp [D]
    rw [cond_word_future_eq μ f hf p hp]
  nlinarith

end StandardMapEntropy.Entropy

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

theorem all_remote_from_finite_entropy
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (k g L : ℕ) {ε δ : ℝ} (hδ : 0≤δ)
    (hclose : LawClose
      (μ.map (fun x => (word f p L (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word f p L (f^[k+g] x))).prod (μ.map (word f p k))) ε)
    (hdef : 4*(cond μ (word f p (k+g))
      (fun x => word f p L (f^[k+g] x))-(k+g : ℕ)*rate μ f p)≤δ^2) :
    ∀ M : ℕ,LawClose
      (μ.map (fun x => (word f p M (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word f p M (f^[k+g] x))).prod (μ.map (word f p k))) (δ+2*ε) := by
  intro M
  by_cases hLM : L≤M
  · exact uniform_remote_from_finite_entropy μ f hf p hp k g L hδ hclose hdef M hLM
  · have hML : M≤L := by omega
    let c : (Fin L → A) → (Fin M → A) := fun w i => w (Fin.castLE hML i)
    have h := lawClose_pair_factor_left μ (fun x => word f p L (f^[k+g] x))
      (word f p k) c ((word_measurable f hf.measurable p hp L).comp (hf.measurable.iterate (k+g)))
      (word_measurable f hf.measurable p hp k) (measurable_of_countable c) hclose
    have hε : 0≤ε := hclose.nonneg
    exact h.mono (by linarith)

end StandardMapEntropy.Entropy

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

lemma lawClose_prefix {X Y A : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) (ν : Measure Y) (f : X → X) (T : Y → Y)
    (hf : Measurable f) (hT : Measurable T) (p : X → A) (q : Y → A)
    (hp : Measurable p) (hq : Measurable q) {m n : ℕ} (hmn : m≤n) {δ : ℝ}
    (h : LawClose (μ.map (word f p n)) (ν.map (word T q n)) δ) :
    LawClose (μ.map (word f p m)) (ν.map (word T q m)) δ := by
  let c : (Fin n → A) → (Fin m → A) := fun w i => w (Fin.castLE hmn i)
  have hc : Measurable c := measurable_of_countable c
  have hh := h.map hc
  rw [Measure.map_map hc (word_measurable f hf p hp n),
    Measure.map_map hc (word_measurable T hT q hq n)] at hh
  exact hh

lemma lawClose_remote_of_word {X Y A : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) (ν : Measure Y) (f : X → X) (T : Y → Y)
    (hf : Measurable f) (hT : Measurable T) (p : X → A) (q : Y → A)
    (hp : Measurable p) (hq : Measurable q) (k g L : ℕ) {δ : ℝ}
    (h : LawClose (μ.map (word f p ((k+g)+L))) (ν.map (word T q ((k+g)+L))) δ) :
    LawClose (μ.map (fun x => (word f p L (f^[k+g] x),word f p k x)))
      (ν.map (fun x => (word T q L (T^[k+g] x),word T q k x))) δ := by
  let c : (Fin ((k+g)+L) → A) → ((Fin L → A)×(Fin k → A)) :=
    fun w => (fun i => w ⟨i.val+(k+g),by omega⟩,fun i => w ⟨i.val,by omega⟩)
  have hc : Measurable c := measurable_of_countable c
  have hh := h.map hc
  rw [Measure.map_map hc (word_measurable f hf p hp _),
    Measure.map_map hc (word_measurable T hT q hq _)] at hh
  have he (x : X) : c (word f p ((k+g)+L) x)=(word f p L (f^[k+g] x),word f p k x) := by
    apply Prod.ext
    · funext i
      exact congrArg p (Function.iterate_add_apply f i.val (k+g) x)
    · rfl
  have he' (y : Y) : c (word T q ((k+g)+L) y)=(word T q L (T^[k+g] y),word T q k y) := by
    apply Prod.ext
    · funext i
      exact congrArg q (Function.iterate_add_apply T i.val (k+g) y)
    · rfl
  simpa only [Function.comp_def,he,he'] using hh

theorem weakBernoulli_finite_determination {X Y A : Type*}
    [MeasurableSpace X] [StandardBorelSpace X] [MeasurableSpace Y] [StandardBorelSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A] [Nonempty A]
    (μ : Measure X) [IsProbabilityMeasure μ] [NullSingletonClass μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ) (p : X → A) (hp : Measurable p)
    (hwb : WeakBernoulliProcess μ e p) {η : ℝ} (hη : 0<η) :
    ∃ m s : ℕ,0<s ∧ ∃ δ : ℝ,0<δ ∧
      ∀ (ν : Measure Y) (_ : IsProbabilityMeasure ν) (_ : NullSingletonClass ν)
        (T : Y → Y) (_ : MeasurePreserving T ν ν) (q : Y → A),Measurable q →
        LawClose (μ.map (word e p m)) (ν.map (word T q m)) δ →
        rate μ e p-δ≤rate ν T q →
        ∀ n : ℕ,∃ R : MatrixCoupling (mass μ (word e p (n*s))) (mass ν (word T q (n*s))),
          R.cost nameCost≤η*(n*s : ℕ) := by
  let ε : ℝ := η/100
  have hε : 0<ε := div_pos hη (by norm_num)
  obtain ⟨g,hg⟩ := weakBernoulli_forward_blocks μ e he p hp hwb hε
  obtain ⟨k,hk⟩ := exists_nat_gt ((g : ℝ)/ε+1)
  have hkpos : 0<k := by
    have hg0 : 0≤(g : ℝ)/ε := div_nonneg (Nat.cast_nonneg g) hε.le
    have hkR : 0<(k : ℝ) := by linarith
    exact_mod_cast hkR
  have hkg : (g : ℝ)≤ε*(k : ℝ) := by
    have hh := (div_lt_iff₀ hε).mp (show (g : ℝ)/ε<(k : ℝ) by linarith)
    nlinarith
  obtain ⟨L,hL⟩ := (eventually_finite_entropy_test μ e he p hp (k+g) hε).exists
  obtain ⟨δ₀,hδ₀,hopen⟩ := finite_entropy_test_open (Y:=Y) μ e he p hp (k+g) L
    (r:=ε^2/4) (by linarith)
  let δ := min ε δ₀
  have hδ : 0<δ := lt_min hε hδ₀
  refine ⟨(k+g)+L,k+g,by omega,δ,hδ,?_⟩
  intro ν hν hnonatomic T hT q hq hclose hrate n
  let : IsProbabilityMeasure ν := hν
  let : NullSingletonClass ν := hnonatomic
  have hdε : δ≤ε := min_le_left _ _
  have hd₀ : δ≤δ₀ := min_le_right _ _
  have hd := hopen ν hν T hT q hq (hclose.mono hd₀) (by linarith)
  have hj := lawClose_remote_of_word μ ν e T he.measurable hT.measurable p q hp hq k g L hclose
  have hfinite := independence_law_stable μ ν
    (fun x => word e p L (e^[k+g] x)) (word e p k)
    (fun y => word T q L (T^[k+g] y)) (word T q k)
    ((word_measurable e he.measurable p hp L).comp (he.measurable.iterate _))
    (word_measurable e he.measurable p hp k)
    ((word_measurable T hT.measurable q hq L).comp (hT.measurable.iterate _))
    (word_measurable T hT.measurable q hq k) hj (hg k L)
  have hremoteQ := all_remote_from_finite_entropy ν T hT q hq k g L hε.le hfinite
    (show 4*(cond ν (word T q (k+g)) (fun y => word T q L (T^[k+g] y))-
      (k+g : ℕ)*rate ν T q)≤ε^2 by linarith)
  have hshort := lawClose_prefix μ ν e T he.measurable hT.measurable p q hp hq
    (show k≤(k+g)+L by omega) hclose
  obtain ⟨R,hR⟩ := full_word_transport μ ν e he p hp T hT q hq k g (hg k) hremoteQ hshort n
  refine ⟨R,hR.trans ?_⟩
  have hb : (k : ℝ)*(ε+δ+(ε+2*(ε+3*δ)))+(g : ℝ)≤η*(k+g : ℕ) := by
    have hk0 : 0≤(k : ℝ) := Nat.cast_nonneg k
    have hg0 : 0≤(g : ℝ) := Nat.cast_nonneg g
    have hsmall : ε+δ+(ε+2*(ε+3*δ))≤11*ε := by linarith
    have hh := mul_le_mul_of_nonneg_left hsmall hk0
    have hηε : η=100*ε := by dsimp [ε]; ring
    push_cast
    rw [hηε]
    nlinarith [mul_nonneg hε.le hk0,mul_nonneg hε.le hg0]
  have hn := mul_le_mul_of_nonneg_left hb (Nat.cast_nonneg n)
  push_cast at hn ⊢
  nlinarith

end HyperbolicCoding

end
end

end OAI