lean/OAI/Dynamics/MultipleMixing/Foundations.lean

import Mathlib

namespace OAI

namespace Rokhlin

open MeasureTheory Filter
open scoped BigOperators ComplexConjugate

section

structure ProjectiveCharacters {Y L : Type*} [MeasurableSpace Y] [AddCommGroup L]
    (η : Measure Y) (χ : L → Y → ℂ) : Prop where
  measurable : ∀ l, AEStronglyMeasurable (χ l) η
  modulus : ∀ l, ∀ᵐ y ∂η, ‖χ l y‖ = 1
  zero : χ 0 =ᵐ[η] fun _ => 1
  mul : ∀ l l', ∃ c : ℂ, ‖c‖ = 1 ∧
    (fun y => χ l y * χ l' y) =ᵐ[η] (fun y => c * χ (l + l') y)
  mean : ∀ l, l ≠ 0 → ∫ y, χ l y ∂η = 0

namespace ProjectiveCharacters
variable {Y L : Type*} [MeasurableSpace Y] [AddCommGroup L]
  {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}
  (hχ : ProjectiveCharacters η χ)
include hχ

theorem integrable (l : L) : Integrable (χ l) η :=
  (integrable_const (1 : ℝ)).mono' (hχ.measurable l) ((hχ.modulus l).mono (fun _ h => h.le))

omit [IsProbabilityMeasure η] in

theorem conjugate (l : L) : ∃ c : ℂ, ‖c‖ = 1 ∧
    (fun y => conj (χ l y)) =ᵐ[η] (fun y => c * χ (-l) y) := by
  obtain ⟨c, hc, hm⟩ := hχ.mul (-l) l
  refine ⟨c⁻¹, by simp [hc], ?_⟩
  filter_upwards [hm, hχ.zero, hχ.modulus l] with y hy h0 hn
  simp only [neg_add_cancel, h0, mul_one] at hy
  have hcn : c ≠ 0 := by intro hz; simp [hz] at hc
  have hln : χ l y ≠ 0 := by intro hz; simp [hz] at hn
  rw [← Complex.inv_eq_conj hn]
  apply (mul_right_cancel₀ hln)
  rw [inv_mul_cancel₀ hln, mul_assoc, hy, inv_mul_cancel₀ hcn]

omit [IsProbabilityMeasure η] in

theorem finset_prod {ι : Type*} (s : Finset ι) (l : ι → L) :
    ∃ c : ℂ, ‖c‖ = 1 ∧
      (fun y => ∏ i ∈ s, χ (l i) y) =ᵐ[η] (fun y => c * χ (∑ i ∈ s, l i) y) := by
  classical
  induction s using Finset.induction_on with
  | empty =>
    refine ⟨1, norm_one, ?_⟩
    filter_upwards [hχ.zero] with y hy
    simp [hy]
  | @insert i s hi ih =>
    obtain ⟨c, hc, hsp⟩ := ih
    obtain ⟨d, hd, hmul⟩ := hχ.mul (l i) (∑ j ∈ s, l j)
    refine ⟨c * d, by simp [hc, hd], ?_⟩
    filter_upwards [hsp, hmul] with y hy hm
    simp only [Finset.prod_insert hi, Finset.sum_insert hi, hy]
    calc
      χ (l i) y * (c * χ (∑ j ∈ s, l j) y) =
        c * (χ (l i) y * χ (∑ j ∈ s, l j) y) := by ring
      _ = c * (d * χ (l i + ∑ j ∈ s, l j) y) := by rw [hm]
      _ = c * d * χ (l i + ∑ j ∈ s, l j) y := by ring

omit [IsProbabilityMeasure η] in
omit [IsProbabilityMeasure η] in

theorem integral_finset_prod_eq_zero {ι : Type*} (s : Finset ι) (l : ι → L)
    (hl : ∑ i ∈ s, l i ≠ 0) :
    ∫ y, ∏ i ∈ s, χ (l i) y ∂η = 0 := by
  obtain ⟨c, _, hp⟩ := hχ.finset_prod s l
  rw [integral_congr_ae hp, integral_const_mul, hχ.mean _ hl, mul_zero]

omit [IsProbabilityMeasure η] in
omit [IsProbabilityMeasure η] in

theorem orthogonal (l m : L) (hlm : l ≠ m) :
    ∫ y, χ l y * conj (χ m y) ∂η = 0 := by
  obtain ⟨c, _, hc⟩ := hχ.conjugate m
  obtain ⟨d, _, hd⟩ := hχ.mul l (-m)
  have heq : (fun y => χ l y * conj (χ m y)) =ᵐ[η]
      (fun y => (c * d) * χ (l - m) y) := by
    filter_upwards [hc, hd] with y hy hz
    rw [hy]
    calc
      χ l y * (c * χ (-m) y) = c * (χ l y * χ (-m) y) := by ring
      _ = c * (d * χ (l + -m) y) := by rw [hz]
      _ = (c * d) * χ (l - m) y := by simp only [sub_eq_add_neg]; ring
  rw [integral_congr_ae heq, integral_const_mul, hχ.mean _ (sub_ne_zero.mpr hlm), mul_zero]

theorem integrable_finset_prod {ι : Type*} (s : Finset ι) (l : ι → L) :
    Integrable (fun y => ∏ i ∈ s, χ (l i) y) η := by
  obtain ⟨c, _, hp⟩ := hχ.finset_prod s l
  exact ((hχ.integrable _).const_mul c).congr hp.symm

theorem weighted_finset_prod {ι : Type*} (s : Finset ι) (l : ι → L) (a : ι → ℂ) :
    Integrable (fun y => ∏ i ∈ s, a i * χ (l i) y) η ∧
    (∫ y, ∏ i ∈ s, a i * χ (l i) y ∂η) =
      (∏ i ∈ s, a i) * ∫ y, ∏ i ∈ s, χ (l i) y ∂η := by
  simp_rw [Finset.prod_mul_distrib]
  exact ⟨(hχ.integrable_finset_prod s l).const_mul _, integral_const_mul _ _⟩

end ProjectiveCharacters

def Dissociated {L : Type*} [AddCommGroup L] (l : ℕ → L) : Prop :=
  ∀ s : Finset ℕ, s.Nonempty → ∀ ε : ℕ → Bool,
    (∑ i ∈ s, if ε i then l i else -l i) ≠ 0

namespace ProjectiveCharacters
variable {Y L : Type*} [MeasurableSpace Y] [AddCommGroup L]
  {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}
  (hχ : ProjectiveCharacters η χ)
include hχ

theorem integral_signed_linear_prod_eq_zero (l : ℕ → L) (hd : Dissociated l)
    (s : Finset ℕ) (hs : s.Nonempty) (a b : ℕ → ℂ) :
    Integrable (fun y => ∏ i ∈ s, (a i * χ (l i) y + b i * χ (-l i) y)) η ∧
    (∫ y, ∏ i ∈ s, (a i * χ (l i) y + b i * χ (-l i) y) ∂η) = 0 := by
  classical
  let term (t : Finset ℕ) (y : Y) :=
    (∏ i ∈ t, a i * χ (l i) y) * ∏ i ∈ s \ t, b i * χ (-l i) y
  have ht (t : Finset ℕ) (hts : t ⊆ s) : term t = fun y => ∏ i ∈ s,
      (if i ∈ t then a i else b i) * χ (if i ∈ t then l i else -l i) y := by
    funext y
    let f (i : ℕ) := (if i ∈ t then a i else b i) *
      χ (if i ∈ t then l i else -l i) y
    change _ = ∏ i ∈ s, f i
    rw [← Finset.prod_sdiff hts, mul_comm]
    apply congrArg₂ (· * ·)
    · exact Finset.prod_congr rfl (fun i hi => by simp [f, hi])
    · exact Finset.prod_congr rfl (fun i hi => by simp [f, (Finset.mem_sdiff.mp hi).2])
  have hterm (t : Finset ℕ) (hts : t ∈ s.powerset) :
      Integrable (term t) η ∧ (∫ y, term t y ∂η) = 0 := by
    rw [ht t (Finset.mem_powerset.mp hts)]
    have hh := hχ.weighted_finset_prod s
      (fun i => if i ∈ t then l i else -l i) (fun i => if i ∈ t then a i else b i)
    refine ⟨hh.1, hh.2.trans ?_⟩
    rw [hχ.integral_finset_prod_eq_zero s _ (by
      simpa using hd s hs (fun i => decide (i ∈ t))), mul_zero]
  have heq : (fun y => ∏ i ∈ s, (a i * χ (l i) y + b i * χ (-l i) y)) =
      fun y => ∑ t ∈ s.powerset, term t y := by
    funext y
    exact Finset.prod_add _ _ s
  rw [heq]
  exact ⟨integrable_finsetSum _ (fun t ht => (hterm t ht).1), by
    rw [integral_finsetSum _ (fun t ht => (hterm t ht).1)]
    exact Finset.sum_eq_zero (fun t ht => (hterm t ht).2)⟩

theorem integral_real_prod_eq_zero (l : ℕ → L) (hd : Dissociated l)
    (s : Finset ℕ) (hs : s.Nonempty) (w : ℕ → ℂ) :
    Integrable (fun y => ∏ i ∈ s, (w i * conj (χ (l i) y)).re) η ∧
    (∫ y, ∏ i ∈ s, (w i * conj (χ (l i) y)).re ∂η) = 0 := by
  choose c hc heq using fun i => hχ.conjugate (l i)
  have hlin := hχ.integral_signed_linear_prod_eq_zero l hd s hs
    (fun i => conj (w i) / 2) (fun i => w i * c i / 2)
  have heq' : (fun y => ((∏ i ∈ s, (w i * conj (χ (l i) y)).re : ℝ) : ℂ)) =ᵐ[η]
      (fun y => ∏ i ∈ s, (conj (w i) / 2 * χ (l i) y +
        (w i * c i / 2) * χ (-l i) y)) := by
    filter_upwards [ae_all_iff.mpr heq] with y hy
    push_cast
    apply Finset.prod_congr rfl
    intro i _
    rw [Complex.re_eq_add_conj, map_mul, starRingEnd_self_apply, hy i]
    ring
  have hint : Integrable (fun y => ((∏ i ∈ s, (w i * conj (χ (l i) y)).re : ℝ) : ℂ)) η :=
    hlin.1.congr heq'.symm
  have hintR := hint.re
  change Integrable (fun y => (((∏ i ∈ s, (w i * conj (χ (l i) y)).re : ℝ) : ℂ)).re) η at hintR
  refine ⟨by simpa only [Complex.ofReal_re] using hintR, ?_⟩
  apply Complex.ofReal_injective
  rw [← integral_complex_ofReal, integral_congr_ae heq', hlin.2]
  rfl

theorem integral_affine_real_prod (l : ℕ → L) (hd : Dissociated l)
    (s : Finset ℕ) (w : ℕ → ℂ) (b : ℕ → ℝ) :
    Integrable (fun y => ∏ i ∈ s, (b i + (w i * conj (χ (l i) y)).re)) η ∧
    (∫ y, ∏ i ∈ s, (b i + (w i * conj (χ (l i) y)).re) ∂η) = ∏ i ∈ s, b i := by
  classical
  have ht (t : Finset ℕ) :
      Integrable (fun y => (∏ i ∈ t, (w i * conj (χ (l i) y)).re) *
        ∏ i ∈ s \ t, b i) η ∧
      (∫ y, (∏ i ∈ t, (w i * conj (χ (l i) y)).re) *
        ∏ i ∈ s \ t, b i ∂η) = if t = ∅ then ∏ i ∈ s, b i else 0 := by
    by_cases he : t = ∅
    · subst t
      simp
    · obtain ⟨hit, hzt⟩ := hχ.integral_real_prod_eq_zero l hd t
        (Finset.nonempty_iff_ne_empty.mpr he) w
      exact ⟨hit.mul_const _, by rw [integral_mul_const, hzt]; simp [he]⟩
  have hex (y : Y) :
      (∏ i ∈ s, (b i + (w i * conj (χ (l i) y)).re)) =
      ∑ t ∈ s.powerset, (∏ i ∈ t, (w i * conj (χ (l i) y)).re) *
        ∏ i ∈ s \ t, b i := by
    simp_rw [add_comm (b _)]
    exact Finset.prod_add _ _ _
  simp_rw [hex]
  refine ⟨integrable_finsetSum _ (fun t _ => (ht t).1), ?_⟩
  rw [integral_finsetSum _ (fun t _ => (ht t).1)]
  simp_rw [(ht _).2]
  simp

theorem dissociated_exponential_bound (l : ℕ → L) (hd : Dissociated l)
    (s : Finset ℕ) (w : ℕ → ℂ) (hw : ∀ i ∈ s, ‖w i‖ ≤ 1)
    {θ : ℝ} (hθ : 0 ≤ θ) (hθ1 : θ ≤ 1) :
    Integrable (fun y => Real.exp (θ * ∑ i ∈ s, (w i * conj (χ (l i) y)).re)) η ∧
    (∫ y, Real.exp (θ * ∑ i ∈ s, (w i * conj (χ (l i) y)).re) ∂η) ≤
      Real.exp (2 * θ ^ 2 * s.card) := by
  have hg := hχ.integral_affine_real_prod l hd s (fun i => (θ : ℂ) * w i)
    (fun _ => 1 + 2 * θ ^ 2)
  have hscale (i : ℕ) (y : Y) :
      ((θ : ℂ) * w i * conj (χ (l i) y)).re =
        θ * (w i * conj (χ (l i) y)).re := by
    simp only [mul_assoc, Complex.mul_re, Complex.ofReal_re, Complex.ofReal_im, zero_mul, sub_zero]
  simp_rw [hscale] at hg
  have hpoint : ∀ᵐ y ∂η, ∀ i ∈ s,
      Real.exp (θ * (w i * conj (χ (l i) y)).re) ≤
        1 + 2 * θ ^ 2 + θ * (w i * conj (χ (l i) y)).re := by
    filter_upwards [ae_all_iff.mpr (fun i => hχ.modulus (l i))] with y hy i hi
    have hr : |(w i * conj (χ (l i) y)).re| ≤ 1 := by
      calc
        _ ≤ ‖w i * conj (χ (l i) y)‖ := Complex.abs_re_le_norm _
        _ = ‖w i‖ := by rw [norm_mul, Complex.norm_conj, hy i, mul_one]
        _ ≤ 1 := hw i hi
    have ht : |θ * (w i * conj (χ (l i) y)).re| ≤ θ := by
      rw [abs_mul, abs_of_nonneg hθ]
      simpa using mul_le_mul_of_nonneg_left hr hθ
    have hq := Real.abs_exp_sub_one_sub_id_le (ht.trans hθ1)
    have hqq : (θ * (w i * conj (χ (l i) y)).re) ^ 2 ≤ θ ^ 2 := by
      rw [← sq_abs]
      exact (sq_le_sq₀ (abs_nonneg _) hθ).mpr ht
    have hupper := (le_abs_self _).trans hq
    nlinarith [sq_nonneg θ]
  have hprod : (fun y => Real.exp (θ * ∑ i ∈ s, (w i * conj (χ (l i) y)).re)) ≤ᵐ[η]
      (fun y => ∏ i ∈ s, (1 + 2 * θ ^ 2 + θ * (w i * conj (χ (l i) y)).re)) := by
    filter_upwards [hpoint] with y hy
    rw [Finset.mul_sum, Real.exp_sum]
    exact Finset.prod_le_prod₀ (fun _ _ => (Real.exp_pos _).le) hy
  have hm : AEStronglyMeasurable
      (fun y => Real.exp (θ * ∑ i ∈ s, (w i * conj (χ (l i) y)).re)) η := by
    apply Real.continuous_exp.comp_aestronglyMeasurable
    apply AEStronglyMeasurable.const_mul
    have hi (i : ℕ) : AEStronglyMeasurable
        (fun y => (w i * conj (χ (l i) y)).re) η :=
      Complex.continuous_re.comp_aestronglyMeasurable
        ((hχ.measurable (l i)).star.const_mul (w i))
    convert Finset.aestronglyMeasurable_sum s (fun i _ => hi i) using 1
    funext y
    simp only [Finset.sum_apply]
  have hint := hg.1.mono' hm (hprod.mono (fun y hy => by
    simpa only [Real.norm_of_nonneg (Real.exp_pos _).le] using hy))
  refine ⟨hint, (integral_mono_ae hint hg.1 hprod).trans ?_⟩
  rw [hg.2, Finset.prod_const]
  calc
    (1 + 2 * θ ^ 2) ^ s.card ≤ (Real.exp (2 * θ ^ 2)) ^ s.card := by
      apply pow_le_pow_left₀ (by positivity)
      simpa only [add_comm] using Real.add_one_le_exp (2 * θ ^ 2)
    _ = Real.exp (2 * θ ^ 2 * s.card) := by rw [← Real.exp_nat_mul, mul_comm]

end ProjectiveCharacters
end

open MeasureTheory Filter
open scoped BigOperators Topology

section

noncomputable def shannonEntropy {A : Type*} [Fintype A] (p : A → ℝ) : ℝ :=
  ∑ a, -p a * Real.log (p a)

section FiniteDistribution
variable {A : Type*} [Fintype A] (p : A → ℝ)
    (hp : ∀ a, 0 ≤ p a) (hsum : ∑ a, p a = 1)
include hp hsum

theorem probability_le_one (a : A) : p a ≤ 1 := by
  rw [← hsum]
  exact Finset.single_le_sum (fun a _ => hp a) (Finset.mem_univ a)

theorem entropy_term_nonneg (a : A) : 0 ≤ -p a * Real.log (p a) := by
  rw [neg_mul, neg_nonneg]
  exact mul_nonpos_of_nonneg_of_nonpos (hp a)
    (Real.log_nonpos (hp a) (probability_le_one p hp hsum a))

theorem shannonEntropy_nonneg : 0 ≤ shannonEntropy p :=
  Finset.sum_nonneg (fun a _ => entropy_term_nonneg p hp hsum a)

