lean/OAI/Dynamics/StandardMap/Entropy/LocallyFiniteLower.lean

import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Entropy.PhysicalVolume

namespace OAI

section
section
namespace StandardMapEntropy.LocalCoding
open MeasureTheory Set Filter
open scoped Topology ENNReal BigOperators
variable {ι : Type*} [DecidableEq ι] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι]
variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]

def codeFiber (f : Ω → Ω) (p : Ω → ι) (N : ℕ) (x : Ω) : Set Ω :=
  {y | ∀ i : ℕ,i≤N → p (f^[i] y)=p (f^[i] x)}

omit [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] [MeasurableSpace Ω] in
lemma masked_history_none_iff (f : Ω → Ω) (p : Ω → ι) (S : ι → Finset ι) (A : Finset ι) (N : ℕ) (x : Ω) :
    Entropy.history (maskedState A (reach S A N) f p) (N+1) x=(fun _ => none) ↔ p x∉A := by
  constructor
  · intro hx
    have h0 := congrFun hx ⟨0,by omega⟩
    exact (maskedState_zero_none A _ (base_subset_reach S A N) f p x).mp h0
  · intro hx
    funext i
    exact maskedState_of_not_mem A _ f p i.val hx

omit [IsProbabilityMeasure μ] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma masked_history_small_atoms (f : Ω → Ω) (hf : MeasurePreserving f μ μ)
    (p : Ω → ι) (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) (A : Finset ι) (N : ℕ) (I : ℝ)
    (hsmall : ∀ᵐ x ∂μ, μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-I)))
    (v : Fin (N+1) → Option (reach S A N)) (hv : v≠fun _ => none) :
    Entropy.mass μ (Entropy.history (maskedState A (reach S A N) f p) (N+1)) v≤Real.exp (-I) := by
  let q := Entropy.history (maskedState A (reach S A N) f p) (N+1)
  by_cases hz : μ (q ⁻¹' {v})=0
  · change (μ (q ⁻¹' {v})).toReal ≤ _
    rw [hz,ENNReal.toReal_zero]
    exact (Real.exp_pos _).le
  · obtain ⟨x,hx,hpath,hsm⟩ := Measure.exists_mem_of_measure_ne_zero_of_ae hz
      (((ae_transition_orbit μ f hf p S hS).and hsmall).filter_mono Measure.absolutelyContinuous_restrict.ae_le)
    have hA : p x∈A := by
      by_contra hnot
      exact hv (hx.symm.trans ((masked_history_none_iff f p S A N x).mpr hnot))
    have hsub : q ⁻¹' {v}⊆codeFiber f p N x := by
      intro y hy i hi
      have hr : p (f^[i] x)∈reach S A N := reach_mono S A hi
        (path_mem_reach S A (fun j => p (f^[j] x)) hA hpath i)
      have he : maskedState A (reach S A N) f p i y=truncate (reach S A N) (p (f^[i] x)) := by
        have ht := congrFun (hy.trans hx.symm) ⟨i,by omega⟩
        exact ht.trans (maskedState_of_mem A _ f p i hA)
      rw [truncate_some _ _ hr] at he
      by_cases hyA : p y∈A
      · rw [maskedState_of_mem A _ f p i hyA] at he
        exact (truncate_eq_some_iff _ _ _).mp he
      · rw [maskedState_of_not_mem A _ f p i hyA] at he
        cases he
    have hle := (measure_mono hsub).trans hsm
    exact (ENNReal.toReal_mono (by simp) hle).trans_eq (ENNReal.toReal_ofReal (Real.exp_pos _).le)

lemma masked_history_entropy_lower (f : Ω → Ω) (hf : MeasurePreserving f μ μ)
    (p : Ω → ι) (hp : Measurable p) (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x))
    (A : Finset ι) (N : ℕ) (I : ℝ)
    (hsmall : ∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-I))) :
    (1-(μ {x | p x∉A}).toReal)*I≤
      Entropy.obs μ (Entropy.history (maskedState A (reach S A N) f p) (N+1)) := by
  have hh := Entropy.obs_lower_small_atoms μ _
    (Entropy.history_measurable _ (measurable_maskedState A _ f p hf.measurable hp) _)
    (fun _ => none) I (masked_history_small_atoms μ f hf p S hS A N I hsmall)
  have he : (Entropy.history (maskedState A (reach S A N) f p) (N+1)) ⁻¹' {fun _ => none}={x | p x∉A} := by
    ext x
    exact masked_history_none_iff f p S A N x
  simpa only [Entropy.mass,he] using hh

