import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Towers.FiniteCouplingRealization
import OAI.Dynamics.StandardMap.Coding.EntropyRateCodebook

namespace OAI

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

lemma rate_factor (f : X → X) (hf : MeasurePreserving f μ μ)
    (p : X → A) (hp : Measurable p) (g : A → B) :
    rate μ f (g ∘ p) ≤ rate μ f p := by
  have hg : Measurable g := measurable_of_finite g
  apply le_of_tendsto_of_tendsto
    (rate_tendsto μ f hf (g ∘ p) (hg.comp hp)) (rate_tendsto μ f hf p hp)
  apply Eventually.of_forall
  intro n
  have heq : word f (g ∘ p) n = (fun v : Fin n → A => fun i => g (v i)) ∘ word f p n := rfl
  dsimp only
  rw [heq]
  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg n)
  exact obs_factor μ _ _ (word_measurable f hf.measurable p hp n)
    (word_measurable f hf.measurable (g ∘ p) (hg.comp hp) n)

lemma rate_word_le (f : X → X) (hf : MeasurePreserving f μ μ)
    (p : X → A) (hp : Measurable p) (m : ℕ) :
    rate μ f (word f p m) ≤ rate μ f p := by
  have hb (n : ℕ) : obs μ (word f (word f p m) n) ≤
      obs μ (word f p n) + obs μ (word f p m) := by
    let G : (Fin (n+m) → A) → (Fin n → Fin m → A) :=
      fun v i j => v ⟨i.val+j.val, Nat.add_lt_add i.isLt j.isLt⟩
    have heq : word f (word f p m) n = G ∘ word f p (n+m) := by
      funext x i j
      simp only [word,Function.comp_apply,G,←Function.iterate_add_apply,Nat.add_comm]
    have hh : obs μ (word f (word f p m) n) ≤ obs μ (word f p (n+m)) := by
      rw [heq]
      exact obs_factor μ _ G (word_measurable f hf.measurable p hp (n+m))
        ((measurable_of_finite G).comp (word_measurable f hf.measurable p hp (n+m)))
    exact hh.trans (obs_word_subadd μ f hf p hp n m)
  have hlim : Tendsto (fun n : ℕ => obs μ (word f p n)/(n : ℝ) +
      obs μ (word f p m)/(n : ℝ)) atTop (𝓝 (rate μ f p)) := by
    simpa only [add_zero] using (rate_tendsto μ f hf p hp).add
      (tendsto_const_div_atTop_nhds_zero_nat (obs μ (word f p m)))
  apply le_of_tendsto_of_tendsto
    (rate_tendsto μ f hf (word f p m) (word_measurable f hf.measurable p hp m)) hlim
  apply Eventually.of_forall
  intro n
  simpa only [add_div] using div_le_div_of_nonneg_right (hb n) (Nat.cast_nonneg n)

lemma rate_word_eq (f : X → X) (hf : MeasurePreserving f μ μ)
    (p : X → A) (hp : Measurable p) {m : ℕ} (hm : 0 < m) :
    rate μ f (word f p m) = rate μ f p := by
  apply le_antisymm (rate_word_le μ f hf p hp m)
  have h := rate_factor μ f hf (word f p m) (word_measurable f hf.measurable p hp m)
    (fun v : Fin m → A => v ⟨0,hm⟩)
  simpa only [Function.comp_def,word,Function.iterate_zero,Function.id_def] using h

