lean/OAI/Probability/GaussianReplacement/Reference.lean

import OAI.Probability.GaussianReplacement.Tilt

namespace OAI

open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal RealInnerProductSpace Topology
noncomputable section
namespace CurrentProjection
open InnerProductSpace
open InformationTheory




lemma sphere_own_density_moment {d m r : ℕ}
    (hdim : AdmissibleDimensions d m r 1) (hd : 2 ≤ d) :
    ∫⁻ z : Rows (m+r) d × Sphere d,
      exactDensity (uniformSphere d) z.1 (label z.1 (z.2:Vector d))
      ∂(gaussianRows (m+r) d).prod (uniformSphere d) ≤
        momentConstant 9 d (3*4^d) (3*4^d) := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos (by omega)
  have hB : (0:ℝ) < 3*4^d := by positivity
  have hG := uniformSphere_growth (show 1 ≤ d by omega) (show m+r ≤ d-1 by have := hdim.2.2.2.1; omega)
  have hD := uniformSphere_growth (show 1 ≤ d by omega) (le_refl (d-1))
  have ha : ∀ᵐ (s : Sphere d) ∂uniformSphere d,
      (∫⁻ G, exactDensity (uniformSphere d) G (label G (s:Vector d))
        ∂gaussianRows (m+r) d) ≤ momentConstant 9 d (3*4^d) (3*4^d) := by
    filter_upwards [ae_target_cube_limit (k:=m+r) (uniformSphere d)] with s hs
    have hfin := extended_ae_finite hdim (uniformSphere d) _ _ hB hB hG hD s
    have he : ∀ᵐ G ∂gaussianRows (m+r) d,
        exactDensity (uniformSphere d) G (label G (s:Vector d)) =
          extendedCubeDensity (uniformSphere d) G (label G (s:Vector d)) := by
      filter_upwards [hs,hfin] with G hG hf
      exact exactDensity_eq_of_tendsto _ _ _ hG.1 hf.ne
    have hm := exact_mixed_moment_of_ae hdim (uniformSphere d) _ _ hB hB hG hD s he
    simpa only [pow_one, gaussianRows, ←lintegral_pi_append (stdGaussian (Vector d)) m r
      _ (measurable_fixed_exact (uniformSphere d) s)] using hm
  rw [lintegral_prod_symm _ (measurable_own_exact (uniformSphere d)).aemeasurable]
  exact (lintegral_mono_ae ha).trans_eq (by simp)

lemma sphere_moment_log_bound {d : ℕ} (hd : 1 ≤ d) :
    Real.log (1+(momentConstant 9 d (3*4^d) (3*4^d)).toReal) ≤ 20*d := by
  have hB : (0:ℝ) < 3*4^d := by positivity
  have he : (momentConstant 9 d (3*4^d) (3*4^d)).toReal =
      Real.exp (9*d)*(3*4^d) := by
    simp [momentConstant,ENNReal.toReal_ofReal (by positivity :
      0 ≤ Real.exp (9*d)*(3*4^d))]
  rw [he]
  have hd1 : (1:ℝ) ≤ d := by exact_mod_cast hd
  have hpow : (1:ℝ) ≤ 4^d := one_le_pow₀ (by norm_num)
  have hexp : (1:ℝ) ≤ Real.exp (9*d) := Real.one_le_exp_iff.mpr (by positivity)
  have ht : 1 ≤ Real.exp (9*d)*(3*4^d) := by nlinarith
  have hl := Real.log_le_log (by positivity : 0<1+Real.exp (9*d)*(3*4^d))
    (show 1+Real.exp (9*d)*(3*4^d) ≤ 2*(Real.exp (9*d)*(3*4^d)) by linarith)
  rw [Real.log_mul (by norm_num : (2:ℝ) ≠ 0) (by positivity),
    Real.log_mul (Real.exp_ne_zero _) hB.ne',Real.log_exp,
    Real.log_mul (by norm_num : (3:ℝ) ≠ 0) (by positivity),Real.log_pow] at hl
  have h2 := Real.log_le_self (by norm_num : (0:ℝ) ≤ 2)
  have h3 := Real.log_le_self (by norm_num : (0:ℝ) ≤ 3)
  have h4 := Real.log_le_self (by norm_num : (0:ℝ) ≤ 4)
  nlinarith

