import Mathlib
import OAI.Analysis.HardSphere.Kernels.FiniteKernelPi
import OAI.Analysis.HardSphere.Geometry.LocalCheck

namespace OAI

noncomputable section
open MeasureTheory ProbabilityTheory
open scoped ENNReal
open MeasureTheory Function Set Filter
open scoped ENNReal BigOperators
namespace HardSphere.Comparison
open ProbabilityTheory

section AuxiliaryMarginals
variable {ι : Type*} [DecidableEq ι] {X Z : ι → Type*}
  [∀ i, MeasurableSpace (X i)] [∀ i, MeasurableSpace (Z i)]
  {C : Type*} [Fintype C]
  (checks : C → LocalCheck (fun i ↦ X i × Z i))
  (κ : ∀ i, Kernel (X i) (Z i)) [∀ i, IsFiniteKernel (κ i)]

def auxiliaryChecks (x : ∀ i, X i) (c : C) : LocalCheck Z where
  support := (checks c).support
  nonempty := (checks c).nonempty
  arity := (checks c).arity
  pass := fun z ↦ (checks c).pass (fun i ↦ (x i, z i))
  measurable_pass := (by fun_prop : Measurable (fun z : ∀ i, Z i ↦ fun i ↦ (x i,z i)))
    (checks c).measurable_pass
  depends := by
    intro z w h
    apply (checks c).depends
    intro i hi
    exact Prod.ext rfl (h i hi)

omit [DecidableEq ι] [Fintype C] in
lemma auxiliary_checkWeight (s : Finset ι) (x : ∀ i, X i) (z : ∀ i, Z i) :
    checkWeight (auxiliaryChecks checks x) s z =
      checkWeight checks s (fun i ↦ (x i,z i)) := rfl

def auxiliaryDensity (s : Finset ι) (x : ∀ i, X i) (z : ∀ i, Z i) : ℝ≥0∞ :=
  checkNormalizer (auxiliaryChecks checks x) (fun i ↦ κ i (x i)) s z

lemma auxiliaryDensity_delete_le {s t : Finset ι} (hst : Disjoint s t)
    (x : ∀ i, X i) (z : ∀ i, Z i) :
    auxiliaryDensity checks κ (s ∪ t) x z ≤
      auxiliaryDensity checks κ s x z * ∏ i ∈ t, κ i (x i) Set.univ :=
  checkNormalizer_delete_le (auxiliaryChecks checks x) hst z

omit [Fintype C] [∀ i, IsFiniteKernel (κ i)] in
lemma auxiliaryDensity_depends (s : Finset ι) (z : ∀ i, Z i) :
    DependsOn (fun x ↦ auxiliaryDensity checks κ s x z) (s : Set ι) := by
  intro x y hxy
  have hμ : (fun i : s ↦ κ i (x i)) = (fun i : s ↦ κ i (y i)) := by
    funext i
    rw [hxy i i.property]
  change (∫⁻ u, checkWeight (auxiliaryChecks checks x) s
    (Function.updateFinset z s u) ∂Measure.pi (fun i : s ↦ κ i (x i))) = _
  rw [hμ]
  apply lintegral_congr
  intro u
  simp only [auxiliary_checkWeight]
  apply checkWeight_depends
  intro i hi
  exact Prod.ext (hxy i hi) rfl

lemma measurable_auxiliaryDensity (s : Finset ι) (z : ∀ i, Z i) :
    Measurable (fun x ↦ auxiliaryDensity checks κ s x z) := by
  let κ' (i : s) : Kernel (∀ j, X j) (Z i) :=
    (κ i).comap (fun x ↦ x i) (measurable_pi_apply (i : ι))
  let η := finiteKernelPi κ'
  have hm : Measurable (fun p : (∀ i, X i) × (∀ i : s, Z i) ↦
      checkWeight checks s (fun i ↦ (p.1 i, Function.updateFinset z s p.2 i))) := by
    apply (measurable_checkWeight checks s).comp
    exact Measurable.of_eval fun i ↦
      ((measurable_pi_apply i).comp measurable_fst).prodMk
        ((measurable_pi_apply i).comp ((measurable_updateFinset (x := z) (s := s)).comp
          measurable_snd))
  have h := hm.lintegral_kernel_prod_right' (κ := η)
  simpa only [η, finiteKernelPi_apply, κ', Kernel.comap_apply,
    auxiliaryDensity, checkNormalizer, lmarginal, auxiliary_checkWeight] using h

