/-- A finite kernel which satisfies the disintegration property is almost everywhere equal to the
disintegration kernel. -/
theorem eq_condKernel_of_measure_eq_compProd (κ : kernel α Ω) [IsFiniteKernel κ]
    (hκ : ρ = ρ.fst ⊗ₘ κ) :
    ∀ᵐ x ∂ρ.fst, κ x = ρ.condKernel x := by
-- The idea is to transporting the question to `ℝ` from `Ω` using `exists_measurableEmbedding_real`
-- and then constructing a measure on `α × ℝ` using the obtained measurable embedding
  obtain ⟨f, hf⟩ := exists_measurableEmbedding_real Ω
  set ρ' : Measure (α × ℝ) := ρ.map (Prod.map id f) with hρ'def
  have hρ' : ρ'.fst = ρ.fst
  · ext s hs
    rw [hρ'def, Measure.fst_apply, Measure.fst_apply, Measure.map_apply]
    exacts [rfl, Measurable.prod measurable_fst <| hf.measurable.comp measurable_snd,
      measurable_fst hs, hs, hs]
  have hρ'' : ∀ᵐ x ∂ρ'.fst, kernel.map κ f hf.measurable x = ρ'.condKernel x
  · refine' eq_condKernel_of_measure_eq_compProd_real ρ' (kernel.map κ f hf.measurable) _
    ext s hs
    simp only [Measure.map_apply (measurable_id.prod_map hf.measurable) hs]
    conv_lhs => congr; rw [hκ]
    rw [Measure.compProd_apply hs, Measure.compProd_apply
      (measurable_id.prod_map hf.measurable hs), (_ : (ρ.map (Prod.map id f)).fst = ρ.fst)]
    · congr
      ext x
      simp only [Set.mem_preimage, Prod_map, id_eq, kernel.prodMkLeft_apply, kernel.map_apply]
      rw [Measure.map_apply hf.measurable]
      · rfl
      · exact measurable_prod_mk_left hs
    · rw [Measure.fst_map_prod_mk]
      · simp only [Prod_map, id_eq]; rfl
      · exact (hf.measurable.comp measurable_snd)
  rw [hρ'] at hρ''
  suffices : ∀ᵐ x ∂ρ.fst, ∀ s, MeasurableSet s →
    ((ρ.map (Prod.map id f)).condKernel x) s = (ρ.condKernel x) (f ⁻¹' s)
  · filter_upwards [hρ'', this] with x hx h
    rw [kernel.map_apply] at hx
    ext s hs
    rw [← Set.preimage_image_eq s hf.injective,
      ← Measure.map_apply hf.measurable <| hf.measurableSet_image.2 hs, hx,
      h _ <| hf.measurableSet_image.2 hs]
  have hprod : (ρ.map (Prod.map id f)).fst = ρ.fst
  · ext s hs
    rw [Measure.fst_apply hs,
      Measure.map_apply (measurable_id.prod_map hf.measurable) (measurable_fst hs),
      ← Set.preimage_comp, Measure.fst_apply hs]
    rfl
  suffices : ρ.map (Prod.map id f) =
    ((ρ.map (Prod.map id f)).fst ⊗ₘ (kernel.map (Measure.condKernel ρ) f hf.measurable))
  · have heq := eq_condKernel_of_measure_eq_compProd_real _ _ this
    rw [hprod] at heq
    filter_upwards [heq] with x hx s hs
    rw [← hx, kernel.map_apply, Measure.map_apply hf.measurable hs]
  ext s hs
  simp only [hprod, Measure.compProd_apply hs, kernel.map_apply _ hf.measurable]
  rw [Measure.map_apply (measurable_id.prod_map hf.measurable) hs, ← lintegral_condKernel_mem]
  · simp only [mem_preimage, Prod_map, id_eq]
    

Proof state:
case this.h
α : Type u_1
mα : MeasurableSpace α
Ω : Type u_2
inst✝⁴ : MeasurableSpace Ω
inst✝³ : StandardBorelSpace Ω
inst✝² : Nonempty Ω
ρ : Measure (α × Ω)
inst✝¹ : IsFiniteMeasure ρ
κ : ↥(kernel α Ω)
inst✝ : IsFiniteKernel κ
hκ : ρ = Measure.fst ρ ⊗ₘ κ
f : Ω → ℝ
hf : MeasurableEmbedding f
ρ' : Measure (α × ℝ) := Measure.map (Prod.map id f) ρ
hρ'def : ρ' = Measure.map (Prod.map id f) ρ
hρ' : Measure.fst ρ' = Measure.fst ρ
hρ'' : ∀ᵐ (x : α) ∂Measure.fst ρ, (kernel.map κ f (_ : Measurable f)) x = (Measure.condKernel ρ') x
hprod : Measure.fst (Measure.map (Prod.map id f) ρ) = Measure.fst ρ
s : Set (α × ℝ)
hs : MeasurableSet s
⊢ ∫⁻ (a : α), ↑↑((Measure.condKernel ρ) a) {x | (a, f x) ∈ s} ∂Measure.fst ρ =
    ∫⁻ (a : α), ↑↑(Measure.map f ((Measure.condKernel ρ) a)) (Prod.mk a ⁻¹' s) ∂Measure.fst ρ

Next tactic:
congr with a