import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Coupling.CoarseConditionalBudget

namespace OAI

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

lemma conditional_entropy_law_test [Fintype B] [MeasurableSingletonClass B]
    (μ : Measure X) (p : X → A) (r : X → B)
    (hp : Measurable p) (hr : Measurable r) {ε : ℝ} (hε : 0<ε) :
    ∃ δ : ℝ,0<δ ∧ ∀ (ν : Measure Y) (q : Y → A) (s : Y → B),
      Measurable q → Measurable s →
      LawClose (μ.map (fun x => (p x,r x))) (ν.map (fun y => (q y,s y))) δ →
      |StandardMapEntropy.Entropy.cond μ p r-StandardMapEntropy.Entropy.cond ν q s|<ε := by
  obtain ⟨δ₁,hδ₁,h₁⟩ := obs_continuity_in_law (Y:=Y) μ (fun x => (p x,r x)) (hp.prodMk hr)
    (show 0<ε/2 by positivity)
  obtain ⟨δ₂,hδ₂,h₂⟩ := obs_continuity_in_law (Y:=Y) μ r hr (show 0<ε/2 by positivity)
  refine ⟨min δ₁ δ₂,lt_min hδ₁ hδ₂,?_⟩
  intro ν q s hq hs hlaw
  have hm := hlaw.map measurable_snd
  rw [Measure.map_map measurable_snd (hp.prodMk hr),
    Measure.map_map measurable_snd (hq.prodMk hs)] at hm
  have hh₁ := h₁ ν (fun y => (q y,s y)) (hq.prodMk hs) (hlaw.mono (min_le_left _ _))
  have hh₂ := h₂ ν s hs (hm.mono (min_le_right _ _))
  unfold StandardMapEntropy.Entropy.cond
  have he : obs μ (fun x => (p x,r x))-obs μ r-
      (obs ν (fun y => (q y,s y))-obs ν s)=
      (obs μ (fun x => (p x,r x))-obs ν (fun y => (q y,s y)))-(obs μ r-obs ν s) := by ring
  rw [he]
  exact (abs_sub _ _).trans_lt (by linarith)

lemma conditional_entropy_law_test_uniform [Fintype B] [MeasurableSingletonClass B]
    (μ : Measure X) (p : X → A) (r : X → B)
    (hp : Measurable p) (hr : Measurable r) {ε : ℝ} (hε : 0<ε) :
    ∃ δ : ℝ,0<δ ∧ ∀ (Y : Type u) [MeasurableSpace Y] (ν : Measure Y)
      (q : Y → A) (s : Y → B),Measurable q → Measurable s →
      LawClose (μ.map (fun x => (p x,r x))) (ν.map (fun y => (q y,s y))) δ →
      |StandardMapEntropy.Entropy.cond μ p r-StandardMapEntropy.Entropy.cond ν q s|<ε := by
  obtain ⟨δ₁,hδ₁,h₁⟩ := finite_entropy_continuity (μ.map (fun x => (p x,r x)))
    (show 0<ε/2 by positivity)
  obtain ⟨δ₂,hδ₂,h₂⟩ := finite_entropy_continuity (μ.map r) (show 0<ε/2 by positivity)
  refine ⟨min δ₁ δ₂,lt_min hδ₁ hδ₂,?_⟩
  intro Y mY ν q s hq hs hlaw
  have hm := hlaw.map measurable_snd
  rw [Measure.map_map measurable_snd (hp.prodMk hr),
    Measure.map_map measurable_snd (hq.prodMk hs)] at hm
  have hh₁ := h₁ (ν.map (fun y => (q y,s y))) (hlaw.mono (min_le_left _ _))
  have hh₂ := h₂ (ν.map s) (hm.mono (min_le_right _ _))
  rw [←obs_eq_entropy_map μ (fun x => (p x,r x)) (hp.prodMk hr),
    ←obs_eq_entropy_map ν (fun y => (q y,s y)) (hq.prodMk hs)] at hh₁
  rw [←obs_eq_entropy_map μ r hr,←obs_eq_entropy_map ν s hs] at hh₂
  unfold StandardMapEntropy.Entropy.cond
  have he : obs μ (fun x => (p x,r x))-obs μ r-
      (obs ν (fun y => (q y,s y))-obs ν s)=
      (obs μ (fun x => (p x,r x))-obs ν (fun y => (q y,s y)))-(obs μ r-obs ν s) := by ring
  rw [he]
  exact (abs_sub _ _).trans_lt (by linarith)

