File: Mathlib/Probability/Kernel/CondDistrib.lean

full_name: ProbabilityTheory.definition._@.Mathlib.Probability.Kernel.CondDistrib._hyg.49
code: /-- **Regular conditional probability distribution**: kernel associated with the conditional
expectation of `Y` given `X`.
For almost all `a`, `condDistrib Y X μ` evaluated at `X a` and a measurable set `s` is equal to
the conditional expectation `μ⟦Y ⁻¹' s | mβ.comap X⟧ a`. It also satisfies the equality
`μ[(fun a => f (X a, Y a)) | mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂(condDistrib Y X μ (X a))`
for all integrable functions `f`. -/
noncomputable irreducible_def condDistrib {_ : MeasurableSpace α} [MeasurableSpace β] (Y : α → Ω)
    (X : α → β) (μ : Measure α) [IsFiniteMeasure μ] : Kernel β Ω 
goal: {x : MeasurableSpace α} →
  [inst : MeasurableSpace β] →
    (α → Ω) →
      (α → β) →
        (μ : MeasureTheory.Measure α) → [inst_1 : MeasureTheory.IsFiniteMeasure μ] → ProbabilityTheory.Kernel β Ω

full_name: ProbabilityTheory.condDistrib
code: /-- **Regular conditional probability distribution**: kernel associated with the conditional
expectation of `Y` given `X`.
For almost all `a`, `condDistrib Y X μ` evaluated at `X a` and a measurable set `s` is equal to
the conditional expectation `μ⟦Y ⁻¹' s | mβ.comap X⟧ a`. It also satisfies the equality
`μ[(fun a => f (X a, Y a)) | mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂(condDistrib Y X μ (X a))`
for all integrable functions `f`. -/
noncomputable irreducible_def condDistrib {_ : MeasurableSpace α} [MeasurableSpace β] (Y : α → Ω)
    (X : α → β) (μ : Measure α) [IsFiniteMeasure μ] : Kernel β Ω 
goal: {x : MeasurableSpace α} →
  [inst : MeasurableSpace β] →
    (α → Ω) →
      (α → β) →
        (μ : MeasureTheory.Measure α) → [inst_1 : MeasureTheory.IsFiniteMeasure μ] → ProbabilityTheory.Kernel β Ω

full_name: ProbabilityTheory.condDistrib_def
code: /-- **Regular conditional probability distribution**: kernel associated with the conditional
expectation of `Y` given `X`.
For almost all `a`, `condDistrib Y X μ` evaluated at `X a` and a measurable set `s` is equal to
the conditional expectation `μ⟦Y ⁻¹' s | mβ.comap X⟧ a`. It also satisfies the equality
`μ[(fun a => f (X a, Y a)) | mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂(condDistrib Y X μ (X a))`
for all integrable functions `f`. -/
noncomputable irreducible_def condDistrib {_ : MeasurableSpace α} [MeasurableSpace β] (Y : α → Ω)
    (X : α → β) (μ : Measure α) [IsFiniteMeasure μ] : Kernel β Ω 
goal: ∀ {x : MeasurableSpace α} [inst : MeasurableSpace β] (Y : α → Ω) (X : α → β) (μ : MeasureTheory.Measure α)
  [inst_1 : MeasureTheory.IsFiniteMeasure μ],
  ProbabilityTheory.condDistrib Y X μ = (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ).condKernel

full_name: ProbabilityTheory.wrapped._@.Mathlib.Probability.Kernel.CondDistrib._hyg.49
code: /-- **Regular conditional probability distribution**: kernel associated with the conditional
expectation of `Y` given `X`.
For almost all `a`, `condDistrib Y X μ` evaluated at `X a` and a measurable set `s` is equal to
the conditional expectation `μ⟦Y ⁻¹' s | mβ.comap X⟧ a`. It also satisfies the equality
`μ[(fun a => f (X a, Y a)) | mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂(condDistrib Y X μ (X a))`
for all integrable functions `f`. -/
noncomputable irreducible_def condDistrib {_ : MeasurableSpace α} [MeasurableSpace β] (Y : α → Ω)
    (X : α → β) (μ : Measure α) [IsFiniteMeasure μ] : Kernel β Ω 
