File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

full_name: IsPiSystem.prod
code: /-- Rectangles formed by π-systems form a π-system. -/
theorem IsPiSystem.prod {C : Set (Set α)} {D : Set (Set β)} (hC : IsPiSystem C)
    (hD : IsPiSystem D) : IsPiSystem (image2 (· ×ˢ ·) C D) 
goal: IsPiSystem (Set.image2 (fun x x_1 => x ×ˢ x_1) C D)

full_name: IsCountablySpanning.prod
code: /-- Rectangles of countably spanning sets are countably spanning. -/
theorem IsCountablySpanning.prod {C : Set (Set α)} {D : Set (Set β)} (hC : IsCountablySpanning C)
    (hD : IsCountablySpanning D) : IsCountablySpanning (image2 (· ×ˢ ·) C D) 
goal: IsCountablySpanning (Set.image2 (fun x x_1 => x ×ˢ x_1) C D)

full_name: generateFrom_prod_eq
code: /-- The product of generated σ-algebras is the one generated by rectangles, if both generating sets
  are countably spanning. -/
theorem generateFrom_prod_eq {α β} {C : Set (Set α)} {D : Set (Set β)} (hC : IsCountablySpanning C)
    (hD : IsCountablySpanning D) :
    @Prod.instMeasurableSpace _ _ (generateFrom C) (generateFrom D) =
      generateFrom (image2 (· ×ˢ ·) C D) 
goal: Prod.instMeasurableSpace = MeasurableSpace.generateFrom (Set.image2 (fun x x_1 => x ×ˢ x_1) C D)

full_name: generateFrom_eq_prod
code: /-- If `C` and `D` generate the σ-algebras on `α` resp. `β`, then rectangles formed by `C` and `D`
  generate the σ-algebra on `α × β`. -/
theorem generateFrom_eq_prod {C : Set (Set α)} {D : Set (Set β)} (hC : generateFrom C = ‹_›)
    (hD : generateFrom D = ‹_›) (h2C : IsCountablySpanning C) (h2D : IsCountablySpanning D) :
    generateFrom (image2 (· ×ˢ ·) C D) = Prod.instMeasurableSpace 
goal: MeasurableSpace.generateFrom (Set.image2 (fun x x_1 => x ×ˢ x_1) C D) = Prod.instMeasurableSpace

full_name: generateFrom_prod
code: /-- The product σ-algebra is generated from boxes, i.e. `s ×ˢ t` for sets `s : Set α` and
  `t : Set β`. -/
theorem generateFrom_prod :
    generateFrom (image2 (· ×ˢ ·) { s : Set α | MeasurableSet s } { t : Set β | MeasurableSet t }) =
      Prod.instMeasurableSpace 
goal: MeasurableSpace.generateFrom (Set.image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t}) =
  Prod.instMeasurableSpace

full_name: isPiSystem_prod
code: /-- Rectangles form a π-system. -/
theorem isPiSystem_prod :
    IsPiSystem (image2 (· ×ˢ ·) { s : Set α | MeasurableSet s } { t : Set β | MeasurableSet t }) 
goal: IsPiSystem (Set.image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t})

full_name: measurable_measure_prod_mk_left_finite
code: /-- If `ν` is a finite measure, and `s ⊆ α × β` is measurable, then `x ↦ ν { y | (x, y) ∈ s }` is
  a measurable function. `measurable_measure_prod_mk_left` is strictly more general. -/
