import OAI.Dynamics.StandardMap.EntropyEndpoint
import OAI.Dynamics.StandardMap.Entropy.FineCharts

namespace OAI

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

lemma fineCoordinate_continuous (k χ ε δ : ℝ) (w : ℂ) (n : ℕ) :
    Continuous (fineCoordinate k χ ε δ w · n) := by
  exact (fineInverse k χ ε δ _).continuous.comp
    ((((contDiff_standardLift k).continuous).iterate n).sub continuous_const)
lemma fineTrapped_closed (k χ ε δ : ℝ) (w : ℂ) (n : ℕ) :
    IsClosed (fineTrapped k χ ε δ w n) := by
  have he : fineTrapped k χ ε δ w n=⋂ j : ℕ, ⋂ _ : j≤n, {v | ‖fineCoordinate k χ ε δ w
    (w+fineFrame k χ ε δ (complexProjection w) v) j‖≤1} := by
    ext v; simp only [fineTrapped,mem_ofPred_eq,mem_iInter]
  rw [he]
  apply isClosed_iInter
  intro j
  apply isClosed_iInter
  intro _
  exact isClosed_le (((fineCoordinate_continuous k χ ε δ w j).comp
    (continuous_const.add (fineFrame k χ ε δ _).continuous)).norm) continuous_const

def fineLiftTrapped (k χ ε δ : ℝ) (w : ℂ) (n : ℕ) : Set ℂ :=
  {p | ∀ j : ℕ, j≤n → ‖fineCoordinate k χ ε δ w p j‖≤1}
lemma fineLiftTrapped_image (k χ ε : ℝ) {δ : ℝ} (hδ : 0<δ) (w : ℂ)
    (hw : FineRegular k χ ε (complexProjection w)) (n : ℕ) :
    fineLiftTrapped k χ ε δ w n=
      (fun v => w+fineFrame k χ ε δ (complexProjection w) v) '' fineTrapped k χ ε δ w n := by
  ext p
  constructor
  · intro hp
    let v := fineInverse k χ ε δ (complexProjection w) (p-w)
    have he : w+fineFrame k χ ε δ (complexProjection w) v=p := by
      dsimp [v]
      rw [fineFrame_inverse k χ ε hδ _ hw.1]
      abel
    exact ⟨v,by change ∀ j, j≤n → _; rw [he]; exact hp,he⟩
  · rintro ⟨v,hv,rfl⟩
    exact hv

lemma volume_pairToComplex_image {S : Set RealPlane} (hS : MeasurableSet S) :
    volume (pairToComplex '' S)=volume S := by
  have he : pairToComplex '' S=Complex.measurableEquivRealProd ⁻¹' S := by
    ext z
    constructor
    · rintro ⟨v,hv,rfl⟩; exact hv
    · intro hz
      exact ⟨complexToPair z,hz,pairToComplex_complexToPair z⟩
  rw [he]
  exact Complex.volume_preserving_equiv_real_prod.measure_preimage hS.nullMeasurableSet

noncomputable def fineVolumeFactor (k χ ε δ : ℝ) (z : Torus) : ℝ :=
  |(fineSize k χ ε δ z • lyapunovFrame k χ z).det|
lemma fineLiftTrapped_volume_eq (k χ ε : ℝ) {δ : ℝ} (hδ : 0<δ) (w : ℂ)
    (hw : FineRegular k χ ε (complexProjection w)) (n : ℕ) :
    volume (fineLiftTrapped k χ ε δ w n)=
      ENNReal.ofReal (fineVolumeFactor k χ ε δ (complexProjection w))*volume (fineTrapped k χ ε δ w n) := by
  rw [fineLiftTrapped_image k χ ε hδ w hw n]
  have he : (fun v => w+fineFrame k χ ε δ (complexProjection w) v) '' fineTrapped k χ ε δ w n=
      (fun z : ℂ => w+z) '' ((fineSize k χ ε δ (complexProjection w) • lyapunovFrame k χ (complexProjection w)) ''
        (pairToComplex '' fineTrapped k χ ε δ w n)) := by
    rw [Set.image_image,Set.image_image]
    rfl
  rw [he,Set.image_add_left,measure_preimage_add,Measure.addHaar_image_continuousLinearMap,
    volume_pairToComplex_image (fineTrapped_closed k χ ε δ w n).measurableSet]
  rfl

