File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

full_name: MeasureTheory.IsFiniteMeasure
code: /-- A measure `μ` is called finite if `μ univ < ∞`. -/
class IsFiniteMeasure (μ : Measure α) : Prop where
  measure_univ_lt_top : μ univ < ∞
goal: Prop

full_name: MeasureTheory.IsFiniteMeasure.measure_univ_lt_top
code: /-- A measure `μ` is called finite if `μ univ < ∞`. -/
class IsFiniteMeasure (μ : Measure α) : Prop where
  measure_univ_lt_top : μ univ < ∞
goal: μ Set.univ < ⊤

full_name: MeasureTheory.not_isFiniteMeasure_iff
code: theorem not_isFiniteMeasure_iff : ¬IsFiniteMeasure μ ↔ μ Set.univ = ∞ 
goal: ¬MeasureTheory.IsFiniteMeasure μ ↔ μ Set.univ = ⊤

full_name: MeasureTheory.Restrict.isFiniteMeasure
code: instance Restrict.isFiniteMeasure (μ : Measure α) [hs : Fact (μ s < ∞)] :
    IsFiniteMeasure (μ.restrict s) 
goal: MeasureTheory.IsFiniteMeasure (μ.restrict s)

full_name: MeasureTheory.measure_lt_top
code: theorem measure_lt_top (μ : Measure α) [IsFiniteMeasure μ] (s : Set α) : μ s < ∞ 
goal: μ s < ⊤

full_name: MeasureTheory.isFiniteMeasureRestrict
code: instance isFiniteMeasureRestrict (μ : Measure α) (s : Set α) [h : IsFiniteMeasure μ] :
    IsFiniteMeasure (μ.restrict s) 
goal: MeasureTheory.IsFiniteMeasure (μ.restrict s)

full_name: MeasureTheory.measure_ne_top
code: theorem measure_ne_top (μ : Measure α) [IsFiniteMeasure μ] (s : Set α) : μ s ≠ ∞ 
goal: μ s ≠ ⊤

full_name: MeasureTheory.measure_compl_le_add_of_le_add
code: theorem measure_compl_le_add_of_le_add [IsFiniteMeasure μ] (hs : MeasurableSet s)
    (ht : MeasurableSet t) {ε : ℝ≥0∞} (h : μ s ≤ μ t + ε) : μ tᶜ ≤ μ sᶜ + ε 
goal: μ tᶜ ≤ μ sᶜ + ε

full_name: MeasureTheory.measure_compl_le_add_iff
code: theorem measure_compl_le_add_iff [IsFiniteMeasure μ] (hs : MeasurableSet s) (ht : MeasurableSet t)
    {ε : ℝ≥0∞} : μ sᶜ ≤ μ tᶜ + ε ↔ μ t ≤ μ s + ε 
goal: μ sᶜ ≤ μ tᶜ + ε ↔ μ t ≤ μ s + ε

full_name: MeasureTheory.measureUnivNNReal
code: /-- The measure of the whole space with respect to a finite measure, considered as `ℝ≥0`. -/
def measureUnivNNReal (μ : Measure α) : ℝ≥0 
goal: ℝ≥0

full_name: MeasureTheory.coe_measureUnivNNReal
code: @[simp]
theorem coe_measureUnivNNReal (μ : Measure α) [IsFiniteMeasure μ] :
    ↑(measureUnivNNReal μ) = μ univ 
goal: ↑(MeasureTheory.measureUnivNNReal μ) = μ Set.univ

full_name: MeasureTheory.isFiniteMeasureZero
code: instance isFiniteMeasureZero : IsFiniteMeasure (0 : Measure α) 
goal: MeasureTheory.IsFiniteMeasure 0

full_name: MeasureTheory.isFiniteMeasureOfIsEmpty
code: instance (priority := 50) isFiniteMeasureOfIsEmpty [IsEmpty α] : IsFiniteMeasure μ 
goal: MeasureTheory.IsFiniteMeasure μ

full_name: MeasureTheory.measureUnivNNReal_zero
code: @[simp]
theorem measureUnivNNReal_zero : measureUnivNNReal (0 : Measure α) = 0 
goal: MeasureTheory.measureUnivNNReal 0 = 0

full_name: MeasureTheory.isFiniteMeasureAdd
code: instance isFiniteMeasureAdd [IsFiniteMeasure μ] [IsFiniteMeasure ν] : IsFiniteMeasure (μ + ν) 
goal: MeasureTheory.IsFiniteMeasure (μ + ν)

full_name: MeasureTheory.isFiniteMeasureSMulNNReal
code: instance isFiniteMeasureSMulNNReal [IsFiniteMeasure μ] {r : ℝ≥0} : IsFiniteMeasure (r • μ) 
goal: MeasureTheory.IsFiniteMeasure (r • μ)

full_name: MeasureTheory.IsFiniteMeasure.average
code: instance IsFiniteMeasure.average : IsFiniteMeasure ((μ univ)⁻¹ • μ) 
goal: MeasureTheory.IsFiniteMeasure ((μ Set.univ)⁻¹ • μ)

full_name: MeasureTheory.isFiniteMeasureSMulOfNNRealTower
code: instance isFiniteMeasureSMulOfNNRealTower {R} [SMul R ℝ≥0] [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0 ℝ≥0∞]
    [IsScalarTower R ℝ≥0∞ ℝ≥0∞] [IsFiniteMeasure μ] {r : R} : IsFiniteMeasure (r • μ) 
goal: MeasureTheory.IsFiniteMeasure (r • μ)

full_name: MeasureTheory.isFiniteMeasure_of_le
code: theorem isFiniteMeasure_of_le (μ : Measure α) [IsFiniteMeasure μ] (h : ν ≤ μ) : IsFiniteMeasure ν 
goal: MeasureTheory.IsFiniteMeasure ν

full_name: MeasureTheory.Measure.isFiniteMeasure_map
code: @[instance]
theorem Measure.isFiniteMeasure_map {m : MeasurableSpace α} (μ : Measure α) [IsFiniteMeasure μ]
    (f : α → β) : IsFiniteMeasure (μ.map f) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.Measure.map f μ)

full_name: MeasureTheory.measureUnivNNReal_eq_zero
code: @[simp]
theorem measureUnivNNReal_eq_zero [IsFiniteMeasure μ] : measureUnivNNReal μ = 0 ↔ μ = 0 
goal: MeasureTheory.measureUnivNNReal μ = 0 ↔ μ = 0

full_name: MeasureTheory.measureUnivNNReal_pos
code: theorem measureUnivNNReal_pos [IsFiniteMeasure μ] (hμ : μ ≠ 0) : 0 < measureUnivNNReal μ 
goal: 0 < MeasureTheory.measureUnivNNReal μ

full_name: MeasureTheory.Measure.le_of_add_le_add_left
code: /-- `le_of_add_le_add_left` is normally applicable to `OrderedCancelAddCommMonoid`,
but it holds for measures with the additional assumption that μ is finite. -/
theorem Measure.le_of_add_le_add_left [IsFiniteMeasure μ] (A2 : μ + ν₁ ≤ μ + ν₂) : ν₁ ≤ ν₂ 
goal: ν₁ ≤ ν₂

full_name: MeasureTheory.summable_measure_toReal
code: theorem summable_measure_toReal [hμ : IsFiniteMeasure μ] {f : ℕ → Set α}
    (hf₁ : ∀ i : ℕ, MeasurableSet (f i)) (hf₂ : Pairwise (Disjoint on f)) :
    Summable fun x => (μ (f x)).toReal 
goal: Summable fun x => (μ (f x)).toReal

full_name: MeasureTheory.ae_eq_univ_iff_measure_eq
code: theorem ae_eq_univ_iff_measure_eq [IsFiniteMeasure μ] (hs : NullMeasurableSet s μ) :
    s =ᵐ[μ] univ ↔ μ s = μ univ 
goal: s =ᵐ[μ] Set.univ ↔ μ s = μ Set.univ

full_name: MeasureTheory.ae_iff_measure_eq
code: theorem ae_iff_measure_eq [IsFiniteMeasure μ] {p : α → Prop}
    (hp : NullMeasurableSet { a | p a } μ) : (∀ᵐ a ∂μ, p a) ↔ μ { a | p a } = μ univ 
goal: (∀ᵐ (a : α) ∂μ, p a) ↔ μ {a | p a} = μ Set.univ

full_name: MeasureTheory.ae_mem_iff_measure_eq
code: theorem ae_mem_iff_measure_eq [IsFiniteMeasure μ] {s : Set α} (hs : NullMeasurableSet s μ) :
    (∀ᵐ a ∂μ, a ∈ s) ↔ μ s = μ univ 
goal: (∀ᵐ (a : α) ∂μ, a ∈ s) ↔ μ s = μ Set.univ

full_name: MeasureTheory.tendsto_measure_biUnion_Ici_zero_of_pairwise_disjoint
code: lemma tendsto_measure_biUnion_Ici_zero_of_pairwise_disjoint
    {X : Type*} [MeasurableSpace X] {μ : Measure X} [IsFiniteMeasure μ]
    {Es : ℕ → Set X} (Es_mble : ∀ i, MeasurableSet (Es i))
    (Es_disj : Pairwise fun n m ↦ Disjoint (Es n) (Es m)) :
    Tendsto (μ ∘ fun n ↦ ⋃ i ≥ n, Es i) atTop (𝓝 0) 
goal: Filter.Tendsto (⇑μ ∘ fun n => ⋃ i, ⋃ (_ : i ≥ n), Es i) Filter.atTop (𝓝 0)

full_name: MeasureTheory.abs_toReal_measure_sub_le_measure_symmDiff'
code: theorem abs_toReal_measure_sub_le_measure_symmDiff'
    (hs : MeasurableSet s) (ht : MeasurableSet t) (hs' : μ s ≠ ∞) (ht' : μ t ≠ ∞) :
    |(μ s).toReal - (μ t).toReal| ≤ (μ (s ∆ t)).toReal 
goal: |(μ s).toReal - (μ t).toReal| ≤ (μ (symmDiff s t)).toReal

full_name: MeasureTheory.abs_toReal_measure_sub_le_measure_symmDiff
code: theorem abs_toReal_measure_sub_le_measure_symmDiff [IsFiniteMeasure μ]
    (hs : MeasurableSet s) (ht : MeasurableSet t) :
    |(μ s).toReal - (μ t).toReal| ≤ (μ (s ∆ t)).toReal 
goal: |(μ s).toReal - (μ t).toReal| ≤ (μ (symmDiff s t)).toReal

full_name: MeasureTheory.IsProbabilityMeasure.measure_univ
code: /-- A measure `μ` is called a probability measure if `μ univ = 1`. -/
class IsProbabilityMeasure (μ : Measure α) : Prop where
  measure_univ : μ univ = 1
goal: μ Set.univ = 1