omit [DecidableEq ι] in
lemma tendsto_code_tail (p : Ω → ι) (hp : Measurable p) :
    Tendsto (fun A : Finset ι => (μ {x | p x∉A}).toReal) atTop (𝓝 0) := by
  have hm : Monotone (fun A : Finset ι => {x : Ω | p x∈A}) := fun A B h x hx => h hx
  have hu : (⋃ A : Finset ι,{x : Ω | p x∈A})=univ := by
    ext x
    simp only [mem_iUnion,mem_ofPred_eq,mem_univ,iff_true]
    exact ⟨{p x},Finset.mem_singleton_self _⟩
  have ht := tendsto_measure_iUnion_atTop (μ:=μ) hm
  rw [hu,measure_univ] at ht
  have hr := (ENNReal.tendsto_toReal ENNReal.one_ne_top).comp ht
  have hc := (tendsto_const_nhds (x:=(1 : ℝ))).sub hr
  convert hc using 1
  · funext A
    have hset : MeasurableSet {x : Ω | p x∈A} := hp A.measurableSet
    rw [show {x : Ω | p x∉A}={x | p x∈A}ᶜ from rfl,measure_compl hset (measure_ne_top _ _),measure_univ,
      ENNReal.toReal_sub_of_le (show μ {x | p x∈A}≤1 by simpa only [measure_univ] using (measure_mono (μ:=μ) (subset_univ {x | p x∈A}))) ENNReal.one_ne_top,ENNReal.toReal_one]
    rfl
  · norm_num

lemma lower_rate_truncation (f : Ω → Ω) (hf : MeasurePreserving f μ μ) (p : Ω → ι) (hp : Measurable p)
    (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) {D : ℕ} (hD : 0<D)
    (hcard : ∀ x,(S x).card≤D) (a b : ℝ)
    (hsmall : ∀ N : ℕ,∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-(a*(N : ℝ)-b))))
    (A K : Finset ι) :
    (1-(μ {x | p x∉A}).toReal)*a≤Entropy.rate μ f (truncate K ∘ p)+(μ {x | p x∉K}).toReal*Real.log (D : ℝ) := by
  let t := (μ {x | p x∉K}).toReal*Real.log (D : ℝ)
  have ht : Tendsto (fun n : ℕ => (n : ℝ)+1) atTop atTop := tendsto_atTop_add_const_right _ _ tendsto_natCast_atTop_atTop
  have hdiv (c : ℝ) : Tendsto (fun n : ℕ => c/((n : ℝ)+1)) atTop (𝓝 0) := tendsto_const_nhds.div_atTop ht
  have hratio : Tendsto (fun n : ℕ => (n : ℝ)/((n : ℝ)+1)) atTop (𝓝 1) := by
    have h := (tendsto_const_nhds (x:=(1 : ℝ))).sub (hdiv 1)
    convert h using 1
    · funext n; field_simp; ring
    · ring_nf
  have hl := (tendsto_const_nhds (x:=1-(μ {x | p x∉A}).toReal)).mul ((hratio.const_mul a).sub (hdiv b))
  have hr := (((Entropy.rate_tendsto μ f hf (truncate K ∘ p) ((measurable_truncate K).comp hp)).comp
    (tendsto_add_atTop_nat 1)).add (hdiv (Real.log ((A.card : ℝ)+1)))).add (hratio.mul_const t)
  have hl' := hl
  simp only [mul_one,sub_zero] at hl'
  have hr' := hr
  simp only [add_zero,one_mul] at hr'
  apply le_of_tendsto_of_tendsto hl' hr'
  apply Filter.Eventually.of_forall
  intro n
  have hh := (masked_history_entropy_lower μ f hf p hp S hS A n (a*(n : ℝ)-b) (hsmall n)).trans
    (masked_history_entropy_upper μ f hf p hp S hS hD hcard A K n)
  have hd : (0 : ℝ)<(n : ℝ)+1 := by positivity
  have hh' := div_le_div_of_nonneg_right hh hd.le
  convert hh' using 1 <;> simp only [Function.comp_apply,Nat.cast_add,Nat.cast_one,t] <;> field_simp

theorem lower_of_finite_rate_bound (f : Ω → Ω) (hf : MeasurePreserving f μ μ) (p : Ω → ι) (hp : Measurable p)
    (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) {D : ℕ} (hD : 0<D)
    (hcard : ∀ x,(S x).card≤D) (a b c : ℝ)
    (hsmall : ∀ N : ℕ,∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-(a*(N : ℝ)-b))))
    (hc : ∀ K : Finset ι,Entropy.rate μ f (truncate K ∘ p)≤c) : a≤c := by
  have hK (K : Finset ι) : a≤c+(μ {x | p x∉K}).toReal*Real.log (D : ℝ) := by
    have ht := ((tendsto_const_nhds (x:=(1 : ℝ))).sub (tendsto_code_tail μ p hp)).mul_const a
    have hh := le_of_tendsto' ht (fun A : Finset ι =>
      (lower_rate_truncation μ f hf p hp S hS hD hcard a b hsmall A K).trans (add_le_add (hc K) le_rfl))
    simpa only [sub_zero,one_mul] using hh
  have hh := ge_of_tendsto' (((tendsto_code_tail μ p hp).mul_const (Real.log (D : ℝ))).const_add c) hK
  simpa only [zero_mul,add_zero] using hh