theorem fineLiftTrapped_volume (k χ ε δ : ℝ) (hδ : 0<δ)
    (hq : Real.exp (-χ+ε)+δ<1) (w : ℂ)
    (hw : ∀ n : ℕ, FineRegular k χ ε (complexProjection ((standardLift k)^[n] w))) (n : ℕ) :
    volume (fineLiftTrapped k χ ε δ w n)≤
      ENNReal.ofReal (4*fineVolumeFactor k χ ε δ (complexProjection w)*(Real.exp (-χ+ε)+δ)^n) := by
  rw [fineLiftTrapped_volume_eq k χ ε hδ w (hw 0) n]
  calc
    _ ≤ ENNReal.ofReal (fineVolumeFactor k χ ε δ (complexProjection w))*
        ENNReal.ofReal (4*(Real.exp (-χ+ε)+δ)^n) :=
      mul_le_mul le_rfl (fineTrapped_volume k χ ε δ hδ hq w hw n) zero_le zero_le
    _ = _ := by rw [←ENNReal.ofReal_mul (show 0≤fineVolumeFactor k χ ε δ (complexProjection w) from abs_nonneg _)]; congr 1; ring

end StandardMapEntropy

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

def complexCell : Set ℂ := {z | z.re∈Ico (0 : ℝ) 1 ∧ z.im∈Ico (0 : ℝ) 1}
lemma complexRep_projection_of_cell {z : ℂ} (hz : z∈complexCell) : complexRep (complexProjection z)=z := by
  apply Complex.ext
  · exact circleRep_coe_of_mem hz.1
  · exact circleRep_coe_of_mem hz.2
lemma measurePreserving_complexProjection_cell :
    MeasurePreserving complexProjection (volume.restrict complexCell) area := by
  have hp := (AddCircle.measurePreserving_mk (1 : ℝ) 0).prod (AddCircle.measurePreserving_mk (1 : ℝ) 0)
  simp only [zero_add] at hp
  rw [←restrict_Ico_eq_restrict_Ioc,Measure.prod_restrict] at hp
  have hc := Complex.volume_preserving_equiv_real_prod.restrict_preimage (measurableSet_Ico.prod measurableSet_Ico :
    MeasurableSet (Ico (0 : ℝ) 1 ×ˢ Ico (0 : ℝ) 1))
  exact hp.comp hc
lemma area_le_volume_of_complexRep_subset {S : Set Torus} (hS : MeasurableSet S) {V : Set ℂ}
    (hsub : ∀ z∈S,complexRep z∈V) : area S≤volume V := by
  rw [←measurePreserving_complexProjection_cell.measure_preimage hS.nullMeasurableSet,
    Measure.restrict_apply (measurePreserving_complexProjection_cell.measurable hS)]
  apply measure_mono
  intro z hz
  have hh := hsub (complexProjection z) hz.1
  rwa [complexRep_projection_of_cell hz.2] at hh
lemma measurableSet_fineLiftTrapped (k χ ε δ : ℝ) (w : ℂ) (n : ℕ) :
    MeasurableSet (fineLiftTrapped k χ ε δ w n) := by
  have he : fineLiftTrapped k χ ε δ w n=⋂ j : ℕ,⋂ _ : j≤n,{p | ‖fineCoordinate k χ ε δ w p j‖≤1} := by
    ext p; simp only [fineLiftTrapped,mem_ofPred_eq,mem_iInter]
  rw [he]
  exact MeasurableSet.iInter (fun j => MeasurableSet.iInter (fun _ =>
    (isClosed_le (fineCoordinate_continuous k χ ε δ w j).norm continuous_const).measurableSet))

lemma exists_fineVolumeFactor_bound (k χ ε : ℝ) {δ : ℝ} (hδ : 0<δ) :
    ∃ C : ℝ,0<C ∧ ∀ z : Torus,fineVolumeFactor k χ ε δ z≤C := by
  let η := fineScale k ε δ
  obtain ⟨C,hC⟩ := (isCompact_closedBall (0 : ℂ →L[ℝ] ℂ) η).exists_bound_of_continuousOn
    (ContinuousLinearMap.continuous_det (𝕜:=ℝ) (E:=ℂ)).continuousOn
  refine ⟨max 1 C,lt_of_lt_of_le zero_lt_one (le_max_left _ _),?_⟩
  intro z
  apply (hC (fineSize k χ ε δ z • lyapunovFrame k χ z) ?_).trans (le_max_right _ _)
  rw [Metric.mem_closedBall,dist_zero_right,norm_smul,Real.norm_eq_abs,abs_of_pos (fineSize_pos k χ ε hδ z)]
  exact (mul_le_mul_of_nonneg_left (lyapunovFrame_norm_le k χ z) (fineSize_pos k χ ε hδ z).le).trans
    (by simpa only [mul_one] using fineSize_le_scale k χ ε hδ z)

