lean/OAI/Dynamics/StandardMap/Coupling/IidFiniteWindowApprox.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Coding.FullEntropyCopySequence
import OAI.Dynamics.StandardMap.Coupling.RelativeFiniteRealization

namespace OAI

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

def centeredWindow (N : ℕ) (w : ℤ → A) : Fin (2*N+1) → A := fun i => w ((i.val : ℤ)-N)

lemma measurable_centeredWindow [Fintype A] [MeasurableSingletonClass A]
    (N : ℕ) : Measurable (centeredWindow (A:=A) N) :=
  Measurable.of_eval (fun _ => measurable_pi_apply _)

lemma centeredWindow_comap_monotone [Fintype A] [MeasurableSingletonClass A] :
    Monotone (fun N => MeasurableSpace.comap (centeredWindow (A:=A) N) inferInstance) := by
  intro N M hNM
  let r : (Fin (2*M+1) → A) → (Fin (2*N+1) → A) :=
    fun v i => v ⟨i.val+(M-N),by omega⟩
  have hm : Measurable[MeasurableSpace.comap (centeredWindow (A:=A) M) inferInstance]
      (centeredWindow (A:=A) M) := measurable_iff_comap_le.mpr le_rfl
  have hh := (measurable_of_countable r).comp hm
  have heq : r ∘ centeredWindow (A:=A) M=centeredWindow N := by
    funext w i
    dsimp [r,centeredWindow]
    congr 1
    omega
  rw [heq] at hh
  exact measurable_iff_comap_le.mp hh

lemma centeredWindow_generates [Fintype A] [MeasurableSingletonClass A] :
    (inferInstance : MeasurableSpace (ℤ → A))=
      ⨆ N,MeasurableSpace.comap (centeredWindow (A:=A) N) inferInstance := by
  let m := ⨆ N,MeasurableSpace.comap (centeredWindow (A:=A) N) inferInstance
  apply le_antisymm
  · have hi (i : ℤ) : @Measurable (ℤ → A) A m inferInstance (fun w => w i) := by
      let N := i.natAbs
      let j : Fin (2*N+1) := ⟨(i+N).toNat,by
        have h₁ := (Int.le_natAbs (a:=i))
        have h₂ : -i≤(i.natAbs : ℤ) := by simpa using (Int.le_natAbs (a:=-i))
        dsimp [N]
        omega⟩
      have hN : @Measurable (ℤ → A) (Fin (2*N+1) → A) m inferInstance (centeredWindow N) :=
        measurable_iff_comap_le.mpr
          (le_iSup (fun n => MeasurableSpace.comap (centeredWindow (A:=A) n) inferInstance) N)
      have hh := (measurable_pi_apply j).comp hN
      have heq : (fun w => centeredWindow (A:=A) N w j)=(fun w => w i) := by
        funext w
        dsimp [centeredWindow,j,N]
        congr 1
        have h₂ : -i≤(i.natAbs : ℤ) := by simpa using (Int.le_natAbs (a:=-i))
        omega
      exact heq ▸ hh
    have hid : @Measurable (ℤ → A) (ℤ → A) m MeasurableSpace.pi id := Measurable.of_eval hi
    simpa only [MeasurableSpace.comap_id] using measurable_iff_comap_le.mp hid
  · apply iSup_le
    intro N
    exact measurable_iff_comap_le.mp (measurable_centeredWindow N)

lemma centeredWindow_as_word [Fintype A] [MeasurableSingletonClass A] (N : ℕ) (w : ℤ → A) :
    centeredWindow N w=word iidShift (fun z : ℤ → A => z 0) (2*N+1)
      (integerIterate iidShift (-(N : ℤ)) w) := by
  funext i
  simp only [iid_word_eq,integerIterate_neg_nat,iidShift_symm_iterate,centeredWindow]

