File: Mathlib/Probability/Kernel/MeasureCompProd.lean

full_name: MeasureTheory.Measure.compProd
code: /-- The composition-product of a measure and a kernel. -/
noncomputable
def compProd (μ : Measure α) (κ : Kernel α β) : Measure (α × β) 
goal: MeasureTheory.Measure (α × β)

full_name: ProbabilityTheory._aux_Mathlib_Probability_Kernel_MeasureCompProd___unexpand_MeasureTheory_Measure_compProd_1
code: @[inherit_doc]
scoped[ProbabilityTheory] infixl:100 " ⊗ₘ " => MeasureTheory.Measure.compProd
goal: Lean.PrettyPrinter.Unexpander

full_name: ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_MeasureCompProd___macroRules_ProbabilityTheory_term_⊗ₘ__1»
code: @[inherit_doc]
scoped[ProbabilityTheory] infixl:100 " ⊗ₘ " => MeasureTheory.Measure.compProd
goal: Lean.Macro

full_name: MeasureTheory.Measure.compProd_of_not_sfinite
code: lemma compProd_of_not_sfinite (μ : Measure α) (κ : Kernel α β) (h : ¬ SFinite μ) :
    μ ⊗ₘ κ = 0 
goal: μ ⊗ₘ κ = 0

full_name: MeasureTheory.Measure.compProd_of_not_isSFiniteKernel
code: lemma compProd_of_not_isSFiniteKernel (μ : Measure α) (κ : Kernel α β) (h : ¬ IsSFiniteKernel κ) :
    μ ⊗ₘ κ = 0 
goal: μ ⊗ₘ κ = 0

full_name: MeasureTheory.Measure.compProd_zero_left
code: @[simp] lemma compProd_zero_left (κ : Kernel α β) : (0 : Measure α) ⊗ₘ κ = 0 
goal: 0 ⊗ₘ κ = 0

full_name: MeasureTheory.Measure.compProd_zero_right
code: @[simp] lemma compProd_zero_right (μ : Measure α) : μ ⊗ₘ (0 : Kernel α β) = 0 
goal: μ ⊗ₘ 0 = 0