lemma circle_coe_eq_of_close {x y : ℝ} (hxy : (x : Circle)=(y : Circle)) (hd : |x-y|<1) : x=y := by
  have hz : ((x-y : ℝ) : Circle)=0 := by rw [QuotientAddGroup.mk_sub,hxy,sub_self]
  obtain ⟨n,hn⟩ := (AddCircle.coe_eq_zero_iff (1 : ℝ)).mp hz
  have hn' : (n : ℝ)=x-y := by simpa only [zsmul_eq_mul,mul_one] using hn
  have hab : (-1 : ℝ)<(n : ℝ) ∧ (n : ℝ)<1 := by rw [hn']; exact abs_lt.mp hd
  have hn0 : n=0 := by
    have h1 : (-1 : ℤ)<n := by exact_mod_cast hab.1
    have h2 : n<(1 : ℤ) := by exact_mod_cast hab.2
    omega
  subst n
  simp only [Int.cast_zero] at hn'
  linarith
lemma complexProjection_eq_of_close {z w : ℂ} (hz : complexProjection z=complexProjection w) (hd : ‖z-w‖<1) : z=w := by
  apply Complex.ext
  · exact circle_coe_eq_of_close (congrArg Prod.fst hz) ((Complex.abs_re_le_norm (z-w)).trans_lt hd)
  · exact circle_coe_eq_of_close (congrArg Prod.snd hz) ((Complex.abs_im_le_norm (z-w)).trans_lt hd)

end StandardMapEntropy

end
section
namespace StandardMapEntropy.Entropy
open MeasureTheory Set Filter
open scoped Topology ENNReal BigOperators
variable {Ω : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
variable {α β γ : Type*} [Fintype α] [Fintype β] [Fintype γ]
variable [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ]
variable [MeasurableSingletonClass α] [MeasurableSingletonClass β] [MeasurableSingletonClass γ]

def history (X : ℕ → Ω → α) (n : ℕ) : Ω → (Fin n → α) := fun x i => X i.val x
omit [Fintype α] [MeasurableSingletonClass α] in
lemma history_measurable (X : ℕ → Ω → α) (hX : ∀ i,Measurable (X i)) (n : ℕ) :
    Measurable (history X n) := Measurable.of_eval (fun i => hX i.val)
noncomputable def historySnocEquiv (n : ℕ) : (Fin (n+1) → α) ≃ (Fin n → α)×α where
  toFun v := (fun i => v i.castSucc,v (Fin.last n))
  invFun v := Fin.lastCases v.2 v.1
  left_inv v := by funext i; refine Fin.lastCases ?_ (fun j => ?_) i <;> simp
  right_inv v := by ext i <;> simp
omit [MeasurableSpace Ω] [Fintype α] [MeasurableSpace α] [MeasurableSingletonClass α] in
lemma historySnocEquiv_apply (X : ℕ → Ω → α) (n : ℕ) (x : Ω) :
    historySnocEquiv n (history X (n+1) x)=(history X n x,X n x) := rfl
omit [IsProbabilityMeasure μ] [MeasurableSpace β] [MeasurableSingletonClass β] in
lemma cond_history_succ (X : ℕ → Ω → α) (n : ℕ) (Y : Ω → β) :
    cond μ (history X (n+1)) Y=cond μ (history X n) Y+cond μ (X n) (fun x => (history X n x,Y x)) := by
  have he := cond_equiv_left μ (history X (n+1)) Y (historySnocEquiv n)
  simp only [Function.comp_def,historySnocEquiv_apply] at he
  rw [←he,cond_chain]
omit [IsProbabilityMeasure μ] [MeasurableSpace β] [MeasurableSingletonClass β] in
lemma cond_history_one (X : ℕ → Ω → α) (Y : Ω → β) : cond μ (history X 1) Y=cond μ (X 0) Y := by
  have he := cond_equiv_left μ (history X 1) Y (Equiv.funUnique (Fin 1) α)
  simpa only [Function.comp_def,Equiv.funUnique_apply,history,Fin.default_eq_zero,Fin.val_zero] using he.symm

lemma cond_history_markov (X : ℕ → Ω → α) (hX : ∀ i,Measurable (X i))
    (Y : Ω → β) (hY : Measurable Y) (R : ℕ → β → γ) (n : ℕ) :
    cond μ (history X (n+1)) Y≤obs μ (X 0)+
      ∑ i∈Finset.range n,cond μ (X (i+1)) (fun x => (R (i+1) (Y x),X i x)) := by
  induction n with
  | zero =>
    simp only [Finset.range_zero,Finset.sum_empty,add_zero]
    change cond μ (history X 1) Y≤obs μ (X 0)
    rw [cond_history_one]
    exact cond_le_obs μ (X 0) Y (hX 0) hY
  | succ n ih =>
    rw [cond_history_succ,Finset.sum_range_succ,←add_assoc]
    apply add_le_add ih
    have he : (fun x => (R (n+1) (Y x),X n x))=
        (fun v : (Fin (n+1)→α)×β => (R (n+1) v.2,v.1 ⟨n,by omega⟩)) ∘
          (fun x => (history X (n+1) x,Y x)) := rfl
    rw [he]
    exact cond_factor_right μ _ _ _ (hX (n+1)) ((history_measurable X hX _).prodMk hY)

lemma obs_history_markov (X : ℕ → Ω → α) (hX : ∀ i,Measurable (X i))
    (Y : Ω → β) (hY : Measurable Y) (R : ℕ → β → γ) (n : ℕ) :
    obs μ (history X (n+1))≤obs μ Y+obs μ (X 0)+
      ∑ i∈Finset.range n,cond μ (X (i+1)) (fun x => (R (i+1) (Y x),X i x)) := by
  have hc := cond_history_markov μ X hX Y hY R n
  have hh := obs_pair_ge_left μ (history X (n+1)) Y (history_measurable X hX _) hY
  change obs μ (fun x => (history X (n+1) x,Y x))-obs μ Y≤_ at hc
  linarith

lemma cond_support_integral (p : Ω → α) (q : Ω → β) (hp : Measurable p) (hq : Measurable q)
    (S : β → Finset α) (hS : ∀ x,p x∈S (q x)) (g : β → ℝ)
    (hg : ∀ b,Real.log ((S b).card : ℝ)≤g b) : cond μ p q≤∫ x,g (q x) ∂μ := by
  have hh := cond_support_bound μ p q hp hq S hS
  have hs : (∑ b,mass μ q b*Real.log ((S b).card : ℝ))≤∑ b,mass μ q b*g b :=
    Finset.sum_le_sum (fun b _ => mul_le_mul_of_nonneg_left (hg b) (mass_nonneg μ q b))
  exact (hh.trans hs).trans_eq (sum_mass_mul_integral μ q hq g)

lemma log_card_le_of_card_le {A : Type*} (s : Finset A) {D : ℕ} (hD : 0<D) (hc : s.card≤D) :
    Real.log (s.card : ℝ)≤Real.log (D : ℝ) := by
  by_cases hs : s.card=0
  · rw [hs,Nat.cast_zero,Real.log_zero]
    exact Real.log_nonneg (by exact_mod_cast hD)
  · exact Real.log_le_log (Nat.cast_pos.mpr (Nat.pos_of_ne_zero hs)) (by exact_mod_cast hc)

end StandardMapEntropy.Entropy

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 β]
variable [MeasurableSingletonClass α] [MeasurableSingletonClass β]

lemma cond_support_bound_ae (p : Ω → α) (q : Ω → β) (hp : Measurable p) (hq : Measurable q)
    (S : β → Finset α) (hS : ∀ᵐ x ∂μ,p x∈S (q x)) :
    cond μ p q≤∑ b,mass μ q b*Real.log ((S b).card : ℝ) := by
  classical
  have rz (b : β) (a : α) (ha : a∉S b) : mass μ (fun x => (p x,q x)) (a,b)=0 := by
    have hs : (fun x => (p x,q x)) ⁻¹' {(a,b)}⊆{x | ¬p x∈S (q x)} := by
      intro x hx hh
      obtain ⟨hx1,hx2⟩ := Prod.mk.inj hx
      exact ha (hx1 ▸ hx2 ▸ hh)
    have hm := measure_mono_null hs (ae_iff.mp hS)
    simp only [mass,hm,ENNReal.toReal_zero]
  have hh := Finset.sum_le_sum (s:=Finset.univ) (fun b _ =>
    shannon_support_bound (fun a => mass μ (fun x => (p x,q x)) (a,b))
      (fun a => mass_nonneg μ _ _) (S b) (rz b))
  simp only [←mass_joint_col μ p q hp hq,shannon,Finset.sum_add_distrib] at hh
  unfold cond obs shannon
  rw [Fintype.sum_prod_type,Finset.sum_comm]
  linarith
lemma cond_support_integral_ae (p : Ω → α) (q : Ω → β) (hp : Measurable p) (hq : Measurable q)
    (S : β → Finset α) (hS : ∀ᵐ x ∂μ,p x∈S (q x)) (g : β → ℝ)
    (hg : ∀ b,Real.log ((S b).card : ℝ)≤g b) : cond μ p q≤∫ x,g (q x) ∂μ := by
  have hh := cond_support_bound_ae μ p q hp hq S hS
  have hs : (∑ b,mass μ q b*Real.log ((S b).card : ℝ))≤∑ b,mass μ q b*g b :=
    Finset.sum_le_sum (fun b _ => mul_le_mul_of_nonneg_left (hg b) (mass_nonneg μ q b))
  exact (hh.trans hs).trans_eq (sum_mass_mul_integral μ q hq g)

lemma mass_le_one (p : Ω → α) (hp : Measurable p) (a : α) : mass μ p a≤1 := by
  have hs := Finset.single_le_sum (fun b _ => mass_nonneg μ p b) (Finset.mem_univ a)
  simpa only [mass_sum μ p hp,measure_univ,ENNReal.toReal_one] using hs

lemma obs_lower_small_atoms (p : Ω → α) (hp : Measurable p) (a₀ : α) (I : ℝ)
    (hsmall : ∀ a : α,a≠a₀ → mass μ p a≤Real.exp (-I)) :
    (1-mass μ p a₀)*I≤obs μ p := by
  classical
  have hterm (a : α) : (if a=a₀ then 0 else mass μ p a*I)≤Real.negMulLog (mass μ p a) := by
    by_cases ha : a=a₀
    · rw [ite_eq_left ha]
      exact Real.negMulLog_nonneg (mass_nonneg μ p a) (mass_le_one μ p hp a)
    · rw [ite_eq_right ha]
      by_cases hz : mass μ p a=0
      · rw [hz,zero_mul,Real.negMulLog_zero]
      · 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 ha)
        rw [Real.log_exp] at hh
        unfold Real.negMulLog
        nlinarith [mass_nonneg μ p a]
  have hs := Finset.sum_le_sum (s:=Finset.univ) (fun a _ => hterm a)
  have he : (∑ a : α,if a=a₀ then 0 else mass μ p a*I)=(1-mass μ p a₀)*I := by
    have ht : (∑ a : α,if a=a₀ then 0 else mass μ p a*I)+mass μ p a₀*I=∑ a : α,mass μ p a*I := by
      have hsingle : (∑ a : α,if a=a₀ then mass μ p a*I else 0)=mass μ p a₀*I := by simp
      rw [←hsingle]
      rw [←Finset.sum_add_distrib]
      exact Finset.sum_congr rfl (fun a _ => by split_ifs <;> simp)
    rw [←Finset.sum_mul,mass_sum μ p hp,measure_univ,ENNReal.toReal_one,one_mul] at ht
    linarith
  simpa only [he,obs,shannon] using hs