end StandardMapEntropy.LocalCoding

end
section
namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped Topology ENNReal
lemma complexProjection_sub (z w : ℂ) : complexProjection (z-w)=complexProjection z-complexProjection w := by
  ext <;> simp only [complexProjection,Complex.sub_re,Complex.sub_im,Prod.fst_sub,Prod.snd_sub,QuotientAddGroup.mk_sub]

lemma adaptive_rep_radius (k χ ε δ : ℝ) (hδ : 0<δ) {z w : Torus}
    (h : adaptiveLabel (codingLevel k χ ε δ hδ) z=adaptiveLabel (codingLevel k χ ε δ hδ) w) :
    ‖complexRep z-complexRep w‖≤2*codingRadius k χ ε δ w := by
  have hh := adaptiveLabel_rep_close h
  rw [adaptiveLabel_level h] at hh
  exact hh.trans (by simpa only [←mul_div_assoc,mul_one] using
    mul_le_mul_of_nonneg_left (codingLevel_size k χ ε δ hδ w) (by norm_num : (0 : ℝ)≤2))

lemma adaptive_lift_difference (k : ℝ) (hk : 0≤k) (χ ε δ : ℝ) (hδ : 0<δ)
    (N : ℕ) (x y : Torus)
    (hword : ∀ j : ℕ,j≤N → adaptiveLabel (codingLevel k χ ε δ hδ) ((standardMap k)^[j] y)=
      adaptiveLabel (codingLevel k χ ε δ hδ) ((standardMap k)^[j] x)) :
    ∀ j : ℕ,j≤N → (standardLift k)^[j] (complexRep y)-(standardLift k)^[j] (complexRep x)=
      complexRep ((standardMap k)^[j] y)-complexRep ((standardMap k)^[j] x) := by
  let L := 9*growthBase k
  have hL : 0≤L := by have hg := growthBase_ge_four k hk; dsimp [L]; linarith
  have hr (z : Torus) : (1+L)*codingRadius k χ ε δ z≤1/100 := by
    change (1+9*growthBase k)*codingRadius k χ ε δ z≤1/100
    simpa only [abs_of_nonneg (show 0≤9*growthBase k from hL)] using codingRadius_small k χ ε hδ z
  have hr0 (z : Torus) : codingRadius k χ ε δ z≤1/100 := by
    have hp := (codingRadius_pos k χ ε hδ z).le
    nlinarith [hr z,mul_nonneg hL hp]
  have hrL (z : Torus) : L*codingRadius k χ ε δ z≤1/100 := by
    have hp := (codingRadius_pos k χ ε hδ z).le
    linarith [hr z]
  intro j
  induction j with
  | zero => intro _; rfl
  | succ j ih =>
    intro hj
    have ihj := ih (by omega)
    let d := (standardLift k)^[j+1] (complexRep y)-(standardLift k)^[j+1] (complexRep x)
    let e := complexRep ((standardMap k)^[j+1] y)-complexRep ((standardMap k)^[j+1] x)
    have hd : ‖d‖≤L*(2*codingRadius k χ ε δ ((standardMap k)^[j] x)) := by
      dsimp only [d]
      rw [Function.iterate_succ_apply',Function.iterate_succ_apply']
      apply (standardLift_lipschitz_bound k hk _ _).trans
      rw [ihj]
      exact mul_le_mul_of_nonneg_left (adaptive_rep_radius k χ ε δ hδ (hword j (by omega))) hL
    have he : ‖e‖≤2*codingRadius k χ ε δ ((standardMap k)^[j+1] x) :=
      adaptive_rep_radius k χ ε δ hδ (hword (j+1) hj)
    have hclose : ‖d-e‖<1 := by
      have hh := (norm_sub_le d e).trans (add_le_add hd he)
      nlinarith [hrL ((standardMap k)^[j] x),hr0 ((standardMap k)^[j+1] x)]
    have hproj : complexProjection d=complexProjection e := by
      simp only [d,e,complexProjection_sub,complexProjection_iterate,complexProjection_complexRep]
    exact complexProjection_eq_of_close hproj hclose