lemma sphere_label_entropy_finite {d m r : ℕ}
    (hdim : AdmissibleDimensions d m r 1) (hd : 2 ≤ d) :
    Integrable (fun z : Rows (m+r) d × Sphere d =>
      Real.log (exactDensity (uniformSphere d) z.1 (label z.1 (z.2:Vector d))).toReal)
      ((gaussianRows (m+r) d).prod (uniformSphere d)) ∧
    (∫ z : Rows (m+r) d × Sphere d,
      Real.log (exactDensity (uniformSphere d) z.1 (label z.1 (z.2:Vector d))).toReal
      ∂(gaussianRows (m+r) d).prod (uniformSphere d)) ≤ 20*d := by
  classical
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos (by omega)
  let : Nonempty (Sphere d) := nonempty_of_isProbabilityMeasure (uniformSphere d)
  let μ := (gaussianRows (m+r) d).prod (uniformSphere d)
  let f : Rows (m+r) d × Sphere d → ℝ≥0∞ :=
    fun z => exactDensity (uniformSphere d) z.1 (label z.1 (z.2:Vector d))
  have hf : Measurable f := measurable_own_exact _
  have hmoment := sphere_own_density_moment hdim hd
  have ht : ∫⁻ z, f z ∂μ ≠ ∞ := ne_top_of_le_ne_top ENNReal.ofReal_ne_top hmoment
  have hJ := log_one_add_jensen μ f hf (fun z => exactDensity_ne_top _ _ _) ht
  have hM := ENNReal.toReal_mono (show momentConstant 9 d (3*4^d) (3*4^d) ≠ ∞ from ENNReal.ofReal_ne_top) hmoment
  have hMlog := Real.log_le_log (by positivity : 0<1+(∫⁻ z, f z ∂μ).toReal)
    (show 1+(∫⁻ z, f z ∂μ).toReal ≤ 1+(momentConstant 9 d (3*4^d) (3*4^d)).toReal from by dsimp [f,μ]; linarith)
  have hb := sphere_moment_log_bound (show 1 ≤ d by omega)
  have hJ' : ∫⁻ z, ENNReal.ofReal (Real.log (1+(f z).toReal)) ∂μ ≤ ENNReal.ofReal (20*d) :=
    hJ.trans (ENNReal.ofReal_le_ofReal (hMlog.trans hb))
  obtain ⟨⟨hiL,hbL⟩,hiP,_⟩ := log_bound_consequences μ f hf (20*d) (by positivity) hJ'
  have hB : (0:ℝ) < 3*4^d := by positivity
  have hAC := ae_labelLaw_ac_of_growth hdim (uniformSphere d) _ _ hB hB
    (uniformSphere_growth (show 1 ≤ d by omega) (show m+r ≤ d-1 by have := hdim.2.2.2.1; omega))
    (uniformSphere_growth (show 1 ≤ d by omega) (le_refl (d-1)))
  let c : Sphere d := Classical.choice inferInstance
  obtain ⟨hi,_⟩ := projection_cover_entropy (uniformSphere d) hAC hiP
    (Finset.singleton_nonempty c) (show (0:ℝ)<1 by norm_num)
    (ae_of_all _ (fun s => ⟨c,Finset.mem_singleton_self c,by
      have hdist := (norm_sub_le (s:Vector d) (c:Vector d))
      simpa only [Subtype.dist_eq,dist_eq_norm,norm_eq_of_mem_sphere s,norm_eq_of_mem_sphere c,one_add_one_eq_two,mul_one] using hdist⟩))
  refine ⟨hi,?_⟩
  apply (integral_mono hi hiL (fun z => ?_)).trans hbL
  exact (le_max_left _ _).trans (logPositive_le_log_one_add (f z))




def conditionalReferenceKL {A B : Type*} [MeasurableSpace A] [MeasurableSpace B]
    (P : Measure (A×B)) (ν : Measure B) : ℝ≥0∞ := klDiv P (P.fst.prod ν)

