| 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 |
|
|
