Download data/lean/OAI/Dynamics/MultipleMixing/Foundations.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 106 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/MultipleMixing/Foundations.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/MultipleMixing/Foundations.lean
-
curl -L -o Foundations.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/MultipleMixing/Foundations.lean
106 kB
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
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 ∂η) =