lemma conditionalReferenceKL_chain {C A B : Type*} [MeasurableSpace C]
    [MeasurableSpace A] [MeasurableSpace B] [StandardBorelSpace B] [Nonempty B]
    (P : Measure (C×(A×B))) [IsProbabilityMeasure P]
    (ν : Measure A) (π : Measure B) [IsProbabilityMeasure ν] [IsProbabilityMeasure π] :
    conditionalReferenceKL P (ν.prod π) =
      conditionalReferenceKL (P.map (Prod.map id Prod.fst)) ν +
      conditionalReferenceKL (P.map MeasurableEquiv.prodAssoc.symm) π := by
  let R := P.map MeasurableEquiv.prodAssoc.symm
  let : IsProbabilityMeasure R := inferInstance
  have hRf : R.fst = P.map (Prod.map id Prod.fst) := by
    rw [Measure.fst,Measure.map_map measurable_fst MeasurableEquiv.prodAssoc.symm.measurable]
    rfl
  have hff : R.fst.fst = P.fst := by
    rw [hRf,Measure.fst,Measure.map_map measurable_fst (measurable_id.prodMap measurable_fst)]
    rfl
  have hr : (P.fst.prod (ν.prod π)).map MeasurableEquiv.prodAssoc.symm =
      (P.fst.prod ν).prod π := by rw [←Measure.prodAssoc_prod,MeasurableEquiv.map_symm_map]
  unfold conditionalReferenceKL
  rw [←klDiv_map_equiv P (P.fst.prod (ν.prod π)) MeasurableEquiv.prodAssoc.symm,hr,
    klDiv_prod_chain R (P.fst.prod ν) π]
  rw [←hff,hRf]

lemma conditionalReferenceKL_add_condition {C A B : Type*} [MeasurableSpace C]
    [MeasurableSpace A] [MeasurableSpace B] [StandardBorelSpace A] [StandardBorelSpace B]
    [Nonempty A] [Nonempty B]
    (P : Measure (C×(A×B))) [IsProbabilityMeasure P]
    (π : Measure B) [IsProbabilityMeasure π] :
    conditionalReferenceKL (P.map MeasurableEquiv.prodAssoc.symm) π =
      conditionalReferenceKL (P.map (Prod.map id Prod.snd)) π +
      conditionalMutualInformation P := by
  let μ := P.fst
  let κ := P.condKernel
  have hP : μ ⊗ₘ κ = P := P.disintegrate P.condKernel
  have hfst : (P.map MeasurableEquiv.prodAssoc.symm).fst = μ ⊗ₘ κ.fst := by
    rw [←hP]
    exact fst_map_assoc_compProd μ κ
  have hsnd : P.map (Prod.map id Prod.snd) = μ ⊗ₘ κ.snd := by
    rw [Kernel.snd_eq,Measure.compProd_map measurable_snd,hP]
  have href : (μ ⊗ₘ (κ.fst ×ₖ Kernel.const C π)).map MeasurableEquiv.prodAssoc.symm =
      (μ ⊗ₘ κ.fst).prod π := by
    rw [compProd_prod_assoc]
    have he : (Kernel.const C π).comap Prod.fst measurable_fst = Kernel.const (C×A) π := rfl
    rw [he,Measure.compProd_const]
  have h := conditionalKL_chain μ κ π
  rw [hP] at h
  have hc := conditionalMutualInformation_compProd μ κ
  simp only [hP] at hc
  unfold conditionalReferenceKL
  rw [hfst,←href,klDiv_map_equiv,h,←hc,hsnd,Measure.fst_compProd]

