File: Mathlib/MeasureTheory/Constructions/Pi.lean

full_name: IsPiSystem.pi
code: /-- Boxes formed by π-systems form a π-system. -/
theorem IsPiSystem.pi {C : ∀ i, Set (Set (α i))} (hC : ∀ i, IsPiSystem (C i)) :
    IsPiSystem (pi univ '' pi univ C) 
goal: IsPiSystem (Set.univ.pi '' Set.univ.pi C)

full_name: isPiSystem_pi
code: /-- Boxes form a π-system. -/
theorem isPiSystem_pi [∀ i, MeasurableSpace (α i)] :
    IsPiSystem (pi univ '' pi univ fun i => { s : Set (α i) | MeasurableSet s }) 
goal: IsPiSystem (Set.univ.pi '' Set.univ.pi fun i => {s | MeasurableSet s})

full_name: IsCountablySpanning.pi
code: /-- Boxes of countably spanning sets are countably spanning. -/
theorem IsCountablySpanning.pi {C : ∀ i, Set (Set (α i))} (hC : ∀ i, IsCountablySpanning (C i)) :
    IsCountablySpanning (pi univ '' pi univ C) 
goal: IsCountablySpanning (Set.univ.pi '' Set.univ.pi C)

full_name: generateFrom_pi_eq
code: /-- The product of generated σ-algebras is the one generated by boxes, if both generating sets
  are countably spanning. -/
theorem generateFrom_pi_eq {C : ∀ i, Set (Set (α i))} (hC : ∀ i, IsCountablySpanning (C i)) :
    (@MeasurableSpace.pi _ _ fun i => generateFrom (C i)) =
    generateFrom (pi univ '' pi univ C) 
goal: MeasurableSpace.pi = MeasurableSpace.generateFrom (Set.univ.pi '' Set.univ.pi C)

full_name: generateFrom_eq_pi
code: /-- If `C` and `D` generate the σ-algebras on `α` resp. `β`, then rectangles formed by `C` and `D`
  generate the σ-algebra on `α × β`. -/
theorem generateFrom_eq_pi [h : ∀ i, MeasurableSpace (α i)] {C : ∀ i, Set (Set (α i))}
    (hC : ∀ i, generateFrom (C i) = h i) (h2C : ∀ i, IsCountablySpanning (C i)) :
    generateFrom (pi univ '' pi univ C) = MeasurableSpace.pi 
goal: MeasurableSpace.generateFrom (Set.univ.pi '' Set.univ.pi C) = MeasurableSpace.pi

full_name: generateFrom_pi
code: /-- The product σ-algebra is generated from boxes, i.e. `s ×ˢ t` for sets `s : set α` and
  `t : set β`. -/
theorem generateFrom_pi [∀ i, MeasurableSpace (α i)] :
    generateFrom (pi univ '' pi univ fun i => { s : Set (α i) | MeasurableSet s }) =
      MeasurableSpace.pi 
goal: MeasurableSpace.generateFrom (Set.univ.pi '' Set.univ.pi fun i => {s | MeasurableSet s}) = MeasurableSpace.pi

full_name: MeasureTheory.piPremeasure
code: /-- An upper bound for the measure in a finite product space.
  It is defined to by taking the image of the set under all projections, and taking the product
  of the measures of these images.
  For measurable boxes it is equal to the correct measure. -/
@[simp]
def piPremeasure (m : ∀ i, OuterMeasure (α i)) (s : Set (∀ i, α i)) : ℝ≥0∞ 
goal: ℝ≥0∞

full_name: MeasureTheory.piPremeasure_pi
code: theorem piPremeasure_pi {s : ∀ i, Set (α i)} (hs : (pi univ s).Nonempty) :
    piPremeasure m (pi univ s) = ∏ i, m i (s i) 
goal: MeasureTheory.piPremeasure m (Set.univ.pi s) = ∏ i : ι, (m i) (s i)

full_name: MeasureTheory.piPremeasure_pi'
code: theorem piPremeasure_pi' {s : ∀ i, Set (α i)} : piPremeasure m (pi univ s) = ∏ i, m i (s i) 
goal: MeasureTheory.piPremeasure m (Set.univ.pi s) = ∏ i : ι, (m i) (s i)

full_name: MeasureTheory.piPremeasure_pi_mono
code: theorem piPremeasure_pi_mono {s t : Set (∀ i, α i)} (h : s ⊆ t) :
    piPremeasure m s ≤ piPremeasure m t 
goal: MeasureTheory.piPremeasure m s ≤ MeasureTheory.piPremeasure m t

full_name: MeasureTheory.piPremeasure_pi_eval
code: theorem piPremeasure_pi_eval {s : Set (∀ i, α i)} :
    piPremeasure m (pi univ fun i => eval i '' s) = piPremeasure m s 
goal: MeasureTheory.piPremeasure m (Set.univ.pi fun i => Function.eval i '' s) = MeasureTheory.piPremeasure m s

full_name: MeasureTheory.OuterMeasure.pi
code: /-- `OuterMeasure.pi m` is the finite product of the outer measures `{m i | i : ι}`.
  It is defined to be the maximal outer measure `n` with the property that
  `n (pi univ s) ≤ ∏ i, m i (s i)`, where `pi univ s` is the product of the sets
  `{s i | i : ι}`. -/
protected def pi (m : ∀ i, OuterMeasure (α i)) : OuterMeasure (∀ i, α i) 
goal: MeasureTheory.OuterMeasure ((i : ι) → α i)

full_name: MeasureTheory.OuterMeasure.pi_pi_le
code: theorem pi_pi_le (m : ∀ i, OuterMeasure (α i)) (s : ∀ i, Set (α i)) :
    OuterMeasure.pi m (pi univ s) ≤ ∏ i, m i (s i) 
goal: (MeasureTheory.OuterMeasure.pi m) (Set.univ.pi s) ≤ ∏ i : ι, (m i) (s i)

full_name: MeasureTheory.OuterMeasure.le_pi
code: theorem le_pi {m : ∀ i, OuterMeasure (α i)} {n : OuterMeasure (∀ i, α i)} :
    n ≤ OuterMeasure.pi m ↔
      ∀ s : ∀ i, Set (α i), (pi univ s).Nonempty → n (pi univ s) ≤ ∏ i, m i (s i) 
goal: n ≤ MeasureTheory.OuterMeasure.pi m ↔
  ∀ (s : (i : ι) → Set (α i)), (Set.univ.pi s).Nonempty → n (Set.univ.pi s) ≤ ∏ i : ι, (m i) (s i)

full_name: MeasureTheory.Measure.tprod
code: /-- A product of measures in `tprod α l`. -/
protected def tprod (l : List δ) (μ : ∀ i, Measure (π i)) : Measure (TProd π l) 
goal: MeasureTheory.Measure (List.TProd π l)