theorem iid_finite_window_approx [Fintype A] [MeasurableSingletonClass A]
    (ν : Measure (ℤ → A)) [IsProbabilityMeasure ν]
    (b : (ℤ → A) → B) (hb : Measurable b) {ε : ℝ} (hε : 0<ε) :
    ∃ N : ℕ,∃ D : (Fin (2*N+1) → A) → B,
      ν.real {w | D (centeredWindow N w)≠b w}<ε :=
  finite_factor_approx ν (fun N => Fin (2*N+1) → A) centeredWindow
    centeredWindow_comap_monotone centeredWindow_generates b hb hε
end HyperbolicCoding

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

lemma mass_comp_factor [StandardBorelSpace X] [StandardBorelSpace Y] [Fintype A]
    (μ : Measure X) (ν : Measure Y) (π : X → Y)
    (hπ : MeasurePreserving π μ ν) (p : Y → A) (hp : Measurable p) :
    mass μ (p ∘ π)=mass ν p := by
  funext a
  unfold mass
  exact congrArg ENNReal.toReal (hπ.measure_preimage (hp (measurableSet_singleton a)).nullMeasurableSet)

lemma rate_of_factor [StandardBorelSpace X] [StandardBorelSpace Y] [Fintype A]
    (μ : Measure X) [IsProbabilityMeasure μ] (ν : Measure Y) [IsProbabilityMeasure ν]
    (e : X → X) (f : Y → Y) (hf : Measurable f)
    (π : X → Y) (hπ : MeasurePreserving π μ ν) (hcomm : ∀ x,π (e x)=f (π x))
    (p : Y → A) (hp : Measurable p) : rate μ e (p ∘ π)=rate ν f p := by
  have hh (n : ℕ) : obs μ (word e (p ∘ π) n)=obs ν (word f p n) := by
    rw [factor_word e f π hcomm p n]
    unfold obs
    rw [mass_comp_factor μ ν π hπ _ (word_measurable f hf p hp n)]
  unfold rate
  simp only [hh]
end HyperbolicCoding