theorem measurable_measure_prod_mk_left_finite [IsFiniteMeasure ν] {s : Set (α × β)}
    (hs : MeasurableSet s) : Measurable fun x => ν (Prod.mk x ⁻¹' s) 
goal: Measurable fun x => ν (Prod.mk x ⁻¹' s)

full_name: measurable_measure_prod_mk_left
code: /-- If `ν` is an s-finite measure, and `s ⊆ α × β` is measurable, then `x ↦ ν { y | (x, y) ∈ s }`
  is a measurable function. -/
theorem measurable_measure_prod_mk_left [SFinite ν] {s : Set (α × β)} (hs : MeasurableSet s) :
    Measurable fun x => ν (Prod.mk x ⁻¹' s) 
goal: Measurable fun x => ν (Prod.mk x ⁻¹' s)

full_name: measurable_measure_prod_mk_right
code: /-- If `μ` is a σ-finite measure, and `s ⊆ α × β` is measurable, then `y ↦ μ { x | (x, y) ∈ s }` is
  a measurable function. -/
theorem measurable_measure_prod_mk_right {μ : Measure α} [SFinite μ] {s : Set (α × β)}
    (hs : MeasurableSet s) : Measurable fun y => μ ((fun x => (x, y)) ⁻¹' s) 
goal: Measurable fun y => μ ((fun x => (x, y)) ⁻¹' s)

full_name: Measurable.map_prod_mk_left
code: theorem Measurable.map_prod_mk_left [SFinite ν] :
    Measurable fun x : α => map (Prod.mk x) ν 
goal: Measurable fun x => MeasureTheory.Measure.map (Prod.mk x) ν

full_name: Measurable.map_prod_mk_right
code: theorem Measurable.map_prod_mk_right {μ : Measure α} [SFinite μ] :
    Measurable fun y : β => map (fun x : α => (x, y)) μ 
goal: Measurable fun y => MeasureTheory.Measure.map (fun x => (x, y)) μ

full_name: MeasurableEmbedding.prod_mk
code: theorem MeasurableEmbedding.prod_mk {α β γ δ : Type*} {mα : MeasurableSpace α}
    {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} {f : α → β}
    {g : γ → δ} (hg : MeasurableEmbedding g) (hf : MeasurableEmbedding f) :
    MeasurableEmbedding fun x : γ × α => (g x.1, f x.2) 
goal: MeasurableEmbedding fun x => (g x.1, f x.2)

full_name: MeasurableEmbedding.prod_mk_left
code: lemma MeasurableEmbedding.prod_mk_left {β γ : Type*} [MeasurableSingletonClass α]
    {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
    (x : α) {f : γ → β} (hf : MeasurableEmbedding f) :
    MeasurableEmbedding (fun y ↦ (x, f y)) 
goal: MeasurableEmbedding fun y => (x, f y)

full_name: measurableEmbedding_prod_mk_left
code: lemma measurableEmbedding_prod_mk_left [MeasurableSingletonClass α] (x : α) :
    MeasurableEmbedding (Prod.mk x : β → α × β) 
goal: MeasurableEmbedding (Prod.mk x)

full_name: MeasurableEmbedding.prod_mk_right
code: lemma MeasurableEmbedding.prod_mk_right {β γ : Type*} [MeasurableSingletonClass α]
    {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
    {f : γ → β} (hf : MeasurableEmbedding f) (x : α) :
    MeasurableEmbedding (fun y ↦ (f y, x)) 
goal: MeasurableEmbedding fun y => (f y, x)

full_name: measurableEmbedding_prod_mk_right
code: lemma measurableEmbedding_prod_mk_right [MeasurableSingletonClass α] (x : α) :
    MeasurableEmbedding (fun y ↦ (y, x) : β → β × α) 
goal: MeasurableEmbedding fun y => (y, x)

full_name: Measurable.lintegral_prod_right'
code: /-- The Lebesgue integral is measurable. This shows that the integrand of (the right-hand-side of)
  Tonelli's theorem is measurable. -/
theorem Measurable.lintegral_prod_right' [SFinite ν] :
    ∀ {f : α × β → ℝ≥0∞}, Measurable f → Measurable fun x => ∫⁻ y, f (x, y) ∂ν 
goal: Measurable f → Measurable fun x => ∫⁻ (y : β), f (x, y) ∂ν

full_name: Measurable.lintegral_prod_right
code: /-- The Lebesgue integral is measurable. This shows that the integrand of (the right-hand-side of)
  Tonelli's theorem is measurable.
  This version has the argument `f` in curried form. -/
theorem Measurable.lintegral_prod_right [SFinite ν] {f : α → β → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun x => ∫⁻ y, f x y ∂ν 
goal: Measurable fun x => ∫⁻ (y : β), f x y ∂ν

full_name: Measurable.lintegral_prod_left'
code: /-- The Lebesgue integral is measurable. This shows that the integrand of (the right-hand-side of)
  the symmetric version of Tonelli's theorem is measurable. -/
theorem Measurable.lintegral_prod_left' [SFinite μ] {f : α × β → ℝ≥0∞} (hf : Measurable f) :
    Measurable fun y => ∫⁻ x, f (x, y) ∂μ 
goal: Measurable fun y => ∫⁻ (x : α), f (x, y) ∂μ

full_name: Measurable.lintegral_prod_left
code: /-- The Lebesgue integral is measurable. This shows that the integrand of (the right-hand-side of)
  the symmetric version of Tonelli's theorem is measurable.
  This version has the argument `f` in curried form. -/
theorem Measurable.lintegral_prod_left [SFinite μ] {f : α → β → ℝ≥0∞}
    (hf : Measurable (uncurry f)) : Measurable fun y => ∫⁻ x, f x y ∂μ 
goal: Measurable fun y => ∫⁻ (x : α), f x y ∂μ

full_name: MeasureTheory.Measure.definition._@.Mathlib.MeasureTheory.Constructions.Prod.Basic._hyg.3239
code: /-- The binary product of measures. They are defined for arbitrary measures, but we basically
  prove all properties under the assumption that at least one of them is s-finite. -/
protected irreducible_def prod (μ : Measure α) (ν : Measure β) : Measure (α × β) 
goal: MeasureTheory.Measure (α × β)

full_name: MeasureTheory.Measure.wrapped._@.Mathlib.MeasureTheory.Constructions.Prod.Basic._hyg.3239
code: /-- The binary product of measures. They are defined for arbitrary measures, but we basically
  prove all properties under the assumption that at least one of them is s-finite. -/
protected irreducible_def prod (μ : Measure α) (ν : Measure β) : Measure (α × β) 
goal: Subtype (Eq @MeasureTheory.Measure.definition✝)

full_name: MeasureTheory.Measure.prod
code: /-- The binary product of measures. They are defined for arbitrary measures, but we basically
  prove all properties under the assumption that at least one of them is s-finite. -/
protected irreducible_def prod (μ : Measure α) (ν : Measure β) : Measure (α × β) 
goal: MeasureTheory.Measure (α × β)

full_name: MeasureTheory.Measure.prod_def
code: /-- The binary product of measures. They are defined for arbitrary measures, but we basically
  prove all properties under the assumption that at least one of them is s-finite. -/
protected irreducible_def prod (μ : Measure α) (ν : Measure β) : Measure (α × β) 
goal: μ.prod ν = μ.bind fun x => MeasureTheory.Measure.map (Prod.mk x) ν

full_name: MeasureTheory.Measure.prod.measureSpace
code: instance prod.measureSpace {α β} [MeasureSpace α] [MeasureSpace β] : MeasureSpace (α × β) 
goal: MeasureTheory.MeasureSpace (α × β)

full_name: MeasureTheory.Measure.volume_eq_prod
code: theorem volume_eq_prod (α β) [MeasureSpace α] [MeasureSpace β] :
    (volume : Measure (α × β)) = (volume : Measure α).prod (volume : Measure β) 
goal: MeasureTheory.volume = MeasureTheory.volume.prod MeasureTheory.volume

full_name: MeasureTheory.Measure.prod_apply
code: theorem prod_apply {s : Set (α × β)} (hs : MeasurableSet s) :
    μ.prod ν s = ∫⁻ x, ν (Prod.mk x ⁻¹' s) ∂μ 
goal: (μ.prod ν) s = ∫⁻ (x : α), ν (Prod.mk x ⁻¹' s) ∂μ

full_name: MeasureTheory.Measure.prod_prod
code: /-- The product measure of the product of two sets is the product of their measures. Note that we
do not need the sets to be measurable. -/
@[simp]
theorem prod_prod (s : Set α) (t : Set β) : μ.prod ν (s ×ˢ t) = μ s * ν t 
goal: (μ.prod ν) (s ×ˢ t) = μ s * ν t

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

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

full_name: MeasureTheory.Measure.prod.instIsOpenPosMeasure
code: instance prod.instIsOpenPosMeasure {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    {m : MeasurableSpace X} {μ : Measure X} [IsOpenPosMeasure μ] {m' : MeasurableSpace Y}
    {ν : Measure Y} [IsOpenPosMeasure ν] [SFinite ν] : IsOpenPosMeasure (μ.prod ν) 
goal: (μ.prod ν).IsOpenPosMeasure

full_name: MeasureTheory.Measure.instIsOpenPosMeasureProdVolumeOfSFinite
code: instance {X Y : Type*}
    [TopologicalSpace X] [MeasureSpace X] [IsOpenPosMeasure (volume : Measure X)]
    [TopologicalSpace Y] [MeasureSpace Y] [IsOpenPosMeasure (volume : Measure Y)]
    [SFinite (volume : Measure Y)] : IsOpenPosMeasure (volume : Measure (X × Y)) 
goal: MeasureTheory.volume.IsOpenPosMeasure

full_name: MeasureTheory.Measure.prod.instIsFiniteMeasure
code: instance prod.instIsFiniteMeasure {α β : Type*} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
    (μ : Measure α) (ν : Measure β) [IsFiniteMeasure μ] [IsFiniteMeasure ν] :
    IsFiniteMeasure (μ.prod ν) 
goal: MeasureTheory.IsFiniteMeasure (μ.prod ν)

full_name: MeasureTheory.Measure.instIsFiniteMeasureProdVolume
code: instance {α β : Type*} [MeasureSpace α] [MeasureSpace β] [IsFiniteMeasure (volume : Measure α)]
    [IsFiniteMeasure (volume : Measure β)] : IsFiniteMeasure (volume : Measure (α × β)) 
goal: MeasureTheory.IsFiniteMeasure MeasureTheory.volume

full_name: MeasureTheory.Measure.prod.instIsProbabilityMeasure
code: instance prod.instIsProbabilityMeasure {α β : Type*} {mα : MeasurableSpace α}
    {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β) [IsProbabilityMeasure μ]
    [IsProbabilityMeasure ν] : IsProbabilityMeasure (μ.prod ν) 
goal: MeasureTheory.IsProbabilityMeasure (μ.prod ν)

full_name: MeasureTheory.Measure.instIsProbabilityMeasureProdVolume
code: instance {α β : Type*} [MeasureSpace α] [MeasureSpace β]
    [IsProbabilityMeasure (volume : Measure α)] [IsProbabilityMeasure (volume : Measure β)] :
    IsProbabilityMeasure (volume : Measure (α × β)) 
goal: MeasureTheory.IsProbabilityMeasure MeasureTheory.volume

full_name: MeasureTheory.Measure.prod.instIsFiniteMeasureOnCompacts
code: instance prod.instIsFiniteMeasureOnCompacts {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
    {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (μ : Measure α) (ν : Measure β)
    [IsFiniteMeasureOnCompacts μ] [IsFiniteMeasureOnCompacts ν] [SFinite ν] :
    IsFiniteMeasureOnCompacts (μ.prod ν) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts (μ.prod ν)

full_name: MeasureTheory.Measure.instIsFiniteMeasureOnCompactsProdVolumeOfSFinite
code: instance {X Y : Type*}
    [TopologicalSpace X] [MeasureSpace X] [IsFiniteMeasureOnCompacts (volume : Measure X)]
    [TopologicalSpace Y] [MeasureSpace Y] [IsFiniteMeasureOnCompacts (volume : Measure Y)]
    [SFinite (volume : Measure Y)] : IsFiniteMeasureOnCompacts (volume : Measure (X × Y)) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts MeasureTheory.volume

full_name: MeasureTheory.Measure.prod.instNoAtoms_fst
code: instance prod.instNoAtoms_fst [NoAtoms μ] :
    NoAtoms (Measure.prod μ ν) 
goal: MeasureTheory.NoAtoms (μ.prod ν)

full_name: MeasureTheory.Measure.prod.instNoAtoms_snd
code: instance prod.instNoAtoms_snd [NoAtoms ν] :
    NoAtoms (Measure.prod μ ν) 
goal: MeasureTheory.NoAtoms (μ.prod ν)

full_name: MeasureTheory.Measure.ae_measure_lt_top
code: theorem ae_measure_lt_top {s : Set (α × β)} (hs : MeasurableSet s) (h2s : (μ.prod ν) s ≠ ∞) :
    ∀ᵐ x ∂μ, ν (Prod.mk x ⁻¹' s) < ∞ 
goal: ∀ᵐ (x : α) ∂μ, ν (Prod.mk x ⁻¹' s) < ⊤

full_name: MeasureTheory.Measure.measure_prod_null
code: /-- Note: the assumption `hs` cannot be dropped. For a counterexample, see
  Walter Rudin *Real and Complex Analysis*, example (c) in section 8.9. -/
theorem measure_prod_null {s : Set (α × β)} (hs : MeasurableSet s) :
    μ.prod ν s = 0 ↔ (fun x => ν (Prod.mk x ⁻¹' s)) =ᵐ[μ] 0 
goal: (μ.prod ν) s = 0 ↔ (fun x => ν (Prod.mk x ⁻¹' s)) =ᵐ[μ] 0

full_name: MeasureTheory.Measure.measure_ae_null_of_prod_null
code: /-- Note: the converse is not true without assuming that `s` is measurable. For a counterexample,
  see Walter Rudin *Real and Complex Analysis*, example (c) in section 8.9. -/
theorem measure_ae_null_of_prod_null {s : Set (α × β)} (h : μ.prod ν s = 0) :
    (fun x => ν (Prod.mk x ⁻¹' s)) =ᵐ[μ] 0 
goal: (fun x => ν (Prod.mk x ⁻¹' s)) =ᵐ[μ] 0

full_name: MeasureTheory.Measure.AbsolutelyContinuous.prod
code: theorem AbsolutelyContinuous.prod [SFinite ν'] (h1 : μ ≪ μ') (h2 : ν ≪ ν') :
    μ.prod ν ≪ μ'.prod ν' 
goal: μ.prod ν ≪ μ'.prod ν'

full_name: MeasureTheory.Measure.ae_ae_of_ae_prod
code: /-- Note: the converse is not true. For a counterexample, see
  Walter Rudin *Real and Complex Analysis*, example (c) in section 8.9. It is true if the set is
  measurable, see `ae_prod_mem_iff_ae_ae_mem`. -/
theorem ae_ae_of_ae_prod {p : α × β → Prop} (h : ∀ᵐ z ∂μ.prod ν, p z) :
    ∀ᵐ x ∂μ, ∀ᵐ y ∂ν, p (x, y) 
goal: ∀ᵐ (x : α) ∂μ, ∀ᵐ (y : β) ∂ν, p (x, y)

full_name: MeasureTheory.Measure.ae_ae_eq_curry_of_prod
code: theorem ae_ae_eq_curry_of_prod {f g : α × β → γ} (h : f =ᵐ[μ.prod ν] g) :
    ∀ᵐ x ∂μ, curry f x =ᵐ[ν] curry g x 
goal: ∀ᵐ (x : α) ∂μ, Function.curry f x =ᵐ[ν] Function.curry g x

full_name: MeasureTheory.Measure.ae_ae_eq_of_ae_eq_uncurry
code: theorem ae_ae_eq_of_ae_eq_uncurry {f g : α → β → γ} (h : uncurry f =ᵐ[μ.prod ν] uncurry g) :
    ∀ᵐ x ∂μ, f x =ᵐ[ν] g x 
goal: ∀ᵐ (x : α) ∂μ, f x =ᵐ[ν] g x

full_name: MeasureTheory.Measure.ae_prod_mem_iff_ae_ae_mem
code: theorem ae_prod_mem_iff_ae_ae_mem {s : Set (α × β)} (hs : MeasurableSet s) :
    (∀ᵐ z ∂μ.prod ν, z ∈ s) ↔ ∀ᵐ x ∂μ, ∀ᵐ y ∂ν, (x, y) ∈ s 
goal: (∀ᵐ (z : α × β) ∂μ.prod ν, z ∈ s) ↔ ∀ᵐ (x : α) ∂μ, ∀ᵐ (y : β) ∂ν, (x, y) ∈ s

full_name: MeasureTheory.Measure.quasiMeasurePreserving_fst
code: theorem quasiMeasurePreserving_fst : QuasiMeasurePreserving Prod.fst (μ.prod ν) μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving Prod.fst (μ.prod ν) μ

full_name: MeasureTheory.Measure.quasiMeasurePreserving_snd
code: theorem quasiMeasurePreserving_snd : QuasiMeasurePreserving Prod.snd (μ.prod ν) ν 
goal: MeasureTheory.Measure.QuasiMeasurePreserving Prod.snd (μ.prod ν) ν

full_name: MeasureTheory.Measure.set_prod_ae_eq
code: lemma set_prod_ae_eq {s s' : Set α} {t t' : Set β} (hs : s =ᵐ[μ] s') (ht : t =ᵐ[ν] t') :
    (s ×ˢ t : Set (α × β)) =ᵐ[μ.prod ν] (s' ×ˢ t' : Set (α × β)) 
goal: s ×ˢ t =ᵐ[μ.prod ν] s' ×ˢ t'

full_name: MeasureTheory.Measure.measure_prod_compl_eq_zero
code: lemma measure_prod_compl_eq_zero {s : Set α} {t : Set β}
    (s_ae_univ : μ sᶜ = 0) (t_ae_univ : ν tᶜ = 0) :
    μ.prod ν (s ×ˢ t)ᶜ = 0 
goal: (μ.prod ν) (s ×ˢ t)ᶜ = 0

full_name: MeasureTheory.NullMeasurableSet.prod
code: lemma _root_.MeasureTheory.NullMeasurableSet.prod {s : Set α} {t : Set β}
    (s_mble : NullMeasurableSet s μ) (t_mble : NullMeasurableSet t ν) :
    NullMeasurableSet (s ×ˢ t) (μ.prod ν) 
goal: MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν)

full_name: MeasureTheory.NullMeasurableSet.right_of_prod
code: /-- If `s ×ˢ t` is a null measurable set and `μ s ≠ 0`, then `t` is a null measurable set. -/
lemma _root_.MeasureTheory.NullMeasurableSet.right_of_prod {s : Set α} {t : Set β}
    (h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)) (hs : μ s ≠ 0) : NullMeasurableSet t ν 
goal: MeasureTheory.NullMeasurableSet t ν

full_name: MeasureTheory.NullMeasurableSet.of_preimage_snd
code: /-- If `Prod.snd ⁻¹' t` is a null measurable set and `μ ≠ 0`, then `t` is a null measurable set. -/
lemma _root_.MeasureTheory.NullMeasurableSet.of_preimage_snd [NeZero μ] {t : Set β}
    (h : NullMeasurableSet (Prod.snd ⁻¹' t) (μ.prod ν)) : NullMeasurableSet t ν 
goal: MeasureTheory.NullMeasurableSet t ν

full_name: MeasureTheory.Measure.nullMeasurableSet_preimage_snd
code: /-- `Prod.snd ⁻¹' t` is null measurable w.r.t. `μ.prod ν` iff `t` is null measurable w.r.t. `ν`
provided that `μ ≠ 0`. -/
lemma nullMeasurableSet_preimage_snd [NeZero μ] {t : Set β} :
    NullMeasurableSet (Prod.snd ⁻¹' t) (μ.prod ν) ↔ NullMeasurableSet t ν 
goal: MeasureTheory.NullMeasurableSet (Prod.snd ⁻¹' t) (μ.prod ν) ↔ MeasureTheory.NullMeasurableSet t ν

full_name: MeasureTheory.Measure.nullMeasurable_comp_snd
code: lemma nullMeasurable_comp_snd [NeZero μ] {f : β → γ} :
    NullMeasurable (f ∘ Prod.snd) (μ.prod ν) ↔ NullMeasurable f ν 
goal: MeasureTheory.NullMeasurable (f ∘ Prod.snd) (μ.prod ν) ↔ MeasureTheory.NullMeasurable f ν

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.prod
code: /-- `μ.prod ν` has finite spanning sets in rectangles of finite spanning sets. -/
noncomputable def FiniteSpanningSetsIn.prod {ν : Measure β} {C : Set (Set α)} {D : Set (Set β)}
    (hμ : μ.FiniteSpanningSetsIn C) (hν : ν.FiniteSpanningSetsIn D) :
    (μ.prod ν).FiniteSpanningSetsIn (image2 (· ×ˢ ·) C D) 
goal: (μ.prod ν).FiniteSpanningSetsIn (Set.image2 (fun x x_1 => x ×ˢ x_1) C D)

full_name: MeasureTheory.Measure.prod_sum_left
code: lemma prod_sum_left {ι : Type*} (m : ι → Measure α) (μ : Measure β) [SFinite μ] :
    (Measure.sum m).prod μ = Measure.sum (fun i ↦ (m i).prod μ) 
goal: (MeasureTheory.Measure.sum m).prod μ = MeasureTheory.Measure.sum fun i => (m i).prod μ

full_name: MeasureTheory.Measure.prod_sum_right
code: lemma prod_sum_right {ι' : Type*} [Countable ι'] (m : Measure α) (m' : ι' → Measure β)
    [∀ n, SFinite (m' n)] :
    m.prod (Measure.sum m') = Measure.sum (fun p ↦ m.prod (m' p)) 
goal: m.prod (MeasureTheory.Measure.sum m') = MeasureTheory.Measure.sum fun p => m.prod (m' p)

full_name: MeasureTheory.Measure.prod_sum
code: lemma prod_sum {ι ι' : Type*} [Countable ι'] (m : ι → Measure α) (m' : ι' → Measure β)
    [∀ n, SFinite (m' n)] :
    (Measure.sum m).prod (Measure.sum m') =
      Measure.sum (fun (p : ι × ι') ↦ (m p.1).prod (m' p.2)) 
goal: (MeasureTheory.Measure.sum m).prod (MeasureTheory.Measure.sum m') =
  MeasureTheory.Measure.sum fun p => (m p.1).prod (m' p.2)

full_name: MeasureTheory.Measure.prod.instSigmaFinite
code: instance prod.instSigmaFinite {α β : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SigmaFinite μ] {_ : MeasurableSpace β} {ν : Measure β} [SigmaFinite ν] :
    SigmaFinite (μ.prod ν) 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SigmaFinite μ] {x_1 : MeasurableSpace β}
  {ν : MeasureTheory.Measure β} [inst : MeasureTheory.SigmaFinite ν], MeasureTheory.SigmaFinite (μ.prod ν)

full_name: MeasureTheory.Measure.prod.instSFinite
code: instance prod.instSFinite {α β : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] {_ : MeasurableSpace β} {ν : Measure β} [SFinite ν] :
    SFinite (μ.prod ν) 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ] {x_1 : MeasurableSpace β}
  {ν : MeasureTheory.Measure β} [inst : MeasureTheory.SFinite ν], MeasureTheory.SFinite (μ.prod ν)

full_name: MeasureTheory.Measure.instSigmaFiniteProdVolume
code: instance {α β} [MeasureSpace α] [SigmaFinite (volume : Measure α)]
    [MeasureSpace β] [SigmaFinite (volume : Measure β)] : SigmaFinite (volume : Measure (α × β)) 
goal: MeasureTheory.SigmaFinite MeasureTheory.volume

full_name: MeasureTheory.Measure.instSFiniteProdVolume
code: instance {α β} [MeasureSpace α] [SFinite (volume : Measure α)]
    [MeasureSpace β] [SFinite (volume : Measure β)] : SFinite (volume : Measure (α × β)) 
goal: MeasureTheory.SFinite MeasureTheory.volume

full_name: MeasureTheory.Measure.prod_eq_generateFrom
code: /-- A measure on a product space equals the product measure if they are equal on rectangles
  with as sides sets that generate the corresponding σ-algebras. -/
theorem prod_eq_generateFrom {μ : Measure α} {ν : Measure β} {C : Set (Set α)} {D : Set (Set β)}
    (hC : generateFrom C = ‹_›) (hD : generateFrom D = ‹_›) (h2C : IsPiSystem C)
    (h2D : IsPiSystem D) (h3C : μ.FiniteSpanningSetsIn C) (h3D : ν.FiniteSpanningSetsIn D)
    {μν : Measure (α × β)} (h₁ : ∀ s ∈ C, ∀ t ∈ D, μν (s ×ˢ t) = μ s * ν t) : μ.prod ν = μν 
goal: μ.prod ν = μν

full_name: MeasureTheory.Measure.prod_eq
code: /-- A measure on a product space equals the product measure of sigma-finite measures if they are
equal on rectangles. -/
theorem prod_eq {μ : Measure α} [SigmaFinite μ] {ν : Measure β} [SigmaFinite ν]
    {μν : Measure (α × β)}
    (h : ∀ s t, MeasurableSet s → MeasurableSet t → μν (s ×ˢ t) = μ s * ν t) : μ.prod ν = μν 
goal: μ.prod ν = μν

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

full_name: MeasureTheory.Measure.measurePreserving_swap
code: theorem measurePreserving_swap : MeasurePreserving Prod.swap (μ.prod ν) (ν.prod μ) 
goal: MeasureTheory.MeasurePreserving Prod.swap (μ.prod ν) (ν.prod μ)

full_name: MeasureTheory.Measure.prod_apply_symm
code: theorem prod_apply_symm {s : Set (α × β)} (hs : MeasurableSet s) :
    μ.prod ν s = ∫⁻ y, μ ((fun x => (x, y)) ⁻¹' s) ∂ν 
goal: (μ.prod ν) s = ∫⁻ (y : β), μ ((fun x => (x, y)) ⁻¹' s) ∂ν

full_name: MeasureTheory.NullMeasurableSet.left_of_prod
code: /-- If `s ×ˢ t` is a null measurable set and `ν t ≠ 0`, then `s` is a null measurable set. -/
lemma _root_.MeasureTheory.NullMeasurableSet.left_of_prod {s : Set α} {t : Set β}
    (h : NullMeasurableSet (s ×ˢ t) (μ.prod ν)) (ht : ν t ≠ 0) : NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet s μ

full_name: MeasureTheory.NullMeasurableSet.of_preimage_fst
code: /-- If `Prod.fst ⁻¹' s` is a null measurable set and `ν ≠ 0`, then `s` is a null measurable set. -/
lemma _root_.MeasureTheory.NullMeasurableSet.of_preimage_fst [NeZero ν] {s : Set α}
    (h : NullMeasurableSet (Prod.fst ⁻¹' s) (μ.prod ν)) : NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet s μ

full_name: MeasureTheory.Measure.nullMeasurableSet_preimage_fst
code: /-- `Prod.fst ⁻¹' s` is null measurable w.r.t. `μ.prod ν` iff `s` is null measurable w.r.t. `μ`
provided that `ν ≠ 0`. -/
lemma nullMeasurableSet_preimage_fst [NeZero ν] {s : Set α} :
    NullMeasurableSet (Prod.fst ⁻¹' s) (μ.prod ν) ↔ NullMeasurableSet s μ 
goal: MeasureTheory.NullMeasurableSet (Prod.fst ⁻¹' s) (μ.prod ν) ↔ MeasureTheory.NullMeasurableSet s μ

full_name: MeasureTheory.Measure.nullMeasurable_comp_fst
code: lemma nullMeasurable_comp_fst [NeZero ν] {f : α → γ} :
    NullMeasurable (f ∘ Prod.fst) (μ.prod ν) ↔ NullMeasurable f μ 
goal: MeasureTheory.NullMeasurable (f ∘ Prod.fst) (μ.prod ν) ↔ MeasureTheory.NullMeasurable f μ

full_name: MeasureTheory.Measure.nullMeasurableSet_prod_of_ne_zero
code: /-- The product of two non-null sets is null measurable
if and only if both of them are null measurable. -/
lemma nullMeasurableSet_prod_of_ne_zero {s : Set α} {t : Set β} (hs : μ s ≠ 0) (ht : ν t ≠ 0) :
    NullMeasurableSet (s ×ˢ t) (μ.prod ν) ↔ NullMeasurableSet s μ ∧ NullMeasurableSet t ν 
goal: MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν) ↔
  MeasureTheory.NullMeasurableSet s μ ∧ MeasureTheory.NullMeasurableSet t ν

full_name: MeasureTheory.Measure.nullMeasurableSet_prod
code: /-- The product of two sets is null measurable
if and only if both of them are null measurable or one of them has measure zero. -/
lemma nullMeasurableSet_prod {s : Set α} {t : Set β} :
    NullMeasurableSet (s ×ˢ t) (μ.prod ν) ↔
      NullMeasurableSet s μ ∧ NullMeasurableSet t ν ∨ μ s = 0 ∨ ν t = 0 
goal: MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν) ↔
  MeasureTheory.NullMeasurableSet s μ ∧ MeasureTheory.NullMeasurableSet t ν ∨ μ s = 0 ∨ ν t = 0

full_name: MeasureTheory.Measure.prodAssoc_prod
code: theorem prodAssoc_prod [SFinite τ] :
    map MeasurableEquiv.prodAssoc ((μ.prod ν).prod τ) = μ.prod (ν.prod τ) 
goal: MeasureTheory.Measure.map (⇑MeasurableEquiv.prodAssoc) ((μ.prod ν).prod τ) = μ.prod (ν.prod τ)

full_name: MeasureTheory.Measure.prod_restrict
code: theorem prod_restrict (s : Set α) (t : Set β) :
    (μ.restrict s).prod (ν.restrict t) = (μ.prod ν).restrict (s ×ˢ t) 
goal: (μ.restrict s).prod (ν.restrict t) = (μ.prod ν).restrict (s ×ˢ t)

full_name: MeasureTheory.Measure.restrict_prod_eq_prod_univ
code: theorem restrict_prod_eq_prod_univ (s : Set α) :
    (μ.restrict s).prod ν = (μ.prod ν).restrict (s ×ˢ univ) 
goal: (μ.restrict s).prod ν = (μ.prod ν).restrict (s ×ˢ Set.univ)

full_name: MeasureTheory.Measure.prod_dirac
code: theorem prod_dirac (y : β) : μ.prod (dirac y) = map (fun x => (x, y)) μ 
goal: μ.prod (MeasureTheory.Measure.dirac y) = MeasureTheory.Measure.map (fun x => (x, y)) μ

full_name: MeasureTheory.Measure.dirac_prod
code: theorem dirac_prod (x : α) : (dirac x).prod ν = map (Prod.mk x) ν 
goal: (MeasureTheory.Measure.dirac x).prod ν = MeasureTheory.Measure.map (Prod.mk x) ν

full_name: MeasureTheory.Measure.dirac_prod_dirac
code: theorem dirac_prod_dirac {x : α} {y : β} : (dirac x).prod (dirac y) = dirac (x, y) 
goal: (MeasureTheory.Measure.dirac x).prod (MeasureTheory.Measure.dirac y) = MeasureTheory.Measure.dirac (x, y)

full_name: MeasureTheory.Measure.prod_add
code: theorem prod_add (ν' : Measure β) [SFinite ν'] : μ.prod (ν + ν') = μ.prod ν + μ.prod ν' 
goal: μ.prod (ν + ν') = μ.prod ν + μ.prod ν'

full_name: MeasureTheory.Measure.add_prod
code: theorem add_prod (μ' : Measure α) [SFinite μ'] : (μ + μ').prod ν = μ.prod ν + μ'.prod ν 
goal: (μ + μ').prod ν = μ.prod ν + μ'.prod ν

full_name: MeasureTheory.Measure.zero_prod
code: @[simp]
theorem zero_prod (ν : Measure β) : (0 : Measure α).prod ν = 0 
goal: MeasureTheory.Measure.prod 0 ν = 0

full_name: MeasureTheory.Measure.prod_zero
code: @[simp]
theorem prod_zero (μ : Measure α) : μ.prod (0 : Measure β) = 0 
goal: μ.prod 0 = 0

full_name: MeasureTheory.Measure.map_prod_map
code: theorem map_prod_map {δ} [MeasurableSpace δ] {f : α → β} {g : γ → δ} (μa : Measure α)
    (μc : Measure γ) [SFinite μa] [SFinite μc] (hf : Measurable f) (hg : Measurable g) :
    (map f μa).prod (map g μc) = map (Prod.map f g) (μa.prod μc) 
goal: (MeasureTheory.Measure.map f μa).prod (MeasureTheory.Measure.map g μc) =
  MeasureTheory.Measure.map (Prod.map f g) (μa.prod μc)

full_name: MeasureTheory.MeasurePreserving.skew_product
code: theorem skew_product [SFinite μa] [SFinite μc] {f : α → β} (hf : MeasurePreserving f μa μb)
    {g : α → γ → δ} (hgm : Measurable (uncurry g)) (hg : ∀ᵐ x ∂μa, map (g x) μc = μd) :
    MeasurePreserving (fun p : α × γ => (f p.1, g p.1 p.2)) (μa.prod μc) (μb.prod μd) 
goal: MeasureTheory.MeasurePreserving (fun p => (f p.1, g p.1 p.2)) (μa.prod μc) (μb.prod μd)

full_name: MeasureTheory.MeasurePreserving.prod
code: /-- If `f : α → β` sends the measure `μa` to `μb` and `g : γ → δ` sends the measure `μc` to `μd`,
then `Prod.map f g` sends `μa.prod μc` to `μb.prod μd`. -/
protected theorem prod [SFinite μa] [SFinite μc] {f : α → β} {g : γ → δ}
    (hf : MeasurePreserving f μa μb) (hg : MeasurePreserving g μc μd) :
    MeasurePreserving (Prod.map f g) (μa.prod μc) (μb.prod μd) 
goal: MeasureTheory.MeasurePreserving (Prod.map f g) (μa.prod μc) (μb.prod μd)

full_name: MeasureTheory.QuasiMeasurePreserving.prod_of_right
code: theorem prod_of_right {f : α × β → γ} {μ : Measure α} {ν : Measure β} {τ : Measure γ}
    (hf : Measurable f) [SFinite ν]
    (h2f : ∀ᵐ x ∂μ, QuasiMeasurePreserving (fun y => f (x, y)) ν τ) :
    QuasiMeasurePreserving f (μ.prod ν) τ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving f (μ.prod ν) τ

full_name: MeasureTheory.QuasiMeasurePreserving.prod_of_left
code: theorem prod_of_left {α β γ} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ]
    {f : α × β → γ} {μ : Measure α} {ν : Measure β} {τ : Measure γ} (hf : Measurable f)
    [SFinite μ] [SFinite ν]
    (h2f : ∀ᵐ y ∂ν, QuasiMeasurePreserving (fun x => f (x, y)) μ τ) :
    QuasiMeasurePreserving f (μ.prod ν) τ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving f (μ.prod ν) τ

full_name: AEMeasurable.prod_swap
code: theorem AEMeasurable.prod_swap [SFinite μ] [SFinite ν] {f : β × α → γ}
    (hf : AEMeasurable f (ν.prod μ)) : AEMeasurable (fun z : α × β => f z.swap) (μ.prod ν) 
goal: AEMeasurable (fun z => f z.swap) (μ.prod ν)

full_name: AEMeasurable.fst
code: theorem AEMeasurable.fst [SFinite ν] {f : α → γ} (hf : AEMeasurable f μ) :
    AEMeasurable (fun z : α × β => f z.1) (μ.prod ν) 
goal: AEMeasurable (fun z => f z.1) (μ.prod ν)

full_name: AEMeasurable.snd
code: theorem AEMeasurable.snd [SFinite ν] {f : β → γ} (hf : AEMeasurable f ν) :
    AEMeasurable (fun z : α × β => f z.2) (μ.prod ν) 
goal: AEMeasurable (fun z => f z.2) (μ.prod ν)

full_name: MeasureTheory.lintegral_prod_swap
code: theorem lintegral_prod_swap [SFinite μ] (f : α × β → ℝ≥0∞) :
    ∫⁻ z, f z.swap ∂ν.prod μ = ∫⁻ z, f z ∂μ.prod ν 
goal: ∫⁻ (z : β × α), f z.swap ∂ν.prod μ = ∫⁻ (z : α × β), f z ∂μ.prod ν

full_name: MeasureTheory.lintegral_prod_of_measurable
code: /-- **Tonelli's Theorem**: For `ℝ≥0∞`-valued measurable functions on `α × β`,
  the integral of `f` is equal to the iterated integral. -/
theorem lintegral_prod_of_measurable :
    ∀ (f : α × β → ℝ≥0∞), Measurable f → ∫⁻ z, f z ∂μ.prod ν = ∫⁻ x, ∫⁻ y, f (x, y) ∂ν ∂μ 
goal: Measurable f → ∫⁻ (z : α × β), f z ∂μ.prod ν = ∫⁻ (x : α), ∫⁻ (y : β), f (x, y) ∂ν ∂μ

full_name: MeasureTheory.lintegral_prod
code: /-- **Tonelli's Theorem**: For `ℝ≥0∞`-valued almost everywhere measurable functions on `α × β`,
  the integral of `f` is equal to the iterated integral. -/
theorem lintegral_prod (f : α × β → ℝ≥0∞) (hf : AEMeasurable f (μ.prod ν)) :
    ∫⁻ z, f z ∂μ.prod ν = ∫⁻ x, ∫⁻ y, f (x, y) ∂ν ∂μ 
goal: ∫⁻ (z : α × β), f z ∂μ.prod ν = ∫⁻ (x : α), ∫⁻ (y : β), f (x, y) ∂ν ∂μ

full_name: MeasureTheory.lintegral_prod_symm
code: /-- The symmetric version of Tonelli's Theorem: For `ℝ≥0∞`-valued almost everywhere measurable
functions on `α × β`, the integral of `f` is equal to the iterated integral, in reverse order. -/
theorem lintegral_prod_symm [SFinite μ] (f : α × β → ℝ≥0∞) (hf : AEMeasurable f (μ.prod ν)) :
    ∫⁻ z, f z ∂μ.prod ν = ∫⁻ y, ∫⁻ x, f (x, y) ∂μ ∂ν 
goal: ∫⁻ (z : α × β), f z ∂μ.prod ν = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν

full_name: MeasureTheory.lintegral_prod_symm'
code: /-- The symmetric version of Tonelli's Theorem: For `ℝ≥0∞`-valued measurable
functions on `α × β`, the integral of `f` is equal to the iterated integral, in reverse order. -/
theorem lintegral_prod_symm' [SFinite μ] (f : α × β → ℝ≥0∞) (hf : Measurable f) :
    ∫⁻ z, f z ∂μ.prod ν = ∫⁻ y, ∫⁻ x, f (x, y) ∂μ ∂ν 
goal: ∫⁻ (z : α × β), f z ∂μ.prod ν = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y) ∂μ ∂ν

full_name: MeasureTheory.lintegral_lintegral
code: /-- The reversed version of **Tonelli's Theorem**. In this version `f` is in curried form, which
makes it easier for the elaborator to figure out `f` automatically. -/
theorem lintegral_lintegral ⦃f : α → β → ℝ≥0∞⦄ (hf : AEMeasurable (uncurry f) (μ.prod ν)) :
    ∫⁻ x, ∫⁻ y, f x y ∂ν ∂μ = ∫⁻ z, f z.1 z.2 ∂μ.prod ν 
goal: ∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (z : α × β), f z.1 z.2 ∂μ.prod ν

full_name: MeasureTheory.lintegral_lintegral_symm
code: /-- The reversed version of **Tonelli's Theorem** (symmetric version). In this version `f` is in
curried form, which makes it easier for the elaborator to figure out `f` automatically. -/
theorem lintegral_lintegral_symm [SFinite μ] ⦃f : α → β → ℝ≥0∞⦄
    (hf : AEMeasurable (uncurry f) (μ.prod ν)) :
    ∫⁻ x, ∫⁻ y, f x y ∂ν ∂μ = ∫⁻ z, f z.2 z.1 ∂ν.prod μ 
goal: ∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (z : β × α), f z.2 z.1 ∂ν.prod μ

full_name: MeasureTheory.lintegral_lintegral_swap
code: /-- Change the order of Lebesgue integration. -/
theorem lintegral_lintegral_swap [SFinite μ] ⦃f : α → β → ℝ≥0∞⦄
    (hf : AEMeasurable (uncurry f) (μ.prod ν)) :
    ∫⁻ x, ∫⁻ y, f x y ∂ν ∂μ = ∫⁻ y, ∫⁻ x, f x y ∂μ ∂ν 
goal: ∫⁻ (x : α), ∫⁻ (y : β), f x y ∂ν ∂μ = ∫⁻ (y : β), ∫⁻ (x : α), f x y ∂μ ∂ν

full_name: MeasureTheory.lintegral_prod_mul
code: theorem lintegral_prod_mul {f : α → ℝ≥0∞} {g : β → ℝ≥0∞} (hf : AEMeasurable f μ)
    (hg : AEMeasurable g ν) : ∫⁻ z, f z.1 * g z.2 ∂μ.prod ν = (∫⁻ x, f x ∂μ) * ∫⁻ y, g y ∂ν 
goal: ∫⁻ (z : α × β), f z.1 * g z.2 ∂μ.prod ν = (∫⁻ (x : α), f x ∂μ) * ∫⁻ (y : β), g y ∂ν

full_name: MeasureTheory.Measure.fst
code: /-- Marginal measure on `α` obtained from a measure `ρ` on `α × β`, defined by `ρ.map Prod.fst`. -/
noncomputable def fst (ρ : Measure (α × β)) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.fst_apply
code: theorem fst_apply {s : Set α} (hs : MeasurableSet s) : ρ.fst s = ρ (Prod.fst ⁻¹' s) 
goal: ρ.fst s = ρ (Prod.fst ⁻¹' s)

full_name: MeasureTheory.Measure.fst_univ
code: theorem fst_univ : ρ.fst univ = ρ univ 
goal: ρ.fst Set.univ = ρ Set.univ

full_name: MeasureTheory.Measure.fst_zero
code: @[simp] theorem fst_zero : fst (0 : Measure (α × β)) = 0 
goal: MeasureTheory.Measure.fst 0 = 0

full_name: MeasureTheory.Measure.instSFiniteFstOfProd
code: instance [SFinite ρ] : SFinite ρ.fst 
goal: MeasureTheory.SFinite ρ.fst

full_name: MeasureTheory.Measure.fst.instIsFiniteMeasure
code: instance fst.instIsFiniteMeasure [IsFiniteMeasure ρ] : IsFiniteMeasure ρ.fst 
goal: MeasureTheory.IsFiniteMeasure ρ.fst

full_name: MeasureTheory.Measure.fst.instIsProbabilityMeasure
code: instance fst.instIsProbabilityMeasure [IsProbabilityMeasure ρ] : IsProbabilityMeasure ρ.fst 
goal: MeasureTheory.IsProbabilityMeasure ρ.fst

full_name: MeasureTheory.Measure.fst_prod
code: @[simp]
lemma fst_prod [IsProbabilityMeasure ν] : (μ.prod ν).fst = μ 
goal: (μ.prod ν).fst = μ

full_name: MeasureTheory.Measure.fst_map_prod_mk₀
code: theorem fst_map_prod_mk₀ {X : α → β} {Y : α → γ} {μ : Measure α}
    (hY : AEMeasurable Y μ) : (μ.map fun a => (X a, Y a)).fst = μ.map X 
goal: (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ).fst = MeasureTheory.Measure.map X μ

full_name: MeasureTheory.Measure.fst_map_prod_mk
code: theorem fst_map_prod_mk {X : α → β} {Y : α → γ} {μ : Measure α}
    (hY : Measurable Y) : (μ.map fun a => (X a, Y a)).fst = μ.map X 
goal: (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ).fst = MeasureTheory.Measure.map X μ

full_name: MeasureTheory.Measure.snd
code: /-- Marginal measure on `β` obtained from a measure on `ρ` `α × β`, defined by `ρ.map Prod.snd`. -/
noncomputable def snd (ρ : Measure (α × β)) : Measure β 
goal: MeasureTheory.Measure β

full_name: MeasureTheory.Measure.snd_apply
code: theorem snd_apply {s : Set β} (hs : MeasurableSet s) : ρ.snd s = ρ (Prod.snd ⁻¹' s) 
goal: ρ.snd s = ρ (Prod.snd ⁻¹' s)

full_name: MeasureTheory.Measure.snd_univ
code: theorem snd_univ : ρ.snd univ = ρ univ 
goal: ρ.snd Set.univ = ρ Set.univ

full_name: MeasureTheory.Measure.snd_zero
code: @[simp] theorem snd_zero : snd (0 : Measure (α × β)) = 0 
goal: MeasureTheory.Measure.snd 0 = 0

full_name: MeasureTheory.Measure.instSFiniteSndOfProd
code: instance [SFinite ρ] : SFinite ρ.snd 
goal: MeasureTheory.SFinite ρ.snd

full_name: MeasureTheory.Measure.snd.instIsFiniteMeasure
code: instance snd.instIsFiniteMeasure [IsFiniteMeasure ρ] : IsFiniteMeasure ρ.snd 
goal: MeasureTheory.IsFiniteMeasure ρ.snd

full_name: MeasureTheory.Measure.snd.instIsProbabilityMeasure
code: instance snd.instIsProbabilityMeasure [IsProbabilityMeasure ρ] : IsProbabilityMeasure ρ.snd 
goal: MeasureTheory.IsProbabilityMeasure ρ.snd

full_name: MeasureTheory.Measure.snd_prod
code: @[simp]
lemma snd_prod [IsProbabilityMeasure μ] : (μ.prod ν).snd = ν 
goal: (μ.prod ν).snd = ν

full_name: MeasureTheory.Measure.snd_map_prod_mk₀
code: theorem snd_map_prod_mk₀ {X : α → β} {Y : α → γ} {μ : Measure α} (hX : AEMeasurable X μ) :
    (μ.map fun a => (X a, Y a)).snd = μ.map Y 
goal: (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ).snd = MeasureTheory.Measure.map Y μ

full_name: MeasureTheory.Measure.snd_map_prod_mk
code: theorem snd_map_prod_mk {X : α → β} {Y : α → γ} {μ : Measure α} (hX : Measurable X) :
    (μ.map fun a => (X a, Y a)).snd = μ.map Y 
goal: (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ).snd = MeasureTheory.Measure.map Y μ

full_name: MeasureTheory.Measure.fst_map_swap
code: @[simp] lemma fst_map_swap : (ρ.map Prod.swap).fst = ρ.snd 
goal: (MeasureTheory.Measure.map Prod.swap ρ).fst = ρ.snd

full_name: MeasureTheory.Measure.snd_map_swap
code: @[simp] lemma snd_map_swap : (ρ.map Prod.swap).snd = ρ.fst 
goal: (MeasureTheory.Measure.map Prod.swap ρ).snd = ρ.fst