full_name: MeasureTheory.Measure.tprod_nil
code: @[simp]
theorem tprod_nil (μ : ∀ i, Measure (π i)) : Measure.tprod [] μ = dirac PUnit.unit 
goal: MeasureTheory.Measure.tprod [] μ = MeasureTheory.Measure.dirac PUnit.unit

full_name: MeasureTheory.Measure.tprod_cons
code: @[simp]
theorem tprod_cons (i : δ) (l : List δ) (μ : ∀ i, Measure (π i)) :
    Measure.tprod (i :: l) μ = (μ i).prod (Measure.tprod l μ) 
goal: MeasureTheory.Measure.tprod (i :: l) μ = (μ i).prod (MeasureTheory.Measure.tprod l μ)

full_name: MeasureTheory.Measure.sigmaFinite_tprod
code: instance sigmaFinite_tprod (l : List δ) (μ : ∀ i, Measure (π i)) [∀ i, SigmaFinite (μ i)] :
    SigmaFinite (Measure.tprod l μ) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.tprod l μ)

full_name: MeasureTheory.Measure.tprod_tprod
code: theorem tprod_tprod (l : List δ) (μ : ∀ i, Measure (π i)) [∀ i, SigmaFinite (μ i)]
    (s : ∀ i, Set (π i)) :
    Measure.tprod l μ (Set.tprod l s) = (l.map fun i => (μ i) (s i)).prod 
goal: (MeasureTheory.Measure.tprod l μ) (Set.tprod l s) = (List.map (fun i => (μ i) (s i)) l).prod

full_name: MeasureTheory.Measure.pi'
code: /-- The product measure on an encodable finite type, defined by mapping `Measure.tprod` along the
  equivalence `MeasurableEquiv.piMeasurableEquivTProd`.
  The definition `MeasureTheory.Measure.pi` should be used instead of this one. -/
def pi' : Measure (∀ i, α i) 
goal: MeasureTheory.Measure ((i : ι) → α i)

full_name: MeasureTheory.Measure.pi'_pi
code: theorem pi'_pi [∀ i, SigmaFinite (μ i)] (s : ∀ i, Set (α i)) :
    pi' μ (pi univ s) = ∏ i, μ i (s i) 
