lean/OAI/Dynamics/StandardMap/Coding/EntropyRateCodebook.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Entropy.FiniteBinCoding
import OAI.Dynamics.StandardMap.Coding.TypicalWordCodebook

namespace OAI

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

omit [DecidableEq A] in
theorem entropy_rate_codebook (f : X → X) (hf : MeasurePreserving f μ μ)
    (htotal : ∀ (m : ℕ), 0 < m → Ergodic (f^[m]) μ)
    (p : X → A) (hp : Measurable p) {δ : ℝ} (hδ : 0<δ) :
    ∃ m : ℕ, 0 < m ∧ ∀ ε : ℝ,0<ε → ∀ᶠ n : ℕ in atTop,
      ∃ S : Finset (Fin (n*m) → A),
        (S.card : ℝ)≤Real.exp ((n*m : ℕ)*(rate μ f p+δ)) ∧
        μ.real {x | word f p (n*m) x∉S}<ε := by
  have hlim := (tendsto_order.mp (rate_tendsto μ f hf p hp)).2
    (rate μ f p+δ/2) (by linarith)
  obtain ⟨m,hm,hmrate⟩ := (eventually_gt_atTop 0 |>.and hlim).exists
  have hmr : 0<(m : ℝ) := Nat.cast_pos.mpr hm
  have hblock : obs μ (word f p m)<(m : ℝ)*(rate μ f p+δ/2) := by
    exact (div_lt_iff₀ hmr).mp hmrate |>.trans_eq (mul_comm _ _)
  refine ⟨m,hm,?_⟩
  intro ε hε
  have htyp := eventually_upper_information_codebook μ (f^[m]) (htotal m hm)
    (word f p m) (word_measurable f hf.measurable p hp m)
    (δ:=(m : ℝ)*δ/2) (by positivity) hε
  filter_upwards [htyp] with n hn
  obtain ⟨B,hB,hbad⟩ := hn
  let S := B.map (wordPack n m).symm.toEmbedding
  have hmem (w : Fin (n*m) → A) : w∈S ↔ wordPack n m w∈B := by
    simp only [S,Finset.mem_map,Equiv.toEmbedding_apply]
    constructor
    · rintro ⟨b,hb,rfl⟩
      simpa using hb
    · intro hw
      exact ⟨wordPack n m w,hw,(wordPack n m).symm_apply_apply w⟩
  refine ⟨S,?_,?_⟩
  · have hcard : S.card=B.card := Finset.card_map _
    rw [hcard]
    apply hB.trans (Real.exp_le_exp.mpr ?_)
    have hn0 : (0 : ℝ)≤n := Nat.cast_nonneg n
    push_cast
    nlinarith
  · convert hbad using 1
    congr 1
    ext x
    simp only [mem_ofPred_eq,hmem,wordPack_apply]

end HyperbolicCoding

end
section
namespace HyperbolicCoding.Marker
open scoped BigOperators
variable {A C : Type*} {n r : ℕ}

def HeadMarker (hr : r < n) (zero one : A) (w : Fin n → A) : Prop :=
  (∀ j : Fin r, w ⟨j.val,lt_trans j.isLt hr⟩=zero) ∧ w ⟨r,hr⟩=one

def MarkedBlock (hr : r < n) (zero one : A) (w : Fin n → A) : Prop :=
  HeadMarker hr zero one w ∧
    ∀ j : Fin n,0 < j.val → ∃ (l : Fin r) (h : j.val+l.val < n), w ⟨j.val+l.val,h⟩=one

def centeredWindow (n : ℕ) (a : ℤ → A) (i : Fin n) : Fin (2*n) → A :=
  fun j => a ((i.val : ℤ)+(j.val : ℤ)-(n : ℤ))

def column (v : Fin (2*n) → A) (t : Fin n) : Fin n → A :=
  fun j => v ⟨n-t.val+j.val,by omega⟩

lemma column_centeredWindow (a : ℤ → A) (i t j : Fin n) :
    column (centeredWindow n a i) t j = a ((i.val : ℤ)-(t.val : ℤ)+(j.val : ℤ)) := by
  unfold column centeredWindow
  congr 1
  rw [Nat.cast_add,Nat.cast_sub (by omega : t.val≤n)]
  ring