omit [IsProbabilityMeasure μ] in
lemma rate_integer_shift (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (p : X → A) (hp : Measurable p) (s : ℤ) :
    rate μ e (p ∘ integerIterate e s) = rate μ e p := by
  have hw (n : ℕ) : word e (p ∘ integerIterate e s) n =
      word e p n ∘ integerIterate e s := by
    funext x i
    simp only [word,Function.comp_apply,←integerIterate_nat,
      ←integerIterate_add,add_comm]
  have ho (n : ℕ) : obs μ (word e (p ∘ integerIterate e s) n) = obs μ (word e p n) := by
    rw [hw]
    exact obs_comp_preserving μ _ (integerIterate_measurePreserving e he s)
      _ (word_measurable e e.measurable p hp n)
  unfold rate
  simp only [ho]

lemma rate_le_window_decoder (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (p : X → A) (hp : Measurable p) (q : X → B) (hq : Measurable q)
    (s : ℤ) (m : ℕ) (D : (Fin m → B) → A) :
    rate μ e p ≤ rate μ e q +
      cond μ p (D ∘ word e q m ∘ integerIterate e s) := by
  let r : X → A := D ∘ word e q m ∘ integerIterate e s
  have hr : Measurable r := (measurable_of_finite D).comp
    ((word_measurable e e.measurable q hq m).comp (integerIterate_measurable e s))
  have hR : rate μ e r ≤ rate μ e q := by
    have hshift := rate_integer_shift μ e he (D ∘ word e q m)
      ((measurable_of_finite D).comp (word_measurable e e.measurable q hq m)) s
    change rate μ e ((D ∘ word e q m) ∘ integerIterate e s) ≤ _
    rw [hshift]
    exact (rate_factor μ e he (word e q m) (word_measurable e e.measurable q hq m) D).trans
      (rate_word_le μ e he q hq m)
  exact (rate_comparison μ e he p r hp hr).trans (add_le_add_left hR _)

theorem rate_lower_of_window_decoder (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (p : X → A) (hp : Measurable p) (q : X → B) (hq : Measurable q)
    (s : ℤ) (m : ℕ) (D : (Fin m → B) → A) :
    let r := D ∘ word e q m ∘ integerIterate e s
    let d := mass μ (errorObs p r) true
    rate μ e p - (Real.negMulLog d + Real.negMulLog (1-d) +
      d*Real.log (Fintype.card A)) ≤ rate μ e q := by
  intro r d
  have hr : Measurable r := (measurable_of_finite D).comp
    ((word_measurable e e.measurable q hq m).comp (integerIterate_measurable e s))
  have h1 := rate_le_window_decoder μ e he p hp q hq s m D
  have h2 := cond_fano_bound μ p r hp hr
  dsimp only [r,d] at *
  linarith

theorem rate_lower_of_small_window_error (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (p : X → A) (hp : Measurable p) {ε : ℝ} (hε : 0 < ε) :
    ∃ η : ℝ,0 < η ∧ ∀ (q : X → B),Measurable q →
      ∀ (s : ℤ) (m : ℕ) (D : (Fin m → B) → A),
      mass μ (errorObs p (D ∘ word e q m ∘ integerIterate e s)) true < η →
      rate μ e p-ε < rate μ e q := by
  obtain ⟨η,hη,hsmall⟩ := cond_small_of_error (α:=A) μ ε hε
  refine ⟨η,hη,?_⟩
  intro q hq s m D hd
  have hr : Measurable (D ∘ word e q m ∘ integerIterate e s) :=
    (measurable_of_finite D).comp
      ((word_measurable e e.measurable q hq m).comp (integerIterate_measurable e s))
  have h1 := rate_le_window_decoder μ e he p hp q hq s m D
  have h2 := hsmall p _ hp hr hd
  linarith

end StandardMapEntropy.Entropy

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

lemma word_centered_iterate (e : X ≃ᵐ X) (q : X → A) (n : ℕ)
    (b : X) (i : Fin n) :
    word e q (2*n) (integerIterate e (-(n : ℤ)) (e^[i.val] b)) =
      Marker.centeredWindow n (orbitName e q b) i := by
  funext j
  simp only [word,Marker.centeredWindow,orbitName,←integerIterate_nat,
    ←integerIterate_add]
  congr 2
  omega

theorem marked_tower_decode_level (e : X ≃ᵐ X) (p : X → C) (q : X → A)
    {n r : ℕ} (hn : 0 < n) (hr : r < n) (zero one : A) (h01 : zero≠one)
    (D : (Fin n → A) → (Fin n → C)) (b : X)
    (hb : Marker.MarkedBlock hr zero one (word e q n b))
    (hD : D (word e q n b)=word e p n b) (i : Fin n) :
    Marker.decodeWindow hn hr zero one D
      (word e q (2*n) (integerIterate e (-(n : ℤ)) (e^[i.val] b))) = p (e^[i.val] b) := by
  rw [word_centered_iterate]
  have hw : (fun j : Fin n => orbitName e q b (j.val : ℤ))=word e q n b := by
    funext j
    simp only [orbitName,integerIterate_nat,word]
  rw [Marker.decode_centeredWindow hn hr zero one h01 D _ (by rw [hw]; exact hb),hw,hD]
  rfl

theorem marked_tower_decode_symbol (e : X ≃ᵐ X) (p : X → C) (q : X → A)
    {n r : ℕ} (hn : 0 < n) (hr : r < n) (zero one : A) (h01 : zero≠one)
    (D : (Fin n → A) → (Fin n → C)) (b : X) (i : Fin n)
    (hb : Marker.MarkedBlock hr zero one (word e q n b))
    (hD : D (word e q n b) i=p (e^[i.val] b)) :
    Marker.decodeWindow hn hr zero one D
      (word e q (2*n) (integerIterate e (-(n : ℤ)) (e^[i.val] b))) = p (e^[i.val] b) := by
  rw [word_centered_iterate]
  have hw : (fun j : Fin n => orbitName e q b (j.val : ℤ))=word e q n b := by
    funext j
    simp only [orbitName,integerIterate_nat,word]
  rw [Marker.decode_centeredWindow hn hr zero one h01 D _ (by rw [hw]; exact hb),hw]
  exact hD

theorem marked_tower_decode_error_sum (μ : Measure X) (e : X ≃ᵐ X)
    (he : MeasurePreserving e μ μ) (p : X → C) (q : X → A)
    {n r : ℕ} (hn : 0 < n) (hr : r < n) (zero one : A) (h01 : zero≠one)
    (D : (Fin n → A) → (Fin n → C)) (U : Set X) :
    let Bad := fun i : Fin n => U ∩ {b | ¬Marker.MarkedBlock hr zero one (word e q n b) ∨
      D (word e q n b) i≠p (e^[i.val] b)}
    μ {x | Marker.decodeWindow hn hr zero one D
      (word e q (2*n) (integerIterate e (-(n : ℤ)) x))≠p x} ≤
      μ (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ + ∑ i : Fin n,μ (Bad i) := by
  intro Bad
  have hsub : {x | Marker.decodeWindow hn hr zero one D
      (word e q (2*n) (integerIterate e (-(n : ℤ)) x))≠p x} ⊆
      (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ ∪ ⋃ i : Fin n,(e^[i.val]) '' Bad i := by
    intro x hx
    by_cases ht : x∈⋃ i : Fin n,(e^[i.val]) '' U
    · obtain ⟨i,b,hb,rfl⟩ := mem_iUnion.mp ht
      right
      refine mem_iUnion.mpr ⟨i,b,⟨hb,?_⟩,rfl⟩
      by_contra h
      change ¬(¬Marker.MarkedBlock hr zero one (word e q n b) ∨
        D (word e q n b) i≠p (e^[i.val] b)) at h
      push Not at h
      exact hx (marked_tower_decode_symbol e p q hn hr zero one h01 D b i h.1 h.2)
    · exact Or.inl ht
  calc
    _ ≤ μ ((⋃ i : Fin n,(e^[i.val]) '' U)ᶜ ∪ ⋃ i : Fin n,(e^[i.val]) '' Bad i) := measure_mono hsub
    _ ≤ μ (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ + μ (⋃ i : Fin n,(e^[i.val]) '' Bad i) := measure_union_le _ _
    _ ≤ μ (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ + ∑' i : Fin n,μ ((e^[i.val]) '' Bad i) :=
      add_le_add_right (measure_iUnion_le _) _
    _ = _ := by simp only [measure_iterate_image μ e he,tsum_fintype]

theorem marked_tower_decode_error (μ : Measure X) (e : X ≃ᵐ X)
    (he : MeasurePreserving e μ μ) (p : X → C) (q : X → A)
    {n r : ℕ} (hn : 0 < n) (hr : r < n) (zero one : A) (h01 : zero≠one)
    (D : (Fin n → A) → (Fin n → C)) (U : Set X) :
    let Bad := U ∩ {b | ¬Marker.MarkedBlock hr zero one (word e q n b) ∨
      D (word e q n b)≠word e p n b}
    μ {x | Marker.decodeWindow hn hr zero one D
      (word e q (2*n) (integerIterate e (-(n : ℤ)) x))≠p x} ≤
      μ (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ + (n : ℝ≥0∞)*μ Bad := by
  intro Bad
  have hsub : {x | Marker.decodeWindow hn hr zero one D
      (word e q (2*n) (integerIterate e (-(n : ℤ)) x))≠p x} ⊆
      (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ ∪ ⋃ i : Fin n,(e^[i.val]) '' Bad := by
    intro x hx
    by_cases ht : x∈⋃ i : Fin n,(e^[i.val]) '' U
    · obtain ⟨i,b,hb,rfl⟩ := mem_iUnion.mp ht
      right
      refine mem_iUnion.mpr ⟨i,b,⟨hb,?_⟩,rfl⟩
      by_contra h
      change ¬(¬Marker.MarkedBlock hr zero one (word e q n b) ∨
        D (word e q n b)≠word e p n b) at h
      push Not at h
      exact hx (marked_tower_decode_level e p q hn hr zero one h01 D b h.1 h.2 i)
    · exact Or.inl ht
  calc
    _ ≤ μ ((⋃ i : Fin n,(e^[i.val]) '' U)ᶜ ∪ ⋃ i : Fin n,(e^[i.val]) '' Bad) := measure_mono hsub
    _ ≤ μ (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ + μ (⋃ i : Fin n,(e^[i.val]) '' Bad) := measure_union_le _ _
    _ ≤ μ (⋃ i : Fin n,(e^[i.val]) '' U)ᶜ + ∑' i : Fin n,μ ((e^[i.val]) '' Bad) :=
      add_le_add_right (measure_iUnion_le _) _
    _ = _ := by simp only [measure_iterate_image μ e he,tsum_fintype,Finset.sum_const,
      Finset.card_univ,Fintype.card_fin,nsmul_eq_mul]

end HyperbolicCoding

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

noncomputable def extendPrefixDecoder {k t : ℕ} (D : (Fin (k+t) → A) → (Fin k → C))
    (c₀ : C) (w : Fin (k+t) → A) : Fin (k+t) → C :=
  Fin.addCases (D w) (fun _ => c₀)

theorem marked_tower_prefix_decoder_error (μ : Measure X) [IsFiniteMeasure μ]
    (e : X ≃ᵐ X) (he : MeasurePreserving e μ μ)
    (p : X → C) (q : X → A) {k t r : ℕ} (hn : 0 < k+t) (hr : r < k+t)
    (zero one : A) (h01 : zero≠one)
    (D : (Fin (k+t) → A) → (Fin k → C)) (c₀ : C)
    {U : Set X} (hU : MeasurableSet U)
    (hmarked : ∀ᵐ b ∂μ.restrict U,Marker.MarkedBlock hr zero one (word e q (k+t) b)) :
    μ.real {x | Marker.decodeWindow hn hr zero one (extendPrefixDecoder D c₀)
      (word e q (2*(k+t)) (integerIterate e (-((k+t : ℕ) : ℤ)) x))≠p x} ≤
      μ.real (⋃ i : Fin (k+t),(e^[i.val]) '' U)ᶜ +
      (k+t : ℕ)*μ.real (U∩{b | D (word e q (k+t) b)≠word e p k b})+
      (t : ℝ)*μ.real U := by
  let E := U∩{b | D (word e q (k+t) b)≠word e p k b}
  let Bad := fun i : Fin (k+t) => U∩{b |
    ¬Marker.MarkedBlock hr zero one (word e q (k+t) b) ∨
      extendPrefixDecoder D c₀ (word e q (k+t) b) i≠p (e^[i.val] b)}
  have hmain := marked_tower_decode_error_sum μ e he p q hn hr zero one h01
    (extendPrefixDecoder D c₀) U
  dsimp only at hmain
  have hhead (i : Fin k) : μ (Bad (Fin.castAdd t i)) ≤ μ E := by
    apply measure_mono_ae
    filter_upwards [(ae_restrict_iff' hU).mp hmarked] with b hb
    intro hbad
    refine ⟨hbad.1,?_⟩
    intro hEq
    have hm := hb hbad.1
    have hd := hbad.2.resolve_left (not_not.mpr hm)
    apply hd
    simp only [extendPrefixDecoder,Fin.addCases_left,hEq,word]
    rfl
  have htail (i : Fin t) : μ (Bad (Fin.natAdd k i)) ≤ μ U :=
    measure_mono (inter_subset_left)
  have hsum : (∑ i : Fin (k+t),μ (Bad i))≤(k : ℝ≥0∞)*μ E+(t : ℝ≥0∞)*μ U := by
    rw [Fin.sum_univ_add]
    apply add_le_add
    · simpa only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] using
        Finset.sum_le_sum (s := Finset.univ) (fun i _ => hhead i)
    · simpa only [Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul] using
        Finset.sum_le_sum (s := Finset.univ) (fun i _ => htail i)
  have hEfin : μ E≠⊤ := measure_ne_top _ _
  have hweak : (k : ℝ≥0∞)*μ E≤((k+t : ℕ) : ℝ≥0∞)*μ E :=
    by gcongr; exact_mod_cast Nat.le_add_right k t
  have hbound := hmain.trans (add_le_add_right (hsum.trans (add_le_add_left hweak _)) _)
  have hfin : μ (⋃ i : Fin (k+t),(e^[i.val]) '' U)ᶜ+
      (((k+t : ℕ) : ℝ≥0∞)*μ E+(t : ℝ≥0∞)*μ U)≠⊤ := by finiteness
  have hreal := ENNReal.toReal_mono hfin hbound
  rw [ENNReal.toReal_add (measure_ne_top _ _) (by finiteness),
    ENNReal.toReal_add (by finiteness) (by finiteness)] at hreal
  simpa only [ENNReal.toReal_mul, ENNReal.toReal_natCast, Measure.real, add_assoc, E] using hreal

end HyperbolicCoding

end
section
namespace HyperbolicCoding.MatrixCoupling
open scoped BigOperators
variable {A B : Type*} [Fintype A] [Fintype B] [DecidableEq A] [DecidableEq B] [Nonempty A]
    {p : A → ℝ} {q : B → ℝ}

theorem exists_decodable_coupling_scaled (r : MatrixCoupling p q) (hq : ∑ b,q b=1)
    (c : A → B → ℝ) (hc0 : ∀ a b,0≤c a b) (hc1 : ∀ a b,c a b≤1)
    {τ M : ℝ} (hτ : 0 < τ) (hM : ∀ b,q b≤M) :
    ∃ (D : B → A) (R : MatrixCoupling p q),
      R.cost (fun a b => symbolCost a (D b))≤Real.sqrt ((Fintype.card A : ℝ)*M+τ*r.cost c) ∧
      R.cost c≤r.cost c+(Fintype.card A : ℝ)*M/τ+
        Real.sqrt ((Fintype.card A : ℝ)*M+τ*r.cost c) := by
  obtain ⟨D,hD⟩ := r.exists_rounded_decoder hq (fun a b => τ*c a b) hM
  let E : ℝ := ∑ a,|assignedMass q D a-p a|
  let C : ℝ := ∑ b,q b*c (D b) b
  have hE : 0≤E := Finset.sum_nonneg (fun a _ => abs_nonneg _)
  have hC : 0≤C := Finset.sum_nonneg (fun b _ => mul_nonneg (r.right_nonneg b) (hc0 _ _))
  have hsum : (∑ b,q b*(τ*c (D b) b))=τ*C := by
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro b _
    ring
  have hscaledCost : r.cost (fun left right => τ*c left right)=τ*r.cost c := by
    simp only [cost,Finset.mul_sum,mul_left_comm]
  rw [hscaledCost,hsum] at hD
  change E^2+τ*C≤(Fintype.card A : ℝ)*M+τ*r.cost c at hD
  have hnonneg : 0≤(Fintype.card A : ℝ)*M+τ*r.cost c := by
    nlinarith [sq_nonneg E,mul_nonneg hτ.le hC]
  have herror : E≤Real.sqrt ((Fintype.card A : ℝ)*M+τ*r.cost c) := by
    nlinarith [Real.sq_sqrt hnonneg,Real.sqrt_nonneg ((Fintype.card A : ℝ)*M+τ*r.cost c),
      mul_nonneg hτ.le hC]
  have hcost : C≤r.cost c+(Fintype.card A : ℝ)*M/τ := by
    have h := (le_div_iff₀ hτ).mpr (show C*τ≤(Fintype.card A : ℝ)*M+τ*r.cost c by
      nlinarith [sq_nonneg E])
    apply h.trans_eq
    field_simp
    ring
  obtain ⟨R,hdecode,hpaint⟩ := r.repair_assignment hq D c hc0 hc1
  refine ⟨D,R,hdecode.trans herror,?_⟩
  change R.cost c≤C+E at hpaint
  linarith

noncomputable def decodingThreshold (ε : ℝ) : ℝ :=
  min (ε^2/16) ((ε^2/16)*ε/4)

lemma decodingThreshold_pos {ε : ℝ} (hε : 0<ε) : 0<decodingThreshold ε :=
  lt_min (by positivity) (by positivity)

theorem decodable_coupling_tolerance {ε : ℝ} (hε : 0<ε)
    (r : MatrixCoupling p q) (hq : (∑ b,q b)=1)
    (c : A → B → ℝ) (hc0 : ∀ a b,0≤c a b) (hc1 : ∀ a b,c a b≤1)
    (M : ℝ) (hM : ∀ b,q b≤M) (hsmall : (Fintype.card A : ℝ)*M≤decodingThreshold ε) :
    ∃ (D : B → A) (R : MatrixCoupling p q),
      R.cost (fun a b => symbolCost a (D b))<ε ∧ R.cost c<r.cost c+ε := by
  let τ : ℝ := ε^2/16
  have hτ : 0<τ := by dsimp [τ]; positivity
  have hr1 : r.cost c≤1 := by
    calc
      r.cost c≤r.cost (fun _ _ => 1) := r.cost_mono _ _ hc1
      _=1 := by
        unfold cost
        simp only [mul_one]
        rw [Finset.sum_comm]
        simp only [r.col,hq]
  obtain ⟨D,R,hD,hR⟩ := r.exists_decodable_coupling_scaled hq c hc0 hc1 hτ hM
  have hs : Real.sqrt ((Fintype.card A : ℝ)*M+τ*r.cost c)<ε/2 := by
    apply (Real.sqrt_lt' (by positivity : 0<ε/2)).mpr
    have h1 : (Fintype.card A : ℝ)*M≤ε^2/16 := hsmall.trans (min_le_left _ _)
    have h2 := mul_le_mul_of_nonneg_left hr1 hτ.le
    dsimp [τ] at h2 ⊢
    nlinarith [sq_pos_of_pos hε]
  have hd : (Fintype.card A : ℝ)*M/τ≤ε/4 := by
    apply (div_le_iff₀ hτ).mpr
    have hb := hsmall.trans (min_le_right _ _)
    change _≤τ*ε/4 at hb
    nlinarith
  exact ⟨D,R,hD.trans_lt (hs.trans (by linarith)),by linarith⟩

theorem exists_decodable_coupling_tolerance {ε : ℝ} (hε : 0<ε) :
    ∃ θ : ℝ,0<θ ∧ ∀ (p : A → ℝ) (q : B → ℝ) (r : MatrixCoupling p q), (∑ b,q b)=1 →
      ∀ (c : A → B → ℝ), (∀ a b,0≤c a b) → (∀ a b,c a b≤1) →
      ∀ M : ℝ,(∀ b,q b≤M) → (Fintype.card A : ℝ)*M≤θ →
      ∃ (D : B → A) (R : MatrixCoupling p q),
        R.cost (fun a b => symbolCost a (D b))<ε ∧ R.cost c<r.cost c+ε :=
  ⟨decodingThreshold ε,decodingThreshold_pos hε,fun _ _ r hq c hc0 hc1 M hM hsmall =>
    decodable_coupling_tolerance hε r hq c hc0 hc1 M hM hsmall⟩

end HyperbolicCoding.MatrixCoupling

end

end OAI