end StandardMapEntropy.Entropy

end
section
namespace StandardMapEntropy.LocalCoding
open MeasureTheory Set Filter
open scoped Topology ENNReal BigOperators
variable {ι : Type*} [DecidableEq ι]

noncomputable def truncate (A : Finset ι) (a : ι) : Option A :=
  if h : a∈A then some ⟨a,h⟩ else none
@[simp] lemma truncate_none_iff (A : Finset ι) (a : ι) : truncate A a=none ↔ a∉A := by
  simp only [truncate]
  split_ifs <;> simp_all
lemma truncate_some (A : Finset ι) (a : ι) (ha : a∈A) : truncate A a=some ⟨a,ha⟩ := by simp [truncate,ha]
lemma truncate_eq_some_iff (A : Finset ι) (a : ι) (b : A) : truncate A a=some b ↔ a=b.val := by
  by_cases ha : a∈A
  · simp only [truncate_some A a ha,Option.some.injEq]
    exact Subtype.ext_iff
  · have hab : a ≠ b.val := fun hh => ha (hh ▸ b.property)
    simp [truncate, ha, hab]
lemma truncate_inj (A : Finset ι) {a b : ι} (ha : a∈A) (hb : b∈A)
    (h : truncate A a=truncate A b) : a=b := by
  rw [truncate_some A a ha,truncate_some A b hb] at h
  exact congrArg Subtype.val (Option.some.inj h)