lemma adaptive_codeFiber_trapped (k : ℝ) (hk : 0≤k) (χ ε δ : ℝ) (hδ : 0<δ)
    (x : Torus) (hx : ∀ j : ℕ,FineRegular k χ ε ((standardMap k)^[j] x)) (N : ℕ) :
    ∀ y∈LocalCoding.codeFiber (standardMap k) (adaptiveLabel (codingLevel k χ ε δ hδ)) N x,
      complexRep y∈fineLiftTrapped k χ ε δ (complexRep x) N := by
  intro y hy j hj
  have hd := adaptive_lift_difference k hk χ ε δ hδ N x y hy j hj
  change ‖fineInverse k χ ε δ (complexProjection ((standardLift k)^[j] (complexRep x)))
    ((standardLift k)^[j] (complexRep y)-(standardLift k)^[j] (complexRep x))‖≤1
  rw [complexProjection_iterate,complexProjection_complexRep,hd]
  have hb := (fineInverse k χ ε δ ((standardMap k)^[j] x)).le_opNorm (complexRep ((standardMap k)^[j] y)-complexRep ((standardMap k)^[j] x))
  have hdist := adaptive_rep_radius k χ ε δ hδ (hy j hj)
  have hh := hb.trans (mul_le_mul_of_nonneg_left hdist (norm_nonneg _))
  have hc := fineInverse_codingRadius k χ ε hδ ((standardMap k)^[j] x) (hx j)
  nlinarith

lemma measurableSet_codeFiber {ι : Type*} [MeasurableSpace ι] [MeasurableSingletonClass ι]
    (f : Torus → Torus) (hf : Measurable f) (p : Torus → ι) (hp : Measurable p) (N : ℕ) (x : Torus) :
    MeasurableSet (LocalCoding.codeFiber f p N x) := by
  have he : LocalCoding.codeFiber f p N x=⋂ j : ℕ,⋂ _ : j≤N,(p ∘ f^[j]) ⁻¹' {p (f^[j] x)} := by
    ext y; simp only [LocalCoding.codeFiber,mem_ofPred_eq,mem_iInter,mem_preimage,mem_singleton_iff,Function.comp_apply]
  rw [he]
  exact MeasurableSet.iInter (fun j => MeasurableSet.iInter (fun _ => (hp.comp (hf.iterate j)) (measurableSet_singleton _)))

theorem adaptive_codeFiber_volume (k : ℝ) (hk : 0≤k) (χ ε δ : ℝ) (hδ : 0<δ)
    (hq : Real.exp (-χ+ε)+δ<1) :
    ∃ C : ℝ,0<C ∧ ∀ x : Torus,(∀ j : ℕ,FineRegular k χ ε ((standardMap k)^[j] x)) → ∀ N : ℕ,
      area (LocalCoding.codeFiber (standardMap k) (adaptiveLabel (codingLevel k χ ε δ hδ)) N x)≤
        ENNReal.ofReal (C*(Real.exp (-χ+ε)+δ)^N) := by
  obtain ⟨C,hC,hbound⟩ := exists_fineVolumeFactor_bound k χ ε hδ
  refine ⟨4*C,by positivity,?_⟩
  intro x hx N
  apply (area_le_volume_of_complexRep_subset
    (measurableSet_codeFiber _ (measurePreserving_standardMap k).measurable _
      (measurable_adaptiveLabel _ (measurable_codingLevel k χ ε δ hδ)) N x)
    (adaptive_codeFiber_trapped k hk χ ε δ hδ x hx N)).trans
  have hreg (j : ℕ) : FineRegular k χ ε (complexProjection ((standardLift k)^[j] (complexRep x))) := by
    simpa only [complexProjection_iterate,complexProjection_complexRep] using hx j
  apply (fineLiftTrapped_volume k χ ε δ hδ hq (complexRep x) hreg N).trans
  apply ENNReal.ofReal_le_ofReal
  simp only [complexProjection_complexRep]
  exact mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left (hbound x) (by norm_num)) (by positivity)

end StandardMapEntropy

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

lemma exists_fine_parameters {a χ : ℝ} (ha : 0<a) (haχ : a<χ) :
    ∃ ε δ : ℝ,0<ε ∧ 0<δ ∧ Real.exp (-χ+ε)+δ<Real.exp (-a) ∧ Real.exp (-a)<1 := by
  let ε := (χ-a)/2
  have hε : 0<ε := by dsimp [ε]; linarith
  have hgap : Real.exp (-χ+ε)<Real.exp (-a) := Real.exp_lt_exp.mpr (by dsimp [ε]; linarith)
  refine ⟨ε,(Real.exp (-a)-Real.exp (-χ+ε))/2,hε,by linarith,by linarith,?_⟩
  exact Real.exp_lt_one_iff.mpr (by linarith)