full_name: MeasureTheory.IsProbabilityMeasure
code: /-- A measure `μ` is called a probability measure if `μ univ = 1`. -/
class IsProbabilityMeasure (μ : Measure α) : Prop where
  measure_univ : μ univ = 1
goal: Prop

full_name: MeasureTheory.isProbabilityMeasure_iff
code: lemma isProbabilityMeasure_iff : IsProbabilityMeasure μ ↔ μ univ = 1 
goal: MeasureTheory.IsProbabilityMeasure μ ↔ μ Set.univ = 1

full_name: MeasureTheory.IsProbabilityMeasure.toIsFiniteMeasure
code: instance (priority := 100) IsProbabilityMeasure.toIsFiniteMeasure (μ : Measure α)
    [IsProbabilityMeasure μ] : IsFiniteMeasure μ 
goal: MeasureTheory.IsFiniteMeasure μ

full_name: MeasureTheory.IsProbabilityMeasure.ne_zero
code: theorem IsProbabilityMeasure.ne_zero (μ : Measure α) [IsProbabilityMeasure μ] : μ ≠ 0 
goal: μ ≠ 0

full_name: MeasureTheory.IsProbabilityMeasure.neZero
code: instance (priority := 100) IsProbabilityMeasure.neZero (μ : Measure α) [IsProbabilityMeasure μ] :
    NeZero μ 
goal: NeZero μ

full_name: MeasureTheory.IsProbabilityMeasure.ae_neBot
code: theorem IsProbabilityMeasure.ae_neBot [IsProbabilityMeasure μ] : NeBot (ae μ) 
goal: (MeasureTheory.ae μ).NeBot

full_name: MeasureTheory.prob_add_prob_compl
code: theorem prob_add_prob_compl [IsProbabilityMeasure μ] (h : MeasurableSet s) : μ s + μ sᶜ = 1 
goal: μ s + μ sᶜ = 1

full_name: MeasureTheory.prob_le_one
code: theorem prob_le_one [IsProbabilityMeasure μ] : μ s ≤ 1 
goal: μ s ≤ 1

full_name: MeasureTheory.isProbabilityMeasureSMul
code: instance isProbabilityMeasureSMul [IsFiniteMeasure μ] [NeZero μ] :
    IsProbabilityMeasure ((μ univ)⁻¹ • μ) 
goal: MeasureTheory.IsProbabilityMeasure ((μ Set.univ)⁻¹ • μ)

full_name: MeasureTheory.isProbabilityMeasure_map
code: theorem isProbabilityMeasure_map {f : α → β} (hf : AEMeasurable f μ) :
    IsProbabilityMeasure (map f μ) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.map f μ)

full_name: MeasureTheory.one_le_prob_iff
code: @[simp]
theorem one_le_prob_iff : 1 ≤ μ s ↔ μ s = 1 
goal: 1 ≤ μ s ↔ μ s = 1

full_name: MeasureTheory.prob_compl_eq_one_sub₀
code: /-- Note that this is not quite as useful as it looks because the measure takes values in `ℝ≥0∞`.
Thus the subtraction appearing is the truncated subtraction of `ℝ≥0∞`, rather than the
better-behaved subtraction of `ℝ`. -/
lemma prob_compl_eq_one_sub₀ (h : NullMeasurableSet s μ) : μ sᶜ = 1 - μ s 
goal: μ sᶜ = 1 - μ s

full_name: MeasureTheory.prob_compl_eq_one_sub
code: /-- Note that this is not quite as useful as it looks because the measure takes values in `ℝ≥0∞`.
Thus the subtraction appearing is the truncated subtraction of `ℝ≥0∞`, rather than the
better-behaved subtraction of `ℝ`. -/
theorem prob_compl_eq_one_sub (hs : MeasurableSet s) : μ sᶜ = 1 - μ s 
goal: μ sᶜ = 1 - μ s

full_name: MeasureTheory.prob_compl_lt_one_sub_of_lt_prob
code: lemma prob_compl_lt_one_sub_of_lt_prob {p : ℝ≥0∞} (hμs : p < μ s) (s_mble : MeasurableSet s) :
    μ sᶜ < 1 - p 
goal: μ sᶜ < 1 - p

full_name: MeasureTheory.prob_compl_le_one_sub_of_le_prob
code: lemma prob_compl_le_one_sub_of_le_prob {p : ℝ≥0∞} (hμs : p ≤ μ s) (s_mble : MeasurableSet s) :
    μ sᶜ ≤ 1 - p 
goal: μ sᶜ ≤ 1 - p

full_name: MeasureTheory.prob_compl_eq_zero_iff₀
code: @[simp] lemma prob_compl_eq_zero_iff₀ (hs : NullMeasurableSet s μ) : μ sᶜ = 0 ↔ μ s = 1 
goal: μ sᶜ = 0 ↔ μ s = 1

full_name: MeasureTheory.prob_compl_eq_zero_iff
code: @[simp] lemma prob_compl_eq_zero_iff (hs : MeasurableSet s) : μ sᶜ = 0 ↔ μ s = 1 
goal: μ sᶜ = 0 ↔ μ s = 1

full_name: MeasureTheory.prob_compl_eq_one_iff₀
code: @[simp] lemma prob_compl_eq_one_iff₀ (hs : NullMeasurableSet s μ) : μ sᶜ = 1 ↔ μ s = 0 
goal: μ sᶜ = 1 ↔ μ s = 0

full_name: MeasureTheory.prob_compl_eq_one_iff
code: @[simp] lemma prob_compl_eq_one_iff (hs : MeasurableSet s) : μ sᶜ = 1 ↔ μ s = 0 
goal: μ sᶜ = 1 ↔ μ s = 0

full_name: MeasureTheory.mem_ae_iff_prob_eq_one₀
code: lemma mem_ae_iff_prob_eq_one₀ (hs : NullMeasurableSet s μ) : s ∈ ae μ ↔ μ s = 1 
goal: s ∈ MeasureTheory.ae μ ↔ μ s = 1

full_name: MeasureTheory.mem_ae_iff_prob_eq_one
code: lemma mem_ae_iff_prob_eq_one (hs : MeasurableSet s) : s ∈ ae μ ↔ μ s = 1 
goal: s ∈ MeasureTheory.ae μ ↔ μ s = 1

full_name: MeasureTheory.ae_iff_prob_eq_one
code: lemma ae_iff_prob_eq_one (hp : Measurable p) : (∀ᵐ a ∂μ, p a) ↔ μ {a | p a} = 1 
goal: (∀ᵐ (a : α) ∂μ, p a) ↔ μ {a | p a} = 1

full_name: MeasureTheory.isProbabilityMeasure_comap
code: lemma isProbabilityMeasure_comap (hf : Injective f) (hf' : ∀ᵐ a ∂μ, a ∈ range f)
    (hf'' : ∀ s, MeasurableSet s → MeasurableSet (f '' s)) :
    IsProbabilityMeasure (μ.comap f) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.comap f μ)

full_name: MeasurableEmbedding.isProbabilityMeasure_comap
code: protected lemma _root_.MeasurableEmbedding.isProbabilityMeasure_comap (hf : MeasurableEmbedding f)
    (hf' : ∀ᵐ a ∂μ, a ∈ range f) : IsProbabilityMeasure (μ.comap f) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.comap f μ)

full_name: MeasureTheory.isProbabilityMeasure_map_up
code: instance isProbabilityMeasure_map_up :
    IsProbabilityMeasure (μ.map ULift.up) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.map ULift.up μ)

full_name: MeasureTheory.isProbabilityMeasure_comap_down
code: instance isProbabilityMeasure_comap_down : IsProbabilityMeasure (μ.comap ULift.down) 
goal: MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.comap ULift.down μ)

full_name: MeasureTheory.NoAtoms.measure_singleton
code: /-- Measure `μ` *has no atoms* if the measure of each singleton is zero.

NB: Wikipedia assumes that for any measurable set `s` with positive `μ`-measure,
there exists a measurable `t ⊆ s` such that `0 < μ t < μ s`. While this implies `μ {x} = 0`,
the converse is not true. -/
class NoAtoms {m0 : MeasurableSpace α} (μ : Measure α) : Prop where
  measure_singleton : ∀ x, μ {x} = 0
goal: μ {x} = 0

full_name: MeasureTheory.NoAtoms
code: /-- Measure `μ` *has no atoms* if the measure of each singleton is zero.

NB: Wikipedia assumes that for any measurable set `s` with positive `μ`-measure,
there exists a measurable `t ⊆ s` such that `0 < μ t < μ s`. While this implies `μ {x} = 0`,
the converse is not true. -/
class NoAtoms {m0 : MeasurableSpace α} (μ : Measure α) : Prop where
  measure_singleton : ∀ x, μ {x} = 0
goal: Prop

full_name: Set.Subsingleton.measure_zero
code: theorem _root_.Set.Subsingleton.measure_zero (hs : s.Subsingleton) (μ : Measure α) [NoAtoms μ] :
    μ s = 0 
goal: μ s = 0

full_name: MeasureTheory.Measure.restrict_singleton'
code: theorem Measure.restrict_singleton' {a : α} : μ.restrict {a} = 0 
goal: μ.restrict {a} = 0

full_name: MeasureTheory.Measure.restrict.instNoAtoms
code: instance Measure.restrict.instNoAtoms (s : Set α) : NoAtoms (μ.restrict s) 
goal: MeasureTheory.NoAtoms (μ.restrict s)

full_name: Set.Countable.measure_zero
code: theorem _root_.Set.Countable.measure_zero (h : s.Countable) (μ : Measure α) [NoAtoms μ] :
    μ s = 0 
goal: μ s = 0

full_name: Set.Countable.ae_not_mem
code: theorem _root_.Set.Countable.ae_not_mem (h : s.Countable) (μ : Measure α) [NoAtoms μ] :
    ∀ᵐ x ∂μ, x ∉ s 
goal: ∀ᵐ (x : α) ∂μ, x ∉ s

full_name: Set.Countable.measure_restrict_compl
code: lemma _root_.Set.Countable.measure_restrict_compl (h : s.Countable) (μ : Measure α) [NoAtoms μ] :
    μ.restrict sᶜ = μ 
goal: μ.restrict sᶜ = μ

full_name: MeasureTheory.restrict_compl_singleton
code: @[simp]
lemma restrict_compl_singleton (a : α) : μ.restrict ({a}ᶜ) = μ 
goal: μ.restrict {a}ᶜ = μ

full_name: Set.Finite.measure_zero
code: theorem _root_.Set.Finite.measure_zero (h : s.Finite) (μ : Measure α) [NoAtoms μ] : μ s = 0 
goal: μ s = 0

full_name: Finset.measure_zero
code: theorem _root_.Finset.measure_zero (s : Finset α) (μ : Measure α) [NoAtoms μ] : μ s = 0 
goal: μ ↑s = 0

full_name: MeasureTheory.insert_ae_eq_self
code: theorem insert_ae_eq_self (a : α) (s : Set α) : (insert a s : Set α) =ᵐ[μ] s 
goal: insert a s =ᵐ[μ] s