def reach (S : ι → Finset ι) (A : Finset ι) : ℕ → Finset ι
  | 0 => A
  | n+1 => reach S A n ∪ (reach S A n).biUnion S
lemma reach_step (S : ι → Finset ι) (A : Finset ι) (n : ℕ) : reach S A n⊆reach S A (n+1) := Finset.subset_union_left
lemma reach_mono (S : ι → Finset ι) (A : Finset ι) : Monotone (reach S A) :=
  monotone_nat_of_le_succ (reach_step S A)
lemma base_subset_reach (S : ι → Finset ι) (A : Finset ι) (n : ℕ) : A⊆reach S A n := reach_mono S A (Nat.zero_le n)
lemma next_mem_reach (S : ι → Finset ι) (A : Finset ι) {n : ℕ} {a b : ι}
    (ha : a∈reach S A n) (hb : b∈S a) : b∈reach S A (n+1) :=
  Finset.mem_union_right _ (Finset.mem_biUnion.mpr ⟨a,ha,hb⟩)
lemma path_mem_reach (S : ι → Finset ι) (A : Finset ι) (x : ℕ → ι)
    (h0 : x 0∈A) (hstep : ∀ i,x (i+1)∈S (x i)) (n : ℕ) : x n∈reach S A n := by
  induction n with
  | zero => exact h0
  | succ n ih => exact next_mem_reach S A ih (hstep n)