lemma exists_spectral_rate_code (k : ℝ) (hk : 0≤k) (a χ : ℝ) (ha : 0<a) (haχ : a<χ) :
    ∃ (p : Torus → AdaptiveSymbol) (S : AdaptiveSymbol → Finset AdaptiveSymbol) (D : ℕ) (b : ℝ),
      Measurable p ∧ 0<D ∧ (∀ s,(S s).card≤D) ∧ 0≤b ∧
      (∀ᵐ z ∂area.restrict (spectralGapRegion k hk χ),p (standardMap k z)∈S (p z)) ∧
      (∀ N : ℕ,∀ᵐ z ∂area.restrict (spectralGapRegion k hk χ),
        area (LocalCoding.codeFiber (standardMap k) p N z)≤ENNReal.ofReal (Real.exp (-((N : ℝ)*a-b)))) := by
  obtain ⟨ε,δ,hε,hδ,hq,hq1⟩ := exists_fine_parameters ha haχ
  obtain ⟨J,hJ⟩ := pow_unbounded_of_one_lt (Real.exp (2*ε)) (show (1 : ℝ)<2 by norm_num)
  obtain ⟨M,hM⟩ := exists_nat_ge (2*(9*growthBase k)*(2 : ℝ)^J)
  obtain ⟨C,hC,hvolume⟩ := adaptive_codeFiber_volume k hk χ ε δ hδ (hq.trans hq1)
  let p := adaptiveLabel (codingLevel k χ ε δ hδ)
  let S := adaptiveSuccessors k (codingLevel k χ ε δ hδ) J M
  let b := max 0 (Real.log C)
  have hCb : C≤Real.exp b := by
    rw [←Real.exp_log hC]
    exact Real.exp_le_exp.mpr (le_max_right _ _)
  refine ⟨p,S,(2*J+1)*(2*M+3)^2,b,measurable_adaptiveLabel _ (measurable_codingLevel k χ ε δ hδ),
    by positivity,adaptiveSuccessors_card k _ J M,le_max_left _ _,?_,?_⟩
  · filter_upwards [ae_fineRegular k hk (ha.trans haχ) hε] with z hz
    have hj := codingLevel_step k χ ε δ hδ z hz J hJ.le
    exact adaptive_successor_mem k hk _ J M hM z hj.1 hj.2
  · intro N
    filter_upwards [ae_fineRegular_all_iterates k hk (ha.trans haχ) hε] with z hz
    apply (hvolume z (fun n => (hz n).1) N).trans
    apply ENNReal.ofReal_le_ofReal
    have hpow : (Real.exp (-χ+ε)+δ)^N≤(Real.exp (-a))^N :=
      pow_le_pow_left₀ (by positivity) hq.le _
    calc
      C*(Real.exp (-χ+ε)+δ)^N ≤ Real.exp b*(Real.exp (-a))^N :=
        mul_le_mul hCb hpow (by positivity) (Real.exp_pos _).le
      _ = Real.exp (-((N : ℝ)*a-b)) := by
        rw [←Real.exp_nat_mul,←Real.exp_add]
        congr 1
        ring
end StandardMapEntropy

end
section
namespace StandardMapEntropy.Entropy
open MeasureTheory Set Filter
open scoped Topology ENNReal BigOperators
variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
variable {α : Type*} [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α]
lemma obs_lower_information (p : Ω → α) (hp : Measurable p) (I : α → ℝ)
    (hsmall : ∀ a : α,mass μ p a≤Real.exp (-I a)) :
    (∫ x,I (p x) ∂μ)≤obs μ p := by
  rw [←sum_mass_mul_integral μ p hp I]
  apply Finset.sum_le_sum
  intro a _
  by_cases hz : mass μ p a=0
  · simp only [hz,zero_mul,Real.negMulLog_zero,le_refl]
  · have hpos : 0 < mass μ p a := lt_of_le_of_ne (mass_nonneg μ p a) (Ne.symm hz)
    have hh := Real.log_le_log hpos (hsmall a)
    rw [Real.log_exp] at hh
    unfold Real.negMulLog
    nlinarith [mass_nonneg μ p a]
end StandardMapEntropy.Entropy

namespace StandardMapEntropy.LocalCoding
open MeasureTheory Set Filter
open scoped Topology ENNReal BigOperators
variable {ι : Type*} [DecidableEq ι] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι]
variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]