lemma conditionalMutualInformation_symm {C A B : Type*} [MeasurableSpace C]
    [MeasurableSpace A] [MeasurableSpace B] [StandardBorelSpace A] [StandardBorelSpace B]
    [Nonempty A] [Nonempty B]
    (P : Measure (C×(A×B))) [IsProbabilityMeasure P] :
    conditionalMutualInformation (P.map (Prod.map id Prod.swap)) =
      conditionalMutualInformation P := by
  let μ := P.fst
  let κ := P.condKernel
  have hP : μ ⊗ₘ κ = P := P.disintegrate P.condKernel
  have hmap : P.map (Prod.map id Prod.swap) = μ ⊗ₘ κ.map Prod.swap := by
    rw [Measure.compProd_map measurable_swap,hP]
  have hfst : (κ.map Prod.swap).fst = κ.snd := by
    rw [Kernel.fst_eq,Kernel.snd_eq,←Kernel.map_comp_right _ measurable_swap measurable_fst]
    rfl
  have hsnd : (κ.map Prod.swap).snd = κ.fst := by
    rw [Kernel.fst_eq,Kernel.snd_eq,←Kernel.map_comp_right _ measurable_swap measurable_snd]
    rfl
  have href : μ ⊗ₘ (κ.snd ×ₖ κ.fst) =
      (μ ⊗ₘ (κ.fst ×ₖ κ.snd)).map (Prod.map id Prod.swap) := by
    rw [←Measure.compProd_map measurable_swap,Kernel.map_prod_swap]
  have : IsMarkovKernel (κ.map Prod.swap) := Kernel.IsMarkovKernel.map κ measurable_swap
  have hc := conditionalMutualInformation_compProd μ (κ.map Prod.swap)
  simp only [hfst,hsnd,href,Measure.compProd_map measurable_swap] at hc
  have he := klDiv_map_equiv (μ ⊗ₘ κ) (μ ⊗ₘ (κ.fst ×ₖ κ.snd))
    ((MeasurableEquiv.refl C).prodCongr MeasurableEquiv.prodComm)
  change klDiv ((μ ⊗ₘ κ).map (Prod.map id Prod.swap))
    ((μ ⊗ₘ (κ.fst ×ₖ κ.snd)).map (Prod.map id Prod.swap)) = _ at he
  rw [he,←conditionalMutualInformation_compProd μ κ] at hc
  simpa only [hP] using hc

lemma conditionalReferenceKL_finite_condition {C A B : Type*} [MeasurableSpace C]
    [MeasurableSpace A] [MeasurableSpace B] [StandardBorelSpace B] [Nonempty B]
    [Countable A] [MeasurableSingletonClass A] [Nonempty A]
    (P : Measure (C×(A×B))) [IsProbabilityMeasure P]
    (π : Measure B) [IsProbabilityMeasure π]
    (hbase : conditionalReferenceKL (P.map (Prod.map id Prod.snd)) π ≠ ∞)
    (hH : shannonEntropy (P.map (fun z => z.2.1)) ≠ ∞) :
    conditionalReferenceKL (P.map MeasurableEquiv.prodAssoc.symm) π ≠ ∞ ∧
    (conditionalReferenceKL (P.map MeasurableEquiv.prodAssoc.symm) π).toReal ≤
      (conditionalReferenceKL (P.map (Prod.map id Prod.snd)) π).toReal +
      (shannonEntropy (P.map (fun z => z.2.1))).toReal := by
  let Q := P.map (Prod.map id Prod.swap)
  let : IsProbabilityMeasure Q := inferInstance
  have hQ : (Q.map MeasurableEquiv.prodAssoc.symm).snd = P.map (fun z => z.2.1) := by
    simp only [Q,Measure.snd,Measure.map_map measurable_snd MeasurableEquiv.prodAssoc.symm.measurable,
      Measure.map_map (measurable_snd.comp MeasurableEquiv.prodAssoc.symm.measurable)
        (measurable_id.prodMap measurable_swap)]
    rfl
  obtain ⟨hc,hcb⟩ := conditionalMutualInformation_le_entropy Q (by rwa [hQ])
  rw [hQ,conditionalMutualInformation_symm P] at hcb
  rw [conditionalMutualInformation_symm P] at hc
  rw [conditionalReferenceKL_add_condition P π]
  exact ⟨ENNReal.add_ne_top.mpr ⟨hbase,hc⟩,by rw [ENNReal.toReal_add hbase hc]; linarith⟩



def gaussianLabels (k : ℕ) : Measure (Fin k → ℝ) := Measure.pi (fun _ => gaussianReal 0 1)