lemma self_column_centeredWindow (a : ℤ → A) (i : Fin n) :
    column (centeredWindow n a i) i = fun j : Fin n => a (j.val : ℤ) := by
  funext j
  rw [column_centeredWindow,sub_self,zero_add]

noncomputable def candidates (hr : r < n) (zero one : A) (v : Fin (2*n) → A) : Finset (Fin n) := by
  classical
  exact Finset.univ.filter (fun t => HeadMarker hr zero one (column v t))

lemma mem_candidates (hr : r < n) (zero one : A) (v : Fin (2*n) → A) (t : Fin n) :
    t∈candidates hr zero one v ↔ HeadMarker hr zero one (column v t) := by
  classical
  simp [candidates]

noncomputable def phase (hn : 0 < n) (hr : r < n) (zero one : A) (v : Fin (2*n) → A) : Fin n :=
  if h : (candidates hr zero one v).Nonempty then (candidates hr zero one v).min' h
    else ⟨0,hn⟩

lemma phase_eq_of_no_earlier (hn : 0 < n) (hr : r < n) (zero one : A) (v : Fin (2*n) → A)
    (i : Fin n) (hi : HeadMarker hr zero one (column v i))
    (hbefore : ∀ t : Fin n,t < i → ¬HeadMarker hr zero one (column v t)) :
    phase hn hr zero one v=i := by
  classical
  have hm : i∈candidates hr zero one v := (mem_candidates hr zero one v i).mpr hi
  have hs : (candidates hr zero one v).Nonempty := ⟨i,hm⟩
  rw [phase,dite_eq_left hs]
  apply le_antisymm (Finset.min'_le _ _ hm)
  by_contra h
  have ht : (candidates hr zero one v).min' hs < i := lt_of_not_ge h
  exact hbefore _ ht ((mem_candidates hr zero one v _).mp (Finset.min'_mem _ hs))

theorem phase_centeredWindow (hn : 0 < n) (hr : r < n) (zero one : A) (h01 : zero≠one)
    (a : ℤ → A) (hblock : MarkedBlock hr zero one (fun j : Fin n => a (j.val : ℤ)))
    (i : Fin n) : phase hn hr zero one (centeredWindow n a i)=i := by
  apply phase_eq_of_no_earlier hn hr zero one _ i
  · rw [self_column_centeredWindow]
    exact hblock.1
  · intro t ht hm
    have hti : t.val < i.val := ht
    let j : Fin n := ⟨i.val-t.val,by omega⟩
    have hj : 0 < j.val := by dsimp [j]; omega
    obtain ⟨l,hl,hb⟩ := hblock.2 j hj
    have hz := hm.1 l
    rw [column_centeredWindow] at hz
    have heq : (i.val : ℤ)-(t.val : ℤ)+(l.val : ℤ) = ((j.val+l.val : ℕ) : ℤ) := by
      dsimp [j]
      omega
    rw [heq] at hz
    exact h01 (hz.symm.trans hb)

noncomputable def decodeWindow (hn : 0 < n) (hr : r < n) (zero one : A)
    (D : (Fin n → A) → (Fin n → C)) (v : Fin (2*n) → A) : C :=
  D (column v (phase hn hr zero one v)) (phase hn hr zero one v)

theorem decode_centeredWindow (hn : 0 < n) (hr : r < n) (zero one : A) (h01 : zero≠one)
    (D : (Fin n → A) → (Fin n → C)) (a : ℤ → A)
    (hblock : MarkedBlock hr zero one (fun j : Fin n => a (j.val : ℤ))) (i : Fin n) :
    decodeWindow hn hr zero one D (centeredWindow n a i)=D (fun j : Fin n => a (j.val : ℤ)) i := by
  unfold decodeWindow
  rw [phase_centeredWindow hn hr zero one h01 a hblock i,self_column_centeredWindow]

section Construction

def markWord (r : ℕ) (zero one : A) (w : Fin n → A) (i : Fin n) : A :=
  if i.val < r then zero else if i.val%r=0 ∨ i.val+1=n then one else w i

lemma exists_multiple_window (hr : 0 < r) (j : ℕ) :
    ∃ k : ℕ,j≤k ∧ k < j+r ∧ k%r=0 := by
  by_cases hj : j%r=0
  · exact ⟨j,le_rfl,by omega,hj⟩
  · have hm : j%r < r := Nat.mod_lt j hr
    have he := Nat.mod_add_div j r
    refine ⟨j+(r-j%r),by omega,by omega,?_⟩
    have hk : j+(r-j%r)=r*(j/r+1) := by
      rw [Nat.mul_add,Nat.mul_one]
      omega
    rw [hk,Nat.mul_mod_right]

lemma exists_guard (hr0 : 0 < r) (hr : r < n) (j : Fin n) (hj : 0 < j.val) :
    ∃ k : Fin n, j.val≤k.val ∧ k.val < j.val+r ∧ r≤k.val ∧
      (k.val%r=0 ∨ k.val+1=n) := by
  by_cases hjr : j.val < r
  · exact ⟨⟨r,hr⟩,hjr.le,by dsimp only; omega,le_rfl,Or.inl (Nat.mod_self r)⟩
  · obtain ⟨k,hjk,hkr,hm⟩ := exists_multiple_window hr0 j.val
    by_cases hkn : k < n
    · exact ⟨⟨k,hkn⟩,hjk,hkr,(by dsimp only; omega),Or.inl hm⟩
    · refine ⟨⟨n-1,by omega⟩,by dsimp only; omega,by dsimp only; omega,by dsimp only; omega,Or.inr (by dsimp only; omega)⟩

theorem markWord_isMarked (hr0 : 0 < r) (hr : r < n) (zero one : A) (w : Fin n → A) :
    MarkedBlock hr zero one (markWord r zero one w) := by
  constructor
  · constructor
    · intro j
      simp only [markWord,j.isLt,↓reduceIte]
    · simp [markWord]
  · intro j hj
    obtain ⟨k,hjk,hkr,hrk,hk⟩ := exists_guard hr0 hr j hj
    let l : Fin r := ⟨k.val-j.val,by omega⟩
    have he : j.val+l.val=k.val := by dsimp [l]; omega
    refine ⟨l,by omega,?_⟩
    simp only [markWord,he,not_lt.mpr hrk,↓reduceIte,hk]

end Construction
end HyperbolicCoding.Marker

end
section
namespace HyperbolicCoding.Marker
open scoped BigOperators
variable {A : Type*} [Fintype A] [DecidableEq A] {n r : ℕ}

def reserved (n r : ℕ) : Finset (Fin n) :=
  Finset.univ.filter (fun i => i.val < r ∨ i.val%r=0 ∨ i.val+1=n)

omit [Fintype A] [DecidableEq A] in
lemma markWord_eq_outside (zero one : A) (w : Fin n → A) (i : Fin n)
    (hi : i∉reserved n r) : markWord r zero one w i=w i := by
  simp only [reserved,Finset.mem_filter,Finset.mem_univ,true_and,not_or] at hi
  simp only [markWord,hi.1,hi.2.1,hi.2.2,or_self,↓reduceIte]

lemma reserved_card (_hr : 0 < r) : (reserved n r).card ≤ r+n/r+2 := by
  let F : reserved n r → (Fin r ⊕ (Fin (n/r+1) ⊕ Unit)) := fun i =>
    if hi : i.val.val < r then Sum.inl ⟨i.val.val,hi⟩
    else if hd : i.val.val%r=0 then Sum.inr (Sum.inl ⟨i.val.val/r,by
      have h := Nat.div_le_div_right (Nat.le_of_lt i.val.isLt) (c:=r)
      omega⟩)
    else Sum.inr (Sum.inr ())
  have hF : Function.Injective F := by
    intro i j hij
    apply Subtype.ext
    apply Fin.ext
    have hi := (Finset.mem_filter.mp i.property).2
    have hj := (Finset.mem_filter.mp j.property).2
    by_cases hi₀ : i.val.val < r
    · by_cases hj₀ : j.val.val < r
      · simpa [F,hi₀,hj₀] using hij
      · simp only [F,dite_eq_left hi₀,dite_eq_right hj₀] at hij
        split_ifs at hij
    · by_cases hj₀ : j.val.val < r
      · simp only [F,dite_eq_right hi₀,dite_eq_left hj₀] at hij
        split_ifs at hij
      · by_cases hi₁ : i.val.val%r=0
        · by_cases hj₁ : j.val.val%r=0
          · have hquot : i.val.val/r=j.val.val/r := by
              simpa [F,hi₀,hj₀,hi₁,hj₁] using hij
            have hq1 := Nat.mod_add_div i.val.val r
            have hq2 := Nat.mod_add_div j.val.val r
            rw [hquot] at hq1
            omega
          · simp [F,hi₀,hj₀,hi₁,hj₁] at hij
        · by_cases hj₁ : j.val.val%r=0
          · simp [F,hi₀,hj₀,hi₁,hj₁] at hij
          · omega
  have h := Fintype.card_le_of_injective F hF
  simpa only [Fintype.card_coe,Fintype.card_sum,Fintype.card_fin,Fintype.card_unit,
    ←Nat.add_assoc] using h

omit [Fintype A] [DecidableEq A] in
lemma markWord_cost (zero one : A) (w : Fin n → A) :
    nameCost w (markWord r zero one w) ≤ (reserved n r).card := by
  calc
    _ ≤ ∑ i : Fin n,if i∈reserved n r then (1 : ℝ) else 0 := by
      unfold nameCost
      apply Finset.sum_le_sum
      intro i _
      by_cases hi : i∈reserved n r
      · simp only [ite_eq_left hi]
        exact symbolCost_le_one _ _
      · rw [ite_eq_right hi,markWord_eq_outside zero one w i hi]
        simp [symbolCost]
    _ = _ := by simp

omit [Fintype A] [DecidableEq A] in
lemma markWord_cost_le (hr : 0 < r) (zero one : A) (w : Fin n → A) :
    nameCost w (markWord r zero one w) ≤ (r+n/r+2 : ℕ) :=
  (markWord_cost zero one w).trans (by exact_mod_cast reserved_card (n:=n) hr)

lemma overwrite_fiber_card (S : Finset (Fin n)) (f : (Fin n → A) → (Fin n → A))
    (hf : ∀ w i,i∉S → f w i=w i) (v : Fin n → A) :
    Fintype.card {w : Fin n → A // f w=v} ≤ (Fintype.card A)^S.card := by
  let F : {w : Fin n → A // f w=v} → (S → A) := fun w i => w.val i.val
  have hF : Function.Injective F := by
    intro w z hwz
    apply Subtype.ext
    funext i
    by_cases hi : i∈S
    · exact congrFun hwz ⟨i,hi⟩
    · calc
        w.val i = f w.val i := (hf w.val i hi).symm
        _ = v i := congrFun w.property i
        _ = f z.val i := (congrFun z.property i).symm
        _ = z.val i := hf z.val i hi
  simpa only [Fintype.card_fun,Fintype.card_coe] using Fintype.card_le_of_injective F hF

lemma markWord_fiber_card (zero one : A) (v : Fin n → A) :
    Fintype.card {w : Fin n → A // markWord r zero one w=v} ≤
      (Fintype.card A)^(reserved n r).card :=
  overwrite_fiber_card (reserved n r) (markWord r zero one)
    (markWord_eq_outside zero one) v

end HyperbolicCoding.Marker

end
section
namespace HyperbolicCoding
open Filter
open scoped Topology

lemma marked_entropy_exponent_bound (a h δ : ℝ) (ha : 1≤a) (K r m n : ℕ)
    (hr : 0<r)
    (hδ : (2*(K : ℝ)+1)*δ≤h/4)
    (hguard : ((K : ℝ)+1)*Real.log a/(r : ℝ)≤h/4) :
    2*Real.exp ((n*K*m : ℕ)*(h+δ))*a^(Marker.reserved (n*K*m+n*m) r).card*
      Real.exp (-((n*K*m+n*m : ℕ) : ℝ)*(h-δ)) ≤
      2*Real.exp (((r : ℝ)+2)*Real.log a-(n : ℝ)*m*(h/2)) := by
  let k := n*K*m
  let N := n*K*m+n*m
  let d := (Marker.reserved N r).card
  have ha0 : 0<a := lt_of_lt_of_le zero_lt_one ha
  have hlog : 0≤Real.log a := Real.log_nonneg ha
  have hrr : (0 : ℝ)<r := Nat.cast_pos.mpr hr
  have hd : (d : ℝ)≤(r : ℝ)+(N : ℝ)/r+2 := by
    have hd' : (d : ℝ)≤(r+N/r+2 : ℕ) := by exact_mod_cast Marker.reserved_card (n:=N) hr
    push_cast at hd'
    exact hd'.trans (by gcongr; exact Nat.cast_div_le)
  have he : (k : ℝ)*(h+δ)+(d : ℝ)*Real.log a-(N : ℝ)*(h-δ) ≤
      ((r : ℝ)+2)*Real.log a-(n : ℝ)*m*(h/2) := by
    calc
      _ ≤ (k : ℝ)*(h+δ)+((r : ℝ)+(N : ℝ)/r+2)*Real.log a-(N : ℝ)*(h-δ) := by gcongr
      _ = ((r : ℝ)+2)*Real.log a+(n : ℝ)*m*
          (-h+(2*(K : ℝ)+1)*δ+((K : ℝ)+1)*Real.log a/r) := by
        dsimp [k,N]
        push_cast
        field_simp
        ring
      _ ≤ _ := by
        have hh : -h+(2*(K : ℝ)+1)*δ+((K : ℝ)+1)*Real.log a/r ≤ -(h/2) := by linarith
        have hg := mul_le_mul_of_nonneg_left hh (show 0≤(n : ℝ)*m by positivity)
        linarith
  have hp : a^d=Real.exp ((d : ℝ)*Real.log a) := by rw [Real.exp_nat_mul,Real.exp_log ha0]
  change 2*Real.exp ((k : ℝ)*(h+δ))*a^d*Real.exp (-(N : ℝ)*(h-δ))≤_
  rw [hp,mul_assoc (2 : ℝ),mul_assoc (2 : ℝ),←Real.exp_add,←Real.exp_add]
  apply mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr _) (by norm_num)
  convert he using 1
  ring

theorem exists_entropy_slack_parameters (a h ε : ℝ) (ha : 1≤a) (hh : 0<h) (hε : 0<ε) :
    ∃ K r : ℕ,0<K ∧ 0<r ∧ ∃ δ : ℝ,0<δ ∧
      (1 : ℝ)/(K+1 : ℕ)<ε ∧
      ∀ m : ℕ, 0 < m → ∀ M : ℝ, 0 < M → ∀ᶠ n : ℕ in atTop,
        0<n ∧ r<n*K*m+n*m ∧
        ((n*m : ℕ) : ℝ)/(n*K*m+n*m : ℕ)<ε ∧
        ((Marker.reserved (n*K*m+n*m) r).card : ℝ)/(n*K*m+n*m : ℕ)<ε ∧
        2*Real.exp ((n*K*m : ℕ)*(h+δ))*a^(Marker.reserved (n*K*m+n*m) r).card*
          Real.exp (-((n*K*m+n*m : ℕ) : ℝ)*(h-δ))<M := by
  obtain ⟨K,hK⟩ := exists_nat_gt (max (1 : ℝ) (1/ε))
  have hKpos : 0<K := by exact_mod_cast lt_trans zero_lt_one ((le_max_left _ _).trans_lt hK)
  have hKR : 0<(K : ℝ)+1 := by positivity
  have htail : (1 : ℝ)/(K+1 : ℕ)<ε := by
    apply (div_lt_iff₀ (by positivity)).mpr
    have hg := (div_lt_iff₀ hε).mp ((le_max_right _ _).trans_lt hK)
    push_cast
    nlinarith
  obtain ⟨r,hr⟩ := exists_nat_gt (max 1 (max (4*((K : ℝ)+1)*Real.log a/h) (4/ε)))
  have hrpos : 0<r := by exact_mod_cast lt_trans zero_lt_one ((le_max_left _ _).trans_lt hr)
  have hrr : (0 : ℝ)<r := Nat.cast_pos.mpr hrpos
  have hguard : ((K : ℝ)+1)*Real.log a/r≤h/4 := by
    apply (div_le_iff₀ hrr).mpr
    have hg := (div_lt_iff₀ hh).mp
      ((le_max_left _ _).trans_lt ((le_max_right _ _).trans_lt hr))
    nlinarith
  have hrsmall : (1 : ℝ)/r<ε/4 := by
    apply (div_lt_iff₀ hrr).mpr
    have hg := (div_lt_iff₀ hε).mp
      ((le_max_right _ _).trans_lt ((le_max_right _ _).trans_lt hr))
    nlinarith
  let δ : ℝ := h/(8*((K : ℝ)+1))
  have hδpos : 0<δ := div_pos hh (by positivity)
  have hδ : (2*(K : ℝ)+1)*δ≤h/4 := by
    have heq : (8*((K : ℝ)+1))*δ=h := by dsimp [δ]; field_simp
    have hg : 0≤δ := hδpos.le
    nlinarith
  refine ⟨K,r,hKpos,hrpos,δ,hδpos,htail,?_⟩
  intro m hm M hM
  let C := ((r : ℝ)+2)*Real.log a
  obtain ⟨n₀,hn₀⟩ := exists_nat_gt (max ((r : ℝ)+1)
    (max (4*((r : ℝ)+2)/ε) (2*(C-Real.log (M/2))/h)))
  filter_upwards [eventually_ge_atTop n₀] with n hn
  have hnr : (n₀ : ℝ)≤n := by exact_mod_cast hn
  have hlarge := hn₀.trans_le hnr
  have hnr' : (r : ℝ)+1<(n : ℝ) := (le_max_left _ _).trans_lt hlarge
  have hnp : 0 < n := by
    exact_mod_cast (lt_trans (by positivity : (0 : ℝ)<(r : ℝ)+1) hnr')
  have hnm : n≤n*m := Nat.le_mul_of_pos_right n hm
  have hnN : n≤n*K*m+n*m := hnm.trans (Nat.le_add_left _ _)
  have hnNR : (n : ℝ)≤(n*K*m+n*m : ℕ) := by exact_mod_cast hnN
  have hnR : (0 : ℝ)<n := Nat.cast_pos.mpr hnp
  have hN : (0 : ℝ)<(n*K*m+n*m : ℕ) := hnR.trans_le hnNR
  refine ⟨hnp,?_,?_,?_,?_⟩
  · have : r<n := by exact_mod_cast (show (r : ℝ)<n by linarith)
    exact this.trans_le hnN
  · have hem : ((n*m : ℕ) : ℝ)/(n*K*m+n*m : ℕ)=(1 : ℝ)/(K+1 : ℕ) := by
      push_cast
      have hmR : (0 : ℝ) < m := Nat.cast_pos.mpr hm
      field_simp
    simpa only [hem] using htail
  · have hd : ((Marker.reserved (n*K*m+n*m) r).card : ℝ)≤
        (r : ℝ)+((n*K*m+n*m : ℕ) : ℝ)/r+2 := by
      have hd' : ((Marker.reserved (n*K*m+n*m) r).card : ℝ)≤(r+(n*K*m+n*m)/r+2 : ℕ) :=
        by exact_mod_cast Marker.reserved_card (n:=n*K*m+n*m) hrpos
      push_cast at hd'
      exact hd'.trans (by gcongr; exact Nat.cast_div_le)
    have hsmall : ((r : ℝ)+2)/((n*K*m+n*m : ℕ) : ℝ)<ε/4 := by
      apply (div_lt_iff₀ hN).mpr
      have ht := (div_lt_iff₀ hε).mp
        ((le_max_left _ _).trans_lt ((le_max_right _ _).trans_lt hlarge))
      have hg := mul_le_mul_of_nonneg_left hnNR hε.le
      nlinarith
    have hdivide := div_le_div_of_nonneg_right hd hN.le
    have heq : ((r : ℝ)+((n*K*m+n*m : ℕ) : ℝ)/r+2)/((n*K*m+n*m : ℕ) : ℝ)=
        ((r : ℝ)+2)/((n*K*m+n*m : ℕ) : ℝ)+(1 : ℝ)/r := by field_simp; ring
    rw [heq] at hdivide
    linarith
  · apply lt_of_le_of_lt (marked_entropy_exponent_bound a h δ ha K r m n hrpos hδ hguard)
    have ht := (div_lt_iff₀ hh).mp
      ((le_max_right _ _).trans_lt ((le_max_right _ _).trans_lt hlarge))
    have hnmR : (n : ℝ)≤(n : ℝ)*m := by exact_mod_cast hnm
    have hg := mul_le_mul_of_nonneg_right hnmR hh.le
    have hexp : C-(n : ℝ)*m*(h/2)<Real.log (M/2) := by nlinarith
    have he := Real.exp_lt_exp.mpr hexp
    rw [Real.exp_log (by positivity : 0<M/2)] at he
    change 2*Real.exp (C-(n : ℝ)*m*(h/2))<M
    linarith

end HyperbolicCoding

end

end OAI