full_name: MeasureTheory.Iio_ae_eq_Iic
code: theorem Iio_ae_eq_Iic : Iio a =ᵐ[μ] Iic a 
goal: Set.Iio a =ᵐ[μ] Set.Iic a

full_name: MeasureTheory.Ioi_ae_eq_Ici
code: theorem Ioi_ae_eq_Ici : Ioi a =ᵐ[μ] Ici a 
goal: Set.Ioi a =ᵐ[μ] Set.Ici a

full_name: MeasureTheory.Ioo_ae_eq_Ioc
code: theorem Ioo_ae_eq_Ioc : Ioo a b =ᵐ[μ] Ioc a b 
goal: Set.Ioo a b =ᵐ[μ] Set.Ioc a b

full_name: MeasureTheory.Ioc_ae_eq_Icc
code: theorem Ioc_ae_eq_Icc : Ioc a b =ᵐ[μ] Icc a b 
goal: Set.Ioc a b =ᵐ[μ] Set.Icc a b

full_name: MeasureTheory.Ioo_ae_eq_Ico
code: theorem Ioo_ae_eq_Ico : Ioo a b =ᵐ[μ] Ico a b 
goal: Set.Ioo a b =ᵐ[μ] Set.Ico a b

full_name: MeasureTheory.Ioo_ae_eq_Icc
code: theorem Ioo_ae_eq_Icc : Ioo a b =ᵐ[μ] Icc a b 
goal: Set.Ioo a b =ᵐ[μ] Set.Icc a b

full_name: MeasureTheory.Ico_ae_eq_Icc
code: theorem Ico_ae_eq_Icc : Ico a b =ᵐ[μ] Icc a b 
goal: Set.Ico a b =ᵐ[μ] Set.Icc a b

full_name: MeasureTheory.Ico_ae_eq_Ioc
code: theorem Ico_ae_eq_Ioc : Ico a b =ᵐ[μ] Ioc a b 
goal: Set.Ico a b =ᵐ[μ] Set.Ioc a b

full_name: MeasureTheory.restrict_Iio_eq_restrict_Iic
code: theorem restrict_Iio_eq_restrict_Iic : μ.restrict (Iio a) = μ.restrict (Iic a) 
goal: μ.restrict (Set.Iio a) = μ.restrict (Set.Iic a)

full_name: MeasureTheory.restrict_Ioi_eq_restrict_Ici
code: theorem restrict_Ioi_eq_restrict_Ici : μ.restrict (Ioi a) = μ.restrict (Ici a) 
goal: μ.restrict (Set.Ioi a) = μ.restrict (Set.Ici a)

full_name: MeasureTheory.restrict_Ioo_eq_restrict_Ioc
code: theorem restrict_Ioo_eq_restrict_Ioc : μ.restrict (Ioo a b) = μ.restrict (Ioc a b) 
goal: μ.restrict (Set.Ioo a b) = μ.restrict (Set.Ioc a b)

full_name: MeasureTheory.restrict_Ioc_eq_restrict_Icc
code: theorem restrict_Ioc_eq_restrict_Icc : μ.restrict (Ioc a b) = μ.restrict (Icc a b) 
goal: μ.restrict (Set.Ioc a b) = μ.restrict (Set.Icc a b)

full_name: MeasureTheory.restrict_Ioo_eq_restrict_Ico
code: theorem restrict_Ioo_eq_restrict_Ico : μ.restrict (Ioo a b) = μ.restrict (Ico a b) 
goal: μ.restrict (Set.Ioo a b) = μ.restrict (Set.Ico a b)

full_name: MeasureTheory.restrict_Ioo_eq_restrict_Icc
code: theorem restrict_Ioo_eq_restrict_Icc : μ.restrict (Ioo a b) = μ.restrict (Icc a b) 
goal: μ.restrict (Set.Ioo a b) = μ.restrict (Set.Icc a b)

full_name: MeasureTheory.restrict_Ico_eq_restrict_Icc
code: theorem restrict_Ico_eq_restrict_Icc : μ.restrict (Ico a b) = μ.restrict (Icc a b) 
goal: μ.restrict (Set.Ico a b) = μ.restrict (Set.Icc a b)

full_name: MeasureTheory.restrict_Ico_eq_restrict_Ioc
code: theorem restrict_Ico_eq_restrict_Ioc : μ.restrict (Ico a b) = μ.restrict (Ioc a b) 
goal: μ.restrict (Set.Ico a b) = μ.restrict (Set.Ioc a b)

full_name: MeasureTheory.uIoc_ae_eq_interval
code: theorem uIoc_ae_eq_interval [LinearOrder α] {a b : α} : Ι a b =ᵐ[μ] [[a, b]] 
goal: Ι a b =ᵐ[μ] Set.uIcc a b

full_name: MeasureTheory.ite_ae_eq_of_measure_zero
code: theorem ite_ae_eq_of_measure_zero {γ} (f : α → γ) (g : α → γ) (s : Set α) [DecidablePred (· ∈ s)]
    (hs_zero : μ s = 0) :
    (fun x => ite (x ∈ s) (f x) (g x)) =ᵐ[μ] g 
goal: (fun x => if x ∈ s then f x else g x) =ᵐ[μ] g

full_name: MeasureTheory.ite_ae_eq_of_measure_compl_zero
code: theorem ite_ae_eq_of_measure_compl_zero {γ} (f : α → γ) (g : α → γ)
    (s : Set α) [DecidablePred (· ∈ s)] (hs_zero : μ sᶜ = 0) :
    (fun x => ite (x ∈ s) (f x) (g x)) =ᵐ[μ] f 
goal: (fun x => if x ∈ s then f x else g x) =ᵐ[μ] f

full_name: MeasureTheory.Measure.FiniteAtFilter
code: /-- A measure is called finite at filter `f` if it is finite at some set `s ∈ f`.
Equivalently, it is eventually finite at `s` in `f.small_sets`. -/
def FiniteAtFilter {_m0 : MeasurableSpace α} (μ : Measure α) (f : Filter α) : Prop 
goal: Prop

full_name: MeasureTheory.Measure.finiteAtFilter_of_finite
code: theorem finiteAtFilter_of_finite {_m0 : MeasurableSpace α} (μ : Measure α) [IsFiniteMeasure μ]
    (f : Filter α) : μ.FiniteAtFilter f 
goal: μ.FiniteAtFilter f

full_name: MeasureTheory.Measure.FiniteAtFilter.exists_mem_basis
code: theorem FiniteAtFilter.exists_mem_basis {f : Filter α} (hμ : FiniteAtFilter μ f) {p : ι → Prop}
    {s : ι → Set α} (hf : f.HasBasis p s) : ∃ i, p i ∧ μ (s i) < ∞ 
goal: ∃ i, p i ∧ μ (s i) < ⊤

full_name: MeasureTheory.Measure.finiteAtBot
code: theorem finiteAtBot {m0 : MeasurableSpace α} (μ : Measure α) : μ.FiniteAtFilter ⊥ 
goal: μ.FiniteAtFilter ⊥

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn
code: /-- `μ` has finite spanning sets in `C` if there is a countable sequence of sets in `C` that have
  finite measures. This structure is a type, which is useful if we want to record extra properties
  about the sets, such as that they are monotone.
  `SigmaFinite` is defined in terms of this: `μ` is σ-finite if there exists a sequence of
  finite spanning sets in the collection of all measurable sets. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure FiniteSpanningSetsIn {m0 : MeasurableSpace α} (μ : Measure α) (C : Set (Set α)) where
  protected set : ℕ → Set α
  protected set_mem : ∀ i, set i ∈ C
  protected finite : ∀ i, μ (set i) < ∞
  protected spanning : ⋃ i, set i = univ
goal: Type u_1

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.finite
code: /-- `μ` has finite spanning sets in `C` if there is a countable sequence of sets in `C` that have
  finite measures. This structure is a type, which is useful if we want to record extra properties
  about the sets, such as that they are monotone.
  `SigmaFinite` is defined in terms of this: `μ` is σ-finite if there exists a sequence of
  finite spanning sets in the collection of all measurable sets. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure FiniteSpanningSetsIn {m0 : MeasurableSpace α} (μ : Measure α) (C : Set (Set α)) where
  protected set : ℕ → Set α
  protected set_mem : ∀ i, set i ∈ C
  protected finite : ∀ i, μ (set i) < ∞
  protected spanning : ⋃ i, set i = univ
goal: μ (self.set i) < ⊤

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.set
code: /-- `μ` has finite spanning sets in `C` if there is a countable sequence of sets in `C` that have
  finite measures. This structure is a type, which is useful if we want to record extra properties
  about the sets, such as that they are monotone.
  `SigmaFinite` is defined in terms of this: `μ` is σ-finite if there exists a sequence of
  finite spanning sets in the collection of all measurable sets. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure FiniteSpanningSetsIn {m0 : MeasurableSpace α} (μ : Measure α) (C : Set (Set α)) where
  protected set : ℕ → Set α
  protected set_mem : ∀ i, set i ∈ C
  protected finite : ∀ i, μ (set i) < ∞
  protected spanning : ⋃ i, set i = univ
goal: ℕ → Set α

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.spanning
code: /-- `μ` has finite spanning sets in `C` if there is a countable sequence of sets in `C` that have
  finite measures. This structure is a type, which is useful if we want to record extra properties
  about the sets, such as that they are monotone.
  `SigmaFinite` is defined in terms of this: `μ` is σ-finite if there exists a sequence of
  finite spanning sets in the collection of all measurable sets. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure FiniteSpanningSetsIn {m0 : MeasurableSpace α} (μ : Measure α) (C : Set (Set α)) where
  protected set : ℕ → Set α
  protected set_mem : ∀ i, set i ∈ C
  protected finite : ∀ i, μ (set i) < ∞
  protected spanning : ⋃ i, set i = univ
goal: ⋃ i, self.set i = Set.univ

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.set_mem
code: /-- `μ` has finite spanning sets in `C` if there is a countable sequence of sets in `C` that have
  finite measures. This structure is a type, which is useful if we want to record extra properties
  about the sets, such as that they are monotone.
  `SigmaFinite` is defined in terms of this: `μ` is σ-finite if there exists a sequence of
  finite spanning sets in the collection of all measurable sets. -/
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure FiniteSpanningSetsIn {m0 : MeasurableSpace α} (μ : Measure α) (C : Set (Set α)) where
  protected set : ℕ → Set α
  protected set_mem : ∀ i, set i ∈ C
  protected finite : ∀ i, μ (set i) < ∞
  protected spanning : ⋃ i, set i = univ
goal: self.set i ∈ C

full_name: MeasureTheory.SFinite.out'
code: /-- A measure is called s-finite if it is a countable sum of finite measures. -/
class SFinite (μ : Measure α) : Prop where
  out' : ∃ m : ℕ → Measure α, (∀ n, IsFiniteMeasure (m n)) ∧ μ = Measure.sum m