instance gaussianLabels_probability (k : ℕ) : IsProbabilityMeasure (gaussianLabels k) := by
  unfold gaussianLabels
  infer_instance

lemma gaussianLabels_density (k : ℕ) :
    (volume : Measure (Fin k → ℝ)).withDensity
      (fun y => ENNReal.ofReal (gaussianProductPDF 1 0 y)) = gaussianLabels k := by
  symm
  apply Measure.pi_eq
  intro t ht
  rw [withDensity_apply _ (MeasurableSet.univ_pi ht)]
  simp only [gaussianProductPDF,radiusVariance,one_pow,Pi.zero_apply]
  change (∫⁻ y in Set.univ.pi t, ENNReal.ofReal (∏ i, gaussianPDFReal 0 1 (y i))) = _
  rw [←ofReal_integral_eq_lintegral_ofReal]
  · change ENNReal.ofReal (∫ y, ∏ i, gaussianPDFReal 0 1 (y i)
        ∂(Measure.pi (fun _ : Fin k => (volume : Measure ℝ))).restrict (Set.univ.pi t)) = _
    rw [Measure.restrict_pi_pi,integral_fintype_prod_eq_prod,
      ENNReal.ofReal_prod_of_nonneg (fun i _ => integral_nonneg (fun _ => (gaussianPDFReal_pos 0 1 _ (by norm_num)).le))]
    congr 1
    funext i
    rw [gaussianReal_apply 0 (by norm_num : (1:ℝ≥0) ≠ 0)]
    exact ofReal_integral_eq_lintegral_ofReal (integrable_gaussianPDFReal 0 1).integrableOn
      (ae_of_all _ (fun x => (gaussianPDFReal_pos 0 1 x (by norm_num)).le))
  · exact (Integrable.fintype_prod (fun _ : Fin k => integrable_gaussianPDFReal 0 1)).integrableOn
  · exact ae_of_all _ (fun y => Finset.prod_nonneg (fun i _ => (gaussianPDFReal_pos 0 1 (y i) (by norm_num)).le))

lemma log_gaussianLabelsPDF {k : ℕ} (y : Fin k → ℝ) :
    Real.log (gaussianProductPDF 1 0 y) = -(k:ℝ)*Real.log (normalizer 1) -
      (∑ i, (y i)^2)/2 := by
  simpa using log_gaussianProductPDF (k:=k) (show (0:ℝ)<1 by norm_num) (0:Fin k→ℝ) y