goal: Subtype (Eq @ProbabilityTheory.definition✝)

full_name: ProbabilityTheory.instIsMarkovKernelCondDistrib
code: instance [MeasurableSpace β] : IsMarkovKernel (condDistrib Y X μ) 
goal: ProbabilityTheory.IsMarkovKernel (ProbabilityTheory.condDistrib Y X μ)

full_name: ProbabilityTheory.condDistrib_apply_of_ne_zero
code: /-- If the singleton `{x}` has non-zero mass for `μ.map X`, then for all `s : Set Ω`,
`condDistrib Y X μ x s = (μ.map X {x})⁻¹ * μ.map (fun a => (X a, Y a)) ({x} ×ˢ s)` . -/
lemma condDistrib_apply_of_ne_zero [MeasurableSingletonClass β]
    (hY : Measurable Y) (x : β) (hX : μ.map X {x} ≠ 0) (s : Set Ω) :
    condDistrib Y X μ x s = (μ.map X {x})⁻¹ * μ.map (fun a => (X a, Y a)) ({x} ×ˢ s) 
goal: ((ProbabilityTheory.condDistrib Y X μ) x) s =
  ((MeasureTheory.Measure.map X μ) {x})⁻¹ * (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ) ({x} ×ˢ s)

full_name: ProbabilityTheory.measurable_condDistrib
code: theorem measurable_condDistrib (hs : MeasurableSet s) :
    Measurable[mβ.comap X] fun a => condDistrib Y X μ (X a) s 
goal: Measurable fun a => ((ProbabilityTheory.condDistrib Y X μ) (X a)) s

full_name: MeasureTheory.AEStronglyMeasurable.ae_integrable_condDistrib_map_iff
code: theorem _root_.MeasureTheory.AEStronglyMeasurable.ae_integrable_condDistrib_map_iff
    (hY : AEMeasurable Y μ) (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a))) :
    (∀ᵐ a ∂μ.map X, Integrable (fun ω => f (a, ω)) (condDistrib Y X μ a)) ∧
      Integrable (fun a => ∫ ω, ‖f (a, ω)‖ ∂condDistrib Y X μ a) (μ.map X) ↔
    Integrable f (μ.map fun a => (X a, Y a)) 
goal: (∀ᵐ (a : β) ∂MeasureTheory.Measure.map X μ,
      MeasureTheory.Integrable (fun ω => f (a, ω)) ((ProbabilityTheory.condDistrib Y X μ) a)) ∧
    MeasureTheory.Integrable (fun a => ∫ (ω : Ω), ‖f (a, ω)‖ ∂(ProbabilityTheory.condDistrib Y X μ) a)
      (MeasureTheory.Measure.map X μ) ↔
  MeasureTheory.Integrable f (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ)

full_name: MeasureTheory.AEStronglyMeasurable.integral_condDistrib_map
code: theorem _root_.MeasureTheory.AEStronglyMeasurable.integral_condDistrib_map
    (hY : AEMeasurable Y μ) (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a))) :
    AEStronglyMeasurable (fun x => ∫ y, f (x, y) ∂condDistrib Y X μ x) (μ.map X) 
goal: MeasureTheory.AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂(ProbabilityTheory.condDistrib Y X μ) x)
  (MeasureTheory.Measure.map X μ)

full_name: MeasureTheory.AEStronglyMeasurable.integral_condDistrib
code: theorem _root_.MeasureTheory.AEStronglyMeasurable.integral_condDistrib (hX : AEMeasurable X μ)
    (hY : AEMeasurable Y μ) (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a))) :
    AEStronglyMeasurable (fun a => ∫ y, f (X a, y) ∂condDistrib Y X μ (X a)) μ 