goal: ∃ m, (∀ (n : ℕ), MeasureTheory.IsFiniteMeasure (m n)) ∧ μ = MeasureTheory.Measure.sum m

full_name: MeasureTheory.SFinite
code: /-- A measure is called s-finite if it is a countable sum of finite measures. -/
class SFinite (μ : Measure α) : Prop where
  out' : ∃ m : ℕ → Measure α, (∀ n, IsFiniteMeasure (m n)) ∧ μ = Measure.sum m
goal: Prop

full_name: MeasureTheory.sFiniteSeq
code: /-- A sequence of finite measures such that `μ = sum (sFiniteSeq μ)` (see `sum_sFiniteSeq`). -/
noncomputable
def sFiniteSeq (μ : Measure α) [h : SFinite μ] : ℕ → Measure α 
goal: ℕ → MeasureTheory.Measure α

full_name: MeasureTheory.isFiniteMeasure_sFiniteSeq
code: instance isFiniteMeasure_sFiniteSeq [h : SFinite μ] (n : ℕ) : IsFiniteMeasure (sFiniteSeq μ n) 
goal: MeasureTheory.IsFiniteMeasure (MeasureTheory.sFiniteSeq μ n)

full_name: MeasureTheory.sum_sFiniteSeq
code: lemma sum_sFiniteSeq (μ : Measure α) [h : SFinite μ] : sum (sFiniteSeq μ) = μ 
goal: MeasureTheory.Measure.sum (MeasureTheory.sFiniteSeq μ) = μ

full_name: MeasureTheory.instSFiniteOfNatMeasure
code: instance : SFinite (0 : Measure α) 
goal: MeasureTheory.SFinite 0

full_name: MeasureTheory.sFiniteSeq_zero
code: @[simp]
lemma sFiniteSeq_zero (n : ℕ) : sFiniteSeq (0 : Measure α) n = 0 
goal: MeasureTheory.sFiniteSeq 0 n = 0

full_name: MeasureTheory.sfinite_sum_of_countable
code: /-- A countable sum of finite measures is s-finite.
This lemma is superseeded by the instance below. -/
lemma sfinite_sum_of_countable [Countable ι]
    (m : ι → Measure α) [∀ n, IsFiniteMeasure (m n)] : SFinite (Measure.sum m) 
goal: MeasureTheory.SFinite (MeasureTheory.Measure.sum m)

full_name: MeasureTheory.instSFiniteSumOfCountable
code: instance [Countable ι] (m : ι → Measure α) [∀ n, SFinite (m n)] : SFinite (Measure.sum m) 
goal: MeasureTheory.SFinite (MeasureTheory.Measure.sum m)

full_name: MeasureTheory.instSFiniteHAddMeasure
code: instance [SFinite μ] [SFinite ν] : SFinite (μ + ν) 
goal: MeasureTheory.SFinite (μ + ν)

full_name: MeasureTheory.instSFiniteRestrict
code: instance [SFinite μ] (s : Set α) : SFinite (μ.restrict s) 
goal: MeasureTheory.SFinite (μ.restrict s)

full_name: MeasureTheory.exists_absolutelyContinuous_isFiniteMeasure
code: /-- An s-finite measure is absolutely continuous with respect to some finite measure. -/
theorem exists_absolutelyContinuous_isFiniteMeasure [SFinite μ] :
    ∃ ν : Measure α, IsFiniteMeasure ν ∧ μ ≪ ν 
goal: ∃ ν, MeasureTheory.IsFiniteMeasure ν ∧ μ ≪ ν

full_name: MeasureTheory.SigmaFinite
code: /-- A measure `μ` is called σ-finite if there is a countable collection of sets
 `{ A i | i ∈ ℕ }` such that `μ (A i) < ∞` and `⋃ i, A i = s`. -/
class SigmaFinite {m0 : MeasurableSpace α} (μ : Measure α) : Prop where
  out' : Nonempty (μ.FiniteSpanningSetsIn univ)
goal: Prop

full_name: MeasureTheory.SigmaFinite.out'
code: /-- A measure `μ` is called σ-finite if there is a countable collection of sets
 `{ A i | i ∈ ℕ }` such that `μ (A i) < ∞` and `⋃ i, A i = s`. -/
class SigmaFinite {m0 : MeasurableSpace α} (μ : Measure α) : Prop where
  out' : Nonempty (μ.FiniteSpanningSetsIn univ)
goal: Nonempty (μ.FiniteSpanningSetsIn Set.univ)

full_name: MeasureTheory.sigmaFinite_iff
code: theorem sigmaFinite_iff : SigmaFinite μ ↔ Nonempty (μ.FiniteSpanningSetsIn univ) 
goal: MeasureTheory.SigmaFinite μ ↔ Nonempty (μ.FiniteSpanningSetsIn Set.univ)

full_name: MeasureTheory.SigmaFinite.out
code: theorem SigmaFinite.out (h : SigmaFinite μ) : Nonempty (μ.FiniteSpanningSetsIn univ) 
goal: Nonempty (μ.FiniteSpanningSetsIn Set.univ)

full_name: MeasureTheory.Measure.toFiniteSpanningSetsIn
code: /-- If `μ` is σ-finite it has finite spanning sets in the collection of all measurable sets. -/
def Measure.toFiniteSpanningSetsIn (μ : Measure α) [h : SigmaFinite μ] :
    μ.FiniteSpanningSetsIn { s | MeasurableSet s } 
goal: μ.FiniteSpanningSetsIn {s | MeasurableSet s}

full_name: MeasureTheory.spanningSets
code: /-- A noncomputable way to get a monotone collection of sets that span `univ` and have finite
  measure using `Classical.choose`. This definition satisfies monotonicity in addition to all other
  properties in `SigmaFinite`. -/
def spanningSets (μ : Measure α) [SigmaFinite μ] (i : ℕ) : Set α 
goal: Set α

full_name: MeasureTheory.monotone_spanningSets
code: theorem monotone_spanningSets (μ : Measure α) [SigmaFinite μ] : Monotone (spanningSets μ) 
goal: Monotone (MeasureTheory.spanningSets μ)

full_name: MeasureTheory.measurable_spanningSets
code: theorem measurable_spanningSets (μ : Measure α) [SigmaFinite μ] (i : ℕ) :
    MeasurableSet (spanningSets μ i) 
goal: MeasurableSet (MeasureTheory.spanningSets μ i)

full_name: MeasureTheory.measure_spanningSets_lt_top
code: theorem measure_spanningSets_lt_top (μ : Measure α) [SigmaFinite μ] (i : ℕ) :
    μ (spanningSets μ i) < ∞ 
goal: μ (MeasureTheory.spanningSets μ i) < ⊤

full_name: MeasureTheory.iUnion_spanningSets
code: theorem iUnion_spanningSets (μ : Measure α) [SigmaFinite μ] : ⋃ i : ℕ, spanningSets μ i = univ 
goal: ⋃ i, MeasureTheory.spanningSets μ i = Set.univ

full_name: MeasureTheory.isCountablySpanning_spanningSets
code: theorem isCountablySpanning_spanningSets (μ : Measure α) [SigmaFinite μ] :
    IsCountablySpanning (range (spanningSets μ)) 
goal: IsCountablySpanning (Set.range (MeasureTheory.spanningSets μ))

full_name: MeasureTheory.spanningSetsIndex
code: /-- `spanningSetsIndex μ x` is the least `n : ℕ` such that `x ∈ spanningSets μ n`. -/
noncomputable def spanningSetsIndex (μ : Measure α) [SigmaFinite μ] (x : α) : ℕ 
goal: ℕ

full_name: MeasureTheory.measurable_spanningSetsIndex
code: theorem measurable_spanningSetsIndex (μ : Measure α) [SigmaFinite μ] :
    Measurable (spanningSetsIndex μ) 
goal: Measurable (MeasureTheory.spanningSetsIndex μ)

full_name: MeasureTheory.preimage_spanningSetsIndex_singleton
code: theorem preimage_spanningSetsIndex_singleton (μ : Measure α) [SigmaFinite μ] (n : ℕ) :
    spanningSetsIndex μ ⁻¹' {n} = disjointed (spanningSets μ) n 
goal: MeasureTheory.spanningSetsIndex μ ⁻¹' {n} = disjointed (MeasureTheory.spanningSets μ) n

full_name: MeasureTheory.spanningSetsIndex_eq_iff
code: theorem spanningSetsIndex_eq_iff (μ : Measure α) [SigmaFinite μ] {x : α} {n : ℕ} :
    spanningSetsIndex μ x = n ↔ x ∈ disjointed (spanningSets μ) n 
goal: MeasureTheory.spanningSetsIndex μ x = n ↔ x ∈ disjointed (MeasureTheory.spanningSets μ) n

full_name: MeasureTheory.mem_disjointed_spanningSetsIndex
code: theorem mem_disjointed_spanningSetsIndex (μ : Measure α) [SigmaFinite μ] (x : α) :
    x ∈ disjointed (spanningSets μ) (spanningSetsIndex μ x) 
goal: x ∈ disjointed (MeasureTheory.spanningSets μ) (MeasureTheory.spanningSetsIndex μ x)

full_name: MeasureTheory.mem_spanningSetsIndex
code: theorem mem_spanningSetsIndex (μ : Measure α) [SigmaFinite μ] (x : α) :
    x ∈ spanningSets μ (spanningSetsIndex μ x) 
goal: x ∈ MeasureTheory.spanningSets μ (MeasureTheory.spanningSetsIndex μ x)

full_name: MeasureTheory.mem_spanningSets_of_index_le
code: theorem mem_spanningSets_of_index_le (μ : Measure α) [SigmaFinite μ] (x : α) {n : ℕ}
    (hn : spanningSetsIndex μ x ≤ n) : x ∈ spanningSets μ n 
goal: x ∈ MeasureTheory.spanningSets μ n

full_name: MeasureTheory.eventually_mem_spanningSets
code: theorem eventually_mem_spanningSets (μ : Measure α) [SigmaFinite μ] (x : α) :
    ∀ᶠ n in atTop, x ∈ spanningSets μ n 
goal: ∀ᶠ (n : ℕ) in Filter.atTop, x ∈ MeasureTheory.spanningSets μ n

full_name: MeasureTheory.sum_restrict_disjointed_spanningSets
code: theorem sum_restrict_disjointed_spanningSets (μ ν : Measure α) [SigmaFinite ν] :
    sum (fun n ↦ μ.restrict (disjointed (spanningSets ν) n)) = μ 
goal: (MeasureTheory.Measure.sum fun n => μ.restrict (disjointed (MeasureTheory.spanningSets ν) n)) = μ

full_name: MeasureTheory.instSFiniteOfSigmaFinite
code: instance (priority := 100) [SigmaFinite μ] : SFinite μ 
goal: MeasureTheory.SFinite μ