lemma marginal_joint_test [Fintype B] [MeasurableSingletonClass B]
    [Fintype D] [MeasurableSingletonClass D] (μ : Measure X) (ν : Measure Y)
    (p : X → A) (r : X → B) (q : Y → A) (s : Y → B)
    (hp : Measurable p) (hr : Measurable r) (hq : Measurable q) (hs : Measurable s)
    (d : A → D) {δ : ℝ}
    (hlaw : LawClose (μ.map (fun x => (p x,r x))) (ν.map (fun y => (q y,s y))) δ) :
    LawClose (μ.map (d ∘ p)) (ν.map (d ∘ q)) δ := by
  have hd : Measurable (fun z : A×B => d z.1) := (measurable_of_countable d).comp measurable_fst
  have hh := hlaw.map hd
  simpa only [Measure.map_map hd (hp.prodMk hr),Measure.map_map hd (hq.prodMk hs),Function.comp_def] using hh

lemma independence_joint_test [Fintype B] [MeasurableSingletonClass B]
    [Fintype D] [MeasurableSingletonClass D] (μ : Measure X) (ν : Measure Y)
    [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (p : X → A) (r : X → B) (q : Y → A) (s : Y → B)
    (hp : Measurable p) (hr : Measurable r) (hq : Measurable q) (hs : Measurable s)
    (d : A → D) {δ ε : ℝ}
    (hlaw : LawClose (μ.map (fun x => (p x,r x))) (ν.map (fun y => (q y,s y))) δ)
    (hremote : LawClose (μ.map (fun x => (r x,d (p x))))
      ((μ.map r).prod (μ.map (d ∘ p))) ε) :
    LawClose (ν.map (fun y => (s y,d (q y)))) ((ν.map s).prod (ν.map (d ∘ q))) (ε+3*δ) := by
  have hd : Measurable (fun z : A×B => (z.2,d z.1)) :=
    measurable_snd.prodMk ((measurable_of_countable d).comp measurable_fst)
  have hh := hlaw.map hd
  rw [Measure.map_map hd (hp.prodMk hr),Measure.map_map hd (hq.prodMk hs)] at hh
  exact independence_law_stable μ ν r (d ∘ p) s (d ∘ q) hr
    ((measurable_of_countable d).comp hp) hs ((measurable_of_countable d).comp hq) hh hremote
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set StandardMapEntropy.Entropy
open scoped BigOperators ENNReal
variable {Y A B : Type*} [Nonempty A]

lemma wordPack_apply_coord {A : Type*} (n s : ℕ) (w : Fin (n*s) → A)
    (i : Fin n) (a : Fin s) : wordPack n s w i a=w (finProdFinEquiv (i,a)) := rfl

lemma wordPack_symm_coord {A : Type*} (n s : ℕ) (w : Fin n → Fin s → A)
    (i : Fin n) (a : Fin s) : (wordPack n s).symm w (finProdFinEquiv (i,a))=w i a := by
  have hh := congrFun (congrFun ((wordPack n s).apply_symm_apply w) i) a
  exact hh

lemma fullBlock_packed [MeasurableSpace Y] [StandardBorelSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (s n : ℕ) (V : Y → Fin n → Fin s → A) (i : Fin n) :
    fullBlock s n (fun x => (wordPack n s).symm (V x)) i.val=fun x => V x i := by
  funext x
  simp only [fullBlock,i.isLt,dite_true,Equiv.apply_symm_apply]

def suffixPrefix (n L i : ℕ) (h : i+L<n) (w : Fin (n-i-1) → B) : Fin L → B :=
  fun a => w ⟨a.val,by omega⟩

def vectorFuture (n L i : ℕ) (h : i+L<n) (w : Fin n → B) : Fin L → B :=
  fun a => w ⟨i+1+a.val,by omega⟩

lemma fullBlock_local_future [MeasurableSpace Y] [StandardBorelSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (s n L i : ℕ) (h : i+L<n)
    (V : Y → Fin n → Fin s → A) :
    suffixPrefix n L i h ∘ finiteName (fullBlock s n (fun x => (wordPack n s).symm (V x)))
      (i+1) (n-i-1)=vectorFuture n L i h ∘ V := by
  funext x a
  simp only [Function.comp_apply,suffixPrefix,finiteName,vectorFuture,fullBlock]
  have hi : i+1+a.val<n := by omega
  simp only [hi,dite_true,Equiv.apply_symm_apply]

lemma block_inner_future_lt (M J L : ℕ) (I : Fin M) (j : Fin J) (hj : j.val+L<J) :
    (finProdFinEquiv (I,j)).val+L<M*J := by
  have hm := Nat.mul_le_mul_right J I.isLt
  change j.val+J*I.val+L<M*J
  nlinarith

lemma vectorFuture_inside_block (M J L : ℕ) (I : Fin M) (j : Fin J) (hj : j.val+L<J)
    (V : Fin M → Fin J → B) :
    vectorFuture (M*J) L (finProdFinEquiv (I,j)).val (block_inner_future_lt M J L I j hj)
      ((wordPack M J).symm V)=vectorFuture J L j.val hj (V I) := by
  funext a
  unfold vectorFuture
  have he : (⟨(finProdFinEquiv (I,j)).val+1+a.val,by
      have hh := block_inner_future_lt M J L I j hj
      omega⟩ : Fin (M*J))=finProdFinEquiv (I,⟨j.val+1+a.val,by omega⟩) := by
    apply Fin.ext
    dsimp [finProdFinEquiv]
    ring
  rw [he,wordPack_symm_coord]

lemma word_vectorFuture [MeasurableSpace Y] [StandardBorelSpace Y]
    (f : Y → Y) (p : Y → B) (J L : ℕ) (j : Fin J) (hj : j.val+L<J) :
    vectorFuture J L j.val hj ∘ word f p J=fun x => word f p L (f^[j.val+1] x) := by
  funext x a
  simp only [Function.comp_apply,vectorFuture,word]
  rw [←Function.iterate_add_apply]
  congr 2
  omega

lemma nameCost_wordPack {A : Type*} (n s : ℕ) (v w : Fin (n*s) → A) :
    nameCost v w=∑ i : Fin n,nameCost (wordPack n s v i) (wordPack n s w i) := by
  rw [nameCost,←Equiv.sum_comp finProdFinEquiv (fun i => symbolCost (v i) (w i)),Fintype.sum_prod_type]
  rfl

lemma fullBlock_nested_head [MeasurableSpace Y] [StandardBorelSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (M J s : ℕ) (V : Y → Fin M → Fin J → Fin s → A)
    (I : Fin M) (j : Fin J) :
    fullBlock s (M*J) (fun x => (wordPack (M*J) s).symm ((wordPack M J).symm (V x)))
      (finProdFinEquiv (I,j)).val=fun x => V x I j := by
  rw [fullBlock_packed]
  funext x a
  exact congrFun (wordPack_symm_coord M J (V x) I j) a

lemma fullBlock_nested_future [MeasurableSpace Y] [StandardBorelSpace Y]
    [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (M J s L : ℕ) (V : Y → Fin M → Fin J → Fin s → A)
    (I : Fin M) (j : Fin J) (hj : j.val+L<J) :
    suffixPrefix (M*J) L (finProdFinEquiv (I,j)).val (block_inner_future_lt M J L I j hj) ∘
      finiteName (fullBlock s (M*J) (fun x => (wordPack (M*J) s).symm ((wordPack M J).symm (V x))))
        ((finProdFinEquiv (I,j)).val+1) (M*J-(finProdFinEquiv (I,j)).val-1)=
      fun x => vectorFuture J L j.val hj (V x I) := by
  rw [fullBlock_local_future]
  funext x
  exact vectorFuture_inside_block M J L I j hj (V x)
end HyperbolicCoding

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

lemma map_word_coordinate [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) (f : X → X) (hf : MeasurePreserving f μ μ)
    (p : X → A) (hp : Measurable p) (J : ℕ) (j : Fin J) :
    μ.map (fun x => word f p J x j)=μ.map p := by
  change μ.map (p ∘ f^[j.val])=μ.map p
  rw [←Measure.map_map hp (hf.measurable.iterate _),(hf.iterate j.val).map_eq]

lemma map_word_head_future [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) (f : X → X) (hf : MeasurePreserving f μ μ)
    (p : X → A) (hp : Measurable p) (J L : ℕ) (j : Fin J) (hj : j.val+L<J) :
    μ.map (fun x => (word f p J x j,vectorFuture J L j.val hj (word f p J x)))=
      μ.map (fun x => (p x,word f p L (f x))) := by
  have hF : Measurable (fun x => (p x,word f p L (f x))) :=
    hp.prodMk ((word_measurable f hf.measurable p hp L).comp hf.measurable)
  have he : (fun x => (word f p J x j,vectorFuture J L j.val hj (word f p J x)))=
      (fun x => (p x,word f p L (f x))) ∘ f^[j.val] := by
    funext x
    apply Prod.ext
    · rfl
    · funext a
      simp only [vectorFuture,word,Function.comp_apply]
      rw [←Function.iterate_succ_apply' f j.val x,←Function.iterate_add_apply]
      congr 2
      omega
  rw [he,←Measure.map_map hF (hf.measurable.iterate _),(hf.iterate j.val).map_eq]

lemma block_law_head_test [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) (ν : Measure Y)
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (J : ℕ) (V : Y → Fin J → A) (hV : Measurable V) {δ : ℝ}
    (hlaw : LawClose (μ.map (word f p J)) (ν.map V) δ) (j : Fin J) :
    LawClose (μ.map p) (ν.map (fun y => V y j)) δ := by
  have hh := hlaw.map (measurable_pi_apply j)
  rw [Measure.map_map (measurable_pi_apply j) (word_measurable f hf.measurable p hp J),
    Measure.map_map (measurable_pi_apply j) hV] at hh
  change LawClose (μ.map (fun x => word f p J x j)) (ν.map (fun y => V y j)) δ at hh
  rw [map_word_coordinate μ f hf p hp J j] at hh
  exact hh

lemma block_law_local_test [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) (ν : Measure Y)
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (J L : ℕ) (V : Y → Fin J → A) (hV : Measurable V) {δ : ℝ}
    (hlaw : LawClose (μ.map (word f p J)) (ν.map V) δ)
    (j : Fin J) (hj : j.val+L<J) :
    LawClose (μ.map (fun x => (p x,word f p L (f x))))
      (ν.map (fun y => (V y j,vectorFuture J L j.val hj (V y)))) δ := by
  let d : (Fin J → A) → A×(Fin L → A) := fun w => (w j,vectorFuture J L j.val hj w)
  have hd : Measurable d := measurable_of_countable d
  have hh := hlaw.map hd
  rw [Measure.map_map hd (word_measurable f hf.measurable p hp J),Measure.map_map hd hV] at hh
  change LawClose (μ.map (fun x => (word f p J x j,vectorFuture J L j.val hj (word f p J x)))) _ _ at hh
  rw [map_word_head_future μ f hf p hp J L j hj] at hh
  exact hh

lemma eventually_conditional_single_test [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) [IsProbabilityMeasure μ]
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    {ε : ℝ} (hε : 0<ε) :
    ∀ᶠ L : ℕ in atTop,StandardMapEntropy.Entropy.cond μ p
      (fun x => word f p L (f x))<rate μ f p+ε := by
  have hh := (entropy_increment_tendsto μ f hf p hp).eventually
    (gt_mem_nhds (show rate μ f p<rate μ f p+ε by linarith))
  simpa only [entropy_increment_eq μ f hf p hp] using hh

lemma remote_law_as_blocks [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) [IsProbabilityMeasure μ]
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (k g L : ℕ) {ρ : ℝ}
    (hremote : LawClose (μ.map (fun x => (word f p (L*(k+g)) (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word f p (L*(k+g)) (f^[k+g] x))).prod (μ.map (word f p k))) ρ) :
    LawClose (μ.map (fun x => (word (f^[k+g]) (word f p (k+g)) L (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word (f^[k+g]) (word f p (k+g)) L (f^[k+g] x))).prod
        (μ.map (word f p k))) ρ := by
  have hh := lawClose_pair_factor_left μ (fun x => word f p (L*(k+g)) (f^[k+g] x))
    (word f p k) (wordPack L (k+g))
    ((word_measurable f hf.measurable p hp _).comp (hf.measurable.iterate _))
    (word_measurable f hf.measurable p hp k) (measurable_of_countable _) hremote
  simpa only [Function.comp_def,wordPack_apply] using hh
end HyperbolicCoding

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

lemma lawClose_one (μ ν : Measure Y) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] :
    LawClose μ ν 1 := by
  intro D _
  apply abs_le.mpr
  constructor <;> linarith [measureReal_nonneg (μ:=μ) (s:=D),measureReal_nonneg (μ:=ν) (s:=D),
    measureReal_le_one (μ:=μ) (s:=D),measureReal_le_one (μ:=ν) (s:=D)]

noncomputable def insideCoarse [Nonempty B] (M J L : ℕ) (i : Fin (M*J))
    (w : Fin (M*J-i.val-1) → B) : Fin L → B :=
  if h : (finProdFinEquiv.symm i).2.val+L<J then
    suffixPrefix (M*J) L i.val (by
      have hh := block_inner_future_lt M J L (finProdFinEquiv.symm i).1
        (finProdFinEquiv.symm i).2 h
      simpa only [Prod.mk.eta,Equiv.apply_symm_apply] using hh) w
  else fun _ => Classical.ofNonempty

noncomputable def extendedCoarse [Nonempty B] (M J L i : ℕ)
    (w : Fin (M*J-i-1) → B) : Fin L → B :=
  if hi : i<M*J then insideCoarse M J L ⟨i,hi⟩ w else fun _ => Classical.ofNonempty

lemma extendedCoarse_at [Nonempty B] (M J L : ℕ) (i : Fin (M*J)) :
    extendedCoarse (B:=B) M J L i.val=insideCoarse M J L i := by
  funext w
  simp only [extendedCoarse,i.isLt,dite_true]

lemma insideCoarse_good [Nonempty B] (M J L : ℕ) (I : Fin M) (j : Fin J) (hj : j.val+L<J) :
    insideCoarse (B:=B) M J L (finProdFinEquiv (I,j))=
      suffixPrefix (M*J) L (finProdFinEquiv (I,j)).val (block_inner_future_lt M J L I j hj) := by
  funext w
  simp only [insideCoarse,Equiv.symm_apply_apply,hj,dite_true]

lemma insideCoarse_bad [Nonempty B] (M J L : ℕ) (I : Fin M) (j : Fin J) (hj : ¬j.val+L<J) :
    insideCoarse (B:=B) M J L (finProdFinEquiv (I,j))=fun _ _ => Classical.ofNonempty := by
  funext w
  simp only [insideCoarse,Equiv.symm_apply_apply,hj,dite_false]

noncomputable def boundaryLoss (M J L : ℕ) (i : Fin (M*J)) : ℝ :=
  if (finProdFinEquiv.symm i).2.val+L<J then 0 else 1

lemma boundaryLoss_nonneg (M J L : ℕ) (i : Fin (M*J)) : 0≤boundaryLoss M J L i := by
  unfold boundaryLoss
  split_ifs <;> norm_num

lemma boundary_count_le (J L : ℕ) :
    (∑ j : Fin J,if j.val+L<J then (0 : ℝ) else 1)≤(L : ℝ) := by
  classical
  let S : Finset (Fin J) := Finset.univ.filter (fun j => ¬j.val+L<J)
  let F : S → Fin L := fun j => ⟨j.val.val+L-J,by
    have hj : ¬j.val.val+L<J := (Finset.mem_filter.mp j.property).2
    have hJ := j.val.isLt
    omega⟩
  have hF : Function.Injective F := by
    intro i j hij
    have hi : ¬i.val.val+L<J := (Finset.mem_filter.mp i.property).2
    have hj : ¬j.val.val+L<J := (Finset.mem_filter.mp j.property).2
    have he := congrArg Fin.val hij
    apply Subtype.ext
    apply Fin.ext
    dsimp [F] at he
    omega
  have hcard : S.card≤L := by
    simpa using Fintype.card_le_of_injective F hF
  have he : (∑ j : Fin J,if j.val+L<J then (0 : ℝ) else 1)=(S.card : ℝ) := by
    dsimp [S]
    rw [←Finset.sum_boole]
    apply Finset.sum_congr rfl
    intro j _
    split_ifs <;> simp_all
  rw [he]
  exact_mod_cast hcard

lemma boundaryLoss_sum_le (M J L : ℕ) :
    (∑ i : Fin (M*J),boundaryLoss M J L i)≤(M*L : ℕ) := by
  rw [←Equiv.sum_comp finProdFinEquiv (boundaryLoss M J L),Fintype.sum_prod_type]
  simp only [boundaryLoss,Equiv.symm_apply_apply]
  calc
    _≤∑ _I : Fin M,(L : ℝ) := Finset.sum_le_sum (fun _ _ => boundary_count_le J L)
    _=_ := by simp
end HyperbolicCoding

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

noncomputable def nestedOutput (M J s : ℕ) (V : Y → Fin M → Fin J → Fin s → A)
    (y : Y) : Fin ((M*J)*s) → A :=
  (wordPack (M*J) s).symm ((wordPack M J).symm (V y))

lemma nestedOutput_measurable [StandardBorelSpace Y] [Nonempty A]
    (M J s : ℕ) (V : Y → Fin M → Fin J → Fin s → A)
    (hV : Measurable V) : Measurable (nestedOutput M J s V) :=
  (measurable_of_countable (fun v => (wordPack (M*J) s).symm ((wordPack M J).symm v))).comp hV

lemma nestedOutput_head [StandardBorelSpace Y] [Nonempty A]
    (M J s : ℕ) (V : Y → Fin M → Fin J → Fin s → A)
    (I : Fin M) (j : Fin J) :
    fullBlock s (M*J) (nestedOutput M J s V) (finProdFinEquiv (I,j)).val=fun x => V x I j :=
  fullBlock_nested_head M J s V I j

lemma nestedOutput_future [StandardBorelSpace Y] [Nonempty A]
    (M J s L : ℕ) (V : Y → Fin M → Fin J → Fin s → A)
    (I : Fin M) (j : Fin J) (hj : j.val+L<J) :
    extendedCoarse (B:=Fin s → A) M J L (finProdFinEquiv (I,j)).val ∘
      finiteName (fullBlock s (M*J) (nestedOutput M J s V))
        ((finProdFinEquiv (I,j)).val+1) (M*J-(finProdFinEquiv (I,j)).val-1)=
      fun x => vectorFuture J L j.val hj (V x I) := by
  rw [extendedCoarse_at,insideCoarse_good M J L I j hj]
  exact fullBlock_nested_future M J s L V I j hj

theorem block_recoding_word_transport [StandardBorelSpace Y] [Nonempty A]
    (μ : Measure X) (ν : Measure Y) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    [NullSingletonClass μ]
    (f : X → X) (hf : MeasurePreserving f μ μ) (p : X → A) (hp : Measurable p)
    (k g L M J : ℕ) (V : Y → Fin M → Fin J → Fin (k+g) → A) (hV : Measurable V)
    {ρ τ δ H : ℝ} (hρ : 0≤ρ) (hτ : 0<τ) (hδ : 0≤δ) (hH : 0≤H)
    (hP : ∀ T : ℕ,LawClose
      (μ.map (fun x => (word f p T (f^[k+g] x),word f p k x)))
      ((μ.map (fun x => word f p T (f^[k+g] x))).prod (μ.map (word f p k))) ρ)
    (hlaw : ∀ I : Fin M,LawClose
      (μ.map (word (f^[k+g]) (word f p (k+g)) J)) (ν.map (fun y => V y I)) δ)
    (htest : ∀ (q : Y → Fin (k+g) → A) (r : Y → Fin L → Fin (k+g) → A),
      Measurable q → Measurable r →
      LawClose (μ.map (fun x => (word f p (k+g) x,
        word (f^[k+g]) (word f p (k+g)) L (f^[k+g] x))))
        (ν.map (fun y => (q y,r y))) δ → StandardMapEntropy.Entropy.cond ν q r≤H) :
    ∃ R : MatrixCoupling (mass μ (word f p ((M*J)*(k+g))))
        (mass ν (nestedOutput M J (k+g) V)),
      R.cost nameCost≤(k : ℝ)*((M*J : ℕ)*(3*ρ+τ+7*δ)+2*(M*L : ℕ)+
        (((M*J : ℕ)*H+(M*L : ℕ)*Real.log (Fintype.card (Fin (k+g) → A)))-
          obs ν (nestedOutput M J (k+g) V))/τ)+(M*J*g : ℕ) := by
  classical
  let q := nestedOutput M J (k+g) V
  have hq : Measurable q := nestedOutput_measurable M J (k+g) V hV
  let c := extendedCoarse (B:=Fin (k+g) → A) M J L
  let ε : ℕ → ℝ := fun i => ρ+3*δ+if hi : i<M*J then boundaryLoss M J L ⟨i,hi⟩ else 0
  have he (i : Fin (M*J)) : ε i.val=ρ+3*δ+boundaryLoss M J L i := by
    simp only [ε,i.isLt,dite_true]
  let d : (Fin (k+g) → A) → Fin k → A := fun w a => w (a.castAdd g)
  have hd : Measurable d := measurable_of_countable d
  have hw := word_measurable f hf.measurable p hp (k+g)
  have hpref : d ∘ word f p (k+g)=word f p k := by funext x a; rfl
  have hpref' (x : X) : d (word f p (k+g) x)=word f p k x := congrFun hpref x
  have hhead (i : Fin (M*J)) : LawClose (μ.map (word f p k))
      (ν.map (d ∘ fullBlock (k+g) (M*J) q i.val)) δ := by
    obtain ⟨⟨I,j⟩,rfl⟩ := finProdFinEquiv.surjective i
    have hh := block_law_head_test μ ν (f^[k+g]) (hf.iterate _) (word f p (k+g)) hw J
      (fun y => V y I) ((measurable_pi_apply I).comp hV) (hlaw I) j
    have hh' := hh.map hd
    have hvij : Measurable (fun y => V y I j) :=
      (measurable_pi_apply j).comp ((measurable_pi_apply I).comp hV)
    rw [Measure.map_map hd hw,Measure.map_map hd hvij,hpref] at hh'
    simpa only [q,nestedOutput_head] using hh'
  have hremote := remote_law_as_blocks μ f hf p hp k g L (hP (L*(k+g)))
  have hpair (I : Fin M) (j : Fin J) (hj : j.val+L<J) :=
    block_law_local_test μ ν (f^[k+g]) (hf.iterate _) (word f p (k+g)) hw J L
      (fun y => V y I) ((measurable_pi_apply I).comp hV) (hlaw I) j hj
  have hlocal (i : ℕ) (hi : i<M*J) : LawClose
      (ν.map (fun x => (c i (finiteName (fullBlock (k+g) (M*J) q) (i+1) (M*J-i-1) x),
        d (fullBlock (k+g) (M*J) q i x))))
      ((ν.map (c i ∘ finiteName (fullBlock (k+g) (M*J) q) (i+1) (M*J-i-1))).prod
        (ν.map (d ∘ fullBlock (k+g) (M*J) q i))) (ε i) := by
    let a : Fin (M*J) := ⟨i,hi⟩
    change LawClose _ _ (ε a.val)
    rw [he]
    obtain ⟨⟨I,j⟩,ha⟩ := finProdFinEquiv.surjective a
    have hiv : i=(finProdFinEquiv (I,j)).val := congrArg Fin.val ha.symm
    subst i
    by_cases hj : j.val+L<J
    · have hh := independence_joint_test μ ν (word f p (k+g))
        (fun x => word (f^[k+g]) (word f p (k+g)) L (f^[k+g] x))
        (fun y => V y I j) (fun y => vectorFuture J L j.val hj (V y I)) hw
        ((word_measurable (f^[k+g]) (hf.measurable.iterate _) (word f p (k+g)) hw L).comp
          (hf.measurable.iterate _))
        ((measurable_pi_apply j).comp ((measurable_pi_apply I).comp hV))
        ((measurable_of_countable (vectorFuture J L j.val hj)).comp ((measurable_pi_apply I).comp hV)) d (hpair I j hj)
        (by simpa only [hpref,hpref'] using hremote)
      have hb : boundaryLoss M J L a=0 := by rw [←ha]; simp only [boundaryLoss,Equiv.symm_apply_apply,hj,ite_true]
      rw [hb,add_zero]
      change LawClose (ν.map (fun x => ((c _ ∘ _) x,d (fullBlock _ _ q _ x)))) _ _
      simpa only [c,q,nestedOutput_future M J (k+g) L V I j hj,nestedOutput_head]
        using hh
    · apply (lawClose_one _ _).mono
      have hb : boundaryLoss M J L a=1 := by rw [←ha]; simp only [boundaryLoss,Equiv.symm_apply_apply,hj,ite_false]
      rw [hb]
      linarith
  have hcond (i : Fin (M*J)) : StandardMapEntropy.Entropy.cond ν
      (fullBlock (k+g) (M*J) q i.val)
      (c i.val ∘ finiteName (fullBlock (k+g) (M*J) q) (i.val+1) (M*J-i.val-1))≤
      H+boundaryLoss M J L i*Real.log (Fintype.card (Fin (k+g) → A)) := by
    obtain ⟨⟨I,j⟩,rfl⟩ := finProdFinEquiv.surjective i
    by_cases hj : j.val+L<J
    · simp only [boundaryLoss,Equiv.symm_apply_apply,hj,ite_true,zero_mul,add_zero]
      change StandardMapEntropy.Entropy.cond ν _ (extendedCoarse M J L _ ∘ _)≤H
      rw [nestedOutput_future M J (k+g) L V I j hj,nestedOutput_head]
      exact htest _ _ ((measurable_pi_apply j).comp ((measurable_pi_apply I).comp hV))
        ((measurable_of_countable (vectorFuture J L j.val hj)).comp ((measurable_pi_apply I).comp hV)) (hpair I j hj)
    · simp only [boundaryLoss,Equiv.symm_apply_apply,hj,ite_false,one_mul]
      have hh := cond_le_obs ν (fullBlock (k+g) (M*J) q (finProdFinEquiv (I,j)).val)
        (c (finProdFinEquiv (I,j)).val ∘ finiteName (fullBlock (k+g) (M*J) q)
          ((finProdFinEquiv (I,j)).val+1) (M*J-(finProdFinEquiv (I,j)).val-1))
        (fullBlock_measurable _ _ q hq _)
        ((measurable_of_countable (c (finProdFinEquiv (I,j)).val)).comp
          (finiteName_measurable _ (fullBlock_measurable _ _ q hq)
            ((finProdFinEquiv (I,j)).val+1) (M*J-(finProdFinEquiv (I,j)).val-1)))
      have hb := obs_bound ν (fullBlock (k+g) (M*J) q (finProdFinEquiv (I,j)).val)
        (fullBlock_measurable _ _ q hq _)
      linarith
  obtain ⟨R,hR⟩ := nonstationary_conditional_word_transport μ ν f hf p hp k g (M*J) q hq
    (fun _ => Fin L → Fin (k+g) → A) c ε (fun _ => δ) hτ hP hhead hlocal
  refine ⟨R,hR.trans ?_⟩
  have hlog : 0≤Real.log (Fintype.card (Fin (k+g) → A)) :=
    Real.log_nonneg (by exact_mod_cast Fintype.card_pos (α:=Fin (k+g) → A))
  have hcs : (∑ i : Fin (M*J),StandardMapEntropy.Entropy.cond ν
      (fullBlock (k+g) (M*J) q i.val)
      (c i.val ∘ finiteName (fullBlock (k+g) (M*J) q) (i.val+1) (M*J-i.val-1)))≤
      (M*J : ℕ)*H+(M*L : ℕ)*Real.log (Fintype.card (Fin (k+g) → A)) := by
    calc
      _≤∑ i : Fin (M*J),(H+boundaryLoss M J L i*Real.log (Fintype.card (Fin (k+g) → A))) :=
        Finset.sum_le_sum (fun i _ => hcond i)
      _=(M*J : ℕ)*H+(∑ i : Fin (M*J),boundaryLoss M J L i)*Real.log (Fintype.card (Fin (k+g) → A)) := by
        rw [Finset.sum_add_distrib,←Finset.sum_mul]; simp
      _≤_ := add_le_add (le_refl _) (mul_le_mul_of_nonneg_right (boundaryLoss_sum_le M J L) hlog)
  have hes : (∑ i : Fin (M*J),ε i.val)≤(M*J : ℕ)*(ρ+3*δ)+(M*L : ℕ) := by
    simp only [he,Finset.sum_add_distrib,Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
    have hh := boundaryLoss_sum_le M J L
    nlinarith
  apply add_le_add _ (le_refl _)
  apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg k)
  have hh := div_le_div_of_nonneg_right (sub_le_sub_right hcs (obs ν q)) hτ.le
  simp only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]
  dsimp only [q] at hh ⊢
  nlinarith
end HyperbolicCoding

end

end OAI