end
section
namespace HyperbolicCoding
open MeasureTheory Set StandardMapEntropy.Entropy
open scoped BigOperators ENNReal
variable {X A B : Type*} [MeasurableSpace X] [StandardBorelSpace 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 relative_iid_window_graph
    [TopologicalSpace X] [SecondCountableTopology X] [OpensMeasurableSpace X]
    (μ : Measure X) [IsProbabilityMeasure μ]
    (e : X ≃ᵐ X) (he : Ergodic e μ) (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 α) (m : ℕ) {ε : ℝ} (hε : 0<ε) :
    ∃ R : ℕ,∃ D : (Fin (2*R+1) → A) → B,
      LawClose (μ.map (word e (fun x => (p x,α x)) m))
        ((Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)).map
          (word iidShift (fun y : ℤ → A => (y 0,D (centeredWindow R y))) m)) ε ∧
      rate (Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)) iidShift
        (fun y : ℤ → A => (y 0,D (centeredWindow R y)))=weightEntropy β := by
  classical
  let : IsProbabilityMeasure (finiteWeightLaw β) := finiteWeightLaw_probability β hβ hβsum
  let ν := Measure.infinitePi (fun _ : ℤ => finiteWeightLaw β)
  let : NullSingletonClass ν := iid_nullSingleton β hβ hβsum hβentropy
  have hcomm : ∀ x,orbitName e p (e x)=iidShift (orbitName e p x) := fun x => orbitName_shift e p x
  have hf : Ergodic iidShift ν := hcode.ergodic_of_ergodic_semiconj he iidShift.measurable hcomm
  have hp0 : (fun x => orbitName e p x 0)=p := by funext x; simp [orbitName,integerIterate]
  obtain ⟨b,hb,hbLaw⟩ := relative_measurable_graph_approx μ ν e he.toMeasurePreserving iidShift hf
    (orbitName e p) hcode hcomm (fun w : ℤ → A => w 0) α (measurable_pi_apply 0) hα m (half_pos hε)
  obtain ⟨R,D,hD⟩ := iid_finite_window_approx ν b hb (show 0<ε/(2*((m : ℝ)+1)) by positivity)
  have hDmeas : Measurable (fun y : ℤ → A => D (centeredWindow R y)) :=
    (measurable_of_countable D).comp (measurable_centeredWindow R)
  have hpaint : ν.real {y | (y 0,b y)≠(y 0,D (centeredWindow R y))}<ε/(2*((m : ℝ)+1)) := by
    convert hD using 1
    congr 1
    ext y
    simp only [Set.mem_ofPred_eq,ne_eq,Prod.mk.injEq,true_and]
    exact ne_comm
  have hLaw := word_lawClose_of_repaint ν iidShift hf.toMeasurePreserving
    (fun y : ℤ → A => (y 0,b y)) (fun y : ℤ → A => (y 0,D (centeredWindow R y)))
    ((measurable_pi_apply 0).prodMk hb) ((measurable_pi_apply 0).prodMk hDmeas) m
  refine ⟨R,D,?_,?_⟩
  · have htrans := hbLaw.triangle hLaw
    change LawClose (μ.map (word e (fun x => (p x,α x)) m)) _ _ at htrans
    apply htrans.mono
    have hm0 : (0 : ℝ)≤ m := Nat.cast_nonneg m
    have hh := (lt_div_iff₀ (by positivity : (0 : ℝ)<2*((m : ℝ)+1))).mp hpaint
    have hn0 := measureReal_nonneg (μ:=ν) (s:={y | (y 0,b y)≠(y 0,D (centeredWindow R y))})
    nlinarith
  · have hfac := rate_of_factor μ ν e iidShift iidShift.measurable (orbitName e p) hcode hcomm
      (fun y : ℤ → A => (y 0,D (centeredWindow R y))) ((measurable_pi_apply 0).prodMk hDmeas)
    have hu := H.upper ((fun y : ℤ → A => (y 0,D (centeredWindow R y))) ∘ orbitName e p)
      (((measurable_pi_apply 0).prodMk hDmeas).comp hcode.measurable)
    rw [hfac] at hu
    apply le_antisymm hu
    have hl := rate_pair_ge_left ν iidShift hf.toMeasurePreserving (fun y : ℤ → A => y 0)
      (fun y => D (centeredWindow R y)) (measurable_pi_apply 0) hDmeas
    rwa [iid_rate β hβ hβsum] at hl
