# The product measure #

In this file we define and prove properties about the binary product measure. If α and β have s-finite measures μ resp. ν then α × β can be equipped with a s-finite measure μ.prod ν that satisfies (μ.prod ν) s = ∫⁻ x, ν {y | (x, y) ∈ s} ∂μ. We also have (μ.prod ν) (s ×ˢ t) = μ s * ν t, i.e. the measure of a rectangle is the product of the measures of the sides.

We also prove Tonelli's theorem.

## Main definition #

• MeasureTheory.Measure.prod: The product of two measures.

## Main results #

• MeasureTheory.Measure.prod_apply states μ.prod ν s = ∫⁻ x, ν {y | (x, y) ∈ s} ∂μ for measurable s. MeasureTheory.Measure.prod_apply_symm is the reversed version.
• MeasureTheory.Measure.prod_prod states μ.prod ν (s ×ˢ t) = μ s * ν t for measurable sets s and t.
• MeasureTheory.lintegral_prod: Tonelli's theorem. It states that for a measurable function α × β → ℝ≥0∞ we have ∫⁻ z, f z ∂(μ.prod ν) = ∫⁻ x, ∫⁻ y, f (x, y) ∂ν ∂μ. The version for functions α → β → ℝ≥0∞ is reversed, and called lintegral_lintegral. Both versions have a variant with _symm appended, where the order of integration is reversed. The lemma Measurable.lintegral_prod_right' states that the inner integral of the right-hand side is measurable.

## Implementation Notes #

Many results are proven twice, once for functions in curried form (α → β → γ) and one for functions in uncurried form (α × β → γ). The former often has an assumption Measurable (uncurry f), which could be inconvenient to discharge, but for the latter it is more common that the function has to be given explicitly, since Lean cannot synthesize the function by itself. We name the lemmas about the uncurried form with a prime. Tonelli's theorem has a different naming scheme, since the version for the uncurried version is reversed.

## Tags #

product measure, Tonelli's theorem, Fubini-Tonelli theorem

theorem IsPiSystem.prod {α : Type u_1} {β : Type u_3} {C : Set (Set α)} {D : Set (Set β)} (hC : ) (hD : ) :
IsPiSystem (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) C D)

Rectangles formed by π-systems form a π-system.

theorem IsCountablySpanning.prod {α : Type u_1} {β : Type u_3} {C : Set (Set α)} {D : Set (Set β)} (hC : ) (hD : ) :
IsCountablySpanning (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) C D)

Rectangles of countably spanning sets are countably spanning.

### Measurability #

Before we define the product measure, we can talk about the measurability of operations on binary functions. We show that if f is a binary measurable function, then the function that integrates along one of the variables (using either the Lebesgue or Bochner integral) is measurable.

theorem generateFrom_prod_eq {α : Type u_7} {β : Type u_8} {C : Set (Set α)} {D : Set (Set β)} (hC : ) (hD : ) :
Prod.instMeasurableSpace = MeasurableSpace.generateFrom (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) C D)

The product of generated σ-algebras is the one generated by rectangles, if both generating sets are countably spanning.

theorem generateFrom_eq_prod {α : Type u_1} {β : Type u_3} [] [] {C : Set (Set α)} {D : Set (Set β)} (hC : = inst✝¹) (hD : ) (h2C : ) (h2D : ) :
MeasurableSpace.generateFrom (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) C D) = Prod.instMeasurableSpace

If C and D generate the σ-algebras on α resp. β, then rectangles formed by C and D generate the σ-algebra on α × β.

theorem generateFrom_prod {α : Type u_1} {β : Type u_3} [] [] :
MeasurableSpace.generateFrom (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) {s : Set α | } {t : Set β | }) = Prod.instMeasurableSpace

The product σ-algebra is generated from boxes, i.e. s ×ˢ t for sets s : Set α and t : Set β.

