| import OAI.Probability.GaussianReplacement.Sphere |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| noncomputable section |
| namespace CurrentProjection |
| open InnerProductSpace |
| open InformationTheory |
|
|
| open InformationTheory |
|
|
| lemma joint_le_fst_prod_count {A W : Type*} [MeasurableSpace A] [MeasurableSpace W] |
| [Countable W] [MeasurableSingletonClass W] (P : Measure (A × W)) [SFinite P.fst] : |
| P ≤ P.fst.prod (Measure.count : Measure W) := by |
| apply Measure.le_iff.mpr |
| intro t ht |
| have hm (w : W) : MeasurableSet {a : A | (a,w) ∈ t} := |
| ht.preimage (measurable_id.prodMk measurable_const) |
| calc |
| P t ≤ P (⋃ w : W, Prod.fst ⁻¹' {a : A | (a,w) ∈ t}) := by |
| apply measure_mono |
| intro z hz |
| exact Set.mem_iUnion.mpr ⟨z.2, hz⟩ |
| _ ≤ ∑' w : W, P (Prod.fst ⁻¹' {a : A | (a,w) ∈ t}) := measure_iUnion_le _ |
| _ = ∑' w : W, P.fst {a : A | (a,w) ∈ t} := by |
| congr 1; funext w; exact (Measure.fst_apply (hm w)).symm |
| _ = (P.fst.prod Measure.count) t := by |
| rw [Measure.prod_apply_symm ht, lintegral_count] |
| rfl |
|
|
| lemma joint_ac_fst_prod_count {A W : Type*} [MeasurableSpace A] [MeasurableSpace W] |
| [Countable W] [MeasurableSingletonClass W] (P : Measure (A × W)) [SFinite P.fst] : |
| P ≪ P.fst.prod (Measure.count : Measure W) := (joint_le_fst_prod_count P).absolutelyContinuous |
|
|
| lemma ae_positive_atom {W : Type*} [MeasurableSpace W] [Countable W] |
| [MeasurableSingletonClass W] (π : Measure W) : ∀ᵐ w ∂π, π {w} ≠ 0 := by |
| have : π {w | π {w} = 0} = 0 := by |
| rw [show {w | π {w} = 0} = ⋃ w : {w : W // π {w} = 0}, ({w.1} : Set W) by |
| ext w; simp] |
| exact measure_iUnion_null (fun w => w.2) |
| simpa only [ae_iff, not_not] using this |
|
|
| lemma joint_ac_prod_marginals {A W : Type*} [MeasurableSpace A] [MeasurableSpace W] |
| [Countable W] [MeasurableSingletonClass W] (P : Measure (A × W)) [IsFiniteMeasure P] : |
| P ≪ P.fst.prod P.snd := by |
| apply Measure.AbsolutelyContinuous.mk |
| intro t ht hzero |
| have hm (w : W) : MeasurableSet {a : A | (a,w) ∈ t} := |
| ht.preimage (measurable_id.prodMk measurable_const) |
| have hsec : ∀ᵐ w ∂P.snd, P.fst {a : A | (a,w) ∈ t} = 0 := by |
| rw [Measure.prod_apply_symm ht] at hzero |
| exact (lintegral_eq_zero_iff (measurable_measure_prodMk_right ht)).mp hzero |
| have hslice (w : W) : P (t ∩ Prod.snd ⁻¹' {w}) = 0 := by |
| by_cases hw : P.snd {w} = 0 |
| · exact measure_mono_null Set.inter_subset_right (by rwa [← Measure.snd_apply (measurableSet_singleton w)]) |
| · have hz : P.fst {a : A | (a,w) ∈ t} = 0 := (ae_iff_of_countable.mp hsec) w hw |
| apply measure_mono_null (t:=Prod.fst ⁻¹' {a : A | (a,w) ∈ t}) |
| · rintro ⟨a,v⟩ ⟨ha,hv⟩ |
| have hvw : v = w := hv |
| simpa only [Set.mem_preimage, Set.mem_ofPred_eq, hvw] using ha |
| · rwa [← Measure.fst_apply (hm w)] |
| have he : t = ⋃ w : W, t ∩ Prod.snd ⁻¹' {w} := by ext z; simp |
| rw [he] |
| exact measure_iUnion_null hslice |
|
|
| lemma joint_le_prod_inverse_mass {A W : Type*} [MeasurableSpace A] [MeasurableSpace W] |
| [Countable W] [MeasurableSingletonClass W] (P : Measure (A × W)) [IsFiniteMeasure P] : |
| P ≤ (P.fst.prod P.snd).withDensity (fun z => (P.snd {z.2})⁻¹) := by |
| have hm : Measurable (fun w : W => (P.snd {w})⁻¹) := measurable_of_countable _ |
| rw [← prod_withDensity_right hm] |
| apply Measure.le_iff.mpr |
| intro t ht |
| have htm (w : W) : MeasurableSet {a : A | (a,w) ∈ t} := |
| ht.preimage (measurable_id.prodMk measurable_const) |
| have he : t = ⋃ w : W, t ∩ Prod.snd ⁻¹' {w} := by ext z; simp |
| calc |
| P t ≤ ∑' w : W, P (t ∩ Prod.snd ⁻¹' {w}) := by |
| calc P t = P (⋃ w : W, t ∩ Prod.snd ⁻¹' {w}) := congrArg P he |
| _ ≤ _ := measure_iUnion_le (fun w : W => t ∩ Prod.snd ⁻¹' {w}) |
| _ ≤ ∑' w : W, P.fst {a : A | (a,w) ∈ t} * ((P.snd {w})⁻¹ * P.snd {w}) := by |
| apply ENNReal.tsum_le_tsum |
| intro w |
| by_cases hw : P.snd {w} = 0 |
| · simp only [hw, ENNReal.inv_zero, mul_zero] |
| exact le_of_eq (measure_mono_null Set.inter_subset_right |
| (by rwa [← Measure.snd_apply (measurableSet_singleton w)])) |
| · rw [ENNReal.inv_mul_cancel hw (measure_ne_top _ _), mul_one, Measure.fst_apply (htm w)] |
| apply measure_mono |
| rintro ⟨a,v⟩ ⟨ha,hv⟩ |
| have hvw : v = w := hv |
| simpa only [Set.mem_preimage, Set.mem_ofPred_eq, hvw] using ha |
| _ = (P.fst.prod (P.snd.withDensity (fun w => (P.snd {w})⁻¹))) t := by |
| rw [Measure.prod_apply_symm ht, lintegral_withDensity_eq_lintegral_mul P.snd hm |
| (measurable_measure_prodMk_right ht), lintegral_countable'] |
| congr 1; funext w |
| change P.fst {a : A | (a,w) ∈ t} * ((P.snd {w})⁻¹ * P.snd {w}) = |
| ((P.snd {w})⁻¹ * P.fst {a : A | (a,w) ∈ t}) * P.snd {w} |
| ac_rfl |
|
|
| lemma rnDeriv_le_of_le_withDensity {A : Type*} [MeasurableSpace A] |
| (P Q : Measure A) [IsFiniteMeasure P] [SigmaFinite Q] |
| (b : A → ℝ≥0∞) (hPQ : P ≤ Q.withDensity b) : |
| P.rnDeriv Q ≤ᵐ[Q] b := by |
| apply ae_le_of_forall_setLIntegral_le_of_sigmaFinite (Measure.measurable_rnDeriv P Q) |
| intro s hs hsf |
| calc |
| ∫⁻ x in s, P.rnDeriv Q x ∂Q ≤ P s := Measure.setLIntegral_rnDeriv_le s |
| _ ≤ (Q.withDensity b) s := hPQ s |
| _ = ∫⁻ x in s, b x ∂Q := withDensity_apply _ hs |
|
|
| lemma klDiv_bound_of_llr_le {A : Type*} [MeasurableSpace A] |
| (P Q : Measure A) [IsProbabilityMeasure P] [IsProbabilityMeasure Q] |
| (hPQ : P ≪ Q) (c : A → ℝ) (hci : Integrable c P) |
| (hc : ∀ᵐ x ∂P, llr P Q x ≤ c x) : |
| klDiv P Q ≠ ∞ ∧ (klDiv P Q).toReal ≤ ∫ x, c x ∂P := by |
| have hri : Integrable (fun x => (Q.rnDeriv P x).toReal) P := by |
| simpa only [IntegrableOn, Measure.restrict_univ] using |
| (Measure.integrableOn_toReal_rnDeriv (μ:=Q) (ν:=P) (s:=Set.univ) (measure_ne_top _ _)) |
| have hlo : ∀ᵐ x ∂P, -(Q.rnDeriv P x).toReal ≤ llr P Q x := by |
| filter_upwards [exp_neg_llr hPQ] with x hx |
| have h := Real.add_one_le_exp (-llr P Q x) |
| rw [hx] at h |
| linarith |
| have hli : Integrable (llr P Q) P := integrable_of_le_of_le |
| (measurable_llr P Q).aestronglyMeasurable hlo hc hri.neg hci |
| refine ⟨klDiv_ne_top hPQ hli, ?_⟩ |
| rw [toReal_klDiv_of_measure_eq hPQ (by simp)] |
| exact integral_mono_ae hli hci hc |
|
|
|
|
| noncomputable def shannonEntropy {W : Type*} [MeasurableSpace W] (π : Measure W) : ℝ≥0∞ := |
| ∫⁻ w, ENNReal.ofReal (-Real.log (π {w}).toReal) ∂π |
|
|
| lemma atom_surprisal_nonneg {W : Type*} [MeasurableSpace W] |
| (π : Measure W) [IsProbabilityMeasure π] (w : W) : |
| 0 ≤ -Real.log (π {w}).toReal := by |
| apply neg_nonneg.mpr |
| exact Real.log_nonpos ENNReal.toReal_nonneg (by exact_mod_cast ENNReal.toReal_mono (by simp) (prob_le_one)) |
|
|
| lemma countable_information_le_entropy {A W : Type*} [MeasurableSpace A] [MeasurableSpace W] |
| [Countable W] [MeasurableSingletonClass W] (P : Measure (A × W)) [IsProbabilityMeasure P] |
| (hH : shannonEntropy P.snd ≠ ∞) : |
| klDiv P (P.fst.prod P.snd) ≠ ∞ ∧ |
| (klDiv P (P.fst.prod P.snd)).toReal ≤ (shannonEntropy P.snd).toReal := by |
| let c : W → ℝ := fun w => -Real.log (P.snd {w}).toReal |
| have hcm : Measurable c := measurable_of_countable _ |
| have hci : Integrable c P.snd := |
| (lintegral_ofReal_ne_top_iff_integrable hcm.aestronglyMeasurable |
| (Filter.Eventually.of_forall (atom_surprisal_nonneg P.snd))).mp hH |
| have hcip : Integrable (fun z : A × W => c z.2) P := |
| (integrable_map_measure hcm.aestronglyMeasurable measurable_snd.aemeasurable).mp hci |
| have hPQ := joint_ac_prod_marginals P |
| have hb := rnDeriv_le_of_le_withDensity P (P.fst.prod P.snd) |
| (fun z => (P.snd {z.2})⁻¹) |
| (joint_le_prod_inverse_mass P) |
| have hpos : ∀ᵐ z : A × W ∂P, P.snd {z.2} ≠ 0 := |
| (ae_map_iff measurable_snd.aemeasurable ((Set.to_countable _).measurableSet)).mp (ae_positive_atom P.snd) |
| have hll : ∀ᵐ z ∂P, llr P (P.fst.prod P.snd) z ≤ c z.2 := by |
| filter_upwards [hPQ.ae_le hb, hpos, Measure.rnDeriv_pos hPQ, |
| hPQ.ae_le (Measure.rnDeriv_ne_top P (P.fst.prod P.snd))] with z hz hzp hzr hzt |
| have ht : (P.snd {z.2})⁻¹ ≠ ∞ := by simpa using hzp |
| have hreal := ENNReal.toReal_mono ht hz |
| have hl := Real.log_le_log (ENNReal.toReal_pos hzr.ne' hzt) hreal |
| simpa only [llr, ENNReal.toReal_inv, Real.log_inv, c] using hl |
| obtain ⟨hf, hi⟩ := klDiv_bound_of_llr_le P (P.fst.prod P.snd) hPQ |
| (fun z => c z.2) hcip hll |
| refine ⟨hf, hi.trans_eq ?_⟩ |
| rw [← integral_map measurable_snd.aemeasurable hcm.aestronglyMeasurable] |
| exact (integral_eq_lintegral_of_nonneg_ae (Filter.Eventually.of_forall |
| (atom_surprisal_nonneg P.snd)) hcm.aestronglyMeasurable) |
|
|
|
|
|
|
| lemma klDiv_map_equiv {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (P Q : Measure A) [IsFiniteMeasure P] [IsFiniteMeasure Q] (e : A ≃ᵐ B) : |
| klDiv (P.map e) (Q.map e) = klDiv P Q := by |
| apply le_antisymm (klDiv_map_le P Q e.measurable) |
| have h := klDiv_map_le (P.map e) (Q.map e) e.symm.measurable |
| simpa only [e.map_symm_map] using h |
|
|
| def swapLast {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] : |
| (A × B) × C ≃ᵐ (A × C) × B where |
| toFun p := ((p.1.1,p.2),p.1.2) |
| invFun p := ((p.1.1,p.2),p.1.2) |
| left_inv _ := rfl |
| right_inv _ := rfl |
| measurable_toFun := (measurable_fst.fst.prodMk measurable_snd).prodMk measurable_fst.snd |
| measurable_invFun := (measurable_fst.fst.prodMk measurable_snd).prodMk measurable_fst.snd |
|
|
| lemma map_swapLast_prod {A B C : Type*} [MeasurableSpace A] [MeasurableSpace B] [MeasurableSpace C] |
| (μ : Measure A) (ν : Measure B) (τ : Measure C) [SFinite μ] [SFinite ν] [SFinite τ] : |
| ((μ.prod ν).prod τ).map swapLast = (μ.prod τ).prod ν := by |
| have he : (swapLast : (A×B)×C ≃ᵐ (A×C)×B) = |
| (MeasurableEquiv.prodAssoc.trans ((MeasurableEquiv.refl A).prodCongr |
| (MeasurableEquiv.prodComm (α:=B) (β:=C)))).trans MeasurableEquiv.prodAssoc.symm := by |
| ext p <;> rfl |
| rw [he] |
| change Measure.map (MeasurableEquiv.prodAssoc.symm ∘ |
| (Prod.map id Prod.swap) ∘ MeasurableEquiv.prodAssoc) _ = _ |
| rw [← Measure.map_map MeasurableEquiv.prodAssoc.symm.measurable |
| (measurable_id.prodMap measurable_swap |>.comp MeasurableEquiv.prodAssoc.measurable)] |
| rw [← Measure.map_map (measurable_id.prodMap measurable_swap) MeasurableEquiv.prodAssoc.measurable] |
| rw [Measure.prodAssoc_prod, ← Measure.map_prod_map _ _ measurable_id measurable_swap, |
| Measure.map_id, Measure.prod_swap] |
| simpa only [Measure.prodAssoc_prod] using |
| (MeasurableEquiv.prodAssoc.map_symm_map (μ:=((μ.prod τ).prod ν))) |
|
|
|
|
| def rowInformation {S W X : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace X] (P : Measure ((S×W)×X)) (γ : Measure X) : ℝ≥0∞ := |
| klDiv P (P.fst.prod γ) |
|
|
| lemma rowInformation_le_entropy {S W X : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace X] [StandardBorelSpace X] [Nonempty X] |
| [Countable W] [MeasurableSingletonClass W] |
| (P : Measure ((S×W)×X)) [IsProbabilityMeasure P] |
| (ν : Measure S) (γ : Measure X) [IsProbabilityMeasure ν] [IsProbabilityMeasure γ] |
| (hInd : (P.map swapLast).fst = ν.prod γ) |
| (hH : shannonEntropy (P.map swapLast).snd ≠ ∞) : |
| rowInformation P γ ≠ ∞ ∧ |
| (rowInformation P γ).toReal ≤ (shannonEntropy (P.map swapLast).snd).toReal := by |
| let : IsProbabilityMeasure (P.map (swapLast : (S×W)×X ≃ᵐ (S×X)×W)) := |
| inferInstance |
| let π := (P.map swapLast).snd |
| have hRef : (((ν.prod π).prod γ).map swapLast) = |
| (P.map swapLast).fst.prod (P.map swapLast).snd := by |
| rw [map_swapLast_prod, hInd] |
| have hi := countable_information_le_entropy (P.map swapLast) hH |
| rw [← hRef, klDiv_map_equiv] at hi |
| have hchain := klDiv_compProd_eq_add P.fst (ν.prod π) P.condKernel (Kernel.const _ γ) |
| rw [P.disintegrate P.condKernel, Measure.compProd_const, Measure.compProd_const] at hchain |
| have hle : rowInformation P γ ≤ klDiv P ((ν.prod π).prod γ) := by |
| rw [hchain] |
| exact le_add_left le_rfl |
| exact ⟨ne_top_of_le_ne_top hi.1 hle, (ENNReal.toReal_mono hi.1 hle).trans hi.2⟩ |
|
|
| lemma rowInformation_refinement {S W X E : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace X] [MeasurableSpace E] |
| (P : Measure ((S×W)×X)) [IsProbabilityMeasure P] |
| (γ : Measure X) [IsProbabilityMeasure γ] (e : S×W → E) (he : Measurable e) : |
| rowInformation (P.map (fun p => ((p.1.1,(p.1.2,e p.1)),p.2))) γ = |
| rowInformation P γ := by |
| let f : S×W → S×(W×E) := fun sw => (sw.1,(sw.2,e sw)) |
| let g : S×(W×E) → S×W := fun sw => (sw.1,sw.2.1) |
| have hf : Measurable f := measurable_fst.prodMk (measurable_snd.prodMk he) |
| have hg : Measurable g := measurable_fst.prodMk measurable_snd.fst |
| let T := Prod.map f (id : X → X) |
| let U := Prod.map g (id : X → X) |
| have hT : Measurable T := hf.prodMap measurable_id |
| have hU : Measurable U := hg.prodMap measurable_id |
| have hfst : (P.map T).fst = P.fst.map f := by |
| simp only [Measure.fst, Measure.map_map measurable_fst hT, |
| Measure.map_map hf measurable_fst] |
| rfl |
| have hRef : (P.map T).fst.prod γ = (P.fst.prod γ).map T := by |
| rw [hfst] |
| change _ = (P.fst.prod γ).map (Prod.map f id) |
| rw [← Measure.map_prod_map P.fst γ hf measurable_id, Measure.map_id] |
| change klDiv (P.map T) ((P.map T).fst.prod γ) = klDiv P (P.fst.prod γ) |
| rw [hRef] |
| apply le_antisymm (klDiv_map_le _ _ hT) |
| have hd := klDiv_map_le (P.map T) ((P.fst.prod γ).map T) hU |
| have heq : U ∘ T = id := rfl |
| simpa only [Measure.map_map hU hT, heq, Measure.map_id] using hd |
|
|
|
|
|
|
| def messagePosterior {S W : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [StandardBorelSpace S] [Nonempty S] (P : Measure (S×W)) [IsFiniteMeasure P] : Kernel W S := |
| (P.map Prod.swap).condKernel |
|
|
| instance messagePosterior_markov {S W : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [StandardBorelSpace S] [Nonempty S] (P : Measure (S×W)) [IsFiniteMeasure P] : |
| IsMarkovKernel (messagePosterior P) := by |
| unfold messagePosterior |
| infer_instance |
|
|
| lemma messagePosterior_apply {S W : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [StandardBorelSpace S] [Nonempty S] [MeasurableSingletonClass W] |
| (P : Measure (S×W)) [IsFiniteMeasure P] {w : W} (hw : P.snd {w} ≠ 0) |
| (s : Set S) (hs : MeasurableSet s) : |
| messagePosterior P w s = (P.snd {w})⁻¹ * P (s ×ˢ {w}) := by |
| have hfst : (P.map Prod.swap).fst = P.snd := by |
| rw [Measure.fst,Measure.snd,Measure.map_map measurable_fst measurable_swap] |
| rfl |
| rw [messagePosterior,Measure.IsCondKernel.apply_of_ne_zero _ _ (by rwa [hfst]), |
| hfst,Measure.map_apply measurable_swap (measurableSet_singleton w |>.prod hs)] |
| congr 2 |
| ext x |
| simp [and_comm] |
|
|
| lemma messagePosterior_le {S W : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [StandardBorelSpace S] [Nonempty S] [MeasurableSingletonClass W] |
| (P : Measure (S×W)) [IsFiniteMeasure P] {w : W} (hw : P.snd {w} ≠ 0) : |
| messagePosterior P w ≤ (P.snd {w})⁻¹ • P.fst := by |
| apply Measure.le_iff.mpr |
| intro s hs |
| rw [messagePosterior_apply P hw s hs,Measure.smul_apply,smul_eq_mul] |
| apply mul_le_mul_right |
| rw [Measure.fst_apply hs] |
| exact measure_mono (by rintro ⟨s,w⟩ h; exact h.1) |
|
|
| lemma messagePosterior_disintegrate {S W : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [StandardBorelSpace S] [Nonempty S] |
| (P : Measure (S×W)) [IsFiniteMeasure P] : |
| (P.snd ⊗ₘ messagePosterior P).map Prod.swap = P := by |
| have hfst : (P.map Prod.swap).fst = P.snd := by |
| rw [Measure.fst,Measure.snd,Measure.map_map measurable_fst measurable_swap] |
| rfl |
| rw [← hfst, messagePosterior,Measure.disintegrate,Measure.map_map measurable_swap measurable_swap] |
| exact Measure.map_id |
|
|
| def refineSignal {S W E : Type*} [MeasurableSpace S] [MeasurableSpace W] [MeasurableSpace E] |
| (P : Measure (S×W)) (e : S×W → E) : Measure (S×(W×E)) := |
| P.map (fun p => (p.1,(p.2,e p))) |
|
|
| instance refineSignal_finite {S W E : Type*} [MeasurableSpace S] [MeasurableSpace W] [MeasurableSpace E] |
| (P : Measure (S×W)) [IsFiniteMeasure P] (e : S×W → E) : IsFiniteMeasure (refineSignal P e) := by |
| unfold refineSignal |
| infer_instance |
|
|
| lemma refineSignal_apply {S W E : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace E] [MeasurableSingletonClass W] [MeasurableSingletonClass E] |
| (P : Measure (S×W)) (e : S×W → E) (he : Measurable e) |
| (w : W) (v : E) (s : Set S) (hs : MeasurableSet s) : |
| refineSignal P e (s ×ˢ {(w,v)}) = P ((s ∩ {x | e (x,w) = v}) ×ˢ {w}) := by |
| rw [refineSignal,Measure.map_apply (measurable_fst.prodMk (measurable_snd.prodMk he)) |
| (hs.prod (measurableSet_singleton (w,v)))] |
| congr 1 |
| ext ⟨a,b⟩ |
| simp only [mem_preimage,mem_prod,mem_singleton_iff,Prod.mk.injEq,mem_inter_iff,mem_ofPred_eq] |
| constructor |
| · rintro ⟨hs,hx,he⟩ |
| exact ⟨⟨hs,by simpa [hx] using he⟩,hx⟩ |
| · rintro ⟨⟨hs,he⟩,hx⟩ |
| exact ⟨hs,hx,by simpa [hx] using he⟩ |
|
|
| lemma refineSignal_mass {S W E : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace E] [StandardBorelSpace S] [Nonempty S] |
| [MeasurableSingletonClass W] [MeasurableSingletonClass E] |
| (P : Measure (S×W)) [IsFiniteMeasure P] (e : S×W → E) (he : Measurable e) |
| {w : W} (hw : P.snd {w} ≠ 0) (v : E) : |
| (refineSignal P e).snd {(w,v)} = P.snd {w} * messagePosterior P w {x | e (x,w) = v} := by |
| have hclass : MeasurableSet {x : S | e (x,w) = v} := |
| (measurableSet_singleton v).preimage (he.comp (measurable_id.prodMk measurable_const)) |
| rw [messagePosterior_apply P hw _ hclass,←mul_assoc, |
| ENNReal.mul_inv_cancel hw (measure_ne_top _ _),one_mul,Measure.snd_apply (measurableSet_singleton (w,v))] |
| have heq : (Prod.snd ⁻¹' ({(w,v)} : Set (W×E))) = (univ : Set S) ×ˢ {(w,v)} := by ext x; simp |
| rw [heq,refineSignal_apply P e he w v univ MeasurableSet.univ,univ_inter] |
|
|
| lemma refineSignal_positive_original {S W E : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace E] [MeasurableSingletonClass W] [MeasurableSingletonClass E] |
| (P : Measure (S×W)) (e : S×W → E) (he : Measurable e) |
| {w : W} {v : E} (hv : (refineSignal P e).snd {(w,v)} ≠ 0) : P.snd {w} ≠ 0 := by |
| contrapose! hv |
| rw [Measure.snd_apply (measurableSet_singleton (w,v)), |
| show (Prod.snd ⁻¹' ({(w,v)} : Set (W×E))) = (univ : Set S) ×ˢ {(w,v)} from by ext x; simp, |
| refineSignal_apply P e he w v univ MeasurableSet.univ,univ_inter] |
| apply measure_mono_null (t:=Prod.snd ⁻¹' {w}) |
| · intro x hx; exact hx.2 |
| · rwa [←Measure.snd_apply (measurableSet_singleton w)] |
|
|
| lemma messagePosterior_refinement {S W E : Type*} [MeasurableSpace S] [MeasurableSpace W] |
| [MeasurableSpace E] [StandardBorelSpace S] [Nonempty S] |
| [MeasurableSingletonClass W] [MeasurableSingletonClass E] |
| (P : Measure (S×W)) [IsFiniteMeasure P] (e : S×W → E) (he : Measurable e) |
| {w : W} {v : E} (hv : (refineSignal P e).snd {(w,v)} ≠ 0) : |
| messagePosterior (refineSignal P e) (w,v) = |
| (messagePosterior P w {x | e (x,w) = v})⁻¹ • |
| (messagePosterior P w).restrict {x | e (x,w) = v} := by |
| have hw := refineSignal_positive_original P e he hv |
| have hclass : MeasurableSet {x : S | e (x,w) = v} := |
| (measurableSet_singleton v).preimage (he.comp (measurable_id.prodMk measurable_const)) |
| have hη : messagePosterior P w {x | e (x,w) = v} ≠ 0 := by |
| intro hz |
| rw [refineSignal_mass P e he hw v,hz,mul_zero] at hv |
| exact hv rfl |
| ext s hs |
| rw [messagePosterior_apply _ hv s hs,refineSignal_apply P e he w v s hs, |
| Measure.smul_apply,smul_eq_mul,Measure.restrict_apply hs, |
| messagePosterior_apply P hw _ (hs.inter hclass),refineSignal_mass P e he hw v, |
| ENNReal.mul_inv (Or.inl hw) (Or.inl (measure_ne_top _ _)), mul_assoc] |
| ac_rfl |
|
|
|
|
|
|
| lemma countable_ac_of_atom {W : Type*} [MeasurableSpace W] [Countable W] |
| [MeasurableSingletonClass W] (P Q : Measure W) |
| (h : ∀ w, Q {w} = 0 → P {w} = 0) : P ≪ Q := by |
| apply Measure.AbsolutelyContinuous.mk |
| intro s hs hz |
| rw [show s = ⋃ w : s, ({w.1} : Set W) by ext x; simp] |
| apply measure_iUnion_null |
| intro w |
| exact h w (measure_mono_null (by simp [w.2]) hz) |
|
|
| lemma rnDeriv_atom {W : Type*} [MeasurableSpace W] [MeasurableSingletonClass W] |
| (P Q : Measure W) [IsFiniteMeasure P] [IsFiniteMeasure Q] |
| (hPQ : P ≪ Q) {w : W} (hw : Q {w} ≠ 0) : |
| P.rnDeriv Q w = P {w} / Q {w} := by |
| have h := congrArg (fun M : Measure W => M {w}) (Measure.withDensity_rnDeriv_eq P Q hPQ) |
| rw [withDensity_apply _ (measurableSet_singleton w),Measure.restrict_singleton, |
| lintegral_smul_measure,lintegral_dirac] at h |
| change Q {w} * P.rnDeriv Q w = P {w} at h |
| apply (ENNReal.eq_div_iff hw (measure_ne_top _ _)).mpr |
| simpa only [mul_comm] using h |
|
|
| lemma countable_entropy_le_crossEntropy {W : Type*} [MeasurableSpace W] [Countable W] |
| [MeasurableSingletonClass W] (P Q : Measure W) [IsProbabilityMeasure P] [IsProbabilityMeasure Q] |
| (hPQ : P ≪ Q) (hci : Integrable (fun w => -Real.log (Q {w}).toReal) P) : |
| shannonEntropy P ≠ ∞ ∧ (shannonEntropy P).toReal ≤ ∫ w, -Real.log (Q {w}).toReal ∂P := by |
| have hpos : ∀ᵐ w ∂P, Q {w} ≠ 0 := hPQ.ae_le (ae_positive_atom Q) |
| have he : ∀ᵐ w ∂P, llr P Q w = Real.log (P {w}).toReal - Real.log (Q {w}).toReal := by |
| filter_upwards [ae_positive_atom P,hpos] with w hp hq |
| rw [llr,rnDeriv_atom P Q hPQ hq,ENNReal.toReal_div,Real.log_div |
| (ENNReal.toReal_ne_zero.mpr ⟨hp,measure_ne_top _ _⟩) |
| (ENNReal.toReal_ne_zero.mpr ⟨hq,measure_ne_top _ _⟩)] |
| have hbound : ∀ᵐ w ∂P, llr P Q w ≤ -Real.log (Q {w}).toReal := by |
| filter_upwards [he] with w hw |
| rw [hw] |
| linarith [atom_surprisal_nonneg P w] |
| have hk := klDiv_bound_of_llr_le P Q hPQ _ hci hbound |
| have hli := (klDiv_ne_top_iff.mp hk.1).2 |
| have hpi : Integrable (fun w => -Real.log (P {w}).toReal) P := by |
| apply (hci.sub hli).congr |
| filter_upwards [he] with w hw |
| change -Real.log (Q {w}).toReal - llr P Q w = -Real.log (P {w}).toReal |
| rw [hw] |
| ring |
| have hent : shannonEntropy P = ENNReal.ofReal (∫ w, -Real.log (P {w}).toReal ∂P) := by |
| exact (ofReal_integral_eq_lintegral_ofReal hpi (Eventually.of_forall (atom_surprisal_nonneg P))).symm |
| refine ⟨by rw [hent]; exact ENNReal.ofReal_ne_top, ?_⟩ |
| rw [hent,ENNReal.toReal_ofReal (integral_nonneg (atom_surprisal_nonneg P))] |
| have hn : 0 ≤ ∫ w, llr P Q w ∂P := by simpa using integral_llr_add_sub_measure_univ_nonneg hPQ hli |
| have hi : (∫ w, llr P Q w ∂P) = (∫ w, -Real.log (Q {w}).toReal ∂P) - |
| ∫ w, -Real.log (P {w}).toReal ∂P := by |
| rw [←integral_sub hci hpi] |
| apply integral_congr_ae |
| filter_upwards [he] with w hw |
| linarith |
| linarith |
|
|
| lemma shannonEntropy_map_le {W V : Type*} [MeasurableSpace W] [MeasurableSpace V] |
| [Countable W] [Countable V] [MeasurableSingletonClass W] [MeasurableSingletonClass V] |
| (P : Measure W) [IsProbabilityMeasure P] (f : W → V) : |
| shannonEntropy (P.map f) ≤ shannonEntropy P := by |
| have hfm : Measurable f := measurable_of_countable _ |
| let : IsProbabilityMeasure (P.map f) := inferInstance |
| unfold shannonEntropy |
| rw [lintegral_map (measurable_of_countable _) hfm] |
| apply lintegral_mono_ae |
| filter_upwards [ae_positive_atom P] with w hw |
| apply ENNReal.ofReal_le_ofReal |
| apply neg_le_neg |
| apply Real.log_le_log (ENNReal.toReal_pos hw (measure_ne_top _ _)) |
| apply ENNReal.toReal_mono (measure_ne_top _ _) |
| rw [Measure.map_apply hfm (measurableSet_singleton (f w))] |
| exact measure_mono (by intro x hx; simpa only [mem_preimage,mem_singleton_iff] using congrArg f hx) |
|
|
| lemma shannonEntropy_equiv {W V : Type*} [MeasurableSpace W] [MeasurableSpace V] |
| [Countable W] [Countable V] [MeasurableSingletonClass W] [MeasurableSingletonClass V] |
| (P : Measure W) [IsProbabilityMeasure P] (e : W ≃ᵐ V) : |
| shannonEntropy (P.map e) = shannonEntropy P := by |
| let : IsProbabilityMeasure (P.map e) := inferInstance |
| apply le_antisymm (shannonEntropy_map_le P e) |
| simpa only [e.map_symm_map] using shannonEntropy_map_le (P.map e) e.symm |
|
|
| lemma geometric_pair_entropy {P : Measure (ℕ×ℕ)} [IsProbabilityMeasure P] |
| (M : ℝ) (hM : 1 ≤ M) |
| (hi : Integrable (fun x : ℕ×ℕ => (x.1:ℝ)+(x.2:ℝ)) P) |
| (hmean : (∫ x : ℕ×ℕ, (x.1:ℝ)+(x.2:ℝ) ∂P) ≤ M) : |
| shannonEntropy P ≠ ∞ ∧ (shannonEntropy P).toReal ≤ 1 + 2 * Real.log (M+1) := by |
| have hM0 : 0 < M := lt_of_lt_of_le zero_lt_one hM |
| have hM1 : 0 < M+1 := by linarith |
| let p : unitInterval := ⟨(M+1)⁻¹, ⟨(inv_pos.mpr hM1).le, (inv_le_one₀ hM1).mpr (by linarith)⟩⟩ |
| have hp0 : p ≠ 0 := by |
| intro h |
| have hh : (M+1)⁻¹ = 0 := congrArg Subtype.val h |
| exact (inv_ne_zero hM1.ne') hh |
| have hp1 : p ≠ 1 := by |
| intro h |
| have hh := congrArg Subtype.val h |
| have hlt : (M+1)⁻¹ < 1 := (inv_lt_one₀ hM1).mpr (by linarith) |
| exact hlt.ne hh |
| have hpR : 0 < (p:ℝ) := inv_pos.mpr hM1 |
| have hqR : 0 < 1-(p:ℝ) := by |
| change 0 < 1-(M+1)⁻¹ |
| linarith [(inv_lt_one₀ hM1).mpr (by linarith : 1 < M+1)] |
| let Q := (geometricMeasure p).prod (geometricMeasure p) |
| have hatom (x : ℕ×ℕ) : Q {x} = ENNReal.ofReal (((1-p)^x.1*p) * ((1-p)^x.2*p)) := by |
| rw [show ({x} : Set (ℕ×ℕ)) = {x.1} ×ˢ {x.2} by ext y; simp [Prod.ext_iff]] |
| rw [Measure.prod_prod,geometricMeasure_singleton hp0,geometricMeasure_singleton hp0, |
| ENNReal.ofReal_mul (geometricMeasure_nonneg p x.1)] |
| have hpos (x : ℕ×ℕ) : Q {x} ≠ 0 := by |
| rw [hatom, ne_eq,ENNReal.ofReal_eq_zero] |
| exact (mul_pos (geometricMeasure_pos hp0 hp1 x.1) (geometricMeasure_pos hp0 hp1 x.2)).not_ge |
| have hc (x : ℕ×ℕ) : -Real.log (Q {x}).toReal = |
| ((x.1:ℝ)+(x.2:ℝ)) * (-Real.log (1-(p:ℝ))) - 2*Real.log (p:ℝ) := by |
| rw [hatom,ENNReal.toReal_ofReal (mul_nonneg (geometricMeasure_nonneg p x.1) |
| (geometricMeasure_nonneg p x.2)),Real.log_mul |
| (geometricMeasure_pos hp0 hp1 x.1).ne' (geometricMeasure_pos hp0 hp1 x.2).ne', |
| Real.log_mul (pow_pos hqR _).ne' hpR.ne', |
| Real.log_mul (pow_pos hqR _).ne' hpR.ne',Real.log_pow,Real.log_pow] |
| ring |
| have hci : Integrable (fun x : ℕ×ℕ => -Real.log (Q {x}).toReal) P := by |
| simp_rw [hc] |
| exact (hi.mul_const _).sub (integrable_const _) |
| have he := countable_entropy_le_crossEntropy P Q |
| (countable_ac_of_atom P Q (fun x hx => False.elim (hpos x hx))) hci |
| refine ⟨he.1,he.2.trans ?_⟩ |
| simp_rw [hc] |
| rw [integral_sub (hi.mul_const _) (integrable_const _),integral_mul_const,integral_const, |
| probReal_univ,one_smul] |
| have hlp : -Real.log (p:ℝ) = Real.log (M+1) := by simp [p,Real.log_inv] |
| have htpos : 0 < 1-(p:ℝ) := by |
| change 0 < 1-(M+1)⁻¹ |
| linarith [(inv_lt_one₀ hM1).mpr (by linarith : 1 < M+1)] |
| have hlog : -Real.log (1-(p:ℝ)) ≤ M⁻¹ := by |
| have hrat : (1-(p:ℝ))⁻¹ = 1+M⁻¹ := by dsimp [p]; field_simp [hM0.ne',hM1.ne']; ring |
| calc |
| _ = Real.log ((1-(p:ℝ))⁻¹) := (Real.log_inv _).symm |
| _ ≤ (1-(p:ℝ))⁻¹ - 1 := Real.log_le_sub_one_of_pos (inv_pos.mpr htpos) |
| _ = _ := by rw [hrat]; ring |
| have hlog0 : 0 ≤ -Real.log (1-(p:ℝ)) := by |
| apply neg_nonneg.mpr (Real.log_nonpos htpos.le _) |
| have : 0 ≤ (p:ℝ) := p.2.1 |
| linarith |
| have hb := mul_le_mul_of_nonneg_right hmean hlog0 |
| have hb' := mul_le_mul_of_nonneg_left hlog hM0.le |
| rw [mul_inv_cancel₀ hM0.ne'] at hb' |
| linarith |
|
|
| lemma entropy_finite_integrable {W : Type*} [MeasurableSpace W] [Countable W] [MeasurableSingletonClass W] |
| (P : Measure W) [IsProbabilityMeasure P] (h : shannonEntropy P ≠ ∞) : |
| Integrable (fun w => -Real.log (P {w}).toReal) P := |
| (lintegral_ofReal_ne_top_iff_integrable (measurable_of_countable _).aestronglyMeasurable |
| (Eventually.of_forall (atom_surprisal_nonneg P))).mp h |
|
|
| lemma integral_surprisal {W : Type*} [MeasurableSpace W] [Countable W] [MeasurableSingletonClass W] |
| (P : Measure W) [IsProbabilityMeasure P] : |
| (∫ w, -Real.log (P {w}).toReal ∂P) = (shannonEntropy P).toReal := |
| integral_eq_lintegral_of_nonneg_ae (Eventually.of_forall (atom_surprisal_nonneg P)) |
| (measurable_of_countable _).aestronglyMeasurable |
|
|
| lemma shannonEntropy_subadd {W E : Type*} [MeasurableSpace W] [MeasurableSpace E] |
| [Countable W] [Countable E] [MeasurableSingletonClass W] [MeasurableSingletonClass E] |
| (P : Measure (W×E)) [IsProbabilityMeasure P] |
| (hW : shannonEntropy P.fst ≠ ∞) (hE : shannonEntropy P.snd ≠ ∞) : |
| shannonEntropy P ≠ ∞ ∧ (shannonEntropy P).toReal ≤ |
| (shannonEntropy P.fst).toReal + (shannonEntropy P.snd).toReal := by |
| have hiW : Integrable (fun z : W×E => -Real.log (P.fst {z.1}).toReal) P := |
| (integrable_map_measure (measurable_of_countable _).aestronglyMeasurable |
| measurable_fst.aemeasurable).mp (entropy_finite_integrable P.fst hW) |
| have hiE : Integrable (fun z : W×E => -Real.log (P.snd {z.2}).toReal) P := |
| (integrable_map_measure (measurable_of_countable _).aestronglyMeasurable |
| measurable_snd.aemeasurable).mp (entropy_finite_integrable P.snd hE) |
| have he : ∀ᵐ z ∂P, -Real.log ((P.fst.prod P.snd) {z}).toReal = |
| -Real.log (P.fst {z.1}).toReal + -Real.log (P.snd {z.2}).toReal := by |
| have hf := (ae_map_iff measurable_fst.aemeasurable |
| ((Set.to_countable _).measurableSet)).mp (ae_positive_atom P.fst) |
| have hs := (ae_map_iff measurable_snd.aemeasurable |
| ((Set.to_countable _).measurableSet)).mp (ae_positive_atom P.snd) |
| filter_upwards [hf,hs] with z hzf hzs |
| rw [show ({z} : Set (W×E)) = {z.1} ×ˢ {z.2} by ext y; simp [Prod.ext_iff], |
| Measure.prod_prod,ENNReal.toReal_mul,Real.log_mul |
| (ENNReal.toReal_ne_zero.mpr ⟨hzf,measure_ne_top _ _⟩) |
| (ENNReal.toReal_ne_zero.mpr ⟨hzs,measure_ne_top _ _⟩)] |
| ring |
| have hi : Integrable (fun z : W×E => -Real.log ((P.fst.prod P.snd) {z}).toReal) P := |
| (hiW.add hiE).congr (by filter_upwards [he] with z hz; exact hz.symm) |
| obtain ⟨hfin,hineq⟩ := countable_entropy_le_crossEntropy P (P.fst.prod P.snd) |
| (joint_ac_prod_marginals P) hi |
| refine ⟨hfin,hineq.trans_eq ?_⟩ |
| rw [integral_congr_ae he,integral_add hiW hiE] |
| have h1 : (∫ a : W×E, -Real.log (P.fst {a.1}).toReal ∂P) = (shannonEntropy P.fst).toReal := by |
| rw [←integral_surprisal] |
| exact (integral_map measurable_fst.aemeasurable (measurable_of_countable |
| (fun w => -Real.log (P.fst {w}).toReal)).aestronglyMeasurable).symm |
| have h2 : (∫ a : W×E, -Real.log (P.snd {a.2}).toReal ∂P) = (shannonEntropy P.snd).toReal := by |
| rw [←integral_surprisal] |
| exact (integral_map measurable_snd.aemeasurable (measurable_of_countable |
| (fun w => -Real.log (P.snd {w}).toReal)).aestronglyMeasurable).symm |
| rw [h1,h2] |
|
|
| lemma intCode_le (q : ℤ) : (Equiv.intEquivNat q : ℝ) ≤ 2 * (q.natAbs:ℝ) := by |
| cases q with |
| | ofNat n => change ((2*n:ℕ):ℝ) ≤ 2*(n:ℝ); norm_cast |
| | negSucc n => change ((2*n+1:ℕ):ℝ) ≤ 2*((n+1:ℕ):ℝ); push_cast; linarith |
|
|
| def natIntEquivNatNat : (ℕ×ℤ) ≃ᵐ (ℕ×ℕ) where |
| toEquiv := (Equiv.refl ℕ).prodCongr Equiv.intEquivNat |
| measurable_toFun := measurable_of_countable _ |
| measurable_invFun := measurable_of_countable _ |
|
|
| lemma natInt_entropy {P : Measure (ℕ×ℤ)} [IsProbabilityMeasure P] |
| (M : ℝ) (hM : 1 ≤ M) |
| (hi : Integrable (fun x : ℕ×ℤ => (x.1:ℝ)+2*(x.2.natAbs:ℝ)) P) |
| (hmean : (∫ x : ℕ×ℤ, (x.1:ℝ)+2*(x.2.natAbs:ℝ) ∂P) ≤ M) : |
| shannonEntropy P ≠ ∞ ∧ (shannonEntropy P).toReal ≤ 1 + 2 * Real.log (M+1) := by |
| let e := natIntEquivNatNat |
| let Q := P.map e |
| let : IsProbabilityMeasure Q := inferInstance |
| have hle (x : ℕ×ℤ) : ((e x).1:ℝ)+((e x).2:ℝ) ≤ (x.1:ℝ)+2*(x.2.natAbs:ℝ) := |
| add_le_add le_rfl (intCode_le x.2) |
| have hi' : Integrable (fun x : ℕ×ℤ => ((e x).1:ℝ)+((e x).2:ℝ)) P := by |
| apply hi.mono' (measurable_of_countable _).aestronglyMeasurable |
| exact Eventually.of_forall (fun x => by rw [Real.norm_eq_abs,abs_of_nonneg (by positivity)]; exact hle x) |
| have hqi : Integrable (fun x : ℕ×ℕ => (x.1:ℝ)+(x.2:ℝ)) Q := |
| (integrable_map_measure (measurable_of_countable _).aestronglyMeasurable e.measurable.aemeasurable).mpr hi' |
| have hqm : (∫ x : ℕ×ℕ, (x.1:ℝ)+(x.2:ℝ) ∂Q) ≤ M := by |
| rw [integral_map e.measurable.aemeasurable (measurable_of_countable _).aestronglyMeasurable] |
| exact (integral_mono_ae hi' hi (Eventually.of_forall hle)).trans hmean |
| have h := geometric_pair_entropy M hM hqi hqm |
| simpa only [Q,shannonEntropy_equiv P e] using h |
|
|
|
|
|
|
| lemma map_fiber_ac_prod {A S Y : Type*} [MeasurableSpace A] [MeasurableSpace S] |
| [MeasurableSpace Y] (μ : Measure A) (ν : Measure S) (L : Measure Y) |
| [SFinite μ] [SFinite ν] [SFinite L] |
| (f : A×S → Y) (hf : Measurable f) |
| (hac : ∀ᵐ a ∂μ, ν.map (fun s => f (a,s)) ≪ L) : |
| (μ.prod ν).map (fun z => (z.1,f z)) ≪ μ.prod L := by |
| apply Measure.AbsolutelyContinuous.mk |
| intro t ht ht0 |
| rw [Measure.prod_apply ht] at ht0 |
| have hz : ∀ᵐ a ∂μ, L {y | (a,y) ∈ t} = 0 := |
| (lintegral_eq_zero_iff (measurable_measure_prodMk_left ht)).mp ht0 |
| rw [Measure.map_apply (measurable_fst.prodMk hf) ht, |
| Measure.prod_apply (ht.preimage (measurable_fst.prodMk hf))] |
| apply (lintegral_eq_zero_iff |
| (measurable_measure_prodMk_left (ht.preimage (measurable_fst.prodMk hf)))).mpr |
| filter_upwards [hac, hz] with a ha hza |
| have hh := ha hza |
| have ham : Measurable (fun s : S => f (a,s)) := |
| hf.comp (measurable_const.prodMk measurable_id) |
| have has : MeasurableSet {y : Y | (a,y) ∈ t} := |
| ht.preimage (show Measurable (fun y : Y => (a,y)) from measurable_const.prodMk measurable_id) |
| rw [Measure.map_apply ham has] at hh |
| exact hh |
|
|
| lemma ae_condKernel_ac_of_joint_ac {A Y : Type*} [MeasurableSpace A] [MeasurableSpace Y] |
| [StandardBorelSpace Y] [Nonempty Y] (P : Measure (A×Y)) [IsFiniteMeasure P] |
| (R : Measure A) (L : Measure Y) [SFinite R] [SFinite L] |
| (hac : P ≪ R.prod L) : ∀ᵐ a ∂P.fst, P.condKernel a ≪ L := by |
| obtain ⟨L', hL', hLL', hL'L⟩ := exists_isFiniteMeasure_absolutelyContinuous L |
| let := hL' |
| have hh : P.fst ⊗ₘ P.condKernel ≪ R ⊗ₘ Kernel.const A L' := by |
| rw [P.disintegrate P.condKernel, Measure.compProd_const] |
| exact hac.trans ((Measure.AbsolutelyContinuous.refl R).prod hLL') |
| filter_upwards [hh.kernel_of_compProd] with a ha |
| exact ha.trans hL'L |
|
|
| lemma adjoin_countable_ac {A Y W : Type*} [MeasurableSpace A] [MeasurableSpace Y] |
| [MeasurableSpace W] [Countable W] [MeasurableSingletonClass W] |
| (P : Measure ((A×Y)×W)) [IsFiniteMeasure P] |
| (R : Measure A) (L : Measure Y) [SFinite R] [SFinite L] |
| (hac : P.fst ≪ R.prod L) : |
| P.map (swapLast : (A×Y)×W ≃ᵐ (A×W)×Y) ≪ (R.prod Measure.count).prod L := by |
| have h := (joint_ac_fst_prod_count P).trans (hac.prod (Measure.AbsolutelyContinuous.refl (Measure.count : Measure W))) |
| have hm := h.map (swapLast : (A×Y)×W ≃ᵐ (A×W)×Y).measurable |
| rwa [map_swapLast_prod] at hm |
|
|
|
|
| lemma countable_null_transfer {A Y W : Type*} [MeasurableSpace A] [MeasurableSpace Y] |
| [MeasurableSpace W] [Countable W] [MeasurableSingletonClass W] |
| (N : Measure ((A×W)×Y)) (R : Measure A) (L : Measure Y) |
| [SFinite R] [SFinite L] |
| (hac : N ≪ (R.prod Measure.count).prod L) |
| (p : A → W → Y → Prop) |
| (hpm : ∀ w, MeasurableSet {ay : A×Y | p ay.1 w ay.2}) |
| (hp : ∀ w a, ∀ᵐ y ∂L, p a w y) : ∀ᵐ z ∂N, p z.1.1 z.1.2 z.2 := by |
| apply hac.ae_le |
| have hm : MeasurableSet {z : (A×W)×Y | p z.1.1 z.1.2 z.2} := by |
| have he : {z : (A×W)×Y | p z.1.1 z.1.2 z.2} = |
| ⋃ w : W, {z : (A×W)×Y | z.1.2 = w} ∩ |
| (fun z : (A×W)×Y => (z.1.1,z.2)) ⁻¹' {ay | p ay.1 w ay.2} := by |
| ext z; simp |
| rw [he] |
| exact MeasurableSet.iUnion fun w => |
| (measurableSet_eq_fun measurable_fst.snd measurable_const).inter |
| ((hpm w).preimage (measurable_fst.fst.prodMk measurable_snd)) |
| apply (Measure.ae_prod_iff_ae_ae hm).mpr |
| exact Filter.Eventually.of_forall fun aw => hp aw.2 aw.1 |
|
|
|
|
| lemma log_one_add_nonneg (x : ℝ≥0∞) : 0 ≤ Real.log (1+x.toReal) := |
| Real.log_nonneg (le_add_of_nonneg_right ENNReal.toReal_nonneg) |
|
|
| lemma log_one_add_le (x : ℝ≥0∞) : Real.log (1+x.toReal) ≤ x.toReal := by |
| simpa using Real.log_le_sub_one_of_pos (show 0 < 1+x.toReal by positivity) |
|
|
| lemma measurable_log_one_add {A : Type*} [MeasurableSpace A] {f : A → ℝ≥0∞} |
| (hf : Measurable f) : Measurable (fun x => Real.log (1+(f x).toReal)) := |
| (measurable_const.add hf.ennreal_toReal).log |
|
|
| lemma log_one_add_jensen {A : Type*} [MeasurableSpace A] |
| (μ : Measure A) [IsProbabilityMeasure μ] (F : A → ℝ≥0∞) |
| (hFm : Measurable F) (hFt : ∀ a, F a ≠ ∞) |
| (hFin : ∫⁻ a, F a ∂μ ≠ ∞) : |
| ∫⁻ a, ENNReal.ofReal (Real.log (1+(F a).toReal)) ∂μ ≤ |
| ENNReal.ofReal (Real.log (1+(∫⁻ a, F a ∂μ).toReal)) := by |
| have hFi : Integrable (fun a => (F a).toReal) μ := by |
| apply (lintegral_ofReal_ne_top_iff_integrable hFm.ennreal_toReal.aestronglyMeasurable |
| (Filter.Eventually.of_forall (fun _ => ENNReal.toReal_nonneg))).mp |
| simpa only [ENNReal.ofReal_toReal (hFt _)] using hFin |
| have hLi : Integrable (fun a => Real.log (1+(F a).toReal)) μ := |
| hFi.mono' (measurable_log_one_add hFm).aestronglyMeasurable |
| (Filter.Eventually.of_forall fun a => by rw [Real.norm_eq_abs, abs_of_nonneg (log_one_add_nonneg _)]; exact log_one_add_le _) |
| let M := 1+(∫⁻ a, F a ∂μ).toReal |
| have hM : 0 < M := by dsimp [M]; positivity |
| have htangent (a : A) : Real.log (1+(F a).toReal) ≤ |
| Real.log M + (1+(F a).toReal)/M - 1 := by |
| have hh := Real.log_le_sub_one_of_pos (show 0 < (1+(F a).toReal)/M by positivity) |
| rw [Real.log_div (by positivity) hM.ne'] at hh |
| linarith |
| have hupper : Integrable (fun a => Real.log M + (1+(F a).toReal)/M - 1) μ := |
| ((integrable_const _).add (((integrable_const 1).add hFi).div_const M)).sub (integrable_const _) |
| have hbound := integral_mono hLi hupper htangent |
| have hmean : ∫ a, (1+(F a).toReal)/M ∂μ = 1 := by |
| rw [integral_div, integral_add (integrable_const 1) hFi, integral_const, |
| integral_toReal hFm.aemeasurable (Filter.Eventually.of_forall fun a => lt_top_iff_ne_top.mpr (hFt a))] |
| simp only [Measure.real, measure_univ, ENNReal.toReal_one, smul_eq_mul, one_mul] |
| exact div_self hM.ne' |
| rw [integral_sub (f:=fun a => Real.log M+(1+(F a).toReal)/M) (g:=fun _ => 1) |
| ((integrable_const _).add (((integrable_const 1).add hFi).div_const M)) |
| (integrable_const 1), integral_add (f:=fun _ => Real.log M) (g:=fun a => (1+(F a).toReal)/M) |
| (integrable_const _) (((integrable_const 1).add hFi).div_const M), |
| hmean, integral_const, integral_const] at hbound |
| simp only [Measure.real, measure_univ, ENNReal.toReal_one, smul_eq_mul, one_mul, add_sub_cancel_right] at hbound |
| rw [← ofReal_integral_eq_lintegral_ofReal hLi (Filter.Eventually.of_forall fun a => log_one_add_nonneg _)] |
| exact ENNReal.ofReal_le_ofReal hbound |
|
|
|
|
| lemma exp_log_normalization (v : ℝ≥0∞) (hv : v ≠ ∞) (c : ℝ) (hc : 0 ≤ c) (q : ℕ) : |
| ENNReal.ofReal (Real.exp ((q:ℝ)*Real.log (1+v.toReal)-(q:ℝ)*Real.log (1+c))) = |
| (1+v)^q / (ENNReal.ofReal (1+c))^q := by |
| rw [Real.exp_sub, Real.exp_nat_mul, Real.exp_nat_mul, |
| Real.exp_log (by positivity), Real.exp_log (by positivity), |
| ENNReal.ofReal_div_of_pos (by positivity), ENNReal.ofReal_pow (by positivity), |
| ENNReal.ofReal_pow (by positivity), ENNReal.ofReal_add (by positivity) ENNReal.toReal_nonneg, |
| ENNReal.ofReal_one, ENNReal.ofReal_toReal hv] |
|
|
|
|
| lemma mixed_entropy_log_bound {A X Z : Type*} [MeasurableSpace A] [MeasurableSpace X] |
| [MeasurableSpace Z] (P : Measure (A×X)) [IsProbabilityMeasure P] |
| (γ : Measure X) (η : Measure Z) [IsProbabilityMeasure γ] [IsProbabilityMeasure η] |
| (hKL : klDiv P (P.fst.prod γ) ≠ ∞) |
| (K : (A×X)×Z → ℝ≥0∞) (hKm : Measurable K) (hKt : ∀ z, K z ≠ ∞) |
| (hKint : ∀ ax, ∫⁻ z, K (ax,z) ∂η ≠ ∞) |
| (C : A → ℝ) (hCm : Measurable C) (hC0 : ∀ a, 0 ≤ C a) |
| (hCI : Integrable (fun a => Real.log (1+C a)) P.fst) |
| {q : ℕ} (hq : 1 ≤ q) |
| (hMoment : ∀ a, ∫⁻ x, (∫⁻ z, K ((a,x),z) ∂η)^q ∂γ ≤ (ENNReal.ofReal (C a))^q) : |
| ∫⁻ axz, ENNReal.ofReal (Real.log (1+(K axz).toReal)) ∂P.prod η ≤ |
| ENNReal.ofReal ((klDiv P (P.fst.prod γ)).toReal / q + |
| ∫ a, Real.log (1+C a) ∂P.fst) := by |
| let F : A×X → ℝ≥0∞ := fun ax => ∫⁻ z, K (ax,z) ∂η |
| have hFm : Measurable F := Measurable.lintegral_prod_right (f:=fun ax z => K (ax,z)) hKm |
| have hf : Measurable (fun ax : A×X => (q:ℝ)*Real.log (1+(F ax).toReal)) := |
| measurable_const.mul (measurable_log_one_add hFm) |
| have hc : Measurable (fun ax : A×X => (q:ℝ)*Real.log (1+C ax.1)) := |
| measurable_const.mul ((measurable_const.add (hCm.comp measurable_fst)).log) |
| have hCc : Integrable (fun ax : A×X => Real.log (1+C ax.1)) P := |
| (integrable_map_measure (measurable_const.add hCm |>.log.aestronglyMeasurable) |
| measurable_fst.aemeasurable).mp hCI |
| have hcI := hCc.const_mul (q:ℝ) |
| have hExp : ∫⁻ ax : A×X, ENNReal.ofReal (Real.exp |
| ((q:ℝ)*Real.log (1+(F ax).toReal)-(q:ℝ)*Real.log (1+C ax.1))) ∂P.fst.prod γ ≤ 1 := by |
| rw [lintegral_prod (fun ax : A×X => ENNReal.ofReal (Real.exp |
| ((q:ℝ)*Real.log (1+(F ax).toReal)-(q:ℝ)*Real.log (1+C ax.1)))) |
| (by exact (hf.sub hc).exp.ennreal_ofReal.aemeasurable)] |
| calc |
| _ ≤ ∫⁻ _a, (1:ℝ≥0∞) ∂P.fst := by |
| apply lintegral_mono; intro a |
| have heq : (fun x => ENNReal.ofReal (Real.exp |
| ((q:ℝ)*Real.log (1+(F (a,x)).toReal)-(q:ℝ)*Real.log (1+C a)))) = |
| (fun x => (1+F (a,x))^q / (ENNReal.ofReal (1+C a))^q) := by |
| funext x |
| exact exp_log_normalization _ (hKint (a,x)) _ (hC0 a) q |
| change (∫⁻ x, ENNReal.ofReal (Real.exp |
| ((q:ℝ)*Real.log (1+(F (a,x)).toReal)-(q:ℝ)*Real.log (1+C a))) ∂γ) ≤ 1 |
| rw [heq] |
| simp_rw [div_eq_mul_inv] |
| have hpow : Measurable (fun x : X => (1+F (a,x))^q) := |
| (measurable_const.add (hFm.comp (measurable_const.prodMk measurable_id))).pow_const q |
| rw [lintegral_mul_const _ hpow] |
| have hh := lintegral_one_add_pow_le γ (fun x => F (a,x)) |
| (hFm.comp (measurable_const.prodMk measurable_id)) hq (hMoment a) |
| have he : ENNReal.ofReal (1+C a) = 1+ENNReal.ofReal (C a) := by |
| rw [ENNReal.ofReal_add (by norm_num) (hC0 a), ENNReal.ofReal_one] |
| rw [he] |
| apply (mul_le_mul' hh le_rfl).trans_eq |
| exact ENNReal.mul_inv_cancel (by positivity) (by finiteness) |
| _ = 1 := by simp |
| obtain ⟨hfi, hbi⟩ := entropy_exp_bound P (P.fst.prod γ) hKL _ _ hf hc |
| (fun ax => mul_nonneg (Nat.cast_nonneg _) (log_one_add_nonneg _)) hcI hExp |
| have hqpos : 0 < (q:ℝ) := by exact_mod_cast (show 0 < q by omega) |
| have hqne := hqpos.ne' |
| have hLi : Integrable (fun ax => Real.log (1+(F ax).toReal)) P := by |
| have hh := hfi.div_const (q:ℝ) |
| simpa only [mul_div_cancel_left₀ _ hqne] using hh |
| have hCeq : ∫ ax : A×X, Real.log (1+C ax.1) ∂P = ∫ a, Real.log (1+C a) ∂P.fst := by |
| exact (integral_map measurable_fst.aemeasurable |
| (measurable_const.add hCm |>.log.aestronglyMeasurable)).symm |
| rw [integral_const_mul, integral_const_mul, hCeq] at hbi |
| have hfinal : ∫ ax, Real.log (1+(F ax).toReal) ∂P ≤ |
| (klDiv P (P.fst.prod γ)).toReal / q + ∫ a, Real.log (1+C a) ∂P.fst := by |
| rw [← sub_le_iff_le_add, le_div_iff₀ hqpos] |
| nlinarith |
| calc |
| _ = ∫⁻ ax, ∫⁻ z, ENNReal.ofReal (Real.log (1+(K (ax,z)).toReal)) ∂η ∂P := |
| lintegral_prod _ (measurable_log_one_add hKm |>.ennreal_ofReal.aemeasurable) |
| _ ≤ ∫⁻ ax, ENNReal.ofReal (Real.log (1+(F ax).toReal)) ∂P := by |
| exact lintegral_mono fun ax => log_one_add_jensen η (fun z => K (ax,z)) |
| (hKm.comp (measurable_const.prodMk measurable_id)) (fun z => hKt (ax,z)) (hKint ax) |
| _ = ENNReal.ofReal (∫ ax, Real.log (1+(F ax).toReal) ∂P) := |
| (ofReal_integral_eq_lintegral_ofReal hLi (Filter.Eventually.of_forall fun _ => log_one_add_nonneg _)).symm |
| _ ≤ _ := ENNReal.ofReal_le_ofReal hfinal |
|
|
|
|
|
|
| end CurrentProjection |
|
|
| end |
|
|
| end OAI |
|
|