omit [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] [MeasurableSpace Ω] in
lemma masked_history_atom_subset (f : Ω → Ω) (p : Ω → ι) (S : ι → Finset ι)
    (A : Finset ι) (N : ℕ) (x : Ω) (hA : p x∈A)
    (hpath : ∀ j : ℕ,p (f^[j+1] x)∈S (p (f^[j] x))) :
    (Entropy.history (maskedState A (reach S A N) f p) (N+1)) ⁻¹'
      {Entropy.history (maskedState A (reach S A N) f p) (N+1) x}⊆codeFiber f p N x := by
  intro y hy i hi
  have hr : p (f^[i] x)∈reach S A N := reach_mono S A hi
    (path_mem_reach S A (fun j => p (f^[j] x)) hA hpath i)
  have he : maskedState A (reach S A N) f p i y=truncate (reach S A N) (p (f^[i] x)) := by
    exact (congrFun hy ⟨i,by omega⟩).trans (maskedState_of_mem A _ f p i hA)
  rw [truncate_some _ _ hr] at he
  by_cases hyA : p y∈A
  · rw [maskedState_of_mem A _ f p i hyA] at he
    exact (truncate_eq_some_iff _ _ _).mp he
  · rw [maskedState_of_not_mem A _ f p i hyA] at he
    cases he

def initialInformation (w : ι → ℝ) (N : ℕ) (b : ℝ) (R : Finset ι)
    (v : Fin (N+1) → Option R) : ℝ :=
  (v ⟨0,by omega⟩).elim 0 (fun a => (N : ℝ)*w a.val-b)
omit [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] [MeasurableSpace Ω] in
lemma initialInformation_history (w : ι → ℝ) (f : Ω → Ω) (p : Ω → ι)
    (A : Finset ι) (S : ι → Finset ι) (N : ℕ) (b : ℝ) (x : Ω) :
    initialInformation w N b (reach S A N) (Entropy.history (maskedState A (reach S A N) f p) (N+1) x)=
      if p x∈A then (N : ℝ)*w (p x)-b else 0 := by
  by_cases hx : p x∈A
  · simp only [initialInformation,Entropy.history,maskedState_of_mem A _ f p 0 hx,Function.iterate_zero,
      Function.id_def,truncate_some _ _ (base_subset_reach S A N hx),Option.elim_some,hx,↓reduceIte]
  · simp only [initialInformation,Entropy.history,maskedState_of_not_mem A _ f p 0 hx,Option.elim_none,hx,↓reduceIte]

lemma masked_history_weighted_small (f : Ω → Ω) (hf : MeasurePreserving f μ μ)
    (p : Ω → ι) (hp : Measurable p) (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x))
    (A : Finset ι) (N : ℕ) (w : ι → ℝ) (b : ℝ)
    (hsmall : ∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-((N : ℝ)*w (p x)-b))))
    (v : Fin (N+1) → Option (reach S A N)) :
    Entropy.mass μ (Entropy.history (maskedState A (reach S A N) f p) (N+1)) v≤
      Real.exp (-initialInformation w N b (reach S A N) v) := by
  let q := Entropy.history (maskedState A (reach S A N) f p) (N+1)
  by_cases hz : μ (q ⁻¹' {v})=0
  · change (μ (q ⁻¹' {v})).toReal≤_
    rw [hz,ENNReal.toReal_zero]
    exact (Real.exp_pos _).le
  · obtain ⟨x,hx,hpath,hsm⟩ := Measure.exists_mem_of_measure_ne_zero_of_ae hz
      (((ae_transition_orbit μ f hf p S hS).and hsmall).filter_mono Measure.absolutelyContinuous_restrict.ae_le)
    change q x=v at hx
    rw [←hx,initialInformation_history]
    by_cases hA : p x∈A
    · rw [ite_eq_left hA]
      have hsub : q ⁻¹' {v}⊆codeFiber f p N x := by
        rw [←hx]; exact masked_history_atom_subset f p S A N x hA hpath
      have hle := (measure_mono hsub).trans hsm
      rw [←hx] at hle
      exact (ENNReal.toReal_mono (by simp) hle).trans_eq (ENNReal.toReal_ofReal (Real.exp_pos _).le)
    · rw [ite_eq_right hA,neg_zero,Real.exp_zero]
      exact Entropy.mass_le_one μ _ (Entropy.history_measurable _
        (measurable_maskedState A _ f p hf.measurable hp) _) _

lemma masked_history_weighted_lower (f : Ω → Ω) (hf : MeasurePreserving f μ μ)
    (p : Ω → ι) (hp : Measurable p) (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x))
    (A : Finset ι) (N : ℕ) (w : ι → ℝ) (hw : Integrable (w ∘ p) μ) (b : ℝ) (hb : 0≤b)
    (hsmall : ∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-((N : ℝ)*w (p x)-b)))) :
    (N : ℝ)*(∫ x in {x | p x∈A},w (p x) ∂μ)-b≤
      Entropy.obs μ (Entropy.history (maskedState A (reach S A N) f p) (N+1)) := by
  have hs : MeasurableSet {x : Ω | p x∈A} := hp A.measurableSet
  have hh := Entropy.obs_lower_information μ _ (Entropy.history_measurable _
    (measurable_maskedState A _ f p hf.measurable hp) _) (initialInformation w N b (reach S A N))
    (masked_history_weighted_small μ f hf p hp S hS A N w b hsmall)
  simp only [initialInformation_history] at hh
  have he : (fun x : Ω => if p x∈A then (N : ℝ)*w (p x)-b else 0)=
      {x : Ω | p x∈A}.indicator (fun x => (N : ℝ)*w (p x)-b) := by
    funext x
    simp only [indicator_apply,mem_ofPred_eq]
  have hwi : Integrable (fun x => (N : ℝ)*w (p x)) μ := hw.const_mul _
  rw [he,integral_indicator hs,integral_sub hwi.integrableOn (integrable_const _),
    integral_const_mul,integral_const,Measure.real,Measure.restrict_apply_univ,smul_eq_mul] at hh
  have hm : (μ {x : Ω | p x∈A}).toReal≤1 := by
    exact (ENNReal.toReal_mono ENNReal.one_ne_top (by simpa only [measure_univ] using (measure_mono (μ:=μ) (subset_univ {x : Ω | p x∈A})))).trans_eq (by simp)
  simpa only [one_mul] using (sub_le_sub_left (mul_le_mul_of_nonneg_right hm hb) _).trans hh