full_name: MeasureTheory.Measure.compProd_apply
code: lemma compProd_apply [SFinite μ] [IsSFiniteKernel κ] {s : Set (α × β)} (hs : MeasurableSet s) :
    (μ ⊗ₘ κ) s = ∫⁻ a, κ a (Prod.mk a ⁻¹' s) ∂μ 
goal: (μ ⊗ₘ κ) s = ∫⁻ (a : α), (κ a) (Prod.mk a ⁻¹' s) ∂μ

full_name: MeasureTheory.Measure.compProd_apply_prod
code: lemma compProd_apply_prod [SFinite μ] [IsSFiniteKernel κ]
    {s : Set α} {t : Set β} (hs : MeasurableSet s) (ht : MeasurableSet t) :
    (μ ⊗ₘ κ) (s ×ˢ t) = ∫⁻ a in s, κ a t ∂μ 
goal: (μ ⊗ₘ κ) (s ×ˢ t) = ∫⁻ (a : α) in s, (κ a) t ∂μ

full_name: MeasureTheory.Measure.compProd_congr
code: lemma compProd_congr [SFinite μ] [IsSFiniteKernel κ] [IsSFiniteKernel η]
    (h : κ =ᵐ[μ] η) : μ ⊗ₘ κ = μ ⊗ₘ η 
goal: μ ⊗ₘ κ = μ ⊗ₘ η

full_name: MeasureTheory.Measure.ae_compProd_of_ae_ae
code: lemma ae_compProd_of_ae_ae [SFinite μ] [IsSFiniteKernel κ] {p : α × β → Prop}
    (hp : MeasurableSet {x | p x}) (h : ∀ᵐ a ∂μ, ∀ᵐ b ∂(κ a), p (a, b)) :
    ∀ᵐ x ∂(μ ⊗ₘ κ), p x 
goal: ∀ᵐ (x : α × β) ∂μ ⊗ₘ κ, p x

full_name: MeasureTheory.Measure.ae_ae_of_ae_compProd
code: lemma ae_ae_of_ae_compProd [SFinite μ] [IsSFiniteKernel κ] {p : α × β → Prop}
    (h : ∀ᵐ x ∂(μ ⊗ₘ κ), p x) :
    ∀ᵐ a ∂μ, ∀ᵐ b ∂κ a, p (a, b) 
goal: ∀ᵐ (a : α) ∂μ, ∀ᵐ (b : β) ∂κ a, p (a, b)

full_name: MeasureTheory.Measure.ae_compProd_iff
code: lemma ae_compProd_iff [SFinite μ] [IsSFiniteKernel κ] {p : α × β → Prop}
    (hp : MeasurableSet {x | p x}) :
    (∀ᵐ x ∂(μ ⊗ₘ κ), p x) ↔ ∀ᵐ a ∂μ, ∀ᵐ b ∂(κ a), p (a, b) 
goal: (∀ᵐ (x : α × β) ∂μ ⊗ₘ κ, p x) ↔ ∀ᵐ (a : α) ∂μ, ∀ᵐ (b : β) ∂κ a, p (a, b)

full_name: MeasureTheory.Measure.compProd_add_left
code: lemma compProd_add_left (μ ν : Measure α) [SFinite μ] [SFinite ν] (κ : Kernel α β)
    [IsSFiniteKernel κ] :
    (μ + ν) ⊗ₘ κ = μ ⊗ₘ κ + ν ⊗ₘ κ 
goal: (μ + ν) ⊗ₘ κ = μ ⊗ₘ κ + ν ⊗ₘ κ

full_name: MeasureTheory.Measure.compProd_add_right
code: lemma compProd_add_right (μ : Measure α) [SFinite μ] (κ η : Kernel α β)
    [IsSFiniteKernel κ] [IsSFiniteKernel η] :
    μ ⊗ₘ (κ + η) = μ ⊗ₘ κ + μ ⊗ₘ η 
goal: μ ⊗ₘ (κ + η) = μ ⊗ₘ κ + μ ⊗ₘ η

full_name: MeasureTheory.Measure.lintegral_compProd
code: lemma lintegral_compProd [SFinite μ] [IsSFiniteKernel κ]
    {f : α × β → ℝ≥0∞} (hf : Measurable f) :
    ∫⁻ x, f x ∂(μ ⊗ₘ κ) = ∫⁻ a, ∫⁻ b, f (a, b) ∂(κ a) ∂μ 
goal: ∫⁻ (x : α × β), f x ∂μ ⊗ₘ κ = ∫⁻ (a : α), ∫⁻ (b : β), f (a, b) ∂κ a ∂μ

full_name: MeasureTheory.Measure.setLIntegral_compProd
code: lemma setLIntegral_compProd [SFinite μ] [IsSFiniteKernel κ]
    {f : α × β → ℝ≥0∞} (hf : Measurable f)
    {s : Set α} (hs : MeasurableSet s) {t : Set β} (ht : MeasurableSet t) :
    ∫⁻ x in s ×ˢ t, f x ∂(μ ⊗ₘ κ) = ∫⁻ a in s, ∫⁻ b in t, f (a, b) ∂(κ a) ∂μ 
goal: ∫⁻ (x : α × β) in s ×ˢ t, f x ∂μ ⊗ₘ κ = ∫⁻ (a : α) in s, ∫⁻ (b : β) in t, f (a, b) ∂κ a ∂μ

full_name: MeasureTheory.Measure.integrable_compProd_iff
code: lemma integrable_compProd_iff [SFinite μ] [IsSFiniteKernel κ] {E : Type*} [NormedAddCommGroup E]
    {f : α × β → E} (hf : AEStronglyMeasurable f (μ ⊗ₘ κ)) :
    Integrable f (μ ⊗ₘ κ) ↔
      (∀ᵐ x ∂μ, Integrable (fun y => f (x, y)) (κ x)) ∧
        Integrable (fun x => ∫ y, ‖f (x, y)‖ ∂(κ x)) μ 
goal: MeasureTheory.Integrable f (μ ⊗ₘ κ) ↔
  (∀ᵐ (x : α) ∂μ, MeasureTheory.Integrable (fun y => f (x, y)) (κ x)) ∧
    MeasureTheory.Integrable (fun x => ∫ (y : β), ‖f (x, y)‖ ∂κ x) μ

full_name: MeasureTheory.Measure.integral_compProd
code: lemma integral_compProd [SFinite μ] [IsSFiniteKernel κ] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace ℝ E]
    {f : α × β → E} (hf : Integrable f (μ ⊗ₘ κ)) :
    ∫ x, f x ∂(μ ⊗ₘ κ) = ∫ a, ∫ b, f (a, b) ∂(κ a) ∂μ 
goal: ∫ (x : α × β), f x ∂μ ⊗ₘ κ = ∫ (a : α), ∫ (b : β), f (a, b) ∂κ a ∂μ

full_name: MeasureTheory.Measure.setIntegral_compProd
code: lemma setIntegral_compProd [SFinite μ] [IsSFiniteKernel κ] {E : Type*}
    [NormedAddCommGroup E] [NormedSpace ℝ E]
    {s : Set α} (hs : MeasurableSet s) {t : Set β} (ht : MeasurableSet t)
    {f : α × β → E} (hf : IntegrableOn f (s ×ˢ t) (μ ⊗ₘ κ))  :
    ∫ x in s ×ˢ t, f x ∂(μ ⊗ₘ κ) = ∫ a in s, ∫ b in t, f (a, b) ∂(κ a) ∂μ 
goal: ∫ (x : α × β) in s ×ˢ t, f x ∂μ ⊗ₘ κ = ∫ (a : α) in s, ∫ (b : β) in t, f (a, b) ∂κ a ∂μ

full_name: MeasureTheory.Measure.dirac_compProd_apply
code: lemma dirac_compProd_apply [MeasurableSingletonClass α] {a : α} [IsSFiniteKernel κ]
    {s : Set (α × β)} (hs : MeasurableSet s) :
    (Measure.dirac a ⊗ₘ κ) s = κ a (Prod.mk a ⁻¹' s) 
goal: (MeasureTheory.Measure.dirac a ⊗ₘ κ) s = (κ a) (Prod.mk a ⁻¹' s)

full_name: MeasureTheory.Measure.dirac_unit_compProd
code: lemma dirac_unit_compProd (κ : Kernel Unit β) [IsSFiniteKernel κ] :
    Measure.dirac () ⊗ₘ κ = (κ ()).map (Prod.mk ()) 
goal: MeasureTheory.Measure.dirac () ⊗ₘ κ = MeasureTheory.Measure.map (Prod.mk ()) (κ ())

full_name: MeasureTheory.Measure.dirac_unit_compProd_const
code: lemma dirac_unit_compProd_const (μ : Measure β) [IsFiniteMeasure μ] :
    Measure.dirac () ⊗ₘ Kernel.const Unit μ = μ.map (Prod.mk ()) 
goal: MeasureTheory.Measure.dirac () ⊗ₘ ProbabilityTheory.Kernel.const Unit μ = MeasureTheory.Measure.map (Prod.mk ()) μ

full_name: MeasureTheory.Measure.snd_dirac_unit_compProd_const
code: @[simp]
lemma snd_dirac_unit_compProd_const (μ : Measure β) [IsFiniteMeasure μ] :
    snd (Measure.dirac () ⊗ₘ Kernel.const Unit μ) = μ 
goal: (MeasureTheory.Measure.dirac () ⊗ₘ ProbabilityTheory.Kernel.const Unit μ).snd = μ

full_name: MeasureTheory.Measure.instSFiniteProdCompProd
code: instance : SFinite (μ ⊗ₘ κ) 
goal: MeasureTheory.SFinite (μ ⊗ₘ κ)

full_name: MeasureTheory.Measure.instIsFiniteMeasureProdCompProdOfIsFiniteKernel
code: instance [IsFiniteMeasure μ] [IsFiniteKernel κ] : IsFiniteMeasure (μ ⊗ₘ κ) 
goal: MeasureTheory.IsFiniteMeasure (μ ⊗ₘ κ)

full_name: MeasureTheory.Measure.instIsProbabilityMeasureProdCompProdOfIsMarkovKernel
code: instance [IsProbabilityMeasure μ] [IsMarkovKernel κ] : IsProbabilityMeasure (μ ⊗ₘ κ) 
goal: MeasureTheory.IsProbabilityMeasure (μ ⊗ₘ κ)