lemma auxiliaryDensity_integral (μ : ∀ i, Measure (X i)) [∀ i, IsFiniteMeasure (μ i)]
    (s : Finset ι) (x : ∀ i, X i) (z : ∀ i, Z i) :
    lmarginal μ s (fun y ↦ auxiliaryDensity checks κ s y z) x =
      checkNormalizer checks (fun i ↦ (μ i).compProd (κ i)) s (fun i ↦ (x i,z i)) := by
  let f (p : ∀ i : s, X i × Z i) :=
    checkWeight checks s (Function.updateFinset (fun i ↦ (x i,z i)) s p)
  have hf : Measurable f := (measurable_checkWeight checks s).comp measurable_updateFinset
  have hh := lintegral_pi_compProd (fun i : s ↦ κ i) (fun i : s ↦ μ i) hf
  change (∫⁻ y, auxiliaryDensity checks κ s (Function.updateFinset x s y) z
    ∂Measure.pi (fun i : s ↦ μ i)) = (∫⁻ p, f p ∂Measure.pi (fun i : s ↦ (μ i).compProd (κ i)))
  rw [hh]
  apply lintegral_congr
  intro y
  change (∫⁻ u, checkWeight (auxiliaryChecks checks (Function.updateFinset x s y)) s
    (Function.updateFinset z s u)
    ∂Measure.pi (fun i : s ↦ κ i (Function.updateFinset x s y i))) = _
  have hμ : (fun i : s ↦ κ i (Function.updateFinset x s y i)) = (fun i : s ↦ κ i (y i)) := by
    funext i
    simp [Function.updateFinset, i.property]
  rw [hμ]
  apply lintegral_congr
  intro u
  rw [auxiliary_checkWeight]
  apply checkWeight_depends
  intro i hi
  simp [Function.updateFinset, hi]

end AuxiliaryMarginals

section OverlapProducts
variable {ι : Type*} [DecidableEq ι] {X : ι → Type*}
  [∀ i, MeasurableSpace (X i)]

def densityProduct (s : Finset ι) (g : ∀ i, X i → ℝ≥0∞) (x : ∀ i, X i) : ℝ≥0∞ :=
  ∏ i ∈ s, g i (x i)

omit [DecidableEq ι] in
lemma measurable_densityProduct (s : Finset ι) (g : ∀ i, X i → ℝ≥0∞)
    (hg : ∀ i, Measurable (g i)) : Measurable (densityProduct s g) :=
  Finset.measurable_prod s fun i _ ↦ (hg i).comp (measurable_pi_apply i)

omit [DecidableEq ι] [∀ i, MeasurableSpace (X i)] in
lemma densityProduct_depends (s : Finset ι) (g : ∀ i, X i → ℝ≥0∞) :
    DependsOn (densityProduct s g) (s : Set ι) := by
  intro x y hxy
  exact Finset.prod_congr rfl fun i hi ↦ congrArg (g i) (hxy i hi)

omit [∀ i, MeasurableSpace (X i)] in
lemma densityProduct_union (s t : Finset ι) (g h : ∀ i, X i → ℝ≥0∞)
    (x : ∀ i, X i) :
    densityProduct s g x * densityProduct t h x =
      ∏ i ∈ s ∪ t, (if i ∈ s then g i (x i) else 1) *
        (if i ∈ t then h i (x i) else 1) := by
  rw [Finset.prod_mul_distrib]
  congr 1
  · rw [Finset.prod_ite, Finset.prod_const_one, mul_one]
    simp only [Finset.filter_mem_eq_inter, Finset.union_inter_cancel_left, densityProduct]
  · rw [Finset.prod_ite, Finset.prod_const_one, mul_one]
    simp only [Finset.filter_mem_eq_inter, Finset.union_inter_cancel_right, densityProduct]