full_name: MeasureTheory.Measure.forall_measure_inter_spanningSets_eq_zero
code: /-- A set in a σ-finite space has zero measure if and only if its intersection with
all members of the countable family of finite measure spanning sets has zero measure. -/
theorem forall_measure_inter_spanningSets_eq_zero [MeasurableSpace α] {μ : Measure α}
    [SigmaFinite μ] (s : Set α) : (∀ n, μ (s ∩ spanningSets μ n) = 0) ↔ μ s = 0 
goal: (∀ (n : ℕ), μ (s ∩ MeasureTheory.spanningSets μ n) = 0) ↔ μ s = 0

full_name: MeasureTheory.Measure.exists_measure_inter_spanningSets_pos
code: /-- A set in a σ-finite space has positive measure if and only if its intersection with
some member of the countable family of finite measure spanning sets has positive measure. -/
theorem exists_measure_inter_spanningSets_pos [MeasurableSpace α] {μ : Measure α} [SigmaFinite μ]
    (s : Set α) : (∃ n, 0 < μ (s ∩ spanningSets μ n)) ↔ 0 < μ s 
goal: (∃ n, 0 < μ (s ∩ MeasureTheory.spanningSets μ n)) ↔ 0 < μ s

full_name: MeasureTheory.Measure.finite_const_le_meas_of_disjoint_iUnion₀
code: /-- If the union of a.e.-disjoint null-measurable sets has finite measure, then there are only
finitely many members of the union whose measure exceeds any given positive number. -/
theorem finite_const_le_meas_of_disjoint_iUnion₀ {ι : Type*} [MeasurableSpace α] (μ : Measure α)
    {ε : ℝ≥0∞} (ε_pos : 0 < ε) {As : ι → Set α} (As_mble : ∀ i : ι, NullMeasurableSet (As i) μ)
    (As_disj : Pairwise (AEDisjoint μ on As)) (Union_As_finite : μ (⋃ i, As i) ≠ ∞) :
    Set.Finite { i : ι | ε ≤ μ (As i) } 
goal: {i | ε ≤ μ (As i)}.Finite

full_name: MeasureTheory.Measure.finite_const_le_meas_of_disjoint_iUnion
code: /-- If the union of disjoint measurable sets has finite measure, then there are only
finitely many members of the union whose measure exceeds any given positive number. -/
theorem finite_const_le_meas_of_disjoint_iUnion {ι : Type*} [MeasurableSpace α] (μ : Measure α)
    {ε : ℝ≥0∞} (ε_pos : 0 < ε) {As : ι → Set α} (As_mble : ∀ i : ι, MeasurableSet (As i))
    (As_disj : Pairwise (Disjoint on As)) (Union_As_finite : μ (⋃ i, As i) ≠ ∞) :
    Set.Finite { i : ι | ε ≤ μ (As i) } 
goal: {i | ε ≤ μ (As i)}.Finite

full_name: Set.Infinite.meas_eq_top
code: /-- If all elements of an infinite set have measure uniformly separated from zero,
then the set has infinite measure. -/
theorem _root_.Set.Infinite.meas_eq_top [MeasurableSingletonClass α]
    {s : Set α} (hs : s.Infinite) (h' : ∃ ε, ε ≠ 0 ∧ ∀ x ∈ s, ε ≤ μ {x}) : μ s = ∞ 
goal: μ s = ⊤

full_name: MeasureTheory.Measure.countable_meas_pos_of_disjoint_of_meas_iUnion_ne_top₀
code: /-- If the union of a.e.-disjoint null-measurable sets has finite measure, then there are only
countably many members of the union whose measure is positive. -/
theorem countable_meas_pos_of_disjoint_of_meas_iUnion_ne_top₀ {ι : Type*} {_ : MeasurableSpace α}
    (μ : Measure α) {As : ι → Set α} (As_mble : ∀ i : ι, NullMeasurableSet (As i) μ)
    (As_disj : Pairwise (AEDisjoint μ on As)) (Union_As_finite : μ (⋃ i, As i) ≠ ∞) :
    Set.Countable { i : ι | 0 < μ (As i) } 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) {As : ι → Set α},
  (∀ (i : ι), MeasureTheory.NullMeasurableSet (As i) μ) →
    Pairwise (MeasureTheory.AEDisjoint μ on As) → μ (⋃ i, As i) ≠ ⊤ → {i | 0 < μ (As i)}.Countable

full_name: MeasureTheory.Measure.countable_meas_pos_of_disjoint_of_meas_iUnion_ne_top
code: /-- If the union of disjoint measurable sets has finite measure, then there are only
countably many members of the union whose measure is positive. -/
theorem countable_meas_pos_of_disjoint_of_meas_iUnion_ne_top {ι : Type*} {_ : MeasurableSpace α}
    (μ : Measure α) {As : ι → Set α} (As_mble : ∀ i : ι, MeasurableSet (As i))
    (As_disj : Pairwise (Disjoint on As)) (Union_As_finite : μ (⋃ i, As i) ≠ ∞) :
    Set.Countable { i : ι | 0 < μ (As i) } 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) {As : ι → Set α},
  (∀ (i : ι), MeasurableSet (As i)) → Pairwise (Disjoint on As) → μ (⋃ i, As i) ≠ ⊤ → {i | 0 < μ (As i)}.Countable

full_name: MeasureTheory.Measure.countable_meas_pos_of_disjoint_iUnion₀
code: /-- In an s-finite space, among disjoint null-measurable sets, only countably many can have positive
measure. -/
theorem countable_meas_pos_of_disjoint_iUnion₀ {ι : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] {As : ι → Set α} (As_mble : ∀ i : ι, NullMeasurableSet (As i) μ)
    (As_disj : Pairwise (AEDisjoint μ on As)) :
    Set.Countable { i : ι | 0 < μ (As i) } 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ] {As : ι → Set α},
  (∀ (i : ι), MeasureTheory.NullMeasurableSet (As i) μ) →
    Pairwise (MeasureTheory.AEDisjoint μ on As) → {i | 0 < μ (As i)}.Countable

full_name: MeasureTheory.Measure.countable_meas_pos_of_disjoint_iUnion
code: /-- In an s-finite space, among disjoint measurable sets, only countably many can have positive
measure. -/
theorem countable_meas_pos_of_disjoint_iUnion {ι : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] {As : ι → Set α} (As_mble : ∀ i : ι, MeasurableSet (As i))
    (As_disj : Pairwise (Disjoint on As)) : Set.Countable { i : ι | 0 < μ (As i) } 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ] {As : ι → Set α},
  (∀ (i : ι), MeasurableSet (As i)) → Pairwise (Disjoint on As) → {i | 0 < μ (As i)}.Countable

full_name: MeasureTheory.Measure.countable_meas_level_set_pos₀
code: theorem countable_meas_level_set_pos₀ {α β : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] [MeasurableSpace β] [MeasurableSingletonClass β] {g : α → β}
    (g_mble : NullMeasurable g μ) : Set.Countable { t : β | 0 < μ { a : α | g a = t } } 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ] [inst : MeasurableSpace β]
  [inst_1 : MeasurableSingletonClass β] {g : α → β},
  MeasureTheory.NullMeasurable g μ → {t | 0 < μ {a | g a = t}}.Countable

full_name: MeasureTheory.Measure.countable_meas_level_set_pos
code: theorem countable_meas_level_set_pos {α β : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] [MeasurableSpace β] [MeasurableSingletonClass β] {g : α → β}
    (g_mble : Measurable g) : Set.Countable { t : β | 0 < μ { a : α | g a = t } } 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ] [inst : MeasurableSpace β]
  [inst_1 : MeasurableSingletonClass β] {g : α → β}, Measurable g → {t | 0 < μ {a | g a = t}}.Countable

full_name: MeasureTheory.Measure.measure_toMeasurable_inter_of_sum
code: /-- If a measure `μ` is the sum of a countable family `mₙ`, and a set `t` has finite measure for
each `mₙ`, then its measurable superset `toMeasurable μ t` (which has the same measure as `t`)
satisfies, for any measurable set `s`, the equality `μ (toMeasurable μ t ∩ s) = μ (t ∩ s)`. -/
theorem measure_toMeasurable_inter_of_sum {s : Set α} (hs : MeasurableSet s) {t : Set α}
    {m : ℕ → Measure α} (hv : ∀ n, m n t ≠ ∞) (hμ : μ = sum m) :
    μ (toMeasurable μ t ∩ s) = μ (t ∩ s) 
goal: μ (MeasureTheory.toMeasurable μ t ∩ s) = μ (t ∩ s)