end HyperbolicCoding

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

 theorem coupling_step_finite (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (q : X → B) (hp : Measurable p) (hq : Measurable q)
    (t : A → ℝ) (r : MatrixCoupling (mass μ p) t)
    (d : A → A → ℝ) (hdiag : ∀ a,d a a=0) (htri : ∀ a b c,d a c≤d a b+d b c)
    {ε : ℝ}
    (hclose : LawClose (μ.map (fun x => (p x,q x))) ((μ.map p).prod (μ.map q)) ε) :
    ∃ s : MatrixCoupling (mass μ (fun x => (q x,p x)))
      (fun ba : B×A => mass μ q ba.1*t ba.2),
      s.cost (fun ba bb => symbolCost ba.1 bb.1+d ba.2 bb.2)≤ε+r.cost d := by
  classical
  let u : A → B → ℝ := fun a b => mass μ (fun x => (p x,q x)) (a,b)
  let v : A → B → ℝ := fun a b => mass μ p a*mass μ q b
  have hrow (a) : ∑ b,u a b=∑ b,v a b := by
    rw [←mass_joint_row μ p q hp hq]
    dsimp only [v]
    rw [←Finset.mul_sum,mass_sum μ q hq]
    simp
  have hc (a) := finite_maximal_coupling_equal_mass (u a) (v a)
    (fun b => mass_nonneg μ _ _) (fun b => mul_nonneg (mass_nonneg μ _ _) (mass_nonneg μ _ _)) (hrow a)
  choose w hw hwrow hwcol hwerr using hc
  let R : MatrixCoupling (mass μ (fun x => (q x,p x)))
      (fun ba : B×A => mass μ q ba.1*mass μ p ba.2) := {
    weight := fun ba ca => if ba.2=ca.2 then w ba.2 ba.1 ca.1 else 0
    nonneg := fun ba ca => by split
                              · exact hw _ _ _
                              · exact le_rfl
    row := fun ba => by
      simp only [Fintype.sum_prod_type]
      simp only [Finset.sum_ite_eq,Finset.mem_univ,ite_true]
      rw [hwrow]
      exact mass_joint_swap μ p q ba.2 ba.1
    col := fun ca => by
      simp only [Fintype.sum_prod_type]
      simp only [Finset.sum_ite_eq',Finset.mem_univ,ite_true]
      rw [hwcol]
      exact mul_comm _ _ }
  let S := (MatrixCoupling.diagonal (mass μ q) (mass_nonneg μ q)).product r
  let cost : (B×A) → (B×A) → ℝ := fun ba bb => symbolCost ba.1 bb.1+d ba.2 bb.2
  have hR : R.cost cost≤ε := by
    have he : R.cost cost=∑ a,∑ b,∑ c,w a b c*symbolCost b c := by
      simp only [MatrixCoupling.cost,R,cost,Fintype.sum_prod_type]
      have hh (b : B) (a : A) (c : B) :
          (∑ a', (if a=a' then w a b c else 0)*(symbolCost b c+d a a'))=
            w a b c*symbolCost b c := by
        simp [ite_mul,hdiag]
      simp only [hh]
      rw [Finset.sum_comm]
    rw [he]
    have : IsProbabilityMeasure (μ.map p) := inferInstance
    have : IsProbabilityMeasure (μ.map q) := inferInstance
    have : IsProbabilityMeasure (μ.map (fun x => (p x,q x))) := inferInstance
    have hprod (a : A) (b : B) : ((μ.map p).prod (μ.map q)).real {(a,b)}=v a 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 hsum : (∑ a,∑ b,max (u a b-v a b) 0)≤ε := by
      have h := positive_mass_difference_le _ _ hclose
      rw [Fintype.sum_prod_type] at h
      have hu (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))
      simpa only [hu,hprod] using h
    apply le_trans _ hsum
    apply Finset.sum_le_sum
    intro a _
    simpa only [symbolCost] using (hwerr a).le
  have hS : S.cost cost=r.cost d := by
    rw [MatrixCoupling.product_cost]
    · rw [MatrixCoupling.diagonal_cost _ _ symbolCost symbolCost_self,zero_add]
    · simpa using mass_sum μ q hq
    · simpa using mass_sum μ p hp
  refine ⟨R.comp S,?_⟩
  have h := MatrixCoupling.comp_cost_le R S cost cost cost (fun a b c => by
    dsimp [cost]
    have h1 := symbolCost_triangle a.1 b.1 c.1
    have h2 := htri a.2 b.2 c.2
    linarith)
  exact h.trans (by rw [hS]; linarith)
end HyperbolicCoding

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

lemma cond_constant [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (_hp : Measurable p) : StandardMapEntropy.Entropy.cond μ p (fun _ => (PUnit.unit : PUnit.{1}))=obs μ p := by
  unfold StandardMapEntropy.Entropy.cond
  have he : obs μ (fun x => (p x,(PUnit.unit : PUnit.{1})))=obs μ p := by
    let e : A ≃ A×PUnit.{1} := (Equiv.prodPUnit A).symm
    exact obs_equiv μ p e
  rw [he,obs_const,sub_zero]

lemma lawClose_of_mutual_information [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (q : X → B) (hp : Measurable p) (hq : Measurable q)
    {δ : ℝ} (hδ : 0 ≤ δ) (hdef : 4*(obs μ q-StandardMapEntropy.Entropy.cond μ q p) ≤ δ^2) :
    LawClose (μ.map (fun x => (p x,q x))) ((μ.map p).prod (μ.map q)) δ := by
  have hconst : LawClose (μ.map (fun x => ((PUnit.unit : PUnit.{1}),q x)))
      ((μ.map (fun _ : X => (PUnit.unit : PUnit.{1}))).prod (μ.map q)) 0 := by
    have heq := (ProbabilityTheory.indepFun_const_left (μ:=μ) (PUnit.unit : PUnit.{1}) q).map_prod_eq_prod_map_map
      measurable_const.aemeasurable hq.aemeasurable
    rw [heq]
    intro D _
    simp only [sub_self,abs_zero]
    exact le_rfl
  have hd : 4*(StandardMapEntropy.Entropy.cond μ q ((fun _ : A => (PUnit.unit : PUnit.{1})) ∘ p)-StandardMapEntropy.Entropy.cond μ q p) ≤ δ^2 := by
    simpa only [Function.comp_def,cond_constant μ q hq] using hdef
  have hh := lawClose_of_coarse_independence μ p q (fun _ : A => (PUnit.unit : PUnit.{1})) hp hq hδ hconst hd
  simpa only [mul_zero,add_zero] using hh

lemma lawClose_entropy_budget [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    (μ : Measure X) [IsProbabilityMeasure μ]
    (p : X → A) (q : X → B) (hp : Measurable p) (hq : Measurable q)
    {τ : ℝ} (hτ : 0 < τ) :
    LawClose (μ.map (fun x => (p x,q x))) ((μ.map p).prod (μ.map q))
      ((obs μ q-StandardMapEntropy.Entropy.cond μ q p)/τ+τ) := by
  have hI : 0 ≤ obs μ q-StandardMapEntropy.Entropy.cond μ q p := sub_nonneg.mpr (cond_le_obs μ q p hq hp)
  apply lawClose_of_mutual_information μ p q hp hq (by positivity)
  have he : ((obs μ q-StandardMapEntropy.Entropy.cond μ q p)/τ)*τ=obs μ q-StandardMapEntropy.Entropy.cond μ q p := div_mul_cancel₀ _ hτ.ne'
  nlinarith [sq_nonneg ((obs μ q-StandardMapEntropy.Entropy.cond μ q p)/τ-τ)]

variable (μ : Measure X)

noncomputable def sequenceEntropyDefect [Fintype A] (q : ℕ → X → A) (i n : ℕ) : ℝ :=
  (∑ j : Fin n,obs μ (q (i+j.val)))-obs μ (finiteName q i n)

lemma obs_finiteName_zero [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    [StandardBorelSpace X] [Nonempty A] [IsProbabilityMeasure μ]
    (q : ℕ → X → A) (i : ℕ) : obs μ (finiteName q i 0)=0 := by
  have heq : finiteName q i 0=(fun _ => (fun j : Fin 0 => j.elim0 : Fin 0 → A)) := by
    funext x j
    exact j.elim0
  rw [heq,obs_const]

lemma sequenceEntropyDefect_cons [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    [StandardBorelSpace X] [Nonempty A] [IsProbabilityMeasure μ]
    (q : ℕ → X → A) (i n : ℕ) :
    sequenceEntropyDefect μ q i (n+1)=
      (obs μ (q i)-StandardMapEntropy.Entropy.cond μ (q i) (finiteName q (i+1) n))+sequenceEntropyDefect μ q (i+1) n := by
  let e : (A×(Fin n → A)) ≃ (Fin (n+1) → A) := Fin.consEquiv (fun _ => A)
  have heq : finiteName q i (n+1)=e ∘ (fun x => (q i x,finiteName q (i+1) n x)) :=
    funext (finiteName_cons q i n)
  have hobs : obs μ (finiteName q i (n+1))=obs μ (fun x => (q i x,finiteName q (i+1) n x)) := by
    rw [heq,obs_equiv]
  simp only [sequenceEntropyDefect,Fin.sum_univ_succ,Fin.val_zero,Nat.add_zero,Fin.val_succ,hobs,StandardMapEntropy.Entropy.cond]
  have hs : (∑ j : Fin n,obs μ (q (i+(j.val+1))))=
      ∑ j : Fin n,obs μ (q ((i+1)+j.val)) := by
    apply Finset.sum_congr rfl
    intro j _
    congr 2
    omega
  rw [hs]
  ring

lemma independentNameWeights_cons_finite [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    [StandardBorelSpace X] [Nonempty A] [IsProbabilityMeasure μ]
    (q : ℕ → X → A) (i n : ℕ) (w : Fin (n+1) → A) :
    independentNameWeights μ q i (n+1) w=
      mass μ (q i) (w 0)*independentNameWeights μ q (i+1) n (Fin.tail w) := by
  rw [independentNameWeights,Fin.prod_univ_succ]
  simp only [Fin.val_zero,Nat.add_zero,Fin.val_succ,Fin.tail,independentNameWeights]
  congr 2
  funext j
  congr 2
  omega

lemma mass_equiv_inverse_finite [StandardBorelSpace X] [IsProbabilityMeasure μ]
    {C D : Type*} [MeasurableSpace C] [Fintype C] [MeasurableSingletonClass C]
    [MeasurableSpace D] [Fintype D] [MeasurableSingletonClass D]
    (p : X → C) (e : C ≃ D) (d : D) : mass μ (e ∘ p) d=mass μ p (e.symm d) := by
  unfold mass
  congr 2
  ext x
  simp only [mem_preimage,mem_singleton_iff,Function.comp_apply,← Equiv.eq_symm_apply]

theorem entropy_product_transport [MeasurableSpace A] [Fintype A] [MeasurableSingletonClass A]
    [StandardBorelSpace X] [Nonempty A] [IsProbabilityMeasure μ]
    (q : ℕ → X → A) (hq : ∀ i,Measurable (q i))
    {τ : ℝ} (hτ : 0 < τ) :
    ∀ i n : ℕ,∃ R : MatrixCoupling (mass μ (finiteName q i n)) (independentNameWeights μ q i n),
      R.cost nameCost ≤ sequenceEntropyDefect μ q i n/τ+(n : ℝ)*τ := by
  intro i n
  induction n generalizing i with
  | zero =>
    have hm (w : Fin 0 → A) : mass μ (finiteName q i 0) w=1 := by
      have he : (finiteName q i 0) ⁻¹' {w}=univ := by
        ext x
        simp only [mem_preimage,mem_singleton_iff,mem_univ,iff_true]
        funext j
        exact j.elim0
      simp [mass,he]
    let R : MatrixCoupling (mass μ (finiteName q i 0)) (independentNameWeights μ q i 0) := {
      weight := fun _ _ => 1
      nonneg := fun _ _ => zero_le_one
      row := fun w => by simp [hm]
      col := fun w => by simp [independentNameWeights] }
    refine ⟨R,?_⟩
    simp [MatrixCoupling.cost,nameCost,sequenceEntropyDefect,obs_finiteName_zero]
  | succ n ih =>
    obtain ⟨r,hr⟩ := ih (i+1)
    have hc := lawClose_entropy_budget μ (finiteName q (i+1) n) (q i)
      (finiteName_measurable q hq (i+1) n) (hq i) hτ
    obtain ⟨s,hs⟩ := coupling_step_finite μ (finiteName q (i+1) n) (q i)
      (finiteName_measurable q hq (i+1) n) (hq i)
      (independentNameWeights μ q (i+1) n) r nameCost nameCost_self nameCost_triangle hc
    let e : (A×(Fin n → A)) ≃ (Fin (n+1) → A) := Fin.consEquiv (fun _ => A)
    let t := s.reindex e.symm e.symm
    have hm (w : Fin (n+1) → A) :
        mass μ (fun x => (q i x,finiteName q (i+1) n x)) (e.symm w)=mass μ (finiteName q i (n+1)) w := by
      rw [←mass_equiv_inverse_finite μ _ e w]
      congr 1
      funext x
      exact (finiteName_cons q i n x).symm
    have hw (w : Fin (n+1) → A) :
        mass μ (q i) (e.symm w).1*independentNameWeights μ q (i+1) n (e.symm w).2=
          independentNameWeights μ q i (n+1) w := (independentNameWeights_cons_finite μ q i n w).symm
    let R : MatrixCoupling (mass μ (finiteName q i (n+1))) (independentNameWeights μ q i (n+1)) := {
      weight := t.weight
      nonneg := t.nonneg
      row := fun w => (t.row w).trans (hm w)
      col := fun w => (t.col w).trans (hw w) }
    have hcost : R.cost nameCost=s.cost (fun a b => symbolCost a.1 b.1+nameCost a.2 b.2) := by
      change t.cost nameCost=_
      have he : (nameCost : (Fin (n+1) → A) → (Fin (n+1) → A) → ℝ)=
          (fun v w => symbolCost (e.symm v).1 (e.symm w).1+nameCost (e.symm v).2 (e.symm w).2) := by
        funext v w
        exact nameCost_split v w
      rw [he]
      exact MatrixCoupling.reindex_cost s e.symm e.symm
        (fun a b : A×(Fin n → A) => symbolCost a.1 b.1+nameCost a.2 b.2)
    refine ⟨R,?_⟩
    rw [hcost,sequenceEntropyDefect_cons]
    have hh := hs.trans (add_le_add (le_refl _) hr)
    convert hh using 1; first | rfl | (push_cast; ring)
end HyperbolicCoding

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

theorem sequential_coupling_budgets (q : ℕ → X → A) (hq : ∀ i,Measurable (q i))
    (N : ℕ) (b : ℕ → ℝ)
    (hremote : ∀ i n : ℕ,i+n+1≤N → LawClose
      (μ.map (fun x => (finiteName q (i+1) n x,q i x)))
      ((μ.map (finiteName q (i+1) n)).prod (μ.map (q i))) (b i)) :
    ∀ i n : ℕ,i+n≤N → ∃ R : MatrixCoupling (mass μ (finiteName q i n)) (independentNameWeights μ q i n),
      R.cost nameCost≤∑ j : Fin n,b (i+j.val) := by
  intro i n hi
  induction n generalizing i with
  | zero =>
    have hm (w : Fin 0 → A) : mass μ (finiteName q i 0) w=1 := by
      have he : (finiteName q i 0) ⁻¹' {w}=univ := by
        ext x
        simp only [mem_preimage,mem_singleton_iff,mem_univ,iff_true]
        funext j
        exact j.elim0
      simp [mass,he]
    let R : MatrixCoupling (mass μ (finiteName q i 0)) (independentNameWeights μ q i 0) := {
      weight := fun _ _ => 1
      nonneg := fun _ _ => zero_le_one
      row := fun w => by simp [hm]
      col := fun w => by simp [independentNameWeights] }
    refine ⟨R,?_⟩
    simp [MatrixCoupling.cost,nameCost]
  | succ n ih =>
    obtain ⟨r,hr⟩ := ih (i+1) (by omega)
    have hc := hremote i n hi
    obtain ⟨s,hs⟩ := coupling_step_finite μ (finiteName q (i+1) n) (q i)
      (finiteName_measurable q hq (i+1) n) (hq i)
      (independentNameWeights μ q (i+1) n) r nameCost nameCost_self nameCost_triangle hc
    let e : (A×(Fin n → A)) ≃ (Fin (n+1) → A) := Fin.consEquiv (fun _ => A)
    let t := s.reindex e.symm e.symm
    have hm (w : Fin (n+1) → A) :
        mass μ (fun x => (q i x,finiteName q (i+1) n x)) (e.symm w)=mass μ (finiteName q i (n+1)) w := by
      rw [←mass_equiv_inverse_finite μ _ e w]
      congr 1
      funext x
      exact (finiteName_cons q i n x).symm
    have hw (w : Fin (n+1) → A) :
        mass μ (q i) (e.symm w).1*independentNameWeights μ q (i+1) n (e.symm w).2=
          independentNameWeights μ q i (n+1) w := (independentNameWeights_cons_finite μ q i n w).symm
    let R : MatrixCoupling (mass μ (finiteName q i (n+1))) (independentNameWeights μ q i (n+1)) := {
      weight := t.weight
      nonneg := t.nonneg
      row := fun w => (t.row w).trans (hm w)
      col := fun w => (t.col w).trans (hw w) }
    have hcost : R.cost nameCost=s.cost (fun a b => symbolCost a.1 b.1+nameCost a.2 b.2) := by
      change t.cost nameCost=_
      have he : (nameCost : (Fin (n+1) → A) → (Fin (n+1) → A) → ℝ)=
          (fun v w => symbolCost (e.symm v).1 (e.symm w).1+nameCost (e.symm v).2 (e.symm w).2) := by
        funext v w
        exact nameCost_split v w
      rw [he]
      exact MatrixCoupling.reindex_cost s e.symm e.symm
        (fun a b : A×(Fin n → A) => symbolCost a.1 b.1+nameCost a.2 b.2)
    refine ⟨R,?_⟩
    rw [hcost,Fin.sum_univ_succ]
    simp only [Fin.val_zero,Nat.add_zero,Fin.val_succ]
    have he : (∑ j : Fin n,b (i+(j.val+1)))=∑ j : Fin n,b (i+1+j.val) := by
      apply Finset.sum_congr rfl
      intro j _
      congr 1
      omega
    rw [he]
    exact hs.trans (add_le_add (le_refl _) hr)

lemma finiteName_entropy_chain (q : ℕ → X → A) (i n : ℕ) :
    obs μ (finiteName q i n)=∑ j : Fin n,StandardMapEntropy.Entropy.cond μ
      (q (i+j.val)) (finiteName q (i+j.val+1) (n-j.val-1)) := by
  induction n generalizing i with
  | zero => simp [obs_finiteName_zero]
  | succ n ih =>
    have he : obs μ (finiteName q i (n+1))=
        StandardMapEntropy.Entropy.cond μ (q i) (finiteName q (i+1) n)+obs μ (finiteName q (i+1) n) := by
      let e : (A×(Fin n → A)) ≃ (Fin (n+1) → A) := Fin.consEquiv (fun _ => A)
      have heq : finiteName q i (n+1)=e ∘ (fun x => (q i x,finiteName q (i+1) n x)) :=
        funext (finiteName_cons q i n)
      rw [heq,obs_equiv]
      unfold StandardMapEntropy.Entropy.cond
      ring
    rw [he,ih,Fin.sum_univ_succ]
    simp only [Fin.val_zero,Nat.add_zero,Nat.sub_zero,Fin.val_succ]
    congr 1
    apply Finset.sum_congr rfl
    intro j _
    have hl : n+1-(j.val+1)-1=n-j.val-1 := by omega
    have hi : i+1+j.val=i+(j.val+1) := by omega
    simp only [hi]
    exact congrArg (fun m => StandardMapEntropy.Entropy.cond μ (q (i+(j.val+1)))
      (finiteName q (i+(j.val+1)+1) m)) hl.symm
end HyperbolicCoding

end

end OAI