theorem isPiSystem_prod {α : Type u_1} {β : Type u_3} [] [] :
IsPiSystem (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) {s : Set α | } {t : Set β | })

Rectangles form a π-system.

theorem measurable_measure_prod_mk_left_finite {α : Type u_1} {β : Type u_3} [] [] {ν : } {s : Set (α × β)} (hs : ) :
Measurable fun (x : α) => ν ( ⁻¹' s)

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 {α : Type u_1} {β : Type u_3} [] [] {ν : } {s : Set (α × β)} (hs : ) :
Measurable fun (x : α) => ν ( ⁻¹' s)

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_right {α : Type u_1} {β : Type u_3} [] [] {μ : } {s : Set (α × β)} (hs : ) :
Measurable fun (y : β) => μ ((fun (x : α) => (x, y)) ⁻¹' s)

If μ is a σ-finite measure, and s ⊆ α × β is measurable, then y ↦ μ { x | (x, y) ∈ s } is a measurable function.

theorem Measurable.map_prod_mk_left {α : Type u_1} {β : Type u_3} [] [] {ν : } :
Measurable fun (x : α) =>
theorem Measurable.map_prod_mk_right {α : Type u_1} {β : Type u_3} [] [] {μ : } :
Measurable fun (y : β) => MeasureTheory.Measure.map (fun (x : α) => (x, y)) μ
theorem MeasurableEmbedding.prod_mk {α : Type u_7} {β : Type u_8} {γ : Type u_9} {δ : Type u_10} {mα : } {mβ : } {mγ : } {mδ : } {f : αβ} {g : γδ} (hg : ) (hf : ) :
MeasurableEmbedding fun (x : γ × α) => (g x.1, f x.2)
theorem MeasurableEmbedding.prod_mk_left {α : Type u_1} [] {β : Type u_7} {γ : Type u_8} {mβ : } {mγ : } (x : α) {f : γβ} (hf : ) :
MeasurableEmbedding fun (y : γ) => (x, f y)
theorem measurableEmbedding_prod_mk_left {α : Type u_1} {β : Type u_3} [] [] (x : α) :
theorem MeasurableEmbedding.prod_mk_right {α : Type u_1} [] {β : Type u_7} {γ : Type u_8} {mβ : } {mγ : } {f : γβ} (hf : ) (x : α) :
MeasurableEmbedding fun (y : γ) => (f y, x)
theorem measurableEmbedding_prod_mk_right {α : Type u_1} {β : Type u_3} [] [] (x : α) :
MeasurableEmbedding fun (y : β) => (y, x)
theorem Measurable.lintegral_prod_right' {α : Type u_1} {β : Type u_3} [] [] {ν : } {f : α × βENNReal} :
Measurable fun (x : α) => ∫⁻ (y : β), f (x, y)ν

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 {α : Type u_1} {β : Type u_3} [] [] {ν : } {f : αβENNReal} (hf : ) :
Measurable fun (x : α) => ∫⁻ (y : β), f x yν

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_left' {α : Type u_1} {β : Type u_3} [] [] {μ : } {f : α × βENNReal} (hf : ) :
Measurable fun (y : β) => ∫⁻ (x : α), f (x, y)μ

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 {α : Type u_1} {β : Type u_3} [] [] {μ : } {f : αβENNReal} (hf : ) :
Measurable fun (y : β) => ∫⁻ (x : α), f x yμ

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.

### The product measure #

@[irreducible]
def MeasureTheory.Measure.prod {α : Type u_7} {β : Type u_8} [] [] (μ : ) (ν : ) :

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.

Equations
Instances For
theorem MeasureTheory.Measure.prod_def {α : Type u_7} {β : Type u_8} [] [] (μ : ) (ν : ) :
μ.prod ν = μ.bind fun (x : α) =>
instance MeasureTheory.Measure.prod.measureSpace {α : Type u_7} {β : Type u_8} :
Equations
theorem MeasureTheory.Measure.volume_eq_prod (α : Type u_7) (β : Type u_8) :
MeasureTheory.volume = MeasureTheory.volume.prod MeasureTheory.volume
theorem MeasureTheory.Measure.prod_apply {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set (α × β)} (hs : ) :
(μ.prod ν) s = ∫⁻ (x : α), ν ( ⁻¹' s)μ
@[simp]
theorem MeasureTheory.Measure.prod_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (s : Set α) (t : Set β) :
(μ.prod ν) (s ×ˢ t) = μ s * ν t

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 MeasureTheory.Measure.map_fst_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
MeasureTheory.Measure.map Prod.fst (μ.prod ν) = ν Set.univ μ
@[simp]
theorem MeasureTheory.Measure.map_snd_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
MeasureTheory.Measure.map Prod.snd (μ.prod ν) = μ Set.univ ν
instance MeasureTheory.Measure.prod.instIsOpenPosMeasure {X : Type u_7} {Y : Type u_8} [] [] {m : } {μ : } [μ.IsOpenPosMeasure] {m' : } {ν : } [ν.IsOpenPosMeasure] :
(μ.prod ν).IsOpenPosMeasure
Equations
• =
instance MeasureTheory.Measure.instIsOpenPosMeasureProdVolumeOfSFinite {X : Type u_7} {Y : Type u_8} [] [MeasureTheory.volume.IsOpenPosMeasure] [] [MeasureTheory.volume.IsOpenPosMeasure] [MeasureTheory.SFinite MeasureTheory.volume] :
MeasureTheory.volume.IsOpenPosMeasure
Equations
• =
instance MeasureTheory.Measure.prod.instIsFiniteMeasure {α : Type u_7} {β : Type u_8} {mα : } {mβ : } (μ : ) (ν : ) :
Equations
• =
instance MeasureTheory.Measure.instIsFiniteMeasureProdVolume {α : Type u_7} {β : Type u_8} [MeasureTheory.IsFiniteMeasure MeasureTheory.volume] [MeasureTheory.IsFiniteMeasure MeasureTheory.volume] :
MeasureTheory.IsFiniteMeasure MeasureTheory.volume
Equations
• =
instance MeasureTheory.Measure.prod.instIsProbabilityMeasure {α : Type u_7} {β : Type u_8} {mα : } {mβ : } (μ : ) (ν : ) :
Equations
• =
Equations
• =
instance MeasureTheory.Measure.prod.instIsFiniteMeasureOnCompacts {α : Type u_7} {β : Type u_8} [] [] {mα : } {mβ : } (μ : ) (ν : ) :
Equations
• =
Equations
• =
instance MeasureTheory.Measure.prod.instNoAtoms_fst {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
Equations
• =
instance MeasureTheory.Measure.prod.instNoAtoms_snd {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
Equations
• =
theorem MeasureTheory.Measure.ae_measure_lt_top {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set (α × β)} (hs : ) (h2s : (μ.prod ν) s ) :
∀ᵐ (x : α) ∂μ, ν ( ⁻¹' s) <
theorem MeasureTheory.Measure.measure_prod_null {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set (α × β)} (hs : ) :
(μ.prod ν) s = 0 (fun (x : α) => ν ( ⁻¹' s)) =ᶠ[μ.ae] 0

Note: the assumption hs cannot be dropped. For a counterexample, see Walter Rudin Real and Complex Analysis, example (c) in section 8.9.

theorem MeasureTheory.Measure.measure_ae_null_of_prod_null {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set (α × β)} (h : (μ.prod ν) s = 0) :
(fun (x : α) => ν ( ⁻¹' s)) =ᶠ[μ.ae] 0

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 MeasureTheory.Measure.AbsolutelyContinuous.prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {μ' : } {ν : } {ν' : } (h1 : μ.AbsolutelyContinuous μ') (h2 : ν.AbsolutelyContinuous ν') :
(μ.prod ν).AbsolutelyContinuous (μ'.prod ν')
theorem MeasureTheory.Measure.ae_ae_of_ae_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {p : α × βProp} (h : ∀ᵐ (z : α × β) ∂μ.prod ν, p z) :
∀ᵐ (x : α) ∂μ, ∀ᵐ (y : β) ∂ν, p (x, y)

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 MeasureTheory.Measure.ae_ae_eq_curry_of_prod {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] {μ : } {ν : } {f : α × βγ} {g : α × βγ} (h : f =ᶠ[(μ.prod ν).ae] g) :
∀ᵐ (x : α) ∂μ, =ᶠ[ν.ae]
theorem MeasureTheory.Measure.ae_ae_eq_of_ae_eq_uncurry {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] {μ : } {ν : } {f : αβγ} {g : αβγ} (h : =ᶠ[(μ.prod ν).ae] ) :
∀ᵐ (x : α) ∂μ, f x =ᶠ[ν.ae] g x
theorem MeasureTheory.Measure.ae_prod_mem_iff_ae_ae_mem {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set (α × β)} (hs : ) :
(∀ᵐ (z : α × β) ∂μ.prod ν, z s) ∀ᵐ (x : α) ∂μ, ∀ᵐ (y : β) ∂ν, (x, y) s
theorem MeasureTheory.Measure.quasiMeasurePreserving_fst {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
theorem MeasureTheory.Measure.quasiMeasurePreserving_snd {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
theorem MeasureTheory.Measure.set_prod_ae_eq {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {s' : Set α} {t : Set β} {t' : Set β} (hs : s =ᶠ[μ.ae] s') (ht : t =ᶠ[ν.ae] t') :
s ×ˢ t =ᶠ[(μ.prod ν).ae] s' ×ˢ t'
theorem MeasureTheory.Measure.measure_prod_compl_eq_zero {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {t : Set β} (s_ae_univ : μ s = 0) (t_ae_univ : ν t = 0) :
(μ.prod ν) (s ×ˢ t) = 0
theorem MeasureTheory.NullMeasurableSet.prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {t : Set β} (s_mble : ) (t_mble : ) :
theorem MeasureTheory.NullMeasurableSet.right_of_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {t : Set β} (h : MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν)) (hs : μ s 0) :

If s ×ˢ t is a null measurable set and μ s ≠ 0, then t is a null measurable set.

theorem MeasureTheory.NullMeasurableSet.of_preimage_snd {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } [] {t : Set β} (h : MeasureTheory.NullMeasurableSet (Prod.snd ⁻¹' t) (μ.prod ν)) :

If Prod.snd ⁻¹' t is a null measurable set and μ ≠ 0, then t is a null measurable set.

theorem MeasureTheory.Measure.nullMeasurableSet_preimage_snd {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } [] {t : Set β} :
MeasureTheory.NullMeasurableSet (Prod.snd ⁻¹' t) (μ.prod ν)

Prod.snd ⁻¹' t is null measurable w.r.t. μ.prod ν iff t is null measurable w.r.t. ν provided that μ ≠ 0.

theorem MeasureTheory.Measure.nullMeasurable_comp_snd {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {μ : } {ν : } [] {f : βγ} :
MeasureTheory.NullMeasurable (f Prod.snd) (μ.prod ν)
noncomputable def MeasureTheory.Measure.FiniteSpanningSetsIn.prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {C : Set (Set α)} {D : Set (Set β)} (hμ : μ.FiniteSpanningSetsIn C) (hν : ν.FiniteSpanningSetsIn D) :
(μ.prod ν).FiniteSpanningSetsIn (Set.image2 (fun (x : Set α) (x_1 : Set β) => x ×ˢ x_1) C D)

μ.prod ν has finite spanning sets in rectangles of finite spanning sets.

Equations
• .prod = { set := fun (n : ) => .set n.unpair.1 ×ˢ .set n.unpair.2, set_mem := , finite := , spanning := }
Instances For
theorem MeasureTheory.Measure.prod_sum_left {α : Type u_1} {β : Type u_3} [] [] {ι : Type u_7} (m : ) (μ : ) :
.prod μ = MeasureTheory.Measure.sum fun (i : ι) => (m i).prod μ
theorem MeasureTheory.Measure.prod_sum_right {α : Type u_1} {β : Type u_3} [] [] {ι' : Type u_7} [] (m : ) (m' : ) [∀ (n : ι'), MeasureTheory.SFinite (m' n)] :
m.prod = MeasureTheory.Measure.sum fun (p : ι') => m.prod (m' p)
theorem MeasureTheory.Measure.prod_sum {α : Type u_1} {β : Type u_3} [] [] {ι : Type u_7} {ι' : Type u_8} [] (m : ) (m' : ) [∀ (n : ι'), MeasureTheory.SFinite (m' n)] :
.prod = MeasureTheory.Measure.sum fun (p : ι × ι') => (m p.1).prod (m' p.2)
instance MeasureTheory.Measure.prod.instSigmaFinite {α : Type u_7} {β : Type u_8} :
∀ {x : } {μ : } [inst : ] {x_1 : } {ν : } [inst : ], MeasureTheory.SigmaFinite (μ.prod ν)
Equations
• =
instance MeasureTheory.Measure.prod.instSFinite {α : Type u_7} {β : Type u_8} :
∀ {x : } {μ : } [inst : ] {x_1 : } {ν : } [inst : ], MeasureTheory.SFinite (μ.prod ν)
Equations
• =
instance MeasureTheory.Measure.instSigmaFiniteProdVolume {α : Type u_7} {β : Type u_8} [MeasureTheory.SigmaFinite MeasureTheory.volume] [MeasureTheory.SigmaFinite MeasureTheory.volume] :
MeasureTheory.SigmaFinite MeasureTheory.volume
Equations
• =
instance MeasureTheory.Measure.instSFiniteProdVolume {α : Type u_7} {β : Type u_8} [MeasureTheory.SFinite MeasureTheory.volume] [MeasureTheory.SFinite MeasureTheory.volume] :
MeasureTheory.SFinite MeasureTheory.volume
Equations
• =
theorem MeasureTheory.Measure.prod_eq_generateFrom {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {C : Set (Set α)} {D : Set (Set β)} (hC : = inst✝¹) (hD : ) (h2C : ) (h2D : ) (h3C : μ.FiniteSpanningSetsIn C) (h3D : ν.FiniteSpanningSetsIn D) {μν : MeasureTheory.Measure (α × β)} (h₁ : sC, tD, μν (s ×ˢ t) = μ s * ν t) :
μ.prod ν = μν

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 MeasureTheory.Measure.prod_eq {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {μν : MeasureTheory.Measure (α × β)} (h : ∀ (s : Set α) (t : Set β), μν (s ×ˢ t) = μ s * ν t) :
μ.prod ν = μν

A measure on a product space equals the product measure of sigma-finite measures if they are equal on rectangles.

theorem MeasureTheory.Measure.prod_swap {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
MeasureTheory.Measure.map Prod.swap (μ.prod ν) = ν.prod μ
theorem MeasureTheory.Measure.measurePreserving_swap {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
MeasureTheory.MeasurePreserving Prod.swap (μ.prod ν) (ν.prod μ)
theorem MeasureTheory.Measure.prod_apply_symm {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set (α × β)} (hs : ) :
(μ.prod ν) s = ∫⁻ (y : β), μ ((fun (x : α) => (x, y)) ⁻¹' s)ν
theorem MeasureTheory.NullMeasurableSet.left_of_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {t : Set β} (h : MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν)) (ht : ν t 0) :

If s ×ˢ t is a null measurable set and ν t ≠ 0, then s is a null measurable set.

theorem MeasureTheory.NullMeasurableSet.of_preimage_fst {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } [] {s : Set α} (h : MeasureTheory.NullMeasurableSet (Prod.fst ⁻¹' s) (μ.prod ν)) :

If Prod.fst ⁻¹' s is a null measurable set and ν ≠ 0, then s is a null measurable set.

theorem MeasureTheory.Measure.nullMeasurableSet_preimage_fst {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } [] {s : Set α} :
MeasureTheory.NullMeasurableSet (Prod.fst ⁻¹' s) (μ.prod ν)

Prod.fst ⁻¹' s is null measurable w.r.t. μ.prod ν iff s is null measurable w.r.t. μ provided that ν ≠ 0.

theorem MeasureTheory.Measure.nullMeasurable_comp_fst {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {μ : } {ν : } [] {f : αγ} :
MeasureTheory.NullMeasurable (f Prod.fst) (μ.prod ν)
theorem MeasureTheory.Measure.nullMeasurableSet_prod_of_ne_zero {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {t : Set β} (hs : μ s 0) (ht : ν t 0) :

The product of two non-null sets is null measurable if and only if both of them are null measurable.

theorem MeasureTheory.Measure.nullMeasurableSet_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {s : Set α} {t : Set β} :
MeasureTheory.NullMeasurableSet (s ×ˢ t) (μ.prod ν) μ s = 0 ν t = 0

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.

theorem MeasureTheory.Measure.prodAssoc_prod {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {μ : } {ν : } {τ : } :
MeasureTheory.Measure.map (MeasurableEquiv.prodAssoc) ((μ.prod ν).prod τ) = μ.prod (ν.prod τ)

### The product of specific measures #

theorem MeasureTheory.Measure.prod_restrict {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (s : Set α) (t : Set β) :
(μ.restrict s).prod (ν.restrict t) = (μ.prod ν).restrict (s ×ˢ t)
theorem MeasureTheory.Measure.restrict_prod_eq_prod_univ {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (s : Set α) :
(μ.restrict s).prod ν = (μ.prod ν).restrict (s ×ˢ Set.univ)
theorem MeasureTheory.Measure.prod_dirac {α : Type u_1} {β : Type u_3} [] [] {μ : } (y : β) :
μ.prod = MeasureTheory.Measure.map (fun (x : α) => (x, y)) μ
theorem MeasureTheory.Measure.dirac_prod {α : Type u_1} {β : Type u_3} [] [] {ν : } (x : α) :
.prod ν =
theorem MeasureTheory.Measure.dirac_prod_dirac {α : Type u_1} {β : Type u_3} [] [] {x : α} {y : β} :
=
theorem MeasureTheory.Measure.prod_add {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (ν' : ) :
μ.prod (ν + ν') = μ.prod ν + μ.prod ν'
theorem MeasureTheory.Measure.add_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (μ' : ) :
(μ + μ').prod ν = μ.prod ν + μ'.prod ν
@[simp]
theorem MeasureTheory.Measure.zero_prod {α : Type u_1} {β : Type u_3} [] [] (ν : ) :
@[simp]
theorem MeasureTheory.Measure.prod_zero {α : Type u_1} {β : Type u_3} [] [] (μ : ) :
μ.prod 0 = 0
theorem MeasureTheory.Measure.map_prod_map {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {δ : Type u_7} [] {f : αβ} {g : γδ} (μa : ) (μc : ) (hf : ) (hg : ) :
().prod () = MeasureTheory.Measure.map (Prod.map f g) (μa.prod μc)
theorem MeasureTheory.MeasurePreserving.skew_product {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {δ : Type u_7} [] {μa : } {μb : } {μc : } {μd : } {f : αβ} (hf : ) {g : αγδ} (hgm : ) (hg : ∀ᵐ (x : α) ∂μa, MeasureTheory.Measure.map (g x) μc = μd) :
MeasureTheory.MeasurePreserving (fun (p : α × γ) => (f p.1, g p.1 p.2)) (μa.prod μc) (μb.prod μd)
theorem MeasureTheory.MeasurePreserving.prod {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {δ : Type u_7} [] {μa : } {μb : } {μc : } {μd : } {f : αβ} {g : γδ} (hf : ) (hg : ) :
MeasureTheory.MeasurePreserving (Prod.map f g) (μa.prod μc) (μb.prod μd)

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.

theorem MeasureTheory.QuasiMeasurePreserving.prod_of_right {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {f : α × βγ} {μ : } {ν : } {τ : } (hf : ) (h2f : ∀ᵐ (x : α) ∂μ, MeasureTheory.Measure.QuasiMeasurePreserving (fun (y : β) => f (x, y)) ν τ) :
theorem MeasureTheory.QuasiMeasurePreserving.prod_of_left {α : Type u_7} {β : Type u_8} {γ : Type u_9} [] [] [] {f : α × βγ} {μ : } {ν : } {τ : } (hf : ) (h2f : ∀ᵐ (y : β) ∂ν, MeasureTheory.Measure.QuasiMeasurePreserving (fun (x : α) => f (x, y)) μ τ) :
theorem AEMeasurable.prod_swap {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {μ : } {ν : } {f : β × αγ} (hf : AEMeasurable f (ν.prod μ)) :
AEMeasurable (fun (z : α × β) => f z.swap) (μ.prod ν)
theorem AEMeasurable.fst {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {μ : } {ν : } {f : αγ} (hf : ) :
AEMeasurable (fun (z : α × β) => f z.1) (μ.prod ν)
theorem AEMeasurable.snd {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {μ : } {ν : } {f : βγ} (hf : ) :
AEMeasurable (fun (z : α × β) => f z.2) (μ.prod ν)

### The Lebesgue integral on a product #

theorem MeasureTheory.lintegral_prod_swap {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (f : α × βENNReal) :
∫⁻ (z : β × α), f z.swapν.prod μ = ∫⁻ (z : α × β), f zμ.prod ν
theorem MeasureTheory.lintegral_prod_of_measurable {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (f : α × βENNReal) :
∫⁻ (z : α × β), f zμ.prod ν = ∫⁻ (x : α), ∫⁻ (y : β), f (x, y)νμ

Tonelli's Theorem: For ℝ≥0∞-valued measurable functions on α × β, the integral of f is equal to the iterated integral.

theorem MeasureTheory.lintegral_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (f : α × βENNReal) (hf : AEMeasurable f (μ.prod ν)) :
∫⁻ (z : α × β), f zμ.prod ν = ∫⁻ (x : α), ∫⁻ (y : β), f (x, y)νμ

Tonelli's Theorem: For ℝ≥0∞-valued almost everywhere measurable functions on α × β, the integral of f is equal to the iterated integral.

theorem MeasureTheory.lintegral_prod_symm {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (f : α × βENNReal) (hf : AEMeasurable f (μ.prod ν)) :
∫⁻ (z : α × β), f zμ.prod ν = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y)μν

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 MeasureTheory.lintegral_prod_symm' {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } (f : α × βENNReal) (hf : ) :
∫⁻ (z : α × β), f zμ.prod ν = ∫⁻ (y : β), ∫⁻ (x : α), f (x, y)μν

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 MeasureTheory.lintegral_lintegral {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } ⦃f : αβENNReal (hf : AEMeasurable () (μ.prod ν)) :
∫⁻ (x : α), ∫⁻ (y : β), f x yνμ = ∫⁻ (z : α × β), f z.1 z.2μ.prod ν

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 MeasureTheory.lintegral_lintegral_symm {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } ⦃f : αβENNReal (hf : AEMeasurable () (μ.prod ν)) :
∫⁻ (x : α), ∫⁻ (y : β), f x yνμ = ∫⁻ (z : β × α), f z.2 z.1ν.prod μ

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 MeasureTheory.lintegral_lintegral_swap {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } ⦃f : αβENNReal (hf : AEMeasurable () (μ.prod ν)) :
∫⁻ (x : α), ∫⁻ (y : β), f x yνμ = ∫⁻ (y : β), ∫⁻ (x : α), f x yμν

Change the order of Lebesgue integration.

theorem MeasureTheory.lintegral_prod_mul {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } {f : αENNReal} {g : βENNReal} (hf : ) (hg : ) :
∫⁻ (z : α × β), f z.1 * g z.2μ.prod ν = (∫⁻ (x : α), f xμ) * ∫⁻ (y : β), g yν

### Marginals of a measure defined on a product #

noncomputable def MeasureTheory.Measure.fst {α : Type u_1} {β : Type u_3} [] [] (ρ : MeasureTheory.Measure (α × β)) :

Marginal measure on α obtained from a measure ρ on α × β, defined by ρ.map Prod.fst.

Equations
Instances For
theorem MeasureTheory.Measure.fst_apply {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} {s : Set α} (hs : ) :
ρ.fst s = ρ (Prod.fst ⁻¹' s)
theorem MeasureTheory.Measure.fst_univ {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} :
ρ.fst Set.univ = ρ Set.univ
@[simp]
theorem MeasureTheory.Measure.fst_zero {α : Type u_1} {β : Type u_3} [] [] :
instance MeasureTheory.Measure.fst.instIsFiniteMeasure {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} :
Equations
• =
instance MeasureTheory.Measure.fst.instIsProbabilityMeasure {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} :
Equations
• =
@[simp]
theorem MeasureTheory.Measure.fst_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
(μ.prod ν).fst = μ
theorem MeasureTheory.Measure.fst_map_prod_mk₀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {X : αβ} {Y : αγ} {μ : } (hY : ) :
(MeasureTheory.Measure.map (fun (a : α) => (X a, Y a)) μ).fst =
theorem MeasureTheory.Measure.fst_map_prod_mk {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {X : αβ} {Y : αγ} {μ : } (hY : ) :
(MeasureTheory.Measure.map (fun (a : α) => (X a, Y a)) μ).fst =
noncomputable def MeasureTheory.Measure.snd {α : Type u_1} {β : Type u_3} [] [] (ρ : MeasureTheory.Measure (α × β)) :

Marginal measure on β obtained from a measure on ρ α × β, defined by ρ.map Prod.snd.

Equations
Instances For
theorem MeasureTheory.Measure.snd_apply {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} {s : Set β} (hs : ) :
ρ.snd s = ρ (Prod.snd ⁻¹' s)
theorem MeasureTheory.Measure.snd_univ {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} :
ρ.snd Set.univ = ρ Set.univ
@[simp]
theorem MeasureTheory.Measure.snd_zero {α : Type u_1} {β : Type u_3} [] [] :
instance MeasureTheory.Measure.snd.instIsFiniteMeasure {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} :
Equations
• =
instance MeasureTheory.Measure.snd.instIsProbabilityMeasure {α : Type u_1} {β : Type u_3} [] [] {ρ : MeasureTheory.Measure (α × β)} :
Equations
• =
@[simp]
theorem MeasureTheory.Measure.snd_prod {α : Type u_1} {β : Type u_3} [] [] {μ : } {ν : } :
(μ.prod ν).snd = ν
theorem MeasureTheory.Measure.snd_map_prod_mk₀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {X : αβ} {Y : αγ} {μ : } (hX : ) :
(MeasureTheory.Measure.map (fun (a : α) => (X a, Y a)) μ).snd =
theorem MeasureTheory.Measure.snd_map_prod_mk {α : Type u_1} {β : Type u_3} {γ : Type u_5} [] [] [] {X : αβ} {Y : αγ} {μ : } (hX : ) :
(MeasureTheory.Measure.map (fun (a : α) => (X a, Y a)) μ).snd =