full_name: MeasureTheory.Measure.measure_toMeasurable_inter_of_cover
code: /-- If a set `t` is covered by a countable family of finite measure sets, then its measurable
superset `toMeasurable μ t` (which has the same measure as `t`) satisfies,
for any measurable set `s`, the equality `μ (toMeasurable μ t ∩ s) = μ (t ∩ s)`. -/
theorem measure_toMeasurable_inter_of_cover {s : Set α} (hs : MeasurableSet s) {t : Set α}
    {v : ℕ → Set α} (hv : t ⊆ ⋃ n, v n) (h'v : ∀ n, μ (t ∩ v n) ≠ ∞) :
    μ (toMeasurable μ t ∩ s) = μ (t ∩ s) 
goal: μ (MeasureTheory.toMeasurable μ t ∩ s) = μ (t ∩ s)

full_name: MeasureTheory.Measure.restrict_toMeasurable_of_cover
code: theorem restrict_toMeasurable_of_cover {s : Set α} {v : ℕ → Set α} (hv : s ⊆ ⋃ n, v n)
    (h'v : ∀ n, μ (s ∩ v n) ≠ ∞) : μ.restrict (toMeasurable μ s) = μ.restrict s 
goal: μ.restrict (MeasureTheory.toMeasurable μ s) = μ.restrict s

full_name: MeasureTheory.Measure.measure_toMeasurable_inter_of_sFinite
code: /-- The measurable superset `toMeasurable μ t` of `t` (which has the same measure as `t`)
satisfies, for any measurable set `s`, the equality `μ (toMeasurable μ t ∩ s) = μ (t ∩ s)`.
This only holds when `μ` is s-finite -- for example for σ-finite measures. For a version without
this assumption (but requiring that `t` has finite measure), see `measure_toMeasurable_inter`. -/
theorem measure_toMeasurable_inter_of_sFinite [SFinite μ] {s : Set α} (hs : MeasurableSet s)
    (t : Set α) : μ (toMeasurable μ t ∩ s) = μ (t ∩ s) 
goal: μ (MeasureTheory.toMeasurable μ t ∩ s) = μ (t ∩ s)

full_name: MeasureTheory.Measure.restrict_toMeasurable_of_sFinite
code: @[simp]
theorem restrict_toMeasurable_of_sFinite [SFinite μ] (s : Set α) :
    μ.restrict (toMeasurable μ s) = μ.restrict s 
goal: μ.restrict (MeasureTheory.toMeasurable μ s) = μ.restrict s

full_name: MeasureTheory.Measure.iSup_restrict_spanningSets_of_measurableSet
code: /-- Auxiliary lemma for `iSup_restrict_spanningSets`. -/
theorem iSup_restrict_spanningSets_of_measurableSet [SigmaFinite μ] (hs : MeasurableSet s) :
    ⨆ i, μ.restrict (spanningSets μ i) s = μ s 
goal: ⨆ i, (μ.restrict (MeasureTheory.spanningSets μ i)) s = μ s

full_name: MeasureTheory.Measure.iSup_restrict_spanningSets
code: theorem iSup_restrict_spanningSets [SigmaFinite μ] (s : Set α) :
    ⨆ i, μ.restrict (spanningSets μ i) s = μ s 
goal: ⨆ i, (μ.restrict (MeasureTheory.spanningSets μ i)) s = μ s

full_name: MeasureTheory.Measure.exists_subset_measure_lt_top
code: /-- In a σ-finite space, any measurable set of measure `> r` contains a measurable subset of
finite measure `> r`. -/
theorem exists_subset_measure_lt_top [SigmaFinite μ] {r : ℝ≥0∞} (hs : MeasurableSet s)
    (h's : r < μ s) : ∃ t, MeasurableSet t ∧ t ⊆ s ∧ r < μ t ∧ μ t < ∞ 
goal: ∃ t, MeasurableSet t ∧ t ⊆ s ∧ r < μ t ∧ μ t < ⊤

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.mono'
code: /-- If `μ` has finite spanning sets in `C` and `C ∩ {s | μ s < ∞} ⊆ D` then `μ` has finite spanning
sets in `D`. -/
protected def mono' (h : μ.FiniteSpanningSetsIn C) (hC : C ∩ { s | μ s < ∞ } ⊆ D) :
    μ.FiniteSpanningSetsIn D 
goal: μ.FiniteSpanningSetsIn D

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.mono
code: /-- If `μ` has finite spanning sets in `C` and `C ⊆ D` then `μ` has finite spanning sets in `D`. -/
protected def mono (h : μ.FiniteSpanningSetsIn C) (hC : C ⊆ D) : μ.FiniteSpanningSetsIn D 
goal: μ.FiniteSpanningSetsIn D

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.sigmaFinite
code: /-- If `μ` has finite spanning sets in the collection of measurable sets `C`, then `μ` is σ-finite.
-/
protected theorem sigmaFinite (h : μ.FiniteSpanningSetsIn C) : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.ext
code: /-- An extensionality for measures. It is `ext_of_generateFrom_of_iUnion` formulated in terms of
`FiniteSpanningSetsIn`. -/
protected theorem ext {ν : Measure α} {C : Set (Set α)} (hA : ‹_› = generateFrom C)
    (hC : IsPiSystem C) (h : μ.FiniteSpanningSetsIn C) (h_eq : ∀ s ∈ C, μ s = ν s) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.isCountablySpanning
code: protected theorem isCountablySpanning (h : μ.FiniteSpanningSetsIn C) : IsCountablySpanning C 
goal: IsCountablySpanning C

full_name: MeasureTheory.Measure.sigmaFinite_of_countable
code: theorem sigmaFinite_of_countable {S : Set (Set α)} (hc : S.Countable) (hμ : ∀ s ∈ S, μ s < ∞)
    (hU : ⋃₀ S = univ) : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.ofLE
code: /-- Given measures `μ`, `ν` where `ν ≤ μ`, `FiniteSpanningSetsIn.ofLe` provides the induced
`FiniteSpanningSet` with respect to `ν` from a `FiniteSpanningSet` with respect to `μ`. -/
def FiniteSpanningSetsIn.ofLE (h : ν ≤ μ) {C : Set (Set α)} (S : μ.FiniteSpanningSetsIn C) :
    ν.FiniteSpanningSetsIn C 
goal: ν.FiniteSpanningSetsIn C

full_name: MeasureTheory.Measure.sigmaFinite_of_le
code: theorem sigmaFinite_of_le (μ : Measure α) [hs : SigmaFinite μ] (h : ν ≤ μ) : SigmaFinite ν 
goal: MeasureTheory.SigmaFinite ν

full_name: MeasureTheory.Measure.add_right_inj
code: @[simp] lemma add_right_inj (μ ν₁ ν₂ : Measure α) [SigmaFinite μ] :
    μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂ 
goal: μ + ν₁ = μ + ν₂ ↔ ν₁ = ν₂

full_name: MeasureTheory.Measure.add_left_inj
code: @[simp] lemma add_left_inj (μ ν₁ ν₂ : Measure α) [SigmaFinite μ] :
    ν₁ + μ = ν₂ + μ ↔ ν₁ = ν₂ 
goal: ν₁ + μ = ν₂ + μ ↔ ν₁ = ν₂

full_name: MeasureTheory.IsFiniteMeasure.toSigmaFinite
code: /-- Every finite measure is σ-finite. -/
instance (priority := 100) IsFiniteMeasure.toSigmaFinite {_m0 : MeasurableSpace α} (μ : Measure α)
    [IsFiniteMeasure μ] : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.sigmaFinite_bot_iff
code: theorem sigmaFinite_bot_iff (μ : @Measure α ⊥) : SigmaFinite μ ↔ IsFiniteMeasure μ 
goal: MeasureTheory.SigmaFinite μ ↔ MeasureTheory.IsFiniteMeasure μ

full_name: MeasureTheory.Restrict.sigmaFinite
code: instance Restrict.sigmaFinite (μ : Measure α) [SigmaFinite μ] (s : Set α) :
    SigmaFinite (μ.restrict s) 
goal: MeasureTheory.SigmaFinite (μ.restrict s)

full_name: MeasureTheory.sum.sigmaFinite
code: instance sum.sigmaFinite {ι} [Finite ι] (μ : ι → Measure α) [∀ i, SigmaFinite (μ i)] :
    SigmaFinite (sum μ) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.sum μ)

full_name: MeasureTheory.Add.sigmaFinite
code: instance Add.sigmaFinite (μ ν : Measure α) [SigmaFinite μ] [SigmaFinite ν] :
    SigmaFinite (μ + ν) 
goal: MeasureTheory.SigmaFinite (μ + ν)

full_name: MeasureTheory.SMul.sigmaFinite
code: instance SMul.sigmaFinite {μ : Measure α} [SigmaFinite μ] (c : ℝ≥0) :
    MeasureTheory.SigmaFinite (c • μ) 
goal: MeasureTheory.SigmaFinite (c • μ)

full_name: MeasureTheory.SigmaFinite.of_map
code: theorem SigmaFinite.of_map (μ : Measure α) {f : α → β} (hf : AEMeasurable f μ)
    (h : SigmaFinite (μ.map f)) : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasurableEmbedding.sigmaFinite_map
code: lemma _root_.MeasurableEmbedding.sigmaFinite_map {f : α → β} (hf : MeasurableEmbedding f)
    [SigmaFinite μ] :
    SigmaFinite (μ.map f) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.map f μ)

full_name: MeasurableEquiv.sigmaFinite_map
code: theorem _root_.MeasurableEquiv.sigmaFinite_map (f : α ≃ᵐ β) [SigmaFinite μ] :
    SigmaFinite (μ.map f) 
goal: MeasureTheory.SigmaFinite (MeasureTheory.Measure.map (⇑f) μ)

full_name: MeasureTheory.ae_of_forall_measure_lt_top_ae_restrict'
code: /-- Similar to `ae_of_forall_measure_lt_top_ae_restrict`, but where you additionally get the
  hypothesis that another σ-finite measure has finite values on `s`. -/
theorem ae_of_forall_measure_lt_top_ae_restrict' {μ : Measure α} (ν : Measure α) [SigmaFinite μ]
    [SigmaFinite ν] (P : α → Prop)
    (h : ∀ s, MeasurableSet s → μ s < ∞ → ν s < ∞ → ∀ᵐ x ∂μ.restrict s, P x) : ∀ᵐ x ∂μ, P x 
goal: ∀ᵐ (x : α) ∂μ, P x

full_name: MeasureTheory.ae_of_forall_measure_lt_top_ae_restrict
code: /-- To prove something for almost all `x` w.r.t. a σ-finite measure, it is sufficient to show that
  this holds almost everywhere in sets where the measure has finite value. -/
theorem ae_of_forall_measure_lt_top_ae_restrict {μ : Measure α} [SigmaFinite μ] (P : α → Prop)
    (h : ∀ s, MeasurableSet s → μ s < ∞ → ∀ᵐ x ∂μ.restrict s, P x) : ∀ᵐ x ∂μ, P x 
goal: ∀ᵐ (x : α) ∂μ, P x

full_name: MeasureTheory.IsLocallyFiniteMeasure
code: /-- A measure is called locally finite if it is finite in some neighborhood of each point. -/
class IsLocallyFiniteMeasure [TopologicalSpace α] (μ : Measure α) : Prop where
  finiteAtNhds : ∀ x, μ.FiniteAtFilter (𝓝 x)
goal: Prop

full_name: MeasureTheory.IsLocallyFiniteMeasure.finiteAtNhds
code: /-- A measure is called locally finite if it is finite in some neighborhood of each point. -/
class IsLocallyFiniteMeasure [TopologicalSpace α] (μ : Measure α) : Prop where
  finiteAtNhds : ∀ x, μ.FiniteAtFilter (𝓝 x)
goal: μ.FiniteAtFilter (𝓝 x)

full_name: MeasureTheory.IsFiniteMeasure.toIsLocallyFiniteMeasure
code: instance (priority := 100) IsFiniteMeasure.toIsLocallyFiniteMeasure [TopologicalSpace α]
    (μ : Measure α) [IsFiniteMeasure μ] : IsLocallyFiniteMeasure μ 
goal: MeasureTheory.IsLocallyFiniteMeasure μ

full_name: MeasureTheory.Measure.finiteAt_nhds
code: theorem Measure.finiteAt_nhds [TopologicalSpace α] (μ : Measure α) [IsLocallyFiniteMeasure μ]
    (x : α) : μ.FiniteAtFilter (𝓝 x) 
goal: μ.FiniteAtFilter (𝓝 x)

full_name: MeasureTheory.Measure.smul_finite
code: theorem Measure.smul_finite (μ : Measure α) [IsFiniteMeasure μ] {c : ℝ≥0∞} (hc : c ≠ ∞) :
    IsFiniteMeasure (c • μ) 
goal: MeasureTheory.IsFiniteMeasure (c • μ)

full_name: MeasureTheory.Measure.exists_isOpen_measure_lt_top
code: theorem Measure.exists_isOpen_measure_lt_top [TopologicalSpace α] (μ : Measure α)
    [IsLocallyFiniteMeasure μ] (x : α) : ∃ s : Set α, x ∈ s ∧ IsOpen s ∧ μ s < ∞ 
goal: ∃ s, x ∈ s ∧ IsOpen s ∧ μ s < ⊤

full_name: MeasureTheory.isLocallyFiniteMeasureSMulNNReal
code: instance isLocallyFiniteMeasureSMulNNReal [TopologicalSpace α] (μ : Measure α)
    [IsLocallyFiniteMeasure μ] (c : ℝ≥0) : IsLocallyFiniteMeasure (c • μ) 
goal: MeasureTheory.IsLocallyFiniteMeasure (c • μ)

full_name: MeasureTheory.Measure.isTopologicalBasis_isOpen_lt_top
code: protected theorem Measure.isTopologicalBasis_isOpen_lt_top [TopologicalSpace α]
    (μ : Measure α) [IsLocallyFiniteMeasure μ] :
    TopologicalSpace.IsTopologicalBasis { s | IsOpen s ∧ μ s < ∞ } 
goal: TopologicalSpace.IsTopologicalBasis {s | IsOpen s ∧ μ s < ⊤}

full_name: MeasureTheory.IsFiniteMeasureOnCompacts
code: /-- A measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`. -/
class IsFiniteMeasureOnCompacts [TopologicalSpace α] (μ : Measure α) : Prop where
  protected lt_top_of_isCompact : ∀ ⦃K : Set α⦄, IsCompact K → μ K < ∞
goal: Prop

full_name: MeasureTheory.IsFiniteMeasureOnCompacts.lt_top_of_isCompact
code: /-- A measure `μ` is finite on compacts if any compact set `K` satisfies `μ K < ∞`. -/
class IsFiniteMeasureOnCompacts [TopologicalSpace α] (μ : Measure α) : Prop where
  protected lt_top_of_isCompact : ∀ ⦃K : Set α⦄, IsCompact K → μ K < ∞
goal: IsCompact K → μ K < ⊤

full_name: IsCompact.measure_lt_top
code: /-- A compact subset has finite measure for a measure which is finite on compacts. -/
theorem _root_.IsCompact.measure_lt_top [TopologicalSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] ⦃K : Set α⦄ (hK : IsCompact K) : μ K < ∞ 
goal: μ K < ⊤

full_name: IsCompact.measure_ne_top
code: /-- A compact subset has finite measure for a measure which is finite on compacts. -/
theorem _root_.IsCompact.measure_ne_top [TopologicalSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] ⦃K : Set α⦄ (hK : IsCompact K) : μ K ≠ ∞ 
goal: μ K ≠ ⊤

full_name: Bornology.IsBounded.measure_lt_top
code: /-- A bounded subset has finite measure for a measure which is finite on compact sets, in a
proper space. -/
theorem _root_.Bornology.IsBounded.measure_lt_top [PseudoMetricSpace α] [ProperSpace α]
    {μ : Measure α} [IsFiniteMeasureOnCompacts μ] ⦃s : Set α⦄ (hs : Bornology.IsBounded s) :
    μ s < ∞ 
goal: μ s < ⊤

full_name: MeasureTheory.measure_closedBall_lt_top
code: theorem measure_closedBall_lt_top [PseudoMetricSpace α] [ProperSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] {x : α} {r : ℝ} : μ (Metric.closedBall x r) < ∞ 
goal: μ (Metric.closedBall x r) < ⊤

full_name: MeasureTheory.measure_ball_lt_top
code: theorem measure_ball_lt_top [PseudoMetricSpace α] [ProperSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] {x : α} {r : ℝ} : μ (Metric.ball x r) < ∞ 
goal: μ (Metric.ball x r) < ⊤

full_name: MeasureTheory.IsFiniteMeasureOnCompacts.smul
code: protected theorem IsFiniteMeasureOnCompacts.smul [TopologicalSpace α] (μ : Measure α)
    [IsFiniteMeasureOnCompacts μ] {c : ℝ≥0∞} (hc : c ≠ ∞) : IsFiniteMeasureOnCompacts (c • μ) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts (c • μ)

full_name: MeasureTheory.IsFiniteMeasureOnCompacts.smul_nnreal
code: instance IsFiniteMeasureOnCompacts.smul_nnreal [TopologicalSpace α] (μ : Measure α)
    [IsFiniteMeasureOnCompacts μ] (c : ℝ≥0) : IsFiniteMeasureOnCompacts (c • μ) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts (c • μ)

full_name: MeasureTheory.instIsFiniteMeasureOnCompactsRestrict
code: instance instIsFiniteMeasureOnCompactsRestrict [TopologicalSpace α] {μ : Measure α}
    [IsFiniteMeasureOnCompacts μ] {s : Set α} : IsFiniteMeasureOnCompacts (μ.restrict s) 
goal: MeasureTheory.IsFiniteMeasureOnCompacts (μ.restrict s)

full_name: MeasureTheory.CompactSpace.isFiniteMeasure
code: instance (priority := 100) CompactSpace.isFiniteMeasure [TopologicalSpace α] [CompactSpace α]
    [IsFiniteMeasureOnCompacts μ] : IsFiniteMeasure μ 
goal: MeasureTheory.IsFiniteMeasure μ

full_name: MeasureTheory.SigmaFinite.of_isFiniteMeasureOnCompacts
code: instance (priority := 100) SigmaFinite.of_isFiniteMeasureOnCompacts [TopologicalSpace α]
    [SigmaCompactSpace α] (μ : Measure α) [IsFiniteMeasureOnCompacts μ] : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.sigmaFinite_of_locallyFinite
code: instance (priority := 100) sigmaFinite_of_locallyFinite [TopologicalSpace α]
    [SecondCountableTopology α] [IsLocallyFiniteMeasure μ] : SigmaFinite μ 
goal: MeasureTheory.SigmaFinite μ

full_name: MeasureTheory.isLocallyFiniteMeasure_of_isFiniteMeasureOnCompacts
code: /-- A measure which is finite on compact sets in a locally compact space is locally finite. -/
instance (priority := 100) isLocallyFiniteMeasure_of_isFiniteMeasureOnCompacts [TopologicalSpace α]
    [WeaklyLocallyCompactSpace α] [IsFiniteMeasureOnCompacts μ] : IsLocallyFiniteMeasure μ 
goal: MeasureTheory.IsLocallyFiniteMeasure μ

full_name: MeasureTheory.exists_pos_measure_of_cover
code: theorem exists_pos_measure_of_cover [Countable ι] {U : ι → Set α} (hU : ⋃ i, U i = univ)
    (hμ : μ ≠ 0) : ∃ i, 0 < μ (U i) 
goal: ∃ i, 0 < μ (U i)

full_name: MeasureTheory.exists_pos_preimage_ball
code: theorem exists_pos_preimage_ball [PseudoMetricSpace δ] (f : α → δ) (x : δ) (hμ : μ ≠ 0) :
    ∃ n : ℕ, 0 < μ (f ⁻¹' Metric.ball x n) 
goal: ∃ n, 0 < μ (f ⁻¹' Metric.ball x ↑n)

full_name: MeasureTheory.exists_pos_ball
code: theorem exists_pos_ball [PseudoMetricSpace α] (x : α) (hμ : μ ≠ 0) :
    ∃ n : ℕ, 0 < μ (Metric.ball x n) 
goal: ∃ n, 0 < μ (Metric.ball x ↑n)

full_name: MeasureTheory.exists_ne_forall_mem_nhds_pos_measure_preimage
code: theorem exists_ne_forall_mem_nhds_pos_measure_preimage {β} [TopologicalSpace β] [T1Space β]
    [SecondCountableTopology β] [Nonempty β] {f : α → β} (h : ∀ b, ∃ᵐ x ∂μ, f x ≠ b) :
    ∃ a b : β, a ≠ b ∧ (∀ s ∈ 𝓝 a, 0 < μ (f ⁻¹' s)) ∧ ∀ t ∈ 𝓝 b, 0 < μ (f ⁻¹' t) 
goal: ∃ a b, a ≠ b ∧ (∀ s ∈ 𝓝 a, 0 < μ (f ⁻¹' s)) ∧ ∀ t ∈ 𝓝 b, 0 < μ (f ⁻¹' t)

full_name: MeasureTheory.ext_on_measurableSpace_of_generate_finite
code: /-- If two finite measures give the same mass to the whole space and coincide on a π-system made
of measurable sets, then they coincide on all sets in the σ-algebra generated by the π-system. -/
theorem ext_on_measurableSpace_of_generate_finite {α} (m₀ : MeasurableSpace α) {μ ν : Measure α}
    [IsFiniteMeasure μ] (C : Set (Set α)) (hμν : ∀ s ∈ C, μ s = ν s) {m : MeasurableSpace α}
    (h : m ≤ m₀) (hA : m = MeasurableSpace.generateFrom C) (hC : IsPiSystem C)
    (h_univ : μ Set.univ = ν Set.univ) {s : Set α} (hs : MeasurableSet[m] s) : μ s = ν s 
goal: μ s = ν s

full_name: MeasureTheory.ext_of_generate_finite
code: /-- Two finite measures are equal if they are equal on the π-system generating the σ-algebra
  (and `univ`). -/
theorem ext_of_generate_finite (C : Set (Set α)) (hA : m0 = generateFrom C) (hC : IsPiSystem C)
    [IsFiniteMeasure μ] (hμν : ∀ s ∈ C, μ s = ν s) (h_univ : μ univ = ν univ) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed
code: /-- Given `S : μ.FiniteSpanningSetsIn {s | MeasurableSet s}`,
`FiniteSpanningSetsIn.disjointed` provides a `FiniteSpanningSetsIn {s | MeasurableSet s}`
such that its underlying sets are pairwise disjoint. -/
protected def FiniteSpanningSetsIn.disjointed {μ : Measure α}
    (S : μ.FiniteSpanningSetsIn { s | MeasurableSet s }) :
    μ.FiniteSpanningSetsIn { s | MeasurableSet s } 
goal: μ.FiniteSpanningSetsIn {s | MeasurableSet s}

full_name: MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed_set_eq
code: theorem FiniteSpanningSetsIn.disjointed_set_eq {μ : Measure α}
    (S : μ.FiniteSpanningSetsIn { s | MeasurableSet s }) : S.disjointed.set = disjointed S.set 
goal: S.disjointed.set = disjointed S.set

full_name: MeasureTheory.Measure.exists_eq_disjoint_finiteSpanningSetsIn
code: theorem exists_eq_disjoint_finiteSpanningSetsIn (μ ν : Measure α) [SigmaFinite μ] [SigmaFinite ν] :
    ∃ (S : μ.FiniteSpanningSetsIn { s | MeasurableSet s })
      (T : ν.FiniteSpanningSetsIn { s | MeasurableSet s }),
      S.set = T.set ∧ Pairwise (Disjoint on S.set) 
goal: ∃ S T, S.set = T.set ∧ Pairwise (Disjoint on S.set)

full_name: MeasureTheory.Measure.FiniteAtFilter.filter_mono
code: theorem filter_mono (h : f ≤ g) : μ.FiniteAtFilter g → μ.FiniteAtFilter f 
goal: μ.FiniteAtFilter g → μ.FiniteAtFilter f

full_name: MeasureTheory.Measure.FiniteAtFilter.inf_of_left
code: theorem inf_of_left (h : μ.FiniteAtFilter f) : μ.FiniteAtFilter (f ⊓ g) 
goal: μ.FiniteAtFilter (f ⊓ g)

full_name: MeasureTheory.Measure.FiniteAtFilter.inf_of_right
code: theorem inf_of_right (h : μ.FiniteAtFilter g) : μ.FiniteAtFilter (f ⊓ g) 
goal: μ.FiniteAtFilter (f ⊓ g)

full_name: MeasureTheory.Measure.FiniteAtFilter.inf_ae_iff
code: @[simp]
theorem inf_ae_iff : μ.FiniteAtFilter (f ⊓ ae μ) ↔ μ.FiniteAtFilter f 
goal: μ.FiniteAtFilter (f ⊓ MeasureTheory.ae μ) ↔ μ.FiniteAtFilter f

full_name: MeasureTheory.Measure.FiniteAtFilter.filter_mono_ae
code: theorem filter_mono_ae (h : f ⊓ (ae μ) ≤ g) (hg : μ.FiniteAtFilter g) : μ.FiniteAtFilter f 
goal: μ.FiniteAtFilter f

full_name: MeasureTheory.Measure.FiniteAtFilter.measure_mono
code: protected theorem measure_mono (h : μ ≤ ν) : ν.FiniteAtFilter f → μ.FiniteAtFilter f 
goal: ν.FiniteAtFilter f → μ.FiniteAtFilter f

full_name: MeasureTheory.Measure.FiniteAtFilter.mono
code: @[mono]
protected theorem mono (hf : f ≤ g) (hμ : μ ≤ ν) : ν.FiniteAtFilter g → μ.FiniteAtFilter f 
goal: ν.FiniteAtFilter g → μ.FiniteAtFilter f

full_name: MeasureTheory.Measure.FiniteAtFilter.eventually
code: protected theorem eventually (h : μ.FiniteAtFilter f) : ∀ᶠ s in f.smallSets, μ s < ∞ 
goal: ∀ᶠ (s : Set α) in f.smallSets, μ s < ⊤

full_name: MeasureTheory.Measure.FiniteAtFilter.filterSup
code: theorem filterSup : μ.FiniteAtFilter f → μ.FiniteAtFilter g → μ.FiniteAtFilter (f ⊔ g) 
goal: μ.FiniteAtFilter f → μ.FiniteAtFilter g → μ.FiniteAtFilter (f ⊔ g)

full_name: MeasureTheory.Measure.finiteAt_nhdsWithin
code: theorem finiteAt_nhdsWithin [TopologicalSpace α] {_m0 : MeasurableSpace α} (μ : Measure α)
    [IsLocallyFiniteMeasure μ] (x : α) (s : Set α) : μ.FiniteAtFilter (𝓝[s] x) 
goal: μ.FiniteAtFilter (𝓝[s] x)

full_name: MeasureTheory.Measure.finiteAt_principal
code: @[simp]
theorem finiteAt_principal : μ.FiniteAtFilter (𝓟 s) ↔ μ s < ∞ 
goal: μ.FiniteAtFilter (𝓟 s) ↔ μ s < ⊤

full_name: MeasureTheory.Measure.isLocallyFiniteMeasure_of_le
code: theorem isLocallyFiniteMeasure_of_le [TopologicalSpace α] {_m : MeasurableSpace α} {μ ν : Measure α}
    [H : IsLocallyFiniteMeasure μ] (h : ν ≤ μ) : IsLocallyFiniteMeasure ν 
goal: MeasureTheory.IsLocallyFiniteMeasure ν

full_name: IsCompact.exists_open_superset_measure_lt_top'
code: /-- If `s` is a compact set and `μ` is finite at `𝓝 x` for every `x ∈ s`, then `s` admits an open
superset of finite measure. -/
theorem exists_open_superset_measure_lt_top' (h : IsCompact s)
    (hμ : ∀ x ∈ s, μ.FiniteAtFilter (𝓝 x)) : ∃ U ⊇ s, IsOpen U ∧ μ U < ∞ 
goal: ∃ U ⊇ s, IsOpen U ∧ μ U < ⊤

full_name: IsCompact.exists_open_superset_measure_lt_top
code: /-- If `s` is a compact set and `μ` is a locally finite measure, then `s` admits an open superset of
finite measure. -/
theorem exists_open_superset_measure_lt_top (h : IsCompact s) (μ : Measure α)
    [IsLocallyFiniteMeasure μ] : ∃ U ⊇ s, IsOpen U ∧ μ U < ∞ 
goal: ∃ U ⊇ s, IsOpen U ∧ μ U < ⊤

full_name: IsCompact.measure_lt_top_of_nhdsWithin
code: theorem measure_lt_top_of_nhdsWithin (h : IsCompact s) (hμ : ∀ x ∈ s, μ.FiniteAtFilter (𝓝[s] x)) :
    μ s < ∞ 
goal: μ s < ⊤

full_name: IsCompact.measure_zero_of_nhdsWithin
code: theorem measure_zero_of_nhdsWithin (hs : IsCompact s) :
    (∀ a ∈ s, ∃ t ∈ 𝓝[s] a, μ t = 0) → μ s = 0 
goal: (∀ a ∈ s, ∃ t ∈ 𝓝[s] a, μ t = 0) → μ s = 0

full_name: isFiniteMeasureOnCompacts_of_isLocallyFiniteMeasure
code: instance (priority := 100) isFiniteMeasureOnCompacts_of_isLocallyFiniteMeasure [TopologicalSpace α]
    {_ : MeasurableSpace α} {μ : Measure α} [IsLocallyFiniteMeasure μ] :
    IsFiniteMeasureOnCompacts μ 
goal: ∀ {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.IsLocallyFiniteMeasure μ],
  MeasureTheory.IsFiniteMeasureOnCompacts μ

full_name: isFiniteMeasure_iff_isFiniteMeasureOnCompacts_of_compactSpace
code: theorem isFiniteMeasure_iff_isFiniteMeasureOnCompacts_of_compactSpace [TopologicalSpace α]
    [MeasurableSpace α] {μ : Measure α} [CompactSpace α] :
    IsFiniteMeasure μ ↔ IsFiniteMeasureOnCompacts μ 
goal: MeasureTheory.IsFiniteMeasure μ ↔ MeasureTheory.IsFiniteMeasureOnCompacts μ

full_name: MeasureTheory.Measure.finiteSpanningSetsInCompact
code: /-- Compact covering of a `σ`-compact topological space as
`MeasureTheory.Measure.FiniteSpanningSetsIn`. -/
def MeasureTheory.Measure.finiteSpanningSetsInCompact [TopologicalSpace α] [SigmaCompactSpace α]
    {_ : MeasurableSpace α} (μ : Measure α) [IsLocallyFiniteMeasure μ] :
    μ.FiniteSpanningSetsIn { K | IsCompact K } 
goal: {x : MeasurableSpace α} →
  (μ : MeasureTheory.Measure α) →
    [inst : MeasureTheory.IsLocallyFiniteMeasure μ] → μ.FiniteSpanningSetsIn {K | IsCompact K}

full_name: MeasureTheory.Measure.finiteSpanningSetsInOpen
code: /-- A locally finite measure on a `σ`-compact topological space admits a finite spanning sequence
of open sets. -/
def MeasureTheory.Measure.finiteSpanningSetsInOpen [TopologicalSpace α] [SigmaCompactSpace α]
    {_ : MeasurableSpace α} (μ : Measure α) [IsLocallyFiniteMeasure μ] :
    μ.FiniteSpanningSetsIn { K | IsOpen K } 
goal: {x : MeasurableSpace α} →
  (μ : MeasureTheory.Measure α) →
    [inst : MeasureTheory.IsLocallyFiniteMeasure μ] → μ.FiniteSpanningSetsIn {K | IsOpen K}

full_name: wrapped._@.Mathlib.MeasureTheory.Measure.Typeclasses._hyg.21963
code: /-- A locally finite measure on a second countable topological space admits a finite spanning
sequence of open sets. -/
noncomputable irreducible_def MeasureTheory.Measure.finiteSpanningSetsInOpen' [TopologicalSpace α]
  [SecondCountableTopology α] {m : MeasurableSpace α} (μ : Measure α) [IsLocallyFiniteMeasure μ] :
  μ.FiniteSpanningSetsIn { K | IsOpen K } 
goal: Subtype (Eq @definition✝)

full_name: MeasureTheory.Measure.finiteSpanningSetsInOpen'_def
code: /-- A locally finite measure on a second countable topological space admits a finite spanning
sequence of open sets. -/
noncomputable irreducible_def MeasureTheory.Measure.finiteSpanningSetsInOpen' [TopologicalSpace α]
  [SecondCountableTopology α] {m : MeasurableSpace α} (μ : Measure α) [IsLocallyFiniteMeasure μ] :
  μ.FiniteSpanningSetsIn { K | IsOpen K } 
goal: μ.finiteSpanningSetsInOpen' =
  let_fun H := ⋯;
  H.some

full_name: MeasureTheory.Measure.finiteSpanningSetsInOpen'
code: /-- A locally finite measure on a second countable topological space admits a finite spanning
sequence of open sets. -/
noncomputable irreducible_def MeasureTheory.Measure.finiteSpanningSetsInOpen' [TopologicalSpace α]
  [SecondCountableTopology α] {m : MeasurableSpace α} (μ : Measure α) [IsLocallyFiniteMeasure μ] :
  μ.FiniteSpanningSetsIn { K | IsOpen K } 
goal: μ.FiniteSpanningSetsIn {K | IsOpen K}

full_name: definition._@.Mathlib.MeasureTheory.Measure.Typeclasses._hyg.21963
code: /-- A locally finite measure on a second countable topological space admits a finite spanning
sequence of open sets. -/
noncomputable irreducible_def MeasureTheory.Measure.finiteSpanningSetsInOpen' [TopologicalSpace α]
  [SecondCountableTopology α] {m : MeasurableSpace α} (μ : Measure α) [IsLocallyFiniteMeasure μ] :
  μ.FiniteSpanningSetsIn { K | IsOpen K } 
goal: μ.FiniteSpanningSetsIn {K | IsOpen K}

full_name: measure_Icc_lt_top
code: theorem measure_Icc_lt_top : μ (Icc a b) < ∞ 
goal: μ (Set.Icc a b) < ⊤

full_name: measure_Ico_lt_top
code: theorem measure_Ico_lt_top : μ (Ico a b) < ∞ 
goal: μ (Set.Ico a b) < ⊤

full_name: measure_Ioc_lt_top
code: theorem measure_Ioc_lt_top : μ (Ioc a b) < ∞ 
goal: μ (Set.Ioc a b) < ⊤

full_name: measure_Ioo_lt_top
code: theorem measure_Ioo_lt_top : μ (Ioo a b) < ∞ 
goal: μ (Set.Ioo a b) < ⊤