goal: (MeasureTheory.Measure.pi' μ) (Set.univ.pi s) = ∏ i : ι, (μ i) (s i)

full_name: MeasureTheory.Measure.pi_caratheodory
code: theorem pi_caratheodory :
    MeasurableSpace.pi ≤ (OuterMeasure.pi fun i => (μ i).toOuterMeasure).caratheodory 
goal: MeasurableSpace.pi ≤ (MeasureTheory.OuterMeasure.pi fun i => (μ i).toOuterMeasure).caratheodory

full_name: MeasureTheory.Measure.pi_def
code: /-- `Measure.pi μ` is the finite product of the measures `{μ i | i : ι}`.
  It is defined to be measure corresponding to `MeasureTheory.OuterMeasure.pi`. -/
protected irreducible_def pi : Measure (∀ i, α i) 
goal: MeasureTheory.Measure.pi μ = (MeasureTheory.OuterMeasure.pi fun i => (μ i).toOuterMeasure).toMeasure ⋯

full_name: MeasureTheory.Measure.wrapped._@.Mathlib.MeasureTheory.Constructions.Pi._hyg.3101
code: /-- `Measure.pi μ` is the finite product of the measures `{μ i | i : ι}`.
  It is defined to be measure corresponding to `MeasureTheory.OuterMeasure.pi`. -/
protected irreducible_def pi : Measure (∀ i, α i) 
goal: Subtype (Eq @MeasureTheory.Measure.definition✝)

full_name: MeasureTheory.Measure.pi
code: /-- `Measure.pi μ` is the finite product of the measures `{μ i | i : ι}`.
  It is defined to be measure corresponding to `MeasureTheory.OuterMeasure.pi`. -/
protected irreducible_def pi : Measure (∀ i, α i) 
goal: MeasureTheory.Measure ((i : ι) → α i)

full_name: MeasureTheory.Measure.definition._@.Mathlib.MeasureTheory.Constructions.Pi._hyg.3101
code: /-- `Measure.pi μ` is the finite product of the measures `{μ i | i : ι}`.
  It is defined to be measure corresponding to `MeasureTheory.OuterMeasure.pi`. -/
protected irreducible_def pi : Measure (∀ i, α i) 
goal: MeasureTheory.Measure ((i : ι) → α i)

full_name: MeasureTheory.MeasureSpace.pi
code: instance _root_.MeasureTheory.MeasureSpace.pi {α : ι → Type*} [∀ i, MeasureSpace (α i)] :
    MeasureSpace (∀ i, α i) 
goal: MeasureTheory.MeasureSpace ((i : ι) → α i)

full_name: MeasureTheory.Measure.pi_pi_aux
code: theorem pi_pi_aux [∀ i, SigmaFinite (μ i)] (s : ∀ i, Set (α i)) (hs : ∀ i, MeasurableSet (s i)) :
    Measure.pi μ (pi univ s) = ∏ i, μ i (s i) 
goal: (MeasureTheory.Measure.pi μ) (Set.univ.pi s) = ∏ i : ι, (μ i) (s i)

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.pi
code: /-- `Measure.pi μ` has finite spanning sets in rectangles of finite spanning sets. -/
def FiniteSpanningSetsIn.pi {C : ∀ i, Set (Set (α i))}
    (hμ : ∀ i, (μ i).FiniteSpanningSetsIn (C i)) :
    (Measure.pi μ).FiniteSpanningSetsIn (pi univ '' pi univ C) 
goal: (MeasureTheory.Measure.pi μ).FiniteSpanningSetsIn (Set.univ.pi '' Set.univ.pi C)

full_name: MeasureTheory.Measure.pi_eq_generateFrom
code: /-- A measure on a finite product space equals the product measure if they are equal on rectangles
  with as sides sets that generate the corresponding σ-algebras. -/
theorem pi_eq_generateFrom {C : ∀ i, Set (Set (α i))}
    (hC : ∀ i, generateFrom (C i) = by apply_assumption) (h2C : ∀ i, IsPiSystem (C i))
    (h3C : ∀ i, (μ i).FiniteSpanningSetsIn (C i)) {μν : Measure (∀ i, α i)}
    (h₁ : ∀ s : ∀ i, Set (α i), (∀ i, s i ∈ C i) → μν (pi univ s) = ∏ i, μ i (s i)) :
    Measure.pi μ = μν 
goal: MeasureTheory.Measure.pi μ = μν

full_name: MeasureTheory.Measure.pi_eq
code: /-- A measure on a finite product space equals the product measure if they are equal on
  rectangles. -/
theorem pi_eq {μ' : Measure (∀ i, α i)}
    (h : ∀ s : ∀ i, Set (α i), (∀ i, MeasurableSet (s i)) → μ' (pi univ s) = ∏ i, μ i (s i)) :
    Measure.pi μ = μ' 
goal: MeasureTheory.Measure.pi μ = μ'

full_name: MeasureTheory.Measure.pi'_eq_pi
code: theorem pi'_eq_pi [Encodable ι] : pi' μ = Measure.pi μ 
goal: MeasureTheory.Measure.pi' μ = MeasureTheory.Measure.pi μ

full_name: MeasureTheory.Measure.pi_pi
code: @[simp]
theorem pi_pi (s : ∀ i, Set (α i)) : Measure.pi μ (pi univ s) = ∏ i, μ i (s i) 
goal: (MeasureTheory.Measure.pi μ) (Set.univ.pi s) = ∏ i : ι, (μ i) (s i)

full_name: MeasureTheory.Measure.pi_univ
code: nonrec theorem pi_univ : Measure.pi μ univ = ∏ i, μ i univ 
goal: (MeasureTheory.Measure.pi μ) Set.univ = ∏ i : ι, (μ i) Set.univ

full_name: MeasureTheory.Measure.pi_ball
code: theorem pi_ball [∀ i, MetricSpace (α i)] (x : ∀ i, α i) {r : ℝ} (hr : 0 < r) :
    Measure.pi μ (Metric.ball x r) = ∏ i, μ i (Metric.ball (x i) r) 
goal: (MeasureTheory.Measure.pi μ) (Metric.ball x r) = ∏ i : ι, (μ i) (Metric.ball (x i) r)

full_name: MeasureTheory.Measure.pi_closedBall
code: theorem pi_closedBall [∀ i, MetricSpace (α i)] (x : ∀ i, α i) {r : ℝ} (hr : 0 ≤ r) :
    Measure.pi μ (Metric.closedBall x r) = ∏ i, μ i (Metric.closedBall (x i) r) 
goal: (MeasureTheory.Measure.pi μ) (Metric.closedBall x r) = ∏ i : ι, (μ i) (Metric.closedBall (x i) r)

full_name: MeasureTheory.Measure.pi.sigmaFinite
code: instance pi.sigmaFinite : SigmaFinite (Measure.pi μ) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.instSigmaFiniteForallVolume
code: instance {α : ι → Type*} [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))] :
    SigmaFinite (volume : Measure (∀ i, α i)) 
goal: MeasureTheory.SigmaFinite MeasureTheory.volume

full_name: MeasureTheory.Measure.pi.instIsFiniteMeasure
code: instance pi.instIsFiniteMeasure [∀ i, IsFiniteMeasure (μ i)] :
    IsFiniteMeasure (Measure.pi μ) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.instIsFiniteMeasureForallVolume
code: instance {α : ι → Type*} [∀ i, MeasureSpace (α i)] [∀ i, IsFiniteMeasure (volume : Measure (α i))] :
    IsFiniteMeasure (volume : Measure (∀ i, α i)) 
goal: MeasureTheory.IsFiniteMeasure MeasureTheory.volume

full_name: MeasureTheory.Measure.pi.instIsProbabilityMeasure
code: instance pi.instIsProbabilityMeasure [∀ i, IsProbabilityMeasure (μ i)] :
    IsProbabilityMeasure (Measure.pi μ) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.instIsProbabilityMeasureForallVolume
code: instance {α : ι → Type*} [∀ i, MeasureSpace (α i)]
    [∀ i, IsProbabilityMeasure (volume : Measure (α i))] :
    IsProbabilityMeasure (volume : Measure (∀ i, α i)) 
goal: MeasureTheory.IsProbabilityMeasure MeasureTheory.volume

full_name: MeasureTheory.Measure.pi_of_empty
code: theorem pi_of_empty {α : Type*} [Fintype α] [IsEmpty α] {β : α → Type*}
    {m : ∀ a, MeasurableSpace (β a)} (μ : ∀ a : α, Measure (β a)) (x : ∀ a, β a := isEmptyElim) :
    Measure.pi μ = dirac x 
goal: MeasureTheory.Measure.pi μ = MeasureTheory.Measure.dirac x

full_name: MeasureTheory.Measure.volume_pi_eq_dirac
code: lemma volume_pi_eq_dirac {ι : Type*} [Fintype ι] [IsEmpty ι]
    {α : ι → Type*} [∀ i, MeasureSpace (α i)] (x : ∀ a, α a := isEmptyElim) :
    (volume : Measure (∀ i, α i)) = Measure.dirac x 
goal: MeasureTheory.volume = MeasureTheory.Measure.dirac x

full_name: MeasureTheory.Measure.pi_empty_univ
code: @[simp]
theorem pi_empty_univ {α : Type*} [Fintype α] [IsEmpty α] {β : α → Type*}
    {m : ∀ α, MeasurableSpace (β α)} (μ : ∀ a : α, Measure (β a)) :
    Measure.pi μ (Set.univ) = 1 
goal: (MeasureTheory.Measure.pi μ) Set.univ = 1

full_name: MeasureTheory.Measure.pi_eval_preimage_null
code: theorem pi_eval_preimage_null {i : ι} {s : Set (α i)} (hs : μ i s = 0) :
    Measure.pi μ (eval i ⁻¹' s) = 0 
goal: (MeasureTheory.Measure.pi μ) (Function.eval i ⁻¹' s) = 0

full_name: MeasureTheory.Measure.pi_hyperplane
code: theorem pi_hyperplane (i : ι) [NoAtoms (μ i)] (x : α i) :
    Measure.pi μ { f : ∀ i, α i | f i = x } = 0 
goal: (MeasureTheory.Measure.pi μ) {f | f i = x} = 0

full_name: MeasureTheory.Measure.ae_eval_ne
code: theorem ae_eval_ne (i : ι) [NoAtoms (μ i)] (x : α i) : ∀ᵐ y : ∀ i, α i ∂Measure.pi μ, y i ≠ x 
goal: ∀ᵐ (y : (i : ι) → α i) ∂MeasureTheory.Measure.pi μ, y i ≠ x

full_name: MeasureTheory.Measure.tendsto_eval_ae_ae
code: theorem tendsto_eval_ae_ae {i : ι} : Tendsto (eval i) (ae (Measure.pi μ)) (ae (μ i)) 
goal: Filter.Tendsto (Function.eval i) (MeasureTheory.ae (MeasureTheory.Measure.pi μ)) (MeasureTheory.ae (μ i))

full_name: MeasureTheory.Measure.ae_pi_le_pi
code: theorem ae_pi_le_pi : ae (Measure.pi μ) ≤ Filter.pi fun i => ae (μ i) 
goal: MeasureTheory.ae (MeasureTheory.Measure.pi μ) ≤ Filter.pi fun i => MeasureTheory.ae (μ i)

full_name: MeasureTheory.Measure.ae_eq_pi
code: theorem ae_eq_pi {β : ι → Type*} {f f' : ∀ i, α i → β i} (h : ∀ i, f i =ᵐ[μ i] f' i) :
    (fun (x : ∀ i, α i) i => f i (x i)) =ᵐ[Measure.pi μ] fun x i => f' i (x i) 
goal: (fun x i => f i (x i)) =ᵐ[MeasureTheory.Measure.pi μ] fun x i => f' i (x i)

full_name: MeasureTheory.Measure.ae_le_pi
code: theorem ae_le_pi {β : ι → Type*} [∀ i, Preorder (β i)] {f f' : ∀ i, α i → β i}
    (h : ∀ i, f i ≤ᵐ[μ i] f' i) :
    (fun (x : ∀ i, α i) i => f i (x i)) ≤ᵐ[Measure.pi μ] fun x i => f' i (x i) 
goal: (fun x i => f i (x i)) ≤ᵐ[MeasureTheory.Measure.pi μ] fun x i => f' i (x i)

full_name: MeasureTheory.Measure.ae_le_set_pi
code: theorem ae_le_set_pi {I : Set ι} {s t : ∀ i, Set (α i)} (h : ∀ i ∈ I, s i ≤ᵐ[μ i] t i) :
    Set.pi I s ≤ᵐ[Measure.pi μ] Set.pi I t 
goal: I.pi s ≤ᵐ[MeasureTheory.Measure.pi μ] I.pi t

full_name: MeasureTheory.Measure.ae_eq_set_pi
code: theorem ae_eq_set_pi {I : Set ι} {s t : ∀ i, Set (α i)} (h : ∀ i ∈ I, s i =ᵐ[μ i] t i) :
    Set.pi I s =ᵐ[Measure.pi μ] Set.pi I t 
goal: I.pi s =ᵐ[MeasureTheory.Measure.pi μ] I.pi t

full_name: MeasureTheory.Measure.pi_map_piCongrLeft
code: lemma pi_map_piCongrLeft [hι' : Fintype ι'] (e : ι ≃ ι') {β : ι' → Type*}
    [∀ i, MeasurableSpace (β i)] (μ : (i : ι') → Measure (β i)) [∀ i, SigmaFinite (μ i)] :
    (Measure.pi fun i ↦ μ (e i)).map (MeasurableEquiv.piCongrLeft (fun i ↦ β i) e)
      = Measure.pi μ 
goal: MeasureTheory.Measure.map (⇑(MeasurableEquiv.piCongrLeft (fun i => β i) e))
    (MeasureTheory.Measure.pi fun i => μ (e i)) =
  MeasureTheory.Measure.pi μ

full_name: MeasureTheory.Measure.pi_map_piOptionEquivProd
code: lemma pi_map_piOptionEquivProd {β : Option ι → Type*} [∀ i, MeasurableSpace (β i)]
    (μ : (i : Option ι) → Measure (β i)) [∀ (i : Option ι), SigmaFinite (μ i)] :
    ((Measure.pi fun i ↦ μ (some i)).prod (μ none)).map
      (MeasurableEquiv.piOptionEquivProd β).symm = Measure.pi μ 
goal: MeasureTheory.Measure.map (⇑(MeasurableEquiv.piOptionEquivProd β).symm)
    ((MeasureTheory.Measure.pi fun i => μ (some i)).prod (μ none)) =
  MeasureTheory.Measure.pi μ

full_name: MeasureTheory.Measure.pi_Iio_ae_eq_pi_Iic
code: theorem pi_Iio_ae_eq_pi_Iic {s : Set ι} {f : ∀ i, α i} :
    (pi s fun i => Iio (f i)) =ᵐ[Measure.pi μ] pi s fun i => Iic (f i) 
goal: (s.pi fun i => Set.Iio (f i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Iic (f i)

full_name: MeasureTheory.Measure.pi_Ioi_ae_eq_pi_Ici
code: theorem pi_Ioi_ae_eq_pi_Ici {s : Set ι} {f : ∀ i, α i} :
    (pi s fun i => Ioi (f i)) =ᵐ[Measure.pi μ] pi s fun i => Ici (f i) 
goal: (s.pi fun i => Set.Ioi (f i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Ici (f i)

full_name: MeasureTheory.Measure.univ_pi_Iio_ae_eq_Iic
code: theorem univ_pi_Iio_ae_eq_Iic {f : ∀ i, α i} :
    (pi univ fun i => Iio (f i)) =ᵐ[Measure.pi μ] Iic f 
goal: (Set.univ.pi fun i => Set.Iio (f i)) =ᵐ[MeasureTheory.Measure.pi μ] Set.Iic f

full_name: MeasureTheory.Measure.univ_pi_Ioi_ae_eq_Ici
code: theorem univ_pi_Ioi_ae_eq_Ici {f : ∀ i, α i} :
    (pi univ fun i => Ioi (f i)) =ᵐ[Measure.pi μ] Ici f 
goal: (Set.univ.pi fun i => Set.Ioi (f i)) =ᵐ[MeasureTheory.Measure.pi μ] Set.Ici f

full_name: MeasureTheory.Measure.pi_Ioo_ae_eq_pi_Icc
code: theorem pi_Ioo_ae_eq_pi_Icc {s : Set ι} {f g : ∀ i, α i} :
    (pi s fun i => Ioo (f i) (g i)) =ᵐ[Measure.pi μ] pi s fun i => Icc (f i) (g i) 
goal: (s.pi fun i => Set.Ioo (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Icc (f i) (g i)

full_name: MeasureTheory.Measure.pi_Ioo_ae_eq_pi_Ioc
code: theorem pi_Ioo_ae_eq_pi_Ioc {s : Set ι} {f g : ∀ i, α i} :
    (pi s fun i => Ioo (f i) (g i)) =ᵐ[Measure.pi μ] pi s fun i => Ioc (f i) (g i) 
goal: (s.pi fun i => Set.Ioo (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Ioc (f i) (g i)

full_name: MeasureTheory.Measure.univ_pi_Ioo_ae_eq_Icc
code: theorem univ_pi_Ioo_ae_eq_Icc {f g : ∀ i, α i} :
    (pi univ fun i => Ioo (f i) (g i)) =ᵐ[Measure.pi μ] Icc f g 
goal: (Set.univ.pi fun i => Set.Ioo (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] Set.Icc f g

full_name: MeasureTheory.Measure.pi_Ioc_ae_eq_pi_Icc
code: theorem pi_Ioc_ae_eq_pi_Icc {s : Set ι} {f g : ∀ i, α i} :
    (pi s fun i => Ioc (f i) (g i)) =ᵐ[Measure.pi μ] pi s fun i => Icc (f i) (g i) 
goal: (s.pi fun i => Set.Ioc (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Icc (f i) (g i)

full_name: MeasureTheory.Measure.univ_pi_Ioc_ae_eq_Icc
code: theorem univ_pi_Ioc_ae_eq_Icc {f g : ∀ i, α i} :
    (pi univ fun i => Ioc (f i) (g i)) =ᵐ[Measure.pi μ] Icc f g 
goal: (Set.univ.pi fun i => Set.Ioc (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] Set.Icc f g

full_name: MeasureTheory.Measure.pi_Ico_ae_eq_pi_Icc
code: theorem pi_Ico_ae_eq_pi_Icc {s : Set ι} {f g : ∀ i, α i} :
    (pi s fun i => Ico (f i) (g i)) =ᵐ[Measure.pi μ] pi s fun i => Icc (f i) (g i) 
goal: (s.pi fun i => Set.Ico (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] s.pi fun i => Set.Icc (f i) (g i)

full_name: MeasureTheory.Measure.univ_pi_Ico_ae_eq_Icc
code: theorem univ_pi_Ico_ae_eq_Icc {f g : ∀ i, α i} :
    (pi univ fun i => Ico (f i) (g i)) =ᵐ[Measure.pi μ] Icc f g 
goal: (Set.univ.pi fun i => Set.Ico (f i) (g i)) =ᵐ[MeasureTheory.Measure.pi μ] Set.Icc f g

full_name: MeasureTheory.Measure.pi_noAtoms
code: /-- If one of the measures `μ i` has no atoms, them `Measure.pi µ`
has no atoms. The instance below assumes that all `μ i` have no atoms. -/
theorem pi_noAtoms (i : ι) [NoAtoms (μ i)] : NoAtoms (Measure.pi μ) 
goal: MeasureTheory.NoAtoms (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.pi_noAtoms'
code: instance pi_noAtoms' [h : Nonempty ι] [∀ i, NoAtoms (μ i)] : NoAtoms (Measure.pi μ) 
goal: MeasureTheory.NoAtoms (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.instNoAtomsForallVolumeOfNonemptyOfSigmaFinite
code: instance {α : ι → Type*} [Nonempty ι] [∀ i, MeasureSpace (α i)]
    [∀ i, SigmaFinite (volume : Measure (α i))] [∀ i, NoAtoms (volume : Measure (α i))] :
    NoAtoms (volume : Measure (∀ i, α i)) 
goal: MeasureTheory.NoAtoms MeasureTheory.volume

full_name: MeasureTheory.Measure.pi.isLocallyFiniteMeasure
code: instance pi.isLocallyFiniteMeasure
    [∀ i, TopologicalSpace (α i)] [∀ i, IsLocallyFiniteMeasure (μ i)] :
    IsLocallyFiniteMeasure (Measure.pi μ) 
goal: MeasureTheory.IsLocallyFiniteMeasure (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.instIsLocallyFiniteMeasureForallVolumeOfSigmaFinite
code: instance {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, MeasureSpace (X i)]
    [∀ i, SigmaFinite (volume : Measure (X i))]
    [∀ i, IsLocallyFiniteMeasure (volume : Measure (X i))] :
    IsLocallyFiniteMeasure (volume : Measure (∀ i, X i)) 
goal: MeasureTheory.IsLocallyFiniteMeasure MeasureTheory.volume

full_name: MeasureTheory.Measure.pi.isMulLeftInvariant
code: @[to_additive]
instance pi.isMulLeftInvariant [∀ i, Group (α i)] [∀ i, MeasurableMul (α i)]
    [∀ i, IsMulLeftInvariant (μ i)] : IsMulLeftInvariant (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsMulLeftInvariant

full_name: MeasureTheory.Measure.pi.isAddLeftInvariant
code: @[to_additive]
instance pi.isMulLeftInvariant [∀ i, Group (α i)] [∀ i, MeasurableMul (α i)]
    [∀ i, IsMulLeftInvariant (μ i)] : IsMulLeftInvariant (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsAddLeftInvariant

full_name: MeasureTheory.Measure.instIsAddLeftInvariantForallVolumeOfMeasurableAddOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableMul (G i)]
    [∀ i, SigmaFinite (volume : Measure (G i))] [∀ i, IsMulLeftInvariant (volume : Measure (G i))] :
    IsMulLeftInvariant (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsAddLeftInvariant

full_name: MeasureTheory.Measure.instIsMulLeftInvariantForallVolumeOfMeasurableMulOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableMul (G i)]
    [∀ i, SigmaFinite (volume : Measure (G i))] [∀ i, IsMulLeftInvariant (volume : Measure (G i))] :
    IsMulLeftInvariant (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsMulLeftInvariant

full_name: MeasureTheory.Measure.pi.isMulRightInvariant
code: @[to_additive]
instance pi.isMulRightInvariant [∀ i, Group (α i)] [∀ i, MeasurableMul (α i)]
    [∀ i, IsMulRightInvariant (μ i)] : IsMulRightInvariant (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsMulRightInvariant

full_name: MeasureTheory.Measure.pi.isAddRightInvariant
code: @[to_additive]
instance pi.isMulRightInvariant [∀ i, Group (α i)] [∀ i, MeasurableMul (α i)]
    [∀ i, IsMulRightInvariant (μ i)] : IsMulRightInvariant (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsAddRightInvariant

full_name: MeasureTheory.Measure.instIsAddRightInvariantForallVolumeOfMeasurableAddOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableMul (G i)]
    [∀ i, SigmaFinite (volume : Measure (G i))]
    [∀ i, IsMulRightInvariant (volume : Measure (G i))] :
    IsMulRightInvariant (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsAddRightInvariant

full_name: MeasureTheory.Measure.instIsMulRightInvariantForallVolumeOfMeasurableMulOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableMul (G i)]
    [∀ i, SigmaFinite (volume : Measure (G i))]
    [∀ i, IsMulRightInvariant (volume : Measure (G i))] :
    IsMulRightInvariant (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsMulRightInvariant

full_name: MeasureTheory.Measure.pi.isInvInvariant
code: @[to_additive]
instance pi.isInvInvariant [∀ i, Group (α i)] [∀ i, MeasurableInv (α i)]
    [∀ i, IsInvInvariant (μ i)] : IsInvInvariant (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsInvInvariant

full_name: MeasureTheory.Measure.pi.isNegInvariant
code: @[to_additive]
instance pi.isInvInvariant [∀ i, Group (α i)] [∀ i, MeasurableInv (α i)]
    [∀ i, IsInvInvariant (μ i)] : IsInvInvariant (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsNegInvariant

full_name: MeasureTheory.Measure.instIsInvInvariantForallVolumeOfMeasurableInvOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableInv (G i)]
    [∀ i, SigmaFinite (volume : Measure (G i))] [∀ i, IsInvInvariant (volume : Measure (G i))] :
    IsInvInvariant (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsInvInvariant

full_name: MeasureTheory.Measure.instIsNegInvariantForallVolumeOfMeasurableNegOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableInv (G i)]
    [∀ i, SigmaFinite (volume : Measure (G i))] [∀ i, IsInvInvariant (volume : Measure (G i))] :
    IsInvInvariant (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsNegInvariant

full_name: MeasureTheory.Measure.pi.isOpenPosMeasure
code: instance pi.isOpenPosMeasure [∀ i, TopologicalSpace (α i)] [∀ i, IsOpenPosMeasure (μ i)] :
    IsOpenPosMeasure (MeasureTheory.Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsOpenPosMeasure

full_name: MeasureTheory.Measure.instIsOpenPosMeasureForallVolumeOfSigmaFinite
code: instance {X : ι → Type*} [∀ i, TopologicalSpace (X i)] [∀ i, MeasureSpace (X i)]
    [∀ i, IsOpenPosMeasure (volume : Measure (X i))] [∀ i, SigmaFinite (volume : Measure (X i))] :
    IsOpenPosMeasure (volume : Measure (∀ i, X i)) 
goal: MeasureTheory.volume.IsOpenPosMeasure

full_name: MeasureTheory.Measure.pi.isFiniteMeasureOnCompacts
code: instance pi.isFiniteMeasureOnCompacts [∀ i, TopologicalSpace (α i)]
    [∀ i, IsFiniteMeasureOnCompacts (μ i)] :
    IsFiniteMeasureOnCompacts (MeasureTheory.Measure.pi μ) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.Measure.instIsFiniteMeasureOnCompactsForallVolumeOfSigmaFinite
code: instance {X : ι → Type*} [∀ i, MeasureSpace (X i)] [∀ i, TopologicalSpace (X i)]
    [∀ i, SigmaFinite (volume : Measure (X i))]
    [∀ i, IsFiniteMeasureOnCompacts (volume : Measure (X i))] :
    IsFiniteMeasureOnCompacts (volume : Measure (∀ i, X i)) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts MeasureTheory.volume

full_name: MeasureTheory.Measure.pi.isAddHaarMeasure
code: @[to_additive]
instance pi.isHaarMeasure [∀ i, Group (α i)] [∀ i, TopologicalSpace (α i)]
    [∀ i, IsHaarMeasure (μ i)] [∀ i, MeasurableMul (α i)] : IsHaarMeasure (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsAddHaarMeasure

full_name: MeasureTheory.Measure.pi.isHaarMeasure
code: @[to_additive]
instance pi.isHaarMeasure [∀ i, Group (α i)] [∀ i, TopologicalSpace (α i)]
    [∀ i, IsHaarMeasure (μ i)] [∀ i, MeasurableMul (α i)] : IsHaarMeasure (Measure.pi μ) 
goal: (MeasureTheory.Measure.pi μ).IsHaarMeasure

full_name: MeasureTheory.Measure.instIsAddHaarMeasureForallVolumeOfMeasurableAddOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableMul (G i)]
    [∀ i, TopologicalSpace (G i)] [∀ i, SigmaFinite (volume : Measure (G i))]
    [∀ i, IsHaarMeasure (volume : Measure (G i))] : IsHaarMeasure (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsAddHaarMeasure

full_name: MeasureTheory.Measure.instIsHaarMeasureForallVolumeOfMeasurableMulOfSigmaFinite
code: @[to_additive]
instance {G : ι → Type*} [∀ i, Group (G i)] [∀ i, MeasureSpace (G i)] [∀ i, MeasurableMul (G i)]
    [∀ i, TopologicalSpace (G i)] [∀ i, SigmaFinite (volume : Measure (G i))]
    [∀ i, IsHaarMeasure (volume : Measure (G i))] : IsHaarMeasure (volume : Measure (∀ i, G i)) 
goal: MeasureTheory.volume.IsHaarMeasure

full_name: MeasureTheory.volume_pi
code: theorem volume_pi [∀ i, MeasureSpace (α i)] :
    (volume : Measure (∀ i, α i)) = Measure.pi fun _ => volume 
goal: MeasureTheory.volume = MeasureTheory.Measure.pi fun x => MeasureTheory.volume

full_name: MeasureTheory.volume_pi_pi
code: theorem volume_pi_pi [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))]
    (s : ∀ i, Set (α i)) : volume (pi univ s) = ∏ i, volume (s i) 
goal: MeasureTheory.volume (Set.univ.pi s) = ∏ i : ι, MeasureTheory.volume (s i)

full_name: MeasureTheory.volume_pi_ball
code: theorem volume_pi_ball [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))]
    [∀ i, MetricSpace (α i)] (x : ∀ i, α i) {r : ℝ} (hr : 0 < r) :
    volume (Metric.ball x r) = ∏ i, volume (Metric.ball (x i) r) 
goal: MeasureTheory.volume (Metric.ball x r) = ∏ i : ι, MeasureTheory.volume (Metric.ball (x i) r)

full_name: MeasureTheory.volume_pi_closedBall
code: theorem volume_pi_closedBall [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))]
    [∀ i, MetricSpace (α i)] (x : ∀ i, α i) {r : ℝ} (hr : 0 ≤ r) :
    volume (Metric.closedBall x r) = ∏ i, volume (Metric.closedBall (x i) r) 
goal: MeasureTheory.volume (Metric.closedBall x r) = ∏ i : ι, MeasureTheory.volume (Metric.closedBall (x i) r)

full_name: MeasureTheory.Pi.isMulLeftInvariant_volume
code: /-- We intentionally restrict this only to the nondependent function space, since type-class
inference cannot find an instance for `ι → ℝ` when this is stated for dependent function spaces. -/
@[to_additive "We intentionally restrict this only to the nondependent function space, since
type-class inference cannot find an instance for `ι → ℝ` when this is stated for dependent function
spaces."]
instance Pi.isMulLeftInvariant_volume {α} [Group α] [MeasureSpace α]
    [SigmaFinite (volume : Measure α)] [MeasurableMul α] [IsMulLeftInvariant (volume : Measure α)] :
    IsMulLeftInvariant (volume : Measure (ι → α)) 
goal: MeasureTheory.volume.IsMulLeftInvariant

full_name: MeasureTheory.Pi.isAddLeftInvariant_volume
code: /-- We intentionally restrict this only to the nondependent function space, since type-class
inference cannot find an instance for `ι → ℝ` when this is stated for dependent function spaces. -/
@[to_additive "We intentionally restrict this only to the nondependent function space, since
type-class inference cannot find an instance for `ι → ℝ` when this is stated for dependent function
spaces."]
instance Pi.isMulLeftInvariant_volume {α} [Group α] [MeasureSpace α]
    [SigmaFinite (volume : Measure α)] [MeasurableMul α] [IsMulLeftInvariant (volume : Measure α)] :
    IsMulLeftInvariant (volume : Measure (ι → α)) 
goal: MeasureTheory.volume.IsAddLeftInvariant

full_name: MeasureTheory.Pi.isNegInvariant_volume
code: /-- We intentionally restrict this only to the nondependent function space, since type-class
inference cannot find an instance for `ι → ℝ` when this is stated for dependent function spaces. -/
@[to_additive "We intentionally restrict this only to the nondependent function space, since
type-class inference cannot find an instance for `ι → ℝ` when this is stated for dependent function
spaces."]
instance Pi.isInvInvariant_volume {α} [Group α] [MeasureSpace α] [SigmaFinite (volume : Measure α)]
    [MeasurableInv α] [IsInvInvariant (volume : Measure α)] :
    IsInvInvariant (volume : Measure (ι → α)) 
goal: MeasureTheory.volume.IsNegInvariant

full_name: MeasureTheory.Pi.isInvInvariant_volume
code: /-- We intentionally restrict this only to the nondependent function space, since type-class
inference cannot find an instance for `ι → ℝ` when this is stated for dependent function spaces. -/
@[to_additive "We intentionally restrict this only to the nondependent function space, since
type-class inference cannot find an instance for `ι → ℝ` when this is stated for dependent function
spaces."]
instance Pi.isInvInvariant_volume {α} [Group α] [MeasureSpace α] [SigmaFinite (volume : Measure α)]
    [MeasurableInv α] [IsInvInvariant (volume : Measure α)] :
    IsInvInvariant (volume : Measure (ι → α)) 
goal: MeasureTheory.volume.IsInvInvariant

full_name: MeasureTheory.measurePreserving_piEquivPiSubtypeProd
code: theorem measurePreserving_piEquivPiSubtypeProd (p : ι → Prop) [DecidablePred p] :
    MeasurePreserving (MeasurableEquiv.piEquivPiSubtypeProd α p) (Measure.pi μ)
      ((Measure.pi fun i : Subtype p => μ i).prod (Measure.pi fun i => μ i)) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piEquivPiSubtypeProd α p)) (MeasureTheory.Measure.pi μ)
  ((MeasureTheory.Measure.pi fun i => μ ↑i).prod (MeasureTheory.Measure.pi fun i => μ ↑i))

full_name: MeasureTheory.volume_preserving_piEquivPiSubtypeProd
code: theorem volume_preserving_piEquivPiSubtypeProd (α : ι → Type*)
    [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))] (p : ι → Prop)
    [DecidablePred p] : MeasurePreserving (MeasurableEquiv.piEquivPiSubtypeProd α p) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piEquivPiSubtypeProd α p)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_piCongrLeft
code: theorem measurePreserving_piCongrLeft (f : ι' ≃ ι) :
    MeasurePreserving (MeasurableEquiv.piCongrLeft α f)
      (Measure.pi fun i' => μ (f i')) (Measure.pi μ) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piCongrLeft α f)) (MeasureTheory.Measure.pi fun i' => μ (f i'))
  (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.volume_measurePreserving_piCongrLeft
code: theorem volume_measurePreserving_piCongrLeft (α : ι → Type*) (f : ι' ≃ ι)
    [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))] :
    MeasurePreserving (MeasurableEquiv.piCongrLeft α f) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piCongrLeft α f)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_sumPiEquivProdPi_symm
code: theorem measurePreserving_sumPiEquivProdPi_symm {π : ι ⊕ ι' → Type*}
    {m : ∀ i, MeasurableSpace (π i)} (μ : ∀ i, Measure (π i)) [∀ i, SigmaFinite (μ i)] :
    MeasurePreserving (MeasurableEquiv.sumPiEquivProdPi π).symm
      ((Measure.pi fun i => μ (.inl i)).prod (Measure.pi fun i => μ (.inr i))) (Measure.pi μ) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm)
  ((MeasureTheory.Measure.pi fun i => μ (Sum.inl i)).prod (MeasureTheory.Measure.pi fun i => μ (Sum.inr i)))
  (MeasureTheory.Measure.pi μ)

full_name: MeasureTheory.volume_measurePreserving_sumPiEquivProdPi_symm
code: theorem volume_measurePreserving_sumPiEquivProdPi_symm (π : ι ⊕ ι' → Type*)
    [∀ i, MeasureSpace (π i)] [∀ i, SigmaFinite (volume : Measure (π i))] :
    MeasurePreserving (MeasurableEquiv.sumPiEquivProdPi π).symm volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.sumPiEquivProdPi π).symm) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_sumPiEquivProdPi
code: theorem measurePreserving_sumPiEquivProdPi {π : ι ⊕ ι' → Type*} {_m : ∀ i, MeasurableSpace (π i)}
    (μ : ∀ i, Measure (π i)) [∀ i, SigmaFinite (μ i)] :
    MeasurePreserving (MeasurableEquiv.sumPiEquivProdPi π)
      (Measure.pi μ) ((Measure.pi fun i => μ (.inl i)).prod (Measure.pi fun i => μ (.inr i))) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.sumPiEquivProdPi π)) (MeasureTheory.Measure.pi μ)
  ((MeasureTheory.Measure.pi fun i => μ (Sum.inl i)).prod (MeasureTheory.Measure.pi fun i => μ (Sum.inr i)))

full_name: MeasureTheory.volume_measurePreserving_sumPiEquivProdPi
code: theorem volume_measurePreserving_sumPiEquivProdPi (π : ι ⊕ ι' → Type*)
    [∀ i, MeasureSpace (π i)] [∀ i, SigmaFinite (volume : Measure (π i))] :
    MeasurePreserving (MeasurableEquiv.sumPiEquivProdPi π) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.sumPiEquivProdPi π)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_piFinSuccAbove
code: theorem measurePreserving_piFinSuccAbove {n : ℕ} {α : Fin (n + 1) → Type u}
    {m : ∀ i, MeasurableSpace (α i)} (μ : ∀ i, Measure (α i)) [∀ i, SigmaFinite (μ i)]
    (i : Fin (n + 1)) :
    MeasurePreserving (MeasurableEquiv.piFinSuccAbove α i) (Measure.pi μ)
      ((μ i).prod <| Measure.pi fun j => μ (i.succAbove j)) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinSuccAbove α i)) (MeasureTheory.Measure.pi μ)
  ((μ i).prod (MeasureTheory.Measure.pi fun j => μ (i.succAbove j)))

full_name: MeasureTheory.volume_preserving_piFinSuccAbove
code: theorem volume_preserving_piFinSuccAbove {n : ℕ} (α : Fin (n + 1) → Type u)
    [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))] (i : Fin (n + 1)) :
    MeasurePreserving (MeasurableEquiv.piFinSuccAbove α i) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinSuccAbove α i)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_piUnique
code: theorem measurePreserving_piUnique {π : ι → Type*} [Unique ι] {m : ∀ i, MeasurableSpace (π i)}
    (μ : ∀ i, Measure (π i)) :
    MeasurePreserving (MeasurableEquiv.piUnique π) (Measure.pi μ) (μ default) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piUnique π)) (MeasureTheory.Measure.pi μ) (μ default)

full_name: MeasureTheory.volume_preserving_piUnique
code: theorem volume_preserving_piUnique (π : ι → Type*) [Unique ι] [∀ i, MeasureSpace (π i)] :
    MeasurePreserving (MeasurableEquiv.piUnique π) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piUnique π)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_funUnique
code: theorem measurePreserving_funUnique {β : Type u} {_m : MeasurableSpace β} (μ : Measure β)
    (α : Type v) [Unique α] :
    MeasurePreserving (MeasurableEquiv.funUnique α β) (Measure.pi fun _ : α => μ) μ 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.funUnique α β)) (MeasureTheory.Measure.pi fun x => μ) μ

full_name: MeasureTheory.volume_preserving_funUnique
code: theorem volume_preserving_funUnique (α : Type u) (β : Type v) [Unique α] [MeasureSpace β] :
    MeasurePreserving (MeasurableEquiv.funUnique α β) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.funUnique α β)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_piFinTwo
code: theorem measurePreserving_piFinTwo {α : Fin 2 → Type u} {m : ∀ i, MeasurableSpace (α i)}
    (μ : ∀ i, Measure (α i)) [∀ i, SigmaFinite (μ i)] :
    MeasurePreserving (MeasurableEquiv.piFinTwo α) (Measure.pi μ) ((μ 0).prod (μ 1)) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinTwo α)) (MeasureTheory.Measure.pi μ) ((μ 0).prod (μ 1))

full_name: MeasureTheory.volume_preserving_piFinTwo
code: theorem volume_preserving_piFinTwo (α : Fin 2 → Type u) [∀ i, MeasureSpace (α i)]
    [∀ i, SigmaFinite (volume : Measure (α i))] :
    MeasurePreserving (MeasurableEquiv.piFinTwo α) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinTwo α)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_finTwoArrow_vec
code: theorem measurePreserving_finTwoArrow_vec {α : Type u} {m : MeasurableSpace α} (μ ν : Measure α)
    [SigmaFinite μ] [SigmaFinite ν] :
    MeasurePreserving MeasurableEquiv.finTwoArrow (Measure.pi ![μ, ν]) (μ.prod ν) 
goal: MeasureTheory.MeasurePreserving (⇑MeasurableEquiv.finTwoArrow) (MeasureTheory.Measure.pi ![μ, ν]) (μ.prod ν)

full_name: MeasureTheory.measurePreserving_finTwoArrow
code: theorem measurePreserving_finTwoArrow {α : Type u} {m : MeasurableSpace α} (μ : Measure α)
    [SigmaFinite μ] :
    MeasurePreserving MeasurableEquiv.finTwoArrow (Measure.pi fun _ => μ) (μ.prod μ) 
goal: MeasureTheory.MeasurePreserving (⇑MeasurableEquiv.finTwoArrow) (MeasureTheory.Measure.pi fun x => μ) (μ.prod μ)

full_name: MeasureTheory.volume_preserving_finTwoArrow
code: theorem volume_preserving_finTwoArrow (α : Type u) [MeasureSpace α]
    [SigmaFinite (volume : Measure α)] :
    MeasurePreserving (@MeasurableEquiv.finTwoArrow α _) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑MeasurableEquiv.finTwoArrow) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_pi_empty
code: theorem measurePreserving_pi_empty {ι : Type u} {α : ι → Type v} [Fintype ι] [IsEmpty ι]
    {m : ∀ i, MeasurableSpace (α i)} (μ : ∀ i, Measure (α i)) :
    MeasurePreserving (MeasurableEquiv.ofUniqueOfUnique (∀ i, α i) Unit) (Measure.pi μ)
      (Measure.dirac ()) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.ofUniqueOfUnique ((i : ι) → α i) Unit)) (MeasureTheory.Measure.pi μ)
  (MeasureTheory.Measure.dirac ())

full_name: MeasureTheory.volume_preserving_pi_empty
code: theorem volume_preserving_pi_empty {ι : Type u} (α : ι → Type v) [Fintype ι] [IsEmpty ι]
    [∀ i, MeasureSpace (α i)] :
    MeasurePreserving (MeasurableEquiv.ofUniqueOfUnique (∀ i, α i) Unit) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.ofUniqueOfUnique ((i : ι) → α i) Unit)) MeasureTheory.volume
  MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_piFinsetUnion