goal: MeasureTheory.AEStronglyMeasurable (fun a => ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)) μ

full_name: ProbabilityTheory.aestronglyMeasurable'_integral_condDistrib
code: theorem aestronglyMeasurable'_integral_condDistrib (hX : AEMeasurable X μ) (hY : AEMeasurable Y μ)
    (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a))) :
    AEStronglyMeasurable' (mβ.comap X) (fun a => ∫ y, f (X a, y) ∂condDistrib Y X μ (X a)) μ 
goal: MeasureTheory.AEStronglyMeasurable' (MeasurableSpace.comap X mβ)
  (fun a => ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)) μ

full_name: ProbabilityTheory.condDistrib_ae_eq_of_measure_eq_compProd
code: /-- `condDistrib` is a.e. uniquely defined as the kernel satisfying the defining property of
`condKernel`. -/
theorem condDistrib_ae_eq_of_measure_eq_compProd (hX : Measurable X) (hY : Measurable Y)
    (κ : Kernel β Ω) [IsFiniteKernel κ] (hκ : μ.map (fun x => (X x, Y x)) = μ.map X ⊗ₘ κ) :
    ∀ᵐ x ∂μ.map X, κ x = condDistrib Y X μ x 
goal: ∀ᵐ (x : β) ∂MeasureTheory.Measure.map X μ, κ x = (ProbabilityTheory.condDistrib Y X μ) x

full_name: ProbabilityTheory.integrable_toReal_condDistrib
code: theorem integrable_toReal_condDistrib (hX : AEMeasurable X μ) (hs : MeasurableSet s) :
    Integrable (fun a => (condDistrib Y X μ (X a) s).toReal) μ 
goal: MeasureTheory.Integrable (fun a => (((ProbabilityTheory.condDistrib Y X μ) (X a)) s).toReal) μ

full_name: MeasureTheory.Integrable.condDistrib_ae_map
code: theorem _root_.MeasureTheory.Integrable.condDistrib_ae_map
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    ∀ᵐ b ∂μ.map X, Integrable (fun ω => f (b, ω)) (condDistrib Y X μ b) 
goal: ∀ᵐ (b : β) ∂MeasureTheory.Measure.map X μ,
  MeasureTheory.Integrable (fun ω => f (b, ω)) ((ProbabilityTheory.condDistrib Y X μ) b)

full_name: MeasureTheory.Integrable.condDistrib_ae
code: theorem _root_.MeasureTheory.Integrable.condDistrib_ae (hX : AEMeasurable X μ)
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    ∀ᵐ a ∂μ, Integrable (fun ω => f (X a, ω)) (condDistrib Y X μ (X a)) 
goal: ∀ᵐ (a : α) ∂μ, MeasureTheory.Integrable (fun ω => f (X a, ω)) ((ProbabilityTheory.condDistrib Y X μ) (X a))

full_name: MeasureTheory.Integrable.integral_norm_condDistrib_map
code: theorem _root_.MeasureTheory.Integrable.integral_norm_condDistrib_map
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    Integrable (fun x => ∫ y, ‖f (x, y)‖ ∂condDistrib Y X μ x) (μ.map X) 
goal: MeasureTheory.Integrable (fun x => ∫ (y : Ω), ‖f (x, y)‖ ∂(ProbabilityTheory.condDistrib Y X μ) x)
  (MeasureTheory.Measure.map X μ)

full_name: MeasureTheory.Integrable.integral_norm_condDistrib
code: theorem _root_.MeasureTheory.Integrable.integral_norm_condDistrib (hX : AEMeasurable X μ)
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    Integrable (fun a => ∫ y, ‖f (X a, y)‖ ∂condDistrib Y X μ (X a)) μ 
goal: MeasureTheory.Integrable (fun a => ∫ (y : Ω), ‖f (X a, y)‖ ∂(ProbabilityTheory.condDistrib Y X μ) (X a)) μ