lemma lmarginal_overlap_products {μ : ∀ i, Measure (X i)}
    [∀ i, IsProbabilityMeasure (μ i)] (s t : Finset ι)
    (g h : ∀ i, X i → ℝ≥0∞) (hg : ∀ i, Measurable (g i))
    (hh : ∀ i, Measurable (h i)) {G : ℝ≥0∞}
    (hgb : ∀ i x, g i x ≤ G)
    (hgm : ∀ i, ∫⁻ x, g i x ∂μ i = 1)
    (hhm : ∀ i, ∫⁻ x, h i x ∂μ i = 1) (x : ∀ i, X i) :
    lmarginal μ (s ∪ t) (fun y ↦ densityProduct s g y * densityProduct t h y) x ≤
      G ^ (s ∩ t).card := by
  let f (i : ι) (y : X i) :=
    (if i ∈ s then g i y else 1) * (if i ∈ t then h i y else 1)
  have hf : ∀ i, Measurable (f i) := by
    intro i
    dsimp [f]
    split_ifs <;> fun_prop
  rw [show (fun y ↦ densityProduct s g y * densityProduct t h y) =
      (fun y ↦ ∏ i ∈ s ∪ t, f i (y i)) from funext (densityProduct_union s t g h)]
  rw [lmarginal_prod_coordinates f hf]
  have hi (i : ι) : (∫⁻ y, f i y ∂μ i) ≤ if i ∈ s ∩ t then G else 1 := by
    by_cases his : i ∈ s <;> by_cases hit : i ∈ t
    · simp only [f, his, hit, ite_true, Finset.mem_inter, and_self]
      calc
        (∫⁻ y, g i y * h i y ∂μ i) ≤ ∫⁻ y, G * h i y ∂μ i :=
          lintegral_mono fun y ↦ mul_le_mul_left (hgb i y) _
        _ = G := by rw [lintegral_const_mul _ (hh i), hhm, mul_one]
    all_goals simp [f, his, hit, hgm, hhm]
  calc
    (∏ i ∈ s ∪ t, ∫⁻ y, f i y ∂μ i) ≤
        ∏ i ∈ s ∪ t, if i ∈ s ∩ t then G else 1 :=
      Finset.prod_le_prod fun i _ ↦ hi i
    _ = G ^ (s ∩ t).card := by
      rw [Finset.prod_ite, Finset.prod_const_one, mul_one]
      have heq : (s ∪ t).filter (fun i ↦ i ∈ s ∩ t) = s ∩ t := by
        ext i
        simp only [Finset.mem_filter, Finset.mem_union, Finset.mem_inter]
        tauto
      rw [heq, Finset.prod_const]

omit [∀ i, MeasurableSpace (X i)] in
lemma dependsOn_mul_union {s t : Finset ι} {f g : (∀ i, X i) → ℝ≥0∞}
    (hf : DependsOn f (s : Set ι)) (hg : DependsOn g (t : Set ι)) :
    DependsOn (fun x ↦ f x * g x) ((s ∪ t : Finset ι) : Set ι) := by
  intro x y hxy
  change f x * g x = f y * g y
  rw [hf (fun i hi ↦ hxy i (Finset.mem_union_left t hi)),
    hg (fun i hi ↦ hxy i (Finset.mem_union_right s hi))]

end OverlapProducts

section KernelOverlap
variable {ι : Type*} [DecidableEq ι] {X Z W : ι → Type*}
  [∀ i, MeasurableSpace (X i)] [∀ i, MeasurableSpace (Z i)]
  [∀ i, MeasurableSpace (W i)]
  {C D : Type*} [Fintype C] [Fintype D]
  (checks : C → LocalCheck (fun i ↦ X i × Z i))
  (other : D → LocalCheck (fun i ↦ X i × W i))
  (κ : ∀ i, Kernel (X i) (Z i)) [∀ i, IsFiniteKernel (κ i)]
  (η : ∀ i, Kernel (X i) (W i)) [∀ i, IsFiniteKernel (η i)]