instance optionFinsetMeasurableSpace (A : Finset ι) : MeasurableSpace (Option A) := ⊤
instance optionFinsetMeasurableSingleton (A : Finset ι) : MeasurableSingletonClass (Option A) :=
  ⟨fun _ => trivial⟩

variable {Ω : Type*} [MeasurableSpace Ω] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι]
lemma measurable_truncate (A : Finset ι) : Measurable (truncate A) := measurable_of_countable _
noncomputable def maskedState (A R : Finset ι) (f : Ω → Ω) (p : Ω → ι) (i : ℕ) (x : Ω) : Option R :=
  if p x∈A then truncate R (p (f^[i] x)) else none
lemma measurable_maskedState (A R : Finset ι) (f : Ω → Ω) (p : Ω → ι)
    (hf : Measurable f) (hp : Measurable p) (i : ℕ) : Measurable (maskedState A R f p i) := by
  exact Measurable.ite (hp (A.measurableSet)) ((measurable_truncate R).comp (hp.comp (hf.iterate i))) measurable_const
omit [MeasurableSpace Ω] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma maskedState_of_mem (A R : Finset ι) (f : Ω → Ω) (p : Ω → ι) (i : ℕ) {x : Ω} (hx : p x∈A) :
    maskedState A R f p i x=truncate R (p (f^[i] x)) := by simp only [maskedState,hx,↓reduceIte]
omit [MeasurableSpace Ω] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma maskedState_of_not_mem (A R : Finset ι) (f : Ω → Ω) (p : Ω → ι) (i : ℕ) {x : Ω} (hx : p x∉A) :
    maskedState A R f p i x=none := by simp only [maskedState,hx,↓reduceIte]
omit [MeasurableSpace Ω] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma maskedState_zero_none (A R : Finset ι) (hAR : A⊆R) (f : Ω → Ω) (p : Ω → ι) (x : Ω) :
    maskedState A R f p 0 x=none ↔ p x∉A := by
  by_cases hx : p x∈A
  · rw [maskedState_of_mem A R f p 0 hx]
    simp only [Function.iterate_zero,Function.id_def,truncate_none_iff]
    exact iff_of_false (fun h => h (hAR hx)) (fun h => h hx)
  · rw [maskedState_of_not_mem A R f p 0 hx]
    exact iff_of_true rfl hx