theorem unlikely_mass_bound {a : ℝ} (ha : 0 < a) :
    ∑ i ∈ Finset.univ.filter (fun i => p i < Real.exp (-a)), p i ≤
      shannonEntropy p / a := by
  classical
  rw [le_div_iff₀ ha, Finset.sum_mul]
  calc
    ∑ i ∈ Finset.univ.filter (fun i => p i < Real.exp (-a)), p i * a ≤
        ∑ i ∈ Finset.univ.filter (fun i => p i < Real.exp (-a)), -p i * Real.log (p i) := by
      apply Finset.sum_le_sum
      intro i hi
      by_cases hz : p i = 0
      · simp [hz]
      · have hpi : 0 < p i := (hp i).lt_of_ne' hz
        have hlog := (Real.log_lt_iff_lt_exp hpi).mpr (Finset.mem_filter.mp hi).2
        nlinarith [mul_nonneg (hp i) (le_of_lt (show 0 < -a - Real.log (p i) by linarith))]
    _ ≤ shannonEntropy p := by
      apply Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _)
      intro i _ _
      exact entropy_term_nonneg p hp hsum i

theorem likely_card_bound (a : ℝ) :
    ((Finset.univ.filter (fun i => Real.exp (-a) ≤ p i)).card : ℝ) ≤ Real.exp a := by
  classical
  have h : ((Finset.univ.filter (fun i => Real.exp (-a) ≤ p i)).card : ℝ) *
      Real.exp (-a) ≤ 1 := by
    calc
      _ = ∑ i ∈ Finset.univ.filter (fun i => Real.exp (-a) ≤ p i), Real.exp (-a) := by simp
      _ ≤ ∑ i ∈ Finset.univ.filter (fun i => Real.exp (-a) ≤ p i), p i :=
        Finset.sum_le_sum (fun i hi => (Finset.mem_filter.mp hi).2)
      _ ≤ ∑ i, p i :=
        Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _) (fun i _ _ => hp i)
      _ = 1 := hsum
  have hm := mul_le_mul_of_nonneg_right h (Real.exp_pos a).le
  simpa only [mul_assoc, ← Real.exp_add, neg_add_cancel, Real.exp_zero, mul_one, one_mul] using hm

end FiniteDistribution
variable {Y : Type*} [MeasurableSpace Y] {η : Measure Y} [IsProbabilityMeasure η]