lemma auxiliaryDensity_overlap_bound
    {μ : ∀ i, Measure (X i)} [∀ i, IsProbabilityMeasure (μ i)]
    (fs ft cs ct : Finset ι)
    (hff : Disjoint fs ft) (hfn : Disjoint (fs ∪ ft) (cs ∪ ct))
    {G : ℝ≥0∞}
    (hκb : ∀ i x, κ i x Set.univ ≤ G)
    (hκm : ∀ i, ∫⁻ x, κ i x Set.univ ∂μ i = 1)
    (hηm : ∀ i, ∫⁻ x, η i x Set.univ ∂μ i = 1)
    (x : ∀ i, X i) (z : ∀ i, Z i) (w : ∀ i, W i) :
    lmarginal μ ((fs ∪ ft) ∪ (cs ∪ ct))
      (fun y ↦ auxiliaryDensity checks κ (fs ∪ cs) y z *
        auxiliaryDensity other η (ft ∪ ct) y w) x ≤
      (checkNormalizer checks (fun i ↦ (μ i).compProd (κ i)) fs (fun i ↦ (x i,z i)) *
       checkNormalizer other (fun i ↦ (μ i).compProd (η i)) ft (fun i ↦ (x i,w i))) *
       G ^ (cs ∩ ct).card := by
  let g (i : ι) (y : X i) := κ i y Set.univ
  let h (i : ι) (y : X i) := η i y Set.univ
  have hg : ∀ i, Measurable (g i) := fun i ↦ (κ i).measurable_coe MeasurableSet.univ
  have hh : ∀ i, Measurable (h i) := fun i ↦ (η i).measurable_coe MeasurableSet.univ
  have hfs : Disjoint fs cs := hfn.mono Finset.subset_union_left Finset.subset_union_left
  have hft : Disjoint ft ct := hfn.mono Finset.subset_union_right Finset.subset_union_right
  let F (y : ∀ i, X i) := auxiliaryDensity checks κ fs y z
  let H (y : ∀ i, X i) := auxiliaryDensity other η ft y w
  let P (y : ∀ i, X i) := densityProduct cs g y * densityProduct ct h y
  have hF : Measurable F := measurable_auxiliaryDensity checks κ fs z
  have hH : Measurable H := measurable_auxiliaryDensity other η ft w
  have hP : Measurable P := (measurable_densityProduct cs g hg).mul
    (measurable_densityProduct ct h hh)
  have hFd : DependsOn F (fs : Set ι) := auxiliaryDensity_depends checks κ fs z
  have hHd : DependsOn H (ft : Set ι) := auxiliaryDensity_depends other η ft w
  have hPd : DependsOn P ((cs ∪ ct : Finset ι) : Set ι) :=
    dependsOn_mul_union (densityProduct_depends cs g) (densityProduct_depends ct h)
  calc
    _ ≤ lmarginal μ ((fs ∪ ft) ∪ (cs ∪ ct)) (fun y ↦ (F y * H y) * P y) x := by
      apply lmarginal_mono _ x
      intro y
      calc
        _ ≤ (F y * densityProduct cs g y) * (H y * densityProduct ct h y) :=
          mul_le_mul' (auxiliaryDensity_delete_le checks κ hfs y z)
            (auxiliaryDensity_delete_le other η hft y w)
        _ = _ := by dsimp [P]; ac_rfl
    _ = (lmarginal μ fs F x * lmarginal μ ft H x) * lmarginal μ (cs ∪ ct) P x := by
      rw [lmarginal_mul_disjoint (f := fun y ↦ F y * H y) (g := P) hfn
        (hF.mul hH) hP (dependsOn_mul_union hFd hHd) hPd,
        lmarginal_mul_disjoint (f := F) (g := H) hff hF hH hFd hHd]
    _ ≤ (lmarginal μ fs F x * lmarginal μ ft H x) * G ^ (cs ∩ ct).card :=
      mul_le_mul_right (lmarginal_overlap_products cs ct g h hg hh hκb hκm hηm x) _
    _ = _ := by rw [auxiliaryDensity_integral, auxiliaryDensity_integral]

