File: Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean

full_name: MeasureTheory.FiniteMeasure.prod
code: /-- The binary product of finite measures. -/
noncomputable def prod (μ : FiniteMeasure α) (ν : FiniteMeasure β) : FiniteMeasure (α × β) 
goal: MeasureTheory.FiniteMeasure (α × β)

full_name: MeasureTheory.FiniteMeasure.toMeasure_prod
code: @[simp] lemma toMeasure_prod : (μ.prod ν).toMeasure = μ.toMeasure.prod ν.toMeasure 
goal: ↑(μ.prod ν) = (↑μ).prod ↑ν

full_name: MeasureTheory.FiniteMeasure.prod_apply
code: lemma prod_apply (s : Set (α × β)) (s_mble : MeasurableSet s) :
    μ.prod ν s = ENNReal.toNNReal (∫⁻ x, ν.toMeasure (Prod.mk x ⁻¹' s) ∂μ) 
goal: (μ.prod ν) s = (∫⁻ (x : α), ↑ν (Prod.mk x ⁻¹' s) ∂↑μ).toNNReal

full_name: MeasureTheory.FiniteMeasure.prod_apply_symm
code: lemma prod_apply_symm (s : Set (α × β)) (s_mble : MeasurableSet s) :
    μ.prod ν s = ENNReal.toNNReal (∫⁻ y, μ.toMeasure ((fun x ↦ ⟨x, y⟩) ⁻¹' s) ∂ν) 
goal: (μ.prod ν) s = (∫⁻ (y : β), ↑μ ((fun x => (x, y)) ⁻¹' s) ∂↑ν).toNNReal

full_name: MeasureTheory.FiniteMeasure.prod_prod
code: lemma prod_prod (s : Set α) (t : Set β) : μ.prod ν (s ×ˢ t) = μ s * ν t 
goal: (μ.prod ν) (s ×ˢ t) = μ s * ν t

full_name: MeasureTheory.FiniteMeasure.mass_prod
code: @[simp] lemma mass_prod : (μ.prod ν).mass = μ.mass * ν.mass 
goal: (μ.prod ν).mass = μ.mass * ν.mass

full_name: MeasureTheory.FiniteMeasure.zero_prod
code: @[simp] lemma zero_prod : (0 : FiniteMeasure α).prod ν = 0 
goal: MeasureTheory.FiniteMeasure.prod 0 ν = 0

full_name: MeasureTheory.FiniteMeasure.prod_zero
code: @[simp] lemma prod_zero : μ.prod (0 : FiniteMeasure β) = 0 
goal: μ.prod 0 = 0

full_name: MeasureTheory.FiniteMeasure.map_fst_prod
code: @[simp] lemma map_fst_prod : (μ.prod ν).map Prod.fst = ν univ • μ 
goal: (μ.prod ν).map Prod.fst = ν Set.univ • μ

full_name: MeasureTheory.FiniteMeasure.map_snd_prod
code: @[simp] lemma map_snd_prod : (μ.prod ν).map Prod.snd = μ univ • ν 
goal: (μ.prod ν).map Prod.snd = μ Set.univ • ν

full_name: MeasureTheory.FiniteMeasure.map_prod_map
code: lemma map_prod_map {α' : Type*} [MeasurableSpace α'] {β' : Type*} [MeasurableSpace β']
    {f : α → α'} {g : β → β'}  (f_mble : Measurable f) (g_mble : Measurable g) :
    (μ.map f).prod (ν.map g) = (μ.prod ν).map (Prod.map f g) 
goal: (μ.map f).prod (ν.map g) = (μ.prod ν).map (Prod.map f g)

full_name: MeasureTheory.FiniteMeasure.prod_swap
code: lemma prod_swap : (μ.prod ν).map Prod.swap = ν.prod μ 
goal: (μ.prod ν).map Prod.swap = ν.prod μ

full_name: MeasureTheory.ProbabilityMeasure.prod
code: /-- The binary product of probability measures. -/
noncomputable def prod (μ : ProbabilityMeasure α) (ν : ProbabilityMeasure β) :
    ProbabilityMeasure (α × β) 
goal: MeasureTheory.ProbabilityMeasure (α × β)

full_name: MeasureTheory.ProbabilityMeasure.toMeasure_prod
code: @[simp] lemma toMeasure_prod : (μ.prod ν).toMeasure = μ.toMeasure.prod ν.toMeasure 
goal: ↑(μ.prod ν) = (↑μ).prod ↑ν

full_name: MeasureTheory.ProbabilityMeasure.prod_apply
code: lemma prod_apply (s : Set (α × β)) (s_mble : MeasurableSet s) :
    μ.prod ν s = ENNReal.toNNReal (∫⁻ x, ν.toMeasure (Prod.mk x ⁻¹' s) ∂μ) 
goal: (μ.prod ν) s = (∫⁻ (x : α), ↑ν (Prod.mk x ⁻¹' s) ∂↑μ).toNNReal

full_name: MeasureTheory.ProbabilityMeasure.prod_apply_symm
code: lemma prod_apply_symm (s : Set (α × β)) (s_mble : MeasurableSet s) :
    μ.prod ν s = ENNReal.toNNReal (∫⁻ y, μ.toMeasure ((fun x ↦ ⟨x, y⟩) ⁻¹' s) ∂ν) 
goal: (μ.prod ν) s = (∫⁻ (y : β), ↑μ ((fun x => (x, y)) ⁻¹' s) ∂↑ν).toNNReal

full_name: MeasureTheory.ProbabilityMeasure.prod_prod
code: lemma prod_prod (s : Set α) (t : Set β) : μ.prod ν (s ×ˢ t) = μ s * ν t 
goal: (μ.prod ν) (s ×ˢ t) = μ s * ν t

full_name: MeasureTheory.ProbabilityMeasure.map_fst_prod
code: /-- The first marginal of a product probability measure is the first probability measure. -/
@[simp] lemma map_fst_prod : (μ.prod ν).map measurable_fst.aemeasurable = μ 
goal: (μ.prod ν).map ⋯ = μ

full_name: MeasureTheory.ProbabilityMeasure.map_snd_prod
code: /-- The second marginal of a product probability measure is the second probability measure. -/
@[simp] lemma map_snd_prod : (μ.prod ν).map measurable_snd.aemeasurable = ν 
goal: (μ.prod ν).map ⋯ = ν

full_name: MeasureTheory.ProbabilityMeasure.map_prod_map
code: lemma map_prod_map {α' : Type*} [MeasurableSpace α'] {β' : Type*} [MeasurableSpace β']
    {f : α → α'} {g : β → β'} (f_mble : Measurable f) (g_mble : Measurable g) :
    (μ.map f_mble.aemeasurable).prod (ν.map g_mble.aemeasurable)
      = (μ.prod ν).map (f_mble.prod_map g_mble).aemeasurable 
goal: (μ.map ⋯).prod (ν.map ⋯) = (μ.prod ν).map ⋯

full_name: MeasureTheory.ProbabilityMeasure.prod_swap
code: lemma prod_swap : (μ.prod ν).map measurable_swap.aemeasurable = ν.prod μ 
goal: (μ.prod ν).map ⋯ = ν.prod μ