full_name: MeasureTheory.Integrable.norm_integral_condDistrib_map
code: theorem _root_.MeasureTheory.Integrable.norm_integral_condDistrib_map
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    Integrable (fun x => ‖∫ y, f (x, y) ∂condDistrib Y X μ x‖) (μ.map X) 
goal: MeasureTheory.Integrable (fun x => ‖∫ (y : Ω), f (x, y) ∂(ProbabilityTheory.condDistrib Y X μ) x‖)
  (MeasureTheory.Measure.map X μ)

full_name: MeasureTheory.Integrable.norm_integral_condDistrib
code: theorem _root_.MeasureTheory.Integrable.norm_integral_condDistrib (hX : AEMeasurable X μ)
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    Integrable (fun a => ‖∫ y, f (X a, y) ∂condDistrib Y X μ (X a)‖) μ 
goal: MeasureTheory.Integrable (fun a => ‖∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)‖) μ

full_name: MeasureTheory.Integrable.integral_condDistrib_map
code: theorem _root_.MeasureTheory.Integrable.integral_condDistrib_map
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    Integrable (fun x => ∫ y, f (x, y) ∂condDistrib Y X μ x) (μ.map X) 
goal: MeasureTheory.Integrable (fun x => ∫ (y : Ω), f (x, y) ∂(ProbabilityTheory.condDistrib Y X μ) x)
  (MeasureTheory.Measure.map X μ)

full_name: MeasureTheory.Integrable.integral_condDistrib
code: theorem _root_.MeasureTheory.Integrable.integral_condDistrib (hX : AEMeasurable X μ)
    (hY : AEMeasurable Y μ) (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    Integrable (fun a => ∫ y, f (X a, y) ∂condDistrib Y X μ (X a)) μ 
goal: MeasureTheory.Integrable (fun a => ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)) μ

full_name: ProbabilityTheory.setLIntegral_preimage_condDistrib
code: theorem setLIntegral_preimage_condDistrib (hX : Measurable X) (hY : AEMeasurable Y μ)
    (hs : MeasurableSet s) (ht : MeasurableSet t) :
    ∫⁻ a in X ⁻¹' t, condDistrib Y X μ (X a) s ∂μ = μ (X ⁻¹' t ∩ Y ⁻¹' s) 
goal: ∫⁻ (a : α) in X ⁻¹' t, ((ProbabilityTheory.condDistrib Y X μ) (X a)) s ∂μ = μ (X ⁻¹' t ∩ Y ⁻¹' s)