end KernelOverlap

section ConditionalNormalizers
variable {ι : Type*} [DecidableEq ι] {X : ι → Type*}
  [∀ i, MeasurableSpace (X i)] {C : Type*} [Fintype C]
  (checks : C → LocalCheck X)

def UniformInsertionOn (μ : ∀ i, Measure (X i)) (a : ℝ≥0∞) (r : Finset ι) : Prop :=
  ∀ i ∈ r, ∀ (s : Finset ι), i ∉ s → ∀ x : ∀ j, X j,
    a ≤ ∫⁻ y, (insertionEvent checks s i).indicator (fun _ ↦ (1 : ℝ≥0∞))
      (Function.update x i y) ∂μ i

omit [Fintype C] in
lemma insertion_integral_lower_on {μ : ∀ i, Measure (X i)} {a : ℝ≥0∞}
    {r : Finset ι} (hcompat : UniformInsertionOn checks μ a r)
    {s : Finset ι} {i : ι} (hir : i ∈ r) (hi : i ∉ s) (x : ∀ i, X i) :
    a * checkWeight checks s x ≤
      ∫⁻ y, checkWeight checks (insert i s) (Function.update x i y) ∂μ i := by
  classical
  by_cases hx : x ∈ retainedEvent checks s
  · have heq : (fun y ↦ checkWeight checks (insert i s) (Function.update x i y)) =
        fun y ↦ (insertionEvent checks s i).indicator (fun _ ↦ (1 : ℝ≥0∞))
          (Function.update x i y) := by
      funext y
      have hu := (retainedEvent_update checks hi x y).2 hx
      simp [checkWeight, retainedEvent_insert, Set.indicator_apply, hu]
    rw [heq]
    simpa [checkWeight, hx] using hcompat i hir s hi x
  · simp [checkWeight, hx]

def partialNormalizer (μ : ∀ i, Measure (X i)) (s o : Finset ι)
    (x : ∀ i, X i) : ℝ≥0∞ := lmarginal μ s (checkWeight checks (s ∪ o)) x

