File: Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean

full_name: ProbabilityTheory.Kernel.isRatCondKernelCDFAux_density_Iic
code: lemma isRatCondKernelCDFAux_density_Iic (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    IsRatCondKernelCDFAux (fun (p : α × γ) q ↦ density κ (fst κ) p.1 p.2 (Iic q)) κ (fst κ) 
goal: ProbabilityTheory.IsRatCondKernelCDFAux (fun p q => κ.density κ.fst p.1 p.2 (Set.Iic ↑q)) κ κ.fst

full_name: ProbabilityTheory.Kernel.isRatCondKernelCDF_density_Iic
code: /-- Taking the kernel density of intervals `Iic q` for `q : ℚ` gives a function with the property
`isRatCondKernelCDF`. -/
lemma isRatCondKernelCDF_density_Iic (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    IsRatCondKernelCDF (fun (p : α × γ) q ↦ density κ (fst κ) p.1 p.2 (Iic q)) κ (fst κ) 
goal: ProbabilityTheory.IsRatCondKernelCDF (fun p q => κ.density κ.fst p.1 p.2 (Set.Iic ↑q)) κ κ.fst

full_name: ProbabilityTheory.Kernel.condKernelCDF
code: /-- The conditional kernel CDF of a kernel `κ : Kernel α (γ × ℝ)`, where `γ` is countably generated.
-/
noncomputable
def condKernelCDF (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] : α × γ → StieltjesFunction 
goal: α × γ → StieltjesFunction

full_name: ProbabilityTheory.Kernel.isCondKernelCDF_condKernelCDF
code: lemma isCondKernelCDF_condKernelCDF (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    IsCondKernelCDF (condKernelCDF κ) κ (fst κ) 
goal: ProbabilityTheory.IsCondKernelCDF κ.condKernelCDF κ κ.fst

full_name: ProbabilityTheory.Kernel.condKernelReal
code: /-- Auxiliary definition for `ProbabilityTheory.Kernel.condKernel`.
A conditional kernel for `κ : Kernel α (γ × ℝ)` where `γ` is countably generated. -/
noncomputable
def condKernelReal (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] : Kernel (α × γ) ℝ 
goal: ProbabilityTheory.Kernel (α × γ) ℝ

full_name: ProbabilityTheory.Kernel.instIsMarkovKernelCondKernelReal
code: instance instIsMarkovKernelCondKernelReal (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    IsMarkovKernel (condKernelReal κ) 
goal: ProbabilityTheory.IsMarkovKernel κ.condKernelReal

full_name: ProbabilityTheory.Kernel.compProd_fst_condKernelReal
code: lemma compProd_fst_condKernelReal (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelReal κ = κ 
goal: κ.fst ⊗ₖ κ.condKernelReal = κ

full_name: ProbabilityTheory.Kernel.condKernelUnitReal
code: /-- Auxiliary definition for `MeasureTheory.Measure.condKernel` and
`ProbabilityTheory.Kernel.condKernel`.
A conditional kernel for `κ : Kernel Unit (α × ℝ)`. -/
noncomputable
def condKernelUnitReal (κ : Kernel Unit (α × ℝ)) [IsFiniteKernel κ] : Kernel (Unit × α) ℝ 
goal: ProbabilityTheory.Kernel (Unit × α) ℝ

full_name: ProbabilityTheory.Kernel.instIsMarkovKernelCondKernelUnitReal
code: instance instIsMarkovKernelCondKernelUnitReal (κ : Kernel Unit (α × ℝ)) [IsFiniteKernel κ] :
    IsMarkovKernel (condKernelUnitReal κ) 
goal: ProbabilityTheory.IsMarkovKernel κ.condKernelUnitReal

full_name: ProbabilityTheory.Kernel.condKernelUnitReal.instIsCondKernel
code: instance condKernelUnitReal.instIsCondKernel (κ : Kernel Unit (α × ℝ)) [IsFiniteKernel κ] :
    κ.IsCondKernel κ.condKernelUnitReal 
goal: κ.IsCondKernel κ.condKernelUnitReal

full_name: ProbabilityTheory.Kernel.compProd_fst_condKernelUnitReal
code: @[deprecated disintegrate (since := "2024-07-26")]
lemma compProd_fst_condKernelUnitReal (κ : Kernel Unit (α × ℝ)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelUnitReal κ = κ 
goal: κ.fst ⊗ₖ κ.condKernelUnitReal = κ

full_name: ProbabilityTheory.Kernel.borelMarkovFromReal
code: /-- Auxiliary definition for `ProbabilityTheory.Kernel.condKernel`.
A Borel space `Ω` embeds measurably into `ℝ` (with embedding `e`), hence we can get a `Kernel α Ω`
from a `Kernel α ℝ` by taking the comap by `e`.
Here we take the comap of a modification of `η : Kernel α ℝ`, useful when `η a` is a probability
measure with all its mass on `range e` almost everywhere with respect to some measure and we want to
ensure that the comap is a Markov kernel.
We thus take the comap by `e` of a kernel defined piecewise: `η` when
`η a (range (embeddingReal Ω))ᶜ = 0`, and an arbitrary deterministic kernel otherwise. -/
noncomputable
def borelMarkovFromReal (Ω : Type*) [Nonempty Ω] [MeasurableSpace Ω] [StandardBorelSpace Ω]
    (η : Kernel α ℝ) :
    Kernel α Ω 
goal: ProbabilityTheory.Kernel α Ω

full_name: ProbabilityTheory.Kernel.borelMarkovFromReal_apply
code: lemma borelMarkovFromReal_apply (Ω : Type*) [Nonempty Ω] [MeasurableSpace Ω] [StandardBorelSpace Ω]
    (η : Kernel α ℝ) (a : α) :
    borelMarkovFromReal Ω η a
      = if η a (range (embeddingReal Ω))ᶜ = 0 then (η a).comap (embeddingReal Ω)
        else (Measure.dirac (range_nonempty (embeddingReal Ω)).choose).comap (embeddingReal Ω) 
goal: (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η) a =
  if (η a) (Set.range (MeasureTheory.embeddingReal Ω))ᶜ = 0 then
    MeasureTheory.Measure.comap (MeasureTheory.embeddingReal Ω) (η a)
  else MeasureTheory.Measure.comap (MeasureTheory.embeddingReal Ω) (MeasureTheory.Measure.dirac (Exists.choose ⋯))

full_name: ProbabilityTheory.Kernel.borelMarkovFromReal_apply'
code: lemma borelMarkovFromReal_apply' (Ω : Type*) [Nonempty Ω] [MeasurableSpace Ω] [StandardBorelSpace Ω]
    (η : Kernel α ℝ) (a : α) {s : Set Ω} (hs : MeasurableSet s) :
    borelMarkovFromReal Ω η a s
      = if η a (range (embeddingReal Ω))ᶜ = 0 then η a (embeddingReal Ω '' s)
        else (embeddingReal Ω '' s).indicator 1 (range_nonempty (embeddingReal Ω)).choose 
goal: ((ProbabilityTheory.Kernel.borelMarkovFromReal Ω η) a) s =
  if (η a) (Set.range (MeasureTheory.embeddingReal Ω))ᶜ = 0 then (η a) (MeasureTheory.embeddingReal Ω '' s)
  else (MeasureTheory.embeddingReal Ω '' s).indicator 1 (Exists.choose ⋯)

full_name: ProbabilityTheory.Kernel.instIsSFiniteKernelBorelMarkovFromReal
code: /-- When `η` is an s-finite kernel, `borelMarkovFromReal Ω η` is an s-finite kernel. -/
instance instIsSFiniteKernelBorelMarkovFromReal (η : Kernel α ℝ) [IsSFiniteKernel η] :
    IsSFiniteKernel (borelMarkovFromReal Ω η) 
goal: ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η)

full_name: ProbabilityTheory.Kernel.instIsFiniteKernelBorelMarkovFromReal
code: /-- When `η` is a finite kernel, `borelMarkovFromReal Ω η` is a finite kernel. -/
instance instIsFiniteKernelBorelMarkovFromReal (η : Kernel α ℝ) [IsFiniteKernel η] :
    IsFiniteKernel (borelMarkovFromReal Ω η) 
goal: ProbabilityTheory.IsFiniteKernel (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η)

full_name: ProbabilityTheory.Kernel.instIsMarkovKernelBorelMarkovFromReal
code: /-- When `η` is a Markov kernel, `borelMarkovFromReal Ω η` is a Markov kernel. -/
instance instIsMarkovKernelBorelMarkovFromReal (η : Kernel α ℝ) [IsMarkovKernel η] :
    IsMarkovKernel (borelMarkovFromReal Ω η) 
goal: ProbabilityTheory.IsMarkovKernel (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η)

full_name: ProbabilityTheory.Kernel.compProd_fst_borelMarkovFromReal_eq_comapRight_compProd
code: /-- For `κ' := map κ (Prod.map (id : β → β) e) (measurable_id.prod_map he.measurable)`, the
hypothesis `hη` is `fst κ' ⊗ₖ η = κ'`. The conclusion of the lemma is
`fst κ ⊗ₖ borelMarkovFromReal Ω η = comapRight (fst κ' ⊗ₖ η) _`. -/
lemma compProd_fst_borelMarkovFromReal_eq_comapRight_compProd
    (κ : Kernel α (β × Ω)) [IsSFiniteKernel κ] (η : Kernel (α × β) ℝ) [IsSFiniteKernel η]
    (hη : (fst (map κ (Prod.map (id : β → β) (embeddingReal Ω))
        (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable))) ⊗ₖ η
      = map κ (Prod.map (id : β → β) (embeddingReal Ω))
        (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable)) :
    fst κ ⊗ₖ borelMarkovFromReal Ω η
      = comapRight (fst (map κ (Prod.map (id : β → β) (embeddingReal Ω))
          (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable)) ⊗ₖ η)
        (MeasurableEmbedding.id.prod_mk (measurableEmbedding_embeddingReal Ω)) 
goal: κ.fst ⊗ₖ ProbabilityTheory.Kernel.borelMarkovFromReal Ω η =
  ((κ.map (Prod.map id (MeasureTheory.embeddingReal Ω)) ⋯).fst ⊗ₖ η).comapRight ⋯

full_name: ProbabilityTheory.Kernel.compProd_fst_borelMarkovFromReal
code: /-- For `κ' := map κ (Prod.map (id : β → β) e) (measurable_id.prod_map he.measurable)`, the
hypothesis `hη` is `fst κ' ⊗ₖ η = κ'`. With that hypothesis,
`fst κ ⊗ₖ borelMarkovFromReal κ η = κ`.-/
lemma compProd_fst_borelMarkovFromReal (κ : Kernel α (β × Ω)) [IsSFiniteKernel κ]
    (η : Kernel (α × β) ℝ) [IsSFiniteKernel η]
    (hη : (fst (map κ (Prod.map (id : β → β) (embeddingReal Ω))
        (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable))) ⊗ₖ η
      = map κ (Prod.map (id : β → β) (embeddingReal Ω))
        (measurable_id.prod_map (measurableEmbedding_embeddingReal Ω).measurable)) :
    fst κ ⊗ₖ borelMarkovFromReal Ω η = κ 
goal: κ.fst ⊗ₖ ProbabilityTheory.Kernel.borelMarkovFromReal Ω η = κ

full_name: ProbabilityTheory.Kernel.condKernelBorel
code: /-- Auxiliary definition for `ProbabilityTheory.Kernel.condKernel`.
A conditional kernel for `κ : Kernel α (γ × Ω)` where `γ` is countably generated and `Ω` is
standard Borel. -/
noncomputable
def condKernelBorel (κ : Kernel α (γ × Ω)) [IsFiniteKernel κ] : Kernel (α × γ) Ω 
goal: ProbabilityTheory.Kernel (α × γ) Ω

full_name: ProbabilityTheory.Kernel.instIsMarkovKernelCondKernelBorel
code: instance instIsMarkovKernelCondKernelBorel (κ : Kernel α (γ × Ω)) [IsFiniteKernel κ] :
    IsMarkovKernel (condKernelBorel κ) 
goal: ProbabilityTheory.IsMarkovKernel κ.condKernelBorel

full_name: ProbabilityTheory.Kernel.condKernelBorel.instIsCondKernel
code: instance condKernelBorel.instIsCondKernel (κ : Kernel α (γ × Ω)) [IsFiniteKernel κ] :
    κ.IsCondKernel κ.condKernelBorel 
goal: κ.IsCondKernel κ.condKernelBorel

full_name: ProbabilityTheory.Kernel.compProd_fst_condKernelBorel
code: @[deprecated disintegrate (since := "2024-07-26")]
lemma compProd_fst_condKernelBorel (κ : Kernel α (γ × Ω)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelBorel κ = κ 
goal: κ.fst ⊗ₖ κ.condKernelBorel = κ

full_name: ProbabilityTheory.Kernel.condKernelUnitBorel
code: /-- Auxiliary definition for `MeasureTheory.Measure.condKernel` and
`ProbabilityTheory.Kernel.condKernel`.
A conditional kernel for `κ : Kernel Unit (α × Ω)` where `Ω` is standard Borel. -/
noncomputable
def condKernelUnitBorel : Kernel (Unit × α) Ω 
goal: ProbabilityTheory.Kernel (Unit × α) Ω

full_name: ProbabilityTheory.Kernel.instIsMarkovKernelCondKernelUnitBorel
code: instance instIsMarkovKernelCondKernelUnitBorel : IsMarkovKernel κ.condKernelUnitBorel 
goal: ProbabilityTheory.IsMarkovKernel κ.condKernelUnitBorel

full_name: ProbabilityTheory.Kernel.condKernelUnitBorel.instIsCondKernel
code: instance condKernelUnitBorel.instIsCondKernel : κ.IsCondKernel κ.condKernelUnitBorel 
goal: κ.IsCondKernel κ.condKernelUnitBorel

full_name: ProbabilityTheory.Kernel.compProd_fst_condKernelUnitBorel
code: @[deprecated disintegrate (since := "2024-07-26")]
lemma compProd_fst_condKernelUnitBorel (κ : Kernel Unit (α × Ω)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelUnitBorel κ = κ 
goal: κ.fst ⊗ₖ κ.condKernelUnitBorel = κ

full_name: ProbabilityTheory.Kernel.wrapped._@.Mathlib.Probability.Kernel.Disintegration.StandardBorel._hyg.4074
code: /-- Conditional kernel of a measure on a product space: a Markov kernel such that
`ρ = ρ.fst ⊗ₘ ρ.condKernel` (see `MeasureTheory.Measure.compProd_fst_condKernel`). -/
noncomputable
irreducible_def _root_.MeasureTheory.Measure.condKernel (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ] :
    Kernel α Ω 
goal: Subtype (Eq @ProbabilityTheory.Kernel.definition✝)

full_name: ProbabilityTheory.Kernel.definition._@.Mathlib.Probability.Kernel.Disintegration.StandardBorel._hyg.4074
code: /-- Conditional kernel of a measure on a product space: a Markov kernel such that
`ρ = ρ.fst ⊗ₘ ρ.condKernel` (see `MeasureTheory.Measure.compProd_fst_condKernel`). -/
noncomputable
irreducible_def _root_.MeasureTheory.Measure.condKernel (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ] :
    Kernel α Ω 
goal: ProbabilityTheory.Kernel α Ω

full_name: MeasureTheory.Measure.condKernel
code: /-- Conditional kernel of a measure on a product space: a Markov kernel such that
`ρ = ρ.fst ⊗ₘ ρ.condKernel` (see `MeasureTheory.Measure.compProd_fst_condKernel`). -/
noncomputable
irreducible_def _root_.MeasureTheory.Measure.condKernel (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ] :
    Kernel α Ω 
goal: ProbabilityTheory.Kernel α Ω

full_name: MeasureTheory.Measure.condKernel_def
code: /-- Conditional kernel of a measure on a product space: a Markov kernel such that
`ρ = ρ.fst ⊗ₘ ρ.condKernel` (see `MeasureTheory.Measure.compProd_fst_condKernel`). -/
noncomputable
irreducible_def _root_.MeasureTheory.Measure.condKernel (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ] :
    Kernel α Ω 
goal: ρ.condKernel = (ProbabilityTheory.Kernel.const Unit ρ).condKernelUnitBorel.comap (fun a => ((), a)) ⋯

full_name: MeasureTheory.Measure.condKernel_apply
code: lemma _root_.MeasureTheory.Measure.condKernel_apply (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ]
    (a : α) :
    ρ.condKernel a = condKernelUnitBorel (const Unit ρ) ((), a) 
goal: ρ.condKernel a = (ProbabilityTheory.Kernel.const Unit ρ).condKernelUnitBorel ((), a)

full_name: MeasureTheory.Measure.condKernel.instIsCondKernel
code: instance _root_.MeasureTheory.Measure.condKernel.instIsCondKernel (ρ : Measure (α × Ω))
    [IsFiniteMeasure ρ] : ρ.IsCondKernel ρ.condKernel 
goal: ρ.IsCondKernel ρ.condKernel

full_name: MeasureTheory.Measure.instIsMarkovKernelCondKernel
code: instance _root_.MeasureTheory.Measure.instIsMarkovKernelCondKernel
    (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ] : IsMarkovKernel ρ.condKernel 
goal: ProbabilityTheory.IsMarkovKernel ρ.condKernel

full_name: MeasureTheory.Measure.compProd_fst_condKernel
code: /-- **Disintegration** of finite product measures on `α × Ω`, where `Ω` is standard Borel. Such a
measure can be written as the composition-product of `ρ.fst` (marginal measure over `α`) and
a Markov kernel from `α` to `Ω`. We call that Markov kernel `ρ.condKernel`. -/
@[deprecated Measure.disintegrate (since := "2024-07-24")]
lemma _root_.MeasureTheory.Measure.compProd_fst_condKernel
    (ρ : Measure (α × Ω)) [IsFiniteMeasure ρ] :
    ρ.fst ⊗ₘ ρ.condKernel = ρ 
goal: ρ.fst ⊗ₘ ρ.condKernel = ρ

full_name: MeasureTheory.Measure.condKernel_apply_of_ne_zero_of_measurableSet
code: /-- Auxiliary lemma for `condKernel_apply_of_ne_zero`. -/
@[deprecated Measure.IsCondKernel.apply_of_ne_zero (since := "2024-07-24"), nolint unusedArguments]
lemma _root_.MeasureTheory.Measure.condKernel_apply_of_ne_zero_of_measurableSet
    [MeasurableSingletonClass α] {x : α} (hx : ρ.fst {x} ≠ 0) {s : Set Ω} (hs : MeasurableSet s) :
    ρ.condKernel x s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s) 
goal: (ρ.condKernel x) s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)

full_name: MeasureTheory.Measure.condKernel_apply_of_ne_zero
code: /-- If the singleton `{x}` has non-zero mass for `ρ.fst`, then for all `s : Set Ω`,
`ρ.condKernel x s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)` . -/
lemma _root_.MeasureTheory.Measure.condKernel_apply_of_ne_zero [MeasurableSingletonClass α]
    {x : α} (hx : ρ.fst {x} ≠ 0) (s : Set Ω) :
    ρ.condKernel x s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s) 
goal: (ρ.condKernel x) s = (ρ.fst {x})⁻¹ * ρ ({x} ×ˢ s)

full_name: ProbabilityTheory.Kernel.compProd_fst_condKernelCountable
code: @[deprecated disintegrate (since := "2024-07-24")]
lemma compProd_fst_condKernelCountable (κ : Kernel α (β × Ω)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelCountable (fun a ↦ (κ a).condKernel)
      (fun x y h ↦ by simp [apply_congr_of_mem_measurableAtom _ h]) = κ 
goal: κ.fst ⊗ₖ ProbabilityTheory.Kernel.condKernelCountable (fun a => (κ a).condKernel) ⋯ = κ

full_name: ProbabilityTheory.Kernel.definition._@.Mathlib.Probability.Kernel.Disintegration.StandardBorel._hyg.5224
code: /-- Conditional kernel of a kernel `κ : Kernel α (β × Ω)`: a Markov kernel such that
`fst κ ⊗ₖ condKernel κ = κ` (see `MeasureTheory.Measure.compProd_fst_condKernel`).
It exists whenever `Ω` is standard Borel and either `α` is countable
or `β` is countably generated. -/
noncomputable
irreducible_def condKernel : Kernel (α × β) Ω 
goal: ProbabilityTheory.Kernel (α × β) Ω

full_name: ProbabilityTheory.Kernel.condKernel_def
code: /-- Conditional kernel of a kernel `κ : Kernel α (β × Ω)`: a Markov kernel such that
`fst κ ⊗ₖ condKernel κ = κ` (see `MeasureTheory.Measure.compProd_fst_condKernel`).
It exists whenever `Ω` is standard Borel and either `α` is countable
or `β` is countably generated. -/
noncomputable
irreducible_def condKernel : Kernel (α × β) Ω 
goal: κ.condKernel =
  if hα : Countable α then ProbabilityTheory.Kernel.condKernelCountable (fun a => (κ a).condKernel) ⋯
  else κ.condKernelBorel

full_name: ProbabilityTheory.Kernel.condKernel
code: /-- Conditional kernel of a kernel `κ : Kernel α (β × Ω)`: a Markov kernel such that
`fst κ ⊗ₖ condKernel κ = κ` (see `MeasureTheory.Measure.compProd_fst_condKernel`).
It exists whenever `Ω` is standard Borel and either `α` is countable
or `β` is countably generated. -/
noncomputable
irreducible_def condKernel : Kernel (α × β) Ω 
goal: ProbabilityTheory.Kernel (α × β) Ω

full_name: ProbabilityTheory.Kernel.wrapped._@.Mathlib.Probability.Kernel.Disintegration.StandardBorel._hyg.5224
code: /-- Conditional kernel of a kernel `κ : Kernel α (β × Ω)`: a Markov kernel such that
`fst κ ⊗ₖ condKernel κ = κ` (see `MeasureTheory.Measure.compProd_fst_condKernel`).
It exists whenever `Ω` is standard Borel and either `α` is countable
or `β` is countably generated. -/
noncomputable
irreducible_def condKernel : Kernel (α × β) Ω 
goal: Subtype (Eq @ProbabilityTheory.Kernel.definition✝)

full_name: ProbabilityTheory.Kernel.instIsMarkovKernelCondKernel
code: /-- `condKernel κ` is a Markov kernel. -/
instance instIsMarkovKernelCondKernel : IsMarkovKernel (condKernel κ) 
goal: ProbabilityTheory.IsMarkovKernel κ.condKernel

full_name: ProbabilityTheory.Kernel.condKernel.instIsCondKernel
code: instance condKernel.instIsCondKernel : κ.IsCondKernel κ.condKernel 
goal: κ.IsCondKernel κ.condKernel

full_name: ProbabilityTheory.Kernel.compProd_fst_condKernel
code: /-- **Disintegration** of finite kernels.
The composition-product of `fst κ` and `condKernel κ` is equal to `κ`. -/
@[deprecated Kernel.disintegrate (since := "2024-07-26")]
lemma compProd_fst_condKernel : fst κ ⊗ₖ condKernel κ = κ 
goal: κ.fst ⊗ₖ κ.condKernel = κ