Download data/lean/OAI/Dynamics/MultipleMixing/Entropy.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 75.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/MultipleMixing/Entropy.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/MultipleMixing/Entropy.lean
-
curl -L -o Entropy.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/MultipleMixing/Entropy.lean
75.3 kB
import OAI.Dynamics.MultipleMixing.Foundations
namespace OAI
noncomputable section
namespace Rokhlin
section
open MeasureTheory Filter
open scoped BigOperators Topology
variable {A B C : Type*} [Fintype A] [Fintype B] [Fintype C]
lemma shannonEntropy_eq_negMulLog (p : A → ℝ) :
shannonEntropy p = ∑ a, Real.negMulLog (p a) := rfl
def rowEntropy (p : A → ℝ) : ℝ :=
shannonEntropy p - Real.negMulLog (∑ a, p a)
lemma rowEntropy_zero : rowEntropy (fun _ : A => 0) = 0 := by
simp [rowEntropy,shannonEntropy,Real.negMulLog]
lemma zero_row {p : A → ℝ} (hp : ∀ a, 0 ≤ p a) (h : ∑ a, p a = 0) (a : A) : p a = 0 := by
exact le_antisymm (h ▸ Finset.single_le_sum (fun a _ => hp a) (Finset.mem_univ a)) (hp a)
lemma rowEntropy_normalize (p : A → ℝ) (hp : ∀ a, 0 ≤ p a) :
rowEntropy p = (∑ a, p a) * shannonEntropy (fun a => p a / ∑ a, p a) := by
classical
let w := ∑ a, p a
have hw : 0 ≤ w := Finset.sum_nonneg (fun a _ => hp a)
by_cases hz : w = 0
· have h0 : p = fun _ => 0 := funext (zero_row hp hz)
subst p
simp [rowEntropy_zero]
· have hs : ∑ a, p a / w = 1 := by rw [←Finset.sum_div,div_self hz]
have he (a : A) : Real.negMulLog (p a) =
p a / w * Real.negMulLog w + w * Real.negMulLog (p a / w) := by
conv_lhs => rw [show p a = w * (p a / w) by field_simp]
exact Real.negMulLog_mul _ _
simp only [rowEntropy,shannonEntropy_eq_negMulLog]
change (∑ a, Real.negMulLog (p a)) - Real.negMulLog w = _
simp_rw [he]
rw [Finset.sum_add_distrib,←Finset.sum_mul,hs,one_mul,←Finset.mul_sum]
ring
lemma rowEntropy_sum_le (p : B → A → ℝ) (hp : ∀ b a, 0 ≤ p b a) :
(∑ b, rowEntropy (p b)) ≤ rowEntropy (fun a => ∑ b, p b a) := by
classical
let w (b : B) := ∑ a, p b a
let s := ∑ b, w b
have hw (b : B) : 0 ≤ w b := Finset.sum_nonneg (fun a _ => hp b a)
have hs : 0 ≤ s := Finset.sum_nonneg (fun b _ => hw b)
by_cases hz : s = 0
· have hw0 b : w b = 0 := zero_row hw hz b
have hp0 b a : p b a = 0 := zero_row (hp b) (hw0 b) a
have hpz : p = fun _ _ => 0 := funext fun b => funext (hp0 b)
rw [hpz]
simp only [Finset.sum_const_zero,rowEntropy_zero,le_refl]
· have hspos : 0 < s := lt_of_le_of_ne hs (Ne.symm hz)
have hweights : ∑ b, w b / s = 1 := by rw [←Finset.sum_div,div_self hz]
have he (a : A) : ∑ b, (w b / s) * (p b a / w b) = (∑ b, p b a) / s := by
rw [Finset.sum_div]
apply Finset.sum_congr rfl
intro b _
by_cases hwb : w b = 0
· rw [zero_row (hp b) hwb a,hwb]; simp
· field_simp
have hj (a : A) : ∑ b, (w b / s) * Real.negMulLog (p b a / w b) ≤
Real.negMulLog ((∑ b, p b a) / s) := by
have h := Real.concaveOn_negMulLog.le_map_sum
(t := Finset.univ) (w := fun b => w b / s) (p := fun b => p b a / w b)
(fun b _ => div_nonneg (hw b) hs) hweights
(fun b _ => div_nonneg (hp b a) (hw b))
simpa only [smul_eq_mul,he] using h
rw [rowEntropy_normalize _ (fun a => Finset.sum_nonneg (fun b _ => hp b a))]
have hsum : (∑ a, ∑ b, p b a) = s := Finset.sum_comm
rw [hsum]
calc
∑ b, rowEntropy (p b) = s * ∑ a, ∑ b, (w b / s) * Real.negMulLog (p b a / w b) := by
simp_rw [rowEntropy_normalize _ (hp _),shannonEntropy_eq_negMulLog]
rw [Finset.sum_comm,Finset.mul_sum]
apply Finset.sum_congr rfl
intro b _
rw [←Finset.mul_sum,←mul_assoc,mul_div_cancel₀ _ hz]
_ ≤ s * ∑ a, Real.negMulLog ((∑ b, p b a) / s) :=
mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun a _ => hj a)) hs
_ = _ := rfl
def conditionalShannon (p : B → A → ℝ) : ℝ := ∑ b, rowEntropy (p b)
lemma shannon_chain_rule (p : B → A → ℝ) :
shannonEntropy (fun z : B × A => p z.1 z.2) =
shannonEntropy (fun b => ∑ a, p b a) + conditionalShannon p := by
simp only [conditionalShannon,rowEntropy,shannonEntropy_eq_negMulLog,Fintype.sum_prod_type,
Finset.sum_sub_distrib]
ring
lemma conditionalShannon_refine (p : C → B → A → ℝ) (hp : ∀ c b a, 0 ≤ p c b a) :
conditionalShannon (fun z : C × B => p z.1 z.2) ≤
conditionalShannon (fun b a => ∑ c, p c b a) := by
simp only [conditionalShannon,Fintype.sum_prod_type]
rw [Finset.sum_comm]
exact Finset.sum_le_sum fun b _ => rowEntropy_sum_le (fun c a => p c b a) (fun c a => hp c b a)
end
section
open MeasureTheory Filter
open scoped BigOperators Topology
variable {Ω A B C : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [Fintype B] [Fintype C]
[MeasurableSpace A] [MeasurableSingletonClass A]
[MeasurableSpace B] [MeasurableSingletonClass B]
[MeasurableSpace C] [MeasurableSingletonClass C]
def randomEntropy (F : Ω → A) : ℝ := shannonEntropy (fun a => μ.real (F ⁻¹' {a}))
def randomConditionalEntropy (F : Ω → A) (G : Ω → B) : ℝ :=
conditionalShannon (fun b a => μ.real {x | G x = b ∧ F x = a})
omit [Fintype B] in
lemma sum_joint_mass (F : Ω → A) (G : Ω → B) (hF : Measurable F) (hG : Measurable G) (b : B) :
(∑ a, μ.real {x | G x = b ∧ F x = a}) = μ.real (G ⁻¹' {b}) := by
rw [←measureReal_iUnion_fintype]
· congr 1
ext x
simp
· intro a a' haa
apply Set.disjoint_left.mpr
intro x hx hx'
exact haa (hx.2.symm.trans hx'.2)
· intro a
exact (hG (measurableSet_singleton b)).inter (hF (measurableSet_singleton a))
lemma randomEntropy_pair (F : Ω → A) (G : Ω → B) (hF : Measurable F) (hG : Measurable G) :
randomEntropy μ (fun x => (G x,F x)) = randomEntropy μ G + randomConditionalEntropy μ F G := by
have h := shannon_chain_rule (fun b a => μ.real {x | G x = b ∧ F x = a})
simp_rw [sum_joint_mass μ F G hF hG] at h
simpa only [randomEntropy,randomConditionalEntropy,Set.preimage,Set.mem_singleton_iff,Prod.ext_iff] using h
lemma randomEntropy_nonneg (F : Ω → A) (hF : Measurable F) : 0 ≤ randomEntropy μ F := by
apply shannonEntropy_nonneg _ (fun _ => measureReal_nonneg)
simpa using (sum_measureReal_preimage_singleton (μ := μ) Finset.univ
(fun a _ => hF (measurableSet_singleton a)))
lemma randomConditionalEntropy_nonneg (F : Ω → A) (G : Ω → B)
(hF : Measurable F) (hG : Measurable G) : 0 ≤ randomConditionalEntropy μ F G := by
have h := randomEntropy_comp_le (η := μ) (fun x => (G x,F x)) (hG.prodMk hF) Prod.fst
change randomEntropy μ G ≤ randomEntropy μ (fun x => (G x,F x)) at h
rw [randomEntropy_pair μ F G hF hG] at h
linarith
lemma randomConditionalEntropy_le (F : Ω → A) (G : Ω → B)
(hF : Measurable F) (hG : Measurable G) : randomConditionalEntropy μ F G ≤ randomEntropy μ F := by
have h := rowEntropy_sum_le (fun b a => μ.real {x | G x = b ∧ F x = a})
(fun _ _ => measureReal_nonneg)
have hsum (a : A) : (∑ b, μ.real {x | G x = b ∧ F x = a}) = μ.real (F ⁻¹' {a}) := by
have hh := sum_joint_mass μ G F hG hF a
convert hh using 1
apply Finset.sum_congr rfl
intro b _
congr 1
ext x
exact and_comm
simp_rw [hsum] at h
have hmass : (∑ a, μ.real (F ⁻¹' {a})) = 1 := by
simpa using (sum_measureReal_preimage_singleton (μ := μ) Finset.univ
(fun a _ => hF (measurableSet_singleton a)))
simpa only [randomConditionalEntropy,conditionalShannon, rowEntropy,hmass,Real.negMulLog_one,
sub_zero,randomEntropy] using h
lemma randomConditionalEntropy_refine (F : Ω → A) (G : Ω → B) (K : Ω → C)
(hF : Measurable F) (hG : Measurable G) (hK : Measurable K) :
randomConditionalEntropy μ F (fun x => (K x,G x)) ≤ randomConditionalEntropy μ F G := by
have hp := conditionalShannon_refine
(fun c b a => μ.real {x | K x = c ∧ G x = b ∧ F x = a}) (fun _ _ _ => measureReal_nonneg)
have he (b : B) (a : A) : (∑ c, μ.real {x | K x = c ∧ G x = b ∧ F x = a}) =
μ.real {x | G x = b ∧ F x = a} := by
have hh := sum_joint_mass μ K (fun x => (G x,F x)) hK (hG.prodMk hF) (b,a)
simpa only [Set.preimage,Set.mem_singleton_iff,Prod.mk.injEq,and_comm,and_left_comm] using hh
simp_rw [he] at hp
simpa only [randomConditionalEntropy,Prod.ext_iff,and_assoc] using hp
lemma randomEntropy_prod_le (F : Ω → A) (G : Ω → B) (hF : Measurable F) (hG : Measurable G) :
randomEntropy μ (fun x => (G x,F x)) ≤ randomEntropy μ G + randomEntropy μ F := by
rw [randomEntropy_pair μ F G hF hG]
exact add_le_add_right (randomConditionalEntropy_le μ F G hF hG) _
lemma randomEntropy_recode (F : Ω → A) (hF : Measurable F) (e : A ≃ B) :
randomEntropy μ (e ∘ F) = randomEntropy μ F := by
apply le_antisymm (randomEntropy_comp_le F hF e)
have h := randomEntropy_comp_le (η := μ) (e ∘ F) ((measurable_of_finite e).comp hF) e.symm
simpa only [Function.comp_def,Equiv.symm_apply_apply] using h
end
section
open MeasureTheory Filter
open scoped Topology BigOperators symmDiff
variable {Ω A B : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [Fintype B] [MeasurableSpace A] [MeasurableSingletonClass A]
[MeasurableSpace B] [MeasurableSingletonClass B]
omit [MeasurableSpace A] [MeasurableSingletonClass A] in
lemma continuous_shannonEntropy : Continuous (shannonEntropy (A := A)) := by
unfold shannonEntropy
exact continuous_finsetSum _ fun a _ => Real.continuous_negMulLog.comp (continuous_apply a)
omit [IsProbabilityMeasure μ] [MeasurableSpace A] [MeasurableSingletonClass A] in
lemma randomEntropy_congr_ae {F G : Ω → A} (h : F =ᵐ[μ] G) : randomEntropy μ F = randomEntropy μ G := by
unfold randomEntropy
congr 1
funext a
apply measureReal_congr
filter_upwards [h] with x hx
apply propext
change F x = a ↔ G x = a
rw [hx]
omit [IsProbabilityMeasure μ] in
lemma randomEntropy_measurePreserving {Υ : Type*} [MeasurableSpace Υ] (ν : Measure Υ)
[IsProbabilityMeasure ν] {T : Ω → Υ} (hT : MeasurePreserving T μ ν)
(F : Υ → A) (hF : Measurable F) : randomEntropy μ (F ∘ T) = randomEntropy ν F := by
unfold randomEntropy
congr 1
funext a
exact hT.measureReal_preimage (hF (measurableSet_singleton a)).nullMeasurableSet
omit [Fintype A] in
lemma atom_mass_disagreement {F G : Ω → A} (hF : Measurable F) (hG : Measurable G) (a : A) :
|μ.real (F ⁻¹' {a}) - μ.real (G ⁻¹' {a})| ≤ μ.real {x | F x ≠ G x} := by
apply (abs_measureReal_sub_le_measureReal_symmDiff
(hF (measurableSet_singleton a)).nullMeasurableSet
(hG (measurableSet_singleton a)).nullMeasurableSet).trans
refine measureReal_mono ?_ (by finiteness)
intro x hx
simp only [Set.mem_symmDiff,Set.mem_preimage,Set.mem_singleton_iff,Set.mem_ofPred_eq] at hx ⊢
rcases hx with hx | hx <;> aesop
lemma randomEntropy_tendsto_of_disagreement {ι : Type*} {l : Filter ι} {Fn : ι → Ω → A} {F : Ω → A}
(hFn : ∀ n, Measurable (Fn n)) (hF : Measurable F)
(h : Tendsto (fun n => μ.real {x | Fn n x ≠ F x}) l (𝓝 0)) :
Tendsto (fun n => randomEntropy μ (Fn n)) l (𝓝 (randomEntropy μ F)) := by
apply continuous_shannonEntropy.tendsto _ |>.comp
apply tendsto_pi_nhds.mpr
intro a
apply (tendsto_iff_norm_sub_tendsto_zero).mpr
exact squeeze_zero_norm (fun n => by simpa only [Real.norm_eq_abs,abs_abs] using atom_mass_disagreement μ (hFn n) hF a) h
lemma randomEntropy_self_pair (F : Ω → A) (hF : Measurable F) :
randomEntropy μ (fun x => (F x,F x)) = randomEntropy μ F := by
apply le_antisymm (randomEntropy_comp_le F hF (fun a => (a,a)))
have h := randomEntropy_comp_le (η := μ) (fun x => (F x,F x)) (hF.prodMk hF) Prod.fst
exact h
lemma randomConditionalEntropy_self (F : Ω → A) (hF : Measurable F) :
randomConditionalEntropy μ F F = 0 := by
have h := randomEntropy_pair μ F F hF hF
rw [randomEntropy_self_pair μ F hF] at h
linarith
lemma randomConditionalEntropy_tendsto_self {ι : Type*} {l : Filter ι} {Fn : ι → Ω → A} {F : Ω → A}
(hFn : ∀ n, Measurable (Fn n)) (hF : Measurable F)
(h : Tendsto (fun n => μ.real {x | Fn n x ≠ F x}) l (𝓝 0)) :
Tendsto (fun n => randomConditionalEntropy μ F (Fn n)) l (𝓝 0) := by
have hp : Tendsto (fun n => μ.real {x | (Fn n x,F x) ≠ (F x,F x)}) l (𝓝 0) := by
have he : (fun n => μ.real {x | (Fn n x,F x) ≠ (F x,F x)}) =
(fun n => μ.real {x | Fn n x ≠ F x}) := by
funext n
congr 1
ext x
constructor
· intro hn he
exact hn (congrArg (fun a => (a,F x)) he)
· intro hn he
exact hn (congrArg Prod.fst he)
rwa [he]
have ht := (randomEntropy_tendsto_of_disagreement μ (fun n => (hFn n).prodMk hF)
(hF.prodMk hF) hp).sub (randomEntropy_tendsto_of_disagreement μ hFn hF h)
have he n : randomEntropy μ (fun x => (Fn n x,F x)) - randomEntropy μ (Fn n) =
randomConditionalEntropy μ F (Fn n) := by rw [randomEntropy_pair μ F (Fn n) hF (hFn n)]; ring
simpa only [he,randomEntropy_self_pair μ F hF,sub_self] using ht
end
section
open MeasureTheory Filter
open scoped Topology BigOperators
variable {Ω A B C D : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [retained0 : IsProbabilityMeasure μ]
[Fintype A] [Fintype B] [Fintype C] [Fintype D]
[retained1 : MeasurableSpace A] [retained2 : MeasurableSingletonClass A]
[retained3 : MeasurableSpace B] [retained4 : MeasurableSingletonClass B]
[MeasurableSpace C] [MeasurableSingletonClass C]
[MeasurableSpace D] [MeasurableSingletonClass D]
lemma randomEntropy_mutual_factor (F : Ω → A) (G : Ω → B) (hF : Measurable F) (hG : Measurable G)
(e : A → B) (r : B → A) (he : G = e ∘ F) (hr : F = r ∘ G) :
randomEntropy μ F = randomEntropy μ G := by
apply le_antisymm
· rw [hr]
exact randomEntropy_comp_le G hG r
· rw [he]
exact randomEntropy_comp_le F hF e
lemma randomEntropy_pair_factor (F : Ω → A) (hF : Measurable F) (e : A → B) :
randomEntropy μ (fun x => (F x,e (F x))) = randomEntropy μ F := by
apply randomEntropy_mutual_factor μ _ F (hF.prodMk ((measurable_of_finite e).comp hF)) hF
Prod.fst (fun a => (a,e a)) rfl rfl
lemma randomConditionalEntropy_condition_redundant (F : Ω → A) (G : Ω → B)
(hF : Measurable F) (hG : Measurable G) (e : B → C) :
randomConditionalEntropy μ F (fun x => (G x,e (G x))) = randomConditionalEntropy μ F G := by
have hp := randomEntropy_pair μ F (fun x => (G x,e (G x))) hF
(hG.prodMk ((measurable_of_finite e).comp hG))
have hq := randomEntropy_pair μ F G hF hG
have hj : randomEntropy μ (fun x => ((G x,e (G x)),F x)) =
randomEntropy μ (fun x => (G x,F x)) := by
exact randomEntropy_mutual_factor μ _ _
((hG.prodMk ((measurable_of_finite e).comp hG)).prodMk hF) (hG.prodMk hF)
(fun z => (z.1.1,z.2)) (fun z => ((z.1,e z.1),z.2)) rfl rfl
rw [hj,randomEntropy_pair_factor μ G hG e] at hp
linarith
lemma randomConditionalEntropy_condition_comp (F : Ω → A) (G : Ω → B)
(hF : Measurable F) (hG : Measurable G) (e : B → C) :
randomConditionalEntropy μ F G ≤ randomConditionalEntropy μ F (e ∘ G) := by
have h := randomConditionalEntropy_refine μ F (e ∘ G) G hF
((measurable_of_finite e).comp hG) hG
change randomConditionalEntropy μ F (fun x => (G x,e (G x))) ≤ _ at h
rwa [randomConditionalEntropy_condition_redundant μ F G hF hG e] at h
lemma randomConditionalEntropy_measurable_factor (F : Ω → A) (G : Ω → B) (K : Ω → C)
(hF : Measurable F) (hK : Measurable K) [Nonempty B]
(hG : Measurable[MeasurableSpace.comap K inferInstance] G) :
randomConditionalEntropy μ F K ≤ randomConditionalEntropy μ F G := by
obtain ⟨e,he⟩ := (Function.factorsThrough_iff G).mp hG.factorsThrough
rw [he]
exact randomConditionalEntropy_condition_comp μ F K hF hK e
lemma randomConditionalEntropy_measurePreserving {Υ : Type*} [MeasurableSpace Υ] (ν : Measure Υ)
[IsProbabilityMeasure ν] {T : Ω → Υ} (hT : MeasurePreserving T μ ν)
(F : Υ → A) (G : Υ → B) (hF : Measurable F) (hG : Measurable G) :
randomConditionalEntropy μ (F ∘ T) (G ∘ T) = randomConditionalEntropy ν F G := by
have h := randomEntropy_pair μ (F ∘ T) (G ∘ T) (hF.comp hT.measurable) (hG.comp hT.measurable)
have h' := randomEntropy_pair ν F G hF hG
have hp := randomEntropy_measurePreserving μ ν hT (fun x => (G x,F x)) (hG.prodMk hF)
have hg := randomEntropy_measurePreserving μ ν hT G hG
change randomEntropy μ (fun x => ((G ∘ T) x,(F ∘ T) x)) = _ at hp
rw [hp,hg] at h
linarith
include retained0 retained1 retained2 retained3 retained4 in
lemma randomConditionalEntropy_congr_ae {F F' : Ω → A} {G G' : Ω → B}
(hF : F =ᵐ[μ] F') (hG : G =ᵐ[μ] G') :
randomConditionalEntropy μ F G = randomConditionalEntropy μ F' G' := by
let _ := retained0
let _ := retained1
let _ := retained2
let _ := retained3
let _ := retained4
unfold randomConditionalEntropy
congr 1
funext b a
apply measureReal_congr
filter_upwards [hF,hG] with x hx hy
apply propext
rw [hx,hy]
end
section
open MeasureTheory Filter
open scoped Topology BigOperators
variable {Ω A B C : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [Fintype B] [Fintype C]
[MeasurableSpace A] [MeasurableSingletonClass A]
[MeasurableSpace B] [MeasurableSingletonClass B]
[MeasurableSpace C] [MeasurableSingletonClass C]
lemma randomConditionalEntropy_chain (F : Ω → A) (G : Ω → B) (K : Ω → C)
(hF : Measurable F) (hG : Measurable G) (hK : Measurable K) :
randomConditionalEntropy μ (fun x => (G x,F x)) K =
randomConditionalEntropy μ G K + randomConditionalEntropy μ F (fun x => (K x,G x)) := by
have h1 := randomEntropy_pair μ (fun x => (G x,F x)) K (hG.prodMk hF) hK
have h2 := randomEntropy_pair μ F (fun x => (K x,G x)) hF (hK.prodMk hG)
have h3 := randomEntropy_pair μ G K hG hK
have he : randomEntropy μ (fun x => (K x,(G x,F x))) =
randomEntropy μ (fun x => ((K x,G x),F x)) := by
exact randomEntropy_mutual_factor μ _ _ (hK.prodMk (hG.prodMk hF)) ((hK.prodMk hG).prodMk hF)
(fun z => ((z.1,z.2.1),z.2.2)) (fun z => (z.1.1,(z.1.2,z.2))) rfl rfl
linarith
lemma randomConditionalEntropy_pair_le (F : Ω → A) (G : Ω → B) (K : Ω → C)
(hF : Measurable F) (hG : Measurable G) (hK : Measurable K) :
randomConditionalEntropy μ (fun x => (G x,F x)) K ≤
randomConditionalEntropy μ G K + randomConditionalEntropy μ F K := by
rw [randomConditionalEntropy_chain μ F G K hF hG hK]
have h := randomConditionalEntropy_condition_comp μ F (fun x => (K x,G x)) hF (hK.prodMk hG) Prod.fst
exact add_le_add_right h _
lemma randomConditionalEntropy_mutual_factor (F : Ω → A) (G : Ω → B) (K : Ω → C)
(hF : Measurable F) (hG : Measurable G) (hK : Measurable K)
(e : A → B) (r : B → A) (he : G = e ∘ F) (hr : F = r ∘ G) :
randomConditionalEntropy μ F K = randomConditionalEntropy μ G K := by
have h1 := randomEntropy_pair μ F K hF hK
have h2 := randomEntropy_pair μ G K hG hK
have he' : (fun x => (K x,G x)) = (fun z : C × A => (z.1,e z.2)) ∘ (fun x => (K x,F x)) := by rw [he]; rfl
have hr' : (fun x => (K x,F x)) = (fun z : C × B => (z.1,r z.2)) ∘ (fun x => (K x,G x)) := by rw [hr]; rfl
have h := randomEntropy_mutual_factor μ _ _ (hK.prodMk hF) (hK.prodMk hG)
(fun z : C × A => (z.1,e z.2)) (fun z : C × B => (z.1,r z.2)) he' hr'
linarith
omit [MeasurableSpace A] [MeasurableSingletonClass A] in
lemma randomEntropy_fintype_one [Unique A] (F : Ω → A) : randomEntropy μ F = 0 := by
classical
have he : F = fun _ => default := funext fun x => Unique.eq_default _
rw [he]
simp [randomEntropy,shannonEntropy]
lemma randomConditionalEntropy_fintype_one [Unique A] (F : Ω → A) (G : Ω → B)
(hF : Measurable F) (hG : Measurable G) : randomConditionalEntropy μ F G = 0 := by
apply le_antisymm _ (randomConditionalEntropy_nonneg μ F G hF hG)
have h := randomConditionalEntropy_le μ F G hF hG
rwa [randomEntropy_fintype_one μ F] at h
def integerWord (F : ℤ → Ω → A) (t : ℤ) (n : ℕ) : Ω → Fin n → A :=
fun x i => F (t+i.val) x
omit [Fintype A] [MeasurableSingletonClass A] in
lemma measurable_integerWord (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t)) (t : ℤ) (n : ℕ) :
Measurable (integerWord F t n) := Measurable.of_eval fun _ => hF _
lemma integerWord_pair (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t)) (t : ℤ) (m n : ℕ) :
randomEntropy μ (integerWord F t (m+n)) =
randomEntropy μ (fun x => (integerWord F t m x,integerWord F (t+m) n x)) := by
apply randomEntropy_mutual_factor μ _ _ (measurable_integerWord F hF _ _)
((measurable_integerWord F hF _ _).prodMk (measurable_integerWord F hF _ _))
(fun z => (fun i => z (i.castAdd n),fun i => z (i.natAdd m)))
(fun z => Fin.append z.1 z.2)
· funext x
apply Prod.ext
· rfl
· funext i
simp only [integerWord,Function.comp_apply,Fin.val_natAdd,Nat.cast_add]
congr 1
ring
· funext x i
induction i using Fin.addCases with
| left i => simp [integerWord]
| right i => simp only [integerWord,Function.comp_apply,Fin.append_right,Fin.val_natAdd,Nat.cast_add]; congr 1; ring
lemma integerWord_add (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t)) (t : ℤ) (m n : ℕ) :
randomEntropy μ (integerWord F t (m+n)) = randomEntropy μ (integerWord F t m) +
randomConditionalEntropy μ (integerWord F (t+m) n) (integerWord F t m) := by
rw [integerWord_pair μ F hF t m n,randomEntropy_pair μ _ _
(measurable_integerWord F hF _ _) (measurable_integerWord F hF _ _)]
lemma integerWord_succ (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t)) (t : ℤ) (n : ℕ) :
randomEntropy μ (integerWord F t (n+1)) = randomEntropy μ (integerWord F t n) +
randomConditionalEntropy μ (F (t+n)) (integerWord F t n) := by
rw [integerWord_add μ F hF t n 1]
congr 1
apply randomConditionalEntropy_mutual_factor μ _ _ _ (measurable_integerWord F hF _ _)
(hF _) (measurable_integerWord F hF _ _) (fun z => z 0) (fun a _ => a)
· funext x
simp [integerWord]
· funext x i
have hi : i = 0 := Subsingleton.elim _ _
subst i
simp only [integerWord,Fin.val_zero,Nat.cast_zero,add_zero,Function.comp_apply]
end
section
open Filter
open scoped Topology BigOperators
theorem entropy_rate_of_decreasing_increments (H : ℕ → ℝ) (h0 : H 0 = 0)
(hmono : Antitone (fun n => H (n+1) - H n))
(hpos : ∀ n, 0 ≤ H (n+1) - H n) :
∃ h : ℝ, 0 ≤ h ∧ (∀ n, h ≤ H (n+1) - H n) ∧
Tendsto (fun n : ℕ => H n / n) atTop (𝓝 h) := by
let a : ℕ → ℝ := fun n => H (n+1) - H n
have hb : BddBelow (Set.range a) := ⟨0,by rintro _ ⟨n,rfl⟩; exact hpos n⟩
refine ⟨⨅ n, a n,?_,fun n => ciInf_le hb n,?_⟩
· exact le_ciInf (fun n => hpos n)
· have ht := (tendsto_atTop_ciInf hmono hb).cesaro
have he n : (∑ j ∈ Finset.range n, a j) = H n := by
dsimp [a]
rw [Finset.sum_range_sub,h0,sub_zero]
simpa only [a,Finset.sum_range_sub,h0,sub_zero,div_eq_mul_inv,mul_comm] using ht
lemma entropy_block_lower (H : ℕ → ℝ) (h : ℝ)
(ha : ∀ n, h ≤ H (n+1) - H n) (m n : ℕ) :
(n : ℝ) * h ≤ H (m+n) - H m := by
induction n with
| zero => simp
| succ n ih =>
have hh := ha (m+n)
simp only [Nat.cast_add,Nat.cast_one]
rw [show m + (n+1) = (m+n)+1 by omega]
nlinarith
theorem entropy_zero_of_tail_bounds (H K : ℕ → ℝ) (h : ℝ)
(hrate : Tendsto (fun n : ℕ => H n / n) atTop (𝓝 h))
(hK : ∀ n, 0 ≤ K n)
(hb : ∀ ε : ℝ, 0 < ε → ∃ c : ℕ, ∀ n : ℕ,
K n + n * h ≤ H (n+c) + n * ε) :
Tendsto (fun n : ℕ => K n / n) atTop (𝓝 0) := by
apply tendsto_order.mpr
constructor
· intro a ha
exact Eventually.of_forall fun n => ha.trans_le (div_nonneg (hK n) (Nat.cast_nonneg n))
· intro ε hε
obtain ⟨c,hc⟩ := hb (ε/2) (by positivity)
have hd : Tendsto (fun n : ℕ => (n+c : ℝ) / n) atTop (𝓝 1) := by
have ht : Tendsto (fun n : ℕ => (c:ℝ) / n) atTop (𝓝 0) := tendsto_const_nhds.div_atTop (tendsto_natCast_atTop_atTop (R := ℝ))
have hh : Tendsto (fun n : ℕ => 1 + c / (n : ℝ)) atTop (𝓝 (1+0)) := tendsto_const_nhds.add ht
simp only [add_zero] at hh
apply hh.congr'
filter_upwards [eventually_ge_atTop 1] with n hn
have hn' : (n : ℝ) ≠ 0 := by exact_mod_cast (by omega : n ≠ 0)
field_simp
have hsh : Tendsto (fun n : ℕ => H (n+c) / n) atTop (𝓝 h) := by
have hh := (hrate.comp (tendsto_add_atTop_nat c)).mul hd
rw [mul_one] at hh
apply hh.congr'
filter_upwards [eventually_ge_atTop 1] with n hn
have hn' : (n+c : ℝ) ≠ 0 := by positivity
simp only [Function.comp_def,Nat.cast_add]
field_simp
have hu := (hsh.sub_const h).add_const (ε/2)
simp only [sub_self,zero_add] at hu
filter_upwards [hu.eventually (gt_mem_nhds (show ε/2 < ε by linarith)),
eventually_ge_atTop 1] with n hh hn
have hn' : (0 : ℝ) < n := by exact_mod_cast (by omega : 0 < n)
apply lt_of_le_of_lt _ hh
apply (div_le_iff₀ hn').mpr
have hf := hc n
have he : (H (n+c) / n - h + ε/2) * n = H (n+c) - n*h + n*(ε/2) := by
field_simp
rw [he]
linarith
end
section
open MeasureTheory Filter
open scoped Topology BigOperators
variable {Ω A : Type*} [retained5 : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A]
omit [MeasurableSpace Ω] [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A] in
lemma integerWord_subword (F : ℤ → Ω → A) (s : ℤ) (l n m : ℕ) (h : l+n ≤ m) :
integerWord F (s+l) n = (fun z : Fin m → A => fun i : Fin n =>
z ⟨l+i.val,by omega⟩) ∘ integerWord F s m := by
funext x i
simp only [integerWord,Function.comp_apply,Nat.cast_add]
congr 1
ring
omit [MeasurableSpace Ω] in
lemma integerWord_subword_measurable (F : ℤ → Ω → A) (s : ℤ) (l n m : ℕ) (h : l+n ≤ m) :
Measurable[MeasurableSpace.comap (integerWord F s m) inferInstance] (integerWord F (s+l) n) := by
rw [integerWord_subword F s l n m h]
exact (measurable_of_finite _).comp (comap_measurable _)
include retained5 in
lemma pastWord_comap_mono (F : ℤ → Ω → A) (t : ℤ) :
Monotone (fun n : ℕ => MeasurableSpace.comap (integerWord F (t-n) n) inferInstance) := by
let _ := retained5
intro m n hmn
have hh := integerWord_subword_measurable F (t-n) (n-m) m n (by omega)
have he : t - (n:ℤ) + (n-m:ℕ) = t-m := by rw [Nat.cast_sub hmn]; ring
rw [he] at hh
exact hh.comap_le
include retained5 in
lemma windowWord_comap_mono (F : ℤ → Ω → A) :
Monotone (fun n : ℕ => MeasurableSpace.comap (integerWord F (-(n:ℤ)) (2*n+1)) inferInstance) := by
let _ := retained5
intro m n hmn
have hh := integerWord_subword_measurable F (-(n:ℤ)) (n-m) (2*m+1) (2*n+1) (by omega)
have he : -(n:ℤ) + (n-m:ℕ) = -(m:ℤ) := by rw [Nat.cast_sub hmn]; ring
rw [he] at hh
exact hh.comap_le
variable (U : ℤ → Ω → Ω) (hU : ∀ s, MeasurePreserving (U s) μ μ)
(F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t))
(htrans : ∀ t s x, F (t+s) x = F t (U s x))
omit [MeasurableSpace Ω] [Fintype A] [MeasurableSpace A] [MeasurableSingletonClass A] in
include htrans in
lemma integerWord_translate (t s : ℤ) (n : ℕ) :
integerWord F (t+s) n = integerWord F t n ∘ U s := by
funext x i
change F ((t+s)+i.val) x = F (t+i.val) (U s x)
rw [show (t+s)+(i.val:ℤ) = (t+i.val)+s by ring,htrans]
include hU hF htrans
lemma integerWord_entropy_translate (t : ℤ) (n : ℕ) :
randomEntropy μ (integerWord F t n) = randomEntropy μ (integerWord F 0 n) := by
rw [show t = 0+t by simp,integerWord_translate U F htrans]
exact randomEntropy_measurePreserving μ μ (hU t) _ (measurable_integerWord F hF _ _)
lemma conditionalEntropy_past_translate (t : ℤ) (n : ℕ) :
randomConditionalEntropy μ (F t) (integerWord F (t-n) n) =
randomConditionalEntropy μ (F 0) (integerWord F (-(n:ℤ)) n) := by
have he : integerWord F (t-n) n = integerWord F (-(n:ℤ)) n ∘ U t := by
rw [show t - (n:ℤ) = -(n:ℤ)+t by ring,integerWord_translate U F htrans]
have hf : F t = F 0 ∘ U t := by funext x; simpa using htrans 0 t x
rw [he,hf]
exact randomConditionalEntropy_measurePreserving μ μ (hU t) _ _ (hF _) (measurable_integerWord F hF _ _)
lemma entropy_increment_past (n : ℕ) :
randomEntropy μ (integerWord F 0 (n+1)) - randomEntropy μ (integerWord F 0 n) =
randomConditionalEntropy μ (F 0) (integerWord F (-(n:ℤ)) n) := by
have hh := integerWord_succ μ F hF (-(n:ℤ)) n
rw [integerWord_entropy_translate μ U hU F hF htrans (-(n:ℤ)) (n+1),
integerWord_entropy_translate μ U hU F hF htrans (-(n:ℤ)) n] at hh
simp only [neg_add_cancel] at hh
linarith
theorem stationary_entropy_rate [Nonempty A] :
∃ h : ℝ, 0 ≤ h ∧
(∀ (t : ℤ) (n : ℕ), h ≤ randomConditionalEntropy μ (F t) (integerWord F (t-n) n)) ∧
Tendsto (fun n : ℕ => randomEntropy μ (integerWord F 0 n) / n) atTop (𝓝 h) := by
let H : ℕ → ℝ := fun n => randomEntropy μ (integerWord F 0 n)
have h0 : H 0 = 0 := randomEntropy_fintype_one μ _
have he n : H (n+1) - H n = randomConditionalEntropy μ (F 0) (integerWord F (-(n:ℤ)) n) :=
entropy_increment_past μ U hU F hF htrans n
have hmono : Antitone (fun n => H (n+1) - H n) := by
intro m n hmn
change H (n+1) - H n ≤ H (m+1) - H m
rw [he,he]
apply randomConditionalEntropy_measurable_factor μ _ _ _ (hF 0) (measurable_integerWord F hF _ _)
have hh := (pastWord_comap_mono F 0 hmn)
simp only [zero_sub] at hh
exact (comap_measurable _).mono hh le_rfl
have hpos n : 0 ≤ H (n+1)-H n := by
rw [he]
exact randomConditionalEntropy_nonneg μ _ _ (hF _) (measurable_integerWord F hF _ _)
obtain ⟨h,hpos,hle,ht⟩ := entropy_rate_of_decreasing_increments H h0 hmono hpos
refine ⟨h,hpos,?_,ht⟩
intro t n
rw [conditionalEntropy_past_translate μ U hU F hF htrans,←he]
exact hle n
end
section
open MeasureTheory Filter Set
variable {Ω : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω)
@[instance_reducible]
def completedFactor (m : MeasurableSpace Ω) : MeasurableSpace Ω where
MeasurableSet' s := MeasurableSet[m₀] s ∧ ∃ t : Set Ω, MeasurableSet[m] t ∧
∀ᵐ x ∂μ, x ∈ s ↔ x ∈ t
measurableSet_empty := ⟨@MeasurableSet.empty Ω m₀,∅,@MeasurableSet.empty Ω m,Eventually.of_forall fun _ => Iff.rfl⟩
measurableSet_compl := by
rintro s ⟨hs,t,ht,he⟩
exact ⟨hs.compl,tᶜ,ht.compl,he.mono fun x hx => not_congr hx⟩
measurableSet_iUnion := by
intro s hs
choose t ht he using fun n => (hs n).2
refine ⟨MeasurableSet.iUnion fun n => (hs n).1,⋃ n, t n,MeasurableSet.iUnion ht,?_⟩
filter_upwards [ae_all_iff.mpr he] with x hx
simp only [mem_iUnion]
exact exists_congr fun n => hx n
lemma completedFactor_le (m : MeasurableSpace Ω) : completedFactor (m₀ := m₀) μ m ≤ m₀ :=
fun _ hs => hs.1
lemma le_completedFactor {m : MeasurableSpace Ω} (hm : m ≤ m₀) : m ≤ completedFactor (m₀ := m₀) μ m :=
fun s hs => ⟨hm s hs,s,hs,Eventually.of_forall fun _ => Iff.rfl⟩
lemma completedFactor_mono : Monotone (completedFactor (m₀ := m₀) μ) := by
intro m n h s hs
obtain ⟨hs,t,ht,he⟩ := hs
exact ⟨hs,t,h t ht,he⟩
lemma completedFactor_congr_set (m : MeasurableSpace Ω) (s t : Set Ω)
(hs : MeasurableSet[m₀] s) (ht : MeasurableSet[completedFactor (m₀ := m₀) μ m] t)
(he : ∀ᵐ x ∂μ, x ∈ s ↔ x ∈ t) : MeasurableSet[completedFactor (m₀ := m₀) μ m] s := by
obtain ⟨_,r,hr,her⟩ := ht
exact ⟨hs,r,hr,he.and her |>.mono fun x hx => hx.1.trans hx.2⟩
lemma measurable_completedFactor_of_ae {Y : Type*} [TopologicalSpace Y] [TopologicalSpace.PseudoMetrizableSpace Y]
[MeasurableSpace Y] [BorelSpace Y]
(m : MeasurableSpace Ω) {f : Ω → Y} (hf : Measurable[m₀] f)
(h : AEStronglyMeasurable[m] f μ) : Measurable[completedFactor (m₀ := m₀) μ m] f := by
intro s hs
exact ⟨hf hs,(h.mk f) ⁻¹' s,h.stronglyMeasurable_mk.measurable hs,
h.ae_eq_mk.mono fun x hx => by simp only [mem_preimage,hx]⟩
lemma completedFactor_iInf_measurable {Y : Type*} [TopologicalSpace Y] [TopologicalSpace.PseudoMetrizableSpace Y]
[MeasurableSpace Y] [BorelSpace Y]
(m : ℕ → MeasurableSpace Ω) {f : Ω → Y} (hf : Measurable[m₀] f)
(h : ∀ n, AEStronglyMeasurable[m n] f μ) :
Measurable[⨅ n, completedFactor (m₀ := m₀) μ (m n)] f := by
intro s hs
exact MeasurableSpace.measurableSet_iInf.mpr fun n =>
measurable_completedFactor_of_ae μ (m n) hf (h n) hs
end
section
open MeasureTheory Filter Set
open scoped Topology BigOperators
variable {Ω : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω)
lemma aeStrong_limit_factor {E : Type*} [TopologicalSpace E] [Nonempty E]
[TopologicalSpace.IsCompletelyMetrizableSpace E] (m : MeasurableSpace Ω)
{f : ℕ → Ω → E} {g : Ω → E} (hf : ∀ n, AEStronglyMeasurable[m] (f n) μ)
(ht : ∀ᵐ x ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (g x))) :
AEStronglyMeasurable[m] g μ := by
let F : ℕ → Ω → E := fun n => (hf n).mk (f n)
have hF : ∀ n, StronglyMeasurable[m] (F n) := fun n => (hf n).stronglyMeasurable_mk
refine ⟨fun x => limUnder atTop (fun n => F n x),StronglyMeasurable.limUnder hF,?_⟩
filter_upwards [ht,ae_all_iff.mpr (fun n => (hf n).ae_eq_mk)] with x hx he
have h : Tendsto (fun n => F n x) atTop (𝓝 (g x)) := by
convert hx using 1
funext n
exact (he n).symm
exact h.limUnder_eq.symm
lemma simpleFunc_aeStrong_of_completed (m : MeasurableSpace Ω)
(g : @SimpleFunc Ω (completedFactor (m₀ := m₀) μ m) ℝ) :
AEStronglyMeasurable[m] g μ := by
classical
have hsets : ∀ c : ℝ, ∃ t : Set Ω, MeasurableSet[m] t ∧
∀ᵐ x ∂μ, g x = c ↔ x ∈ t := fun c => (@SimpleFunc.measurableSet_fiber Ω ℝ (completedFactor (m₀ := m₀) μ m) g c).2
choose t ht he using hsets
let G : Ω → ℝ := fun x => ∑ c ∈ (@SimpleFunc.range Ω ℝ (completedFactor (m₀ := m₀) μ m) g), (t c).indicator (fun _ => c) x
have hm : StronglyMeasurable[m] G :=
Finset.stronglyMeasurable_fun_sum _ fun c _ => stronglyMeasurable_const.indicator (ht c)
refine ⟨G,hm,?_⟩
filter_upwards [ae_all_iff.mpr (fun c : (@SimpleFunc.range Ω ℝ (completedFactor (m₀ := m₀) μ m) g) => he c.val)] with x hx
have hi (c : ℝ) (hc : c ∈ (@SimpleFunc.range Ω ℝ (completedFactor (m₀ := m₀) μ m) g)) :
(t c).indicator (fun _ => c) x = if g x = c then c else 0 := by
simp only [Set.indicator_apply]
rw [←hx ⟨c,hc⟩]
dsimp [G]
simp_rw [Finset.sum_congr rfl hi]
symm
rw [Finset.sum_eq_single (g x)]
· simp only [ite_true]
· intro c hc hne
exact ite_eq_right (Ne.symm hne)
· intro hnot
exact False.elim (hnot (@SimpleFunc.mem_range_self Ω ℝ (completedFactor (m₀ := m₀) μ m) g x))
lemma aeStrong_of_measurable_completed (m : MeasurableSpace Ω)
{f : Ω → ℝ} (hf : Measurable[completedFactor (m₀ := m₀) μ m] f) :
AEStronglyMeasurable[m] f μ := by
have hs := hf.stronglyMeasurable
exact aeStrong_limit_factor (m₀ := m₀) μ m (fun n => simpleFunc_aeStrong_of_completed (m₀ := m₀) μ m (hs.approx n))
(Eventually.of_forall hs.tendsto_approx)
end
section
open MeasureTheory Filter Set
open scoped Topology BigOperators symmDiff
variable {Ω : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
lemma set_approx_iSup_completed (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hmono : Monotone m) {s : Set Ω}
(hs : MeasurableSet[completedFactor (m₀ := m₀) μ (⨆ n, m n)] s)
(ε : ℝ) (hε : 0 < ε) :
∃ n t, MeasurableSet[m n] t ∧ μ.real (s ∆ t) < ε := by
have hle : (⨆ n, m n) ≤ m₀ := iSup_le hm
let C : Set (Set Ω) := {t | ∃ n, MeasurableSet[m n] t}
have hCalg : IsSetAlgebra C := by
refine ⟨⟨0,@MeasurableSet.empty Ω (m 0)⟩,?_,?_⟩
· rintro t ⟨n,hn⟩
exact ⟨n,hn.compl⟩
· rintro t t' ⟨n,hn⟩ ⟨k,hk⟩
exact ⟨max n k,((hmono (le_max_left n k)) _ hn).union ((hmono (le_max_right n k)) _ hk)⟩
have hCgen : (⨆ n, m n) = MeasurableSpace.generateFrom C := by
apply le_antisymm
· apply iSup_le
intro n t ht
exact MeasurableSpace.measurableSet_generateFrom ⟨n,ht⟩
· apply MeasurableSpace.generateFrom_le
rintro t ⟨n,hn⟩
exact (le_iSup m n) _ hn
have hdense := @Measure.MeasureDense.of_generateFrom_isSetAlgebra_finite Ω (⨆ n, m n) (μ.trim hle)
C inferInstance hCalg hCgen
obtain ⟨t,ht,he⟩ := hs.2
obtain ⟨r,⟨n,hn⟩,hr⟩ := @Measure.MeasureDense.approx Ω (⨆ n, m n) (μ.trim hle) C hdense t ht (by finiteness) ε hε
have hrAll : MeasurableSet[(⨆ n, m n)] r := (le_iSup m n) _ hn
rw [trim_measurableSet_eq hle (ht.symmDiff hrAll)] at hr
have he' : s ∆ r =ᵐ[μ] t ∆ r := by
filter_upwards [he] with x hx
apply propext
simp only [Set.mem_symmDiff,hx]
refine ⟨n,r,hn,?_⟩
have her : μ.real (s ∆ r) = μ.real (t ∆ r) := measureReal_congr he'
apply lt_of_eq_of_lt her
have hh := ENNReal.toReal_lt_toReal (measure_ne_top μ (t ∆ r)) ENNReal.ofReal_ne_top |>.mpr hr
simpa only [Measure.real,ENNReal.toReal_ofReal hε.le] using hh
variable {B : Type*} [Fintype B] [Nonempty B] [MeasurableSpace B] [MeasurableSingletonClass B]
def pickFiniteBit (v : B → Bool) : B :=
if h : ∃ b, v b = true then Classical.choose h else Classical.choice ‹Nonempty B›
omit [MeasurableSpace B] [MeasurableSingletonClass B] in
lemma pickFiniteBit_eq (b : B) (v : B → Bool) (hv : ∀ a, v a = true ↔ a = b) :
pickFiniteBit v = b := by
have he : ∃ a, v a = true := ⟨b,(hv b).mpr rfl⟩
simp only [pickFiniteBit,dite_eq_left he]
exact (hv _).mp (Classical.choose_spec he)
lemma finite_approx_iSup_completed (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hmono : Monotone m) (F : Ω → B)
(hF : Measurable[completedFactor (m₀ := m₀) μ (⨆ n, m n)] F)
(ε : ℝ) (hε : 0 < ε) :
∃ n G, Measurable[m n] G ∧ μ.real {x | G x ≠ F x} < ε := by
classical
let δ := ε / (Fintype.card B + 1 : ℝ)
have hδ : 0 < δ := div_pos hε (by positivity)
have hsets (b : B) := set_approx_iSup_completed μ m hm hmono
(hF (measurableSet_singleton b)) δ hδ
choose n r hr hεr using hsets
let N := Finset.univ.sup n
have hrN (b : B) : MeasurableSet[m N] (r b) :=
(hmono (Finset.le_sup (f := n) (Finset.mem_univ b))) _ (hr b)
let code : Ω → B → Bool := fun x b => if x ∈ r b then true else false
have hcode : Measurable[m N] code := by
refine @Measurable.of_eval Ω B (fun _ => Bool) (m N) _ code ?_
intro b
exact Measurable.ite (hrN b) measurable_const measurable_const
let G : Ω → B := pickFiniteBit ∘ code
have hG : Measurable[m N] G := (measurable_of_finite pickFiniteBit).comp hcode
have hsub : {x | G x ≠ F x} ⊆ ⋃ b, ((F ⁻¹' {b}) ∆ r b) := by
intro x hx
by_contra hn
have hbits (b : B) : code x b = true ↔ b = F x := by
have hh : x ∉ (F ⁻¹' {b}) ∆ r b := fun hh => hn (Set.mem_iUnion.mpr ⟨b,hh⟩)
simp only [Set.mem_symmDiff,Set.mem_preimage,Set.mem_singleton_iff,not_or] at hh
simp only [code,ite_eq_left_iff,Bool.false_eq_true,imp_false]
aesop
exact hx (pickFiniteBit_eq (F x) (code x) hbits)
refine ⟨N,G,hG,lt_of_le_of_lt ((measureReal_mono hsub).trans (measureReal_iUnion_fintype_le _)) ?_⟩
calc
(∑ b, μ.real ((F ⁻¹' {b}) ∆ r b)) ≤ ∑ _ : B, δ := Finset.sum_le_sum fun b _ => (hεr b).le
_ = (Fintype.card B : ℝ) * δ := by simp
_ < ε := by
have hd : (0 : ℝ) < Fintype.card B + 1 := by positivity
dsimp [δ]
rw [← mul_div_assoc]
exact (div_lt_iff₀ hd).mpr (by nlinarith)
end
section
open MeasureTheory Filter
open scoped Topology BigOperators
variable {Ω A B : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [Fintype B] [MeasurableSpace A] [MeasurableSingletonClass A]
[MeasurableSpace B] [MeasurableSingletonClass B]
lemma randomConditionalEntropy_tendsto_condition {ι : Type*} {l : Filter ι}
(F : Ω → A) (hF : Measurable F) {Gn : ι → Ω → B} {G : Ω → B}
(hGn : ∀ n, Measurable (Gn n)) (hG : Measurable G)
(h : Tendsto (fun n => μ.real {x | Gn n x ≠ G x}) l (𝓝 0)) :
Tendsto (fun n => randomConditionalEntropy μ F (Gn n)) l (𝓝 (randomConditionalEntropy μ F G)) := by
have hp : Tendsto (fun n => μ.real {x | (Gn n x,F x) ≠ (G x,F x)}) l (𝓝 0) := by
have he : (fun n => μ.real {x | (Gn n x,F x) ≠ (G x,F x)}) =
(fun n => μ.real {x | Gn n x ≠ G x}) := by
funext n
congr 1
ext x
constructor
· intro hn he
exact hn (congrArg (fun a => (a,F x)) he)
· intro hn he
exact hn (congrArg Prod.fst he)
rwa [he]
have ht := (randomEntropy_tendsto_of_disagreement μ (fun n => (hGn n).prodMk hF)
(hG.prodMk hF) hp).sub (randomEntropy_tendsto_of_disagreement μ hGn hG h)
have he (H : Ω → B) (hH : Measurable H) : randomEntropy μ (fun x => (H x,F x)) - randomEntropy μ H =
randomConditionalEntropy μ F H := by rw [randomEntropy_pair μ F H hF hH]; ring
simpa only [he G hG,he _ (hGn _)] using ht
lemma finite_approx_completed_sequence [Nonempty B]
(m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀) (hmono : Monotone m)
(G : Ω → B) (hG : Measurable[completedFactor (m₀ := m₀) μ (⨆ n, m n)] G) :
∃ n : ℕ → ℕ, ∃ Gn : ℕ → Ω → B, (∀ l, Measurable[m (n l)] (Gn l)) ∧
Tendsto (fun l => μ.real {x | Gn l x ≠ G x}) atTop (𝓝 0) := by
have hs (l : ℕ) := finite_approx_iSup_completed μ m hm hmono G hG (1 / (l+1 : ℝ)) (by positivity)
choose n Gn hGn he using hs
refine ⟨n,Gn,hGn,?_⟩
have ht : Tendsto (fun l : ℕ => 1 / (l+1 : ℝ)) atTop (𝓝 0) := by
exact tendsto_const_nhds.div_atTop ((tendsto_natCast_atTop_atTop (R := ℝ)).atTop_add tendsto_const_nhds)
exact squeeze_zero (fun _ => measureReal_nonneg) (fun l => (he l).le) ht
lemma exists_conditional_entropy_lt_of_completed [Nonempty A]
{C : ℕ → Type*} [∀ n, Fintype (C n)] [∀ n, MeasurableSpace (C n)]
[∀ n, MeasurableSingletonClass (C n)] (K : ∀ n, Ω → C n)
(hK : ∀ n, Measurable (K n))
(hmono : Monotone (fun n => MeasurableSpace.comap (K n) inferInstance))
(F : Ω → A) (hF : Measurable[completedFactor (m₀ := m₀) μ
(⨆ n, MeasurableSpace.comap (K n) inferInstance)] F)
(ε : ℝ) (hε : 0 < ε) : ∃ n, randomConditionalEntropy μ F (K n) < ε := by
have hm n : MeasurableSpace.comap (K n) inferInstance ≤ m₀ := (hK n).comap_le
obtain ⟨n,G,hG,ht⟩ := finite_approx_completed_sequence μ _ hm hmono F hF
have hF0 : Measurable F := hF.mono (completedFactor_le μ _) le_rfl
have hG0 l : Measurable (G l) := (hG l).mono (hm _) le_rfl
have hcond := randomConditionalEntropy_tendsto_self μ hG0 hF0 ht
obtain ⟨l,hl⟩ := (hcond.eventually (gt_mem_nhds hε)).exists
refine ⟨n l,lt_of_le_of_lt ?_ hl⟩
exact randomConditionalEntropy_measurable_factor μ F (G l) (K (n l)) hF0 (hK _) (hG l)
lemma conditional_entropy_lower_of_completed [Nonempty B]
{C : ℕ → Type*} [∀ n, Fintype (C n)] [∀ n, MeasurableSpace (C n)]
[∀ n, MeasurableSingletonClass (C n)] (K : ∀ n, Ω → C n)
(hK : ∀ n, Measurable (K n))
(hmono : Monotone (fun n => MeasurableSpace.comap (K n) inferInstance))
(F : Ω → A) (hF : Measurable F) (G : Ω → B)
(hG : Measurable[completedFactor (m₀ := m₀) μ
(⨆ n, MeasurableSpace.comap (K n) inferInstance)] G)
(r : ℝ) (hr : ∀ n, r ≤ randomConditionalEntropy μ F (K n)) :
r ≤ randomConditionalEntropy μ F G := by
have hm n : MeasurableSpace.comap (K n) inferInstance ≤ m₀ := (hK n).comap_le
obtain ⟨n,Gn,hGn,ht⟩ := finite_approx_completed_sequence μ _ hm hmono G hG
have hG0 : Measurable G := hG.mono (completedFactor_le μ _) le_rfl
have hGn0 l : Measurable (Gn l) := (hGn l).mono (hm _) le_rfl
have hcond := randomConditionalEntropy_tendsto_condition μ F hF hGn0 hG0 ht
apply ge_of_tendsto hcond
exact Eventually.of_forall fun l => (hr (n l)).trans
(randomConditionalEntropy_measurable_factor μ F (Gn l) (K (n l)) hF (hK _) (hGn l))
end
section
open MeasureTheory Filter
open scoped Topology BigOperators
variable {Ω A B : Type*} [MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [Fintype B]
[MeasurableSpace A] [MeasurableSingletonClass A]
[MeasurableSpace B] [MeasurableSingletonClass B]
lemma integerWord_conditional_succ (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t))
(G : Ω → B) (hG : Measurable G) (t : ℤ) (n : ℕ) :
randomConditionalEntropy μ (integerWord F t (n+1)) G =
randomConditionalEntropy μ (integerWord F t n) G +
randomConditionalEntropy μ (F (t+n)) (fun x => (G x,integerWord F t n x)) := by
have he : randomConditionalEntropy μ (integerWord F t (n+1)) G =
randomConditionalEntropy μ (fun x => (integerWord F t n x,F (t+n) x)) G := by
apply randomConditionalEntropy_mutual_factor μ _ _ G (measurable_integerWord F hF _ _)
((measurable_integerWord F hF _ _).prodMk (hF _)) hG
(fun z => (fun i : Fin n => z i.castSucc,z (Fin.last n))) (fun z => Fin.snoc z.1 z.2)
· rfl
· funext x i
refine Fin.lastCases ?_ (fun j => ?_) i
· simp only [Function.comp_apply,Fin.snoc_last,integerWord,Fin.val_last]
· simp only [Function.comp_apply,Fin.snoc_castSucc,integerWord,Fin.val_castSucc]
rw [he,randomConditionalEntropy_chain μ _ _ _ (hF _) (measurable_integerWord F hF _ _) hG]
lemma integerWord_conditional_le_sum (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t))
(G : Ω → B) (hG : Measurable G) (t : ℤ) (n : ℕ) :
randomConditionalEntropy μ (integerWord F t n) G ≤
∑ j ∈ Finset.range n, randomConditionalEntropy μ (F (t+j)) G := by
induction n with
| zero => simp [randomConditionalEntropy_fintype_one μ _ G (measurable_integerWord F hF _ _) hG]
| succ n ih =>
rw [integerWord_conditional_succ μ F hF G hG t n,Finset.sum_range_succ]
exact add_le_add ih
(randomConditionalEntropy_condition_comp μ (F (t+n))
(fun x => (G x,integerWord F t n x)) (hF _)
(hG.prodMk (measurable_integerWord F hF _ _)) Prod.fst)
lemma integerWord_conditional_lower (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t))
(G : Ω → B) (hG : Measurable G) (t : ℤ) (n : ℕ) (r : ℝ)
(hr : ∀ j < n, r ≤ randomConditionalEntropy μ (F (t+j))
(fun x => (G x,integerWord F t j x))) :
(n : ℝ) * r ≤ randomConditionalEntropy μ (integerWord F t n) G := by
induction n with
| zero => simpa only [Nat.cast_zero,zero_mul] using randomConditionalEntropy_nonneg μ _ _ (measurable_integerWord F hF t 0) hG
| succ n ih =>
rw [integerWord_conditional_succ μ F hF G hG t n,Nat.cast_add,Nat.cast_one,add_mul,one_mul]
exact add_le_add (ih (fun j hj => hr j (by omega))) (hr n (by omega))
end
section
open MeasureTheory Filter
open scoped Topology BigOperators
variable {Ω A B : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
[Fintype A] [Fintype B] [Nonempty A] [Nonempty B]
[MeasurableSpace A] [MeasurableSingletonClass A]
[MeasurableSpace B] [MeasurableSingletonClass B]
abbrev processPast (F : ℤ → Ω → A) (t : ℤ) : MeasurableSpace Ω :=
⨆ n : ℕ, MeasurableSpace.comap (integerWord F (t-n) n) inferInstance
abbrev processFull (F : ℤ → Ω → A) : MeasurableSpace Ω :=
⨆ n : ℕ, MeasurableSpace.comap (integerWord F (-(n:ℤ)) (2*n+1)) inferInstance
omit [Fintype A] [Nonempty A] [MeasurableSingletonClass A] in
lemma processPast_le (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t)) (t : ℤ) :
processPast F t ≤ m₀ := iSup_le fun _n => (measurable_integerWord F hF _ _).comap_le
omit [Fintype A] [Nonempty A] [MeasurableSingletonClass A] in
lemma processFull_le (F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t)) :
processFull F ≤ m₀ := iSup_le fun _n => (measurable_integerWord F hF _ _).comap_le
omit [Nonempty A] in
include m₀ in
lemma processPast_zero_le_full (F : ℤ → Ω → A) : processPast F 0 ≤ processFull F := by
let _ := m₀
apply iSup_le
intro n
have hh := integerWord_subword_measurable F (-(n:ℤ)) 0 n (2*n+1) (by omega)
simp only [Nat.cast_zero,add_zero] at hh
have hh' : MeasurableSpace.comap (integerWord F (0-(n:ℤ)) n) inferInstance ≤
MeasurableSpace.comap (integerWord F (-(n:ℤ)) (2*n+1)) inferInstance := by
simpa only [zero_sub] using hh.comap_le
change _ ≤ ⨆ m : ℕ, MeasurableSpace.comap (integerWord F (-(m:ℤ)) (2*m+1)) inferInstance
exact le_iSup_of_le n hh'
variable (U : ℤ → Ω → Ω) (hU : ∀ s, MeasurePreserving (U s) μ μ)
(F : ℤ → Ω → A) (hF : ∀ t, Measurable (F t))
(htrans : ∀ t s x, F (t+s) x = F t (U s x))
(G : ℤ → Ω → B) (hG : ∀ t, Measurable (G t))
(hGtrans : ∀ t s x, G (t+s) x = G t (U s x))
(htail : ∀ t s, Measurable[completedFactor (m₀ := m₀) μ (processPast F t)] (G s))
include htail hF in
lemma tail_word_conditional_lower (n : ℕ) (r : ℝ)
(hr : ∀ (t : ℤ) (m : ℕ), r ≤ randomConditionalEntropy μ (F t) (integerWord F (t-m) m)) :
(n : ℝ) * r ≤ randomConditionalEntropy μ (integerWord F 0 n) (integerWord G 0 n) := by
have hg s : Measurable (G s) := (htail 0 s).mono (completedFactor_le μ _) le_rfl
apply integerWord_conditional_lower μ F hF (integerWord G 0 n) (measurable_integerWord G hg _ _) 0 n r
intro j hj
apply conditional_entropy_lower_of_completed μ (fun m => integerWord F ((0+(j:ℤ))-m) m)
(fun m => measurable_integerWord F hF _ _) (pastWord_comap_mono F _) (F (0+(j:ℤ))) (hF _) _ ?_ r (hr _)
apply Measurable.prodMk
· exact @Measurable.of_eval Ω (Fin n) (fun _ => B)
(completedFactor (m₀ := m₀) μ (processPast F (0+(j:ℤ)))) _
(integerWord G 0 n) (fun i => htail _ _)
· have hh : MeasurableSpace.comap (integerWord F 0 j) inferInstance ≤ processPast F (0+(j:ℤ)) := by
have hh := le_iSup (fun m : ℕ => MeasurableSpace.comap (integerWord F ((0+(j:ℤ))-m) m) inferInstance) j
simpa only [processPast,zero_add,sub_self] using hh
exact (comap_measurable _).mono (hh.trans (le_completedFactor μ (processPast_le F hF _))) le_rfl
omit [Nonempty B] in
include hU hF htrans hG hGtrans in
lemma tail_word_conditional_upper (M n : ℕ) (ε : ℝ)
(he : randomConditionalEntropy μ (G 0) (integerWord F (-(M:ℤ)) (2*M+1)) ≤ ε) :
randomConditionalEntropy μ (integerWord G 0 n) (integerWord F (-(M:ℤ)) (n+2*M)) ≤ n*ε := by
apply (integerWord_conditional_le_sum μ G hG _ (measurable_integerWord F hF _ _) 0 n).trans
calc
_ ≤ ∑ j ∈ Finset.range n, ε := by
apply Finset.sum_le_sum
intro j hj
have hj' := Finset.mem_range.mp hj
have hs := integerWord_subword_measurable F (-(M:ℤ)) j (2*M+1) (n+2*M) (by omega)
have hc := randomConditionalEntropy_measurable_factor μ (G (0+(j:ℤ)))
(integerWord F (-(M:ℤ)+(j:ℤ)) (2*M+1)) (integerWord F (-(M:ℤ)) (n+2*M))
(hG _) (measurable_integerWord F hF _ _) hs
have hf : G (0+(j:ℤ)) = G 0 ∘ U j := funext fun x => hGtrans 0 j x
rw [integerWord_translate U F htrans,hf,
randomConditionalEntropy_measurePreserving μ μ (hU j) _ _ (hG _) (measurable_integerWord F hF _ _)] at hc
simpa only [hf] using hc.trans he
_ = n*ε := by simp
include hU hF htrans hG hGtrans htail in
theorem tail_process_entropy_zero :
Tendsto (fun n : ℕ => randomEntropy μ (integerWord G 0 n) / n) atTop (𝓝 0) := by
obtain ⟨h,hpos,hlower,hrate⟩ := stationary_entropy_rate μ U hU F hF htrans
apply entropy_zero_of_tail_bounds (fun n => randomEntropy μ (integerWord F 0 n))
(fun n => randomEntropy μ (integerWord G 0 n)) h hrate
(fun n => randomEntropy_nonneg μ _ (measurable_integerWord G hG _ _))
intro ε hε
have hfull : Measurable[completedFactor (m₀ := m₀) μ (processFull F)] (G 0) :=
(htail 0 0).mono (completedFactor_mono μ (processPast_zero_le_full F)) le_rfl
obtain ⟨M,hM⟩ := exists_conditional_entropy_lt_of_completed μ
(fun m => integerWord F (-(m:ℤ)) (2*m+1)) (fun m => measurable_integerWord F hF _ _)
(windowWord_comap_mono F) (G 0) hfull ε hε
refine ⟨2*M,fun n => ?_⟩
have hlo := tail_word_conditional_lower μ F hF G htail n h hlower
have hup := tail_word_conditional_upper μ U hU F hF htrans G hG hGtrans M n ε hM.le
have he : randomEntropy μ (fun x => (integerWord G 0 n x,integerWord F 0 n x)) ≤
randomEntropy μ (fun x => (integerWord F (-(M:ℤ)) (n+2*M) x,integerWord G 0 n x)) := by
let e : (Fin (n+2*M) → A) × (Fin n → B) → (Fin n → B) × (Fin n → A) :=
fun z => (z.2,fun i => z.1 ⟨M+i.val,by omega⟩)
have heq : (fun x => (integerWord G 0 n x,integerWord F 0 n x)) =
e ∘ (fun x => (integerWord F (-(M:ℤ)) (n+2*M) x,integerWord G 0 n x)) := by
funext x
apply Prod.ext
· rfl
· funext i
dsimp [e,integerWord]
congr 1
ring
rw [heq]
exact randomEntropy_comp_le _ ((measurable_integerWord F hF _ _).prodMk (measurable_integerWord G hG _ _)) e
rw [randomEntropy_pair μ _ _ (measurable_integerWord F hF _ _) (measurable_integerWord G hG _ _),
randomEntropy_pair μ _ _ (measurable_integerWord G hG _ _) (measurable_integerWord F hF _ _),
integerWord_entropy_translate μ U hU F hF htrans] at he
linarith
end
section
open Filter
open scoped Topology
variable {𝕜 H : Type*} [RCLike 𝕜] [NormedAddCommGroup H] [InnerProductSpace 𝕜 H]
[CompleteSpace H]
local instance complete_iInf (K : ℕ → Submodule 𝕜 H) [∀ n, CompleteSpace (K n)] :
CompleteSpace ↥(⨅ n, K n) := by
have h : IsClosed (↑(⨅ n, K n) : Set H) := by
simp only [Submodule.coe_iInf]
exact isClosed_iInter fun n => (completeSpace_coe_iff_isComplete.mp (inferInstance : CompleteSpace (K n))).isClosed
exact h.completeSpace_coe
lemma antitone_projection_tendsto (K : ℕ → Submodule 𝕜 H)
[∀ n, CompleteSpace (K n)] (hK : Antitone K) (x : H) :
Tendsto (fun n => (K n).starProjection x) atTop
(𝓝 ((⨅ n, K n).starProjection x)) := by
have he : (⨆ n, (K n)ᗮ)ᗮ = ⨅ n, K n := by
apply le_antisymm
· apply le_iInf
intro n
simpa only [Submodule.orthogonal_orthogonal] using
(Submodule.orthogonal_le (le_iSup (fun n => (K n)ᗮ) n))
· intro x hx y hy
have hy' : y ∈ (⨅ n, K n)ᗮ :=
(iSup_le (fun n => Submodule.orthogonal_le (iInf_le K n))) hy
exact inner_eq_zero_symm.mp (hy' x hx)
have he' : (⨆ n, (K n)ᗮ).topologicalClosure = (⨅ n, K n)ᗮ := by
rw [←Submodule.orthogonal_orthogonal_eq_closure,he]
have ht := Submodule.starProjection_tendsto_closure_iSup
(fun n => (K n)ᗮ) (fun a b h => Submodule.orthogonal_le (hK h)) x
simp only [he'] at ht
have hh := (tendsto_const_nhds (x := x) (f := atTop)).sub ht
simpa only [Submodule.starProjection_orthogonal_val,sub_sub_cancel] using hh
end
section
open MeasureTheory Filter
open scoped ENNReal Topology
variable {Ω : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω)
lemma lpMeas_completed_eq (m : MeasurableSpace Ω) (hm : m ≤ m₀) :
@lpMeas Ω ℝ ℝ _ _ _ (completedFactor (m₀ := m₀) μ m) m₀ 2 μ = @lpMeas Ω ℝ ℝ _ _ _ m m₀ 2 μ := by
ext f
simp only [mem_lpMeas_iff_aestronglyMeasurable]
constructor
· intro h
have hm' : Measurable[completedFactor (m₀ := m₀) μ m] (h.mk f) := h.stronglyMeasurable_mk.measurable
exact (aeStrong_of_measurable_completed (m₀ := m₀) μ m hm').congr h.ae_eq_mk.symm
· exact fun h => h.mono (le_completedFactor (m₀ := m₀) μ hm)
lemma lpMeas_completed_iInf (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀) :
@lpMeas Ω ℝ ℝ _ _ _ (⨅ n, completedFactor (m₀ := m₀) μ (m n)) m₀ 2 μ = ⨅ n, @lpMeas Ω ℝ ℝ _ _ _ (m n) m₀ 2 μ := by
ext f
simp only [Submodule.mem_iInf,mem_lpMeas_iff_aestronglyMeasurable]
constructor
· intro h n
have h' := h.mono (iInf_le (fun n => completedFactor (m₀ := m₀) μ (m n)) n)
have hh : f ∈ @lpMeas Ω ℝ ℝ _ _ _ (completedFactor (m₀ := m₀) μ (m n)) m₀ 2 μ := by
exact mem_lpMeas_iff_aestronglyMeasurable.mpr h'
rw [lpMeas_completed_eq μ (m n) (hm n)] at hh
exact mem_lpMeas_iff_aestronglyMeasurable.mp hh
· intro h
exact (completedFactor_iInf_measurable μ m (Lp.stronglyMeasurable f).measurable h).stronglyMeasurable.aestronglyMeasurable
lemma reverse_conditional_L2 (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) (f : Lp ℝ 2 μ) :
Tendsto (fun n => (condExpL2 ℝ ℝ (hm n) f : Lp ℝ 2 μ)) atTop
(𝓝 (condExpL2 ℝ ℝ
(show (⨅ n, completedFactor (m₀ := m₀) μ (m n)) ≤ m₀ from
(iInf_le _ 0).trans (completedFactor_le μ (m 0))) f : Lp ℝ 2 μ)) := by
let K : ℕ → Submodule ℝ (Lp ℝ 2 μ) := fun n => @lpMeas Ω ℝ ℝ _ _ _ (m n) m₀ 2 μ
let (n : ℕ) : Fact (m n ≤ m₀) := ⟨hm n⟩
have hK : Antitone K := by
intro a b hab f hf
exact mem_lpMeas_iff_aestronglyMeasurable.mpr
((mem_lpMeas_iff_aestronglyMeasurable.mp hf).mono (hanti hab))
have h := antitone_projection_tendsto K hK f
have ht : Fact ((⨅ n, completedFactor (m₀ := m₀) μ (m n)) ≤ m₀) :=
⟨(iInf_le _ 0).trans (completedFactor_le μ (m 0))⟩
let := ht
simpa only [K, ←lpMeas_completed_iInf μ m hm, Submodule.starProjection_apply,condExpL2] using h
end
section
open MeasureTheory Filter
open scoped Topology RealInnerProductSpace
variable {Ω : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
omit [IsProbabilityMeasure μ] in
lemma reverse_tail_pairing (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) (f : Lp ℝ 2 μ) (g : ℕ → Lp ℝ 2 μ)
(hg : ∀ n, AEStronglyMeasurable[m n] (g n) μ)
(hb : ∀ n, ‖g n‖ ≤ 1) :
Tendsto (fun n => ⟪f - (condExpL2 ℝ ℝ
(show (⨅ n, completedFactor (m₀ := m₀) μ (m n)) ≤ m₀ from
(iInf_le _ 0).trans (completedFactor_le μ (m 0))) f : Lp ℝ 2 μ), g n⟫)
atTop (𝓝 0) := by
let ft : Lp ℝ 2 μ := condExpL2 ℝ ℝ
(show (⨅ n, completedFactor (m₀ := m₀) μ (m n)) ≤ m₀ from
(iInf_le _ 0).trans (completedFactor_le μ (m 0))) f
have he n : ⟪f-ft,g n⟫ = ⟪(condExpL2 ℝ ℝ (hm n) f : Lp ℝ 2 μ)-ft,g n⟫ := by
simp only [inner_sub_left,inner_condExpL2_eq_inner_fun (hm n) f (g n) (hg n)]
have hbound n : |⟪f-ft,g n⟫| ≤ ‖(condExpL2 ℝ ℝ (hm n) f : Lp ℝ 2 μ)-ft‖ := by
rw [he]
exact (abs_real_inner_le_norm _ _).trans (by nlinarith [norm_nonneg ((condExpL2 ℝ ℝ (hm n) f : Lp ℝ 2 μ)-ft),hb n])
have ht : Tendsto (fun n => ‖(condExpL2 ℝ ℝ (hm n) f : Lp ℝ 2 μ)-ft‖) atTop (𝓝 0) := by
simpa only [ft,sub_self,norm_zero] using ((reverse_conditional_L2 μ m hm hanti f).sub (tendsto_const_nhds (x := ft))).norm
exact squeeze_zero_norm (fun n => by simpa only [Real.norm_eq_abs] using hbound n) ht
lemma reverse_tail_pairing_of_bound (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) (f : Lp ℝ 2 μ) (g : ℕ → Lp ℝ 2 μ)
(hg : ∀ n, AEStronglyMeasurable[m n] (g n) μ)
(hb : ∀ n, ∀ᵐ x ∂μ, |g n x| ≤ 1) :
Tendsto (fun n => ⟪f - (condExpL2 ℝ ℝ
(show (⨅ n, completedFactor (m₀ := m₀) μ (m n)) ≤ m₀ from
(iInf_le _ 0).trans (completedFactor_le μ (m 0))) f : Lp ℝ 2 μ), g n⟫)
atTop (𝓝 0) := by
apply reverse_tail_pairing μ m hm hanti f g hg
intro n
simpa only [measureUnivNNReal,measure_univ,ENNReal.toNNReal_one,NNReal.coe_one,Real.one_rpow,one_mul]
using Lp.norm_le_of_ae_bound (f := g n) (by norm_num : (0 : ℝ) ≤ 1) (hb n)
end
section
open MeasureTheory Filter
variable {Ω A : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω)
[MeasurableSpace A]
omit m₀ in
lemma processPast_eq_generators (F : ℤ → Ω → A) (t : ℤ) :
processPast F t = ⨆ q : {q : ℤ // q < t}, MeasurableSpace.comap (F q) inferInstance := by
change (⨆ n : ℕ, MeasurableSpace.comap (fun x (i : Fin n) => F (t-(n:ℤ)+(i.val:ℤ)) x) inferInstance) = _
simp_rw [MeasurableSpace.comap_process_pi]
apply le_antisymm
· apply iSup_le
intro n
apply iSup_le
intro i
apply le_iSup_of_le ⟨t-(n:ℤ)+(i.val:ℤ),by omega⟩
exact le_rfl
· apply iSup_le
intro q
let n := (t-q.val).toNat
have hn : (n:ℤ) = t-q.val := by dsimp [n]; omega
have hnpos : 0 < n := by have := q.property; omega
apply le_iSup_of_le n
apply le_iSup_of_le (⟨0,hnpos⟩ : Fin n)
simp only [Nat.cast_zero,add_zero,hn,sub_sub_cancel]
exact le_rfl
omit m₀ in
lemma processPast_mono (F : ℤ → Ω → A) : Monotone (processPast F) := by
intro s t h
rw [processPast_eq_generators,processPast_eq_generators]
apply iSup_le
intro q
exact le_iSup_of_le ⟨q.val,q.property.trans_le h⟩ le_rfl
lemma completedFactor_comap {f : Ω → Ω} (hf : MeasurePreserving f μ μ)
{m n : MeasurableSpace Ω} (h : MeasurableSpace.comap f m ≤ n) :
MeasurableSpace.comap f (completedFactor (m₀ := m₀) μ m) ≤ completedFactor (m₀ := m₀) μ n := by
rintro s ⟨r,hr,rfl⟩
obtain ⟨hr,v,hv,he⟩ := hr
change MeasurableSet[m₀] (f ⁻¹' r) ∧ ∃ v, MeasurableSet[n] v ∧ ∀ᵐ x ∂μ, x ∈ f ⁻¹' r ↔ x ∈ v
let : MeasurableSpace Ω := m₀
have hfm : @Measurable Ω Ω m₀ m₀ f := hf.measurable
have hea : ∀ᵐ x ∂μ, f x ∈ r ↔ f x ∈ v :=
hf.quasiMeasurePreserving.ae he
exact ⟨hfm hr,f ⁻¹' v,h _ ⟨v,hv,rfl⟩,hea⟩
omit m₀ in
lemma processPast_comap (U : ℤ → Ω → Ω) (F : ℤ → Ω → A)
(htrans : ∀ t s x, F (t+s) x = F t (U s x)) (t s : ℤ) :
MeasurableSpace.comap (U s) (processPast F t) ≤ processPast F (t+s) := by
rw [processPast_eq_generators,MeasurableSpace.comap_iSup,processPast_eq_generators]
apply iSup_le
intro q
rw [MeasurableSpace.comap_comp]
have he : F (q.val+s) = F q ∘ U s := funext fun x => htrans q s x
rw [←he]
exact le_iSup_of_le ⟨q.val+s,by have := q.property; omega⟩ le_rfl
abbrev processTail (F : ℤ → Ω → A) : MeasurableSpace Ω :=
⨅ n : ℕ, completedFactor (m₀ := m₀) μ (processPast F (-(n:ℤ)))
lemma processTail_le (F : ℤ → Ω → A) : processTail μ F ≤ m₀ :=
(iInf_le _ 0).trans (completedFactor_le μ _)
lemma processTail_le_past (F : ℤ → Ω → A) (t : ℤ) :
processTail μ F ≤ completedFactor (m₀ := m₀) μ (processPast F t) := by
have h : -(((-t).toNat : ℕ) : ℤ) ≤ t := by omega
exact (iInf_le _ ((-t).toNat)).trans (completedFactor_mono μ (processPast_mono F h))
lemma processTail_comap (U : ℤ → Ω → Ω) (hU : ∀ s, MeasurePreserving (U s) μ μ)
(F : ℤ → Ω → A) (htrans : ∀ t s x, F (t+s) x = F t (U s x)) (s : ℤ) :
MeasurableSpace.comap (U s) (processTail μ F) ≤ processTail μ F := by
apply le_iInf
intro n
have h := MeasurableSpace.comap_mono (g := U s) (processTail_le_past μ F (-(n:ℤ)-s))
apply h.trans
have ht := completedFactor_comap μ (hU s) (processPast_comap U F htrans (-(n:ℤ)-s) s)
simpa only [sub_add_cancel] using ht
lemma measurable_tail_translate {B : Type*} [MeasurableSpace B]
(U : ℤ → Ω → Ω) (hU : ∀ s, MeasurePreserving (U s) μ μ)
(F : ℤ → Ω → A) (htrans : ∀ t s x, F (t+s) x = F t (U s x))
(g : Ω → B) (hg : Measurable[processTail μ F] g) (s t : ℤ) :
Measurable[completedFactor (m₀ := m₀) μ (processPast F t)] (g ∘ U s) := by
have hu : @Measurable Ω Ω (processTail μ F) (processTail μ F) (U s) :=
measurable_iff_comap_le.mpr (processTail_comap μ U hU F htrans s)
exact (hg.comp hu).mono (processTail_le_past μ F t) le_rfl
end
section
open MeasureTheory Filter
open scoped Topology ENNReal NNReal
lemma antitone_starProjection_tendsto {𝕜 H : Type*} [RCLike 𝕜]
[NormedAddCommGroup H] [InnerProductSpace 𝕜 H] [CompleteSpace H]
(V : ℕ → Submodule 𝕜 H) [∀ n, (V n).HasOrthogonalProjection]
[(⨅ n, V n).HasOrthogonalProjection]
(hV : Antitone V) (x : H) :
Tendsto (fun n => (V n).starProjection x) atTop
(𝓝 ((⨅ n, V n).starProjection x)) := by
have hmono : Monotone (fun n => (V n)ᗮ) := fun _ _ h => Submodule.orthogonal_le (hV h)
have he : (⨆ n, (V n)ᗮ).topologicalClosure = (⨅ n, V n)ᗮ := by
rw [← Submodule.orthogonal_orthogonal_eq_closure, ← Submodule.iInf_orthogonal]
simp only [Submodule.orthogonal_orthogonal]
have ht := Submodule.starProjection_tendsto_closure_iSup (fun n => (V n)ᗮ) hmono x
simp only [he] at ht
have hh := (tendsto_const_nhds (x := x) (f := atTop)).sub ht
simpa only [Submodule.starProjection_orthogonal, sub_apply,
ContinuousLinearMap.id_apply, sub_sub_cancel] using hh
variable {Ω : Type*} {m₀ : MeasurableSpace Ω} {μ : Measure Ω}
lemma lpMeas_iInf_antitone (m : ℕ → MeasurableSpace Ω) (_hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) :
lpMeas ℝ ℝ (⨅ n, m n) 2 μ = ⨅ n, lpMeas ℝ ℝ (m n) 2 μ := by
apply le_antisymm
· apply le_iInf
intro n f hf
exact mem_lpMeas_iff_aestronglyMeasurable.mpr
((mem_lpMeas_iff_aestronglyMeasurable.mp hf).mono (iInf_le _ n))
· intro f hf
have hf' (n : ℕ) : AEStronglyMeasurable[m n] f μ :=
mem_lpMeas_iff_aestronglyMeasurable.mp (((Submodule.mem_iInf _).mp hf) n)
let g : ℕ → Ω → ℝ := fun n => (hf' n).mk f
let F : Ω → ℝ := fun ω => limUnder atTop (fun n => g n ω)
have hg (n : ℕ) : StronglyMeasurable[m n] (g n) := (hf' n).stronglyMeasurable_mk
have hF (j : ℕ) : StronglyMeasurable[m j] F := by
have hg' (n : ℕ) : StronglyMeasurable[m j] (g (n+j)) :=
(hg (n+j)).mono (hanti (Nat.le_add_left j n))
let : MeasurableSpace Ω := m j
have hh := StronglyMeasurable.limUnder (l := atTop) hg'
convert hh using 1
funext ω
dsimp [F]
unfold limUnder
rw [show (fun n => g (n+j) ω) = (fun n => g n ω) ∘ (fun n => n+j) from rfl,
← Filter.map_map, map_add_atTop_eq_nat]
have hmeas : Measurable[⨅ n, m n] F := by
intro S hS
exact MeasurableSpace.measurableSet_iInf.mpr (fun j => (hF j).measurable hS)
apply mem_lpMeas_iff_aestronglyMeasurable.mpr
refine hmeas.stronglyMeasurable.aestronglyMeasurable.congr ?_
filter_upwards [ae_all_iff.mpr (fun n => (hf' n).ae_eq_mk)] with ω hω
have he : (fun n => g n ω) = fun _ => f ω := funext (fun n => (hω n).symm)
change limUnder atTop (fun n => g n ω) = f ω
rw [he]
exact tendsto_const_nhds.limUnder_eq
lemma condExpL2_antitone_tendsto (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) (f : Lp ℝ 2 μ) :
Tendsto (fun n => (condExpL2 ℝ ℝ (hm n) f : Lp ℝ 2 μ)) atTop
(𝓝 (condExpL2 ℝ ℝ ((iInf_le m 0).trans (hm 0)) f : Lp ℝ 2 μ)) := by
let V (n : ℕ) := lpMeas ℝ ℝ (m n) 2 μ
have inst (n : ℕ) : (V n).HasOrthogonalProjection := by
let : Fact (m n ≤ m₀) := ⟨hm n⟩
dsimp [V]
infer_instance
have hme : (⨅ n, V n) = lpMeas ℝ ℝ (⨅ n, m n) 2 μ :=
(lpMeas_iInf_antitone m hm hanti).symm
have inst' : (⨅ n, V n).HasOrthogonalProjection := by
rw [hme]
let : Fact ((⨅ n, m n) ≤ m₀) := ⟨(iInf_le m 0).trans (hm 0)⟩
infer_instance
let := inst
let := inst'
have hV : Antitone V := by
intro i j hij f hf
exact mem_lpMeas_iff_aestronglyMeasurable.mpr
((mem_lpMeas_iff_aestronglyMeasurable.mp hf).mono (hanti hij))
have h := antitone_starProjection_tendsto V hV f
simp only [hme] at h
exact h
lemma integral_norm_L2_le [IsProbabilityMeasure μ] (f : Lp ℝ 2 μ) :
(∫ ω, ‖f ω‖ ∂μ) ≤ ‖f‖ := by
rw [← lpNorm_one_eq_integral_norm (Lp.aestronglyMeasurable f), lpNorm, Lp.norm_def]
exact ENNReal.toReal_mono (Lp.eLpNorm_ne_top f)
(eLpNorm_le_eLpNorm_of_exponent_le (by norm_num : (1 : ℝ≥0∞) ≤ 2))
lemma condExp_antitone_L1_tendsto [IsProbabilityMeasure μ]
(m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) {f : Ω → ℝ} (hf : MemLp f 2 μ) :
Tendsto (fun n => ∫ ω, ‖μ[f | m n] ω - μ[f | ⨅ i, m i] ω‖ ∂μ) atTop (𝓝 0) := by
let ht : (⨅ i, m i) ≤ m₀ := (iInf_le m 0).trans (hm 0)
let c (n : ℕ) : Lp ℝ 2 μ := condExpL2 ℝ ℝ (hm n) hf.toLp
let d : Lp ℝ 2 μ := condExpL2 ℝ ℝ ht hf.toLp
have hc := condExpL2_antitone_tendsto m hm hanti hf.toLp
change Tendsto c atTop (𝓝 d) at hc
have hc' : Tendsto (fun n => ‖c n - d‖) atTop (𝓝 0) := by
simpa using (hc.sub (tendsto_const_nhds (x := d) (f := atTop))).norm
apply squeeze_zero (fun _ => integral_nonneg (fun _ => norm_nonneg _)) _ hc'
intro n
calc
(∫ ω, ‖μ[f | m n] ω - μ[f | ⨅ i, m i] ω‖ ∂μ) = ∫ ω, ‖(c n - d) ω‖ ∂μ := by
apply integral_congr_ae
filter_upwards [hf.condExpL2_ae_eq_condExp (𝕜 := ℝ) (hm n), hf.condExpL2_ae_eq_condExp (𝕜 := ℝ) ht,
Lp.coeFn_sub (c n) d] with ω hn hd he
rw [he]
change c n ω = μ[f | m n] ω at hn
change d ω = μ[f | ⨅ i, m i] ω at hd
simp only [Pi.sub_apply, hn, hd]
_ ≤ ‖c n - d‖ := integral_norm_L2_le _
end
open MeasureTheory Filter
open scoped Topology
variable {Ω : Type*} [m₀ : MeasurableSpace Ω] (μ : Measure Ω) [IsProbabilityMeasure μ]
def clippedConditional (m : MeasurableSpace Ω) (f : Ω → ℝ) : Ω → ℝ :=
fun x => max 0 (min 1 (μ[f | m] x))
omit [IsProbabilityMeasure μ] in
lemma clippedConditional_bounds (m : MeasurableSpace Ω) (f : Ω → ℝ) (x : Ω) :
clippedConditional (m₀ := m₀) μ m f x ∈ Set.Icc (0:ℝ) 1 := by
exact ⟨le_max_left _ _,max_le (by norm_num) (min_le_left _ _)⟩
omit [IsProbabilityMeasure μ] in
lemma clippedConditional_measurable (m : MeasurableSpace Ω) (f : Ω → ℝ) :
Measurable[m] (clippedConditional (m₀ := m₀) μ m f) := by
exact measurable_const.max (measurable_const.min stronglyMeasurable_condExp.measurable)
omit [IsProbabilityMeasure μ] in
lemma clippedConditional_ae (m : MeasurableSpace Ω) (f : Ω → ℝ)
(hf : ∀ᵐ x ∂μ, f x ∈ Set.Icc (0:ℝ) 1) :
clippedConditional (m₀ := m₀) μ m f =ᵐ[μ] μ[f | m] := by
let : MeasurableSpace Ω := m₀
have hn := condExp_nonneg (m := m) (hf.mono fun _ h => h.1)
have hb := condExp_le_nonneg_const (m := m) (show (0:ℝ) ≤ 1 by norm_num) (hf.mono fun _ h => h.2)
filter_upwards [hn,hb] with x hx hy
change (0:ℝ) ≤ μ[f | m] x at hx
simp only [clippedConditional,min_eq_right hy,max_eq_right hx]
lemma clippedConditional_mean (m : MeasurableSpace Ω) (hm : m ≤ m₀) (f : Ω → ℝ)
(hf : ∀ᵐ x ∂μ, f x ∈ Set.Icc (0:ℝ) 1) :
(∫ x, clippedConditional (m₀ := m₀) μ m f x ∂μ) = ∫ x, f x ∂μ := by
let : MeasurableSpace Ω := m₀
rw [integral_congr_ae (clippedConditional_ae (m₀ := m₀) μ m f hf),integral_condExp hm]
lemma exists_simple_interval_approx (m : MeasurableSpace Ω) (hm : m ≤ m₀)
(g : Ω → ℝ) (hg : Measurable[m] g) (hb : ∀ x, g x ∈ Set.Icc (0:ℝ) 1)
(ε : ℝ) (hε : 0 < ε) :
∃ s : @SimpleFunc Ω m ℝ, (∀ x, s x ∈ Set.Icc (0:ℝ) 1) ∧
(∫ x, |s x-g x| ∂μ) < ε := by
let s : ℕ → @SimpleFunc Ω m ℝ := fun n =>
SimpleFunc.approxOn g hg (Set.Icc 0 1) 0 (by norm_num) n
have hs n x : s n x ∈ Set.Icc (0:ℝ) 1 := SimpleFunc.approxOn_mem hg (by norm_num) n x
have hsm n : Measurable[m₀] (s n) := (s n).measurable.mono hm le_rfl
have hgm : Measurable[m₀] g := hg.mono hm le_rfl
have hlim x : Tendsto (fun n => |s n x-g x|) atTop (𝓝 (0:ℝ)) := by
have ht : Tendsto (fun n => s n x) atTop (𝓝 (g x)) :=
SimpleFunc.tendsto_approxOn hg (by norm_num) (subset_closure (hb x))
simpa only [sub_self,abs_zero] using (ht.sub_const (g x)).abs
have hbound n : ∀ᵐ x ∂μ, ‖|s n x-g x|‖ ≤ (1:ℝ) := by
filter_upwards with x
rw [Real.norm_eq_abs,abs_abs]
exact abs_le.mpr ⟨by have h1 := (hs n x).1; have h2 := (hb x).2; linarith,
by have h1 := (hs n x).2; have h2 := (hb x).1; linarith⟩
let : MeasurableSpace Ω := m₀
have ht : Tendsto (fun n => ∫ x, |s n x-g x| ∂μ) atTop (𝓝 (0:ℝ)) := by
simpa only [integral_zero,Pi.sub_apply] using tendsto_integral_of_dominated_convergence (μ := μ)
(fun _ => (1:ℝ)) (fun n => ((hsm n).sub hgm).abs.aestronglyMeasurable)
(integrable_const _) hbound (Eventually.of_forall hlim)
obtain ⟨n,hn⟩ := (ht.eventually (gt_mem_nhds hε)).exists
exact ⟨s n,hs n,hn⟩
lemma reverse_condExp_completed_L1 (m : ℕ → MeasurableSpace Ω) (hm : ∀ n, m n ≤ m₀)
(hanti : Antitone m) {f : Ω → ℝ} (hf : MemLp f 2 μ) :
Tendsto (fun n => ∫ x, ‖μ[f | m n] x - μ[f | ⨅ j, completedFactor (m₀ := m₀) μ (m j)] x‖ ∂μ)
atTop (𝓝 (0:ℝ)) := by
let ht : (⨅ j, completedFactor (m₀ := m₀) μ (m j)) ≤ m₀ :=
(iInf_le _ 0).trans (completedFactor_le μ _)
let c n : Lp ℝ 2 μ := condExpL2 ℝ ℝ (hm n) hf.toLp
let d : Lp ℝ 2 μ := condExpL2 ℝ ℝ ht hf.toLp
have hc := reverse_conditional_L2 μ m hm hanti hf.toLp
change Tendsto c atTop (𝓝 d) at hc
have hnorm : Tendsto (fun n => ‖c n-d‖) atTop (𝓝 (0:ℝ)) := by
simpa only [sub_self,norm_zero] using (hc.sub (tendsto_const_nhds (x := d))).norm
apply squeeze_zero (fun _ => integral_nonneg fun _ => norm_nonneg _) _ hnorm
intro n
have he : (∫ x, ‖μ[f | m n] x-μ[f | ⨅ j, completedFactor (m₀ := m₀) μ (m j)] x‖ ∂μ) =
∫ x, ‖(c n-d) x‖ ∂μ := by
apply integral_congr_ae
filter_upwards [hf.condExpL2_ae_eq_condExp (𝕜 := ℝ) (hm n),
hf.condExpL2_ae_eq_condExp (𝕜 := ℝ) ht,Lp.coeFn_sub (c n) d] with x hx hy hz
rw [hz]
change c n x = _ at hx
change d x = _ at hy
simp only [Pi.sub_apply,hx,hy]
rw [he]
exact integral_norm_L2_le _
end Rokhlin
end
end OAI
import OAI.Dynamics.MultipleMixing.Foundations
namespace OAI
noncomputable section
namespace Rokhlin
section
open MeasureTheory Filter
open scoped BigOperators Topology
variable {A B C : Type*} [Fintype A] [Fintype B] [Fintype C]
lemma shannonEntropy_eq_negMulLog (p : A → ℝ) :
shannonEntropy p = ∑ a, Real.negMulLog (p a) := rfl
def rowEntropy (p : A → ℝ) : ℝ :=
shannonEntropy p - Real.negMulLog (∑ a, p a)
lemma rowEntropy_zero : rowEntropy (fun _ : A => 0) = 0 := by
simp [rowEntropy,shannonEntropy,Real.negMulLog]
lemma zero_row {p : A → ℝ} (hp : ∀ a, 0 ≤ p a) (h : ∑ a, p a = 0) (a : A) : p a = 0 := by
exact le_antisymm (h ▸ Finset.single_le_sum (fun a _ => hp a) (Finset.mem_univ a)) (hp a)
lemma rowEntropy_normalize (p : A → ℝ) (hp : ∀ a, 0 ≤ p a) :
rowEntropy p = (∑ a, p a) * shannonEntropy (fun a => p a / ∑ a, p a) := by
classical
let w := ∑ a, p a
have hw : 0 ≤ w := Finset.sum_nonneg (fun a _ => hp a)
by_cases hz : w = 0
· have h0 : p = fun _ => 0 := funext (zero_row hp hz)
subst p
simp [rowEntropy_zero]
· have hs : ∑ a, p a / w = 1 := by rw [←Finset.sum_div,div_self hz]
have he (a : A) : Real.negMulLog (p a) =
p a / w * Real.negMulLog w + w * Real.negMulLog (p a / w) := by
conv_lhs => rw [show p a = w * (p a / w) by field_simp]
exact Real.negMulLog_mul _ _
simp only [rowEntropy,shannonEntropy_eq_negMulLog]
change (∑ a, Real.negMulLog (p a)) - Real.negMulLog w = _
simp_rw [he]
rw [Finset.sum_add_distrib,←Finset.sum_mul,hs,one_mul,←Finset.mul_sum]
ring
lemma rowEntropy_sum_le (p : B → A → ℝ) (hp : ∀ b a, 0 ≤ p b a) :
(∑ b, rowEntropy (p b)) ≤ rowEntropy (fun a => ∑ b, p b a) := by
classical
let w (b : B) := ∑ a, p b a
let s := ∑ b, w b
have hw (b : B) : 0 ≤ w b := Finset.sum_nonneg (fun a _ => hp b a)
have hs : 0 ≤ s := Finset.sum_nonneg (fun b _ => hw b)
by_cases hz : s = 0
· have hw0 b : w b = 0 := zero_row hw hz b
have hp0 b a : p b a = 0 := zero_row (hp b) (hw0 b) a
have hpz : p = fun _ _ => 0 := funext fun b => funext (hp0 b)
rw [hpz]
simp only [Finset.sum_const_zero,rowEntropy_zero,le_refl]
· have hspos : 0 < s := lt_of_le_of_ne hs (Ne.symm hz)
have hweights : ∑ b, w b / s = 1 := by rw [←Finset.sum_div,div_self hz]
have he (a : A) : ∑ b, (w b / s) * (p b a / w b) = (∑ b, p b a) / s := by
rw [Finset.sum_div]
apply Finset.sum_congr rfl
intro b _
by_cases hwb : w b = 0
· rw [zero_row (hp b) hwb a,hwb]; simp
· field_simp
have hj (a : A) : ∑ b, (w b / s) * Real.negMulLog (p b a / w b) ≤
Real.negMulLog ((∑ b, p b a) / s) := by
have h := Real.concaveOn_negMulLog.le_map_sum
(t := Finset.univ) (w := fun b => w b / s) (p := fun b => p b a / w b)
(fun b _ => div_nonneg (hw b) hs) hweights
(fun b _ => div_nonneg (hp b a) (hw b))
simpa only [smul_eq_mul,he] using h
rw [rowEntropy_normalize _ (fun a => Finset.sum_nonneg (fun b _ => hp b a))]
have hsum : (∑ a, ∑ b, p b a) = s := Finset.sum_comm
rw [hsum]
calc
∑ b, rowEntropy (p b) = s * ∑ a, ∑ b, (w b / s) * Real.negMulLog (p b a / w b) := by
simp_rw [rowEntropy_normalize _ (hp _),shannonEntropy_eq_negMulLog]
rw [Finset.sum_comm,Finset.mul_sum]
apply Finset.sum_congr rfl
intro b _
rw [←Finset.mul_sum,←mul_assoc,mul_div_cancel₀ _ hz]
_ ≤ s * ∑ a, Real.negMulLog ((∑ b, p b a) / s) :=
mul_le_mul_of_nonneg_left (Finset.sum_le_sum (fun a _ => hj a)) hs
_ = _ := rfl
def conditionalShannon (p : B → A → ℝ) : ℝ := ∑ b, rowEntropy (p b)
lemma shannon_chain_rule (p : B → A → ℝ) :
shannonEntropy (fun z : B × A => p z.1 z.2) =
shannonEntropy (fun b => ∑ a, p b a) + conditionalShannon p := by
simp only [conditionalShannon,rowEntropy,shannonEntropy_eq_negMulLog,Fintype.sum_prod_type,
Finset.sum_sub_distrib]
ring
lemma conditionalShannon_refine (p : C → B → A → ℝ) (hp : ∀ c b a, 0 ≤ p c b a) :
conditionalShannon (fun z : C × B => p z.1 z.2) ≤
conditionalShannon (fun b a => ∑ c, p c b a) := by