lemma partialNormalizer_insert_lower {μ : ∀ i, Measure (X i)}
    [∀ i, SigmaFinite (μ i)] {a : ℝ≥0∞} {r : Finset ι}
    (hcompat : UniformInsertionOn checks μ a r) {s o : Finset ι} {i : ι}
    (hir : i ∈ r) (hi : i ∉ s ∪ o) (x : ∀ i, X i) :
    a * partialNormalizer checks μ s o x ≤
      partialNormalizer checks μ (insert i s) o x := by
  have his : i ∉ s := fun h ↦ hi (Finset.mem_union_left o h)
  rw [partialNormalizer, partialNormalizer, Finset.insert_union,
    lmarginal_insert' _ (measurable_checkWeight checks _) his]
  calc
    a * lmarginal μ s (checkWeight checks (s ∪ o)) x =
        lmarginal μ s (fun x ↦ a * checkWeight checks (s ∪ o) x) x := by
      dsimp [lmarginal]
      exact (lintegral_const_mul a ((measurable_checkWeight checks (s ∪ o)).comp
        (measurable_updateFinset (x := x) (s := s)))).symm
    _ ≤ _ := lmarginal_mono (insertion_integral_lower_on checks hcompat hir hi) x

lemma partialNormalizer_union_lower {μ : ∀ i, Measure (X i)}
    [∀ i, SigmaFinite (μ i)] {a : ℝ≥0∞} {r : Finset ι}
    (hcompat : UniformInsertionOn checks μ a r)
    (s t o : Finset ι) (htr : t ⊆ r) (hto : Disjoint (s ∪ o) t)
    (x : ∀ i, X i) :
    a ^ t.card * partialNormalizer checks μ s o x ≤
      partialNormalizer checks μ (s ∪ t) o x := by
  induction t using Finset.induction_on with
  | empty => simp
  | @insert i t hit ih =>
    have hino : i ∉ s ∪ o := (Finset.disjoint_insert_right.mp hto).1
    have hto' := (Finset.disjoint_insert_right.mp hto).2
    have hiu : i ∉ (s ∪ t) ∪ o := by
      simp only [Finset.mem_union, not_or] at hino ⊢
      exact ⟨⟨hino.1, hit⟩, hino.2⟩
    calc
      a ^ (insert i t).card * partialNormalizer checks μ s o x =
          a * (a ^ t.card * partialNormalizer checks μ s o x) := by
        rw [Finset.card_insert_of_notMem hit, pow_succ]
        ac_rfl
      _ ≤ a * partialNormalizer checks μ (s ∪ t) o x :=
        mul_le_mul_right (ih ((Finset.subset_insert _ _).trans htr) hto') a
      _ ≤ partialNormalizer checks μ (insert i (s ∪ t)) o x :=
        partialNormalizer_insert_lower checks hcompat (htr (Finset.mem_insert_self _ _)) hiu x
      _ = _ := by rw [Finset.union_insert]

lemma partialNormalizer_pos {μ : ∀ i, Measure (X i)} [∀ i, SigmaFinite (μ i)]
    {a : ℝ≥0∞} (ha : 0 < a) {s o : Finset ι}
    (hcompat : UniformInsertionOn checks μ a s) (hso : Disjoint s o)
    (x : ∀ i, X i) (hx : x ∈ retainedEvent checks o) :
    0 < partialNormalizer checks μ s o x := by
  have h := partialNormalizer_union_lower checks hcompat ∅ s o (Finset.Subset.refl s)
    (by simpa using hso.symm) x
  simp only [partialNormalizer, Finset.empty_union, lmarginal_empty, checkWeight,
    Set.indicator_of_mem hx, mul_one] at h
  exact lt_of_lt_of_le (by positivity) h

lemma partialNormalizer_far_eq {μ : ∀ i, Measure (X i)} [∀ i, SigmaFinite (μ i)]
    {s o : Finset ι} (hso : Disjoint s o) (hsep : SeparatedChecks checks s o)
    (x : ∀ i, X i) :
    partialNormalizer checks μ s o x = checkNormalizer checks μ s x * checkWeight checks o x := by
  rw [partialNormalizer]
  have heq : checkWeight checks (s ∪ o) = fun y ↦ checkWeight checks s y * checkWeight checks o y :=
    funext (checkWeight_union checks hsep)
  rw [heq]
  change (∫⁻ y, checkWeight checks s (Function.updateFinset x s y) *
    checkWeight checks o (Function.updateFinset x s y) ∂Measure.pi (fun i : s ↦ μ i)) = _
  have hu : ∀ y : ∀ i : s, X i,
      checkWeight checks o (Function.updateFinset x s y) = checkWeight checks o x := by
    intro y
    apply checkWeight_depends
    intro i hi
    have his : i ∉ s := Finset.disjoint_right.mp hso hi
    simp [Function.updateFinset, his]
  simp_rw [hu]
  exact lintegral_mul_const _ ((measurable_checkWeight checks s).comp
    (measurable_updateFinset (x := x) (s := s)))

lemma partialNormalizer_le_far {μ : ∀ i, Measure (X i)} [∀ i, IsProbabilityMeasure (μ i)]
    {s t o : Finset ι} (hst : Disjoint s t) (x : ∀ i, X i) :
    partialNormalizer checks μ (s ∪ t) o x ≤ checkNormalizer checks μ s x := by
  calc
    _ ≤ lmarginal μ (s ∪ t) (checkWeight checks s) x :=
      lmarginal_mono (checkWeight_antitone checks
        (Finset.subset_union_left.trans Finset.subset_union_left)) x
    _ = _ := by
      rw [lmarginal_union' μ _ (measurable_checkWeight checks s) hst]
      change (∫⁻ y, checkNormalizer checks μ s (Function.updateFinset x t y)
        ∂Measure.pi (fun i : t ↦ μ i)) = _
      simp_rw [checkNormalizer_const checks s _ x]
      simp

end ConditionalNormalizers

variable {ι : Type*} [DecidableEq ι] {X Z : ι → Type*}
  [∀ i, MeasurableSpace (X i)] [∀ i, MeasurableSpace (Z i)]
  {C : Type*} [Fintype C]
  (checks : C → LocalCheck (fun i ↦ X i × Z i))
  (κ : ∀ i, Kernel (X i) (Z i)) [∀ i, IsFiniteKernel (κ i)]

def conditionalDensity (s o : Finset ι) (x : ∀ i, X i) (z : ∀ i, Z i) : ℝ≥0∞ :=
  lmarginal (fun i ↦ κ i (x i)) s
    (fun v ↦ checkWeight checks (s ∪ o) (fun i ↦ (x i,v i))) z

omit [Fintype C] [∀ i, IsFiniteKernel (κ i)] in
lemma conditionalDensity_le_auxiliaryDensity (s o : Finset ι)
    (x : ∀ i, X i) (z : ∀ i, Z i) :
    conditionalDensity checks κ s o x z ≤ auxiliaryDensity checks κ s x z :=
  lmarginal_mono (fun v ↦ checkWeight_antitone checks Finset.subset_union_left
    (fun i ↦ (x i,v i))) z

lemma measurable_conditionalDensity (s o : Finset ι) (z : ∀ i, Z i) :
    Measurable (fun x ↦ conditionalDensity checks κ s o x z) := by
  let κ' (i : s) : Kernel (∀ j, X j) (Z i) :=
    (κ i).comap (fun x ↦ x i) (measurable_pi_apply (i : ι))
  let η := finiteKernelPi κ'
  have hm : Measurable (fun p : (∀ i, X i) × (∀ i : s, Z i) ↦
      checkWeight checks (s ∪ o) (fun i ↦ (p.1 i, Function.updateFinset z s p.2 i))) := by
    apply (measurable_checkWeight checks (s ∪ o)).comp
    exact Measurable.of_eval fun i ↦
      ((measurable_pi_apply i).comp measurable_fst).prodMk
        ((measurable_pi_apply i).comp ((measurable_updateFinset (x := z) (s := s)).comp
          measurable_snd))
  have h := hm.lintegral_kernel_prod_right' (κ := η)
  simpa only [η, finiteKernelPi_apply, κ', Kernel.comap_apply,
    conditionalDensity, lmarginal] using h

lemma conditionalDensity_integral (μ : ∀ i, Measure (X i)) [∀ i, IsFiniteMeasure (μ i)]
    (s o : Finset ι) (x : ∀ i, X i) (z : ∀ i, Z i) :
    lmarginal μ s (fun y ↦ conditionalDensity checks κ s o y z) x =
      partialNormalizer checks (fun i ↦ (μ i).compProd (κ i)) s o (fun i ↦ (x i,z i)) := by
  let f (p : ∀ i : s, X i × Z i) :=
    checkWeight checks (s ∪ o) (Function.updateFinset (fun i ↦ (x i,z i)) s p)
  have hf : Measurable f := (measurable_checkWeight checks (s ∪ o)).comp measurable_updateFinset
  have hh := lintegral_pi_compProd (fun i : s ↦ κ i) (fun i : s ↦ μ i) hf
  change (∫⁻ y, conditionalDensity checks κ s o (Function.updateFinset x s y) z
    ∂Measure.pi (fun i : s ↦ μ i)) = (∫⁻ p, f p ∂Measure.pi (fun i : s ↦ (μ i).compProd (κ i)))
  rw [hh]
  apply lintegral_congr
  intro y
  change (∫⁻ u, checkWeight checks (s ∪ o)
    (fun i ↦ (Function.updateFinset x s y i, Function.updateFinset z s u i))
    ∂Measure.pi (fun i : s ↦ κ i (Function.updateFinset x s y i))) = _
  have hμ : (fun i : s ↦ κ i (Function.updateFinset x s y i)) = (fun i : s ↦ κ i (y i)) := by
    funext i
    simp [Function.updateFinset, i.property]
  rw [hμ]
  apply lintegral_congr
  intro u
  apply congrArg (checkWeight checks (s ∪ o))
  funext i
  by_cases hi : i ∈ s <;> simp [Function.updateFinset, hi]

end HardSphere.Comparison
end

end OAI