omit [DecidableEq ι] [IsProbabilityMeasure μ] in
lemma tendsto_integral_code_truncation (p : Ω → ι) (hp : Measurable p) (w : ι → ℝ)
    (hw : Integrable (w ∘ p) μ) :
    Tendsto (fun A : Finset ι => ∫ x in {x | p x∈A},w (p x) ∂μ) atTop (𝓝 (∫ x,w (p x) ∂μ)) := by
  have ht := tendsto_integral_filter_of_dominated_convergence (μ:=μ) (fun x => ‖w (p x)‖)
    (F:=fun A : Finset ι => {x | p x∈A}.indicator (fun x => w (p x)))
    (Filter.Eventually.of_forall (fun A => (hw.indicator (hp A.measurableSet)).aestronglyMeasurable))
    (Filter.Eventually.of_forall (fun A => ae_of_all _ (fun x => norm_indicator_le_norm_self _ x))) hw.norm
    (ae_of_all _ (fun x => by
      apply tendsto_const_nhds.congr'
      filter_upwards [eventually_ge_atTop ({p x} : Finset ι)] with A hA
      exact (indicator_of_mem (hA (Finset.mem_singleton_self _)) _).symm))
  have he (A : Finset ι) : (∫ x, {x | p x∈A}.indicator (fun x => w (p x)) x ∂μ)=
      ∫ x in {x | p x∈A},w (p x) ∂μ := integral_indicator (hp A.measurableSet)
  simp_rw [he] at ht
  exact ht

lemma weighted_lower_rate_truncation (f : Ω → Ω) (hf : MeasurePreserving f μ μ) (p : Ω → ι) (hp : Measurable p)
    (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) {D : ℕ} (hD : 0<D)
    (hcard : ∀ x,(S x).card≤D) (w : ι → ℝ) (hw : Integrable (w ∘ p) μ) (b : ℝ) (hb : 0≤b)
    (hsmall : ∀ N : ℕ,∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-((N : ℝ)*w (p x)-b))))
    (A K : Finset ι) :
    (∫ x in {x | p x∈A},w (p x) ∂μ)≤Entropy.rate μ f (truncate K ∘ p)+(μ {x | p x∉K}).toReal*Real.log (D : ℝ) := by
  let t := (μ {x | p x∉K}).toReal*Real.log (D : ℝ)
  have ht : Tendsto (fun n : ℕ => (n : ℝ)+1) atTop atTop := tendsto_atTop_add_const_right _ _ tendsto_natCast_atTop_atTop
  have hdiv (c : ℝ) : Tendsto (fun n : ℕ => c/((n : ℝ)+1)) atTop (𝓝 0) := tendsto_const_nhds.div_atTop ht
  have hratio : Tendsto (fun n : ℕ => (n : ℝ)/((n : ℝ)+1)) atTop (𝓝 1) := by
    have h := (tendsto_const_nhds (x:=(1 : ℝ))).sub (hdiv 1)
    convert h using 1
    · funext n; field_simp; ring
    · ring_nf
  have hl := (hratio.mul_const (∫ x in {x | p x∈A},w (p x) ∂μ)).sub (hdiv b)
  have hr := (((Entropy.rate_tendsto μ f hf (truncate K ∘ p) ((measurable_truncate K).comp hp)).comp
    (tendsto_add_atTop_nat 1)).add (hdiv (Real.log ((A.card : ℝ)+1)))).add (hratio.mul_const t)
  simp only [one_mul,sub_zero] at hl
  simp only [add_zero,one_mul] at hr
  apply le_of_tendsto_of_tendsto hl hr
  apply Filter.Eventually.of_forall
  intro n
  have hh := (masked_history_weighted_lower μ f hf p hp S hS A n w hw b hb (hsmall n)).trans
    (masked_history_entropy_upper μ f hf p hp S hS hD hcard A K n)
  have hd : (0 : ℝ)<(n : ℝ)+1 := by positivity
  have hh' := div_le_div_of_nonneg_right hh hd.le
  convert hh' using 1 <;> simp only [Function.comp_apply,Nat.cast_add,Nat.cast_one,t] <;> field_simp