omit [DecidableEq ι] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma ae_transition_orbit (μ : Measure Ω) (f : Ω → Ω) (hf : MeasurePreserving f μ μ)
    (p : Ω → ι) (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) :
    ∀ᵐ x ∂μ,∀ i : ℕ,p (f^[i+1] x)∈S (p (f^[i] x)) := by
  rw [ae_all_iff]
  intro i
  have hh := (hf.iterate i).quasiMeasurePreserving.ae hS
  simpa only [Function.iterate_succ_apply'] using hh

end StandardMapEntropy.LocalCoding

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

noncomputable def transitionSupport (S : ι → Finset ι) (R K : Finset ι) :
    Option K×Option R → Finset (Option R)
  | (_,none) => {none}
  | (none,some a) => (S a.val).image (truncate R)
  | (some b,some _) => {truncate R b.val}
omit [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma transitionSupport_log_bound (S : ι → Finset ι) (R K : Finset ι) {D : ℕ}
    (hD : 0<D) (hcard : ∀ a,(S a).card≤D) (b : Option K×Option R) :
    Real.log ((transitionSupport S R K b).card : ℝ)≤ if b.1=none then Real.log (D : ℝ) else 0 := by
  rcases b with ⟨b,c⟩
  cases c with
  | none =>
    simp only [transitionSupport,Finset.card_singleton,Nat.cast_one,Real.log_one]
    split_ifs
    · exact Real.log_nonneg (by exact_mod_cast hD)
    · exact le_rfl
  | some c =>
    cases b with
    | none =>
      simp only [transitionSupport,↓reduceIte]
      exact Entropy.log_card_le_of_card_le _ hD (Finset.card_image_le.trans (hcard c.val))
    | some b => simp only [transitionSupport,Finset.card_singleton,Nat.cast_one,Real.log_one,Option.some_ne_none,↓reduceIte,le_refl]

omit [MeasurableSpace Ω] [MeasurableSpace ι] [MeasurableSingletonClass ι] [Countable ι] in
lemma masked_transition_mem (f : Ω → Ω) (p : Ω → ι) (S : ι → Finset ι) (A K : Finset ι)
    (N i : ℕ) (hi : i≤N) (x : Ω)
    (hx : ∀ j : ℕ,p (f^[j+1] x)∈S (p (f^[j] x))) :
    maskedState A (reach S A N) f p (i+1) x∈transitionSupport S (reach S A N) K
      (truncate K (p (f^[i+1] x)),maskedState A (reach S A N) f p i x) := by
  by_cases hA : p x∈A
  · have hreach := path_mem_reach S A (fun j => p (f^[j] x)) hA hx i
    have hr : p (f^[i] x)∈reach S A N := reach_mono S A hi hreach
    rw [maskedState_of_mem A _ f p i hA,truncate_some _ _ hr,maskedState_of_mem A _ f p (i+1) hA]
    by_cases hK : p (f^[i+1] x)∈K
    · rw [truncate_some K _ hK]
      exact Finset.mem_singleton_self _
    · rw [(truncate_none_iff K _).mpr hK]
      exact Finset.mem_image.mpr ⟨p (f^[i+1] x),hx i,rfl⟩
  · rw [maskedState_of_not_mem A _ f p i hA,maskedState_of_not_mem A _ f p (i+1) hA]
    exact Finset.mem_singleton_self _

omit [Countable ι] [IsProbabilityMeasure μ] in
lemma tail_integral (f : Ω → Ω) (hf : MeasurePreserving f μ μ) (p : Ω → ι)
    (hp : Measurable p) (K : Finset ι) (i : ℕ) (c : ℝ) :
    (∫ x,if truncate K (p (f^[i] x))=none then c else 0 ∂μ)=
      (μ {x | p x∉K}).toReal*c := by
  have hset : MeasurableSet {x | p x∉K} := (hp K.measurableSet).compl
  have he : (fun x => if truncate K (p (f^[i] x))=none then c else 0)=
      ((f^[i]) ⁻¹' {x | p x∉K}).indicator (fun _ => c) := by
    funext x
    by_cases hx : p (f^[i] x) ∈ K <;> simp [Set.indicator, hx]
  rw [he,integral_indicator ((hf.measurable.iterate i) hset),integral_const,Measure.real,Measure.restrict_apply_univ,
    (hf.iterate i).measure_preimage hset.nullMeasurableSet]
  rfl

lemma masked_cond_le_tail (f : Ω → Ω) (hf : MeasurePreserving f μ μ) (p : Ω → ι) (hp : Measurable p)
    (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) {D : ℕ} (hD : 0<D)
    (hcard : ∀ a,(S a).card≤D) (A K : Finset ι) (N i : ℕ) (hi : i≤N) :
    Entropy.cond μ (maskedState A (reach S A N) f p (i+1))
      (fun x => (truncate K (p (f^[i+1] x)),maskedState A (reach S A N) f p i x))≤
      (μ {x | p x∉K}).toReal*Real.log (D : ℝ) := by
  have hm (j : ℕ) := measurable_maskedState A (reach S A N) f p hf.measurable hp j
  have ht := Entropy.cond_support_integral_ae μ _ _ (hm (i+1))
    (((measurable_truncate K).comp (hp.comp (hf.measurable.iterate (i+1)))).prodMk (hm i))
    (transitionSupport S (reach S A N) K)
    (by filter_upwards [ae_transition_orbit μ f hf p S hS] with x hx; exact masked_transition_mem f p S A K N i hi x hx)
    (fun b => if b.1=none then Real.log (D : ℝ) else 0)
    (transitionSupport_log_bound S (reach S A N) K hD hcard)
  simpa only [Function.comp_apply,tail_integral μ f hf p hp K (i+1)] using ht

lemma masked_initial_entropy (f : Ω → Ω) (p : Ω → ι) (hf : Measurable f) (hp : Measurable p)
    (A R : Finset ι) (hAR : A⊆R) :
    Entropy.obs μ (maskedState A R f p 0)≤Real.log ((A.card : ℝ)+1) := by
  let g : Option A → Option R := Option.map (fun a => ⟨a.val,hAR a.property⟩)
  have he : maskedState A R f p 0=g ∘ (truncate A ∘ p) := by
    funext x
    by_cases hx : p x∈A
    · simp only [maskedState,hx,↓reduceIte,Function.iterate_zero,Function.id_def,Function.comp_apply,
        truncate_some A _ hx,truncate_some R _ (hAR hx),g,Option.map_some]
    · simp only [maskedState,hx,↓reduceIte,Function.comp_apply,(truncate_none_iff A _).mpr hx,g,Option.map_none]
  have hg : Measurable (g ∘ (truncate A ∘ p)) := by rw [←he]; exact measurable_maskedState A R f p hf hp 0
  rw [he]
  have hh := Entropy.obs_factor μ (truncate A ∘ p) g ((measurable_truncate A).comp hp) hg
  apply hh.trans
  have hb := Entropy.obs_bound μ (truncate A ∘ p) ((measurable_truncate A).comp hp)
  simpa only [Fintype.card_option,Fintype.card_coe,Nat.cast_add,Nat.cast_one] using hb

lemma masked_history_entropy_upper (f : Ω → Ω) (hf : MeasurePreserving f μ μ) (p : Ω → ι) (hp : Measurable p)
    (S : ι → Finset ι) (hS : ∀ᵐ x ∂μ,p (f x)∈S (p x)) {D : ℕ} (hD : 0<D)
    (hcard : ∀ a,(S a).card≤D) (A K : Finset ι) (N : ℕ) :
    Entropy.obs μ (Entropy.history (maskedState A (reach S A N) f p) (N+1))≤
      Entropy.obs μ (Entropy.word f (truncate K ∘ p) (N+1))+Real.log ((A.card : ℝ)+1)+
        (N : ℝ)*((μ {x | p x∉K}).toReal*Real.log (D : ℝ)) := by
  let R : ℕ → (Fin (N+1)→Option K) → Option K := fun i v => if h : i<N+1 then v ⟨i,h⟩ else none
  have hh := Entropy.obs_history_markov μ (maskedState A (reach S A N) f p)
    (measurable_maskedState A _ f p hf.measurable hp)
    (Entropy.word f (truncate K ∘ p) (N+1))
    (Entropy.word_measurable f hf.measurable (truncate K ∘ p) ((measurable_truncate K).comp hp) (N+1)) R N
  have hsum : (∑ i∈Finset.range N,Entropy.cond μ (maskedState A (reach S A N) f p (i+1))
      (fun x => (R (i+1) (Entropy.word f (truncate K ∘ p) (N+1) x),maskedState A (reach S A N) f p i x)))≤
      (N : ℝ)*((μ {x | p x∉K}).toReal*Real.log (D : ℝ)) := by
    calc
      _ ≤ ∑ _i∈Finset.range N,(μ {x | p x∉K}).toReal*Real.log (D : ℝ) := by
        apply Finset.sum_le_sum
        intro i hi
        have hiN : i<N := Finset.mem_range.mp hi
        simpa only [R,dite_eq_left (show i+1<N+1 by omega),Entropy.word,Function.comp_apply] using
          masked_cond_le_tail μ f hf p hp S hS hD hcard A K N i (by omega)
      _ = _ := by simp
  have hinit := masked_initial_entropy μ f p hf.measurable hp A (reach S A N) (base_subset_reach S A N)
  exact hh.trans (add_le_add (add_le_add le_rfl hinit) hsum)

end StandardMapEntropy.LocalCoding

end
end

end OAI