theorem exponential_tail_bound (S : Y → ℝ) {θ b t : ℝ} (hθ : 0 < θ)
    (hint : Integrable (fun y => Real.exp (θ * S y)) η)
    (hbound : (∫ y, Real.exp (θ * S y) ∂η) ≤ Real.exp b) :
    η.real {y | t < S y} ≤ Real.exp (b - θ * t) := by
  have hm := mul_meas_ge_le_integral_of_nonneg
    (Eventually.of_forall (fun y => (Real.exp_pos (θ * S y)).le)) hint (Real.exp (θ * t))
  have hsub : {y | t < S y} ⊆ {y | Real.exp (θ * t) ≤ Real.exp (θ * S y)} := by
    intro y hy
    exact Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hy.le hθ.le)
  have hm' := (mul_le_mul_of_nonneg_left (measureReal_mono hsub) (Real.exp_pos _).le).trans
    (hm.trans hbound)
  rw [Real.exp_sub]
  exact (le_div_iff₀ (Real.exp_pos _)).mpr (by simpa only [mul_comm] using hm')

theorem randomized_tail_bound {A : Type*} [Fintype A] (F : Y → A)
    (hF : ∀ a, MeasurableSet (F ⁻¹' {a})) (S : A → Y → ℝ)
    {a ε δ : ℝ} (ha : 0 < a) (hδ : 0 ≤ δ)
    (ht : ∀ w, η.real {y | ε < S w y} ≤ δ) :
    η.real {y | ε < S (F y) y} ≤
      shannonEntropy (fun w => η.real (F ⁻¹' {w})) / a + Real.exp a * δ := by
  classical
  let p (w : A) := η.real (F ⁻¹' {w})
  have hp : ∀ w, 0 ≤ p w := fun _ => measureReal_nonneg
  have hsum : ∑ w, p w = 1 := by
    have hh := sum_measureReal_preimage_singleton (μ := η) Finset.univ (fun w _ => hF w)
    simpa [p] using hh
  let good := Finset.univ.filter (fun w => Real.exp (-a) ≤ p w)
  let bad := Finset.univ.filter (fun w => p w < Real.exp (-a))
  have hsub : {y | ε < S (F y) y} ⊆
      (F ⁻¹' (bad : Set A)) ∪ ⋃ w ∈ good, {y | ε < S w y} := by
    intro y hy
    by_cases hg : Real.exp (-a) ≤ p (F y)
    · right
      exact Set.mem_iUnion.mpr ⟨F y, Set.mem_iUnion.mpr ⟨by simp [good, hg], hy⟩⟩
    · left
      simpa [bad] using lt_of_not_ge hg
  have hbad : η.real (F ⁻¹' (bad : Set A)) ≤ shannonEntropy p / a := by
    rw [← sum_measureReal_preimage_singleton bad (fun w _ => hF w)]
    exact unlikely_mass_bound p hp hsum ha
  calc
    η.real {y | ε < S (F y) y} ≤
        η.real (F ⁻¹' (bad : Set A)) + η.real (⋃ w ∈ good, {y | ε < S w y}) :=
      (measureReal_mono hsub).trans (measureReal_union_le _ _)
    _ ≤ shannonEntropy p / a + ∑ w ∈ good, η.real {y | ε < S w y} :=
      add_le_add hbad (measureReal_biUnion_finset_le _ _)
    _ ≤ shannonEntropy p / a + Real.exp a * δ := by
      apply add_le_add_right
      calc
        _ ≤ ∑ _ ∈ good, δ := Finset.sum_le_sum (fun w _ => ht w)
        _ = (good.card : ℝ) * δ := by simp
        _ ≤ Real.exp a * δ := mul_le_mul_of_nonneg_right (likely_card_bound p hp hsum a) hδ

end

section
open MeasureTheory Filter
open scoped BigOperators Topology

theorem integral_le_threshold_add_tail {Y : Type*} [MeasurableSpace Y]
    {η : Measure Y} [IsProbabilityMeasure η] {S : Y → ℝ}
    (hint : Integrable S η) (hS : ∀ᵐ y ∂η, S y ≤ 1) {ε : ℝ} (hε : 0 ≤ ε) :
    (∫ y, S y ∂η) ≤ ε + η.real {y | ε < S y} := by
  let s := {y | ε < S y}
  have hs : NullMeasurableSet s η :=
    aestronglyMeasurable_const.nullMeasurableSet_lt hint.aestronglyMeasurable
  have he : ∫ y in s, S y ∂η ≤ η.real s := by
    have hh := integral_mono_ae hint.restrict (integrable_const (1 : ℝ))
      (ae_restrict_of_ae hS : ∀ᵐ y ∂η.restrict s, S y ≤ 1)
    simpa using hh
  have hc : ∫ y in sᶜ, S y ∂η ≤ ε := by
    have hh : ∫ y in sᶜ, S y ∂η ≤ η.real sᶜ * ε := by
      have hh := integral_mono_ae hint.restrict (integrable_const ε)
        ((ae_restrict_mem₀ hs.compl).mono (fun y hy => le_of_not_gt hy))
      simpa using hh
    exact hh.trans (by simpa using mul_le_mul_of_nonneg_right (measureReal_le_one (s := sᶜ)) hε)
  rw [← integral_add_compl₀ hs hint]
  linarith

end

section
open MeasureTheory Filter
open scoped BigOperators Topology ComplexConjugate

variable {Y L : Type*} [MeasurableSpace Y] [AddCommGroup L]
    {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}

theorem dissociated_tail_bound (hχ : ProjectiveCharacters η χ)
    (l : ℕ → L) (hd : Dissociated l) (n : ℕ) (hn : 0 < n)
    (w : ℕ → ℂ) (hw : ∀ i < n, ‖w i‖ ≤ 1)
    {ε : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) :
    η.real {y | ε < (∑ i ∈ Finset.range n, (w i * conj (χ (l i) y)).re) / n} ≤
      Real.exp (-ε ^ 2 * n / 8) := by
  have hn' : (0 : ℝ) < n := by exact_mod_cast hn
  have hh := hχ.dissociated_exponential_bound l hd (Finset.range n) w
    (fun i hi => hw i (Finset.mem_range.mp hi)) (θ := ε / 4) (by positivity) (by linarith)
  have ht := exponential_tail_bound
    (fun y => ∑ i ∈ Finset.range n, (w i * conj (χ (l i) y)).re)
    (θ := ε / 4) (b := 2 * (ε / 4) ^ 2 * n) (t := ε * n) (by positivity)
    hh.1 (by simpa using hh.2)
  have he : (-ε ^ 2 * (n : ℝ) / 8) = 2 * (ε / 4) ^ 2 * n - ε / 4 * (ε * n) := by ring
  rw [he]
  convert ht using 1
  congr 1
  ext y
  exact lt_div_iff₀ hn'

def entropyWord {A : Type*} (F : ℕ → Y → A) (n : ℕ) : Y → (Fin n → A) :=
  fun y i => F i.val y

noncomputable def wordEntropy {A : Type*} [Fintype A] (F : ℕ → Y → A) (n : ℕ) : ℝ :=
  shannonEntropy (fun w => η.real (entropyWord F n ⁻¹' {w}))

end

section
open MeasureTheory Filter
open scoped BigOperators Topology ComplexConjugate
variable {Y L A : Type*} [MeasurableSpace Y] [AddCommGroup L]
    {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]

theorem randomized_dissociated_tail (hχ : ProjectiveCharacters η χ)
    (l : ℕ → L) (hd : Dissociated l)
    (F : ℕ → Y → A) (hF : ∀ i, Measurable (F i))
    (v : A → ℂ) (hv : ∀ a, ‖v a‖ ≤ 1)
    (ω : ℕ → ℂ) (hω : ∀ i, ‖ω i‖ ≤ 1)
    (n : ℕ) (hn : 0 < n) {a ε : ℝ} (ha : 0 < a) (hε : 0 < ε) (hε1 : ε ≤ 1) :
    η.real {y | ε < (∑ i ∈ Finset.range n,
      (ω i * v (F i y) * conj (χ (l i) y)).re) / n} ≤
      wordEntropy (η := η) F n / a + Real.exp (a - ε ^ 2 * n / 8) := by
  classical
  let w (t : Fin n → A) (i : ℕ) := if h : i < n then ω i * v (t ⟨i, h⟩) else 0
  let S (t : Fin n → A) (y : Y) :=
    (∑ i ∈ Finset.range n, (w t i * conj (χ (l i) y)).re) / n
  have ht (t : Fin n → A) : η.real {y | ε < S t y} ≤ Real.exp (-ε ^ 2 * n / 8) := by
    apply dissociated_tail_bound hχ l hd n hn (w t) _ hε hε1
    intro i hi
    simp only [w, dite_eq_left hi, norm_mul]
    exact (mul_le_mul (hω i) (hv _) (norm_nonneg _) (by norm_num)).trans_eq (one_mul 1)
  have hf : Measurable (entropyWord F n) := Measurable.of_eval (fun i => hF i.val)
  have hh := randomized_tail_bound (entropyWord F n)
    (fun t => hf (measurableSet_singleton t)) S ha (Real.exp_pos _).le ht
  have he (y : Y) : S (entropyWord F n y) y =
      (∑ i ∈ Finset.range n, (ω i * v (F i y) * conj (χ (l i) y)).re) / n := by
    dsimp only [S]
    apply congrArg (fun r : ℝ => r / (n : ℝ))
    apply Finset.sum_congr rfl
    intro i hi
    simp only [w, dite_eq_left (Finset.mem_range.mp hi), entropyWord]
  simp_rw [he] at hh
  simpa only [wordEntropy, ← Real.exp_add, sub_eq_add_neg, neg_mul, neg_div] using hh

end

section
open MeasureTheory Filter
open scoped BigOperators Topology ComplexConjugate

theorem exists_aligning_phase (z : ℂ) : ∃ ω : ℂ, ‖ω‖ = 1 ∧ (ω * z).re = ‖z‖ := by
  by_cases hz : z = 0
  · exact ⟨1, by simp, by simp [hz]⟩
  · refine ⟨conj z / (‖z‖ : ℂ), ?_, ?_⟩
    · simp [hz]
    · have hn : ‖z‖ ≠ 0 := norm_ne_zero_iff.mpr hz
      rw [div_mul_eq_mul_div, ← Complex.normSq_eq_conj_mul_self, Complex.div_ofReal_re,
        Complex.ofReal_re, Complex.normSq_eq_norm_sq]
      field_simp

variable {Y L A : Type*} [MeasurableSpace Y] [AddCommGroup L]
    {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]

theorem dissociated_correlation_mean_bound (hχ : ProjectiveCharacters η χ)
    (l : ℕ → L) (hd : Dissociated l)
    (F : ℕ → Y → A) (hF : ∀ i, Measurable (F i))
    (v : A → ℂ) (hv : ∀ a, ‖v a‖ ≤ 1)
    (n : ℕ) (hn : 0 < n) {a ε : ℝ} (ha : 0 < a) (hε : 0 < ε) (hε1 : ε ≤ 1) :
    (∑ i ∈ Finset.range n, ‖∫ y, v (F i y) * conj (χ (l i) y) ∂η‖) / n ≤
      ε + wordEntropy (η := η) F n / a + Real.exp (a - ε ^ 2 * n / 8) := by
  choose ω hω hw using fun i =>
    exists_aligning_phase (∫ y, v (F i y) * conj (χ (l i) y) ∂η)
  let q (i : ℕ) (y : Y) := ω i * v (F i y) * conj (χ (l i) y)
  have hqm (i : ℕ) : AEStronglyMeasurable (q i) η :=
    ((((measurable_of_finite v).comp (hF i)).aestronglyMeasurable.const_mul (ω i)).mul
      (hχ.measurable (l i)).star)
  have hqb (i : ℕ) : ∀ᵐ y ∂η, ‖q i y‖ ≤ 1 := by
    filter_upwards [hχ.modulus (l i)] with y hy
    simpa only [q, norm_mul, Complex.norm_conj, hy, hω i, one_mul, mul_one] using hv (F i y)
  have hqi (i : ℕ) : Integrable (q i) η :=
    (integrable_const (1 : ℝ)).mono' (hqm i) (hqb i)
  have hqR (i : ℕ) : Integrable (fun y => (q i y).re) η := (hqi i).re
  let S (y : Y) := (∑ i ∈ Finset.range n, (q i y).re) / n
  have hSi : Integrable S η :=
    (integrable_finsetSum _ (fun i _ => hqR i)).div_const _
  have hn' : (0 : ℝ) < n := by exact_mod_cast hn
  have hSb : ∀ᵐ y ∂η, S y ≤ 1 := by
    filter_upwards [ae_all_iff.mpr hqb] with y hy
    apply (div_le_iff₀ hn').mpr
    calc
      _ ≤ ∑ _ ∈ Finset.range n, (1 : ℝ) := Finset.sum_le_sum
        (fun i _ => (Complex.re_le_norm _).trans (hy i))
      _ = 1 * n := by simp
  have hmean : (∫ y, S y ∂η) =
      (∑ i ∈ Finset.range n, ‖∫ y, v (F i y) * conj (χ (l i) y) ∂η‖) / n := by
    rw [integral_div, integral_finsetSum _ (fun i _ => hqR i)]
    congr 1
    apply Finset.sum_congr rfl
    intro i _
    change (∫ y, Complex.reCLM (q i y) ∂η) = _
    rw [Complex.reCLM.integral_comp_comm (hqi i)]
    change (∫ y, ω i * v (F i y) * conj (χ (l i) y) ∂η).re = _
    simp_rw [mul_assoc]
    rw [integral_const_mul]
    exact hw i
  rw [← hmean]
  have htail := randomized_dissociated_tail hχ l hd F hF v hv ω (fun i => (hω i).le)
    n hn ha hε hε1
  have hh := integral_le_threshold_add_tail hSi hSb hε.le
  exact hh.trans (by simpa only [add_assoc] using add_le_add_right htail ε)

end

section
open MeasureTheory Filter
open scoped BigOperators Topology ComplexConjugate
variable {Y L A : Type*} [MeasurableSpace Y] [AddCommGroup L]
    {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]

theorem entropy_cancellation (hχ : ProjectiveCharacters η χ)
    (l : ℕ → L) (hd : Dissociated l)
    (F : ℕ → Y → A) (hF : ∀ i, Measurable (F i))
    (v : A → ℂ) (hv : ∀ a, ‖v a‖ ≤ 1)
    (hH : Tendsto (fun n : ℕ => wordEntropy (η := η) F n / n) atTop (𝓝 0)) :
    Tendsto (fun n : ℕ =>
      (∑ i ∈ Finset.range n, ‖∫ y, v (F i y) * conj (χ (l i) y) ∂η‖) / n)
      atTop (𝓝 0) := by
  apply tendsto_order.mpr
  constructor
  · intro b hb
    exact Eventually.of_forall (fun n => hb.trans_le (by positivity))
  · intro b hb
    let ε : ℝ := min (b / 2) 1
    have hε : 0 < ε := lt_min (by positivity) zero_lt_one
    have hε1 : ε ≤ 1 := min_le_right _ _
    have hεb : ε ≤ b / 2 := min_le_left _ _
    let c : ℝ := ε ^ 2 / 16
    have hc : 0 < c := by positivity
    have hE : Tendsto (fun n : ℕ => Real.exp (-(c * n))) atTop (𝓝 0) :=
      Real.tendsto_exp_atBot.comp
        (tendsto_neg_atTop_atBot.comp ((tendsto_const_mul_atTop_of_pos hc).mpr
          tendsto_natCast_atTop_atTop))
    have hH' : Tendsto (fun n : ℕ => wordEntropy (η := η) F n / (c * n)) atTop (𝓝 0) := by
      simpa only [div_div, mul_comm, zero_div] using hH.div_const c
    have ht := hH'.add hE
    simp only [add_zero] at ht
    filter_upwards [ht.eventually (gt_mem_nhds (show 0 < b / 2 by positivity)),
      eventually_gt_atTop 0] with n hn hn0
    have hn' : (0 : ℝ) < n := by exact_mod_cast hn0
    have hh := dissociated_correlation_mean_bound hχ l hd F hF v hv n hn0
      (a := c * n) (mul_pos hc hn') hε hε1
    have he : c * (n : ℝ) - ε ^ 2 * n / 8 = -(c * n) := by dsimp [c]; ring
    rw [he] at hh
    linarith

end

section FactorEntropy
variable {A B : Type*} [Fintype A] [Fintype B]

theorem shannonEntropy_map_le [DecidableEq B] (p : A → ℝ) (hp : ∀ a, 0 ≤ p a) (f : A → B) :
    shannonEntropy (fun b => ∑ a, if f a = b then p a else 0) ≤ shannonEntropy p := by
  classical
  let q (b : B) := ∑ a, if f a = b then p a else 0
  have hpq (a : A) : p a ≤ q (f a) := by
    exact (by simpa [q] using
      (Finset.single_le_sum (s := Finset.univ)
        (f := fun x => if f x = f a then p x else 0)
        (fun x _ => by split_ifs; exact hp x; exact le_rfl) (Finset.mem_univ a)))
  have he (b : B) : -q b * Real.log (q b) =
      ∑ a, if f a = b then -p a * Real.log (q b) else 0 := by
    change -(∑ a, if f a = b then p a else 0) * Real.log (q b) = _
    rw [neg_mul, Finset.sum_mul, ← Finset.sum_neg_distrib]
    apply Finset.sum_congr rfl
    intro a _
    split_ifs <;> simp
  change (∑ b, -q b * Real.log (q b)) ≤ ∑ a, -p a * Real.log (p a)
  simp_rw [he]
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum
  intro a _
  simp only [Finset.sum_ite_eq, Finset.mem_univ, ite_true]
  by_cases ha : p a = 0
  · simp [ha]
  · exact mul_le_mul_of_nonpos_left
      (Real.log_le_log ((hp a).lt_of_ne' ha) (hpq a)) (neg_nonpos.mpr (hp a))

end FactorEntropy
section
variable {Y A B : Type*} [MeasurableSpace Y] {η : Measure Y} [IsProbabilityMeasure η]
    [Fintype A] [Fintype B] [MeasurableSpace A] [MeasurableSingletonClass A]

theorem randomEntropy_comp_le (F : Y → A) (hF : Measurable F) (g : A → B) :
    shannonEntropy (fun b => η.real ((g ∘ F) ⁻¹' {b})) ≤
      shannonEntropy (fun a => η.real (F ⁻¹' {a})) := by
  classical
  have he (b : B) : η.real ((g ∘ F) ⁻¹' {b}) =
      ∑ a, if g a = b then η.real (F ⁻¹' {a}) else 0 := by
    rw [← Finset.sum_filter]
    have hh := sum_measureReal_preimage_singleton (μ := η)
      (Finset.univ.filter (fun a => g a = b)) (fun a _ => hF (measurableSet_singleton a))
    rw [hh]
    congr 1
    ext y
    simp
  simp_rw [he]
  exact shannonEntropy_map_le _ (fun _ => measureReal_nonneg) g

theorem wordEntropy_nonneg (F : ℕ → Y → A) (hF : ∀ n, Measurable (F n)) (n : ℕ) :
    0 ≤ wordEntropy (η := η) F n := by
  apply shannonEntropy_nonneg _ (fun _ => measureReal_nonneg)
  have hm : Measurable (entropyWord F n) := Measurable.of_eval (fun _ => hF _)
  have hh := sum_measureReal_preimage_singleton (μ := η) Finset.univ
    (fun w _ => hm (measurableSet_singleton w))
  simpa using hh

theorem wordEntropy_progression_le (F : ℕ → Y → A) (hF : ∀ n, Measurable (F n))
    (p : ℕ) (hp : 0 < p) (j n : ℕ) :
    wordEntropy (η := η) (fun m => F (p * m + j)) n ≤
      wordEntropy (η := η) F (p * n + j) := by
  let select (w : Fin (p * n + j) → A) (i : Fin n) :=
    w ⟨p * i.val + j, Nat.add_lt_add_right (Nat.mul_lt_mul_of_pos_left i.isLt hp) j⟩
  have hm : Measurable (entropyWord F (p * n + j)) :=
    Measurable.of_eval (fun _ => hF _)
  exact randomEntropy_comp_le (entropyWord F (p * n + j)) hm select

theorem zero_entropy_progression (F : ℕ → Y → A) (hF : ∀ n, Measurable (F n))
    (hH : Tendsto (fun n : ℕ => wordEntropy (η := η) F n / n) atTop (𝓝 0))
    (p : ℕ) (hp : 0 < p) (j : ℕ) :
    Tendsto (fun n : ℕ => wordEntropy (η := η) (fun m => F (p * m + j)) n / n)
      atTop (𝓝 0) := by
  have hM : Tendsto (fun n : ℕ => p * n + j) atTop atTop := by
    apply tendsto_atTop_mono (fun n => ?_) tendsto_id
    change n ≤ p * n + j
    have hh := Nat.mul_le_mul_right n hp
    omega
  have ht := (hH.comp hM).mul_const ((p + j : ℕ) : ℝ)
  simp only [zero_mul] at ht
  apply squeeze_zero' ?_ ?_ ht
  · exact Eventually.of_forall (fun n => div_nonneg
      (wordEntropy_nonneg _ (fun m => hF (p * m + j)) n) (Nat.cast_nonneg n))
  · filter_upwards [eventually_gt_atTop 0] with n hn
    have hn' : (0 : ℝ) < n := by exact_mod_cast hn
    have hM' : (0 : ℝ) < p * n + j := by positivity
    have hMn : (p * n + j : ℝ) ≤ (p + j) * n := by
      have h1 : (1 : ℝ) ≤ n := by exact_mod_cast hn
      nlinarith [mul_le_mul_of_nonneg_left h1 (show (0 : ℝ) ≤ j by positivity)]
    have hpos := wordEntropy_nonneg (η := η) F hF (p * n + j)
    calc
      _ ≤ wordEntropy (η := η) F (p * n + j) / n :=
        div_le_div_of_nonneg_right (wordEntropy_progression_le F hF p hp j n) hn'.le
      _ ≤ wordEntropy (η := η) F (p * n + j) / (p * n + j) * (p + j) := by
        apply (div_le_iff₀ hn').mpr
        rw [div_mul_eq_mul_div, div_mul_eq_mul_div]
        apply (le_div_iff₀ hM').mpr
        nlinarith [mul_le_mul_of_nonneg_left hMn hpos]
      _ = _ := by simp only [Function.comp_apply, Nat.cast_add, Nat.cast_mul]

end

open MeasureTheory Filter
open scoped Topology InnerProductSpace ComplexConjugate


section Hilbert
variable {H ι : Type*} [NormedAddCommGroup H] [InnerProductSpace ℂ H]
    (U : ι → H →ₗᵢ[ℂ] H) (l : Filter ι) (e : H)

theorem isClosed_mixing_right (f : H) :
    IsClosed {g : H | Tendsto (fun i => inner ℂ f (U i g)) l
      (𝓝 (inner ℂ f e * inner ℂ e g))} := by
  apply Equicontinuous.isClosed_setOfPred_tendsto
  · apply UniformEquicontinuous.equicontinuous
    apply LipschitzWith.uniformEquicontinuous _ ‖f‖₊
    intro i
    apply LipschitzWith.of_dist_le_mul
    intro x y
    rw [dist_eq_norm, ← inner_sub_right]
    calc
      ‖inner ℂ f (U i x - U i y)‖ ≤ ‖f‖ * ‖U i x - U i y‖ := norm_inner_le_norm _ _
      _ = ‖f‖₊ * dist x y := by rw [← map_sub, LinearIsometry.norm_map, dist_eq_norm]; rfl
  · exact continuous_const.mul (continuous_const.inner continuous_id)

theorem isClosed_mixing_left (g : H) :
    IsClosed {f : H | Tendsto (fun i => inner ℂ f (U i g)) l
      (𝓝 (inner ℂ f e * inner ℂ e g))} := by
  apply Equicontinuous.isClosed_setOfPred_tendsto
  · apply UniformEquicontinuous.equicontinuous
    apply LipschitzWith.uniformEquicontinuous _ ‖g‖₊
    intro i
    apply LipschitzWith.of_dist_le_mul
    intro x y
    rw [dist_eq_norm, ← inner_sub_left]
    calc
      ‖inner ℂ (x - y) (U i g)‖ ≤ ‖x - y‖ * ‖U i g‖ := norm_inner_le_norm _ _
      _ = ‖g‖₊ * dist x y := by rw [LinearIsometry.norm_map, dist_eq_norm]; exact mul_comm _ _
  · exact (continuous_id.inner continuous_const).mul continuous_const
end Hilbert
section

variable {Ω ι : Type*} [MeasurableSpace Ω]
    {μ : Measure Ω} [IsProbabilityMeasure μ]
    (t : ι → Ω → Ω) (ht : ∀ i, MeasurePreserving (t i) μ μ) (l : Filter ι)

noncomputable def probabilityOne : Lp ℂ 2 μ :=
  indicatorConstLp 2 MeasurableSet.univ (measure_ne_top _ _) (1 : ℂ)

theorem mixing_L2
    (hmix : ∀ A B : Set Ω, MeasurableSet A → MeasurableSet B →
      Tendsto (fun i => μ (A ∩ t i ⁻¹' B)) l (𝓝 (μ A * μ B)))
    (f g : Lp ℂ 2 μ) :
    Tendsto (fun i => inner ℂ f ((Lp.compMeasurePreservingₗᵢ ℂ (t i) (ht i)) g)) l
      (𝓝 (inner ℂ f (probabilityOne (μ := μ)) *
        inner ℂ (probabilityOne (μ := μ)) g)) := by
  let U := fun i => Lp.compMeasurePreservingₗᵢ (E := ℂ) (p := 2) ℂ (t i) (ht i)
  let e : Lp ℂ 2 μ := probabilityOne
  change Tendsto (fun i => inner ℂ f (U i g)) l (𝓝 (inner ℂ f e * inner ℂ e g))
  have hbase (A B : Set Ω) (hA : MeasurableSet A) (hB : MeasurableSet B)
      (a b : ℂ) : Tendsto (fun i => inner ℂ
        (indicatorConstLp 2 hA (measure_ne_top _ _) a)
        (U i (indicatorConstLp 2 hB (measure_ne_top _ _) b))) l
      (𝓝 (inner ℂ (indicatorConstLp 2 hA (measure_ne_top _ _) a) e *
        inner ℂ e (indicatorConstLp 2 hB (measure_ne_top _ _) b))) := by
    have hreal := (ENNReal.tendsto_toReal (by finiteness : μ A * μ B ≠ ⊤)).comp
      (hmix A B hA hB)
    have hcomplex := Complex.continuous_ofReal.continuousAt.tendsto.comp hreal
    have hc := hcomplex.mul_const (conj a * b)
    convert hc using 1
    · funext i
      change inner ℂ (indicatorConstLp 2 hA _ a)
        (Lp.compMeasurePreserving (t i) (ht i) (indicatorConstLp 2 hB _ b)) = _
      rw [Lp.indicatorConstLp_compMeasurePreserving,
        L2.inner_indicatorConstLp_indicatorConstLp]
      simp [RCLike.inner_apply, measureReal_def, mul_comm]
    · dsimp [e, probabilityOne]
      rw [L2.inner_indicatorConstLp_indicatorConstLp,
        L2.inner_indicatorConstLp_indicatorConstLp]
      congr 1
      simp [RCLike.inner_apply, ENNReal.toReal_mul, measureReal_def, Algebra.smul_def]
      ring
  have hfirst (A : Set Ω) (hA : MeasurableSet A) (a : ℂ) :
      ∀ g : Lp ℂ 2 μ, Tendsto (fun i => inner ℂ
        (indicatorConstLp 2 hA (measure_ne_top _ _) a) (U i g)) l
        (𝓝 (inner ℂ (indicatorConstLp 2 hA (measure_ne_top _ _) a) e * inner ℂ e g)) := by
    refine Lp.induction (by norm_num : (2 : ENNReal) ≠ ⊤) _ ?_ ?_ ?_
    · intro b B hB _
      exact hbase A B hA hB a b
    · intro f g hf hg _ h₁ h₂
      simpa only [map_add, inner_add_right, mul_add] using h₁.add h₂
    · exact isClosed_mixing_right U l e _
  have hall : ∀ f : Lp ℂ 2 μ, ∀ g : Lp ℂ 2 μ,
      Tendsto (fun i => inner ℂ f (U i g)) l (𝓝 (inner ℂ f e * inner ℂ e g)) := by
    refine Lp.induction (by norm_num : (2 : ENNReal) ≠ ⊤) _ ?_ ?_ ?_
    · intro a A hA _
      exact hfirst A hA a
    · intro f g hf hg _ h₁ h₂ w
      simpa only [inner_add_left, add_mul] using (h₁ w).add (h₂ w)
    · simp only [Set.ofPred_forall]
      exact isClosed_iInter (fun g => isClosed_mixing_left U l e g)
  exact hall f g

theorem inner_probabilityOne (f : Lp ℂ 2 μ) :
    inner ℂ (probabilityOne (μ := μ)) f = ∫ y, f y ∂μ := by
  rw [L2.inner_def]
  apply integral_congr_ae
  filter_upwards [indicatorConstLp_coeFn (p := 2) (hs := MeasurableSet.univ)
    (hμs := measure_ne_top μ Set.univ) (c := (1 : ℂ))] with y hy
  change inner ℂ ((indicatorConstLp 2 MeasurableSet.univ
    (measure_ne_top μ Set.univ) (1 : ℂ)) y) (f y) = f y
  rw [hy]
  simp

include ht in

theorem mixing_integral_coupling {Y : Type*} [MeasurableSpace Y]
    {η : Measure Y} [IsProbabilityMeasure η] (x : Y → Ω)
    (hx : MeasurePreserving x η μ)
    (hmix : ∀ A B : Set Ω, MeasurableSet A → MeasurableSet B →
      Tendsto (fun i => μ (A ∩ t i ⁻¹' B)) l (𝓝 (μ A * μ B)))
    {F : Ω → ℂ} (hF : MemLp F 2 μ) (hF0 : ∫ z, F z ∂μ = 0)
    {q : Y → ℂ} (hq : MemLp q 2 η) :
    Tendsto (fun i => ∫ y, F (t i (x y)) * conj (q y) ∂η) l (𝓝 0) := by
  let V := (Lp.compMeasurePreservingₗᵢ (E := ℂ) (p := 2) ℂ x hx).toContinuousLinearMap
  have hm := mixing_L2 t ht l hmix (V.adjoint (hq.toLp q)) (hF.toLp F)
  have hmean : inner ℂ (probabilityOne (μ := μ)) (hF.toLp F) = 0 := by
    rw [inner_probabilityOne]
    exact (integral_congr_ae hF.coeFn_toLp).trans hF0
  rw [hmean, mul_zero] at hm
  convert hm using 1
  funext i
  rw [ContinuousLinearMap.adjoint_inner_left, L2.inner_def]
  apply integral_congr_ae
  have h₁ := Lp.coeFn_compMeasurePreserving
    (Lp.compMeasurePreserving (t i) (ht i) (hF.toLp F)) hx
  have h₂ := hx.quasiMeasurePreserving.ae_eq_comp
    (Lp.coeFn_compMeasurePreserving (hF.toLp F) (ht i))
  have h₃ := (ht i).quasiMeasurePreserving.ae_eq_comp hF.coeFn_toLp
  have h₄ := hx.quasiMeasurePreserving.ae_eq_comp h₃
  filter_upwards [hq.coeFn_toLp, h₁, h₂, h₄] with y hy h1 h2 h4
  change F (t i (x y)) * conj (q y) =
    inner ℂ ((hq.toLp q) y)
      ((Lp.compMeasurePreserving x hx
        (Lp.compMeasurePreserving (t i) (ht i) (hF.toLp F))) y)
  rw [hy, h1, h2, h4]
  rfl

end

open Filter
open scoped BigOperators Topology InnerProductSpace

section

noncomputable def cesaro {E : Type*} [AddCommGroup E] [Module ℝ E]
    (v : ℕ → E) (N : ℕ) : E := (N : ℝ)⁻¹ • ∑ n ∈ Finset.range N, v n

section Normed
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]

theorem norm_cesaro_le (v : ℕ → E) (N : ℕ) :
    ‖cesaro v N‖ ≤ (N : ℝ)⁻¹ * ∑ n ∈ Finset.range N, ‖v n‖ := by
  rw [cesaro, norm_smul, Real.norm_of_nonneg (by positivity : 0 ≤ (N : ℝ)⁻¹)]
  exact mul_le_mul_of_nonneg_left (norm_sum_le _ _) (by positivity)

theorem norm_cesaro_le_bound (v : ℕ → E) {C : ℝ} (hC : 0 ≤ C)
    (hv : ∀ n, ‖v n‖ ≤ C) (N : ℕ) : ‖cesaro v N‖ ≤ C := by
  by_cases hN : N = 0
  · simp [cesaro, hN, hC]
  calc
    ‖cesaro v N‖ ≤ (N : ℝ)⁻¹ * ∑ n ∈ Finset.range N, ‖v n‖ := norm_cesaro_le v N
    _ ≤ (N : ℝ)⁻¹ * ∑ _ ∈ Finset.range N, C :=
      mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun n _ => hv n)) (by positivity)
    _ = C := by simp [hN]

theorem norm_cesaro_shift_sub_le (v : ℕ → E) {C : ℝ}
    (hv : ∀ n, ‖v n‖ ≤ C) (s N : ℕ) :
    ‖cesaro (fun n => v (n + s)) N - cesaro v N‖ ≤
      (N : ℝ)⁻¹ * (2 * s * C) := by
  have heq : (∑ n ∈ Finset.range N, v (n + s)) - ∑ n ∈ Finset.range N, v n =
      (∑ n ∈ Finset.range s, v (n + N)) - ∑ n ∈ Finset.range s, v n := by
    have h₁ := Finset.sum_range_add v N s
    have h₂ := Finset.sum_range_add v s N
    rw [Nat.add_comm s N] at h₂
    simp only [Nat.add_comm] at h₁ h₂
    rw [h₁] at h₂
    apply sub_eq_sub_iff_add_eq_add.mpr
    simpa only [add_comm] using h₂.symm
  calc
    ‖cesaro (fun n => v (n + s)) N - cesaro v N‖ =
        (N : ℝ)⁻¹ * ‖(∑ n ∈ Finset.range s, v (n + N)) -
          ∑ n ∈ Finset.range s, v n‖ := by
      rw [cesaro, cesaro, ← smul_sub, heq, norm_smul,
        Real.norm_of_nonneg (by positivity : 0 ≤ (N : ℝ)⁻¹)]
    _ ≤ (N : ℝ)⁻¹ * ((∑ n ∈ Finset.range s, ‖v (n + N)‖) +
          ∑ n ∈ Finset.range s, ‖v n‖) := by
      apply mul_le_mul_of_nonneg_left _ (by positivity)
      exact (norm_sub_le _ _).trans (add_le_add (norm_sum_le _ _) (norm_sum_le _ _))
    _ ≤ (N : ℝ)⁻¹ * ((∑ _ ∈ Finset.range s, C) + ∑ _ ∈ Finset.range s, C) := by
      apply mul_le_mul_of_nonneg_left _ (by positivity)
      exact add_le_add (Finset.sum_le_sum (fun n _ => hv (n + N)))
        (Finset.sum_le_sum (fun n _ => hv n))
    _ = (N : ℝ)⁻¹ * (2 * s * C) := by
      simp only [Finset.sum_const, Finset.card_range, nsmul_eq_mul]
      ring

theorem cesaro_shift_sub_tendsto_zero (v : ℕ → E) {C : ℝ}
    (hv : ∀ n, ‖v n‖ ≤ C) (s : ℕ) :
    Tendsto (fun N => cesaro (fun n => v (n + s)) N - cesaro v N) atTop (𝓝 0) := by
  apply squeeze_zero_norm (norm_cesaro_shift_sub_le v hv s)
  simpa using (tendsto_inv_atTop_zero.comp
    (tendsto_natCast_atTop_atTop (R := ℝ))).mul_const (2 * s * C)

theorem cesaro_finset_sum {ι : Type*} (s : Finset ι) (v : ι → ℕ → E) (N : ℕ) :
    cesaro (fun n => ∑ i ∈ s, v i n) N = ∑ i ∈ s, cesaro (v i) N := by
  simp only [cesaro, Finset.smul_sum]
  rw [Finset.sum_comm]

theorem cesaro_smul (c : ℝ) (v : ℕ → E) (N : ℕ) :
    cesaro (fun n => c • v n) N = c • cesaro v N := by
  unfold cesaro
  rw [← Finset.smul_sum]
  exact smul_comm _ _ _

theorem cesaro_sub (v w : ℕ → E) (N : ℕ) :
    cesaro (fun n => v n - w n) N = cesaro v N - cesaro w N := by
  simp only [cesaro, Finset.sum_sub_distrib, smul_sub]

theorem cesaro_smoothing_sub_tendsto_zero (v : ℕ → E) {C : ℝ}
    (hv : ∀ n, ‖v n‖ ≤ C) (H : ℕ) (hH : H ≠ 0) (r : Fin H → ℕ) :
    Tendsto (fun N => cesaro (fun n => (H : ℝ)⁻¹ • ∑ a : Fin H, v (n + r a)) N -
      cesaro v N) atTop (𝓝 0) := by
  have h := (tendsto_finsetSum Finset.univ (fun (a : Fin H) _ =>
    cesaro_shift_sub_tendsto_zero v hv (r a))).const_smul (H : ℝ)⁻¹
  simp only [Finset.sum_const_zero, smul_zero] at h
  convert h using 1
  funext N
  rw [cesaro_smul, cesaro_finset_sum]
  rw [Finset.sum_sub_distrib, smul_sub, Finset.sum_const,
    Finset.card_univ, Fintype.card_fin, ← Nat.cast_smul_eq_nsmul ℝ,
    smul_smul, inv_mul_cancel₀ (Nat.cast_ne_zero.mpr hH), one_smul]

end Normed

theorem cesaro_mono {f g : ℕ → ℝ} (h : ∀ n, f n ≤ g n) (N : ℕ) :
    cesaro f N ≤ cesaro g N := by
  exact mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun n _ => h n)) (by positivity)

theorem cesaro_le_bound {f : ℕ → ℝ} {C : ℝ} (hC : 0 ≤ C)
    (h : ∀ n, f n ≤ C) (N : ℕ) : cesaro f N ≤ C := by
  by_cases hN : N = 0
  · simpa [cesaro, hN] using hC
  · exact (cesaro_mono h N).trans_eq (by simp [cesaro, hN])

variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]

theorem norm_cesaro_sq_le (v : ℕ → E) (N : ℕ) :
    ‖cesaro v N‖ ^ 2 ≤ cesaro (fun n => ‖v n‖ ^ 2) N := by
  by_cases hN : N = 0
  · simp [cesaro, hN]
  have hn : (0 : ℝ) < N := Nat.cast_pos.mpr (Nat.pos_of_ne_zero hN)
  have hs := Finset.sum_mul_sq_le_sq_mul_sq (Finset.range N)
    (fun n => ‖v n‖) (fun _ => (1 : ℝ))
  simp only [mul_one, one_pow, Finset.sum_const, Finset.card_range, nsmul_eq_mul,
    mul_one] at hs
  have hnorm := norm_cesaro_le v N
  have hsquare : ‖cesaro v N‖ ^ 2 ≤
      (N : ℝ)⁻¹ ^ 2 * (∑ n ∈ Finset.range N, ‖v n‖)^2 := by
    simpa only [mul_pow] using pow_le_pow_left₀ (norm_nonneg _) hnorm 2
  calc
    ‖cesaro v N‖ ^ 2 ≤ (N : ℝ)⁻¹ ^ 2 * (∑ n ∈ Finset.range N, ‖v n‖)^2 := hsquare
    _ ≤ (N : ℝ)⁻¹ ^ 2 * ((∑ n ∈ Finset.range N, ‖v n‖^2) * N) :=
      mul_le_mul_of_nonneg_left hs (by positivity)
    _ = cesaro (fun n => ‖v n‖ ^ 2) N := by
      simp only [cesaro, smul_eq_mul]
      field_simp

theorem norm_finite_mean_sq (v : ℕ → E) (H : ℕ) (r : Fin H → ℕ) (n : ℕ) :
    ‖(H : ℝ)⁻¹ • ∑ a : Fin H, v (n + r a)‖ ^ 2 =
      (H : ℝ)⁻¹ ^ 2 * ∑ a : Fin H, ∑ b : Fin H,
        inner ℝ (v (n + r a)) (v (n + r b)) := by
  rw [norm_smul, Real.norm_of_nonneg (by positivity : 0 ≤ (H : ℝ)⁻¹), mul_pow,
    ← real_inner_self_eq_norm_sq]
  simp only [sum_inner, inner_sum]
  rw [Finset.sum_comm]

theorem norm_smoothed_cesaro_sq_le (v : ℕ → E) (H N : ℕ) (r : Fin H → ℕ) :
    ‖cesaro (fun n => (H : ℝ)⁻¹ • ∑ a : Fin H, v (n + r a)) N‖ ^ 2 ≤
      (H : ℝ)⁻¹ ^ 2 * ∑ a : Fin H, ∑ b : Fin H,
        cesaro (fun n => inner ℝ (v (n + r a)) (v (n + r b))) N := by
  convert norm_cesaro_sq_le (fun n => (H : ℝ)⁻¹ • ∑ a : Fin H, v (n + r a)) N using 1
  simp_rw [norm_finite_mean_sq]
  change _ = cesaro (fun n => ((H : ℝ)⁻¹ ^ 2) • ∑ a : Fin H, ∑ b : Fin H,
    inner ℝ (v (n + r a)) (v (n + r b))) N
  rw [cesaro_smul, cesaro_finset_sum]
  simp_rw [cesaro_finset_sum, smul_eq_mul]

def LagCesaroBound (v : ℕ → E) (c : ℕ → ℝ) : Prop :=
  ∀ h : ℕ, 0 < h → ∀ ε : ℝ, 0 < ε → ∀ᶠ N in atTop,
    cesaro (fun n => |inner ℝ (v n) (v (n + h))|) N ≤ c h + ε

theorem shifted_lag_cesaro_bound (v : ℕ → E) {C : ℝ} (hv : ∀ n, ‖v n‖ ≤ C)
    {c : ℕ → ℝ} (hc : LagCesaroBound v c) (s h : ℕ) (hh : 0 < h)
    (ε : ℝ) (hε : 0 < ε) : ∀ᶠ N in atTop,
    cesaro (fun n => |inner ℝ (v (n + s)) (v (n + s + h))|) N ≤ c h + ε := by
  have hC : 0 ≤ C := (norm_nonneg (v 0)).trans (hv 0)
  have hb : ∀ n, ‖|inner ℝ (v n) (v (n + h))|‖ ≤ C ^ 2 := by
    intro n
    rw [Real.norm_eq_abs, abs_abs, ← Real.norm_eq_abs]
    exact (norm_inner_le_norm _ _).trans
      (by simpa only [pow_two] using mul_le_mul (hv n) (hv (n + h)) (norm_nonneg _) hC)
  have hs := cesaro_shift_sub_tendsto_zero _ hb s
  have he := hs.eventually_lt_const (half_pos hε)
  filter_upwards [he, hc h hh (ε / 2) (half_pos hε)] with N hshift hbase
  change cesaro (fun n => |inner ℝ (v (n + s)) (v (n + s + h))|) N -
    cesaro (fun n => |inner ℝ (v n) (v (n + h))|) N < ε / 2 at hshift
  linarith

theorem pair_cesaro_bound (v : ℕ → E) {C : ℝ} (hv : ∀ n, ‖v n‖ ≤ C)
    {c : ℕ → ℝ} (hc : LagCesaroBound v c) (a b : ℕ) (hab : a ≠ b)
    (ε : ℝ) (hε : 0 < ε) : ∀ᶠ N in atTop,
    cesaro (fun n => inner ℝ (v (n + a)) (v (n + b))) N ≤ c (Nat.dist a b) + ε := by
  rcases le_total a b with hle | hle
  · have he := shifted_lag_cesaro_bound v hv hc a (b - a) (by omega) ε hε
    filter_upwards [he] with N hN
    have hsub : ∀ n, n + a + (b - a) = n + b := by omega
    simp_rw [hsub, ← Nat.dist_eq_sub_of_le hle] at hN
    exact (cesaro_mono (fun n => le_abs_self _) N).trans hN
  · have he := shifted_lag_cesaro_bound v hv hc b (a - b) (by omega) ε hε
    filter_upwards [he] with N hN
    have hsub : ∀ n, n + b + (a - b) = n + a := by omega
    simp_rw [hsub, ← Nat.dist_eq_sub_of_le_right hle] at hN
    exact (cesaro_mono (fun n => (real_inner_comm _ _).le.trans (le_abs_self _)) N).trans hN

theorem van_der_corput (v : ℕ → E) {C : ℝ} (hv : ∀ n, ‖v n‖ ≤ C)
    {c : ℕ → ℝ} (hc : LagCesaroBound v c) (hclim : Tendsto c atTop (𝓝 0)) :
    Tendsto (cesaro v) atTop (𝓝 0) := by
  apply Metric.tendsto_nhds.mpr
  intro ε hε
  have hδ : 0 < ε ^ 2 / 16 := by positivity
  have hinv : Tendsto (fun H : ℕ => (H : ℝ)⁻¹ * C ^ 2) atTop (𝓝 0) := by
    simpa using (tendsto_inv_atTop_zero.comp
      (tendsto_natCast_atTop_atTop (R := ℝ))).mul_const (C ^ 2)
  obtain ⟨H, hHpos, hHsmall⟩ :=
    ((eventually_ge_atTop 1).and (hinv.eventually_lt_const hδ)).exists
  have hH : H ≠ 0 := by omega
  have hHR : (H : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hH
  obtain ⟨L₀, hL₀⟩ := eventually_atTop.mp (hclim.eventually_lt_const (half_pos hδ))
  let L := L₀ + 1
  let r (a : Fin H) := a.val * L
  have hpairs : ∀ a b : Fin H, ∀ᶠ N in atTop,
      cesaro (fun n => inner ℝ (v (n + r a)) (v (n + r b))) N ≤
        (if a = b then C ^ 2 else 0) + ε ^ 2 / 16 := by
    intro a b
    by_cases hab : a = b
    · subst b
      apply Eventually.of_forall
      intro N
      simp only [ite_true]
      have hdiag : cesaro (fun n => inner ℝ (v (n + r a)) (v (n + r a))) N ≤ C ^ 2 := by
        apply cesaro_le_bound (sq_nonneg C)
        intro n
        rw [real_inner_self_eq_norm_sq]
        exact pow_le_pow_left₀ (norm_nonneg _) (hv _) 2
      linarith
    · have hval : a.val ≠ b.val := fun h => hab (Fin.ext h)
      have hdist : L₀ ≤ Nat.dist (r a) (r b) := by
        dsimp [r]
        rw [Nat.dist_mul_right]
        have hh : 1 ≤ Nat.dist a.val b.val := Nat.dist_pos_of_ne hval
        have hh' := Nat.mul_le_mul_right L hh
        simp only [one_mul] at hh'
        exact (by dsimp [L]; omega : L₀ ≤ L).trans hh'
      have hr : r a ≠ r b := by
        intro hh
        have hh' := Nat.eq_of_mul_eq_mul_right (by dsimp [L]; omega : 0 < L) hh
        exact hval hh'
      filter_upwards [pair_cesaro_bound v hv hc (r a) (r b) hr
        (ε ^ 2 / 16 / 2) (half_pos hδ)] with N hN
      simp only [ite_eq_right hab]
      have hh := hL₀ _ hdist
      linarith
  have hpairs' : ∀ᶠ N in atTop, ∀ a b : Fin H,
      cesaro (fun n => inner ℝ (v (n + r a)) (v (n + r b))) N ≤
        (if a = b then C ^ 2 else 0) + ε ^ 2 / 16 :=
    eventually_all.mpr (fun a => eventually_all.mpr (hpairs a))
  let w (n : ℕ) := (H : ℝ)⁻¹ • ∑ a : Fin H, v (n + r a)
  have hdiff := cesaro_smoothing_sub_tendsto_zero v hv H hH r
  have hdiff' := (Metric.tendsto_nhds.mp hdiff) (ε / 2) (half_pos hε)
  filter_upwards [hpairs', hdiff'] with N hN hdiffN
  have hbound : ‖cesaro w N‖ ^ 2 ≤ (H : ℝ)⁻¹ * C ^ 2 + ε ^ 2 / 16 := by
    calc
      ‖cesaro w N‖ ^ 2 ≤ (H : ℝ)⁻¹ ^ 2 * ∑ a : Fin H, ∑ b : Fin H,
          cesaro (fun n => inner ℝ (v (n + r a)) (v (n + r b))) N :=
        norm_smoothed_cesaro_sq_le v H N r
      _ ≤ (H : ℝ)⁻¹ ^ 2 * ∑ a : Fin H, ∑ b : Fin H,
          ((if a = b then C ^ 2 else 0) + ε ^ 2 / 16) := by
        apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
        exact Finset.sum_le_sum (fun a _ => Finset.sum_le_sum (fun b _ => hN a b))
      _ = (H : ℝ)⁻¹ * C ^ 2 + ε ^ 2 / 16 := by
        simp only [Finset.sum_add_distrib, Finset.sum_ite_eq, Finset.mem_univ, ite_true,
          Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
        field_simp
  have hw : ‖cesaro w N‖ < ε / 2 := by
    nlinarith [norm_nonneg (cesaro w N)]
  have he : ‖cesaro w N - cesaro v N‖ < ε / 2 := by
    simpa only [dist_zero_right] using hdiffN
  simp only [dist_zero_right]
  calc
    ‖cesaro v N‖ = ‖cesaro w N - (cesaro w N - cesaro v N)‖ := by
      congr 1; abel
    _ ≤ ‖cesaro w N‖ + ‖cesaro w N - cesaro v N‖ := norm_sub_le _ _
    _ < ε := by linarith

end

section

open MeasureTheory Filter
open scoped BigOperators Topology InnerProductSpace ComplexConjugate

def DifferencePolynomial {L : Type*} [AddCommGroup L] : ℕ → (ℕ → L) → Prop
  | 0, P => ∃ l, ∀ m, P m = l
  | d + 1, P => ∀ h : ℕ, 0 < h → DifferencePolynomial d (fun m => P (m + h) - P m)

namespace DifferencePolynomial
variable {L : Type*} [AddCommGroup L]

theorem const (l : L) (d : ℕ) : DifferencePolynomial d (fun _ => l) := by
  induction d generalizing l with
  | zero => exact ⟨l, fun _ => rfl⟩
  | succ d ih =>
    intro h _
    simpa only [sub_self] using ih (0 : L)

theorem add {d : ℕ} {P Q : ℕ → L} (hP : DifferencePolynomial d P)
    (hQ : DifferencePolynomial d Q) : DifferencePolynomial d (fun m => P m + Q m) := by
  induction d generalizing P Q with
  | zero =>
    obtain ⟨p, hp⟩ := hP
    obtain ⟨q, hq⟩ := hQ
    exact ⟨p + q, fun m => by simp only [hp, hq]⟩
  | succ d ih =>
    intro h hh
    have hx := ih (hP h hh) (hQ h hh)
    convert hx using 1
    funext m
    exact add_sub_add_comm _ _ _ _

theorem shift {d : ℕ} {P : ℕ → L} (hP : DifferencePolynomial d P) (s : ℕ) :
    DifferencePolynomial d (fun m => P (m + s)) := by
  induction d generalizing P with
  | zero => obtain ⟨l, hl⟩ := hP; exact ⟨l, fun m => hl (m + s)⟩
  | succ d ih =>
    intro h hh
    have hx := ih (hP h hh)
    convert hx using 1
    funext m
    simp only [Nat.add_right_comm]

theorem sum {ι : Type*} (S : Finset ι) {d : ℕ} (P : ι → ℕ → L)
    (hP : ∀ i ∈ S, DifferencePolynomial d (P i)) :
    DifferencePolynomial d (fun m => ∑ i ∈ S, P i m) := by
  classical
  induction S using Finset.induction_on with
  | empty => simpa using const (0 : L) d
  | @insert i S hi ih =>
    simp only [Finset.sum_insert hi]
    exact (hP i (Finset.mem_insert_self _ _)).add
      (ih (fun j hj => hP j (Finset.mem_insert_of_mem hj)))

theorem succ {d : ℕ} {P : ℕ → L} (hP : DifferencePolynomial d P) :
    DifferencePolynomial (d + 1) P := by
  induction d generalizing P with
  | zero =>
    obtain ⟨l, hl⟩ := hP
    have heq : P = fun _ => l := funext hl
    rw [heq]
    exact const l 1
  | succ d ih => exact fun h hh => ih (hP h hh)

theorem mono {d e : ℕ} (hde : d ≤ e) {P : ℕ → L} (hP : DifferencePolynomial d P) :
    DifferencePolynomial e P := by
  induction e, hde using Nat.le_induction with
  | base => exact hP
  | succ e _ ih => exact ih.succ

theorem of_forward_difference {d : ℕ} {P : ℕ → L}
    (hP : DifferencePolynomial d (fun m => P (m + 1) - P m)) :
    DifferencePolynomial (d + 1) P := by
  intro h hh
  clear hh
  have hs := sum (Finset.range h) (fun i m => P (m + i + 1) - P (m + i))
    (fun i _ => hP.shift i)
  have heq (m : ℕ) : (∑ i ∈ Finset.range h, (P (m + i + 1) - P (m + i))) =
      P (m + h) - P m := by
    clear hs
    induction h with
    | zero => simp
    | succ h ih =>
      rw [Finset.sum_range_succ, ih]
      simp only [Nat.add_assoc]
      abel
  simpa only [heq] using hs

theorem choose_nsmul (a : ℕ) (l : L) :
    DifferencePolynomial a (fun m => m.choose a • l) := by
  induction a with
  | zero => simpa using const l 0
  | succ a ih =>
    apply of_forward_difference
    convert ih using 1
    funext m
    rw [Nat.choose_succ_succ, add_nsmul]
    abel

theorem binomial (d : ℕ) (l : ℕ → L) :
    DifferencePolynomial d (fun m => ∑ a ∈ Finset.range (d + 1), m.choose a • l a) := by
  apply sum
  intro a ha
  exact (choose_nsmul a (l a)).mono (by have := Finset.mem_range.mp ha; omega)

end DifferencePolynomial

section Bounded
variable {Y : Type*} [MeasurableSpace Y] {η : Measure Y} [IsProbabilityMeasure η]

theorem norm_toLp_le_bound {f : Y → ℂ} (hf : MemLp f 2 η) {C : ℝ}
    (hC : 0 ≤ C) (hb : ∀ᵐ y ∂η, ‖f y‖ ≤ C) : ‖hf.toLp f‖ ≤ C := by
  have hb' : ∀ᵐ y ∂η, ‖hf.toLp f y‖ ≤ C := by
    filter_upwards [hf.coeFn_toLp, hb] with y hy hb
    simpa only [hy] using hb
  simpa [measureUnivNNReal] using Lp.norm_le_of_ae_bound hC hb'
end Bounded

namespace ProjectiveCharacters
variable {Y L : Type*} [MeasurableSpace Y] [AddCommGroup L]
    {η : Measure Y} [IsProbabilityMeasure η] {χ : L → Y → ℂ}
    (hχ : ProjectiveCharacters η χ)
include hχ

omit [IsProbabilityMeasure η] in

theorem mul_conj (l m : L) : ∃ c : ℂ, ‖c‖ = 1 ∧
    (fun y => χ l y * conj (χ m y)) =ᵐ[η] (fun y => c * χ (l - m) y) := by
  obtain ⟨c, hc, hcon⟩ := hχ.conjugate m
  obtain ⟨d, hd, hmul⟩ := hχ.mul l (-m)
  refine ⟨c * d, by simp [hc, hd], ?_⟩
  filter_upwards [hcon, hmul] with y hy hz
  rw [hy]
  calc
    χ l y * (c * χ (-m) y) = c * (χ l y * χ (-m) y) := by ring
    _ = c * (d * χ (l + -m) y) := by rw [hz]
    _ = (c * d) * χ (l - m) y := by simp only [sub_eq_add_neg]; ring

theorem norm_integral_conj_le_one (l : L) : ‖∫ y, conj (χ l y) ∂η‖ ≤ 1 := by
  have hb : ∀ᵐ y ∂η, ‖conj (χ l y)‖ ≤ 1 := by
    filter_upwards [hχ.modulus l] with y hy
    simpa using hy.le
  simpa using norm_integral_le_of_norm_le_const hb
end ProjectiveCharacters

theorem l2_real_inner_eq_re_inner {Y : Type*} [MeasurableSpace Y] {η : Measure Y}
    (f g : Lp ℂ 2 η) : inner ℝ f g = (inner ℂ f g).re := by
  rw [L2.inner_def, L2.inner_def]
  simp_rw [real_inner_eq_re_inner ℂ]
  exact integral_re (L2.integrable_inner (𝕜 := ℂ) f g)

variable {X Y L : Type*} [MeasurableSpace X] [MeasurableSpace Y] [AddCommGroup L]
    {μ : Measure X} [IsProbabilityMeasure μ]
    {η : Measure Y} [IsProbabilityMeasure η]
    (x : Y → X) (hx : MeasurePreserving x η μ)
    (t : ℕ → X → X) (ht : ∀ m, MeasurePreserving (t m) μ μ)
    {χ : L → Y → ℂ} (hχ : ProjectiveCharacters η χ)

omit [IsProbabilityMeasure μ] in
include hx ht hχ in

theorem phased_memLp {F : X → ℂ} (hFm : AEStronglyMeasurable F μ)
    {C : ℝ} (hFb : ∀ᵐ z ∂μ, ‖F z‖ ≤ C) (P : ℕ → L)
    (ω : ℕ → ℂ) (hω : ∀ m, ‖ω m‖ = 1) (m : ℕ) :
    MemLp (fun y => ω m * F (t m (x y)) * conj (χ (P m) y)) 2 η := by
  apply MemLp.of_bound
    (((hFm.comp_measurePreserving ((ht m).comp hx)).const_mul _).mul
      (hχ.measurable _).star) C
  filter_upwards [((ht m).comp hx).quasiMeasurePreserving.ae hFb,
    hχ.modulus (P m)] with y hy hz
  change ‖ω m * F (t m (x y)) * conj (χ (P m) y)‖ ≤ C
  simpa only [norm_mul, Complex.norm_conj, hω, hz, one_mul, mul_one, Function.comp_def] using hy

omit [MeasurableSpace X] [IsProbabilityMeasure η] in
include hχ in

theorem phased_lag_norm {F : X → ℂ} (P : ℕ → L) (ω : ℕ → ℂ)
    (hω : ∀ m, ‖ω m‖ = 1) (m h : ℕ)
    (htadd : ∀ a b z, t (a + b) z = t b (t a z))
    (hf : ∀ m, MemLp (fun y => ω m * F (t m (x y)) * conj (χ (P m) y)) 2 η) :
    ‖inner ℂ ((hf m).toLp _) ((hf (m + h)).toLp _)‖ =
      ‖∫ y, (F (t h (t m (x y))) * conj (F (t m (x y)))) *
        conj (χ (P (m + h) - P m) y) ∂η‖ := by
  obtain ⟨c, hc, hm⟩ := hχ.mul_conj (P (m + h)) (P m)
  rw [L2.inner_def]
  have heq : (fun y => inner ℂ (((hf m).toLp _) y) (((hf (m + h)).toLp _) y)) =ᵐ[η]
      (fun y => (ω (m + h) * conj (ω m) * conj c) *
        ((F (t h (t m (x y))) * conj (F (t m (x y)))) *
          conj (χ (P (m + h) - P m) y))) := by
    filter_upwards [(hf m).coeFn_toLp, (hf (m + h)).coeFn_toLp, hm] with y hy hz hm
    rw [hy, hz, RCLike.inner_apply, map_mul, map_mul, starRingEnd_self_apply,
      htadd m h]
    have hm' := congrArg conj hm
    simp only [map_mul, starRingEnd_self_apply] at hm'
    calc
      _ = (ω (m + h) * conj (ω m)) *
        (F (t h (t m (x y))) * conj (F (t m (x y)))) *
        (conj (χ (P (m + h)) y) * χ (P m) y) := by ring
      _ = _ := by rw [hm']; ring
  rw [integral_congr_ae heq, integral_const_mul, norm_mul]
  simp [hω, hc]

include hx ht hχ in

theorem polynomial_cancellation
    (htadd : ∀ a b z, t (a + b) z = t b (t a z))
    (hmix : ∀ A B : Set X, MeasurableSet A → MeasurableSet B →
      Tendsto (fun m => μ (A ∩ t m ⁻¹' B)) atTop (𝓝 (μ A * μ B)))
    (d : ℕ) (P : ℕ → L) (hP : DifferencePolynomial d P)
    {F : X → ℂ} (hFm : AEStronglyMeasurable F μ)
    {C : ℝ} (hC : 0 ≤ C) (hFb : ∀ᵐ z ∂μ, ‖F z‖ ≤ C)
    (hF0 : ∫ z, F z ∂μ = 0) :
    Tendsto (fun N : ℕ => (N : ℝ)⁻¹ * ∑ m ∈ Finset.range N,
      ‖∫ y, F (t m (x y)) * conj (χ (P m) y) ∂η‖) atTop (𝓝 0) := by
  induction d generalizing P F C with
  | zero =>
    obtain ⟨l, hl⟩ := hP
    have hF := MemLp.of_bound (p := 2) hFm C hFb
    have hq := MemLp.of_bound (p := 2) (hχ.measurable l) 1
      ((hχ.modulus l).mono (fun _ h => h.le))
    have hm := mixing_integral_coupling t ht atTop x hx hmix hF hF0 hq
    simpa only [hl, norm_zero] using hm.norm.cesaro
  | succ d ih =>
    choose ω hω hw using fun m =>
      exists_aligning_phase (∫ y, F (t m (x y)) * conj (χ (P m) y) ∂η)
    let q (m : ℕ) (y : Y) := ω m * F (t m (x y)) * conj (χ (P m) y)
    have hq (m : ℕ) : MemLp (q m) 2 η := phased_memLp x hx t ht hχ hFm hFb P ω hω m
    let v (m : ℕ) : Lp ℂ 2 η := (hq m).toLp (q m)
    have hv (m : ℕ) : ‖v m‖ ≤ C := by
      apply norm_toLp_le_bound (hq m) hC
      filter_upwards [((ht m).comp hx).quasiMeasurePreserving.ae hFb,
        hχ.modulus (P m)] with y hy hz
      simpa only [q, norm_mul, Complex.norm_conj, hω, hz, one_mul, mul_one, Function.comp_def] using hy
    let c (h : ℕ) := ‖∫ z, F (t h z) * conj (F z) ∂μ‖
    have hclim : Tendsto c atTop (𝓝 0) := by
      have hF := MemLp.of_bound (p := 2) hFm C hFb
      have hm := mixing_integral_coupling t ht atTop id (MeasurePreserving.id μ)
        hmix hF hF0 hF
      simpa only [c, id_eq, norm_zero] using hm.norm
    have hlag : LagCesaroBound v c := by
      intro h hh ε hε
      let H (z : X) := F (t h z) * conj (F z)
      have hHm : AEStronglyMeasurable H μ :=
        (hFm.comp_measurePreserving (ht h)).mul hFm.star
      have hHb : ∀ᵐ z ∂μ, ‖H z‖ ≤ C ^ 2 := by
        filter_upwards [(ht h).quasiMeasurePreserving.ae hFb, hFb] with z hz hf
        dsimp [H]
        rw [norm_mul, Complex.norm_conj, pow_two]
        exact mul_le_mul hz hf (norm_nonneg _) hC
      have hHi : Integrable H μ := (MemLp.of_bound (p := 1) hHm (C ^ 2) hHb).integrable le_rfl
      let a : ℂ := ∫ z, H z ∂μ
      let G (z : X) := H z - a
      have hGm : AEStronglyMeasurable G μ := hHm.sub aestronglyMeasurable_const
      have hGb : ∀ᵐ z ∂μ, ‖G z‖ ≤ C ^ 2 + ‖a‖ := by
        filter_upwards [hHb] with z hz
        exact (norm_sub_le _ _).trans (add_le_add hz le_rfl)
      have hG0 : ∫ z, G z ∂μ = 0 := by
        dsimp [G]
        rw [integral_sub hHi (integrable_const a)]
        simp [a]
      let D (m : ℕ) := P (m + h) - P m
      have hGc := ih D (hP h hh) hGm (by positivity : 0 ≤ C ^ 2 + ‖a‖) hGb hG0
      let b (m : ℕ) := ‖∫ y, G (t m (x y)) * conj (χ (D m) y) ∂η‖
      have hbound (m : ℕ) : |inner ℝ (v m) (v (m + h))| ≤ b m + c h := by
        have hreal : |inner ℝ (v m) (v (m + h))| ≤
            ‖inner ℂ (v m) (v (m + h))‖ := by
          rw [l2_real_inner_eq_re_inner]
          exact Complex.abs_re_le_norm _
        have heq := phased_lag_norm x t hχ P ω hω m h htadd hq
        change ‖inner ℂ (v m) (v (m + h))‖ = _ at heq
        rw [heq] at hreal
        refine hreal.trans ?_
        have hGi : Integrable (fun y => G (t m (x y)) * conj (χ (D m) y)) η := by
          have hhq := phased_memLp x hx t ht hχ hGm hGb D (fun _ => 1)
            (fun _ => norm_one) m
          simpa only [one_mul] using hhq.integrable (by norm_num : (1 : ENNReal) ≤ 2)
        have hei : Integrable (fun y => a * conj (χ (D m) y)) η :=
          ((MemLp.of_bound (p := 1) (hχ.measurable _).star 1
            ((hχ.modulus (D m)).mono (fun y hy => by simpa only [Pi.star_apply, norm_star] using hy.le))).integrable le_rfl).const_mul a
        have hi : (∫ y, H (t m (x y)) * conj (χ (D m) y) ∂η) =
            (∫ y, G (t m (x y)) * conj (χ (D m) y) ∂η) +
              a * (∫ y, conj (χ (D m) y) ∂η) := by
          rw [← integral_const_mul, ← integral_add hGi hei]
          apply integral_congr_ae
          exact Eventually.of_forall (fun y => by dsimp [G]; ring)
        change ‖∫ y, H (t m (x y)) * conj (χ (D m) y) ∂η‖ ≤ _
        rw [hi]
        calc
          _ ≤ b m + ‖a * ∫ y, conj (χ (D m) y) ∂η‖ := norm_add_le _ _
          _ ≤ b m + ‖a‖ := by
            gcongr
            rw [norm_mul]
            exact (mul_le_mul_of_nonneg_left (hχ.norm_integral_conj_le_one _) (norm_nonneg a)).trans_eq
              (mul_one _)
          _ = b m + c h := rfl
      filter_upwards [hGc.eventually_lt_const hε, eventually_gt_atTop 0] with N hN hN0
      have hNne : (N : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hN0)
      change cesaro (fun m => |inner ℝ (v m) (v (m + h))|) N ≤ c h + ε
      calc
        _ ≤ cesaro (fun m => b m + c h) N := cesaro_mono hbound N
        _ = cesaro b N + c h := by
          simp [cesaro, Finset.sum_add_distrib, mul_add, hNne]
        _ ≤ c h + ε := by change (N : ℝ)⁻¹ * ∑ m ∈ Finset.range N, b m < ε at hN
                          change (N : ℝ)⁻¹ * ∑ m ∈ Finset.range N, b m + c h ≤ c h + ε
                          linarith
    have hc := van_der_corput v hv hlag hclim
    have hcont : Continuous (fun w : Lp ℂ 2 η =>
        inner ℝ (probabilityOne (μ := η)) w) := by fun_prop
    have he (m : ℕ) : inner ℝ (probabilityOne (μ := η)) (v m) =
        ‖∫ y, F (t m (x y)) * conj (χ (P m) y) ∂η‖ := by
      rw [l2_real_inner_eq_re_inner, inner_probabilityOne]
      have hqi : (∫ y, v m y ∂η) = ∫ y, q m y ∂η := integral_congr_ae (hq m).coeFn_toLp
      rw [hqi]
      change (∫ y, ω m * F (t m (x y)) * conj (χ (P m) y) ∂η).re = _
      simp_rw [mul_assoc]
      rw [integral_const_mul]
      exact hw m
    have hi' : Tendsto (fun N => inner ℝ (probabilityOne (μ := η)) (cesaro v N)) atTop (𝓝 0) := by
      simpa only [Function.comp_def, inner_zero_right] using (hcont.tendsto 0).comp hc
    convert hi' using 1
    funext N
    simp only [cesaro, inner_smul_right, inner_sum, he]

include hx ht hχ in

theorem binomial_cancellation
    (htadd : ∀ a b z, t (a + b) z = t b (t a z))
    (hmix : ∀ A B : Set X, MeasurableSet A → MeasurableSet B →
      Tendsto (fun m => μ (A ∩ t m ⁻¹' B)) atTop (𝓝 (μ A * μ B)))
    (d : ℕ) (l : ℕ → L)
    {F : X → ℂ} (hFm : AEStronglyMeasurable F μ)
    {C : ℝ} (hC : 0 ≤ C) (hFb : ∀ᵐ z ∂μ, ‖F z‖ ≤ C)
    (hF0 : ∫ z, F z ∂μ = 0) :
    Tendsto (fun N : ℕ => (N : ℝ)⁻¹ * ∑ m ∈ Finset.range N,
      ‖∫ y, F (t m (x y)) *
        conj (χ (∑ a ∈ Finset.range (d + 1), m.choose a • l a) y) ∂η‖)
      atTop (𝓝 0) :=
  polynomial_cancellation x hx t ht hχ htadd hmix d _
    (DifferencePolynomial.binomial d l) hFm hC hFb hF0

end

open scoped BigOperators
open Polynomial
section

theorem monic_mahlerMeasure_eq_one (p : ℤ[X]) (hp : p.Monic)
    (hroots : ∀ z ∈ p.aroots ℂ, ‖z‖ ≤ 1) :
    (p.map (Int.castRingHom ℂ)).mahlerMeasure = 1 := by
  rw [Polynomial.mahlerMeasure_eq_leadingCoeff_mul_prod_roots]
  rw [(hp.map _).leadingCoeff, norm_one, one_mul]
  apply Multiset.prod_eq_one
  intro r hr
  obtain ⟨z, hz, rfl⟩ := Multiset.mem_map.mp hr
  exact max_eq_left (hroots z hz)

theorem integer_polynomial_dvd_cyclotomic_power (p : ℤ[X]) (hp : p.Monic)
    (hzero : ∀ z ∈ p.aroots ℂ, z ≠ 0)
    (hroots : ∀ z ∈ p.aroots ℂ, ‖z‖ ≤ 1) :
    ∃ N d : ℕ, 0 < N ∧ 0 < d ∧ p ∣ (X ^ N - 1) ^ d := by
  classical
  let f := p.map (Int.castRingHom ℂ)
  let s := f.roots.toFinset
  have hmahler := monic_mahlerMeasure_eq_one p hp hroots
  have horders (z : s) : ∃ n : ℕ, 0 < n ∧ (z.val : ℂ) ^ n = 1 := by
    have hz : z.val ∈ p.aroots ℂ := Multiset.mem_toFinset.mp z.property
    exact Polynomial.pow_eq_one_of_mahlerMeasure_eq_one hmahler (hzero _ hz) hz
  choose n hnpos hn using horders
  let N := ∏ z : s, n z
  have hN : 0 < N := Finset.prod_pos (fun _ _ => hnpos _)
  have hpow : ∀ z ∈ f.roots, z ^ N = 1 := by
    intro z hz
    let w : s := ⟨z, Multiset.mem_toFinset.mpr hz⟩
    have hd : n w ∣ N := Finset.dvd_prod_of_mem n (Finset.mem_univ w)
    obtain ⟨a, ha⟩ := hd
    rw [ha, pow_mul, hn w, one_pow]
  let Q : ℂ[X] := X ^ N - 1
  have hQ : Q ≠ 0 := by
    intro hh
    have he := congrArg (eval (0 : ℂ)) hh
    simp [Q, hN.ne'] at he
  have hQroots : ∀ z ∈ f.roots, z ∈ Q.roots := by
    intro z hz
    apply (mem_roots hQ).mpr
    simp [IsRoot.def, Q, hpow z hz]
  let d := f.roots.card + 1
  have hd : 0 < d := Nat.succ_pos _
  have hmult : f.roots ≤ (Q ^ d).roots := by
    rw [roots_pow]
    apply Multiset.le_iff_count.mpr
    intro z
    rw [Multiset.count_nsmul]
    by_cases hz : z ∈ f.roots
    · have hc : 0 < Q.roots.count z := Multiset.count_pos.mpr (hQroots z hz)
      calc
        f.roots.count z ≤ f.roots.card := Multiset.count_le_card _ _
        _ ≤ d := Nat.le_succ _
        _ ≤ d * Q.roots.count z := Nat.le_mul_of_pos_right d hc
    · simp [Multiset.count_eq_zero.mpr hz]
  have hf0 : f ≠ 0 := (hp.map _).ne_zero
  have hdivC : f ∣ Q ^ d :=
    ((IsAlgClosed.splits f).dvd_iff_roots_le_roots hf0 (pow_ne_zero d hQ)).mpr hmult
  refine ⟨N, d, hN, hd, ?_⟩
  apply (Polynomial.map_dvd_map (Int.castRingHom ℂ) (Int.castRingHom ℂ).injective_int hp).mp
  simpa [f, Q] using hdivC

theorem quasiUnipotent_of_integer_annihilator {A : Type*} [Ring A] [Algebra ℤ A]
    (a : A) (p : ℤ[X]) (hp : p.Monic) (hann : aeval a p = 0)
    (hzero : ∀ z ∈ p.aroots ℂ, z ≠ 0)
    (hroots : ∀ z ∈ p.aroots ℂ, ‖z‖ ≤ 1) :
    ∃ N d : ℕ, 0 < N ∧ 0 < d ∧ (a ^ N - 1) ^ d = 0 := by
  obtain ⟨N, d, hN, hd, hdiv⟩ := integer_polynomial_dvd_cyclotomic_power p hp hzero hroots
  refine ⟨N, d, hN, hd, ?_⟩
  have hh := Polynomial.aeval_eq_zero_of_dvd_aeval_eq_zero hdiv hann
  simpa using hh

section Lattice
variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
  [Module.Free R M] [Module.Finite R M]

lemma charpoly_dual (f : M →ₗ[R] M) : f.dualMap.charpoly = f.charpoly := by
  classical
  let b := Module.Free.chooseBasis R M
  have hm : LinearMap.toMatrix b.dualBasis b.dualBasis f.dualMap =
      (LinearMap.toMatrix b b f).transpose := by
    ext i j
    simp [LinearMap.toMatrix_apply, Module.Basis.dualBasis_repr,
      Matrix.transpose_apply]
  rw [← f.dualMap.charpoly_toMatrix b.dualBasis, hm, Matrix.charpoly_transpose,
    f.charpoly_toMatrix b]

end Lattice

section Torsion
variable {M : Type*} [AddCommGroup M] (G : M ≃ₗ[ℤ] M)

lemma map_mem_torsion {x : M} (hx : x ∈ Submodule.torsion ℤ M) :
    G x ∈ Submodule.torsion ℤ M := by
  obtain ⟨a, ha⟩ := (Submodule.mem_torsion_iff x).mp hx
  apply (Submodule.mem_torsion_iff (G x)).mpr
  refine ⟨a, ?_⟩
  change (a : ℤ) • x = 0 at ha
  change (a : ℤ) • G x = 0
  simpa only [map_smul, map_zero] using congrArg G ha

lemma torsion_map_equiv : (Submodule.torsion ℤ M).map G.toLinearMap =
    Submodule.torsion ℤ M := by
  ext x
  constructor
  · rintro ⟨y, hy, rfl⟩
    exact map_mem_torsion G hy
  · intro hx
    exact ⟨G.symm x, map_mem_torsion G.symm hx, G.apply_symm_apply x⟩

noncomputable def torsionQuotEquiv : (M ⧸ Submodule.torsion ℤ M) ≃ₗ[ℤ]
    (M ⧸ Submodule.torsion ℤ M) :=
  Submodule.Quotient.equiv _ _ G (torsion_map_equiv G)

@[simp] lemma torsionQuotEquiv_mk (x : M) :
    torsionQuotEquiv G ((Submodule.torsion ℤ M).mkQ x) =
      (Submodule.torsion ℤ M).mkQ (G x) := rfl

noncomputable def torsionRestrictEquiv : (Submodule.torsion ℤ M) ≃ₗ[ℤ]
    (Submodule.torsion ℤ M) where
  toFun x := ⟨G x, map_mem_torsion G x.property⟩
  invFun x := ⟨G.symm x, map_mem_torsion G.symm x.property⟩
  left_inv x := by ext; exact G.symm_apply_apply x
  right_inv x := by ext; exact G.apply_symm_apply x
  map_add' x y := by ext; exact map_add G _ _
  map_smul' a x := by ext; exact map_smul G a (x : M)

lemma torsionRestrictEquiv_pow (n : ℕ) (x : Submodule.torsion ℤ M) :
    ((torsionRestrictEquiv G ^ n) x : M) = (G ^ n) x := by
  induction n with
  | zero => rfl
  | succ n ih =>
    simp only [pow_succ', LinearEquiv.mul_apply]
    change G ((torsionRestrictEquiv G ^ n) x : M) = _
    rw [ih]

lemma torsion_period [Module.Finite ℤ M] :
    ∃ n : ℕ, 0 < n ∧ ∀ x ∈ Submodule.torsion ℤ M, (G ^ n) x = x := by
  classical
  have : Finite (Submodule.torsion ℤ M) :=
    Module.finite_of_fg_torsion _ (Submodule.torsion_isTorsion)
  have : Finite ((Submodule.torsion ℤ M) ≃ₗ[ℤ] (Submodule.torsion ℤ M)) :=
    Finite.of_injective (fun f => (f : (Submodule.torsion ℤ M) → (Submodule.torsion ℤ M)))
      DFunLike.coe_injective
  let H := torsionRestrictEquiv G
  refine ⟨orderOf H, orderOf_pos H, ?_⟩
  intro x hx
  have hh := congrArg (fun f : (Submodule.torsion ℤ M) ≃ₗ[ℤ]
      (Submodule.torsion ℤ M) => ((f ⟨x, hx⟩ : Submodule.torsion ℤ M) : M))
      (pow_orderOf_eq_one H)
  change ((torsionRestrictEquiv G ^ orderOf H) ⟨x, hx⟩ : M) = x at hh
  rw [torsionRestrictEquiv_pow] at hh
  exact hh

end Torsion

section CyclicLattice
open scoped TensorProduct
variable {M : Type*} [AddCommGroup M] (G : M ≃ₗ[ℤ] M) (l : M)

lemma eigenfunctional_generator_ne_zero
    (hspan : Submodule.span ℤ (Set.range fun n : ℤ => (G ^ n) l) = ⊤)
    (φ : M →+ ℂ) (hφ : φ ≠ 0) (ζ : ℂ) (hζ : ζ ≠ 0)
    (heigen : ∀ x, φ (G x) = ζ * φ x) : φ l ≠ 0 := by
  intro hl
  have horbit (n : ℤ) : φ ((G ^ n) l) = 0 := by
    induction n using Int.induction_on with
    | zero => simpa using hl
    | succ n ih =>
      rw [add_comm (n : ℤ), zpow_add, zpow_one, LinearEquiv.mul_apply, heigen, ih, mul_zero]
    | pred n ih =>
      have heq : G * G ^ (-(n : ℤ) - 1) = G ^ (-(n : ℤ)) := by
        calc
          G * G ^ (-(n : ℤ) - 1) = G ^ (1 : ℤ) * G ^ (-(n : ℤ) - 1) := by rw [zpow_one]
          _ = G ^ (1 + (-(n : ℤ) - 1)) := by rw [zpow_add]
          _ = G ^ (-(n : ℤ)) := by congr 1; omega
      have hh := heigen ((G ^ (-(n : ℤ) - 1)) l)
      rw [← LinearEquiv.mul_apply, heq, ih] at hh
      exact (mul_eq_zero.mp hh.symm).resolve_left hζ
  have hker : Submodule.span ℤ (Set.range fun n : ℤ => (G ^ n) l) ≤
      φ.toIntLinearMap.ker := by
    apply Submodule.span_le.mpr
    rintro _ ⟨n, rfl⟩
    exact horbit n
  rw [hspan] at hker
  exact hφ (by ext x; exact hker (Submodule.mem_top : x ∈ (⊤ : Submodule ℤ M)))

variable [Module.Free ℤ M] [Module.Finite ℤ M]

theorem lattice_orbit_alternative
    (hspan : Submodule.span ℤ (Set.range fun n : ℤ => (G ^ n) l) = ⊤) :
    (∃ (φ : M →+ ℂ) (ζ : ℂ), φ l ≠ 0 ∧ 1 < ‖ζ‖ ∧
      ∀ x, φ (G x) = ζ * φ x) ∨
    (∃ N d : ℕ, 0 < N ∧ 0 < d ∧ (G.toLinearMap ^ N - 1) ^ d = 0) := by
  classical
  let V := ℂ ⊗[ℤ] M
  let H : V ≃ₗ[ℂ] V := G.baseChange ℤ ℂ M M
  let p := G.toLinearMap.charpoly
  have hp : p.Monic := G.toLinearMap.charpoly_monic
  have hchar : H.toLinearMap.charpoly = p.map (Int.castRingHom ℂ) := by
    exact G.toLinearMap.charpoly_baseChange ℂ
  have hzero : ∀ ζ ∈ p.aroots ℂ, ζ ≠ 0 := by
    intro ζ hζ hz
    have hr : H.toLinearMap.charpoly.IsRoot ζ := by
      rw [hchar]
      exact (Polynomial.mem_roots (hp.map _).ne_zero).mp hζ
    have he := (Module.End.hasEigenvalue_iff_isRoot_charpoly H.toLinearMap ζ).mpr hr
    obtain ⟨v, hv, hv0⟩ := he.exists_hasEigenvector
    have hh : H v = 0 := by simpa [hz] using Module.End.mem_eigenspace_iff.mp hv
    exact hv0 (H.injective (hh.trans (map_zero H).symm))
  by_cases hex : ∃ ζ ∈ p.aroots ℂ, 1 < ‖ζ‖
  · obtain ⟨ζ, hroot, hζ⟩ := hex
    have hr : H.toLinearMap.dualMap.charpoly.IsRoot ζ := by
      rw [charpoly_dual, hchar]
      exact (Polynomial.mem_roots (hp.map _).ne_zero).mp hroot
    have he := (Module.End.hasEigenvalue_iff_isRoot_charpoly H.toLinearMap.dualMap ζ).mpr hr
    obtain ⟨F, hF⟩ := he.exists_hasEigenvector
    let φ : M →+ ℂ := F.toAddMonoidHom.comp
      (TensorProduct.mk ℤ ℂ M (1 : ℂ)).toAddMonoidHom
    have hφapply (x : M) : φ x = F ((1 : ℂ) ⊗ₜ[ℤ] x) := rfl
    have hφ0 : φ ≠ 0 := by
      intro hh
      apply hF.2
      apply LinearMap.ext
      intro v
      change F v = 0
      induction v using TensorProduct.inductionOn with
      | tmul a x =>
        have hFx : F ((1 : ℂ) ⊗ₜ[ℤ] x) = 0 := by
          change φ x = 0
          simp only [hh, AddMonoidHom.zero_apply]
        rw [show a ⊗ₜ[ℤ] x = a • ((1 : ℂ) ⊗ₜ[ℤ] x) by
          rw [TensorProduct.smul_tmul']; simp, map_smul, hFx, smul_zero]
      | add v w hv hw => rw [map_add, hv, hw, add_zero]
    have heigen (x : M) : φ (G x) = ζ * φ x := by
      have hh := congrArg (fun f : Module.Dual ℂ V => f ((1 : ℂ) ⊗ₜ[ℤ] x))
        hF.apply_eq_smul
      change F (H ((1 : ℂ) ⊗ₜ[ℤ] x)) = ζ * F ((1 : ℂ) ⊗ₜ[ℤ] x) at hh
      exact hh
    exact Or.inl ⟨φ, ζ, eigenfunctional_generator_ne_zero G l hspan φ hφ0 ζ
      (hzero ζ hroot) heigen, hζ, heigen⟩
  · right
    apply quasiUnipotent_of_integer_annihilator G.toLinearMap p hp
      G.toLinearMap.aeval_self_charpoly hzero
    intro ζ hζ
    exact le_of_not_gt (fun hh => hex ⟨ζ, hζ, hh⟩)

end CyclicLattice

lemma nilpotent_pow_sub_one {A : Type*} [Ring A] [Algebra ℤ A]
    (a : A) (d q : ℕ) (h : (a - 1) ^ d = 0) : (a ^ q - 1) ^ d = 0 := by
  have hdiv : ((X : ℤ[X]) - 1) ^ d ∣ (X ^ q - 1) ^ d :=
    pow_dvd_pow_of_dvd (sub_one_dvd_pow_sub_one X q) d
  have hh := Polynomial.aeval_eq_zero_of_dvd_aeval_eq_zero hdiv
    (show aeval a (((X : ℤ[X]) - 1) ^ d) = 0 by simpa using h)
  simpa using hh

lemma linear_semiconj_pow {R M N : Type*} [Semiring R]
    [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R N]
    (q : M →ₗ[R] N) (a : Module.End R M) (b : Module.End R N)
    (h : ∀ x, q (a x) = b (q x)) (n : ℕ) (x : M) :
    q ((a ^ n) x) = (b ^ n) (q x) := by
  induction n with
  | zero => rfl
  | succ n ih => simp only [pow_succ', Module.End.mul_apply, h, ih]

variable {M : Type*} [AddCommGroup M] (G : M ≃ₗ[ℤ] M)

lemma torsionQuotEquiv_zpow_mk (n : ℤ) (x : M) :
    (torsionQuotEquiv G ^ n) ((Submodule.torsion ℤ M).mkQ x) =
      (Submodule.torsion ℤ M).mkQ ((G ^ n) x) := by
  induction n using Int.induction_on generalizing x with
  | zero => rfl
  | succ n ih =>
    simp only [zpow_add, zpow_one, LinearEquiv.mul_apply]
    exact ih (x := G x)
  | pred n ih =>
    simp only [zpow_sub, zpow_one, LinearEquiv.mul_apply]
    exact ih (x := G.symm x)

lemma torsionQuot_cyclic (l : M)
    (hspan : Submodule.span ℤ (Set.range fun n : ℤ => (G ^ n) l) = ⊤) :
    Submodule.span ℤ (Set.range fun n : ℤ =>
      (torsionQuotEquiv G ^ n) ((Submodule.torsion ℤ M).mkQ l)) = ⊤ := by
  let q := (Submodule.torsion ℤ M).mkQ
  have hrange : (Set.range fun n : ℤ => (torsionQuotEquiv G ^ n) (q l)) =
      q '' (Set.range fun n : ℤ => (G ^ n) l) := by
    rw [← Set.range_comp]
    congr 1
    funext n
    exact torsionQuotEquiv_zpow_mk G n l
  rw [hrange, ← Submodule.map_span, hspan, Submodule.map_top]
  exact LinearMap.range_eq_top.mpr (Submodule.mkQ_surjective _)

theorem quasiUnipotent_of_torsionQuot [Module.Finite ℤ M] (N d : ℕ)
    (hN : 0 < N) (_hd : 0 < d)
    (hquot : ((torsionQuotEquiv G).toLinearMap ^ N - 1) ^ d = 0) :
    ∃ p e : ℕ, 0 < p ∧ 0 < e ∧ (G.toLinearMap ^ p - 1) ^ e = 0 := by
  obtain ⟨q, hq, hper⟩ := torsion_period G
  let p := N * q
  have hp : 0 < p := Nat.mul_pos hN hq
  have hquot' : ((torsionQuotEquiv G).toLinearMap ^ p - 1) ^ d = 0 := by
    simpa [p, ← pow_mul] using
      nilpotent_pow_sub_one ((torsionQuotEquiv G).toLinearMap ^ N) d q hquot
  have hper' (x : M) (hx : x ∈ Submodule.torsion ℤ M) : (G ^ p) x = x := by
    change (G ^ (N * q)) x = x
    rw [Nat.mul_comm N q, pow_mul]
    have hfix : ∀ n : ℕ, ((G ^ q) ^ n) x = x := by
      intro n
      induction n with
      | zero => rfl
      | succ n ih => simp only [pow_succ', LinearEquiv.mul_apply, ih, hper x hx]
    exact hfix N
  let π := (Submodule.torsion ℤ M).mkQ
  have hpow (n : ℕ) (x : M) : π ((G.toLinearMap ^ n) x) =
      ((torsionQuotEquiv G).toLinearMap ^ n) (π x) :=
    linear_semiconj_pow π G.toLinearMap (torsionQuotEquiv G).toLinearMap
      (fun _ => rfl) n x
  have hdiff (x : M) : π ((G.toLinearMap ^ p - 1) x) =
      ((torsionQuotEquiv G).toLinearMap ^ p - 1) (π x) := by
    simp only [LinearMap.sub_apply, Module.End.one_apply, map_sub, hpow]
  have himage (x : M) : ((G.toLinearMap ^ p - 1) ^ d) x ∈ Submodule.torsion ℤ M := by
    apply (Submodule.Quotient.mk_eq_zero _).mp
    change π (((G.toLinearMap ^ p - 1) ^ d) x) = 0
    rw [linear_semiconj_pow π _ _ hdiff, hquot', LinearMap.zero_apply]
  refine ⟨p, d + 1, hp, Nat.succ_pos _, ?_⟩
  apply LinearMap.ext
  intro x
  rw [pow_succ', Module.End.mul_apply, LinearMap.sub_apply, Module.End.one_apply,
    LinearMap.zero_apply, sub_eq_zero]
  simpa only [Module.End.pow_apply, LinearEquiv.pow_apply, LinearEquiv.coe_coe] using
    hper' (((G.toLinearMap ^ p - 1) ^ d) x) (himage x)

theorem fg_cyclic_orbit_alternative [Module.Finite ℤ M] (l : M)
    (hspan : Submodule.span ℤ (Set.range fun n : ℤ => (G ^ n) l) = ⊤) :
    (∃ (φ : M →+ ℂ) (ζ : ℂ), φ l ≠ 0 ∧ 1 < ‖ζ‖ ∧
      ∀ x, φ (G x) = ζ * φ x) ∨
    (∃ N d : ℕ, 0 < N ∧ 0 < d ∧ (G.toLinearMap ^ N - 1) ^ d = 0) := by
  let π := (Submodule.torsion ℤ M).mkQ
  rcases lattice_orbit_alternative (torsionQuotEquiv G) (π l)
      (torsionQuot_cyclic G l hspan) with h | h
  · obtain ⟨φ, ζ, hφ, hζ, heigen⟩ := h
    exact Or.inl ⟨φ.comp π.toAddMonoidHom, ζ, hφ, hζ, fun x => heigen (π x)⟩
  · obtain ⟨N, d, hN, hd, hnil⟩ := h
    exact Or.inr (quasiUnipotent_of_torsionQuot G N d hN hd hnil)

end

open scoped BigOperators
section
variable {L : Type*} [AddCommGroup L] (G : L ≃ₗ[ℤ] L) (l : L)

noncomputable def cyclicOrbit : Submodule ℤ L :=
  Submodule.span ℤ (Set.range fun n : ℤ => (G ^ n) l)

noncomputable def initialOrbit (q : ℕ) : Submodule ℤ L :=
  Submodule.span ℤ ((fun n : ℕ => (G ^ n) l) '' {n | n < q})

lemma mem_initialOrbit {q i : ℕ} (hi : i < q) :
    (G ^ i) l ∈ initialOrbit G l q :=
  Submodule.subset_span ⟨i, hi, rfl⟩

theorem cyclicOrbit_fg_of_boundary (q : ℕ) (hq : 0 < q)
    (hupper : (G ^ q) l ∈ initialOrbit G l q)
    (hlower : G.symm l ∈ initialOrbit G l q) :
    (cyclicOrbit G l).FG := by
  let M := initialOrbit G l q
  have hforward : M ≤ M.comap G.toLinearMap := by
    apply Submodule.span_le.mpr
    rintro _ ⟨i, hi, rfl⟩
    change G ((G ^ i) l) ∈ M
    rw [← LinearEquiv.mul_apply, ← pow_succ']
    have hle : i + 1 ≤ q := hi
    rcases lt_or_eq_of_le hle with hlt | heq
    · exact mem_initialOrbit G l hlt
    · simpa [heq] using hupper
  have hbackward : M ≤ M.comap G.symm.toLinearMap := by
    apply Submodule.span_le.mpr
    rintro _ ⟨i, hi, rfl⟩
    change G.symm ((G ^ i) l) ∈ M
    cases i with
    | zero => simpa using hlower
    | succ i =>
      rw [pow_succ', LinearEquiv.mul_apply, G.symm_apply_apply]
      exact mem_initialOrbit G l (Nat.lt_trans (Nat.lt_succ_self i) hi)
  have hzero : l ∈ M := by simpa using mem_initialOrbit G l hq
  have horbit (n : ℤ) : (G ^ n) l ∈ M := by
    induction n using Int.induction_on with
    | zero => simpa using hzero
    | succ n ih =>
      have hh := hforward ih
      change G ((G ^ (n : ℤ)) l) ∈ M at hh
      simpa only [← LinearEquiv.mul_apply, ← zpow_one_add, add_comm] using hh
    | pred n ih =>
      have hh := hbackward ih
      change G.symm ((G ^ (-(n : ℤ))) l) ∈ M at hh
      have heq : G.symm * G ^ (-(n : ℤ)) = G ^ (-(n : ℤ) - 1) := by
        change G⁻¹ * G ^ (-(n : ℤ)) = _
        rw [← zpow_neg_one, ← zpow_add]
        congr 1
        omega
      rw [← LinearEquiv.mul_apply, heq] at hh
      convert hh using 1
  have hEq : cyclicOrbit G l = M := by
    apply le_antisymm
    · exact Submodule.span_le.mpr (by rintro _ ⟨n, rfl⟩; exact horbit n)
    · apply Submodule.span_le.mpr
      rintro _ ⟨i, _, rfl⟩
      exact Submodule.subset_span ⟨(i : ℤ), by simp⟩
  rw [hEq]
  exact Submodule.fg_span ((Set.finite_Iio q).image _)

theorem cyclicOrbit_fg_of_relation (q : ℕ) (hq : 0 < q) (b : ℕ → ℤ)
    (hb0 : b 0 = 1 ∨ b 0 = -1) (hbq : b q = 1 ∨ b q = -1)
    (hrel : ∑ i ∈ Finset.range (q + 1), b i • (G ^ i) l = 0) :
    (cyclicOrbit G l).FG := by
  apply cyclicOrbit_fg_of_boundary G l q hq
  · have hs : (∑ i ∈ Finset.range q, b i • (G ^ i) l) ∈ initialOrbit G l q := by
      apply Submodule.sum_mem
      intro i hi
      exact Submodule.smul_mem _ _ (mem_initialOrbit G l (Finset.mem_range.mp hi))
    rw [Finset.sum_range_succ] at hrel
    have hh : b q • (G ^ q) l ∈ initialOrbit G l q := by
      rw [eq_neg_of_add_eq_zero_right hrel]
      exact Submodule.neg_mem _ hs
    rcases hbq with h | h <;> simpa [h] using hh
  · have hs : (∑ i ∈ Finset.range q, b (i + 1) • (G ^ i) l) ∈
        initialOrbit G l q := by
      apply Submodule.sum_mem
      intro i hi
      exact Submodule.smul_mem _ _ (mem_initialOrbit G l (Finset.mem_range.mp hi))
    rw [Finset.sum_range_succ'] at hrel
    have hh := congrArg G.symm hrel
    simp only [map_add, map_sum, map_zsmul, pow_zero,
      pow_succ', LinearEquiv.mul_apply, G.symm_apply_apply, map_zero] at hh
    change (∑ x ∈ Finset.range q, b (x + 1) • (G ^ x) l) + b 0 • G.symm l = 0 at hh
    have hb : b 0 • G.symm l ∈ initialOrbit G l q := by
      rw [eq_neg_of_add_eq_zero_right hh]
      exact Submodule.neg_mem _ hs
    rcases hb0 with h | h <;> simpa [h] using hb

lemma cyclicOrbit_shift (m : ℕ) : cyclicOrbit G ((G ^ m) l) = cyclicOrbit G l := by
  unfold cyclicOrbit
  congr 1
  ext x
  constructor
  · rintro ⟨n, rfl⟩
    refine ⟨n + (m : ℤ), ?_⟩
    change (G ^ (n + (m : ℤ))) l = (G ^ n) ((G ^ m) l)
    rw [zpow_add, LinearEquiv.mul_apply, zpow_natCast]
  · rintro ⟨n, rfl⟩
    refine ⟨n - (m : ℤ), ?_⟩
    change (G ^ (n - (m : ℤ))) ((G ^ m) l) = (G ^ n) l
    rw [← zpow_natCast G m, ← LinearEquiv.mul_apply, ← zpow_add, sub_add_cancel]

theorem cyclicOrbit_fg_of_signed_relation (s : Finset ℕ) (hs : s.Nonempty)
    (ε : ℕ → Bool) (hrel : (∑ i ∈ s, if ε i then (G ^ i) l else -((G ^ i) l)) = 0) :
    (cyclicOrbit G l).FG := by
  classical
  let m := s.min' hs
  let M := s.max' hs
  let q := M - m
  let v := (G ^ m) l
  let b : ℕ → ℤ := fun i => if m + i ∈ s then (if ε (m + i) then 1 else -1) else 0
  let f : ℕ → L := fun i => if i ∈ s then (if ε i then (G ^ i) l else -((G ^ i) l)) else 0
  have hm : m ∈ s := Finset.min'_mem s hs
  have hM : M ∈ s := Finset.max'_mem s hs
  have hmM : m ≤ M := Finset.min'_le s M hM
  have hmq : m + q = M := by dsimp [q]; omega
  have hsub : s ⊆ Finset.Ico m (M + 1) := by
    intro i hi
    exact Finset.mem_Ico.mpr ⟨Finset.min'_le s i hi,
      Nat.lt_succ_of_le (Finset.le_max' s i hi)⟩
  have hsum : (∑ i ∈ Finset.Ico m (M + 1), f i) = 0 := by
    rw [← Finset.sum_subset hsub (by intro i _ hi; simp [f, hi])]
    simpa only [f, Finset.sum_congr rfl (fun i hi => ite_eq_left hi)] using hrel
  have hb0 : b 0 = 1 ∨ b 0 = -1 := by simp only [b, Nat.add_zero, ite_eq_left hm]; split <;> simp
  have hbq : b q = 1 ∨ b q = -1 := by simp only [b, hmq, ite_eq_left hM]; split <;> simp
  have hnormalized : (∑ i ∈ Finset.range (q + 1), b i • (G ^ i) v) = 0 := by
    have hcount : M + 1 - m = q + 1 := by dsimp [q]; omega
    rw [Finset.sum_Ico_eq_sum_range, hcount] at hsum
    convert hsum using 1
    apply Finset.sum_congr rfl
    intro i _
    dsimp [b, f, v]
    split_ifs with hi hε
    · simp only [one_smul, ← LinearEquiv.mul_apply, ← pow_add, Nat.add_comm]
    · simp only [neg_one_smul, ← LinearEquiv.mul_apply, ← pow_add, Nat.add_comm]
    · simp only [zero_smul]
  have hv : (cyclicOrbit G v).FG := by
    rcases Nat.eq_zero_or_pos q with hq | hq
    · have hb : b 0 • v = 0 := by simpa [hq] using hnormalized
      have hv0 : v = 0 := by rcases hb0 with h | h <;> simpa [h] using hb
      simp only [hv0, cyclicOrbit, map_zero, Set.range_const, Submodule.span_singleton_eq_bot.mpr rfl]
      exact Submodule.fg_bot
    · exact cyclicOrbit_fg_of_relation G v q hq b hb0 hbq hnormalized
  simpa only [v, cyclicOrbit_shift] using hv

end

section OrbitGrowth
variable {L : Type*} [AddCommGroup L]

theorem dissociated_of_geometric_functional (l : ℕ → L) (φ : L →+ ℂ)
    (a ζ : ℂ) (ha : a ≠ 0) (hζ : 2 < ‖ζ‖)
    (hφ : ∀ m, φ (l m) = a * ζ ^ m) : Dissociated l := by
  classical
  intro s hs ε heq
  let m := s.max' hs
  have hm : m ∈ s := Finset.max'_mem s hs
  have hrel : (∑ i ∈ s, if ε i then a * ζ ^ i else -(a * ζ ^ i)) = 0 := by
    have hh := congrArg φ heq
    simpa only [map_sum, apply_ite, map_neg, map_zero, hφ] using hh
  have heq' : (if ε m then a * ζ ^ m else -(a * ζ ^ m)) =
      -(∑ i ∈ s.erase m, if ε i then a * ζ ^ i else -(a * ζ ^ i)) := by
    rw [← Finset.sum_erase_add _ _ hm] at hrel
    exact eq_neg_of_add_eq_zero_left (by simpa [add_comm] using hrel)
  have hsmall : s.erase m ⊆ Finset.range m := by
    intro i hi
    have his := Finset.mem_of_mem_erase hi
    have hne := (Finset.mem_erase.mp hi).1
    exact Finset.mem_range.mpr (lt_of_le_of_ne (Finset.le_max' s i his) hne)
  have hbound : ‖a‖ * ‖ζ‖ ^ m ≤ ‖a‖ * ∑ i ∈ Finset.range m, ‖ζ‖ ^ i := by
    calc
      _ = ‖if ε m then a * ζ ^ m else -(a * ζ ^ m)‖ := by
        split <;> simp [norm_pow]
      _ = ‖∑ i ∈ s.erase m, if ε i then a * ζ ^ i else -(a * ζ ^ i)‖ := by
        rw [heq', norm_neg]
      _ ≤ ∑ i ∈ s.erase m, ‖if ε i then a * ζ ^ i else -(a * ζ ^ i)‖ := norm_sum_le _ _
      _ = ∑ i ∈ s.erase m, ‖a‖ * ‖ζ‖ ^ i := by
        apply Finset.sum_congr rfl
        intro i _
        split <;> simp [norm_pow]
      _ ≤ ∑ i ∈ Finset.range m, ‖a‖ * ‖ζ‖ ^ i :=
        Finset.sum_le_sum_of_subset_of_nonneg hsmall (fun _ _ _ => by positivity)
      _ = _ := by rw [Finset.mul_sum]
  have hsum : (∑ i ∈ Finset.range m, ‖ζ‖ ^ i) < ‖ζ‖ ^ m := by
    induction m with
    | zero => simp
    | succ m ih =>
      rw [Finset.sum_range_succ, pow_succ]
      have hp : 0 < ‖ζ‖ ^ m := pow_pos (lt_trans (by norm_num) hζ) m
      nlinarith
  have ha' : 0 < ‖a‖ := norm_pos_iff.mpr ha
  exact (not_lt_of_ge hbound) (mul_lt_mul_of_pos_left hsum ha')

theorem dissociated_progressions_of_eigenfunctional (G : L → L) (l : L)
    (φ : L →+ ℂ) (ζ : ℂ) (hl : φ l ≠ 0) (hζ : 1 < ‖ζ‖)
    (heigen : ∀ v, φ (G v) = ζ * φ v) :
    ∃ p : ℕ, 0 < p ∧ ∀ j : ℕ,
      Dissociated (fun m => G^[p * m + j] l) := by
  obtain ⟨p, hp⟩ := pow_unbounded_of_one_lt (2 : ℝ) hζ
  have hp0 : 0 < p := by
    by_contra hh
    have : p = 0 := Nat.eq_zero_of_not_pos hh
    simp [this] at hp
  have hφ (n : ℕ) : φ (G^[n] l) = φ l * ζ ^ n := by
    induction n with
    | zero => simp
    | succ n ih =>
      rw [Function.iterate_succ_apply', heigen, ih, pow_succ]
      ring
  refine ⟨p, hp0, fun j => ?_⟩
  apply dissociated_of_geometric_functional _ φ (φ l * ζ ^ j) (ζ ^ p)
  · exact mul_ne_zero hl (pow_ne_zero _ (by intro hh; norm_num [hh] at hζ))
  · simpa only [norm_pow] using hp
  · intro m
    rw [hφ, pow_add, pow_mul]
    ring


theorem differencePolynomial_of_nilpotent_difference (G : Module.End ℤ L)
    (d : ℕ) (l : L) (h : ((G - 1) ^ (d + 1)) l = 0) :
    DifferencePolynomial d (fun m => (G ^ m) l) := by
  induction d generalizing l with
  | zero =>
    have hl : G l = l := by
      simpa only [zero_add, pow_one, LinearMap.sub_apply, Module.End.one_apply,
        sub_eq_zero] using h
    refine ⟨l, ?_⟩
    intro m
    induction m with
    | zero => rfl
    | succ m ih => simpa only [pow_succ, Module.End.mul_apply, hl] using ih
  | succ d ih =>
    apply DifferencePolynomial.of_forward_difference
    have hn : ((G - 1) ^ (d + 1)) ((G - 1) l) = 0 := by
      simpa only [pow_succ, Module.End.mul_apply] using h
    have hp := ih ((G - 1) l) hn
    convert hp using 1
    funext m
    simp only [pow_succ, Module.End.mul_apply, LinearMap.sub_apply,
      Module.End.one_apply, map_sub]

theorem polynomial_progressions_of_nilpotent (G : Module.End ℤ L)
    (p d : ℕ) (h : (G ^ p - 1) ^ (d + 1) = 0) (l : L) (j : ℕ) :
    DifferencePolynomial d (fun m => (G ^ (p * m + j)) l) := by
  have hn : ((G ^ p - 1) ^ (d + 1)) ((G ^ j) l) = 0 := by rw [h]; rfl
  have hp := differencePolynomial_of_nilpotent_difference (G ^ p) d ((G ^ j) l) hn
  convert hp using 1
  funext m
  rw [pow_add, pow_mul, Module.End.mul_apply]

end OrbitGrowth

section
variable {L : Type*} [AddCommGroup L] (G : L ≃ₗ[ℤ] L) (l : L)

lemma cyclicOrbit_zpow_mem (m : ℤ) {x : L} (hx : x ∈ cyclicOrbit G l) :
    (G ^ m) x ∈ cyclicOrbit G l := by
  induction hx using Submodule.span_induction with
  | mem y hy =>
    obtain ⟨n, rfl⟩ := hy
    apply Submodule.subset_span
    exact ⟨m + n, by dsimp; rw [zpow_add, LinearEquiv.mul_apply]⟩
  | zero => simpa only [map_zero] using (zero_mem (cyclicOrbit G l))
  | add x y _ _ hx hy => simpa only [map_add] using Submodule.add_mem _ hx hy
  | smul a x _ hx => simpa only [map_smul] using Submodule.smul_mem _ a hx

lemma cyclicOrbit_apply_mem {x : L} (hx : x ∈ cyclicOrbit G l) :
    G x ∈ cyclicOrbit G l := by simpa using cyclicOrbit_zpow_mem G l 1 hx

lemma cyclicOrbit_symm_apply_mem {x : L} (hx : x ∈ cyclicOrbit G l) :
    G.symm x ∈ cyclicOrbit G l := by simpa using cyclicOrbit_zpow_mem G l (-1) hx

noncomputable def cyclicOrbitEquiv : cyclicOrbit G l ≃ₗ[ℤ] cyclicOrbit G l where
  toFun x := ⟨G x, cyclicOrbit_apply_mem G l x.property⟩
  invFun x := ⟨G.symm x, cyclicOrbit_symm_apply_mem G l x.property⟩
  left_inv x := by ext; exact G.symm_apply_apply x
  right_inv x := by ext; exact G.apply_symm_apply x
  map_add' x y := by ext; exact map_add G _ _
  map_smul' a x := by ext; exact map_smul G a (x : L)

lemma cyclicOrbitEquiv_zpow_coe (n : ℤ) (x : cyclicOrbit G l) :
    ((cyclicOrbitEquiv G l ^ n) x : L) = (G ^ n) x := by
  induction n using Int.induction_on generalizing x with
  | zero => rfl
  | succ n ih =>
    simp only [zpow_add, zpow_one, LinearEquiv.mul_apply]
    exact ih (cyclicOrbitEquiv G l x)
  | pred n ih =>
    simp only [zpow_sub, zpow_one, LinearEquiv.mul_apply]
    exact ih ((cyclicOrbitEquiv G l).symm x)

lemma cyclicOrbitEquiv_pow_coe (n : ℕ) (x : cyclicOrbit G l) :
    ((cyclicOrbitEquiv G l ^ n) x : L) = (G ^ n) x := by
  simpa only [zpow_natCast] using cyclicOrbitEquiv_zpow_coe G l (n : ℤ) x

noncomputable def cyclicGenerator : cyclicOrbit G l :=
  ⟨l, Submodule.subset_span ⟨0, by simp⟩⟩

lemma cyclicGenerator_spans : Submodule.span ℤ (Set.range fun n : ℤ =>
    (cyclicOrbitEquiv G l ^ n) (cyclicGenerator G l)) = ⊤ := by
  apply (Submodule.span_val_image_eq_iff (cyclicOrbit G l) _).mp
  rw [← Set.range_comp]
  have heq : (Subtype.val ∘ fun n : ℤ =>
      (cyclicOrbitEquiv G l ^ n) (cyclicGenerator G l)) = fun n : ℤ => (G ^ n) l := by
    funext n
    exact cyclicOrbitEquiv_zpow_coe G l n (cyclicGenerator G l)
  rw [heq]
  rfl

lemma Dissociated.of_injective_map {A B : Type*} [AddCommGroup A] [AddCommGroup B]
    (f : A →+ B) (hf : Function.Injective f) (a : ℕ → A)
    (h : Dissociated a) : Dissociated (fun n => f (a n)) := by
  intro s hs ε hzero
  apply h s hs ε
  apply hf
  rw [map_zero, map_sum]
  convert hzero using 1
  apply Finset.sum_congr rfl
  intro i _
  split <;> simp only [map_neg]

theorem orbit_alternatives :
    Dissociated (fun r : ℕ => (G ^ r) l) ∨
    (∃ p : ℕ, 0 < p ∧ ∀ j : ℕ, Dissociated (fun m => (G ^ (p * m + j)) l)) ∨
    (∃ p d : ℕ, 0 < p ∧ 0 < d ∧
      ((cyclicOrbitEquiv G l).toLinearMap ^ p - 1) ^ d = 0) := by
  classical
  by_cases hdiss : Dissociated (fun r : ℕ => (G ^ r) l)
  · exact Or.inl hdiss
  · right
    simp only [Dissociated, not_forall, exists_prop, not_ne_iff] at hdiss
    obtain ⟨s, hs, ε, hrel⟩ := hdiss
    have hfg := cyclicOrbit_fg_of_signed_relation G l s hs ε hrel
    have : Module.Finite ℤ (cyclicOrbit G l) := Module.Finite.of_fg hfg
    rcases fg_cyclic_orbit_alternative (cyclicOrbitEquiv G l) (cyclicGenerator G l)
        (cyclicGenerator_spans G l) with h | h
    · obtain ⟨φ, ζ, hφ, hζ, heigen⟩ := h
      obtain ⟨p, hp, hd⟩ := dissociated_progressions_of_eigenfunctional
        (cyclicOrbitEquiv G l) (cyclicGenerator G l) φ ζ hφ hζ heigen
      refine Or.inl ⟨p, hp, fun j => ?_⟩
      have hh := Dissociated.of_injective_map (cyclicOrbit G l).subtype.toAddMonoidHom
        (cyclicOrbit G l).injective_subtype _ (hd j)
      have heq (n : ℕ) : (((cyclicOrbitEquiv G l)^[n]) (cyclicGenerator G l) : L) =
          (G ^ n) l := by
        rw [← LinearEquiv.pow_apply]
        exact cyclicOrbitEquiv_pow_coe G l n (cyclicGenerator G l)
      change Dissociated (fun n => (((cyclicOrbitEquiv G l)^[p * n + j])
        (cyclicGenerator G l) : L)) at hh
      simpa only [heq] using hh
    · exact Or.inr h

end

section
open MeasureTheory Filter
open scoped BigOperators Topology ComplexConjugate

theorem cesaro_zero_of_progressions (a : ℕ → ℝ) (ha : ∀ n, 0 ≤ a n)
    (p : ℕ) (hp : 0 < p)
    (h : ∀ j < p, Tendsto (fun N : ℕ =>
      (∑ m ∈ Finset.range N, a (p * m + j)) / N) atTop (𝓝 0)) :
    Tendsto (fun N : ℕ => (∑ m ∈ Finset.range N, a m) / N) atTop (𝓝 0) := by
  have hblock (N : ℕ) : (∑ m ∈ Finset.range (p * N), a m) =
      ∑ m ∈ Finset.range N, ∑ j ∈ Finset.range p, a (p * m + j) := by
    induction N with
    | zero => simp
    | succ N ih =>
      rw [Nat.mul_succ, Finset.sum_range_add, ih, Finset.sum_range_succ]
  have hsum := tendsto_finsetSum (Finset.range p) (fun j hj => h j (Finset.mem_range.mp hj))
  simp only [Finset.sum_const_zero] at hsum
  apply squeeze_zero (fun N => div_nonneg
    (Finset.sum_nonneg (fun m _ => ha m)) (Nat.cast_nonneg N)) (fun N => ?_) hsum
  rw [← Finset.sum_div, Finset.sum_comm, ← hblock]
  apply div_le_div_of_nonneg_right _ (Nat.cast_nonneg N)
  exact Finset.sum_le_sum_of_subset_of_nonneg
    (Finset.range_mono (by simpa using Nat.mul_le_mul_right N hp))
    (fun m _ _ => ha m)

namespace DifferencePolynomial

theorem map {A B : Type*} [AddCommGroup A] [AddCommGroup B]
    (f : A →+ B) {d : ℕ} {P : ℕ → A} (h : DifferencePolynomial d P) :
    DifferencePolynomial d (fun m => f (P m)) := by
  induction d generalizing P with
  | zero => obtain ⟨l, hl⟩ := h; exact ⟨f l, fun m => congrArg f (hl m)⟩
  | succ d ih =>
    intro s hs
    simpa only [map_sub] using ih (h s hs)
end DifferencePolynomial

theorem wordEntropy_comp {X Y A : Type*} [MeasurableSpace X] [MeasurableSpace Y]
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
    {μ : Measure X} [IsProbabilityMeasure μ] {η : Measure Y} [IsProbabilityMeasure η]
    (x : Y → X) (hx : MeasurePreserving x η μ)
    (F : ℕ → X → A) (hF : ∀ m, Measurable (F m)) (n : ℕ) :
    wordEntropy (η := η) (fun m y => F m (x y)) n = wordEntropy (η := μ) F n := by
  unfold wordEntropy shannonEntropy
  apply Finset.sum_congr rfl
  intro w _
  have he : η.real (entropyWord (fun m y => F m (x y)) n ⁻¹' {w}) =
      μ.real (entropyWord F n ⁻¹' {w}) := hx.measureReal_preimage
    ((Measurable.of_eval (fun _ => hF _)) (measurableSet_singleton w)).nullMeasurableSet
  dsimp only
  rw [he]


theorem orbit_cancellation_unit
    {X Y L A : Type*} [MeasurableSpace X] [MeasurableSpace Y] [AddCommGroup L]
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
    {μ : Measure X} [IsProbabilityMeasure μ]
    {η : Measure Y} [IsProbabilityMeasure η]
    (x : Y → X) (hx : MeasurePreserving x η μ)
    (t : ℕ → X → X) (ht : ∀ m, MeasurePreserving (t m) μ μ)
    (htadd : ∀ a b z, t (a + b) z = t b (t a z))
    (hmix : ∀ A B : Set X, MeasurableSet A → MeasurableSet B →
      Tendsto (fun m => μ (A ∩ t m ⁻¹' B)) atTop (𝓝 (μ A * μ B)))
    (a : X → A) (ha : Measurable a) (v : A → ℂ) (hv : ∀ b, ‖v b‖ ≤ 1)
    (hcenter : ∫ z, v (a z) ∂μ = 0)
    (hH : Tendsto (fun n : ℕ => wordEntropy (η := μ) (fun m z => a (t m z)) n / n)
      atTop (𝓝 0))
    {χ : L → Y → ℂ} (hχ : ProjectiveCharacters η χ)
    (G : L ≃ₗ[ℤ] L) (l : L) :
    Tendsto (fun N : ℕ => (∑ m ∈ Finset.range N,
      ‖∫ y, v (a (t m (x y))) * conj (χ ((G ^ m) l) y) ∂η‖) / N)
      atTop (𝓝 0) := by
  have haw (m : ℕ) : Measurable (fun y => a (t m (x y))) :=
    ha.comp ((ht m).measurable.comp hx.measurable)
  have hHy : Tendsto (fun n : ℕ =>
      wordEntropy (η := η) (fun m y => a (t m (x y))) n / n) atTop (𝓝 0) := by
    have he (n : ℕ) := wordEntropy_comp x hx (fun m z => a (t m z))
      (fun m => ha.comp (ht m).measurable) n
    simpa only [he] using hH
  rcases orbit_alternatives G l with hd | ⟨p, hp, hd⟩ | ⟨p, d, hp, hd, hn⟩
  · exact entropy_cancellation hχ _ hd _ haw v hv hHy
  · apply cesaro_zero_of_progressions _ (fun _ => norm_nonneg _) p hp
    intro j _
    exact entropy_cancellation hχ _ (hd j) _ (fun m => haw (p * m + j)) v hv
      (zero_entropy_progression _ haw hHy p hp j)
  · obtain ⟨d, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hd.ne'
    have hpm : Tendsto (fun m : ℕ => p * m) atTop atTop :=
      tendsto_atTop_mono (fun m => by simpa using Nat.mul_le_mul_right m hp) tendsto_id
    apply cesaro_zero_of_progressions _ (fun _ => norm_nonneg _) p hp
    intro j _
    have hpoly := polynomial_progressions_of_nilpotent
      (cyclicOrbitEquiv G l).toLinearMap p d hn (cyclicGenerator G l) j
    have hmap := hpoly.map (cyclicOrbit G l).subtype.toAddMonoidHom
    have heq (m : ℕ) : ((cyclicOrbitEquiv G l).toLinearMap ^ m) (cyclicGenerator G l) =
        (cyclicOrbitEquiv G l ^ m) (cyclicGenerator G l) := by
      rw [Module.End.pow_apply, LinearEquiv.coe_coe, ← LinearEquiv.pow_apply]
    have hpolyl : DifferencePolynomial d (fun m => (G ^ (p * m + j)) l) := by
      convert hmap using 1
      funext m
      change (G ^ (p * m + j)) l =
        (((cyclicOrbitEquiv G l).toLinearMap ^ (p * m + j)) (cyclicGenerator G l) : L)
      rw [heq, cyclicOrbitEquiv_pow_coe]
      rfl
    have hfm : AEStronglyMeasurable (fun z => v (a z)) μ :=
      ((measurable_of_finite v).comp ha).aestronglyMeasurable
    have hfmj := hfm.comp_measurePreserving (ht j)
    have hfj0 : ∫ z, v (a (t j z)) ∂μ = 0 := by
      have hh := integral_map (μ := μ) (f := fun z => v (a z))
        (ht j).measurable.aemeasurable (by rw [(ht j).map_eq]; exact hfm)
      simpa only [(ht j).map_eq, hcenter] using hh.symm
    have hc := polynomial_cancellation x hx (fun m => t (p * m)) (fun m => ht (p * m)) hχ
      (fun b c z => by rw [Nat.mul_add, htadd])
      (fun A B hA hB => (hmix A B hA hB).comp hpm) d _ hpolyl hfmj zero_le_one
      (Eventually.of_forall (fun z => hv (a (t j z)))) hfj0
    simpa only [Function.comp_apply, htadd, div_eq_mul_inv, mul_comm] using hc

end

open MeasureTheory Filter
open scoped BigOperators Topology ComplexConjugate

theorem orbit_cancellation
    {X Y L A : Type*} [MeasurableSpace X] [MeasurableSpace Y] [AddCommGroup L]
    [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
    {μ : Measure X} [IsProbabilityMeasure μ]
    {η : Measure Y} [IsProbabilityMeasure η]
    (x : Y → X) (hx : MeasurePreserving x η μ)
    (t : ℕ → X → X) (ht : ∀ m, MeasurePreserving (t m) μ μ)
    (htadd : ∀ a b z, t (a + b) z = t b (t a z))
    (hmix : ∀ A B : Set X, MeasurableSet A → MeasurableSet B →
      Tendsto (fun m => μ (A ∩ t m ⁻¹' B)) atTop (𝓝 (μ A * μ B)))
    (a : X → A) (ha : Measurable a) (v : A → ℂ)
    (hcenter : ∫ z, v (a z) ∂μ = 0)
    (hH : Tendsto (fun n : ℕ => wordEntropy (η := μ) (fun m z => a (t m z)) n / n)
      atTop (𝓝 0))
    {χ : L → Y → ℂ} (hχ : ProjectiveCharacters η χ)
    (G : L ≃ₗ[ℤ] L) (l : L) :
    Tendsto (fun N : ℕ => (N : ℝ)⁻¹ * ∑ m ∈ Finset.range N,
      ‖∫ y, v (a (t m (x y))) * conj (χ ((G ^ m) l) y) ∂η‖)
      atTop (𝓝 0) := by
  let C : ℝ := (∑ b, ‖v b‖) + 1
  have hC : 0 < C := by
    have : 0 ≤ ∑ b, ‖v b‖ := Finset.sum_nonneg (fun _ _ => norm_nonneg _)
    dsimp only [C]
    linarith
  have hCn : (C : ℂ) ≠ 0 := by exact_mod_cast hC.ne'
  let w (b : A) : ℂ := (C : ℂ)⁻¹ * v b
  have hw (b : A) : ‖w b‖ ≤ 1 := by
    have hb := Finset.single_le_sum (fun b _ => norm_nonneg (v b)) (Finset.mem_univ b)
    change ‖(C : ℂ)⁻¹ * v b‖ ≤ 1
    rw [norm_mul, norm_inv, Complex.norm_real, Real.norm_of_nonneg hC.le, mul_comm,
      ← div_eq_mul_inv, div_le_one hC]
    dsimp only [C]
    linarith
  have hw0 : ∫ z, w (a z) ∂μ = 0 := by
    simp only [w, integral_const_mul, hcenter, mul_zero]
  have hlim := orbit_cancellation_unit x hx t ht htadd hmix a ha w hw hw0 hH hχ G l
  have he (b : A) : v b = (C : ℂ) * w b := by simp [w, hCn]
  have hecor (m : ℕ) : ‖∫ y, v (a (t m (x y))) * conj (χ ((G ^ m) l) y) ∂η‖ =
      C * ‖∫ y, w (a (t m (x y))) * conj (χ ((G ^ m) l) y) ∂η‖ := by
    simp_rw [he, mul_assoc, integral_const_mul]
    rw [norm_mul, Complex.norm_real, Real.norm_of_nonneg hC.le]
  have hh := hlim.const_mul C
  simp only [mul_zero] at hh
  convert hh using 1
  funext N
  simp only [hecor, ← Finset.mul_sum, div_eq_mul_inv]
  ring


end Rokhlin

end OAI