code: theorem measurePreserving_piFinsetUnion [DecidableEq ι] {s t : Finset ι} (h : Disjoint s t)
    (μ : ∀ i, Measure (α i)) [∀ i, SigmaFinite (μ i)] :
    MeasurePreserving (MeasurableEquiv.piFinsetUnion α h)
      ((Measure.pi fun i : s ↦ μ i).prod (Measure.pi fun i : t ↦ μ i))
      (Measure.pi fun i : ↥(s ∪ t) ↦ μ i) 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinsetUnion α h))
  ((MeasureTheory.Measure.pi fun i => μ ↑i).prod (MeasureTheory.Measure.pi fun i => μ ↑i))
  (MeasureTheory.Measure.pi fun i => μ ↑i)

full_name: MeasureTheory.volume_preserving_piFinsetUnion
code: theorem volume_preserving_piFinsetUnion (α : ι → Type*) [DecidableEq ι] {s t : Finset ι}
    (h : Disjoint s t) [∀ i, MeasureSpace (α i)] [∀ i, SigmaFinite (volume : Measure (α i))] :
    MeasurePreserving (MeasurableEquiv.piFinsetUnion α h) volume volume 
goal: MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.piFinsetUnion α h)) MeasureTheory.volume MeasureTheory.volume

full_name: MeasureTheory.measurePreserving_pi
code: theorem measurePreserving_pi {β : ι → Type*} [∀ i, MeasurableSpace (β i)]
    (ν : (i : ι) → Measure (β i)) {f : (i : ι) → (α i) → (β i)} [∀ i, SigmaFinite (ν i)]
    (hf : ∀ i, MeasurePreserving (f i) (μ i) (ν i)) :
    MeasurePreserving (fun a i ↦ f i (a i)) (Measure.pi μ) (Measure.pi ν) 
goal: MeasureTheory.MeasurePreserving (fun a i => f i (a i)) (MeasureTheory.Measure.pi μ) (MeasureTheory.Measure.pi ν)

full_name: MeasureTheory.volume_preserving_pi
code: theorem volume_preserving_pi {α' β' : ι → Type*} [∀ i, MeasureSpace (α' i)]
    [∀ i, MeasureSpace (β' i)] [∀ i, SigmaFinite (volume : Measure (β' i))]
    {f : (i : ι) → (α' i) → (β' i)} (hf : ∀ i, MeasurePreserving (f i)) :
    MeasurePreserving (fun (a : (i : ι) → α' i) (i : ι) ↦ (f i) (a i)) 
goal: MeasureTheory.MeasurePreserving (fun a i => f i (a i)) MeasureTheory.volume MeasureTheory.volume