lemma projectionSquare_sphere_joint_integrable {d k : ℕ}
    (ρ : Measure (Sphere d)) [IsProbabilityMeasure ρ] :
    Integrable (fun z : Rows k d × Sphere d => projectionSquare z.1 (z.2:Vector d))
      ((gaussianRows k d).prod ρ) := by
  have hm : Measurable (fun z : Rows k d × Sphere d => projectionSquare z.1 (z.2:Vector d)) := by
    unfold projectionSquare label
    fun_prop
  apply (integrable_prod_iff' hm.aestronglyMeasurable).mpr
  refine ⟨ae_of_all _ (fun s => projectionSquare_integrable (s:Vector d)),?_⟩
  have he : (fun s : Sphere d => ∫ G, ‖projectionSquare G (s:Vector d)‖ ∂gaussianRows k d) =
      fun _ => (k:ℝ) := by
    funext s
    simp_rw [Real.norm_eq_abs,abs_of_nonneg (projectionSquare_nonneg _ _)]
    rw [projectionSquare_integral,norm_eq_of_mem_sphere s]
    simp
  rw [he]
  exact integrable_const _

lemma projectionSquare_sphere_joint_integral {d k : ℕ}
    (ρ : Measure (Sphere d)) [IsProbabilityMeasure ρ] :
    (∫ z : Rows k d × Sphere d, projectionSquare z.1 (z.2:Vector d)
      ∂(gaussianRows k d).prod ρ) = k := by
  rw [integral_prod_symm _ (projectionSquare_sphere_joint_integrable ρ)]
  simp only [projectionSquare_integral,norm_eq_of_mem_sphere,
    one_pow,mul_one,integral_const,probReal_univ,one_smul]

lemma gaussian_log_reference_projection {d k : ℕ}
    (ρ : Measure (Sphere d)) [IsProbabilityMeasure ρ] :
    Integrable (fun z : Rows k d×(Fin k→ℝ) =>
      Real.log (gaussianProductPDF 1 0 z.2)) (projectionJoint ρ (gaussianRows k d)) ∧
    (∫ z : Rows k d×(Fin k→ℝ), Real.log (gaussianProductPDF 1 0 z.2)
      ∂projectionJoint ρ (gaussianRows k d)) =
      -(k:ℝ)*(Real.log (normalizer 1)+1/2) := by
  have hf : Measurable (fun z : Rows k d×(Fin k→ℝ) => Real.log (gaussianProductPDF 1 0 z.2)) := by
    unfold gaussianProductPDF
    fun_prop
  have hm : Measurable (fun z : Rows k d×Sphere d => (z.1,label z.1 (z.2:Vector d))) :=
    measurable_fst.prodMk measurable_own_label
  have hi : Integrable (fun z : Rows k d×Sphere d =>
      Real.log (gaussianProductPDF 1 0 (label z.1 (z.2:Vector d))))
      ((gaussianRows k d).prod ρ) := by
    simp_rw [log_gaussianLabelsPDF]
    exact (integrable_const _).sub ((projectionSquare_sphere_joint_integrable ρ).div_const 2)
  refine ⟨(integrable_map_measure hf.aestronglyMeasurable hm.aemeasurable).mpr hi,?_⟩
  rw [projectionJoint,integral_map hm.aemeasurable hf.aestronglyMeasurable]
  simp_rw [log_gaussianLabelsPDF]
  change (∫ z : Rows k d×Sphere d, -(k:ℝ)*Real.log (normalizer 1) - projectionSquare z.1 (z.2:Vector d)/2 ∂(gaussianRows k d).prod ρ) = _
  rw [integral_sub (integrable_const _) ((projectionSquare_sphere_joint_integrable ρ).div_const 2),
    integral_const,integral_div,projectionSquare_sphere_joint_integral]
  simp only [probReal_univ,one_smul]
  ring

lemma sphere_projection_reference_finite {d m r : ℕ}
    (hdim : AdmissibleDimensions d m r 1) (hd : 2 ≤ d) :
    klDiv (projectionJoint (uniformSphere d) (gaussianRows (m+r) d))
      ((gaussianRows (m+r) d).prod (gaussianLabels (m+r))) ≠ ∞ ∧
    (klDiv (projectionJoint (uniformSphere d) (gaussianRows (m+r) d))
      ((gaussianRows (m+r) d).prod (gaussianLabels (m+r)))).toReal ≤
      20*d + (m+r:ℕ)*(Real.log (normalizer 1)+1/2) := by
  let : IsProbabilityMeasure (uniformSphere d) := uniformSphere_probability_of_pos (by omega)
  let P := projectionJoint (uniformSphere d) (gaussianRows (m+r) d)
  let Q := (gaussianRows (m+r) d).prod (gaussianLabels (m+r))
  let Λ := (gaussianRows (m+r) d).prod (volume : Measure (Fin (m+r)→ℝ))
  let p : Rows (m+r) d×(Fin (m+r)→ℝ) → ℝ≥0∞ := fun z => exactDensity (uniformSphere d) z.1 z.2
  let g : Rows (m+r) d×(Fin (m+r)→ℝ) → ℝ := fun z => gaussianProductPDF 1 0 z.2
  have hp : Measurable p := measurable_exactDensity _
  have hg : Measurable g := by unfold g gaussianProductPDF; fun_prop
  have hQ : Λ.withDensity (fun z => ENNReal.ofReal (g z)) = Q := by
    have hs : Measurable (fun y : Fin (m+r)→ℝ => ENNReal.ofReal (gaussianProductPDF 1 0 y)) := by unfold gaussianProductPDF; fun_prop
    dsimp [Λ,g,Q]
    rw [←prod_withDensity_right hs,gaussianLabels_density]
  have hB : (0:ℝ) < 3*4^d := by positivity
  have hAC := ae_labelLaw_ac_of_growth hdim (uniformSphere d) _ _ hB hB
    (uniformSphere_growth (show 1 ≤ d by omega) (show m+r ≤ d-1 by have := hdim.2.2.2.1; omega))
    (uniformSphere_growth (show 1 ≤ d by omega) (le_refl (d-1)))
  obtain ⟨hPQ,he⟩ := llr_of_two_densities P Q Λ p hp
    (projectionJoint_withDensity _ _ hAC) g hg (fun z => gaussianProductPDF_pos (by norm_num) _ _) hQ
  obtain ⟨hpi,hpb⟩ := sphere_label_entropy_finite hdim hd
  have hpm : Measurable (fun z : Rows (m+r) d×Sphere d => (z.1,label z.1 (z.2:Vector d))) :=
    measurable_fst.prodMk measurable_own_label
  have hpi' : Integrable (fun z => Real.log (p z).toReal) P :=
    (integrable_map_measure hp.ennreal_toReal.log.aestronglyMeasurable hpm.aemeasurable).mpr hpi
  obtain ⟨hgi,hge⟩ := gaussian_log_reference_projection (k:=m+r) (uniformSphere d)
  have hll : Integrable (llr P Q) P := (hpi'.sub hgi).congr he.symm
  refine ⟨klDiv_ne_top hPQ hll,?_⟩
  rw [toReal_klDiv_of_measure_eq hPQ (by simp),integral_congr_ae he,integral_sub hpi' hgi,hge]
  have hpint : (∫ z, Real.log (p z).toReal ∂P) =
      ∫ z : Rows (m+r) d×Sphere d, Real.log (exactDensity (uniformSphere d) z.1 (label z.1 (z.2:Vector d))).toReal
      ∂(gaussianRows (m+r) d).prod (uniformSphere d) :=
    integral_map hpm.aemeasurable hp.ennreal_toReal.log.aestronglyMeasurable
  rw [hpint]
  linarith




lemma weighted_log_integral {T : Type*} [MeasurableSpace T]
    (μ : Measure T) (w g : T → ℝ)
    (hw : ∀ t, 0 < w t) (hg : ∀ t, 0 < g t)
    (hwi : Integrable w μ) (hgi : Integrable g μ)
    (hli : Integrable (fun t => w t * (Real.log (g t) - Real.log (w t))) μ)
    (hA : 0 < ∫ t, w t ∂μ) (hM : 0 < ∫ t, g t ∂μ) :
    (∫ t, w t * (Real.log (g t) - Real.log (w t)) ∂μ) ≤
      (∫ t, w t ∂μ) * (Real.log (∫ t, g t ∂μ) - Real.log (∫ t, w t ∂μ)) := by
  let A := ∫ t, w t ∂μ
  let M := ∫ t, g t ∂μ
  change 0 < A at hA
  change 0 < M at hM
  have hp (t : T) : w t * (Real.log (g t) - Real.log (w t)) ≤
      w t * (Real.log M - Real.log A) + (A/M)*g t - w t := by
    have hh := Real.log_le_sub_one_of_pos (div_pos (div_pos (hg t) (hw t)) (div_pos hM hA))
    rw [Real.log_div (div_ne_zero (hg t).ne' (hw t).ne') (div_ne_zero hM.ne' hA.ne'),
      Real.log_div (hg t).ne' (hw t).ne',Real.log_div hM.ne' hA.ne'] at hh
    have hh' := mul_le_mul_of_nonneg_left hh (hw t).le
    have he : w t * ((g t / w t) / (M / A) - 1) = (A/M)*g t - w t := by
      field_simp [hA.ne',hM.ne',(hw t).ne']
    rw [he] at hh'
    nlinarith
  have hi : Integrable (fun t => w t*(Real.log M-Real.log A)+(A/M)*g t-w t) μ :=
    ((hwi.mul_const _).add (hgi.const_mul (A/M))).sub hwi
  have hb := integral_mono hli hi hp
  have hv : (∫ t, w t * (Real.log M-Real.log A) + (A/M)*g t - w t ∂μ) =
      A * (Real.log M-Real.log A) + (A/M)*M - A := by
    calc
      _ = (∫ t, w t * (Real.log M-Real.log A) + (A/M)*g t ∂μ) - A :=
        integral_sub ((hwi.mul_const _).add (hgi.const_mul _)) hwi
      _ = A * (Real.log M-Real.log A) + (A/M)*M - A := by
        rw [integral_add (hwi.mul_const (Real.log M-Real.log A)) (hgi.const_mul (A/M))]
        simp only [integral_mul_const, integral_const_mul, A, M]
  rw [hv,div_mul_cancel₀ _ hM.ne'] at hb
  linarith

def regularizedReciprocal {d : ℕ} (e : ℝ) (s t : Sphere d) : ℝ :=
  (max (dist s t) e)⁻¹

def regularizedScale {d : ℕ} (μ : Measure (Sphere d)) (e : ℝ) (s : Sphere d) : ℝ :=
  ∫ t, regularizedReciprocal e s t ∂μ

lemma sphere_subtype_dist_le_two {d : ℕ} (s t : Sphere d) : dist s t ≤ 2 := by
  simpa only [Subtype.dist_eq,dist_eq_norm,norm_eq_of_mem_sphere s,
    norm_eq_of_mem_sphere t,one_add_one_eq_two] using norm_sub_le (s:Vector d) (t:Vector d)

lemma regularizedReciprocal_pos {d : ℕ} {e : ℝ} (he : 0 < e) (s t : Sphere d) :
    0 < regularizedReciprocal e s t := inv_pos.mpr (he.trans_le (le_max_right _ _))

lemma regularizedReciprocal_bounds {d : ℕ} {e : ℝ} (he : 0 < e) (he1 : e ≤ 1)
    (s t : Sphere d) : 1/2 ≤ regularizedReciprocal e s t ∧ regularizedReciprocal e s t ≤ e⁻¹ := by
  have hmax : 0 < max (dist s t) e := he.trans_le (le_max_right _ _)
  constructor
  · simp only [one_div,regularizedReciprocal]
    change (2:ℝ)⁻¹ ≤ (max (dist s t) e)⁻¹
    exact (inv_le_inv₀ (by norm_num) hmax).mpr (max_le (sphere_subtype_dist_le_two s t) (by linarith))
  · exact (inv_le_inv₀ hmax he).mpr (le_max_right _ _)

lemma integrable_regularizedReciprocal {d : ℕ} (μ : Measure (Sphere d)) [IsProbabilityMeasure μ]
    {e : ℝ} (he : 0 < e) (s : Sphere d) : Integrable (regularizedReciprocal e s) μ := by
  apply (integrable_const (e⁻¹)).mono' (by unfold regularizedReciprocal; fun_prop)
  apply ae_of_all
  intro t
  rw [Real.norm_eq_abs,abs_of_pos (regularizedReciprocal_pos he s t)]
  exact (inv_le_inv₀ (he.trans_le (le_max_right _ _)) he).mpr (le_max_right _ _)

lemma regularizedScale_bounds {d : ℕ} (μ : Measure (Sphere d)) [IsProbabilityMeasure μ]
    {e : ℝ} (he : 0 < e) (he1 : e ≤ 1) (s : Sphere d) :
    1/2 ≤ regularizedScale μ e s ∧ regularizedScale μ e s ≤ e⁻¹ := by
  have hi := integrable_regularizedReciprocal μ he s
  constructor
  · simpa [regularizedScale] using integral_mono (integrable_const (1/2:ℝ)) hi
      (fun t => (regularizedReciprocal_bounds he he1 s t).1)
  · simpa [regularizedScale] using integral_mono hi (integrable_const (e⁻¹))
      (fun t => (regularizedReciprocal_bounds he he1 s t).2)

lemma log_regularizedReciprocal {d : ℕ} (e : ℝ) (s t : Sphere d) :
    Real.log (regularizedReciprocal e s t) = -Real.log (max (dist s t) e) := Real.log_inv _



end CurrentProjection

end

end OAI