full_name: ProbabilityTheory.setLIntegral_condDistrib_of_measurableSet
code: theorem setLIntegral_condDistrib_of_measurableSet (hX : Measurable X) (hY : AEMeasurable Y μ)
    (hs : MeasurableSet s) {t : Set α} (ht : MeasurableSet[mβ.comap X] t) :
    ∫⁻ a in t, condDistrib Y X μ (X a) s ∂μ = μ (t ∩ Y ⁻¹' s) 
goal: ∫⁻ (a : α) in t, ((ProbabilityTheory.condDistrib Y X μ) (X a)) s ∂μ = μ (t ∩ Y ⁻¹' s)

full_name: ProbabilityTheory.condDistrib_ae_eq_condexp
code: /-- For almost every `a : α`, the `condDistrib Y X μ` kernel applied to `X a` and a measurable set
`s` is equal to the conditional expectation of the indicator of `Y ⁻¹' s`. -/
theorem condDistrib_ae_eq_condexp (hX : Measurable X) (hY : Measurable Y) (hs : MeasurableSet s) :
    (fun a => (condDistrib Y X μ (X a) s).toReal) =ᵐ[μ] μ⟦Y ⁻¹' s|mβ.comap X⟧ 
goal: (fun a => (((ProbabilityTheory.condDistrib Y X μ) (X a)) s).toReal) =ᵐ[μ]
  μ[(Y ⁻¹' s).indicator fun ω => 1|MeasurableSpace.comap X mβ]

full_name: ProbabilityTheory.condexp_prod_ae_eq_integral_condDistrib'
code: /-- The conditional expectation of a function `f` of the product `(X, Y)` is almost everywhere equal
to the integral of `y ↦ f(X, y)` against the `condDistrib` kernel. -/
theorem condexp_prod_ae_eq_integral_condDistrib' [NormedSpace ℝ F] [CompleteSpace F]
    (hX : Measurable X) (hY : AEMeasurable Y μ)
    (hf_int : Integrable f (μ.map fun a => (X a, Y a))) :
    μ[fun a => f (X a, Y a)|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a,y) ∂condDistrib Y X μ (X a) 
goal: μ[fun a => f (X a, Y a)|MeasurableSpace.comap X mβ] =ᵐ[μ] fun a =>
  ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)

full_name: ProbabilityTheory.condexp_prod_ae_eq_integral_condDistrib₀
code: /-- The conditional expectation of a function `f` of the product `(X, Y)` is almost everywhere equal
to the integral of `y ↦ f(X, y)` against the `condDistrib` kernel. -/
theorem condexp_prod_ae_eq_integral_condDistrib₀ [NormedSpace ℝ F] [CompleteSpace F]
    (hX : Measurable X) (hY : AEMeasurable Y μ)
    (hf : AEStronglyMeasurable f (μ.map fun a => (X a, Y a)))
    (hf_int : Integrable (fun a => f (X a, Y a)) μ) :
    μ[fun a => f (X a, Y a)|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂condDistrib Y X μ (X a) 
goal: μ[fun a => f (X a, Y a)|MeasurableSpace.comap X mβ] =ᵐ[μ] fun a =>
  ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)

full_name: ProbabilityTheory.condexp_prod_ae_eq_integral_condDistrib
code: /-- The conditional expectation of a function `f` of the product `(X, Y)` is almost everywhere equal
to the integral of `y ↦ f(X, y)` against the `condDistrib` kernel. -/
theorem condexp_prod_ae_eq_integral_condDistrib [NormedSpace ℝ F] [CompleteSpace F]
    (hX : Measurable X) (hY : AEMeasurable Y μ) (hf : StronglyMeasurable f)
    (hf_int : Integrable (fun a => f (X a, Y a)) μ) :
    μ[fun a => f (X a, Y a)|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f (X a, y) ∂condDistrib Y X μ (X a) 
goal: μ[fun a => f (X a, Y a)|MeasurableSpace.comap X mβ] =ᵐ[μ] fun a =>
  ∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a)

full_name: ProbabilityTheory.condexp_ae_eq_integral_condDistrib
code: theorem condexp_ae_eq_integral_condDistrib [NormedSpace ℝ F] [CompleteSpace F] (hX : Measurable X)
    (hY : AEMeasurable Y μ) {f : Ω → F} (hf : StronglyMeasurable f)
    (hf_int : Integrable (fun a => f (Y a)) μ) :
    μ[fun a => f (Y a)|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f y ∂condDistrib Y X μ (X a) 
goal: μ[fun a => f (Y a)|MeasurableSpace.comap X mβ] =ᵐ[μ] fun a =>
  ∫ (y : Ω), f y ∂(ProbabilityTheory.condDistrib Y X μ) (X a)

full_name: ProbabilityTheory.condexp_ae_eq_integral_condDistrib'
code: /-- The conditional expectation of `Y` given `X` is almost everywhere equal to the integral
`∫ y, y ∂(condDistrib Y X μ (X a))`. -/
theorem condexp_ae_eq_integral_condDistrib' {Ω} [NormedAddCommGroup Ω] [NormedSpace ℝ Ω]
    [CompleteSpace Ω] [MeasurableSpace Ω] [BorelSpace Ω] [SecondCountableTopology Ω] {Y : α → Ω}
    (hX : Measurable X) (hY_int : Integrable Y μ) :
    μ[Y|mβ.comap X] =ᵐ[μ] fun a => ∫ y, y ∂condDistrib Y X μ (X a) 
goal: μ[Y|MeasurableSpace.comap X mβ] =ᵐ[μ] fun a => ∫ (y : Ω), y ∂(ProbabilityTheory.condDistrib Y X μ) (X a)

full_name: MeasureTheory.AEStronglyMeasurable.comp_snd_map_prod_mk
code: theorem _root_.MeasureTheory.AEStronglyMeasurable.comp_snd_map_prod_mk
    {Ω F} {mΩ : MeasurableSpace Ω} (X : Ω → β) {μ : Measure Ω} [TopologicalSpace F] {f : Ω → F}
    (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun x : β × Ω => f x.2) (μ.map fun ω => (X ω, ω)) 
goal: MeasureTheory.AEStronglyMeasurable (fun x => f x.2) (MeasureTheory.Measure.map (fun ω => (X ω, ω)) μ)

full_name: MeasureTheory.Integrable.comp_snd_map_prod_mk
code: theorem _root_.MeasureTheory.Integrable.comp_snd_map_prod_mk
    {Ω} {mΩ : MeasurableSpace Ω} (X : Ω → β) {μ : Measure Ω} {f : Ω → F} (hf_int : Integrable f μ) :
    Integrable (fun x : β × Ω => f x.2) (μ.map fun ω => (X ω, ω)) 
goal: MeasureTheory.Integrable (fun x => f x.2) (MeasureTheory.Measure.map (fun ω => (X ω, ω)) μ)

full_name: ProbabilityTheory.aestronglyMeasurable_comp_snd_map_prod_mk_iff
code: theorem aestronglyMeasurable_comp_snd_map_prod_mk_iff {Ω F} {_ : MeasurableSpace Ω}
    [TopologicalSpace F] {X : Ω → β} {μ : Measure Ω} (hX : Measurable X) {f : Ω → F} :
    AEStronglyMeasurable (fun x : β × Ω => f x.2) (μ.map fun ω => (X ω, ω)) ↔
    AEStronglyMeasurable f μ 
goal: ∀ {x : MeasurableSpace Ω} [inst : TopologicalSpace F] {X : Ω → β} {μ : MeasureTheory.Measure Ω},
  Measurable X →
    ∀ {f : Ω → F},
      MeasureTheory.AEStronglyMeasurable (fun x => f x.2) (MeasureTheory.Measure.map (fun ω => (X ω, ω)) μ) ↔
        MeasureTheory.AEStronglyMeasurable f μ

full_name: ProbabilityTheory.integrable_comp_snd_map_prod_mk_iff
code: theorem integrable_comp_snd_map_prod_mk_iff {Ω} {_ : MeasurableSpace Ω} {X : Ω → β} {μ : Measure Ω}
    (hX : Measurable X) {f : Ω → F} :
    Integrable (fun x : β × Ω => f x.2) (μ.map fun ω => (X ω, ω)) ↔ Integrable f μ 
goal: ∀ {x : MeasurableSpace Ω} {X : Ω → β} {μ : MeasureTheory.Measure Ω},
  Measurable X →
    ∀ {f : Ω → F},
      MeasureTheory.Integrable (fun x => f x.2) (MeasureTheory.Measure.map (fun ω => (X ω, ω)) μ) ↔
        MeasureTheory.Integrable f μ

full_name: ProbabilityTheory.condexp_ae_eq_integral_condDistrib_id
code: theorem condexp_ae_eq_integral_condDistrib_id [NormedSpace ℝ F] [CompleteSpace F] {X : Ω → β}
    {μ : Measure Ω} [IsFiniteMeasure μ] (hX : Measurable X) {f : Ω → F} (hf_int : Integrable f μ) :
    μ[f|mβ.comap X] =ᵐ[μ] fun a => ∫ y, f y ∂condDistrib id X μ (X a) 
goal: μ[f|MeasurableSpace.comap X mβ] =ᵐ[μ] fun a => ∫ (y : Ω), f y ∂(ProbabilityTheory.condDistrib id X μ) (X a)