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