theorem weighted_lower_of_finite_rate_bound (f : Ω → Ω) (hf : MeasurePreserving f μ μ)
    (p : Ω → ι) (hp : Measurable p) (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x))
    {D : ℕ} (hD : 0<D) (hcard : ∀ x,(S x).card≤D)
    (w : ι → ℝ) (hw : Integrable (w ∘ p) μ) (b c : ℝ) (hb : 0≤b)
    (hsmall : ∀ N : ℕ,∀ᵐ x ∂μ,μ (codeFiber f p N x)≤ENNReal.ofReal (Real.exp (-((N : ℝ)*w (p x)-b))))
    (hc : ∀ K : Finset ι,Entropy.rate μ f (truncate K ∘ p)≤c) : (∫ x,w (p x) ∂μ)≤c := by
  have hK (K : Finset ι) : (∫ x,w (p x) ∂μ)≤c+(μ {x | p x∉K}).toReal*Real.log (D : ℝ) := by
    exact le_of_tendsto' (tendsto_integral_code_truncation μ p hp w hw) (fun A : Finset ι =>
      (weighted_lower_rate_truncation μ f hf p hp S hS hD hcard w hw b hb hsmall A K).trans (add_le_add (hc K) le_rfl))
  have hh := ge_of_tendsto' (((tendsto_code_tail μ p hp).mul_const (Real.log (D : ℝ))).const_add c) hK
  simpa only [zero_mul,add_zero] using hh
end StandardMapEntropy.LocalCoding

end
section
namespace StandardMapEntropy.Entropy
open MeasureTheory Set Filter
open scoped Topology ENNReal BigOperators
variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
variable {α β : Type*} [Fintype α] [Fintype β]
variable [MeasurableSpace α] [MeasurableSpace β] [MeasurableSingletonClass α] [MeasurableSingletonClass β]
omit [IsProbabilityMeasure μ] [MeasurableSpace α] [MeasurableSpace β]
  [MeasurableSingletonClass α] [MeasurableSingletonClass β] in
lemma rate_equiv (f : Ω → Ω) (p : Ω → α) (e : α ≃ β) : rate μ f (e ∘ p)=rate μ f p := by
  have he (n : ℕ) : obs μ (word f (e ∘ p) n)=obs μ (word f p n) := by
    have hword : word f (e ∘ p) n=(Equiv.piCongrRight (fun _ : Fin n => e)) ∘ word f p n := rfl
    rw [hword,obs_equiv]
  simp only [rate,he]
end StandardMapEntropy.Entropy

namespace StandardMapEntropy
open MeasureTheory Set Filter
open scoped Topology ENNReal
lemma finite_rate_le_metricEntropy {α : Type*} [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α]
    (μ : Measure Torus) [IsProbabilityMeasure μ] (f : Torus → Torus) (hf : MeasurePreserving f μ μ)
    (p : Torus → α) (hp : Measurable p) : ENNReal.ofReal (Entropy.rate μ f p)≤ metricEntropy μ f := by
  let : Nonempty α := ⟨p (0,0)⟩
  have hcard : Fintype.card α-1+1=Fintype.card α := Nat.sub_add_cancel (Fintype.card_pos)
  let e : α ≃ Fin (Fintype.card α-1+1) := (Fintype.equivFin α).trans (finCongr hcard.symm)
  let q : FinitePartition (Fintype.card α-1) := ⟨e ∘ p,(measurable_of_countable e).comp hp⟩
  have hle : partitionEntropy μ f q≤ metricEntropy μ f := le_iSup_of_le _ (le_iSup_of_le q le_rfl)
  rw [partitionEntropy_eq_ofReal_rate μ f hf q] at hle
  exact (congrArg ENNReal.ofReal (Entropy.rate_equiv μ f p e)).symm.le.trans hle
end StandardMapEntropy

end
end

end OAI