| import OAI.Probability.GaussianReplacement.FreshRows |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Set Filter |
| open scoped ENNReal NNReal RealInnerProductSpace Topology |
| noncomputable section |
| namespace CurrentProjection |
| open InnerProductSpace |
| open InformationTheory |
|
|
|
|
| def dependentMapKernel {A B D : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace D] (κ : Kernel A B) (f : A×B → D) : Kernel A D := |
| (Kernel.id ×ₖ κ).map f |
|
|
| lemma dependentMapKernel_markov {A B D : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace D] (κ : Kernel A B) [IsMarkovKernel κ] (f : A×B → D) |
| (hf : Measurable f) : IsMarkovKernel (dependentMapKernel κ f) := |
| Kernel.IsMarkovKernel.map _ hf |
|
|
| lemma dependentMapKernel_apply {A B D : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace D] (κ : Kernel A B) [IsSFiniteKernel κ] (f : A×B → D) |
| (hf : Measurable f) (a : A) : dependentMapKernel κ f a = (κ a).map (fun b => f (a,b)) := by |
| rw [dependentMapKernel,Kernel.map_apply _ hf,Kernel.prod_apply,Kernel.id_apply, |
| Measure.dirac_prod,Measure.map_map hf (measurable_prodMk_left (x:=a))] |
| rfl |
|
|
| lemma compProd_dependentMapKernel {A B D : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace D] (μ : Measure A) [SFinite μ] |
| (κ : Kernel A B) [IsSFiniteKernel κ] (f : A×B → D) (hf : Measurable f) : |
| μ ⊗ₘ dependentMapKernel κ f = (μ ⊗ₘ κ).map (fun z => (z.1,f z)) := by |
| have : IsSFiniteKernel (dependentMapKernel κ f) := by unfold dependentMapKernel; infer_instance |
| ext t ht |
| rw [Measure.compProd_apply ht,Measure.map_apply (measurable_fst.prodMk hf) ht, |
| Measure.compProd_apply (ht.preimage (measurable_fst.prodMk hf))] |
| apply lintegral_congr |
| intro a |
| rw [dependentMapKernel_apply κ f hf a, |
| Measure.map_apply (show Measurable (fun b => f (a,b)) from hf.comp measurable_prodMk_left) |
| (ht.preimage (measurable_prodMk_left (x:=a)))] |
| rfl |
|
|
| lemma compProd_conditional_prod_swap {C S X : Type*} [MeasurableSpace C] |
| [MeasurableSpace S] [MeasurableSpace X] (μ : Measure C) [SFinite μ] |
| (κ : Kernel C S) [IsSFiniteKernel κ] (γ : Measure X) [SFinite γ] : |
| ((μ.prod γ) ⊗ₘ κ.comap Prod.fst measurable_fst).map |
| (fun z : (C×X)×S => ((z.1.1,z.2),z.1.2)) = (μ ⊗ₘ κ).prod γ := by |
| have h1 := compProd_prod_assoc μ (Kernel.const C γ) κ |
| rw [Measure.compProd_const] at h1 |
| rw [←h1,Measure.map_map (by fun_prop) MeasurableEquiv.prodAssoc.symm.measurable] |
| have h2 := compProd_prod_assoc μ κ (Kernel.const C γ) |
| have hconst : (Kernel.const C γ).comap (Prod.fst : C×S → C) measurable_fst = Kernel.const _ γ := rfl |
| rw [hconst,Measure.compProd_const] at h2 |
| rw [←h2,←Kernel.map_prod_swap (Kernel.const C γ) κ,Measure.compProd_map measurable_swap, |
| Measure.map_map MeasurableEquiv.prodAssoc.symm.measurable (measurable_id.prodMap measurable_swap)] |
| rfl |
|
|
| def scalarProjectionKernel {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (κ : Kernel C (Sphere d)) : Kernel (C×Vector d) ℝ := |
| dependentMapKernel (κ.comap Prod.fst measurable_fst) |
| (fun z : (C×Vector d)×Sphere d => ⟪(z.2:Vector d),z.1.2⟫) |
|
|
| instance scalarProjectionKernel_markov {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (κ : Kernel C (Sphere d)) [IsMarkovKernel κ] : IsMarkovKernel (scalarProjectionKernel κ) := |
| dependentMapKernel_markov _ _ (by fun_prop) |
|
|
| lemma scalarProjectionKernel_apply {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (κ : Kernel C (Sphere d)) [IsSFiniteKernel κ] (z : C×Vector d) : |
| scalarProjectionKernel κ z = (κ z.1).map (fun s : Sphere d => ⟪(s:Vector d),z.2⟫) := |
| dependentMapKernel_apply _ _ (by fun_prop) _ |
|
|
| def scalarObservation {d : ℕ} {C : Type*} (z : (C×Sphere d)×Vector d) : (C×Vector d)×ℝ := |
| ((z.1.1,z.2),⟪(z.1.2:Vector d),z.2⟫) |
|
|
| lemma measurable_scalarObservation {d : ℕ} {C : Type*} [MeasurableSpace C] : |
| Measurable (scalarObservation (d:=d) (C:=C)) := by unfold scalarObservation; fun_prop |
|
|
| def scalarObservationLaw {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) : Measure ((C×Vector d)×ℝ) := |
| (Γ.prod (stdGaussian (Vector d))).map scalarObservation |
|
|
| instance scalarObservationLaw_probability {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] : IsProbabilityMeasure (scalarObservationLaw Γ) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| measurable_scalarObservation.aemeasurable).mpr inferInstance |
|
|
| lemma scalarObservationLaw_disintegrate {d : ℕ} [Nonempty (Sphere d)] |
| {C : Type*} [MeasurableSpace C] (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] : |
| (Γ.fst.prod (stdGaussian (Vector d))) ⊗ₘ scalarProjectionKernel Γ.condKernel = scalarObservationLaw Γ := by |
| rw [scalarProjectionKernel,compProd_dependentMapKernel _ _ _ (by fun_prop),scalarObservationLaw] |
| have he := compProd_conditional_prod_swap Γ.fst Γ.condKernel (stdGaussian (Vector d)) |
| rw [Γ.disintegrate Γ.condKernel] at he |
| rw [←he,Measure.map_map measurable_scalarObservation (by fun_prop)] |
| rfl |
|
|
| lemma scalarObservationLaw_fst {d : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] : |
| (scalarObservationLaw Γ).fst = Γ.fst.prod (stdGaussian (Vector d)) := by |
| rw [←scalarObservationLaw_disintegrate Γ,Measure.fst_compProd] |
|
|
| lemma scalarCube_projection {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (κ : Kernel C (Sphere d)) [IsSFiniteKernel κ] (z : C×Vector d) (s : Sphere d) (δ : ℝ) : |
| scalarCube (scalarProjectionKernel κ z) ⟪(s:Vector d),z.2⟫ δ = |
| ∫⁻ t : Sphere d, cubeKernel δ ⟪(t:Vector d)-(s:Vector d),z.2⟫ ∂κ z.1 := by |
| rw [scalarCube,scalarProjectionKernel_apply,lintegral_map |
| (f:=fun t : ℝ => cubeKernel δ (t-⟪(s:Vector d),z.2⟫)) |
| ((measurable_cubeKernel δ).comp (by fun_prop)) (by fun_prop)] |
| simp only [inner_sub_left] |
|
|
| lemma scalarObservationLaw_kernel_ac {d : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] |
| (h : conditionalReferenceKL (scalarObservationLaw Γ) (gaussianReal 0 1) ≠ ∞) : |
| ∀ᵐ a ∂Γ.fst.prod (stdGaussian (Vector d)), scalarProjectionKernel Γ.condKernel a ≪ volume := by |
| have hac := (klDiv_ne_top_iff.mp h).1 |
| have hgv : gaussianReal 0 1 ≪ (volume : Measure ℝ) := by |
| rw [gaussianReal_of_var_ne_zero _ (by norm_num)] |
| exact withDensity_absolutelyContinuous _ _ |
| change scalarObservationLaw Γ ≪ (scalarObservationLaw Γ).fst.prod (gaussianReal 0 1) at hac |
| have hh : (Γ.fst.prod (stdGaussian (Vector d))) ⊗ₘ scalarProjectionKernel Γ.condKernel ≪ |
| (Γ.fst.prod (stdGaussian (Vector d))) ⊗ₘ Kernel.const _ (gaussianReal 0 1) := by |
| rw [Measure.compProd_const,scalarObservationLaw_disintegrate Γ,←scalarObservationLaw_fst Γ] |
| exact hac |
| exact hh.kernel_of_compProd.mono (fun a ha => ha.trans hgv) |
|
|
| lemma scalarObservationLaw_density {d : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] |
| (h : conditionalReferenceKL (scalarObservationLaw Γ) (gaussianReal 0 1) ≠ ∞) : |
| ((scalarObservationLaw Γ).fst.prod volume).withDensity |
| (fun z => scalarDensity (scalarProjectionKernel Γ.condKernel z.1) z.2) = scalarObservationLaw Γ := by |
| rw [scalarObservationLaw_fst,←scalarObservationLaw_disintegrate Γ] |
| exact kernel_scalarDensity_withDensity _ _ (scalarObservationLaw_kernel_ac Γ h) |
|
|
| lemma scalarObservationLaw_ae_limit {d : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] |
| (h : conditionalReferenceKL (scalarObservationLaw Γ) (gaussianReal 0 1) ≠ ∞) : |
| ∀ᵐ z ∂scalarObservationLaw Γ, Tendsto |
| (fun n : ℕ => scalarCube (scalarProjectionKernel Γ.condKernel z.1) z.2 (1/(n:ℝ))) |
| atTop (𝓝 (scalarDensity (scalarProjectionKernel Γ.condKernel z.1) z.2)) := by |
| have ha : scalarObservationLaw Γ ≪ (scalarObservationLaw Γ).fst.prod volume := by |
| have hh := withDensity_absolutelyContinuous |
| ((scalarObservationLaw Γ).fst.prod volume) |
| (fun z => scalarDensity (scalarProjectionKernel Γ.condKernel z.1) z.2) |
| rwa [scalarObservationLaw_density Γ h] at hh |
| exact ha.ae_le (kernel_scalarDensity_ae_limit (scalarObservationLaw Γ).fst |
| (scalarProjectionKernel Γ.condKernel)) |
|
|
| lemma prod_map_swap23 {A B D : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| [MeasurableSpace D] (μ : Measure A) (ν : Measure B) (π : Measure D) |
| [SFinite μ] [SFinite ν] [SFinite π] : |
| ((μ.prod ν).prod π).map (fun z : (A×B)×D => ((z.1.1,z.2),z.1.2)) = (μ.prod π).prod ν := by |
| have h : ((μ.prod ν).prod π).map (fun z : (A×B)×D => ((z.1.1,z.2),z.1.2)) = |
| (((μ.prod ν).prod π).map MeasurableEquiv.prodAssoc).map |
| ((MeasurableEquiv.prodAssoc : (A×D)×B ≃ᵐ A×(D×B)).symm ∘ Prod.map id Prod.swap) := by |
| rw [Measure.map_map (by fun_prop) MeasurableEquiv.prodAssoc.measurable] |
| rfl |
| rw [h,Measure.prodAssoc_prod,←Measure.map_map MeasurableEquiv.prodAssoc.symm.measurable |
| (measurable_id.prodMap measurable_swap),←Measure.map_prod_map _ _ measurable_id measurable_swap, |
| Measure.map_id,Measure.prod_swap,←Measure.prodAssoc_prod,MeasurableEquiv.map_symm_map] |
|
|
|
|
|
|
| def residualLabelObservation {d r : ℕ} {C : Type*} |
| (w : ((C×Sphere d)×Vector d)×Rows r d) : ((C×(Rows r d×(Fin r→ℝ)))×Vector d)×ℝ := |
| (((w.1.1.1,(w.2,label w.2 (w.1.1.2:Vector d))),w.1.2),⟪(w.1.1.2:Vector d),w.1.2⟫) |
|
|
| lemma measurable_residualLabelObservation {d r : ℕ} {C : Type*} [MeasurableSpace C] : |
| Measurable (residualLabelObservation (d:=d) (r:=r) (C:=C)) := by |
| unfold residualLabelObservation label |
| fun_prop |
|
|
| def residualLabelLaw {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) (r : ℕ) : |
| Measure (((C×(Rows r d×(Fin r→ℝ)))×Vector d)×ℝ) := |
| (P.prod (gaussianRows r d)).map residualLabelObservation |
|
|
| instance residualLabelLaw_probability {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| IsProbabilityMeasure (residualLabelLaw P r) := by |
| exact (Measure.isProbabilityMeasure_map_iff |
| measurable_residualLabelObservation.aemeasurable).mpr inferInstance |
|
|
| lemma residualLabelLaw_fresh {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] (r : ℕ) : |
| residualLabelLaw (Γ.prod (stdGaussian (Vector d))) r = |
| scalarObservationLaw (residualLaw Γ r) := by |
| unfold scalarObservationLaw residualLaw |
| have he : ((Γ.prod (gaussianRows r d)).map residualObservation).prod (stdGaussian (Vector d)) = |
| ((Γ.prod (gaussianRows r d)).prod (stdGaussian (Vector d))).map |
| (Prod.map residualObservation id) := by |
| simpa only [Measure.map_id] using Measure.map_prod_map |
| (Γ.prod (gaussianRows r d)) (stdGaussian (Vector d)) measurable_residualObservation measurable_id |
| rw [he,←prod_map_swap23 Γ (stdGaussian (Vector d)) (gaussianRows r d), |
| Measure.map_map (measurable_residualObservation.prodMap measurable_id) (by fun_prop), |
| Measure.map_map measurable_scalarObservation |
| ((measurable_residualObservation.prodMap measurable_id).comp (by fun_prop))] |
| rfl |
|
|
| lemma klDiv_prod_same {A B : Type*} [MeasurableSpace A] [MeasurableSpace B] |
| (μ ν : Measure A) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν] |
| (π : Measure B) [IsProbabilityMeasure π] : klDiv (μ.prod π) (ν.prod π) = klDiv μ ν := by |
| rw [←Measure.compProd_const,←Measure.compProd_const] |
| exact klDiv_compProd_left _ _ _ |
|
|
| lemma residualLabelLaw_kl_le {d : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] (r : ℕ) : |
| klDiv (residualLabelLaw P r) (scalarObservationLaw (residualLaw P.fst r)) ≤ |
| klDiv P (P.fst.prod (stdGaussian (Vector d))) := by |
| rw [←residualLabelLaw_fresh P.fst r] |
| exact (klDiv_map_le _ _ measurable_residualLabelObservation).trans_eq |
| (klDiv_prod_same _ _ _) |
|
|
| def residualExact {d r : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] |
| (w : ((C×Sphere d)×Vector d)×Rows r d) : ℝ≥0∞ := |
| scalarDensity (scalarProjectionKernel (residualLaw Γ r).condKernel |
| (residualLabelObservation w).1) (residualLabelObservation w).2 / |
| residualScale Γ w.1.1 w.2 |
|
|
| lemma measurable_residualExact {d r : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] : |
| Measurable (residualExact (r:=r) Γ) := by |
| exact ((measurable_scalarDensity (scalarProjectionKernel (residualLaw Γ r).condKernel)).comp |
| measurable_residualLabelObservation).div ((measurable_residualScale Γ).comp |
| (measurable_fst.fst.prodMk measurable_snd)) |
|
|
| lemma residualExact_finite {d r : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (Γ : Measure (C×Sphere d)) [IsProbabilityMeasure Γ] |
| (w : ((C×Sphere d)×Vector d)×Rows r d) : residualExact Γ w ≠ ∞ := by |
| exact ENNReal.div_ne_top (scalarDensity_finite _ _) |
| (ne_of_gt (lt_of_lt_of_le (by norm_num) (residualScale_lower Γ w.1.1 w.2))) |
|
|
| lemma residualCube_ae_limit_actual {d r : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] |
| (hKL : klDiv P (P.fst.prod (stdGaussian (Vector d))) ≠ ∞) |
| (href : conditionalReferenceKL (scalarObservationLaw (residualLaw P.fst r)) (gaussianReal 0 1) ≠ ∞) : |
| ∀ᵐ w ∂P.prod (gaussianRows r d), Tendsto |
| (fun n : ℕ => residualCube P.fst (1/(n:ℝ)) w) atTop (𝓝 (residualExact P.fst w)) := by |
| have hk := ne_top_of_le_ne_top hKL (residualLabelLaw_kl_le P r) |
| have ha := (klDiv_ne_top_iff.mp hk).1 |
| have ht := ha.ae_le (scalarObservationLaw_ae_limit (residualLaw P.fst r) href) |
| have hh := ae_of_ae_map measurable_residualLabelObservation.aemeasurable ht |
| filter_upwards [hh] with w hw |
| have hd := ENNReal.Tendsto.div_const hw (Or.inr |
| (ne_of_gt (lt_of_lt_of_le (by norm_num) (residualScale_lower P.fst w.1.1 w.2)))) |
| convert hd using 1 |
| · funext n |
| dsimp only [residualLabelObservation,Prod.fst,Prod.snd] |
| rw [scalarCube_projection] |
| rfl |
| · rfl |
|
|
| lemma residualCube_log_bound {d r q : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] |
| (hKL : klDiv P (P.fst.prod (stdGaussian (Vector d))) ≠ ∞) |
| (hr : r ≤ d) (hd : d ≤ 8*r) (hq : 1 ≤ q) (hqr : 2*q ≤ r) (hmargin : 2 ≤ r-q) |
| (hfin : ∀ᵐ z ∂residualLaw P.fst r, reciprocalScale ((residualLaw P.fst r).condKernel z.1) z.2 ≠ ∞) |
| {δ : ℝ} (hδ : 0 < δ) : |
| ∫⁻ w, ENNReal.ofReal (Real.log (1+(residualCube P.fst δ w).toReal)) ∂P.prod (gaussianRows r d) ≤ |
| ENNReal.ofReal ((klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal / q + |
| Real.log (1+5*kernelSmallBallConstant)) := by |
| have hc : 0 ≤ 5*kernelSmallBallConstant := by |
| have := kernelSmallBallConstant_ge_two |
| linarith |
| simpa only [integral_const,probReal_univ,one_smul] using mixed_entropy_log_bound_ae P |
| (stdGaussian (Vector d)) (gaussianRows r d) hKL (residualCube P.fst δ) |
| (measurable_residualCube P.fst δ) (residualCube_finite P.fst δ) (residualCube_integral_finite P.fst δ) |
| (fun _ => 5*kernelSmallBallConstant) measurable_const (fun _=>hc) (integrable_const _) hq |
| (residualCube_moment P.fst hr hd hqr hmargin hfin hδ) |
|
|
| lemma residualExact_log_bound {d r q : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] |
| (hKL : klDiv P (P.fst.prod (stdGaussian (Vector d))) ≠ ∞) |
| (hr : r ≤ d) (hd : d ≤ 8*r) (hq : 1 ≤ q) (hqr : 2*q ≤ r) (hmargin : 2 ≤ r-q) |
| (hfin : ∀ᵐ z ∂residualLaw P.fst r, reciprocalScale ((residualLaw P.fst r).condKernel z.1) z.2 ≠ ∞) |
| (href : conditionalReferenceKL (scalarObservationLaw (residualLaw P.fst r)) (gaussianReal 0 1) ≠ ∞) : |
| Integrable (fun w => Real.log (1+(residualExact P.fst w).toReal)) (P.prod (gaussianRows r d)) ∧ |
| (∫ w, Real.log (1+(residualExact P.fst w).toReal) ∂P.prod (gaussianRows r d)) ≤ |
| (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal / q + |
| Real.log (1+5*kernelSmallBallConstant) := by |
| have hR : 0 ≤ (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal / q + |
| Real.log (1+5*kernelSmallBallConstant) := by |
| apply add_nonneg (by positivity) |
| apply Real.log_nonneg |
| have := kernelSmallBallConstant_ge_two |
| linarith |
| apply (log_bound_consequences _ _ (measurable_residualExact P.fst) _ hR ?_).1 |
| apply log_lintegral_bound_of_ae_tendsto _ (fun n => residualCube P.fst (1/(n:ℝ))) |
| (residualExact P.fst) (fun n => measurable_residualCube P.fst _) (residualExact_finite P.fst) |
| (residualCube_ae_limit_actual P hKL href) |
| intro n hn |
| exact residualCube_log_bound P hKL hr hd hq hqr hmargin hfin (by positivity) |
|
|
|
|
|
|
|
|
| lemma klDiv_map_bound_of_llr_le {A D : Type*} [MeasurableSpace A] [MeasurableSpace D] |
| (P : Measure A) [IsProbabilityMeasure P] (R : Measure D) [IsProbabilityMeasure R] |
| (f : A → D) (hf : Measurable f) (ha : P.map f ≪ R) |
| (u : A → ℝ) (hu : Integrable u P) |
| (hb : ∀ᵐ w ∂P, llr (P.map f) R (f w) ≤ u w) : |
| klDiv (P.map f) R ≠ ∞ ∧ (klDiv (P.map f) R).toReal ≤ ∫ w, u w ∂P := by |
| let : IsProbabilityMeasure (P.map f) := inferInstance |
| have hri : Integrable (fun x => (R.rnDeriv (P.map f) x).toReal) (P.map f) := by |
| simpa only [IntegrableOn,Measure.restrict_univ] using |
| (Measure.integrableOn_toReal_rnDeriv (μ:=R) (ν:=P.map f) (s:=Set.univ) (measure_ne_top _ _)) |
| have hri' : Integrable (fun w => (R.rnDeriv (P.map f) (f w)).toReal) P := |
| (integrable_map_measure (Measurable.ennreal_toReal (Measure.measurable_rnDeriv _ _)).aestronglyMeasurable |
| hf.aemeasurable).mp hri |
| have hlo : ∀ᵐ w ∂P, -(R.rnDeriv (P.map f) (f w)).toReal ≤ llr (P.map f) R (f w) := by |
| filter_upwards [ae_of_ae_map hf.aemeasurable (exp_neg_llr ha)] with w hw |
| have ht := Real.add_one_le_exp (-llr (P.map f) R (f w)) |
| rw [hw] at ht |
| linarith |
| have hi : Integrable (fun w => llr (P.map f) R (f w)) P := integrable_of_le_of_le |
| ((measurable_llr _ _).comp hf).aestronglyMeasurable hlo hb hri'.neg hu |
| have hi' : Integrable (llr (P.map f) R) (P.map f) := |
| (integrable_map_measure (measurable_llr _ _).aestronglyMeasurable hf.aemeasurable).mpr hi |
| refine ⟨klDiv_ne_top ha hi',?_⟩ |
| rw [toReal_klDiv_of_measure_eq ha (by simp),integral_map hf.aemeasurable |
| (measurable_llr _ _).aestronglyMeasurable] |
| exact integral_mono_ae hi hu hb |
|
|
| lemma klDiv_map_cross_bound {A D : Type*} [MeasurableSpace A] [MeasurableSpace D] |
| (P : Measure A) [IsProbabilityMeasure P] (Q R : Measure D) |
| [IsProbabilityMeasure Q] [IsProbabilityMeasure R] |
| (f : A → D) (hf : Measurable f) (hPQ : klDiv (P.map f) Q ≠ ∞) (hQR : Q ≪ R) |
| (u : A → ℝ) (hu : Integrable u P) |
| (hb : ∀ᵐ w ∂P, llr Q R (f w) ≤ u w) : |
| klDiv (P.map f) R ≠ ∞ ∧ (klDiv (P.map f) R).toReal ≤ |
| (klDiv (P.map f) Q).toReal + ∫ w, u w ∂P := by |
| let : IsProbabilityMeasure (P.map f) := inferInstance |
| obtain ⟨ha,hi⟩ := klDiv_ne_top_iff.mp hPQ |
| have hi' : Integrable (fun w => llr (P.map f) Q (f w)) P := |
| (integrable_map_measure (measurable_llr _ _).aestronglyMeasurable hf.aemeasurable).mp hi |
| have he := ae_of_ae_map hf.aemeasurable (llr_chain_ae (P.map f) Q R ha hQR) |
| have hb' : ∀ᵐ w ∂P, llr (P.map f) R (f w) ≤ llr (P.map f) Q (f w)+u w := by |
| filter_upwards [he,hb] with w hw hb |
| rw [hw] |
| linarith |
| obtain ⟨hfin,hbound⟩ := klDiv_map_bound_of_llr_le P R f hf (ha.trans hQR) _ (hi'.add hu) hb' |
| refine ⟨hfin,?_⟩ |
| simp only [Pi.add_apply] at hbound |
| rw [integral_add hi' hu,←integral_map hf.aemeasurable (measurable_llr _ _).aestronglyMeasurable, |
| ←toReal_klDiv_of_measure_eq ha (by simp)] at hbound |
| exact hbound |
| |
| |
| |
| lemma residualSignalLaw {d r : ℕ} {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] : |
| (P.prod (gaussianRows r d)).map |
| (fun w => residualObservation (w.1.1,w.2)) = residualLaw P.fst r := by |
| unfold residualLaw |
| have he : (P.fst.prod (gaussianRows r d)) = |
| (P.prod (gaussianRows r d)).map (Prod.map Prod.fst id) := by |
| simpa only [Measure.map_id,Measure.fst] using Measure.map_prod_map P (gaussianRows r d) measurable_fst measurable_id |
| rw [he,Measure.map_map measurable_residualObservation (measurable_fst.prodMap measurable_id)] |
| rfl |
| |
| lemma density_positive_ae {A : Type*} [MeasurableSpace A] |
| (Q Λ : Measure A) [IsProbabilityMeasure Q] [SigmaFinite Λ] |
| (p : A → ℝ≥0∞) (hp : Measurable p) (he : Λ.withDensity p = Q) : |
| ∀ᵐ a ∂Q, 0 < p a := by |
| have ha : Q ≪ Λ := by rw [←he]; exact withDensity_absolutelyContinuous _ _ |
| have hr : Q.rnDeriv Λ =ᵐ[Λ] p := by rw [←he]; exact Measure.rnDeriv_withDensity _ hp |
| filter_upwards [ha.ae_le hr,Measure.rnDeriv_pos ha] with a h1 h2 |
| rwa [←h1] |
| |
| lemma log_le_log_scale_add {p A : ℝ≥0∞} (hp : 0 < p) (hpt : p ≠ ∞) |
| (hA : 0 < A) (hAt : A ≠ ∞) : |
| Real.log p.toReal ≤ Real.log A.toReal+Real.log (1+(p/A).toReal) := by |
| have hp' := ENNReal.toReal_pos hp.ne' hpt |
| have hA' := ENNReal.toReal_pos hA.ne' hAt |
| rw [ENNReal.toReal_div] |
| have hl := Real.log_le_log (div_pos hp' hA') (le_add_of_nonneg_left (show (0:ℝ)≤1 by norm_num) : p.toReal/A.toReal ≤ 1+p.toReal/A.toReal) |
| rw [Real.log_div hp'.ne' hA'.ne'] at hl |
| linarith |
| |
| def hybridRowConstant : ℝ := cauchyTiltConstant+Real.log (1+5*kernelSmallBallConstant) |
| |
| lemma residual_reference_bound {d r q : ℕ} [Nonempty (Sphere d)] {C : Type*} [MeasurableSpace C] |
| (P : Measure ((C×Sphere d)×Vector d)) [IsProbabilityMeasure P] |
| (hKL : klDiv P (P.fst.prod (stdGaussian (Vector d))) ≠ ∞) |
| (hr : r ≤ d) (hd : d ≤ 8*r) (hq : 1 ≤ q) (hqr : 2*q ≤ r) (hmargin : 2 ≤ r-q) |
| (hfresh : conditionalReferenceKL (scalarObservationLaw (residualLaw P.fst r)) (gaussianReal 0 1) ≠ ∞) |
| (hnext : conditionalReferenceKL (cauchyObservationLaw (residualLaw P.fst r)) (gaussianReal 0 1) ≠ ∞) |
| (hlabel : (residualLabelLaw P r).snd = gaussianReal 0 1) : |
| klDiv (residualLabelLaw P r) |
| ((scalarObservationLaw (residualLaw P.fst r)).fst.prod (gaussianReal 0 1)) ≠ ∞ ∧ |
| (klDiv (residualLabelLaw P r) |
| ((scalarObservationLaw (residualLaw P.fst r)).fst.prod (gaussianReal 0 1))).toReal ≤ |
| (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal + |
| (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal / q + hybridRowConstant + |
| (conditionalReferenceKL (cauchyObservationLaw (residualLaw P.fst r)) (gaussianReal 0 1)).toReal := by |
| let Γ := residualLaw P.fst r |
| let M := P.prod (gaussianRows r d) |
| let Q := scalarObservationLaw Γ |
| let R := Q.fst.prod (gaussianReal 0 1) |
| let Λ := Q.fst.prod (volume : Measure ℝ) |
| let p : ((C×(Rows r d×(Fin r→ℝ)))×Vector d)×ℝ → ℝ≥0∞ := |
| fun z => scalarDensity (scalarProjectionKernel Γ.condKernel z.1) z.2 |
| have hp : Measurable p := measurable_scalarDensity _ |
| have hpQ : Λ.withDensity p = Q := scalarObservationLaw_density Γ hfresh |
| have hgR : Λ.withDensity (fun z => ENNReal.ofReal (gaussianPDFReal 0 1 z.2)) = R := by |
| rw [show (fun z : ((C×(Rows r d×(Fin r→ℝ)))×Vector d)×ℝ => |
| ENNReal.ofReal (gaussianPDFReal 0 1 z.2)) = (fun z => gaussianPDF 0 1 z.2) from rfl, |
| ←prod_withDensity_right (measurable_gaussianPDF 0 1)] |
| change Q.fst.prod _ = Q.fst.prod (gaussianReal 0 1) |
| rw [gaussianReal_of_var_ne_zero 0 (by norm_num : (1:ℝ≥0) ≠ 0)] |
| have hdens := llr_of_two_densities Q R Λ p hp hpQ |
| (fun z => gaussianPDFReal 0 1 z.2) (by fun_prop) |
| (fun z => gaussianPDFReal_pos _ _ _ (by norm_num)) hgR |
| have hobsKL := ne_top_of_le_ne_top hKL (residualLabelLaw_kl_le P r) |
| have hobsAC := (klDiv_ne_top_iff.mp hobsKL).1 |
| have hpos := ae_of_ae_map measurable_residualLabelObservation.aemeasurable |
| (hobsAC.ae_le (density_positive_ae Q Λ p hp hpQ)) |
| have hllr := ae_of_ae_map measurable_residualLabelObservation.aemeasurable (hobsAC.ae_le hdens.2) |
| obtain ⟨hAfinite,hAi,hAb⟩ := reciprocalScale_experiment_bound Γ Γ.condKernel hnext |
| have hmap : M.map (fun w => residualObservation (w.1.1,w.2)) = Γ := residualSignalLaw P |
| have hmapm : Measurable (fun w : ((C×Sphere d)×Vector d)×Rows r d => residualObservation (w.1.1,w.2)) := |
| measurable_residualObservation.comp (measurable_fst.fst.prodMk measurable_snd) |
| have hAm : Measurable (fun z : (C×(Rows r d×(Fin r→ℝ)))×Sphere d => |
| Real.log (reciprocalScale (Γ.condKernel z.1) z.2).toReal) := |
| (reciprocalScale_kernel_measurable Γ.condKernel).ennreal_toReal.log |
| have hAi' : Integrable (fun w => Real.log (residualScale P.fst w.1.1 w.2).toReal) M := by |
| exact (integrable_map_measure hAm.aestronglyMeasurable hmapm.aemeasurable).mp (hmap.symm ▸ hAi) |
| have hAb' : (∫ w, Real.log (residualScale P.fst w.1.1 w.2).toReal ∂M) ≤ |
| cauchyTiltConstant-standardGaussianEntropy+ |
| (conditionalReferenceKL (cauchyObservationLaw Γ) (gaussianReal 0 1)).toReal := by |
| have he := integral_map (μ:=M) hmapm.aemeasurable hAm.aestronglyMeasurable |
| rw [hmap] at he |
| exact he ▸ hAb |
| have hAf : ∀ᵐ w ∂M, residualScale P.fst w.1.1 w.2 ≠ ∞ := by |
| have ht : ∀ᵐ z ∂M.map (fun w => residualObservation (w.1.1,w.2)), |
| reciprocalScale (Γ.condKernel z.1) z.2 ≠ ∞ := by rwa [hmap] |
| exact ae_of_ae_map hmapm.aemeasurable ht |
| obtain ⟨hNi,hNb⟩ := residualExact_log_bound P hKL hr hd hq hqr hmargin hAfinite hfresh |
| obtain ⟨hgi,hgb⟩ := standardGaussian_cross_entropy (residualLabelLaw P r) hlabel |
| have hgm : Measurable (fun z : ((C×(Rows r d×(Fin r→ℝ)))×Vector d)×ℝ => |
| Real.log (gaussianPDFReal 0 1 z.2)) := by fun_prop |
| have hgi' : Integrable (fun w => Real.log (gaussianPDFReal 0 1 (residualLabelObservation w).2)) M := |
| (integrable_map_measure hgm.aestronglyMeasurable measurable_residualLabelObservation.aemeasurable).mp hgi |
| let u : ((C×Sphere d)×Vector d)×Rows r d → ℝ := fun w => |
| Real.log (residualScale P.fst w.1.1 w.2).toReal + Real.log (1+(residualExact P.fst w).toReal) - |
| Real.log (gaussianPDFReal 0 1 (residualLabelObservation w).2) |
| have hui : Integrable u M := (hAi'.add hNi).sub hgi' |
| have hu : ∀ᵐ w ∂M, llr Q R (residualLabelObservation w) ≤ u w := by |
| filter_upwards [hllr,hpos,hAf] with w hl hp0 hAt |
| rw [hl] |
| have ht := log_le_log_scale_add hp0 (scalarDensity_finite _ _) |
| (lt_of_lt_of_le (by norm_num) (residualScale_lower P.fst w.1.1 w.2)) hAt |
| exact sub_le_sub_right ht _ |
| obtain ⟨hfin,hbound⟩ := klDiv_map_cross_bound M Q R residualLabelObservation |
| measurable_residualLabelObservation hobsKL hdens.1 u hui hu |
| refine ⟨hfin,?_⟩ |
| have hK : (klDiv (residualLabelLaw P r) Q).toReal ≤ |
| (klDiv P (P.fst.prod (stdGaussian (Vector d)))).toReal := |
| ENNReal.toReal_mono hKL (residualLabelLaw_kl_le P r) |
| have hgb' : -(∫ w, Real.log (gaussianPDFReal 0 1 (residualLabelObservation w).2) ∂M) = standardGaussianEntropy := by |
| rw [←integral_map measurable_residualLabelObservation.aemeasurable hgm.aestronglyMeasurable] |
| simpa only [integral_neg,residualLabelLaw,M] using hgb |
| dsimp only [u] at hbound |
| have hsum : Integrable (fun w => Real.log (residualScale P.fst w.1.1 w.2).toReal + |
| Real.log (1+(residualExact P.fst w).toReal)) M := hAi'.add hNi |
| rw [integral_sub hsum hgi',integral_add hAi' hNi] at hbound |
| change _ ≤ _ + _ + (cauchyTiltConstant+Real.log (1+5*kernelSmallBallConstant)) + _ |
| dsimp only [M,Q,R,Γ,residualLabelLaw] at hbound hK hAb' hNb hgb' ⊢ |
| linarith |
|
|
|
|
|
|
| end CurrentProjection |
|
|
| end |
|
|
| end OAI |
|
|
