import OAI.MeasureTheory.SelfSimilar.FiniteDistribution

namespace OAI

universe uι uα uβ uγ uδ

section
open scoped BigOperators ENNReal
open MeasureTheory
namespace EntropyRateDimension
namespace MeasureEntropy

noncomputable def mass {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) (b : β) : ℝ := μ.real {x | f x = b}

noncomputable def entropy {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) : ℝ := ∑' b, Real.negMulLog (mass μ f b)

theorem mass_nonneg {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) (b : β) : 0 ≤ mass μ f b := ENNReal.toReal_nonneg

theorem mass_le_one {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    [IsProbabilityMeasure μ] (f : α → β) (b : β) : mass μ f b ≤ 1 := by
  exact (measureReal_mono (Set.subset_univ _)).trans_eq (by simp)

theorem entropy_nonneg {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    [IsProbabilityMeasure μ] (f : α → β) : 0 ≤ entropy μ f :=
  tsum_nonneg (fun b => Real.negMulLog_nonneg (mass_nonneg μ f b) (mass_le_one μ f b))

theorem mass_eq_zero_of_ae {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) {b : β} (hb : b ∉ s) :
    mass μ f b = 0 := by
  have hh : μ {x | f x = b} = 0 := measure_mono_null (by
    intro x hx
    change f x = b at hx
    change f x ∉ s
    simpa only [hx] using hb) (ae_iff.mp hs)
  simp only [mass, Measure.real_def, hh, ENNReal.toReal_zero]

theorem entropy_eq_sum {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) :
    entropy μ f = ∑ b ∈ s, Real.negMulLog (mass μ f b) := by
  apply tsum_eq_sum
  intro b hb
  rw [mass_eq_zero_of_ae μ f s hs hb, Real.negMulLog_zero]

theorem mass_sum {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] (μ : Measure α) [IsProbabilityMeasure μ]
    (f : α → β) (hf : Measurable f) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) :
    ∑ b ∈ s, mass μ f b = 1 := by
  classical
  have hd : (↑s : Set β).PairwiseDisjoint (fun b => {x | f x = b}) := by
    intro b _ c _ hbc
    apply Set.disjoint_left.mpr
    intro x hx hy
    exact hbc (hx.symm.trans hy)
  have hm : ∀ b ∈ s, MeasurableSet {x | f x = b} :=
    fun b _ => (measurableSet_singleton b).preimage hf
  have he : (⋃ b ∈ s, {x | f x = b}) = {x | f x ∈ s} := by
    ext x
    simp only [Set.mem_iUnion, Set.mem_ofPred_eq]
    constructor
    · rintro ⟨b,hb,hxb⟩
      simpa only [hxb] using hb
    · intro hx
      exact ⟨f x,hx,rfl⟩
  have hu : μ (⋃ b ∈ s, {x | f x = b}) = 1 := by
    rw [he]
    calc
      _ = μ Set.univ := measure_congr (by
        filter_upwards [hs] with x hx
        apply propext
        change (f x ∈ s) ↔ True
        exact iff_true_intro hx)
      _ = 1 := measure_univ
  rw [measure_biUnion_finset hd hm] at hu
  have he' := congrArg ENNReal.toReal hu
  simpa only [ENNReal.toReal_sum (fun b _ => measure_ne_top μ _), ENNReal.toReal_one, mass, Measure.real_def] using he'

def CompactlyCarried (μ : Measure ℝ) : Prop :=
  ∃ B : ℝ, 0 ≤ B ∧ μ (Set.Icc (-B) B)ᶜ = 0

noncomputable def label (s u x : ℝ) : ℤ := ⌊x/s+u⌋

noncomputable def grid (μ : Measure ℝ) (s u : ℝ) : ℝ := entropy μ (label s u)

noncomputable def averaged (μ : Measure ℝ) (s : ℝ) : ℝ :=
  ∫ u in Set.Icc (0 : ℝ) 1, grid μ s u

theorem label_measurable (s u : ℝ) : Measurable (label s u) :=
  ((measurable_id.div_const s).add_const u).floor

theorem label_joint_measurable (s : ℝ) : Measurable (fun ux : ℝ × ℝ => label s ux.1 ux.2) :=
  ((measurable_snd.div_const s).add measurable_fst).floor

theorem measurable_mass_label (μ : Measure ℝ) [IsFiniteMeasure μ] (s : ℝ) (b : ℤ) :
    Measurable (fun u => mass μ (label s u) b) := by
  have h := measurable_measure_prodMk_left (ν := μ)
    ((measurableSet_singleton b).preimage (label_joint_measurable s))
  exact h.ennreal_toReal

theorem measurable_grid (μ : Measure ℝ) [IsFiniteMeasure μ] (s : ℝ) :
    Measurable (grid μ s) :=
  Measurable.tsum (fun b => Real.continuous_negMulLog.measurable.comp (measurable_mass_label μ s b))

theorem label_in_interval {B s u x : ℝ} (hs : 0 < s) (hx : x ∈ Set.Icc (-B) B) :
    label s u x ∈ Finset.Icc ⌊-B/s+u⌋ ⌊B/s+u⌋ := by
  exact Finset.mem_Icc.mpr ⟨Int.floor_le_floor (by linarith [(div_le_div_iff_of_pos_right hs).mpr hx.1]),
    Int.floor_le_floor (by linarith [(div_le_div_iff_of_pos_right hs).mpr hx.2])⟩

theorem label_ae_finite (μ : Measure ℝ) {B s u : ℝ} (hs : 0 < s)
    (hB : μ (Set.Icc (-B) B)ᶜ = 0) :
    ∀ᵐ x ∂μ, label s u x ∈ Finset.Icc ⌊-B/s+u⌋ ⌊B/s+u⌋ := by
  have hb : ∀ᵐ x ∂μ, x ∈ Set.Icc (-B) B := ae_iff.mpr hB
  exact hb.mono (fun _ hx => label_in_interval hs hx)

theorem grid_eq_sum (μ : Measure ℝ) {B s u : ℝ} (hs : 0 < s)
    (hB : μ (Set.Icc (-B) B)ᶜ = 0) :
    grid μ s u = ∑ b ∈ Finset.Icc ⌊-B/s+u⌋ ⌊B/s+u⌋,
      Real.negMulLog (mass μ (label s u) b) :=
  entropy_eq_sum μ _ _ (label_ae_finite μ hs hB)

theorem label_ae_uniform (μ : Measure ℝ) {B s u : ℝ} (hs : 0 < s)
    (hB : μ (Set.Icc (-B) B)ᶜ = 0) (hu : u ∈ Set.Icc (0 : ℝ) 1) :
    ∀ᵐ x ∂μ, label s u x ∈ Finset.Icc ⌊-B/s⌋ ⌊B/s+1⌋ := by
  filter_upwards [label_ae_finite μ hs hB] with x hx
  obtain ⟨hlo,hhi⟩ := Finset.mem_Icc.mp hx
  exact Finset.mem_Icc.mpr ⟨(Int.floor_le_floor (by linarith [hu.1] : -B/s ≤ -B/s+u)).trans hlo,
    hhi.trans (Int.floor_le_floor (by linarith [hu.2] : B/s+u ≤ B/s+1))⟩

theorem grid_nonneg (μ : Measure ℝ) [IsProbabilityMeasure μ] (s u : ℝ) : 0 ≤ grid μ s u :=
  entropy_nonneg μ _

theorem grid_le_card (μ : Measure ℝ) [IsProbabilityMeasure μ] {B s u : ℝ} (hs : 0 < s)
    (hB : μ (Set.Icc (-B) B)ᶜ = 0) (hu : u ∈ Set.Icc (0 : ℝ) 1) :
    grid μ s u ≤ (Finset.Icc ⌊-B/s⌋ ⌊B/s+1⌋).card := by
  rw [grid, entropy_eq_sum μ _ _ (label_ae_uniform μ hs hB hu)]
  calc
    _ ≤ ∑ b ∈ Finset.Icc ⌊-B/s⌋ ⌊B/s+1⌋, (1 : ℝ) := by
      apply Finset.sum_le_sum
      intro b _
      exact (Real.negMulLog_le_one_sub_self (mass_nonneg μ _ b)).trans
        (sub_le_self _ (mass_nonneg μ _ b))
    _ = _ := by simp

theorem grid_integrable (μ : Measure ℝ) [IsProbabilityMeasure μ] (hμ : CompactlyCarried μ)
    {s : ℝ} (hs : 0 < s) : Integrable (grid μ s) (volume.restrict (Set.Icc 0 1)) := by
  obtain ⟨B,_,hB⟩ := hμ
  apply (integrable_const ((Finset.Icc ⌊-B/s⌋ ⌊B/s+1⌋).card : ℝ)).mono'
    (measurable_grid μ s).aestronglyMeasurable
  filter_upwards [ae_restrict_mem measurableSet_Icc] with u hu
  rw [Real.norm_eq_abs, abs_of_nonneg (grid_nonneg μ s u)]
  exact grid_le_card μ hs hB hu

theorem averaged_nonneg (μ : Measure ℝ) [IsProbabilityMeasure μ] (s : ℝ) :
    0 ≤ averaged μ s := integral_nonneg (fun _ => grid_nonneg μ s _)

theorem mass_comp {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] [DecidableEq γ]
    (μ : Measure α) [IsFiniteMeasure μ] (f : α → β) (hf : Measurable f)
    (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) (g : β → γ) (c : γ) :
    mass μ (g ∘ f) c = FiniteEntropy.mass s (mass μ f) g c := by
  classical
  let t := s.filter (fun b => g b = c)
  have hd : (↑t : Set β).PairwiseDisjoint (fun b => {x | f x = b}) := by
    intro b _ d _ hbd
    exact Set.disjoint_left.mpr (fun _ hx hy => hbd (hx.symm.trans hy))
  have he : {x | g (f x) = c} =ᵐ[μ] ⋃ b ∈ t, {x | f x = b} := by
    filter_upwards [hs] with x hx
    apply propext
    change (g (f x) = c) ↔ x ∈ ⋃ b ∈ t, {x | f x = b}
    simp only [Set.mem_iUnion, Set.mem_ofPred_eq]
    constructor
    · intro h
      exact ⟨f x,Finset.mem_filter.mpr ⟨hx,h⟩,rfl⟩
    · rintro ⟨b,hb,he⟩
      exact he ▸ (Finset.mem_filter.mp hb).2
  unfold mass
  change μ.real {x | g (f x) = c} = _
  rw [measureReal_congr he, measureReal_biUnion_finset hd]
  · rfl
  · intro b _
    exact (measurableSet_singleton b).preimage hf

theorem entropy_comp {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] [DecidableEq γ]
    (μ : Measure α) [IsFiniteMeasure μ] (f : α → β) (hf : Measurable f)
    (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) (g : β → γ) :
    entropy μ (g ∘ f) = FiniteEntropy.observableEntropy s (mass μ f) g := by
  classical
  rw [entropy_eq_sum μ (g ∘ f) (s.image g) (hs.mono (fun _ hx => Finset.mem_image_of_mem g hx))]
  exact Finset.sum_congr rfl (fun b _ => congrArg Real.negMulLog (mass_comp μ f hf s hs g b))

theorem entropy_comp_injective {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] [DecidableEq γ] [Nonempty β] [Nonempty γ]
    (μ : Measure α) [IsFiniteMeasure μ] (f : α → β) (hf : Measurable f)
    (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) (g : β → γ) (hg : Function.Injective g) :
    entropy μ (g ∘ f) = entropy μ f := by
  rw [entropy_comp μ f hf s hs g, FiniteEntropy.observableEntropy_of_injective s _ g
    (fun b _ => mass_nonneg μ f b) hg, entropy_eq_sum μ f s hs]
  rfl

theorem mass_map {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSpace γ] [MeasurableSingletonClass γ]
    (μ : Measure α) (f : α → β) (hf : Measurable f) (g : β → γ) (hg : Measurable g) (c : γ) :
    mass (μ.map f) g c = mass μ (g ∘ f) c := by
  unfold mass Measure.real
  change ((μ.map f) (g ⁻¹' {c})).toReal = _
  rw [Measure.map_apply hf ((measurableSet_singleton c).preimage hg)]
  rfl

theorem entropy_map {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSpace γ] [MeasurableSingletonClass γ]
    (μ : Measure α) (f : α → β) (hf : Measurable f) (g : β → γ) (hg : Measurable g) :
    entropy (μ.map f) g = entropy μ (g ∘ f) := by
  exact tsum_congr (fun c => congrArg Real.negMulLog (mass_map μ f hf g hg c))

theorem grid_periodic (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) : Function.Periodic (grid μ s) 1 := by
  intro u
  obtain ⟨B,_,hB⟩ := hμ
  have he : label s (u+1) = (fun b : ℤ => b+1) ∘ label s u := by
    funext x
    simp only [label, Function.comp_apply]
    rw [← add_assoc, Int.floor_add_one]
  rw [grid, he, entropy_comp_injective μ (label s u) (label_measurable s u)
    _ (label_ae_finite μ hs hB) _ (add_left_injective 1)]
  rfl

theorem grid_translate (μ : Measure ℝ) (s u b : ℝ) :
    grid (μ.map (fun x => x+b)) s u = grid μ s (u+b/s) := by
  rw [grid, entropy_map μ (fun x => x+b) (measurable_id.add_const b) _ (label_measurable s u)]
  congr 1
  funext x
  simp only [Function.comp_apply, label, add_div]
  congr 1
  ring

theorem grid_scale_pos (μ : Measure ℝ) {a s : ℝ} (_ha : 0 < a) (u : ℝ) :
    grid (μ.map (fun x => a*x)) s u = grid μ (s/a) u := by
  rw [grid, entropy_map μ (fun x => a*x) (measurable_const.mul measurable_id) _ (label_measurable s u)]
  congr 1
  funext x
  simp only [Function.comp_apply, label]
  congr 2
  simp only [div_eq_mul_inv, mul_inv_rev, inv_inv]
  ring

theorem entropy_comp_le {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] [DecidableEq γ]
    (μ : Measure α) [IsFiniteMeasure μ] (f : α → β) (hf : Measurable f)
    (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) (g : β → γ) :
    entropy μ (g ∘ f) ≤ entropy μ f := by
  rw [entropy_comp μ f hf s hs g, entropy_eq_sum μ f s hs]
  exact FiniteEntropy.observableEntropy_le s _ g (fun b _ => mass_nonneg μ f b)

theorem entropy_pair_le {α : Type uα} {β : Type uβ} {γ : Type uγ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSpace γ] [MeasurableSingletonClass β] [MeasurableSingletonClass γ]
    [DecidableEq β] [DecidableEq γ]
    (μ : Measure α) [IsProbabilityMeasure μ] (f : α → β) (hf : Measurable f)
    (g : α → γ) (hg : Measurable g) (s : Finset β) (t : Finset γ)
    (hs : ∀ᵐ x ∂μ, f x ∈ s) (ht : ∀ᵐ x ∂μ, g x ∈ t) :
    entropy μ (fun x => (f x,g x)) ≤ entropy μ f + entropy μ g := by
  classical
  let F := fun x => (f x,g x)
  have hF : Measurable F := hf.prodMk hg
  have hst : ∀ᵐ x ∂μ, F x ∈ s ×ˢ t := by
    filter_upwards [hs,ht] with x hx hy
    exact Finset.mem_product.mpr ⟨hx,hy⟩
  have h := FiniteEntropy.observableEntropy_pair_le (s ×ˢ t) (mass μ F) Prod.fst Prod.snd
    (fun b _ => mass_nonneg μ F b) (mass_sum μ F hF (s ×ˢ t) hst)
  have hid : (fun b : β × γ => (b.1,b.2)) = id := rfl
  rw [hid, FiniteEntropy.observableEntropy_id] at h
  have hfst := entropy_comp μ F hF (s ×ˢ t) hst Prod.fst
  have hsnd := entropy_comp μ F hF (s ×ˢ t) hst Prod.snd
  change entropy μ f = _ at hfst
  change entropy μ g = _ at hsnd
  rw [hfst, hsnd, entropy_eq_sum μ F (s ×ˢ t) hst]
  exact h

theorem averaged_eq_intervalIntegral (μ : Measure ℝ) (s : ℝ) :
    averaged μ s = ∫ u in (0 : ℝ)..1, grid μ s u := by
  rw [averaged, integral_Icc_eq_integral_Ioc, intervalIntegral.integral_of_le zero_le_one]

theorem grid_intervalIntegrable (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (a b : ℝ) :
    IntervalIntegrable (grid μ s) volume a b := by
  apply (grid_periodic μ hμ hs).intervalIntegrable₀ one_ne_zero
  exact (intervalIntegrable_iff_integrableOn_Icc_of_le zero_le_one).mpr (grid_integrable μ hμ hs)

theorem averaged_translate (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (b : ℝ) :
    averaged (μ.map (fun x => x+b)) s = averaged μ s := by
  simp only [averaged_eq_intervalIntegral, grid_translate]
  rw [intervalIntegral.integral_comp_add_right]
  simpa only [zero_add, add_comm (1 : ℝ)] using
    (grid_periodic μ hμ hs).intervalIntegral_add_eq (b/s) 0

theorem averaged_scale_pos (μ : Measure ℝ) {a s : ℝ} (ha : 0 < a) :
    averaged (μ.map (fun x => a*x)) s = averaged μ (s/a) := by
  unfold averaged
  exact integral_congr_ae (Filter.Eventually.of_forall (grid_scale_pos μ ha))

theorem averaged_grid_nsmul (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) :
    (∫ u in (0 : ℝ)..1, grid μ s ((N : ℝ)*u)) = averaged μ s := by
  have hNr : (N : ℝ) ≠ 0 := by exact_mod_cast hN.ne'
  rw [intervalIntegral.integral_comp_mul_left _ hNr, mul_zero, mul_one]
  have he := (grid_periodic μ hμ hs).intervalIntegral_add_zsmul_eq (N : ℤ) 0
    (grid_intervalIntegrable μ hμ hs)
  simp only [zsmul_eq_mul, zero_add, Int.cast_natCast, mul_one] at he
  rw [he, smul_eq_mul, ← mul_assoc, inv_mul_cancel₀ hNr, one_mul, averaged_eq_intervalIntegral]

theorem label_nested (s u x : ℝ) {N : ℕ} (hN : 0 < N) :
    label ((N : ℝ)*s) u x = label s ((N : ℝ)*u) x / (N : ℤ) := by
  simp only [label]
  rw [← Int.floor_div_natCast]
  congr 1
  have hn : (N : ℝ) ≠ 0 := by exact_mod_cast hN.ne'
  rw [add_div, mul_div_cancel_left₀ u hn]
  simp only [div_eq_mul_inv, mul_inv_rev]
  ring

theorem entropy_congr_ae {α : Type uα} {β : Type uβ} [MeasurableSpace α]
    (μ : Measure α) {f g : α → β} (h : f =ᵐ[μ] g) : entropy μ f = entropy μ g := by
  apply tsum_congr
  intro b
  congr 1
  apply measureReal_congr
  filter_upwards [h] with x hx
  exact congrArg (fun y => y = b) hx

theorem ae_label_reflect (μ : Measure ℝ) [IsProbabilityMeasure μ] (s : ℝ) :
    ∀ᵐ u ∂volume, ∀ᵐ x ∂μ, label s (-u) (-x) = -label s u x - 1 := by
  have hm : MeasurableSet {ux : ℝ × ℝ | ux.2/s+ux.1 ∉ Set.range (Int.cast : ℤ → ℝ)} :=
    ((Set.countable_range (Int.cast : ℤ → ℝ)).measurableSet.preimage
      ((measurable_snd.div_const s).add measurable_fst)).compl
  have he : ∀ᵐ u ∂volume, ∀ᵐ x ∂μ, x/s+u ∉ Set.range (Int.cast : ℤ → ℝ) := by
    apply (Measure.ae_ae_comm hm).mpr
    apply Filter.Eventually.of_forall
    intro x
    have h := (Set.countable_range (fun n : ℤ => (n : ℝ)-x/s)).ae_notMem volume
    filter_upwards [h] with u hu
    rintro ⟨n,hn⟩
    apply hu
    exact ⟨n,by linarith⟩
  filter_upwards [he] with u hu
  filter_upwards [hu] with x hx
  unfold label
  rw [neg_div, ← neg_add, Int.floor_neg, (Int.ceil_eq_floor_add_one_iff_notMem _).mpr hx]
  omega

theorem grid_reflect_ae (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    (fun u => grid (μ.map Neg.neg) s (-u)) =ᵐ[volume] grid μ s := by
  filter_upwards [ae_label_reflect μ s] with u hu
  obtain ⟨B,_,hB⟩ := hμ
  rw [grid, entropy_map μ Neg.neg measurable_neg _ (label_measurable s (-u))]
  have hh : (label s (-u) ∘ Neg.neg) =ᵐ[μ] (fun b : ℤ => -b-1) ∘ label s u := hu
  rw [entropy_congr_ae μ hh, entropy_comp_injective μ (label s u)
    (label_measurable s u) _ (label_ae_finite μ hs hB) (fun b : ℤ => -b-1)]
  · rfl
  · intro a b hab
    change -a-1 = -b-1 at hab
    omega

theorem averaged_reflect (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    averaged (μ.map Neg.neg) s = averaged μ s := by
  rw [averaged_eq_intervalIntegral, averaged_eq_intervalIntegral]
  have he := intervalIntegral.integral_comp_neg (a := (-1 : ℝ)) (b := 0)
    (grid (μ.map Neg.neg) s)
  simp only [neg_zero, neg_neg] at he
  rw [← he]
  calc
    _ = ∫ u in (-1 : ℝ)..0, grid μ s u := by
      apply intervalIntegral.integral_congr_ae
      filter_upwards [grid_reflect_ae μ hμ hs] with u hu
      exact fun _ => hu
    _ = _ := by simpa only [neg_add_cancel, zero_add] using
      (grid_periodic μ hμ hs).intervalIntegral_add_eq (-1) 0

theorem CompactlyCarried.map_affine {μ : Measure ℝ} (hμ : CompactlyCarried μ) (a b : ℝ) :
    CompactlyCarried (μ.map (fun x => a*x+b)) := by
  obtain ⟨B,hB,hμB⟩ := hμ
  let C := |a| * B + |b|
  refine ⟨C,by dsimp [C]; positivity,?_⟩
  rw [Measure.map_apply (f := fun x : ℝ => a*x+b) (by fun_prop) measurableSet_Icc.compl]
  apply measure_mono_null _ hμB
  intro x hx hxin
  apply hx
  have hxb : |x| ≤ B := abs_le.mpr hxin
  have hax : |a*x+b| ≤ C := (abs_add_le _ _).trans (by
    rw [abs_mul]
    exact add_le_add_left (mul_le_mul_of_nonneg_left hxb (abs_nonneg a)) _)
  exact abs_le.mp hax

theorem averaged_scale (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s a : ℝ} (hs : 0 < s) (ha : a ≠ 0) :
    averaged (μ.map (fun x => a*x)) s = averaged μ (s/|a|) := by
  rcases ha.lt_or_gt with ha | ha
  · have hn : 0 < -a := neg_pos.mpr ha
    have hp : IsProbabilityMeasure (μ.map Neg.neg) := (Measure.isProbabilityMeasure_map_iff measurable_neg.aemeasurable).2 inferInstance
    let := hp
    have hc : CompactlyCarried (μ.map Neg.neg) := by
      convert hμ.map_affine (-1) 0 using 1; simp
    have hm : μ.map (fun x => a*x) = (μ.map Neg.neg).map (fun x => (-a)*x) := by
      rw [Measure.map_map (g := fun x : ℝ => (-a)*x) (by fun_prop) measurable_neg]
      congr 1
      funext x
      simp only [Function.comp_apply, neg_mul_neg]
    rw [hm, averaged_scale_pos _ hn, averaged_reflect μ hμ (div_pos hs hn), abs_of_neg ha]
  · rw [averaged_scale_pos μ ha, abs_of_pos ha]

theorem averaged_affine (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s a : ℝ} (hs : 0 < s) (ha : a ≠ 0) (b : ℝ) :
    averaged (μ.map (fun x => a*x+b)) s = averaged μ (s/|a|) := by
  have hp : IsProbabilityMeasure (μ.map (fun x => a*x)) := (Measure.isProbabilityMeasure_map_iff (measurable_const.mul measurable_id).aemeasurable).2 inferInstance
  let := hp
  have hc : CompactlyCarried (μ.map (fun x => a*x)) := by
    simpa only [add_zero] using hμ.map_affine a 0
  have he : μ.map (fun x => a*x+b) = (μ.map (fun x => a*x)).map (fun x => x+b) := by
    rw [Measure.map_map (g := fun x : ℝ => x+b) (f := fun x : ℝ => a*x) (by fun_prop) (by fun_prop)]
    rfl
  rw [he, averaged_translate _ hc hs b, averaged_scale μ hμ hs ha]

theorem entropy_le_add_of_reconstruct {α : Type uα} {β : Type uβ} {γ : Type uγ} {δ : Type uδ} [MeasurableSpace α]
    [MeasurableSpace β] [MeasurableSpace γ] [MeasurableSingletonClass β]
    [MeasurableSingletonClass γ] [DecidableEq β] [DecidableEq γ] [DecidableEq δ]
    (μ : Measure α) [IsProbabilityMeasure μ] (f : α → δ) (g : α → β) (h : α → γ)
    (hg : Measurable g) (hh : Measurable h) (s : Finset β) (t : Finset γ)
    (hs : ∀ᵐ x ∂μ, g x ∈ s) (ht : ∀ᵐ x ∂μ, h x ∈ t)
    (q : β × γ → δ) (hq : ∀ᵐ x ∂μ, f x = q (g x,h x)) :
    entropy μ f ≤ entropy μ g + entropy μ h := by
  have hst : ∀ᵐ x ∂μ, (g x,h x) ∈ s ×ˢ t := by
    filter_upwards [hs,ht] with x hx hy
    exact Finset.mem_product.mpr ⟨hx,hy⟩
  calc
    entropy μ f = entropy μ (q ∘ fun x => (g x,h x)) := entropy_congr_ae μ hq
    _ ≤ entropy μ (fun x => (g x,h x)) := entropy_comp_le μ _ (hg.prodMk hh) _ hst q
    _ ≤ entropy μ g + entropy μ h := entropy_pair_le μ g hg h hh s t hs ht

theorem entropy_le_log_card {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] (μ : Measure α) [IsProbabilityMeasure μ]
    (f : α → β) (hf : Measurable f) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) :
    entropy μ f ≤ Real.log s.card := by
  rw [entropy_eq_sum μ f s hs]
  exact FiniteEntropy.entropy_le_log_card s _ (fun b _ => mass_nonneg μ f b)
    (mass_sum μ f hf s hs)

theorem floor_relative_bounds {a z b : ℝ} (ha : 0 < a) (hz : 0 ≤ z) (hz' : z < 1) :
    ⌊b+a*z⌋-⌊b⌋ ∈ Finset.Icc (0 : ℤ) ⌈a⌉ := by
  apply Finset.mem_Icc.mpr
  constructor
  · have h := Int.floor_le_floor (show b ≤ b+a*z by nlinarith)
    omega
  · have hlt : b+a*z < ((⌊b⌋+⌈a⌉+1 : ℤ) : ℝ) := by
      push_cast
      nlinarith [Int.lt_floor_add_one b, Int.le_ceil a]
    have hh := Int.floor_lt.mpr hlt
    omega

noncomputable def relativeLabel (s t u v x : ℝ) : ℤ :=
  label s u x - ⌊(t/s)*(label t v x : ℝ)+u-(t/s)*v⌋

theorem relativeLabel_measurable (s t u v : ℝ) : Measurable (relativeLabel s t u v) := by
  unfold relativeLabel
  exact (label_measurable s u).sub
    (((((measurable_of_countable (fun n : ℤ => (n : ℝ))).comp (label_measurable t v)).const_mul (t/s)).add_const u).sub_const ((t/s)*v)).floor

theorem relativeLabel_mem {s t : ℝ} (hs : 0 < s) (ht : 0 < t) (u v x : ℝ) :
    relativeLabel s t u v x ∈ Finset.Icc (0 : ℤ) ⌈t/s⌉ := by
  let z := x/t+v-(label t v x : ℝ)
  have hz : 0 ≤ z := sub_nonneg.mpr (Int.floor_le _)
  have hz' : z < 1 := by
    change x/t+v-(⌊x/t+v⌋ : ℝ) < 1
    linarith [Int.lt_floor_add_one (x/t+v)]
  have he : (t/s)*(label t v x : ℝ)+u-(t/s)*v+(t/s)*z = x/s+u := by
    dsimp [z]
    field_simp; ring
  have h := floor_relative_bounds (b := (t/s)*(label t v x : ℝ)+u-(t/s)*v)
    (div_pos ht hs) hz hz'
  rw [he] at h
  exact h

theorem grid_le_grid_add_log (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s t : ℝ} (hs : 0 < s) (ht : 0 < t) (u v : ℝ) :
    grid μ s u ≤ grid μ t v + Real.log (⌈t/s⌉+1 : ℝ) := by
  obtain ⟨B,_,hB⟩ := hμ
  have hrel : ∀ᵐ x ∂μ, relativeLabel s t u v x ∈ Finset.Icc (0 : ℤ) ⌈t/s⌉ :=
    Filter.Eventually.of_forall (relativeLabel_mem hs ht u v)
  have he := entropy_le_add_of_reconstruct μ (label s u) (label t v) (relativeLabel s t u v)
    (label_measurable t v) (relativeLabel_measurable s t u v) _ _
    (label_ae_finite μ ht hB) hrel
    (fun p : ℤ × ℤ => ⌊(t/s)*(p.1 : ℝ)+u-(t/s)*v⌋+p.2)
    (Filter.Eventually.of_forall (fun x => by dsimp [relativeLabel]; omega))
  have hc := entropy_le_log_card μ _ (relativeLabel_measurable s t u v) _ hrel
  have hn : 0 ≤ ⌈t/s⌉+1 := by have hh := (Int.ceil_pos.mpr (div_pos ht hs)); omega
  have hcard : ((Finset.Icc (0 : ℤ) ⌈t/s⌉).card : ℝ) = (⌈t/s⌉ : ℝ)+1 := by
    rw [Int.card_Icc]
    have he := congrArg (fun k : ℤ => (k : ℝ)) (Int.toNat_of_nonneg hn)
    simpa only [sub_zero, Int.cast_natCast, Int.cast_add, Int.cast_one] using he
  rw [hcard] at hc
  exact he.trans (add_le_add_right hc _)

theorem grid_le_grid_add_log_two (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s t : ℝ} (hs : 0 < s) (ht : 0 < t) (hts : t ≤ s) (u v : ℝ) :
    grid μ s u ≤ grid μ t v + Real.log 2 := by
  have hc : ⌈t/s⌉ = (1 : ℤ) := by
    have hh := Int.ceil_pos.mpr (div_pos ht hs)
    have hu : ⌈t/s⌉ ≤ (1 : ℤ) := Int.ceil_le.mpr (by
      norm_num
      exact (div_le_one hs).mpr hts)
    omega
  simpa only [hc, Int.cast_one, one_add_one_eq_two] using grid_le_grid_add_log μ hμ hs ht u v

theorem grid_le_grid_add_log_ratio (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s t : ℝ} (hs : 0 < s) (ht : 0 < t) (u v : ℝ) :
    grid μ s u ≤ grid μ t v + Real.log (t/s+2) := by
  have hc : (0 : ℝ) < (⌈t/s⌉ : ℝ)+1 := by
    have hh := Int.le_ceil (t/s)
    linarith [div_pos ht hs]
  have hu : (⌈t/s⌉ : ℝ)+1 ≤ t/s+2 := by linarith [Int.ceil_lt_add_one (t/s)]
  exact (grid_le_grid_add_log μ hμ hs ht u v).trans
    (add_le_add_right (Real.log_le_log hc hu) _)

theorem averaged_le_averaged_add_log_two (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s t : ℝ} (hs : 0 < s) (ht : 0 < t) (hts : t ≤ s) :
    averaged μ s ≤ averaged μ t + Real.log 2 := by
  have hi := (grid_integrable μ hμ ht).add (integrable_const (Real.log 2))
  have hh := integral_mono_ae (grid_integrable μ hμ hs) hi
    (Filter.Eventually.of_forall (fun u => grid_le_grid_add_log_two μ hμ hs ht hts u u))
  simp only [Pi.add_apply] at hh
  rw [integral_add (grid_integrable μ hμ ht) (integrable_const _)] at hh
  simpa [averaged, integral_const, Measure.real_def] using hh

theorem averaged_le_averaged_add_log_ratio (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s t : ℝ} (hs : 0 < s) (ht : 0 < t) :
    averaged μ s ≤ averaged μ t + Real.log (t/s+2) := by
  have hi := (grid_integrable μ hμ ht).add (integrable_const (Real.log (t/s+2)))
  have hh := integral_mono_ae (grid_integrable μ hμ hs) hi
    (Filter.Eventually.of_forall (fun u => grid_le_grid_add_log_ratio μ hμ hs ht u u))
  simp only [Pi.add_apply] at hh
  rw [integral_add (grid_integrable μ hμ ht) (integrable_const _)] at hh
  simpa [averaged, integral_const, Measure.real_def] using hh

theorem nested_grid_bounds (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) (u : ℝ) :
    0 ≤ grid μ s ((N : ℝ)*u)-grid μ ((N : ℝ)*s) u ∧
      grid μ s ((N : ℝ)*u)-grid μ ((N : ℝ)*s) u ≤ Real.log N := by
  classical
  obtain ⟨B,_,hB⟩ := hμ
  have hNr : (0 : ℝ) < N := by exact_mod_cast hN
  have hNz : (0 : ℤ) < N := by exact_mod_cast hN
  let f := label s ((N : ℝ)*u)
  let g := label ((N : ℝ)*s) u
  have hf := label_ae_finite (u := (N : ℝ)*u) μ hs hB
  have hg := label_ae_finite (u := u) μ (mul_pos hNr hs) hB
  have hfg : g = (fun z : ℤ => z/(N : ℤ)) ∘ f := by
    funext x
    exact label_nested s u x hN
  have hlow := entropy_comp_le μ f (label_measurable _ _) _ hf (fun z : ℤ => z/(N : ℤ))
  rw [← hfg] at hlow
  have hm : Measurable (fun x => f x % (N : ℤ)) :=
    (measurable_of_countable (fun z : ℤ => z % (N : ℤ))).comp (label_measurable _ _)
  have hr : ∀ᵐ x ∂μ, f x % (N : ℤ) ∈ Finset.Ico (0 : ℤ) (N : ℤ) := by
    apply Filter.Eventually.of_forall
    intro x
    exact Finset.mem_Ico.mpr ⟨Int.emod_nonneg _ hNz.ne', Int.emod_lt_of_pos _ hNz⟩
  have hh := entropy_le_add_of_reconstruct μ f g (fun x => f x%(N : ℤ))
    (label_measurable _ _) hm _ _ hg hr
    (fun p : ℤ × ℤ => p.1*(N : ℤ)+p.2) (Filter.Eventually.of_forall (fun x => by
      rw [hfg]
      exact (Int.ediv_mul_add_emod (f x) N).symm))
  have her := entropy_le_log_card μ _ hm _ hr
  simp only [Int.card_Ico, sub_zero, Int.toNat_natCast] at her
  change entropy μ f ≤ entropy μ g + entropy μ (fun x => f x%(N : ℤ)) at hh
  change 0 ≤ entropy μ f-entropy μ g ∧ entropy μ f-entropy μ g ≤ Real.log N
  constructor <;> linarith

theorem averaged_nested_bounds (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) :
    0 ≤ averaged μ s-averaged μ ((N : ℝ)*s) ∧
      averaged μ s-averaged μ ((N : ℝ)*s) ≤ Real.log N := by
  have hNr : (N : ℝ) ≠ 0 := by exact_mod_cast hN.ne'
  have hpos : (0 : ℝ) < N := by exact_mod_cast hN
  have hf : IntervalIntegrable (fun u => grid μ s ((N : ℝ)*u)) volume 0 1 := by
    simpa only [zero_div, div_self hNr] using
      (grid_intervalIntegrable μ hμ hs 0 (N : ℝ)).comp_mul_left (c := (N : ℝ))
  have hc := grid_intervalIntegrable μ hμ (mul_pos hpos hs) 0 1
  have hi := hf.sub hc
  have hge := intervalIntegral.integral_mono zero_le_one (intervalIntegrable_const (c := (0 : ℝ))) hi
    (fun u => (nested_grid_bounds μ hμ hs hN u).1)
  have hle := intervalIntegral.integral_mono zero_le_one hi
    (intervalIntegrable_const (c := Real.log N)) (fun u => (nested_grid_bounds μ hμ hs hN u).2)
  rw [intervalIntegral.integral_sub hf hc, averaged_grid_nsmul μ hμ hs hN,
    ← averaged_eq_intervalIntegral] at hge hle
  simpa only [intervalIntegral.integral_const, sub_zero, one_smul] using And.intro hge hle

theorem mass_mixture {ι : Type uι} {α : Type uα} {β : Type uβ} [Fintype ι] [MeasurableSpace α]
    (μ : Measure α) (ν : ι → Measure α) [∀ i, IsFiniteMeasure (ν i)] (w : ι → ℝ)
    (hw : ∀ i, 0 ≤ w i) (hm : μ = ∑ i, ENNReal.ofReal (w i) • ν i) (f : α → β) (b : β) :
    mass μ f b = ∑ i, w i*mass (ν i) f b := by
  unfold mass
  rw [hm]
  simp only [Measure.real_def, Measure.coe_finsetSum, Finset.sum_apply, Measure.smul_apply,
    smul_eq_mul]
  rw [ENNReal.toReal_sum (fun i _ => ENNReal.mul_ne_top ENNReal.ofReal_ne_top (measure_ne_top _ _))]
  apply Finset.sum_congr rfl
  intro i _
  rw [ENNReal.toReal_mul, ENNReal.toReal_ofReal (hw i)]

theorem entropy_coarsening_mixture {ι : Type uι} {α : Type uα} {β : Type uβ} {γ : Type uγ} [Fintype ι]
    [MeasurableSpace α] [MeasurableSpace β] [MeasurableSingletonClass β]
    [DecidableEq β] [DecidableEq γ]
    (μ : Measure α) [IsProbabilityMeasure μ] (ν : ι → Measure α)
    [∀ i, IsProbabilityMeasure (ν i)] (w : ι → ℝ) (hw : ∀ i, 0 ≤ w i)
    (hm : μ = ∑ i, ENNReal.ofReal (w i) • ν i)
    (f : α → β) (hf : Measurable f) (s : Finset β)
    (hs : ∀ᵐ x ∂μ, f x ∈ s) (hsi : ∀ i, ∀ᵐ x ∂ν i, f x ∈ s) (g : β → γ) :
    (∑ i, w i*(entropy (ν i) f-entropy (ν i) (g ∘ f))) ≤
      entropy μ f-entropy μ (g ∘ f) := by
  classical
  have hh := FiniteEntropy.conditionalEntropy_mixture Finset.univ s w
    (fun i => mass (ν i) f) id g (fun i _ => hw i)
    (fun i _ b _ => mass_nonneg (ν i) f b) (fun i _ => mass_sum (ν i) f hf s (hsi i))
  have he : (fun b => ∑ i, w i*mass (ν i) f b) = mass μ f :=
    funext (fun b => (mass_mixture μ ν w hw hm f b).symm)
  rw [he, FiniteEntropy.conditionalEntropy_id _ _ _ (fun b _ => mass_nonneg μ f b)] at hh
  have hi : ∀ i, FiniteEntropy.conditionalEntropy s (mass (ν i) f) id g =
      entropy (ν i) f-entropy (ν i) (g ∘ f) := by
    intro i
    rw [FiniteEntropy.conditionalEntropy_id _ _ _ (fun b _ => mass_nonneg (ν i) f b),
      ← entropy_comp (ν i) f hf s (hsi i) g, entropy_eq_sum (ν i) f s (hsi i)]
    rfl
  simp_rw [hi] at hh
  rw [← entropy_comp μ f hf s hs g] at hh
  rw [entropy_eq_sum μ f s hs]
  exact hh

theorem nested_grid_mixture {ι : Type uι} [Fintype ι]
    (μ : Measure ℝ) [IsProbabilityMeasure μ] (hμ : CompactlyCarried μ)
    (ν : ι → Measure ℝ) [∀ i, IsProbabilityMeasure (ν i)]
    (hν : ∀ i, CompactlyCarried (ν i)) (w : ι → ℝ) (hw : ∀ i, 0 ≤ w i)
    (hm : μ = ∑ i, ENNReal.ofReal (w i) • ν i)
    {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) (u : ℝ) :
    (∑ i, w i*(grid (ν i) s ((N : ℝ)*u)-grid (ν i) ((N : ℝ)*s) u)) ≤
      grid μ s ((N : ℝ)*u)-grid μ ((N : ℝ)*s) u := by
  classical
  obtain ⟨B,_,hB⟩ := hμ
  choose C hC hCi using hν
  let v := (N : ℝ)*u
  let a := Finset.Icc ⌊-B/s+v⌋ ⌊B/s+v⌋
  let ai := fun i => Finset.Icc ⌊-C i/s+v⌋ ⌊C i/s+v⌋
  let A := a ∪ Finset.univ.biUnion ai
  have ha : ∀ᵐ x ∂μ, label s v x ∈ A := (label_ae_finite μ hs hB).mono (fun x hx =>
    Finset.mem_union_left _ hx)
  have hai : ∀ i, ∀ᵐ x ∂ν i, label s v x ∈ A := by
    intro i
    filter_upwards [label_ae_finite (u := v) (ν i) hs (hCi i)] with x hx
    exact Finset.mem_union_right a (Finset.mem_biUnion.mpr ⟨i, Finset.mem_univ _, hx⟩)
  have hh := entropy_coarsening_mixture μ ν w hw hm (label s v) (label_measurable s v)
    A ha hai (fun z : ℤ => z/(N : ℤ))
  have he : (fun z : ℤ => z/(N : ℤ)) ∘ label s v = label ((N : ℝ)*s) u := by
    funext x
    exact (label_nested s u x hN).symm
  rw [he] at hh
  exact hh

theorem grid_nsmul_intervalIntegrable (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) :
    IntervalIntegrable (fun u => grid μ s ((N : ℝ)*u)) volume 0 1 := by
  have hn : (N : ℝ) ≠ 0 := by exact_mod_cast hN.ne'
  simpa only [zero_div, div_self hn] using
    (grid_intervalIntegrable μ hμ hs 0 (N : ℝ)).comp_mul_left (c := (N : ℝ))

theorem averaged_nested_mixture {ι : Type uι} [Fintype ι]
    (μ : Measure ℝ) [IsProbabilityMeasure μ] (hμ : CompactlyCarried μ)
    (ν : ι → Measure ℝ) [∀ i, IsProbabilityMeasure (ν i)]
    (hν : ∀ i, CompactlyCarried (ν i)) (w : ι → ℝ) (hw : ∀ i, 0 ≤ w i)
    (hm : μ = ∑ i, ENNReal.ofReal (w i) • ν i)
    {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) :
    (∑ i, w i*(averaged (ν i) s-averaged (ν i) ((N : ℝ)*s))) ≤
      averaged μ s-averaged μ ((N : ℝ)*s) := by
  have hn : (0 : ℝ) < N := by exact_mod_cast hN
  have hi := fun i => (grid_nsmul_intervalIntegrable (ν i) (hν i) hs hN).sub
    (grid_intervalIntegrable (ν i) (hν i) (mul_pos hn hs) 0 1)
  have hf := (grid_nsmul_intervalIntegrable μ hμ hs hN).sub
    (grid_intervalIntegrable μ hμ (mul_pos hn hs) 0 1)
  have hh := intervalIntegral.integral_mono zero_le_one (IntervalIntegrable.sum Finset.univ
    (fun i (_ : i ∈ Finset.univ) => (hi i).const_mul (w i))) hf
      (fun u => by
        simpa only [Finset.sum_apply] using nested_grid_mixture μ hμ ν hν w hw hm hs hN u)
  simp only [Finset.sum_apply] at hh
  rw [intervalIntegral.integral_finsetSum (fun i (_ : i ∈ Finset.univ) => (hi i).const_mul (w i))] at hh
  simp_rw [intervalIntegral.integral_const_mul] at hh
  simp_rw [intervalIntegral.integral_sub (grid_nsmul_intervalIntegrable (ν _) (hν _) hs hN)
    (grid_intervalIntegrable (ν _) (hν _) (mul_pos hn hs) 0 1),
    averaged_grid_nsmul (ν _) (hν _) hs hN, ← averaged_eq_intervalIntegral] at hh
  rw [intervalIntegral.integral_sub (grid_nsmul_intervalIntegrable μ hμ hs hN)
    (grid_intervalIntegrable μ hμ (mul_pos hn hs) 0 1),
    averaged_grid_nsmul μ hμ hs hN, ← averaged_eq_intervalIntegral] at hh
  exact hh

theorem CompactlyCarried.mixture {ι : Type uι} [Fintype ι]
    (ν : ι → Measure ℝ) (hν : ∀ i, CompactlyCarried (ν i)) (w : ι → ℝ) :
    CompactlyCarried (∑ i, ENNReal.ofReal (w i) • ν i) := by
  classical
  choose C hC hCi using hν
  let B := ∑ i, C i
  have hi : ∀ i, C i ≤ B := fun i => Finset.single_le_sum (fun j _ => hC j) (Finset.mem_univ i)
  refine ⟨B, Finset.sum_nonneg (fun i _ => hC i), ?_⟩
  simp only [Measure.coe_finsetSum, Finset.sum_apply, Measure.smul_apply, smul_eq_mul]
  apply Finset.sum_eq_zero
  intro i _
  have hz : ν i (Set.Icc (-B) B)ᶜ = 0 := measure_mono_null (by
    intro x hx hxin
    exact hx ⟨by linarith [hxin.1,hi i],by linarith [hxin.2,hi i]⟩) (hCi i)
  rw [hz, mul_zero]

theorem mixture_probability {ι : Type uι} {α : Type uα} [Fintype ι] [MeasurableSpace α]
    (ν : ι → Measure α) [∀ i, IsProbabilityMeasure (ν i)] (w : ι → ℝ)
    (hw : ∀ i, 0 ≤ w i) (hw1 : ∑ i, w i=1) :
    IsProbabilityMeasure (∑ i, ENNReal.ofReal (w i) • ν i) := by
  constructor
  simp only [Measure.coe_finsetSum, Finset.sum_apply, Measure.smul_apply, measure_univ,
    smul_eq_mul, mul_one]
  rw [← ENNReal.ofReal_sum_of_nonneg (fun i _ => hw i), hw1, ENNReal.ofReal_one]

theorem averaged_nested_translate_mixture {ι : Type uι} [Fintype ι]
    (μ : Measure ℝ) [IsProbabilityMeasure μ] (hμ : CompactlyCarried μ)
    (w : ι → ℝ) (hw : ∀ i, 0 ≤ w i) (hw1 : ∑ i, w i=1) (b : ι → ℝ)
    {s : ℝ} (hs : 0 < s) {N : ℕ} (hN : 0 < N) :
    averaged μ s-averaged μ ((N : ℝ)*s) ≤
      averaged (∑ i, ENNReal.ofReal (w i) • μ.map (fun x => x+b i)) s-
      averaged (∑ i, ENNReal.ofReal (w i) • μ.map (fun x => x+b i)) ((N : ℝ)*s) := by
  let ν := fun i => μ.map (fun x => x+b i)
  have hp : ∀ i, IsProbabilityMeasure (ν i) := fun i =>
    (Measure.isProbabilityMeasure_map_iff (measurable_id.add_const (b i)).aemeasurable).2 inferInstance
  let := hp
  have hc : ∀ i, CompactlyCarried (ν i) := fun i => by
    simpa only [one_mul] using hμ.map_affine 1 (b i)
  let ρ := ∑ i, ENNReal.ofReal (w i) • ν i
  have hpρ := mixture_probability ν w hw hw1
  let := hpρ
  have hh := averaged_nested_mixture ρ (CompactlyCarried.mixture ν hc w) ν hc w hw rfl hs hN
  have hn : (0 : ℝ) < N := by exact_mod_cast hN
  have he : ∀ i, averaged (ν i) s-averaged (ν i) ((N : ℝ)*s) =
      averaged μ s-averaged μ ((N : ℝ)*s) := by
    intro i
    rw [averaged_translate μ hμ hs, averaged_translate μ hμ (mul_pos hn hs)]
  simp_rw [he] at hh
  simpa only [← Finset.sum_mul, hw1, one_mul] using hh

theorem entropy_summable {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) (a : Finset β) (ha : ∀ᵐ x ∂μ, f x ∈ a) :
    Summable (fun b => Real.negMulLog (mass μ f b)) := by
  apply summable_of_ne_finset_zero (s := a)
  intro b hb
  simp only [mass_eq_zero_of_ae μ f a ha hb, Real.negMulLog_zero]

theorem mass_summable {α : Type uα} {β : Type uβ} [MeasurableSpace α] (μ : Measure α)
    (f : α → β) (a : Finset β) (ha : ∀ᵐ x ∂μ, f x ∈ a) :
    Summable (mass μ f) := by
  apply summable_of_ne_finset_zero (s := a)
  exact fun b hb => mass_eq_zero_of_ae μ f a ha hb

theorem mass_tsum {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] (μ : Measure α) [IsProbabilityMeasure μ]
    (f : α → β) (hf : Measurable f) (a : Finset β) (ha : ∀ᵐ x ∂μ, f x ∈ a) :
    ∑' b, mass μ f b = 1 := by
  rw [tsum_eq_sum (fun b hb => mass_eq_zero_of_ae μ f a ha hb)]
  exact mass_sum μ f hf a ha

noncomputable def fairShift (μ : Measure ℝ) (v : ℝ) : Measure ℝ :=
  ∑ i : Fin 2, ENNReal.ofReal (1/2 : ℝ) • μ.map (fun x => x+(i : ℝ)*v)

theorem fairShift_probability (μ : Measure ℝ) [IsProbabilityMeasure μ] (v : ℝ) :
    IsProbabilityMeasure (fairShift μ v) := by
  let ν := fun i : Fin 2 => μ.map (fun x => x+(i : ℝ)*v)
  have : ∀ i, IsProbabilityMeasure (ν i) := fun i =>
    (Measure.isProbabilityMeasure_map_iff (measurable_id.add_const _).aemeasurable).2 inferInstance
  let := this
  exact mixture_probability ν (fun _ => 1/2) (by intro; positivity) (by norm_num [Fin.sum_univ_two])

theorem CompactlyCarried.fairShift {μ : Measure ℝ} (hμ : CompactlyCarried μ) (v : ℝ) :
    CompactlyCarried (fairShift μ v) := by
  apply CompactlyCarried.mixture
  intro i
  simpa only [one_mul] using hμ.map_affine 1 ((i : ℝ)*v)

theorem label_add_scale {s : ℝ} (hs : s ≠ 0) (u x : ℝ) :
    label s u (x+s) = label s u x+1 := by
  dsimp only [label]
  rw [add_div, div_self hs]
  convert Int.floor_add_one (x/s+u) using 1
  congr 1
  ring

theorem mass_fairShift (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {s : ℝ} (hs : 0 < s) (u : ℝ) (j : ℤ) :
    mass (fairShift μ s) (label s u) j =
      (mass μ (label s u) j+mass μ (label s u) (j-1))/2 := by
  have hi : ∀ i : Fin 2, IsProbabilityMeasure (μ.map (fun x => x+(i : ℝ)*s)) :=
    fun i => (Measure.isProbabilityMeasure_map_iff (measurable_id.add_const _).aemeasurable).2 inferInstance
  let := hi
  rw [mass_mixture (fairShift μ s) _ (fun _ : Fin 2 => 1/2) (by intro; positivity) rfl,
    Fin.sum_univ_two]
  simp only [Fin.val_zero, Nat.cast_zero, zero_mul, add_zero, Fin.val_one,
    Nat.cast_one, one_mul]
  rw [mass_map μ (fun x => x) measurable_id (label s u) (label_measurable s u),
    mass_map μ (fun x => x+s) (measurable_id.add_const s) (label s u) (label_measurable s u)]
  have he : mass μ ((label s u) ∘ (fun x => x+s)) j = mass μ (label s u) (j-1) := by
    unfold mass
    congr 1
    ext x
    simp only [Set.mem_ofPred_eq, Function.comp_apply, label_add_scale hs.ne']
    omega
  rw [he]
  change (1/2)*mass μ (label s u) j+(1/2)*mass μ (label s u) (j-1) = _
  ring

theorem mass_int_div_two {α : Type uα} [MeasurableSpace α] (μ : Measure α)
    [IsFiniteMeasure μ] (f : α → ℤ) (hf : Measurable f) (k : ℤ) :
    mass μ (fun x => f x/2) k = mass μ f (2*k)+mass μ f (2*k+1) := by
  have he : {x | f x/2=k} = {x | f x=2*k} ∪ {x | f x=2*k+1} := by
    ext x
    simp only [Set.mem_ofPred_eq, Set.mem_union]
    omega
  unfold mass
  rw [he]
  apply measureReal_union
  · exact Set.disjoint_left.mpr (by
      intro x hx hy
      simp only [Set.mem_ofPred_eq] at hx hy
      omega)
  · exact measurableSet_eq_fun hf measurable_const
  · exact measure_ne_top μ _
  · exact measure_ne_top μ _

theorem mass_nested_two (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (s u : ℝ) (k : ℤ) :
    mass μ (label (2*s) (u/2)) k =
      mass μ (label s u) (2*k)+mass μ (label s u) (2*k+1) := by
  have he : label (2*s) (u/2) = fun x => label s u x/2 := by
    funext x
    simpa only [Nat.cast_ofNat, show (2 : ℝ) * (u / 2) = u by ring] using
      label_nested s (u/2) x (by norm_num : 0 < (2 : ℕ))
  rw [he, mass_int_div_two μ _ (label_measurable s u)]

theorem mass_fairShift_odd (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {s : ℝ} (hs : 0 < s) (u : ℝ) (k : ℤ) :
    mass (fairShift μ s) (label s u) (2*k+1) =
      mass μ (label (2*s) (u/2)) k/2 := by
  rw [mass_fairShift μ hs, mass_nested_two]
  simp only [add_sub_cancel_right]
  ring

theorem mass_fairShift_even (μ : Measure ℝ) [IsProbabilityMeasure μ]
    {s : ℝ} (hs : 0 < s) (u : ℝ) (k : ℤ) :
    mass (fairShift μ s) (label s u) (2*k) =
      mass μ (label (2*s) ((u+1)/2)) k/2 := by
  have he (j : ℤ) : mass μ (label s (u+1)) j = mass μ (label s u) (j-1) := by
    unfold mass label
    congr 1
    ext x
    simp only [Set.mem_ofPred_eq, ← add_assoc, Int.floor_add_one]
    omega
  rw [mass_fairShift μ hs, mass_nested_two, he, he]
  simp only [add_sub_cancel_right]
  ring

theorem entropy_half_mass {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] (μ : Measure α) [IsProbabilityMeasure μ]
    (f : α → β) (hf : Measurable f) (a : Finset β) (ha : ∀ᵐ x ∂μ, f x ∈ a) :
    (∑' b, Real.negMulLog (mass μ f b/2)) = entropy μ f/2+Real.log 2/2 := by
  have he (b : β) : Real.negMulLog (mass μ f b/2) =
      (1/2)*Real.negMulLog (mass μ f b)+Real.negMulLog (1/2)*mass μ f b := by
    rw [div_eq_mul_inv, Real.negMulLog_mul]
    ring_nf
  simp_rw [he]
  rw [((entropy_summable μ f a ha).mul_left (1/2)).tsum_add
    ((mass_summable μ f a ha).mul_left (Real.negMulLog (1/2))),
    tsum_mul_left, tsum_mul_left, mass_tsum μ f hf a ha]
  have hc : Real.negMulLog (1/2)=Real.log 2/2 := by
    change -(1/2 : ℝ)*Real.log (1/2)=_
    rw [Real.log_div (by norm_num) (by norm_num), Real.log_one]
    ring
  rw [hc]
  change (1/2)*entropy μ f+(Real.log 2/2)*1 = _
  ring

theorem grid_fairShift (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    grid (fairShift μ s) s u = Real.log 2+
      (grid μ (2*s) (u/2)+grid μ (2*s) ((u+1)/2))/2 := by
  classical
  obtain ⟨B,hB,hBμ⟩ := (hμ.fairShift s)
  let F := fun j => Real.negMulLog (mass (fairShift μ s) (label s u) j)
  have hf : Summable F := entropy_summable (fairShift μ s) _ _ (label_ae_finite _ hs hBμ)
  have heven : Summable (fun k : ℤ => F (k*2)) := hf.comp_injective (i := fun k : ℤ => k*2) (by
    intro a b h
    change a*2=b*2 at h
    omega)
  have hodd : Summable (fun k : ℤ => F (k*2+1)) := hf.comp_injective (i := fun k : ℤ => k*2+1) (by
    intro a b h
    change a*2+1=b*2+1 at h
    omega)
  have hprod := ((Int.divModEquiv 2).symm.summable_iff).mpr hf
  change Summable (fun p => F ((Int.divModEquiv 2).symm p)) at hprod
  change (∑' j, F j) = _
  rw [← (Int.divModEquiv 2).symm.tsum_eq F, hprod.tsum_prod]
  simp only [tsum_fintype, Fin.sum_univ_two, Int.divModEquiv_symm_apply,
    Nat.cast_ofNat, Fin.val_zero, Nat.cast_zero, add_zero, Fin.val_one, Nat.cast_one]
  rw [heven.tsum_add hodd]
  dsimp only [F]
  simp_rw [show ∀ k : ℤ, k*2=2*k from fun k => mul_comm k 2,
    mass_fairShift_even μ hs, mass_fairShift_odd μ hs]
  obtain ⟨C,hC,hCμ⟩ := hμ
  rw [entropy_half_mass μ _ (label_measurable _ _) _
      (label_ae_finite μ (by linarith : 0 < 2*s) hCμ),
    entropy_half_mass μ _ (label_measurable _ _) _
      (label_ae_finite μ (by linarith : 0 < 2*s) hCμ)]
  change grid μ (2*s) ((u+1)/2)/2+Real.log 2/2+
    (grid μ (2*s) (u/2)/2+Real.log 2/2) = _
  ring

theorem averaged_fairShift (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    averaged (fairShift μ s) s = averaged μ (2*s)+Real.log 2 := by
  have ht : 0 < 2*s := by linarith
  let f := grid μ (2*s)
  have hi0 : IntervalIntegrable (fun u => f (u/2)) volume 0 1 := by
    have h := (grid_intervalIntegrable μ hμ ht 0 (1/2)).comp_mul_left (c := (1/2 : ℝ))
    norm_num at h
    simpa only [f, div_eq_mul_inv, mul_comm, one_mul] using h
  have hi1 : IntervalIntegrable (fun u => f ((u+1)/2)) volume 0 1 := by
    have h := (grid_intervalIntegrable μ hμ ht (1/2) 1).comp_mul_left (c := (1/2 : ℝ))
    norm_num at h
    have hh := h.comp_add_right 1
    norm_num at hh
    simpa only [f, div_eq_mul_inv, mul_comm, one_mul] using hh
  have he0 : (∫ u in (0 : ℝ)..1, f (u/2)) = 2*(∫u in (0 : ℝ)..(1/2), f u) := by
    rw [intervalIntegral.integral_comp_div f (by norm_num : (2 : ℝ) ≠ 0)]
    simp only [zero_div, smul_eq_mul]
  have he1 : (∫ u in (0 : ℝ)..1, f ((u+1)/2)) = 2*(∫u in (1/2 : ℝ)..1, f u) := by
    rw [intervalIntegral.integral_comp_add_right (fun u => f (u/2)) 1]
    norm_num only [zero_add, one_add_one_eq_two]
    rw [intervalIntegral.integral_comp_div f (by norm_num : (2 : ℝ) ≠ 0)]
    norm_num only [div_self (by norm_num : (2 : ℝ) ≠ 0), smul_eq_mul]
  rw [averaged_eq_intervalIntegral]
  calc
    _ = ∫u in (0 : ℝ)..1, Real.log 2+(f (u/2)+f ((u+1)/2))/2 := by
      apply intervalIntegral.integral_congr
      intro u _
      exact grid_fairShift μ hμ hs u
    _ = Real.log 2+(2*(∫u in (0 : ℝ)..(1/2), f u)+
        2*(∫u in (1/2 : ℝ)..1, f u))/2 := by
      rw [intervalIntegral.integral_add intervalIntegrable_const ((hi0.add hi1).div_const 2),
        intervalIntegral.integral_div, intervalIntegral.integral_add hi0 hi1, he0, he1]
      simp only [intervalIntegral.integral_const, sub_zero, one_smul]
    _ = averaged μ (2*s)+Real.log 2 := by
      have hh := intervalIntegral.integral_add_adjacent_intervals
        (grid_intervalIntegrable μ hμ ht 0 (1/2)) (grid_intervalIntegrable μ hμ ht (1/2) 1)
      change (∫u in (0 : ℝ)..(1/2), f u)+(∫u in (1/2 : ℝ)..1, f u) = _ at hh
      rw [← mul_add, mul_div_cancel_left₀ _ (by norm_num : (2 : ℝ) ≠ 0), hh,
        ← averaged_eq_intervalIntegral]
      ring

noncomputable def observationLaw {α : Type uα} {β : Type uβ} [MeasurableSpace α] [MeasurableSpace β]
    [MeasurableSingletonClass β] (μ : Measure α) [IsProbabilityMeasure μ]
    (f : α → β) (hf : Measurable f) (s : Finset β) (hs : ∀ᵐ x ∂μ, f x ∈ s) :
    FiniteDistribution β :=
  ⟨mass μ f,s,mass_nonneg μ f,fun _b hb => mass_eq_zero_of_ae μ f s hs hb,
    mass_sum μ f hf s hs⟩

noncomputable def gridLaw (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) : FiniteDistribution ℤ :=
  observationLaw μ (label s u) (label_measurable s u)
    (Finset.Icc ⌊-hμ.choose/s+u⌋ ⌊hμ.choose/s+u⌋)
    (label_ae_finite μ hs hμ.choose_spec.2)

theorem gridLaw_weight (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    (gridLaw μ hμ hs u).weight=mass μ (label s u) := rfl

theorem gridLaw_entropy (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    (gridLaw μ hμ hs u).entropy=grid μ s u := rfl

noncomputable def gridDeficit (μ : Measure ℝ) (s u : ℝ) : ℝ :=
  grid (fairShift μ s) s u-grid μ s u

theorem gridDeficit_eq_js (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    gridDeficit μ s u=(gridLaw μ hμ hs u).js ((gridLaw μ hμ hs u).translate 1) := by
  let := fairShift_probability μ s
  let p := gridLaw μ hμ hs u
  have he : (p.mix (p.translate 1)).weight=(gridLaw (fairShift μ s) (hμ.fairShift s) hs u).weight := by
    funext b
    change (p.weight b+(p.translate 1).weight b)/2=mass (fairShift μ s) (label s u) b
    rw [FiniteDistribution.translate_weight, mass_fairShift μ hs]
    rfl
  have ht : (p.translate 1).entropy=p.entropy :=
    FiniteDistribution.entropy_map_injective p (fun a : ℤ => a+1) (add_left_injective 1)
  rw [FiniteDistribution.js, FiniteDistribution.entropy_congr _ _ he, ht]
  change grid (fairShift μ s) s u-grid μ s u=
    grid (fairShift μ s) s u-(grid μ s u+grid μ s u)/2
  ring

theorem gridDeficit_bounds (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    0 ≤ gridDeficit μ s u ∧ gridDeficit μ s u ≤ Real.log 2 := by
  rw [gridDeficit_eq_js μ hμ hs u]
  exact ⟨FiniteDistribution.js_nonneg _ _,FiniteDistribution.js_le_log_two _ _⟩

theorem gridLaw_coarsen_two (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    ((gridLaw μ hμ hs (2*u)).map (fun n : ℤ => n/2)).weight=
      (gridLaw μ hμ (mul_pos (by norm_num : (0 : ℝ)<2) hs) u).weight := by
  classical
  let : DecidableEq ℤ := fun _ _ => Classical.propDecidable _
  funext b
  rw [FiniteDistribution.map_weight_on _ _ _ (Finset.Subset.refl _)]
  change FiniteEntropy.mass (Finset.Icc ⌊-hμ.choose/s+2*u⌋ ⌊hμ.choose/s+2*u⌋) (mass μ (label s (2*u))) (fun n : ℤ => n/2) b=
    mass μ (label (2*s) u) b
  rw [← mass_comp μ (label s (2*u)) (label_measurable _ _) _
    (label_ae_finite μ hs hμ.choose_spec.2)]
  congr 1
  funext x
  symm
  simpa using label_nested s u x (by norm_num : 0 < (2 : ℕ))

theorem gridDeficit_double_sq (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) (u : ℝ) :
    (gridDeficit μ (2*s) u)^2 ≤ 8*(Real.log 2)^2*gridDeficit μ s (2*u) := by
  let p := gridLaw μ hμ hs (2*u)
  let q := gridLaw μ hμ (mul_pos (by norm_num : (0 : ℝ)<2) hs) u
  have he : (p.map (fun n => n/2)).weight=q.weight := gridLaw_coarsen_two μ hμ hs u
  have he' : ((p.translate 2).map (fun n => n/2)).weight=(q.translate 1).weight := by
    rw [FiniteDistribution.map_translate_div_two]
    funext b
    rw [FiniteDistribution.translate_weight, FiniteDistribution.translate_weight, he]
  have hh := FiniteDistribution.js_two_step_coarsen p (fun n => n/2)
  rw [FiniteDistribution.js_congr _ _ q (q.translate 1) he he'] at hh
  rw [gridDeficit_eq_js μ hμ (mul_pos (by norm_num : (0 : ℝ)<2) hs) u,
    gridDeficit_eq_js μ hμ hs (2*u)]
  exact hh

theorem gridDeficit_integrable (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    Integrable (gridDeficit μ s) (volume.restrict (Set.Icc 0 1)) := by
  let := fairShift_probability μ s
  exact (grid_integrable (fairShift μ s) (hμ.fairShift s) hs).sub (grid_integrable μ hμ hs)

theorem integral_gridDeficit (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    (∫ u in Set.Icc (0 : ℝ) 1, gridDeficit μ s u)=
      Real.log 2-(averaged μ s-averaged μ (2*s)) := by
  let := fairShift_probability μ s
  simp only [gridDeficit]
  rw [integral_sub (grid_integrable _ (hμ.fairShift s) hs) (grid_integrable μ hμ hs)]
  change averaged (fairShift μ s) s-averaged μ s=_
  rw [averaged_fairShift μ hμ hs]
  ring

noncomputable def deficit (μ : Measure ℝ) (s : ℝ) : ℝ :=
  Real.log 2-(averaged μ s-averaged μ (2*s))

theorem deficit_bounds (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    0 ≤ deficit μ s ∧ deficit μ s ≤ Real.log 2 := by
  rw [deficit, ← integral_gridDeficit μ hμ hs]
  constructor
  · exact integral_nonneg (fun u => (gridDeficit_bounds μ hμ hs u).1)
  · have hh := integral_mono (gridDeficit_integrable μ hμ hs)
      (integrable_const (Real.log 2)) (fun u => (gridDeficit_bounds μ hμ hs u).2)
    simpa using hh

theorem gridDeficit_sq_integrable (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    Integrable (fun u => (gridDeficit μ s u)^2) (volume.restrict (Set.Icc 0 1)) := by
  apply (integrable_const ((Real.log 2)^2)).mono'
    ((gridDeficit_integrable μ hμ hs).aestronglyMeasurable.pow 2)
  filter_upwards [] with u
  rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)]
  obtain ⟨h0,h1⟩ := gridDeficit_bounds μ hμ hs u
  exact pow_le_pow_left₀ h0 h1 2

theorem integral_gridDeficit_double_shift (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    (∫ u in Set.Icc (0 : ℝ) 1, gridDeficit μ s (2*u))=deficit μ s := by
  let := fairShift_probability μ s
  have hi (ν : Measure ℝ) [IsProbabilityMeasure ν] (hν : CompactlyCarried ν) :
      IntervalIntegrable (fun u => grid ν s (2*u)) volume 0 1 := by
    have h := (grid_intervalIntegrable ν hν hs 0 2).comp_mul_left (c := (2 : ℝ))
    norm_num at h
    exact h
  rw [integral_Icc_eq_integral_Ioc, ← intervalIntegral.integral_of_le zero_le_one]
  simp only [gridDeficit]
  have he (ν : Measure ℝ) [IsProbabilityMeasure ν] (hν : CompactlyCarried ν) :
      (∫ u in (0 : ℝ)..1, grid ν s (2*u)) = averaged ν s := by
    simpa using averaged_grid_nsmul ν hν hs (by norm_num : 0 < (2 : ℕ))
  rw [intervalIntegral.integral_sub (hi _ (hμ.fairShift s)) (hi μ hμ),
    he _ (hμ.fairShift s), he μ hμ,
    averaged_fairShift μ hμ hs, deficit]
  ring

theorem deficit_double_sq (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) {s : ℝ} (hs : 0 < s) :
    (deficit μ (2*s))^2 ≤ 8*(Real.log 2)^2*deficit μ s := by
  let := fairShift_probability μ s
  have ht : 0 < 2*s := mul_pos (by norm_num) hs
  let : IsProbabilityMeasure (volume.restrict (Set.Icc (0 : ℝ) 1)) := ⟨by simp⟩
  have hj := (convexOn_pow (𝕜 := ℝ) 2).map_integral_le
    (continuous_pow 2).continuousOn isClosed_Ici
    (Filter.Eventually.of_forall (fun u => (gridDeficit_bounds μ hμ ht u).1))
    (gridDeficit_integrable μ hμ ht) (gridDeficit_sq_integrable μ hμ ht)
  rw [integral_gridDeficit μ hμ ht] at hj
  change (deficit μ (2*s))^2 ≤ _ at hj
  have hi : Integrable (fun u => gridDeficit μ s (2*u))
      (volume.restrict (Set.Icc 0 1)) := by
    apply (integrable_const (Real.log 2)).mono'
      (((measurable_grid (fairShift μ s) s).sub (measurable_grid μ s)).comp
        (measurable_const.mul measurable_id)).aestronglyMeasurable
    filter_upwards [] with u
    exact (abs_of_nonneg (gridDeficit_bounds μ hμ hs (2*u)).1).le.trans
      (gridDeficit_bounds μ hμ hs (2*u)).2
  have hh := integral_mono (gridDeficit_sq_integrable μ hμ ht)
    (hi.const_mul (8*(Real.log 2)^2)) (gridDeficit_double_sq μ hμ hs)
  change (∫ u in Set.Icc (0 : ℝ) 1, (gridDeficit μ (2*s) u)^2) ≤ _ at hh
  rw [integral_const_mul, integral_gridDeficit_double_shift μ hμ hs] at hh
  exact hj.trans hh

theorem deficit_dyadic_tendsto_zero (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) (v : ℕ → ℝ) (hv : ∀ n, 0 < v n)
    (h : Filter.Tendsto (fun n => deficit μ (v n)) Filter.atTop (nhds 0)) (j : ℕ) :
    Filter.Tendsto (fun n => deficit μ ((2 : ℝ)^j*v n)) Filter.atTop (nhds 0) := by
  induction j with
  | zero => simpa using h
  | succ j ih =>
    have hz : Filter.Tendsto (fun n => Real.sqrt (8*(Real.log 2)^2 *
        deficit μ ((2 : ℝ)^j*v n))) Filter.atTop (nhds 0) := by
      simpa using (ih.const_mul (8*(Real.log 2)^2)).sqrt
    apply tendsto_of_tendsto_of_tendsto_of_le_of_le tendsto_const_nhds hz
    · intro n
      exact (deficit_bounds μ hμ (s := (2 : ℝ)^(j+1)*v n)
        (mul_pos (pow_pos (by norm_num) _) (hv n))).1
    · intro n
      apply Real.le_sqrt_of_sq_le
      have hb := deficit_double_sq μ hμ (s := (2 : ℝ)^j*v n)
        (mul_pos (pow_pos (by norm_num) _) (hv n))
      have he : (2 : ℝ)^(j+1)*v n = 2*((2 : ℝ)^j*v n) := by rw [pow_succ]; ring
      rwa [← he] at hb

theorem sum_dyadic_deficit (μ : Measure ℝ) (s : ℝ) (K : ℕ) :
    (∑j ∈ Finset.range K, deficit μ ((2 : ℝ)^j*s))=
      K*Real.log 2-(averaged μ s-averaged μ ((2 : ℝ)^K*s)) := by
  induction K with
  | zero => simp
  | succ K ih =>
    rw [Finset.sum_range_succ, ih]
    simp only [deficit, Nat.cast_add, Nat.cast_one, pow_succ]
    have he : 2*((2 : ℝ)^K*s)=2^K*2*s := by ring
    rw [he]
    ring

theorem wide_window_saturation (μ : Measure ℝ) [IsProbabilityMeasure μ]
    (hμ : CompactlyCarried μ) (v : ℕ → ℝ) (hv : ∀ n, 0 < v n)
    (h : Filter.Tendsto (fun n => deficit μ (v n)) Filter.atTop (nhds 0)) (K : ℕ) :
    Filter.Tendsto (fun n => averaged μ (v n)-averaged μ ((2 : ℝ)^K*v n))
      Filter.atTop (nhds (K*Real.log 2)) := by
  have hh := tendsto_finsetSum (Finset.range K) (fun j _ => deficit_dyadic_tendsto_zero μ hμ v hv h j)
  simp only [sum_dyadic_deficit, Finset.sum_const_zero] at hh
  have ht := (tendsto_const_nhds (x := (K : ℝ)*Real.log 2)).sub hh
  simpa only [sub_sub_cancel, sub_zero] using ht

end MeasureEntropy
end EntropyRateDimension
end

end OAI