File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

full_name: MeasureTheory.ae_isMeasurablyGenerated
code: instance ae_isMeasurablyGenerated : IsMeasurablyGenerated (ae μ) 
goal: (MeasureTheory.ae μ).IsMeasurablyGenerated

full_name: MeasureTheory.ae_uIoc_iff
code: /-- See also `MeasureTheory.ae_restrict_uIoc_iff`. -/
theorem ae_uIoc_iff [LinearOrder α] {a b : α} {P : α → Prop} :
    (∀ᵐ x ∂μ, x ∈ Ι a b → P x) ↔ (∀ᵐ x ∂μ, x ∈ Ioc a b → P x) ∧ ∀ᵐ x ∂μ, x ∈ Ioc b a → P x 
goal: (∀ᵐ (x : α) ∂μ, x ∈ Ι a b → P x) ↔ (∀ᵐ (x : α) ∂μ, x ∈ Set.Ioc a b → P x) ∧ ∀ᵐ (x : α) ∂μ, x ∈ Set.Ioc b a → P x

full_name: MeasureTheory.measure_union
code: theorem measure_union (hd : Disjoint s₁ s₂) (h : MeasurableSet s₂) : μ (s₁ ∪ s₂) = μ s₁ + μ s₂ 
goal: μ (s₁ ∪ s₂) = μ s₁ + μ s₂

full_name: MeasureTheory.measure_union'
code: theorem measure_union' (hd : Disjoint s₁ s₂) (h : MeasurableSet s₁) : μ (s₁ ∪ s₂) = μ s₁ + μ s₂ 
goal: μ (s₁ ∪ s₂) = μ s₁ + μ s₂

full_name: MeasureTheory.measure_inter_add_diff
code: theorem measure_inter_add_diff (s : Set α) (ht : MeasurableSet t) : μ (s ∩ t) + μ (s \ t) = μ s 
goal: μ (s ∩ t) + μ (s \ t) = μ s

full_name: MeasureTheory.measure_diff_add_inter
code: theorem measure_diff_add_inter (s : Set α) (ht : MeasurableSet t) : μ (s \ t) + μ (s ∩ t) = μ s 
goal: μ (s \ t) + μ (s ∩ t) = μ s

full_name: MeasureTheory.measure_union_add_inter
code: theorem measure_union_add_inter (s : Set α) (ht : MeasurableSet t) :
    μ (s ∪ t) + μ (s ∩ t) = μ s + μ t 
goal: μ (s ∪ t) + μ (s ∩ t) = μ s + μ t

full_name: MeasureTheory.measure_union_add_inter'
code: theorem measure_union_add_inter' (hs : MeasurableSet s) (t : Set α) :
    μ (s ∪ t) + μ (s ∩ t) = μ s + μ t 
goal: μ (s ∪ t) + μ (s ∩ t) = μ s + μ t

full_name: MeasureTheory.measure_symmDiff_eq
code: lemma measure_symmDiff_eq (hs : MeasurableSet s) (ht : MeasurableSet t) :
    μ (s ∆ t) = μ (s \ t) + μ (t \ s) 
goal: μ (symmDiff s t) = μ (s \ t) + μ (t \ s)

full_name: MeasureTheory.measure_symmDiff_le
code: lemma measure_symmDiff_le (s t u : Set α) :
    μ (s ∆ u) ≤ μ (s ∆ t) + μ (t ∆ u) 
goal: μ (symmDiff s u) ≤ μ (symmDiff s t) + μ (symmDiff t u)

full_name: MeasureTheory.measure_add_measure_compl
code: theorem measure_add_measure_compl (h : MeasurableSet s) : μ s + μ sᶜ = μ univ 
goal: μ s + μ sᶜ = μ Set.univ

full_name: MeasureTheory.measure_biUnion₀
code: theorem measure_biUnion₀ {s : Set β} {f : β → Set α} (hs : s.Countable)
    (hd : s.Pairwise (AEDisjoint μ on f)) (h : ∀ b ∈ s, NullMeasurableSet (f b) μ) :
    μ (⋃ b ∈ s, f b) = ∑' p : s, μ (f p) 
goal: μ (⋃ b ∈ s, f b) = ∑' (p : ↑s), μ (f ↑p)

full_name: MeasureTheory.measure_biUnion
code: theorem measure_biUnion {s : Set β} {f : β → Set α} (hs : s.Countable) (hd : s.PairwiseDisjoint f)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : μ (⋃ b ∈ s, f b) = ∑' p : s, μ (f p) 
goal: μ (⋃ b ∈ s, f b) = ∑' (p : ↑s), μ (f ↑p)

full_name: MeasureTheory.measure_sUnion₀
code: theorem measure_sUnion₀ {S : Set (Set α)} (hs : S.Countable) (hd : S.Pairwise (AEDisjoint μ))
    (h : ∀ s ∈ S, NullMeasurableSet s μ) : μ (⋃₀ S) = ∑' s : S, μ s 
goal: μ (⋃₀ S) = ∑' (s : ↑S), μ ↑s

full_name: MeasureTheory.measure_sUnion
code: theorem measure_sUnion {S : Set (Set α)} (hs : S.Countable) (hd : S.Pairwise Disjoint)
    (h : ∀ s ∈ S, MeasurableSet s) : μ (⋃₀ S) = ∑' s : S, μ s 
goal: μ (⋃₀ S) = ∑' (s : ↑S), μ ↑s

full_name: MeasureTheory.measure_biUnion_finset₀
code: theorem measure_biUnion_finset₀ {s : Finset ι} {f : ι → Set α}
    (hd : Set.Pairwise (↑s) (AEDisjoint μ on f)) (hm : ∀ b ∈ s, NullMeasurableSet (f b) μ) :
    μ (⋃ b ∈ s, f b) = ∑ p ∈ s, μ (f p) 
goal: μ (⋃ b ∈ s, f b) = ∑ p ∈ s, μ (f p)

full_name: MeasureTheory.measure_biUnion_finset
code: theorem measure_biUnion_finset {s : Finset ι} {f : ι → Set α} (hd : PairwiseDisjoint (↑s) f)
    (hm : ∀ b ∈ s, MeasurableSet (f b)) : μ (⋃ b ∈ s, f b) = ∑ p ∈ s, μ (f p) 
goal: μ (⋃ b ∈ s, f b) = ∑ p ∈ s, μ (f p)

full_name: MeasureTheory.tsum_meas_le_meas_iUnion_of_disjoint₀
code: /-- The measure of an a.e. disjoint union (even uncountable) of null-measurable sets is at least
the sum of the measures of the sets. -/
theorem tsum_meas_le_meas_iUnion_of_disjoint₀ {ι : Type*} [MeasurableSpace α] (μ : Measure α)
    {As : ι → Set α} (As_mble : ∀ i : ι, NullMeasurableSet (As i) μ)
    (As_disj : Pairwise (AEDisjoint μ on As)) : (∑' i, μ (As i)) ≤ μ (⋃ i, As i) 
goal: ∑' (i : ι), μ (As i) ≤ μ (⋃ i, As i)

full_name: MeasureTheory.tsum_meas_le_meas_iUnion_of_disjoint
code: /-- The measure of a disjoint union (even uncountable) of measurable sets is at least the sum of
the measures of the sets. -/
theorem tsum_meas_le_meas_iUnion_of_disjoint {ι : Type*} [MeasurableSpace α] (μ : Measure α)
    {As : ι → Set α} (As_mble : ∀ i : ι, MeasurableSet (As i))
    (As_disj : Pairwise (Disjoint on As)) : (∑' i, μ (As i)) ≤ μ (⋃ i, As i) 
goal: ∑' (i : ι), μ (As i) ≤ μ (⋃ i, As i)

full_name: MeasureTheory.tsum_measure_preimage_singleton
code: /-- If `s` is a countable set, then the measure of its preimage can be found as the sum of measures
of the fibers `f ⁻¹' {y}`. -/
theorem tsum_measure_preimage_singleton {s : Set β} (hs : s.Countable) {f : α → β}
    (hf : ∀ y ∈ s, MeasurableSet (f ⁻¹' {y})) : (∑' b : s, μ (f ⁻¹' {↑b})) = μ (f ⁻¹' s) 
goal: ∑' (b : ↑s), μ (f ⁻¹' {↑b}) = μ (f ⁻¹' s)

full_name: MeasureTheory.measure_preimage_eq_zero_iff_of_countable
code: lemma measure_preimage_eq_zero_iff_of_countable {s : Set β} {f : α → β} (hs : s.Countable) :
    μ (f ⁻¹' s) = 0 ↔ ∀ x ∈ s, μ (f ⁻¹' {x}) = 0 
goal: μ (f ⁻¹' s) = 0 ↔ ∀ x ∈ s, μ (f ⁻¹' {x}) = 0

full_name: MeasureTheory.sum_measure_preimage_singleton
code: /-- If `s` is a `Finset`, then the measure of its preimage can be found as the sum of measures
of the fibers `f ⁻¹' {y}`. -/
theorem sum_measure_preimage_singleton (s : Finset β) {f : α → β}
    (hf : ∀ y ∈ s, MeasurableSet (f ⁻¹' {y})) : (∑ b ∈ s, μ (f ⁻¹' {b})) = μ (f ⁻¹' ↑s) 
goal: ∑ b ∈ s, μ (f ⁻¹' {b}) = μ (f ⁻¹' ↑s)

full_name: MeasureTheory.measure_diff_null'
code: theorem measure_diff_null' (h : μ (s₁ ∩ s₂) = 0) : μ (s₁ \ s₂) = μ s₁ 
goal: μ (s₁ \ s₂) = μ s₁

full_name: MeasureTheory.measure_add_diff
code: theorem measure_add_diff (hs : MeasurableSet s) (t : Set α) : μ s + μ (t \ s) = μ (s ∪ t) 
goal: μ s + μ (t \ s) = μ (s ∪ t)

full_name: MeasureTheory.measure_diff'
code: theorem measure_diff' (s : Set α) (hm : MeasurableSet t) (h_fin : μ t ≠ ∞) :
    μ (s \ t) = μ (s ∪ t) - μ t 
goal: μ (s \ t) = μ (s ∪ t) - μ t

full_name: MeasureTheory.measure_diff
code: theorem measure_diff (h : s₂ ⊆ s₁) (h₂ : MeasurableSet s₂) (h_fin : μ s₂ ≠ ∞) :
    μ (s₁ \ s₂) = μ s₁ - μ s₂ 
goal: μ (s₁ \ s₂) = μ s₁ - μ s₂

full_name: MeasureTheory.le_measure_diff
code: theorem le_measure_diff : μ s₁ - μ s₂ ≤ μ (s₁ \ s₂) 
goal: μ s₁ - μ s₂ ≤ μ (s₁ \ s₂)

full_name: MeasureTheory.measure_eq_top_iff_of_symmDiff
code: /-- If the measure of the symmetric difference of two sets is finite,
then one has infinite measure if and only if the other one does. -/
theorem measure_eq_top_iff_of_symmDiff (hμst : μ (s ∆ t) ≠ ∞) : μ s = ∞ ↔ μ t = ∞ 
goal: μ s = ⊤ ↔ μ t = ⊤

full_name: MeasureTheory.measure_ne_top_iff_of_symmDiff
code: /-- If the measure of the symmetric difference of two sets is finite,
then one has finite measure if and only if the other one does. -/
theorem measure_ne_top_iff_of_symmDiff (hμst : μ (s ∆ t) ≠ ∞) : μ s ≠ ∞ ↔ μ t ≠ ∞ 
goal: μ s ≠ ⊤ ↔ μ t ≠ ⊤

full_name: MeasureTheory.measure_diff_lt_of_lt_add
code: theorem measure_diff_lt_of_lt_add (hs : MeasurableSet s) (hst : s ⊆ t) (hs' : μ s ≠ ∞) {ε : ℝ≥0∞}
    (h : μ t < μ s + ε) : μ (t \ s) < ε 
goal: μ (t \ s) < ε

full_name: MeasureTheory.measure_diff_le_iff_le_add
code: theorem measure_diff_le_iff_le_add (hs : MeasurableSet s) (hst : s ⊆ t) (hs' : μ s ≠ ∞) {ε : ℝ≥0∞} :
    μ (t \ s) ≤ ε ↔ μ t ≤ μ s + ε 
goal: μ (t \ s) ≤ ε ↔ μ t ≤ μ s + ε

full_name: MeasureTheory.measure_eq_measure_of_null_diff
code: theorem measure_eq_measure_of_null_diff {s t : Set α} (hst : s ⊆ t) (h_nulldiff : μ (t \ s) = 0) :
    μ s = μ t 
goal: μ s = μ t

full_name: MeasureTheory.measure_eq_measure_of_between_null_diff
code: theorem measure_eq_measure_of_between_null_diff {s₁ s₂ s₃ : Set α} (h12 : s₁ ⊆ s₂) (h23 : s₂ ⊆ s₃)
    (h_nulldiff : μ (s₃ \ s₁) = 0) : μ s₁ = μ s₂ ∧ μ s₂ = μ s₃ 
goal: μ s₁ = μ s₂ ∧ μ s₂ = μ s₃

full_name: MeasureTheory.measure_eq_measure_smaller_of_between_null_diff
code: theorem measure_eq_measure_smaller_of_between_null_diff {s₁ s₂ s₃ : Set α} (h12 : s₁ ⊆ s₂)
    (h23 : s₂ ⊆ s₃) (h_nulldiff : μ (s₃ \ s₁) = 0) : μ s₁ = μ s₂ 
goal: μ s₁ = μ s₂

full_name: MeasureTheory.measure_eq_measure_larger_of_between_null_diff
code: theorem measure_eq_measure_larger_of_between_null_diff {s₁ s₂ s₃ : Set α} (h12 : s₁ ⊆ s₂)
    (h23 : s₂ ⊆ s₃) (h_nulldiff : μ (s₃ \ s₁) = 0) : μ s₂ = μ s₃ 
goal: μ s₂ = μ s₃

full_name: MeasureTheory.measure_compl₀
code: lemma measure_compl₀ (h : NullMeasurableSet s μ) (hs : μ s ≠ ∞) :
    μ sᶜ = μ Set.univ - μ s 
goal: μ sᶜ = μ Set.univ - μ s

full_name: MeasureTheory.measure_compl
code: theorem measure_compl (h₁ : MeasurableSet s) (h_fin : μ s ≠ ∞) : μ sᶜ = μ univ - μ s 
goal: μ sᶜ = μ Set.univ - μ s

full_name: MeasureTheory.measure_inter_conull'
code: lemma measure_inter_conull' (ht : μ (s \ t) = 0) : μ (s ∩ t) = μ s 
goal: μ (s ∩ t) = μ s

full_name: MeasureTheory.measure_inter_conull
code: lemma measure_inter_conull (ht : μ tᶜ = 0) : μ (s ∩ t) = μ s 
goal: μ (s ∩ t) = μ s

full_name: MeasureTheory.union_ae_eq_left_iff_ae_subset
code: @[simp]
theorem union_ae_eq_left_iff_ae_subset : (s ∪ t : Set α) =ᵐ[μ] s ↔ t ≤ᵐ[μ] s 
goal: s ∪ t =ᵐ[μ] s ↔ t ≤ᵐ[μ] s

full_name: MeasureTheory.union_ae_eq_right_iff_ae_subset
code: @[simp]
theorem union_ae_eq_right_iff_ae_subset : (s ∪ t : Set α) =ᵐ[μ] t ↔ s ≤ᵐ[μ] t 
goal: s ∪ t =ᵐ[μ] t ↔ s ≤ᵐ[μ] t

full_name: MeasureTheory.ae_eq_of_ae_subset_of_measure_ge
code: theorem ae_eq_of_ae_subset_of_measure_ge (h₁ : s ≤ᵐ[μ] t) (h₂ : μ t ≤ μ s) (hsm : MeasurableSet s)
    (ht : μ t ≠ ∞) : s =ᵐ[μ] t 
goal: s =ᵐ[μ] t

full_name: MeasureTheory.ae_eq_of_subset_of_measure_ge
code: /-- If `s ⊆ t`, `μ t ≤ μ s`, `μ t ≠ ∞`, and `s` is measurable, then `s =ᵐ[μ] t`. -/
theorem ae_eq_of_subset_of_measure_ge (h₁ : s ⊆ t) (h₂ : μ t ≤ μ s) (hsm : MeasurableSet s)
    (ht : μ t ≠ ∞) : s =ᵐ[μ] t 
goal: s =ᵐ[μ] t

full_name: MeasureTheory.measure_iUnion_congr_of_subset
code: theorem measure_iUnion_congr_of_subset [Countable β] {s : β → Set α} {t : β → Set α}
    (hsub : ∀ b, s b ⊆ t b) (h_le : ∀ b, μ (t b) ≤ μ (s b)) : μ (⋃ b, s b) = μ (⋃ b, t b) 
goal: μ (⋃ b, s b) = μ (⋃ b, t b)

full_name: MeasureTheory.measure_union_congr_of_subset
code: theorem measure_union_congr_of_subset {t₁ t₂ : Set α} (hs : s₁ ⊆ s₂) (hsμ : μ s₂ ≤ μ s₁)
    (ht : t₁ ⊆ t₂) (htμ : μ t₂ ≤ μ t₁) : μ (s₁ ∪ t₁) = μ (s₂ ∪ t₂) 
goal: μ (s₁ ∪ t₁) = μ (s₂ ∪ t₂)

full_name: MeasureTheory.measure_iUnion_toMeasurable
code: @[simp]
theorem measure_iUnion_toMeasurable [Countable β] (s : β → Set α) :
    μ (⋃ b, toMeasurable μ (s b)) = μ (⋃ b, s b) 
goal: μ (⋃ b, MeasureTheory.toMeasurable μ (s b)) = μ (⋃ b, s b)

full_name: MeasureTheory.measure_biUnion_toMeasurable
code: theorem measure_biUnion_toMeasurable {I : Set β} (hc : I.Countable) (s : β → Set α) :
    μ (⋃ b ∈ I, toMeasurable μ (s b)) = μ (⋃ b ∈ I, s b) 
goal: μ (⋃ b ∈ I, MeasureTheory.toMeasurable μ (s b)) = μ (⋃ b ∈ I, s b)

full_name: MeasureTheory.measure_toMeasurable_union
code: @[simp]
theorem measure_toMeasurable_union : μ (toMeasurable μ s ∪ t) = μ (s ∪ t) 
goal: μ (MeasureTheory.toMeasurable μ s ∪ t) = μ (s ∪ t)

full_name: MeasureTheory.measure_union_toMeasurable
code: @[simp]
theorem measure_union_toMeasurable : μ (s ∪ toMeasurable μ t) = μ (s ∪ t) 
goal: μ (s ∪ MeasureTheory.toMeasurable μ t) = μ (s ∪ t)

full_name: MeasureTheory.sum_measure_le_measure_univ
code: theorem sum_measure_le_measure_univ {s : Finset ι} {t : ι → Set α}
    (h : ∀ i ∈ s, NullMeasurableSet (t i) μ) (H : Set.Pairwise s (AEDisjoint μ on t)) :
    (∑ i ∈ s, μ (t i)) ≤ μ (univ : Set α) 
goal: ∑ i ∈ s, μ (t i) ≤ μ Set.univ

full_name: MeasureTheory.tsum_measure_le_measure_univ
code: theorem tsum_measure_le_measure_univ {s : ι → Set α} (hs : ∀ i, NullMeasurableSet (s i) μ)
    (H : Pairwise (AEDisjoint μ on s)) : ∑' i, μ (s i) ≤ μ (univ : Set α) 
goal: ∑' (i : ι), μ (s i) ≤ μ Set.univ

full_name: MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_tsum_measure
code: /-- Pigeonhole principle for measure spaces: if `∑' i, μ (s i) > μ univ`, then
one of the intersections `s i ∩ s j` is not empty. -/
theorem exists_nonempty_inter_of_measure_univ_lt_tsum_measure {m : MeasurableSpace α}
    (μ : Measure α) {s : ι → Set α} (hs : ∀ i, NullMeasurableSet (s i) μ)
    (H : μ (univ : Set α) < ∑' i, μ (s i)) : ∃ i j, i ≠ j ∧ (s i ∩ s j).Nonempty 
goal: ∃ i j, i ≠ j ∧ (s i ∩ s j).Nonempty

full_name: MeasureTheory.exists_nonempty_inter_of_measure_univ_lt_sum_measure
code: /-- Pigeonhole principle for measure spaces: if `s` is a `Finset` and
`∑ i ∈ s, μ (t i) > μ univ`, then one of the intersections `t i ∩ t j` is not empty. -/
theorem exists_nonempty_inter_of_measure_univ_lt_sum_measure {m : MeasurableSpace α} (μ : Measure α)
    {s : Finset ι} {t : ι → Set α} (h : ∀ i ∈ s, NullMeasurableSet (t i) μ)
    (H : μ (univ : Set α) < ∑ i ∈ s, μ (t i)) :
    ∃ i ∈ s, ∃ j ∈ s, ∃ _h : i ≠ j, (t i ∩ t j).Nonempty 
goal: ∃ i ∈ s, ∃ j ∈ s, ∃ (_ : i ≠ j), (t i ∩ t j).Nonempty

full_name: MeasureTheory.nonempty_inter_of_measure_lt_add
code: /-- If two sets `s` and `t` are included in a set `u`, and `μ s + μ t > μ u`,
then `s` intersects `t`. Version assuming that `t` is measurable. -/
theorem nonempty_inter_of_measure_lt_add {m : MeasurableSpace α} (μ : Measure α) {s t u : Set α}
    (ht : MeasurableSet t) (h's : s ⊆ u) (h't : t ⊆ u) (h : μ u < μ s + μ t) :
    (s ∩ t).Nonempty 
goal: (s ∩ t).Nonempty

full_name: MeasureTheory.nonempty_inter_of_measure_lt_add'
code: /-- If two sets `s` and `t` are included in a set `u`, and `μ s + μ t > μ u`,
then `s` intersects `t`. Version assuming that `s` is measurable. -/
theorem nonempty_inter_of_measure_lt_add' {m : MeasurableSpace α} (μ : Measure α) {s t u : Set α}
    (hs : MeasurableSet s) (h's : s ⊆ u) (h't : t ⊆ u) (h : μ u < μ s + μ t) :
    (s ∩ t).Nonempty 
goal: (s ∩ t).Nonempty

full_name: MeasureTheory.measure_iUnion_eq_iSup
code: /-- Continuity from below: the measure of the union of a directed sequence of (not necessarily
-measurable) sets is the supremum of the measures. -/
theorem measure_iUnion_eq_iSup [Countable ι] {s : ι → Set α} (hd : Directed (· ⊆ ·) s) :
    μ (⋃ i, s i) = ⨆ i, μ (s i) 
goal: μ (⋃ i, s i) = ⨆ i, μ (s i)

full_name: MeasureTheory.measure_iUnion_eq_iSup'
code: /-- Continuity from below: the measure of the union of a sequence of
(not necessarily measurable) sets is the supremum of the measures of the partial unions. -/
theorem measure_iUnion_eq_iSup' {α ι : Type*} [MeasurableSpace α] {μ : Measure α}
    [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)]
    {f : ι → Set α} : μ (⋃ i, f i) = ⨆ i, μ (Accumulate f i) 
goal: μ (⋃ i, f i) = ⨆ i, μ (Set.Accumulate f i)

full_name: MeasureTheory.measure_biUnion_eq_iSup
code: theorem measure_biUnion_eq_iSup {s : ι → Set α} {t : Set ι} (ht : t.Countable)
    (hd : DirectedOn ((· ⊆ ·) on s) t) : μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i) 
goal: μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)

full_name: MeasureTheory.measure_iInter_eq_iInf
code: /-- Continuity from above: the measure of the intersection of a decreasing sequence of measurable
sets is the infimum of the measures. -/
theorem measure_iInter_eq_iInf [Countable ι] {s : ι → Set α} (h : ∀ i, MeasurableSet (s i))
    (hd : Directed (· ⊇ ·) s) (hfin : ∃ i, μ (s i) ≠ ∞) : μ (⋂ i, s i) = ⨅ i, μ (s i) 
goal: μ (⋂ i, s i) = ⨅ i, μ (s i)

full_name: MeasureTheory.measure_iInter_eq_iInf'
code: /-- Continuity from above: the measure of the intersection of a sequence of
measurable sets is the infimum of the measures of the partial intersections. -/
theorem measure_iInter_eq_iInf' {α ι : Type*} [MeasurableSpace α] {μ : Measure α}
    [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)]
    {f : ι → Set α} (h : ∀ i, MeasurableSet (f i)) (hfin : ∃ i, μ (f i) ≠ ∞) :
    μ (⋂ i, f i) = ⨅ i, μ (⋂ j ≤ i, f j) 
goal: μ (⋂ i, f i) = ⨅ i, μ (⋂ j, ⋂ (_ : j ≤ i), f j)

full_name: MeasureTheory.tendsto_measure_iUnion
code: /-- Continuity from below: the measure of the union of an increasing sequence of (not necessarily
measurable) sets is the limit of the measures. -/
theorem tendsto_measure_iUnion [Preorder ι] [IsDirected ι (· ≤ ·)] [Countable ι]
    {s : ι → Set α} (hm : Monotone s) : Tendsto (μ ∘ s) atTop (𝓝 (μ (⋃ n, s n))) 
goal: Filter.Tendsto (⇑μ ∘ s) Filter.atTop (nhds (μ (⋃ n, s n)))

full_name: MeasureTheory.tendsto_measure_iUnion'
code: /-- Continuity from below: the measure of the union of a sequence of (not necessarily measurable)
sets is the limit of the measures of the partial unions. -/
theorem tendsto_measure_iUnion' {α ι : Type*} [MeasurableSpace α] {μ : Measure α} [Countable ι]
    [Preorder ι] [IsDirected ι (· ≤ ·)] {f : ι → Set α} :
    Tendsto (fun i ↦ μ (Accumulate f i)) atTop (𝓝 (μ (⋃ i, f i))) 
goal: Filter.Tendsto (fun i => μ (Set.Accumulate f i)) Filter.atTop (nhds (μ (⋃ i, f i)))

full_name: MeasureTheory.tendsto_measure_iInter
code: /-- Continuity from above: the measure of the intersection of a decreasing sequence of measurable
sets is the limit of the measures. -/
theorem tendsto_measure_iInter [Countable ι] [Preorder ι] [IsDirected ι (· ≤ ·)] {s : ι → Set α}
    (hs : ∀ n, MeasurableSet (s n)) (hm : Antitone s) (hf : ∃ i, μ (s i) ≠ ∞) :
    Tendsto (μ ∘ s) atTop (𝓝 (μ (⋂ n, s n))) 
goal: Filter.Tendsto (⇑μ ∘ s) Filter.atTop (nhds (μ (⋂ n, s n)))

full_name: MeasureTheory.tendsto_measure_iInter'
code: /-- Continuity from above: the measure of the intersection of a sequence of measurable
sets such that one has finite measure is the limit of the measures of the partial intersections. -/
theorem tendsto_measure_iInter' {α ι : Type*} [MeasurableSpace α] {μ : Measure α} [Countable ι]
    [Preorder ι] [IsDirected ι (· ≤ ·)] {f : ι → Set α} (hm : ∀ i, MeasurableSet (f i))
    (hf : ∃ i, μ (f i) ≠ ∞) :
    Tendsto (fun i ↦ μ (⋂ j ∈ {j | j ≤ i}, f j)) atTop (𝓝 (μ (⋂ i, f i))) 
goal: Filter.Tendsto (fun i => μ (⋂ j ∈ {j | j ≤ i}, f j)) Filter.atTop (nhds (μ (⋂ i, f i)))

full_name: MeasureTheory.tendsto_measure_biInter_gt
code: /-- The measure of the intersection of a decreasing sequence of measurable
sets indexed by a linear order with first countable topology is the limit of the measures. -/
theorem tendsto_measure_biInter_gt {ι : Type*} [LinearOrder ι] [TopologicalSpace ι]
    [OrderTopology ι] [DenselyOrdered ι] [FirstCountableTopology ι] {s : ι → Set α}
    {a : ι} (hs : ∀ r > a, MeasurableSet (s r)) (hm : ∀ i j, a < i → i ≤ j → s i ⊆ s j)
    (hf : ∃ r > a, μ (s r) ≠ ∞) : Tendsto (μ ∘ s) (𝓝[Ioi a] a) (𝓝 (μ (⋂ r > a, s r))) 
goal: Filter.Tendsto (⇑μ ∘ s) (nhdsWithin a (Set.Ioi a)) (nhds (μ (⋂ r, ⋂ (_ : r > a), s r)))

full_name: MeasureTheory.measure_limsup_eq_zero
code: /-- One direction of the **Borel-Cantelli lemma** (sometimes called the "*first* Borel-Cantelli
lemma"): if (sᵢ) is a sequence of sets such that `∑ μ sᵢ` is finite, then the limit superior of the
`sᵢ` is a null set.

Note: for the *second* Borel-Cantelli lemma (applying to independent sets in a probability space),
see `ProbabilityTheory.measure_limsup_eq_one`. -/
theorem measure_limsup_eq_zero {s : ℕ → Set α} (hs : (∑' i, μ (s i)) ≠ ∞) :
    μ (limsup s atTop) = 0 
goal: μ (Filter.limsup s Filter.atTop) = 0

full_name: MeasureTheory.measure_liminf_eq_zero
code: theorem measure_liminf_eq_zero {s : ℕ → Set α} (h : (∑' i, μ (s i)) ≠ ∞) :
    μ (liminf s atTop) = 0 
goal: μ (Filter.liminf s Filter.atTop) = 0

full_name: MeasureTheory.limsup_ae_eq_of_forall_ae_eq
code: theorem limsup_ae_eq_of_forall_ae_eq (s : ℕ → Set α) {t : Set α}
    (h : ∀ n, s n =ᵐ[μ] t) : limsup (α := Set α) s atTop =ᵐ[μ] t 
goal: Filter.limsup s Filter.atTop =ᵐ[μ] t

full_name: MeasureTheory.liminf_ae_eq_of_forall_ae_eq
code: theorem liminf_ae_eq_of_forall_ae_eq (s : ℕ → Set α) {t : Set α}
    (h : ∀ n, s n =ᵐ[μ] t) : liminf (α := Set α) s atTop =ᵐ[μ] t 
goal: Filter.liminf s Filter.atTop =ᵐ[μ] t

full_name: MeasureTheory.measure_if
code: theorem measure_if {x : β} {t : Set β} {s : Set α} :
    μ (if x ∈ t then s else ∅) = indicator t (fun _ => μ s) x 
goal: μ (if x ∈ t then s else ∅) = t.indicator (fun x => μ s) x

full_name: MeasureTheory.OuterMeasure.toMeasure
code: /-- Obtain a measure by giving an outer measure where all sets in the σ-algebra are
  Carathéodory measurable. -/
def OuterMeasure.toMeasure (m : OuterMeasure α) (h : ms ≤ m.caratheodory) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.le_toOuterMeasure_caratheodory
code: theorem le_toOuterMeasure_caratheodory (μ : Measure α) : ms ≤ μ.toOuterMeasure.caratheodory 
goal: ms ≤ μ.caratheodory

full_name: MeasureTheory.toMeasure_toOuterMeasure
code: @[simp]
theorem toMeasure_toOuterMeasure (m : OuterMeasure α) (h : ms ≤ m.caratheodory) :
    (m.toMeasure h).toOuterMeasure = m.trim 
goal: (m.toMeasure h).toOuterMeasure = m.trim

full_name: MeasureTheory.toMeasure_apply
code: @[simp]
theorem toMeasure_apply (m : OuterMeasure α) (h : ms ≤ m.caratheodory) {s : Set α}
    (hs : MeasurableSet s) : m.toMeasure h s = m s 
goal: (m.toMeasure h) s = m s

full_name: MeasureTheory.le_toMeasure_apply
code: theorem le_toMeasure_apply (m : OuterMeasure α) (h : ms ≤ m.caratheodory) (s : Set α) :
    m s ≤ m.toMeasure h s 
goal: m s ≤ (m.toMeasure h) s

full_name: MeasureTheory.toMeasure_apply₀
code: theorem toMeasure_apply₀ (m : OuterMeasure α) (h : ms ≤ m.caratheodory) {s : Set α}
    (hs : NullMeasurableSet s (m.toMeasure h)) : m.toMeasure h s = m s 
goal: (m.toMeasure h) s = m s

full_name: MeasureTheory.toOuterMeasure_toMeasure
code: @[simp]
theorem toOuterMeasure_toMeasure {μ : Measure α} :
    μ.toOuterMeasure.toMeasure (le_toOuterMeasure_caratheodory _) = μ 
goal: μ.toMeasure ⋯ = μ

full_name: MeasureTheory.boundedBy_measure
code: @[simp]
theorem boundedBy_measure (μ : Measure α) : OuterMeasure.boundedBy μ = μ.toOuterMeasure 
goal: MeasureTheory.OuterMeasure.boundedBy ⇑μ = μ.toOuterMeasure

full_name: MeasureTheory.Measure.measure_inter_eq_of_measure_eq
code: /-- If `u` is a superset of `t` with the same (finite) measure (both sets possibly non-measurable),
then for any measurable set `s` one also has `μ (t ∩ s) = μ (u ∩ s)`. -/
theorem measure_inter_eq_of_measure_eq {s t u : Set α} (hs : MeasurableSet s) (h : μ t = μ u)
    (htu : t ⊆ u) (ht_ne_top : μ t ≠ ∞) : μ (t ∩ s) = μ (u ∩ s) 
goal: μ (t ∩ s) = μ (u ∩ s)

full_name: MeasureTheory.Measure.measure_toMeasurable_inter
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) = μ (u ∩ s)`.
Here, we require that the measure of `t` is finite. The conclusion holds without this assumption
when the measure is s-finite (for example when it is σ-finite),
see `measure_toMeasurable_inter_of_sFinite`. -/
theorem measure_toMeasurable_inter {s t : Set α} (hs : MeasurableSet s) (ht : μ t ≠ ∞) :
    μ (toMeasurable μ t ∩ s) = μ (t ∩ s) 
goal: μ (MeasureTheory.toMeasurable μ t ∩ s) = μ (t ∩ s)

full_name: MeasureTheory.Measure.instZero
code: instance instZero [MeasurableSpace α] : Zero (Measure α) 
goal: Zero (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.zero_toOuterMeasure
code: @[simp]
theorem zero_toOuterMeasure {_m : MeasurableSpace α} : (0 : Measure α).toOuterMeasure = 0 
goal: MeasureTheory.Measure.toOuterMeasure 0 = 0

full_name: MeasureTheory.Measure.coe_zero
code: @[simp, norm_cast]
theorem coe_zero {_m : MeasurableSpace α} : ⇑(0 : Measure α) = 0 
goal: ⇑0 = 0

full_name: MeasureTheory.Measure.apply_eq_zero_of_isEmpty
code: @[nontriviality]
lemma apply_eq_zero_of_isEmpty [IsEmpty α] {_ : MeasurableSpace α} (μ : Measure α) (s : Set α) :
    μ s = 0 
goal: ∀ {x : MeasurableSpace α} (μ : MeasureTheory.Measure α) (s : Set α), μ s = 0

full_name: MeasureTheory.Measure.instSubsingleton
code: instance instSubsingleton [IsEmpty α] {m : MeasurableSpace α} : Subsingleton (Measure α) 
goal: Subsingleton (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.eq_zero_of_isEmpty
code: theorem eq_zero_of_isEmpty [IsEmpty α] {_m : MeasurableSpace α} (μ : Measure α) : μ = 0 
goal: μ = 0

full_name: MeasureTheory.Measure.instInhabited
code: instance instInhabited [MeasurableSpace α] : Inhabited (Measure α) 
goal: Inhabited (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instAdd
code: instance instAdd [MeasurableSpace α] : Add (Measure α) 
goal: Add (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.add_toOuterMeasure
code: @[simp]
theorem add_toOuterMeasure {_m : MeasurableSpace α} (μ₁ μ₂ : Measure α) :
    (μ₁ + μ₂).toOuterMeasure = μ₁.toOuterMeasure + μ₂.toOuterMeasure 
goal: (μ₁ + μ₂).toOuterMeasure = μ₁.toOuterMeasure + μ₂.toOuterMeasure

full_name: MeasureTheory.Measure.coe_add
code: @[simp, norm_cast]
theorem coe_add {_m : MeasurableSpace α} (μ₁ μ₂ : Measure α) : ⇑(μ₁ + μ₂) = μ₁ + μ₂ 
goal: ⇑(μ₁ + μ₂) = ⇑μ₁ + ⇑μ₂

full_name: MeasureTheory.Measure.add_apply
code: theorem add_apply {_m : MeasurableSpace α} (μ₁ μ₂ : Measure α) (s : Set α) :
    (μ₁ + μ₂) s = μ₁ s + μ₂ s 
goal: (μ₁ + μ₂) s = μ₁ s + μ₂ s

full_name: MeasureTheory.Measure.instSMul
code: instance instSMul [MeasurableSpace α] : SMul R (Measure α) 
goal: SMul R (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.smul_toOuterMeasure
code: @[simp]
theorem smul_toOuterMeasure {_m : MeasurableSpace α} (c : R) (μ : Measure α) :
    (c • μ).toOuterMeasure = c • μ.toOuterMeasure 
goal: (c • μ).toOuterMeasure = c • μ.toOuterMeasure

full_name: MeasureTheory.Measure.coe_smul
code: @[simp, norm_cast]
theorem coe_smul {_m : MeasurableSpace α} (c : R) (μ : Measure α) : ⇑(c • μ) = c • ⇑μ 
goal: ⇑(c • μ) = c • ⇑μ

full_name: MeasureTheory.Measure.smul_apply
code: @[simp]
theorem smul_apply {_m : MeasurableSpace α} (c : R) (μ : Measure α) (s : Set α) :
    (c • μ) s = c • μ s 
goal: (c • μ) s = c • μ s

full_name: MeasureTheory.Measure.instSMulCommClass
code: instance instSMulCommClass [SMulCommClass R R' ℝ≥0∞] [MeasurableSpace α] :
    SMulCommClass R R' (Measure α) 
goal: SMulCommClass R R' (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instIsScalarTower
code: instance instIsScalarTower [SMul R R'] [IsScalarTower R R' ℝ≥0∞] [MeasurableSpace α] :
    IsScalarTower R R' (Measure α) 
goal: IsScalarTower R R' (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instIsCentralScalar
code: instance instIsCentralScalar [SMul Rᵐᵒᵖ ℝ≥0∞] [IsCentralScalar R ℝ≥0∞] [MeasurableSpace α] :
    IsCentralScalar R (Measure α) 
goal: IsCentralScalar R (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instNoZeroSMulDivisors
code: instance instNoZeroSMulDivisors [Zero R] [SMulWithZero R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [NoZeroSMulDivisors R ℝ≥0∞] : NoZeroSMulDivisors R (Measure α) 
goal: NoZeroSMulDivisors R (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instMulAction
code: instance instMulAction [Monoid R] [MulAction R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [MeasurableSpace α] : MulAction R (Measure α) 
goal: MulAction R (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instAddCommMonoid
code: instance instAddCommMonoid [MeasurableSpace α] : AddCommMonoid (Measure α) 
goal: AddCommMonoid (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.coeAddHom
code: /-- Coercion to function as an additive monoid homomorphism. -/
def coeAddHom {_ : MeasurableSpace α} : Measure α →+ Set α → ℝ≥0∞ 
goal: {x : MeasurableSpace α} → MeasureTheory.Measure α →+ Set α → ENNReal

full_name: MeasureTheory.Measure.coe_finset_sum
code: @[simp]
theorem coe_finset_sum {_m : MeasurableSpace α} (I : Finset ι) (μ : ι → Measure α) :
    ⇑(∑ i ∈ I, μ i) = ∑ i ∈ I, ⇑(μ i) 
goal: ⇑(∑ i ∈ I, μ i) = ∑ i ∈ I, ⇑(μ i)

full_name: MeasureTheory.Measure.finset_sum_apply
code: theorem finset_sum_apply {m : MeasurableSpace α} (I : Finset ι) (μ : ι → Measure α) (s : Set α) :
    (∑ i ∈ I, μ i) s = ∑ i ∈ I, μ i s 
goal: (∑ i ∈ I, μ i) s = ∑ i ∈ I, (μ i) s

full_name: MeasureTheory.Measure.instDistribMulAction
code: instance instDistribMulAction [Monoid R] [DistribMulAction R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [MeasurableSpace α] : DistribMulAction R (Measure α) 
goal: DistribMulAction R (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instModule
code: instance instModule [Semiring R] [Module R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] [MeasurableSpace α] :
    Module R (Measure α) 
goal: Module R (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.coe_nnreal_smul_apply
code: @[simp]
theorem coe_nnreal_smul_apply {_m : MeasurableSpace α} (c : ℝ≥0) (μ : Measure α) (s : Set α) :
    (c • μ) s = c * μ s 
goal: (c • μ) s = ↑c * μ s

full_name: MeasureTheory.Measure.nnreal_smul_coe_apply
code: @[simp]
theorem nnreal_smul_coe_apply {_m : MeasurableSpace α} (c : ℝ≥0) (μ : Measure α) (s : Set α) :
    c • μ s = c * μ s 
goal: c • μ s = ↑c * μ s

full_name: MeasureTheory.Measure.ae_smul_measure_iff
code: theorem ae_smul_measure_iff {p : α → Prop} {c : ℝ≥0∞} (hc : c ≠ 0) :
    (∀ᵐ x ∂c • μ, p x) ↔ ∀ᵐ x ∂μ, p x 
goal: (∀ᵐ (x : α) ∂c • μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p x

full_name: MeasureTheory.Measure.ae_smul_measure_eq
code: @[simp]
theorem ae_smul_measure_eq {c : ℝ≥0∞} (hc : c ≠ 0) : ae (c • μ) = ae μ 
goal: MeasureTheory.ae (c • μ) = MeasureTheory.ae μ

full_name: MeasureTheory.Measure.measure_eq_left_of_subset_of_measure_add_eq
code: theorem measure_eq_left_of_subset_of_measure_add_eq {s t : Set α} (h : (μ + ν) t ≠ ∞) (h' : s ⊆ t)
    (h'' : (μ + ν) s = (μ + ν) t) : μ s = μ t 
goal: μ s = μ t

full_name: MeasureTheory.Measure.measure_eq_right_of_subset_of_measure_add_eq
code: theorem measure_eq_right_of_subset_of_measure_add_eq {s t : Set α} (h : (μ + ν) t ≠ ∞) (h' : s ⊆ t)
    (h'' : (μ + ν) s = (μ + ν) t) : ν s = ν t 
goal: ν s = ν t

full_name: MeasureTheory.Measure.measure_toMeasurable_add_inter_left
code: theorem measure_toMeasurable_add_inter_left {s t : Set α} (hs : MeasurableSet s)
    (ht : (μ + ν) t ≠ ∞) : μ (toMeasurable (μ + ν) t ∩ s) = μ (t ∩ s) 
goal: μ (MeasureTheory.toMeasurable (μ + ν) t ∩ s) = μ (t ∩ s)

full_name: MeasureTheory.Measure.measure_toMeasurable_add_inter_right
code: theorem measure_toMeasurable_add_inter_right {s t : Set α} (hs : MeasurableSet s)
    (ht : (μ + ν) t ≠ ∞) : ν (toMeasurable (μ + ν) t ∩ s) = ν (t ∩ s) 
goal: ν (MeasureTheory.toMeasurable (μ + ν) t ∩ s) = ν (t ∩ s)

full_name: MeasureTheory.Measure.instPartialOrder
code: /-- Measures are partially ordered. -/
instance instPartialOrder [MeasurableSpace α] : PartialOrder (Measure α) 
goal: PartialOrder (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.toOuterMeasure_le
code: theorem toOuterMeasure_le : μ₁.toOuterMeasure ≤ μ₂.toOuterMeasure ↔ μ₁ ≤ μ₂ 
goal: μ₁.toOuterMeasure ≤ μ₂.toOuterMeasure ↔ μ₁ ≤ μ₂

full_name: MeasureTheory.Measure.le_iff
code: theorem le_iff : μ₁ ≤ μ₂ ↔ ∀ s, MeasurableSet s → μ₁ s ≤ μ₂ s 
goal: μ₁ ≤ μ₂ ↔ ∀ (s : Set α), MeasurableSet s → μ₁ s ≤ μ₂ s

full_name: MeasureTheory.Measure.le_intro
code: theorem le_intro (h : ∀ s, MeasurableSet s → s.Nonempty → μ₁ s ≤ μ₂ s) : μ₁ ≤ μ₂ 
goal: μ₁ ≤ μ₂

full_name: MeasureTheory.Measure.le_iff'
code: theorem le_iff' : μ₁ ≤ μ₂ ↔ ∀ s, μ₁ s ≤ μ₂ s 
goal: μ₁ ≤ μ₂ ↔ ∀ (s : Set α), μ₁ s ≤ μ₂ s

full_name: MeasureTheory.Measure.lt_iff
code: theorem lt_iff : μ < ν ↔ μ ≤ ν ∧ ∃ s, MeasurableSet s ∧ μ s < ν s 
goal: μ < ν ↔ μ ≤ ν ∧ ∃ s, MeasurableSet s ∧ μ s < ν s

full_name: MeasureTheory.Measure.lt_iff'
code: theorem lt_iff' : μ < ν ↔ μ ≤ ν ∧ ∃ s, μ s < ν s 
goal: μ < ν ↔ μ ≤ ν ∧ ∃ s, μ s < ν s

full_name: MeasureTheory.Measure.covariantAddLE
code: instance covariantAddLE [MeasurableSpace α] :
    CovariantClass (Measure α) (Measure α) (· + ·) (· ≤ ·) 
goal: CovariantClass (MeasureTheory.Measure α) (MeasureTheory.Measure α) (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1

full_name: MeasureTheory.Measure.le_add_left
code: protected theorem le_add_left (h : μ ≤ ν) : μ ≤ ν' + ν 
goal: μ ≤ ν' + ν

full_name: MeasureTheory.Measure.le_add_right
code: protected theorem le_add_right (h : μ ≤ ν) : μ ≤ ν + ν' 
goal: μ ≤ ν + ν'

full_name: MeasureTheory.Measure.sInf_caratheodory
code: theorem sInf_caratheodory (s : Set α) (hs : MeasurableSet s) :
    MeasurableSet[(sInf (toOuterMeasure '' m)).caratheodory] s 
goal: MeasurableSet s

full_name: MeasureTheory.Measure.instInfSet
code: instance [MeasurableSpace α] : InfSet (Measure α) 
goal: InfSet (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.sInf_apply
code: theorem sInf_apply (hs : MeasurableSet s) : sInf m s = sInf (toOuterMeasure '' m) s 
goal: (sInf m) s = (sInf (MeasureTheory.Measure.toOuterMeasure '' m)) s

full_name: _private.Mathlib.MeasureTheory.Measure.MeasureSpace.0.MeasureTheory.Measure.measure_sInf_le
code: private theorem measure_sInf_le (h : μ ∈ m) : sInf m ≤ μ 
goal: sInf m ≤ μ

full_name: _private.Mathlib.MeasureTheory.Measure.MeasureSpace.0.MeasureTheory.Measure.measure_le_sInf
code: private theorem measure_le_sInf (h : ∀ μ' ∈ m, μ ≤ μ') : μ ≤ sInf m 
goal: μ ≤ sInf m

full_name: MeasureTheory.Measure.instCompleteSemilatticeInf
code: instance instCompleteSemilatticeInf [MeasurableSpace α] : CompleteSemilatticeInf (Measure α) 
goal: CompleteSemilatticeInf (MeasureTheory.Measure α)

full_name: MeasureTheory.Measure.instCompleteLattice
code: instance instCompleteLattice [MeasurableSpace α] : CompleteLattice (Measure α) 
goal: CompleteLattice (MeasureTheory.Measure α)

full_name: MeasureTheory.OuterMeasure.toMeasure_top
code: @[simp]
theorem _root_.MeasureTheory.OuterMeasure.toMeasure_top :
    (⊤ : OuterMeasure α).toMeasure (by rw [OuterMeasure.top_caratheodory]; exact le_top) =
      (⊤ : Measure α) 
goal: ⊤.toMeasure ⋯ = ⊤

full_name: MeasureTheory.Measure.toOuterMeasure_top
code: @[simp]
theorem toOuterMeasure_top [MeasurableSpace α] :
    (⊤ : Measure α).toOuterMeasure = (⊤ : OuterMeasure α) 
goal: ⊤.toOuterMeasure = ⊤

full_name: MeasureTheory.Measure.top_add
code: @[simp]
theorem top_add : ⊤ + μ = ⊤ 
goal: ⊤ + μ = ⊤

full_name: MeasureTheory.Measure.add_top
code: @[simp]
theorem add_top : μ + ⊤ = ⊤ 
goal: μ + ⊤ = ⊤

full_name: MeasureTheory.Measure.zero_le
code: protected theorem zero_le {_m0 : MeasurableSpace α} (μ : Measure α) : 0 ≤ μ 
goal: 0 ≤ μ

full_name: MeasureTheory.Measure.nonpos_iff_eq_zero'
code: theorem nonpos_iff_eq_zero' : μ ≤ 0 ↔ μ = 0 
goal: μ ≤ 0 ↔ μ = 0

full_name: MeasureTheory.Measure.measure_univ_eq_zero
code: @[simp]
theorem measure_univ_eq_zero : μ univ = 0 ↔ μ = 0 
goal: μ Set.univ = 0 ↔ μ = 0

full_name: MeasureTheory.Measure.measure_univ_ne_zero
code: theorem measure_univ_ne_zero : μ univ ≠ 0 ↔ μ ≠ 0 
goal: μ Set.univ ≠ 0 ↔ μ ≠ 0

full_name: MeasureTheory.Measure.instNeZeroENNRealCoeSetUniv
code: instance [NeZero μ] : NeZero (μ univ) 
goal: NeZero (μ Set.univ)

full_name: MeasureTheory.Measure.measure_univ_pos
code: @[simp]
theorem measure_univ_pos : 0 < μ univ ↔ μ ≠ 0 
goal: 0 < μ Set.univ ↔ μ ≠ 0

full_name: MeasureTheory.Measure.liftLinear
code: /-- Lift a linear map between `OuterMeasure` spaces such that for each measure `μ` every measurable
set is caratheodory-measurable w.r.t. `f μ` to a linear map between `Measure` spaces. -/
def liftLinear {m0 : MeasurableSpace α} (f : OuterMeasure α →ₗ[ℝ≥0∞] OuterMeasure β)
    (hf : ∀ μ : Measure α, ‹_› ≤ (f μ.toOuterMeasure).caratheodory) :
    Measure α →ₗ[ℝ≥0∞] Measure β 
goal: MeasureTheory.Measure α →ₗ[ENNReal] MeasureTheory.Measure β

full_name: MeasureTheory.Measure.liftLinear_apply₀
code: lemma liftLinear_apply₀ {f : OuterMeasure α →ₗ[ℝ≥0∞] OuterMeasure β} (hf) {s : Set β}
    (hs : NullMeasurableSet s (liftLinear f hf μ)) : liftLinear f hf μ s = f μ.toOuterMeasure s 
goal: ((MeasureTheory.Measure.liftLinear f hf) μ) s = (f μ.toOuterMeasure) s

full_name: MeasureTheory.Measure.liftLinear_apply
code: @[simp]
theorem liftLinear_apply {f : OuterMeasure α →ₗ[ℝ≥0∞] OuterMeasure β} (hf) {s : Set β}
    (hs : MeasurableSet s) : liftLinear f hf μ s = f μ.toOuterMeasure s 
goal: ((MeasureTheory.Measure.liftLinear f hf) μ) s = (f μ.toOuterMeasure) s

full_name: MeasureTheory.Measure.le_liftLinear_apply
code: theorem le_liftLinear_apply {f : OuterMeasure α →ₗ[ℝ≥0∞] OuterMeasure β} (hf) (s : Set β) :
    f μ.toOuterMeasure s ≤ liftLinear f hf μ s 
goal: (f μ.toOuterMeasure) s ≤ ((MeasureTheory.Measure.liftLinear f hf) μ) s

full_name: MeasureTheory.Measure.mapₗ
code: /-- The pushforward of a measure as a linear map. It is defined to be `0` if `f` is not
a measurable function. -/
def mapₗ [MeasurableSpace α] (f : α → β) : Measure α →ₗ[ℝ≥0∞] Measure β 
goal: MeasureTheory.Measure α →ₗ[ENNReal] MeasureTheory.Measure β

full_name: MeasureTheory.Measure.mapₗ_congr
code: theorem mapₗ_congr {f g : α → β} (hf : Measurable f) (hg : Measurable g) (h : f =ᵐ[μ] g) :
    mapₗ f μ = mapₗ g μ 
goal: (MeasureTheory.Measure.mapₗ f) μ = (MeasureTheory.Measure.mapₗ g) μ

full_name: MeasureTheory.Measure.map_def
code: /-- The pushforward of a measure. It is defined to be `0` if `f` is not an almost everywhere
measurable function. -/
irreducible_def map [MeasurableSpace α] (f : α → β) (μ : Measure α) : Measure β 
goal: MeasureTheory.Measure.map f μ =
  if hf : AEMeasurable f μ then (MeasureTheory.Measure.mapₗ (AEMeasurable.mk f hf)) μ else 0

full_name: MeasureTheory.Measure.definition._@.Mathlib.MeasureTheory.Measure.MeasureSpace._hyg.20076
code: /-- The pushforward of a measure. It is defined to be `0` if `f` is not an almost everywhere
measurable function. -/
irreducible_def map [MeasurableSpace α] (f : α → β) (μ : Measure α) : Measure β 
goal: MeasureTheory.Measure β

full_name: MeasureTheory.Measure.map
code: /-- The pushforward of a measure. It is defined to be `0` if `f` is not an almost everywhere
measurable function. -/
irreducible_def map [MeasurableSpace α] (f : α → β) (μ : Measure α) : Measure β 
goal: MeasureTheory.Measure β

full_name: MeasureTheory.Measure.wrapped._@.Mathlib.MeasureTheory.Measure.MeasureSpace._hyg.20076
code: /-- The pushforward of a measure. It is defined to be `0` if `f` is not an almost everywhere
measurable function. -/
irreducible_def map [MeasurableSpace α] (f : α → β) (μ : Measure α) : Measure β 
goal: Subtype (Eq @MeasureTheory.Measure.definition✝)

full_name: MeasureTheory.Measure.mapₗ_mk_apply_of_aemeasurable
code: theorem mapₗ_mk_apply_of_aemeasurable {f : α → β} (hf : AEMeasurable f μ) :
    mapₗ (hf.mk f) μ = map f μ 
goal: (MeasureTheory.Measure.mapₗ (AEMeasurable.mk f hf)) μ = MeasureTheory.Measure.map f μ

full_name: MeasureTheory.Measure.mapₗ_apply_of_measurable
code: theorem mapₗ_apply_of_measurable {f : α → β} (hf : Measurable f) (μ : Measure α) :
    mapₗ f μ = map f μ 
goal: (MeasureTheory.Measure.mapₗ f) μ = MeasureTheory.Measure.map f μ

full_name: MeasureTheory.Measure.map_add
code: @[simp]
theorem map_add (μ ν : Measure α) {f : α → β} (hf : Measurable f) :
    (μ + ν).map f = μ.map f + ν.map f 
goal: MeasureTheory.Measure.map f (μ + ν) = MeasureTheory.Measure.map f μ + MeasureTheory.Measure.map f ν

full_name: MeasureTheory.Measure.map_zero
code: @[simp]
theorem map_zero (f : α → β) : (0 : Measure α).map f = 0 
goal: MeasureTheory.Measure.map f 0 = 0

full_name: MeasureTheory.Measure.map_of_not_aemeasurable
code: @[simp]
theorem map_of_not_aemeasurable {f : α → β} {μ : Measure α} (hf : ¬AEMeasurable f μ) :
    μ.map f = 0 
goal: MeasureTheory.Measure.map f μ = 0

full_name: MeasureTheory.Measure.map_congr
code: theorem map_congr {f g : α → β} (h : f =ᵐ[μ] g) : Measure.map f μ = Measure.map g μ 
goal: MeasureTheory.Measure.map f μ = MeasureTheory.Measure.map g μ

full_name: MeasureTheory.Measure.map_smul
code: @[simp]
protected theorem map_smul (c : ℝ≥0∞) (μ : Measure α) (f : α → β) :
    (c • μ).map f = c • μ.map f 
goal: MeasureTheory.Measure.map f (c • μ) = c • MeasureTheory.Measure.map f μ

full_name: MeasureTheory.Measure.map_smul_nnreal
code: @[simp]
protected theorem map_smul_nnreal (c : ℝ≥0) (μ : Measure α) (f : α → β) :
    (c • μ).map f = c • μ.map f 
goal: MeasureTheory.Measure.map f (c • μ) = c • MeasureTheory.Measure.map f μ

full_name: MeasureTheory.Measure.map_apply₀
code: lemma map_apply₀ {f : α → β} (hf : AEMeasurable f μ) {s : Set β}
    (hs : NullMeasurableSet s (map f μ)) : μ.map f s = μ (f ⁻¹' s) 
goal: (MeasureTheory.Measure.map f μ) s = μ (f ⁻¹' s)

full_name: MeasureTheory.Measure.map_apply_of_aemeasurable
code: /-- We can evaluate the pushforward on measurable sets. For non-measurable sets, see
  `MeasureTheory.Measure.le_map_apply` and `MeasurableEquiv.map_apply`. -/
@[simp]
theorem map_apply_of_aemeasurable (hf : AEMeasurable f μ) {s : Set β} (hs : MeasurableSet s) :
    μ.map f s = μ (f ⁻¹' s) 
goal: (MeasureTheory.Measure.map f μ) s = μ (f ⁻¹' s)

full_name: MeasureTheory.Measure.map_apply
code: @[simp]
theorem map_apply (hf : Measurable f) {s : Set β} (hs : MeasurableSet s) :
    μ.map f s = μ (f ⁻¹' s) 
goal: (MeasureTheory.Measure.map f μ) s = μ (f ⁻¹' s)

full_name: MeasureTheory.Measure.map_toOuterMeasure
code: theorem map_toOuterMeasure (hf : AEMeasurable f μ) :
    (μ.map f).toOuterMeasure = (OuterMeasure.map f μ.toOuterMeasure).trim 
goal: (MeasureTheory.Measure.map f μ).toOuterMeasure = ((MeasureTheory.OuterMeasure.map f) μ.toOuterMeasure).trim

full_name: MeasureTheory.Measure.map_eq_zero_iff
code: @[simp] lemma map_eq_zero_iff (hf : AEMeasurable f μ) : μ.map f = 0 ↔ μ = 0 
goal: MeasureTheory.Measure.map f μ = 0 ↔ μ = 0

full_name: MeasureTheory.Measure.mapₗ_eq_zero_iff
code: @[simp] lemma mapₗ_eq_zero_iff (hf : Measurable f) : Measure.mapₗ f μ = 0 ↔ μ = 0 
goal: (MeasureTheory.Measure.mapₗ f) μ = 0 ↔ μ = 0

full_name: MeasureTheory.Measure.measure_preimage_of_map_eq_self
code: /-- If `map f μ = μ`, then the measure of the preimage of any null measurable set `s`
is equal to the measure of `s`.
Note that this lemma does not assume (a.e.) measurability of `f`. -/
lemma measure_preimage_of_map_eq_self {f : α → α} (hf : map f μ = μ)
    {s : Set α} (hs : NullMeasurableSet s μ) : μ (f ⁻¹' s) = μ s 
goal: μ (f ⁻¹' s) = μ s

full_name: MeasureTheory.Measure.map_ne_zero_iff
code: lemma map_ne_zero_iff (hf : AEMeasurable f μ) : μ.map f ≠ 0 ↔ μ ≠ 0 
goal: MeasureTheory.Measure.map f μ ≠ 0 ↔ μ ≠ 0

full_name: MeasureTheory.Measure.mapₗ_ne_zero_iff
code: lemma mapₗ_ne_zero_iff (hf : Measurable f) : Measure.mapₗ f μ ≠ 0 ↔ μ ≠ 0 
goal: (MeasureTheory.Measure.mapₗ f) μ ≠ 0 ↔ μ ≠ 0

full_name: MeasureTheory.Measure.map_id
code: @[simp]
theorem map_id : map id μ = μ 
goal: MeasureTheory.Measure.map id μ = μ

full_name: MeasureTheory.Measure.map_id'
code: @[simp]
theorem map_id' : map (fun x => x) μ = μ 
goal: MeasureTheory.Measure.map (fun x => x) μ = μ

full_name: MeasureTheory.Measure.map_map
code: theorem map_map {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
    (μ.map f).map g = μ.map (g ∘ f) 
goal: MeasureTheory.Measure.map g (MeasureTheory.Measure.map f μ) = MeasureTheory.Measure.map (g ∘ f) μ

full_name: MeasureTheory.Measure.map_mono
code: @[mono]
theorem map_mono {f : α → β} (h : μ ≤ ν) (hf : Measurable f) : μ.map f ≤ ν.map f 
goal: MeasureTheory.Measure.map f μ ≤ MeasureTheory.Measure.map f ν

full_name: MeasureTheory.Measure.le_map_apply
code: /-- Even if `s` is not measurable, we can bound `map f μ s` from below.
  See also `MeasurableEquiv.map_apply`. -/
theorem le_map_apply {f : α → β} (hf : AEMeasurable f μ) (s : Set β) : μ (f ⁻¹' s) ≤ μ.map f s 
goal: μ (f ⁻¹' s) ≤ (MeasureTheory.Measure.map f μ) s

full_name: MeasureTheory.Measure.le_map_apply_image
code: theorem le_map_apply_image {f : α → β} (hf : AEMeasurable f μ) (s : Set α) :
    μ s ≤ μ.map f (f '' s) 
goal: μ s ≤ (MeasureTheory.Measure.map f μ) (f '' s)

full_name: MeasureTheory.Measure.preimage_null_of_map_null
code: /-- Even if `s` is not measurable, `map f μ s = 0` implies that `μ (f ⁻¹' s) = 0`. -/
theorem preimage_null_of_map_null {f : α → β} (hf : AEMeasurable f μ) {s : Set β}
    (hs : μ.map f s = 0) : μ (f ⁻¹' s) = 0 
goal: μ (f ⁻¹' s) = 0

full_name: MeasureTheory.Measure.tendsto_ae_map
code: theorem tendsto_ae_map {f : α → β} (hf : AEMeasurable f μ) : Tendsto f (ae μ) (ae (μ.map f)) 
goal: Filter.Tendsto f (MeasureTheory.ae μ) (MeasureTheory.ae (MeasureTheory.Measure.map f μ))

full_name: MeasureTheory.Measure.comapₗ
code: /-- Pullback of a `Measure` as a linear map. If `f` sends each measurable set to a measurable
set, then for each measurable set `s` we have `comapₗ f μ s = μ (f '' s)`.

Note that if `f` is not injective, this definition assigns `Set.univ` measure zero.

If the linearity is not needed, please use `comap` instead, which works for a larger class of
functions. `comapₗ` is an auxiliary definition and most lemmas deal with comap. -/
def comapₗ [MeasurableSpace α] (f : α → β) : Measure β →ₗ[ℝ≥0∞] Measure α 
goal: MeasureTheory.Measure β →ₗ[ENNReal] MeasureTheory.Measure α

full_name: MeasureTheory.Measure.comapₗ_apply
code: theorem comapₗ_apply {β} [MeasurableSpace α] {mβ : MeasurableSpace β} (f : α → β)
    (hfi : Injective f) (hf : ∀ s, MeasurableSet s → MeasurableSet (f '' s)) (μ : Measure β)
    (hs : MeasurableSet s) : comapₗ f μ s = μ (f '' s) 
goal: ((MeasureTheory.Measure.comapₗ f) μ) s = μ (f '' s)

full_name: MeasureTheory.Measure.comap
code: /-- Pullback of a `Measure`. If `f` sends each measurable set to a null-measurable set,
then for each measurable set `s` we have `comap f μ s = μ (f '' s)`.

Note that if `f` is not injective, this definition assigns `Set.univ` measure zero. -/
def comap [MeasurableSpace α] (f : α → β) (μ : Measure β) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.comap_apply₀
code: theorem comap_apply₀ [MeasurableSpace α] (f : α → β) (μ : Measure β) (hfi : Injective f)
    (hf : ∀ s, MeasurableSet s → NullMeasurableSet (f '' s) μ)
    (hs : NullMeasurableSet s (comap f μ)) : comap f μ s = μ (f '' s) 
goal: (MeasureTheory.Measure.comap f μ) s = μ (f '' s)

full_name: MeasureTheory.Measure.le_comap_apply
code: theorem le_comap_apply {β} [MeasurableSpace α] {mβ : MeasurableSpace β} (f : α → β) (μ : Measure β)
    (hfi : Injective f) (hf : ∀ s, MeasurableSet s → NullMeasurableSet (f '' s) μ) (s : Set α) :
    μ (f '' s) ≤ comap f μ s 
goal: μ (f '' s) ≤ (MeasureTheory.Measure.comap f μ) s

full_name: MeasureTheory.Measure.comap_apply
code: theorem comap_apply {β} [MeasurableSpace α] {_mβ : MeasurableSpace β} (f : α → β)
    (hfi : Injective f) (hf : ∀ s, MeasurableSet s → MeasurableSet (f '' s)) (μ : Measure β)
    (hs : MeasurableSet s) : comap f μ s = μ (f '' s) 
goal: (MeasureTheory.Measure.comap f μ) s = μ (f '' s)

full_name: MeasureTheory.Measure.comapₗ_eq_comap
code: theorem comapₗ_eq_comap {β} [MeasurableSpace α] {_mβ : MeasurableSpace β} (f : α → β)
    (hfi : Injective f) (hf : ∀ s, MeasurableSet s → MeasurableSet (f '' s)) (μ : Measure β)
    (hs : MeasurableSet s) : comapₗ f μ s = comap f μ s 
goal: ((MeasureTheory.Measure.comapₗ f) μ) s = (MeasureTheory.Measure.comap f μ) s

full_name: MeasureTheory.Measure.measure_image_eq_zero_of_comap_eq_zero
code: theorem measure_image_eq_zero_of_comap_eq_zero {β} [MeasurableSpace α] {_mβ : MeasurableSpace β}
    (f : α → β) (μ : Measure β) (hfi : Injective f)
    (hf : ∀ s, MeasurableSet s → NullMeasurableSet (f '' s) μ) {s : Set α} (hs : comap f μ s = 0) :
    μ (f '' s) = 0 
goal: μ (f '' s) = 0

full_name: MeasureTheory.Measure.ae_eq_image_of_ae_eq_comap
code: theorem ae_eq_image_of_ae_eq_comap {β} [MeasurableSpace α] {mβ : MeasurableSpace β} (f : α → β)
    (μ : Measure β) (hfi : Injective f) (hf : ∀ s, MeasurableSet s → NullMeasurableSet (f '' s) μ)
    {s t : Set α} (hst : s =ᵐ[comap f μ] t) : f '' s =ᵐ[μ] f '' t 
goal: f '' s =ᵐ[μ] f '' t

full_name: MeasureTheory.Measure.NullMeasurableSet.image
code: theorem NullMeasurableSet.image {β} [MeasurableSpace α] {mβ : MeasurableSpace β} (f : α → β)
    (μ : Measure β) (hfi : Injective f) (hf : ∀ s, MeasurableSet s → NullMeasurableSet (f '' s) μ)
    {s : Set α} (hs : NullMeasurableSet s (μ.comap f)) : NullMeasurableSet (f '' s) μ 
goal: MeasureTheory.NullMeasurableSet (f '' s) μ

full_name: MeasureTheory.Measure.comap_preimage
code: theorem comap_preimage {β} [MeasurableSpace α] {mβ : MeasurableSpace β} (f : α → β) (μ : Measure β)
    {s : Set β} (hf : Injective f) (hf' : Measurable f)
    (h : ∀ t, MeasurableSet t → NullMeasurableSet (f '' t) μ) (hs : MeasurableSet s) :
    μ.comap f (f ⁻¹' s) = μ (s ∩ range f) 
goal: (MeasureTheory.Measure.comap f μ) (f ⁻¹' s) = μ (s ∩ Set.range f)

full_name: MeasureTheory.Measure.sum
code: /-- Sum of an indexed family of measures. -/
noncomputable def sum (f : ι → Measure α) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.le_sum_apply
code: theorem le_sum_apply (f : ι → Measure α) (s : Set α) : ∑' i, f i s ≤ sum f s 
goal: ∑' (i : ι), (f i) s ≤ (MeasureTheory.Measure.sum f) s

full_name: MeasureTheory.Measure.sum_apply
code: @[simp]
theorem sum_apply (f : ι → Measure α) {s : Set α} (hs : MeasurableSet s) :
    sum f s = ∑' i, f i s 
goal: (MeasureTheory.Measure.sum f) s = ∑' (i : ι), (f i) s

full_name: MeasureTheory.Measure.sum_apply₀
code: theorem sum_apply₀ (f : ι → Measure α) {s : Set α} (hs : NullMeasurableSet s (sum f)) :
    sum f s = ∑' i, f i s 
goal: (MeasureTheory.Measure.sum f) s = ∑' (i : ι), (f i) s

full_name: MeasureTheory.Measure.sum_apply_of_countable
code: theorem sum_apply_of_countable [Countable ι] (f : ι → Measure α) (s : Set α) :
    sum f s = ∑' i, f i s 
goal: (MeasureTheory.Measure.sum f) s = ∑' (i : ι), (f i) s

full_name: MeasureTheory.Measure.le_sum
code: theorem le_sum (μ : ι → Measure α) (i : ι) : μ i ≤ sum μ 
goal: μ i ≤ MeasureTheory.Measure.sum μ

full_name: MeasureTheory.Measure.sum_apply_eq_zero
code: @[simp]
theorem sum_apply_eq_zero [Countable ι] {μ : ι → Measure α} {s : Set α} :
    sum μ s = 0 ↔ ∀ i, μ i s = 0 
goal: (MeasureTheory.Measure.sum μ) s = 0 ↔ ∀ (i : ι), (μ i) s = 0

full_name: MeasureTheory.Measure.sum_apply_eq_zero'
code: theorem sum_apply_eq_zero' {μ : ι → Measure α} {s : Set α} (hs : MeasurableSet s) :
    sum μ s = 0 ↔ ∀ i, μ i s = 0 
goal: (MeasureTheory.Measure.sum μ) s = 0 ↔ ∀ (i : ι), (μ i) s = 0

full_name: MeasureTheory.Measure.sum_zero
code: @[simp]
lemma sum_zero : Measure.sum (fun (_ : ι) ↦ (0 : Measure α)) = 0 
goal: (MeasureTheory.Measure.sum fun x => 0) = 0

full_name: MeasureTheory.Measure.sum_sum
code: theorem sum_sum {ι' : Type*} (μ : ι → ι' → Measure α) :
    (sum fun n => sum (μ n)) = sum (fun (p : ι × ι') ↦ μ p.1 p.2) 
goal: (MeasureTheory.Measure.sum fun n => MeasureTheory.Measure.sum (μ n)) = MeasureTheory.Measure.sum fun p => μ p.1 p.2

full_name: MeasureTheory.Measure.sum_comm
code: theorem sum_comm {ι' : Type*} (μ : ι → ι' → Measure α) :
    (sum fun n => sum (μ n)) = sum fun m => sum fun n => μ n m 
goal: (MeasureTheory.Measure.sum fun n => MeasureTheory.Measure.sum (μ n)) =
  MeasureTheory.Measure.sum fun m => MeasureTheory.Measure.sum fun n => μ n m

full_name: MeasureTheory.Measure.ae_sum_iff
code: theorem ae_sum_iff [Countable ι] {μ : ι → Measure α} {p : α → Prop} :
    (∀ᵐ x ∂sum μ, p x) ↔ ∀ i, ∀ᵐ x ∂μ i, p x 
goal: (∀ᵐ (x : α) ∂MeasureTheory.Measure.sum μ, p x) ↔ ∀ (i : ι), ∀ᵐ (x : α) ∂μ i, p x

full_name: MeasureTheory.Measure.ae_sum_iff'
code: theorem ae_sum_iff' {μ : ι → Measure α} {p : α → Prop} (h : MeasurableSet { x | p x }) :
    (∀ᵐ x ∂sum μ, p x) ↔ ∀ i, ∀ᵐ x ∂μ i, p x 
goal: (∀ᵐ (x : α) ∂MeasureTheory.Measure.sum μ, p x) ↔ ∀ (i : ι), ∀ᵐ (x : α) ∂μ i, p x

full_name: MeasureTheory.Measure.sum_fintype
code: @[simp]
theorem sum_fintype [Fintype ι] (μ : ι → Measure α) : sum μ = ∑ i, μ i 
goal: MeasureTheory.Measure.sum μ = ∑ i : ι, μ i

full_name: MeasureTheory.Measure.sum_coe_finset
code: theorem sum_coe_finset (s : Finset ι) (μ : ι → Measure α) :
    (sum fun i : s => μ i) = ∑ i ∈ s, μ i 
goal: (MeasureTheory.Measure.sum fun i => μ ↑i) = ∑ i ∈ s, μ i

full_name: MeasureTheory.Measure.ae_sum_eq
code: @[simp]
theorem ae_sum_eq [Countable ι] (μ : ι → Measure α) : ae (sum μ) = ⨆ i, ae (μ i) 
goal: MeasureTheory.ae (MeasureTheory.Measure.sum μ) = ⨆ i, MeasureTheory.ae (μ i)

full_name: MeasureTheory.Measure.sum_bool
code: theorem sum_bool (f : Bool → Measure α) : sum f = f true + f false 
goal: MeasureTheory.Measure.sum f = f true + f false

full_name: MeasureTheory.Measure.sum_cond
code: theorem sum_cond (μ ν : Measure α) : (sum fun b => cond b μ ν) = μ + ν 
goal: (MeasureTheory.Measure.sum fun b => bif b then μ else ν) = μ + ν

full_name: MeasureTheory.Measure.sum_of_isEmpty
code: @[simp]
theorem sum_of_isEmpty [IsEmpty ι] (μ : ι → Measure α) : sum μ = 0 
goal: MeasureTheory.Measure.sum μ = 0

full_name: MeasureTheory.Measure.sum_add_sum_compl
code: theorem sum_add_sum_compl (s : Set ι) (μ : ι → Measure α) :
    ((sum fun i : s => μ i) + sum fun i : ↥sᶜ => μ i) = sum μ 
goal: ((MeasureTheory.Measure.sum fun i => μ ↑i) + MeasureTheory.Measure.sum fun i => μ ↑i) = MeasureTheory.Measure.sum μ

full_name: MeasureTheory.Measure.sum_congr
code: theorem sum_congr {μ ν : ℕ → Measure α} (h : ∀ n, μ n = ν n) : sum μ = sum ν 
goal: MeasureTheory.Measure.sum μ = MeasureTheory.Measure.sum ν

full_name: MeasureTheory.Measure.sum_add_sum
code: theorem sum_add_sum {ι : Type*} (μ ν : ι → Measure α) : sum μ + sum ν = sum fun n => μ n + ν n 
goal: MeasureTheory.Measure.sum μ + MeasureTheory.Measure.sum ν = MeasureTheory.Measure.sum fun n => μ n + ν n

full_name: MeasureTheory.Measure.sum_comp_equiv
code: @[simp] lemma sum_comp_equiv {ι ι' : Type*} (e : ι' ≃ ι) (m : ι → Measure α) :
    sum (m ∘ e) = sum m 
goal: MeasureTheory.Measure.sum (m ∘ ⇑e) = MeasureTheory.Measure.sum m

full_name: MeasureTheory.Measure.sum_extend_zero
code: @[simp] lemma sum_extend_zero {ι ι' : Type*} {f : ι → ι'} (hf : Injective f) (m : ι → Measure α) :
    sum (Function.extend f m 0) = sum m 
goal: MeasureTheory.Measure.sum (Function.extend f m 0) = MeasureTheory.Measure.sum m

full_name: MeasureTheory.Measure.AbsolutelyContinuous
code: /-- We say that `μ` is absolutely continuous with respect to `ν`, or that `μ` is dominated by `ν`,
  if `ν(A) = 0` implies that `μ(A) = 0`. -/
def AbsolutelyContinuous {_m0 : MeasurableSpace α} (μ ν : Measure α) : Prop 
goal: Prop

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_Measure_MeasureSpace___macroRules_MeasureTheory_term_≪__1»
code: @[inherit_doc MeasureTheory.Measure.AbsolutelyContinuous]
scoped[MeasureTheory] infixl:50 " ≪ " => MeasureTheory.Measure.AbsolutelyContinuous
goal: Lean.Macro

full_name: MeasureTheory._aux_Mathlib_MeasureTheory_Measure_MeasureSpace___unexpand_MeasureTheory_Measure_AbsolutelyContinuous_1
code: @[inherit_doc MeasureTheory.Measure.AbsolutelyContinuous]
scoped[MeasureTheory] infixl:50 " ≪ " => MeasureTheory.Measure.AbsolutelyContinuous
goal: Lean.PrettyPrinter.Unexpander

full_name: MeasureTheory.Measure.absolutelyContinuous_of_le
code: theorem absolutelyContinuous_of_le (h : μ ≤ ν) : μ ≪ ν 
goal: μ.AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.absolutelyContinuous_of_eq
code: theorem absolutelyContinuous_of_eq (h : μ = ν) : μ ≪ ν 
goal: μ.AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.AbsolutelyContinuous.mk
code: theorem mk (h : ∀ ⦃s : Set α⦄, MeasurableSet s → ν s = 0 → μ s = 0) : μ ≪ ν 
goal: μ.AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.AbsolutelyContinuous.refl
code: @[refl]
protected theorem refl {_m0 : MeasurableSpace α} (μ : Measure α) : μ ≪ μ 
goal: μ.AbsolutelyContinuous μ

full_name: MeasureTheory.Measure.AbsolutelyContinuous.rfl
code: protected theorem rfl : μ ≪ μ 
goal: μ.AbsolutelyContinuous μ

full_name: MeasureTheory.Measure.AbsolutelyContinuous.instIsRefl
code: instance instIsRefl [MeasurableSpace α] : IsRefl (Measure α) (· ≪ ·) 
goal: IsRefl (MeasureTheory.Measure α) fun x x_1 => x.AbsolutelyContinuous x_1

full_name: MeasureTheory.Measure.AbsolutelyContinuous.zero
code: @[simp]
protected lemma zero (μ : Measure α) : 0 ≪ μ 
goal: MeasureTheory.Measure.AbsolutelyContinuous 0 μ

full_name: MeasureTheory.Measure.AbsolutelyContinuous.trans
code: @[trans]
protected theorem trans (h1 : μ₁ ≪ μ₂) (h2 : μ₂ ≪ μ₃) : μ₁ ≪ μ₃ 
goal: μ₁.AbsolutelyContinuous μ₃

full_name: MeasureTheory.Measure.AbsolutelyContinuous.map
code: @[mono]
protected theorem map (h : μ ≪ ν) {f : α → β} (hf : Measurable f) : μ.map f ≪ ν.map f 
goal: (MeasureTheory.Measure.map f μ).AbsolutelyContinuous (MeasureTheory.Measure.map f ν)

full_name: MeasureTheory.Measure.AbsolutelyContinuous.smul
code: protected theorem smul [Monoid R] [DistribMulAction R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    (h : μ ≪ ν) (c : R) : c • μ ≪ ν 
goal: (c • μ).AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.AbsolutelyContinuous.add
code: protected lemma add (h1 : μ₁ ≪ ν) (h2 : μ₂ ≪ ν') : μ₁ + μ₂ ≪ ν + ν' 
goal: (μ₁ + μ₂).AbsolutelyContinuous (ν + ν')

full_name: MeasureTheory.Measure.AbsolutelyContinuous.add_left_iff
code: lemma add_left_iff {μ₁ μ₂ ν : Measure α} :
    μ₁ + μ₂ ≪ ν ↔ μ₁ ≪ ν ∧ μ₂ ≪ ν 
goal: (μ₁ + μ₂).AbsolutelyContinuous ν ↔ μ₁.AbsolutelyContinuous ν ∧ μ₂.AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.AbsolutelyContinuous.add_left
code: lemma add_left {μ₁ μ₂ ν : Measure α} (h₁ : μ₁ ≪ ν) (h₂ : μ₂ ≪ ν) : μ₁ + μ₂ ≪ ν 
goal: (μ₁ + μ₂).AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.AbsolutelyContinuous.add_right
code: lemma add_right (h1 : μ ≪ ν) (ν' : Measure α) : μ ≪ ν + ν' 
goal: μ.AbsolutelyContinuous (ν + ν')

full_name: MeasureTheory.Measure.absolutelyContinuous_zero_iff
code: @[simp]
lemma absolutelyContinuous_zero_iff : μ ≪ 0 ↔ μ = 0 
goal: μ.AbsolutelyContinuous 0 ↔ μ = 0

full_name: MeasureTheory.Measure.absolutelyContinuous_sum_left
code: lemma absolutelyContinuous_sum_left {μs : ι → Measure α} (hμs : ∀ i, μs i ≪ ν) :
    Measure.sum μs ≪ ν 
goal: (MeasureTheory.Measure.sum μs).AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.absolutelyContinuous_sum_right
code: lemma absolutelyContinuous_sum_right {μs : ι → Measure α} (i : ι) (hνμ : ν ≪ μs i) :
    ν ≪ Measure.sum μs 
goal: ν.AbsolutelyContinuous (MeasureTheory.Measure.sum μs)

full_name: MeasureTheory.Measure.absolutelyContinuous_of_le_smul
code: theorem absolutelyContinuous_of_le_smul {μ' : Measure α} {c : ℝ≥0∞} (hμ'_le : μ' ≤ c • μ) :
    μ' ≪ μ 
goal: μ'.AbsolutelyContinuous μ

full_name: MeasureTheory.Measure.smul_absolutelyContinuous
code: lemma smul_absolutelyContinuous {c : ℝ≥0∞} : c • μ ≪ μ 
goal: (c • μ).AbsolutelyContinuous μ

full_name: MeasureTheory.Measure.absolutelyContinuous_smul
code: lemma absolutelyContinuous_smul {c : ℝ≥0∞} (hc : c ≠ 0) : μ ≪ c • μ 
goal: μ.AbsolutelyContinuous (c • μ)

full_name: MeasureTheory.Measure.ae_le_iff_absolutelyContinuous
code: theorem ae_le_iff_absolutelyContinuous : ae μ ≤ ae ν ↔ μ ≪ ν 
goal: MeasureTheory.ae μ ≤ MeasureTheory.ae ν ↔ μ.AbsolutelyContinuous ν

full_name: MeasureTheory.Measure.AbsolutelyContinuous.ae_eq
code: theorem AbsolutelyContinuous.ae_eq (h : μ ≪ ν) {f g : α → δ} (h' : f =ᵐ[ν] g) : f =ᵐ[μ] g 
goal: f =ᵐ[μ] g

full_name: MeasureTheory.AEDisjoint.of_absolutelyContinuous
code: protected theorem _root_.MeasureTheory.AEDisjoint.of_absolutelyContinuous
    (h : AEDisjoint μ s t) {ν : Measure α} (h' : ν ≪ μ) :
    AEDisjoint ν s t 
goal: MeasureTheory.AEDisjoint ν s t

full_name: MeasureTheory.AEDisjoint.of_le
code: protected theorem _root_.MeasureTheory.AEDisjoint.of_le
    (h : AEDisjoint μ s t) {ν : Measure α} (h' : ν ≤ μ) :
    AEDisjoint ν s t 
goal: MeasureTheory.AEDisjoint ν s t

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.absolutelyContinuous
code: /-- A map `f : α → β` is said to be *quasi measure preserving* (a.k.a. non-singular) w.r.t. measures
`μa` and `μb` if it is measurable and `μb s = 0` implies `μa (f ⁻¹' s) = 0`. -/
structure QuasiMeasurePreserving {m0 : MeasurableSpace α} (f : α → β)
  (μa : Measure α := by volume_tac)
  (μb : Measure β := by volume_tac) : Prop where
  protected measurable : Measurable f
  protected absolutelyContinuous : μa.map f ≪ μb
goal: (MeasureTheory.Measure.map f μa).AbsolutelyContinuous μb

full_name: MeasureTheory.Measure.QuasiMeasurePreserving
code: /-- A map `f : α → β` is said to be *quasi measure preserving* (a.k.a. non-singular) w.r.t. measures
`μa` and `μb` if it is measurable and `μb s = 0` implies `μa (f ⁻¹' s) = 0`. -/
structure QuasiMeasurePreserving {m0 : MeasurableSpace α} (f : α → β)
  (μa : Measure α := by volume_tac)
  (μb : Measure β := by volume_tac) : Prop where
  protected measurable : Measurable f
  protected absolutelyContinuous : μa.map f ≪ μb
goal: Prop

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.measurable
code: /-- A map `f : α → β` is said to be *quasi measure preserving* (a.k.a. non-singular) w.r.t. measures
`μa` and `μb` if it is measurable and `μb s = 0` implies `μa (f ⁻¹' s) = 0`. -/
structure QuasiMeasurePreserving {m0 : MeasurableSpace α} (f : α → β)
  (μa : Measure α := by volume_tac)
  (μb : Measure β := by volume_tac) : Prop where
  protected measurable : Measurable f
  protected absolutelyContinuous : μa.map f ≪ μb
goal: Measurable f

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.id
code: protected theorem id {_m0 : MeasurableSpace α} (μ : Measure α) : QuasiMeasurePreserving id μ μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving id μ μ

full_name: Measurable.quasiMeasurePreserving
code: protected theorem _root_.Measurable.quasiMeasurePreserving
    {_m0 : MeasurableSpace α} (hf : Measurable f) (μ : Measure α) :
    QuasiMeasurePreserving f μ (μ.map f) 
goal: MeasureTheory.Measure.QuasiMeasurePreserving f μ (MeasureTheory.Measure.map f μ)

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.mono_left
code: theorem mono_left (h : QuasiMeasurePreserving f μa μb) (ha : μa' ≪ μa) :
    QuasiMeasurePreserving f μa' μb 
goal: MeasureTheory.Measure.QuasiMeasurePreserving f μa' μb

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.mono_right
code: theorem mono_right (h : QuasiMeasurePreserving f μa μb) (ha : μb ≪ μb') :
    QuasiMeasurePreserving f μa μb' 
goal: MeasureTheory.Measure.QuasiMeasurePreserving f μa μb'

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.mono
code: @[mono]
theorem mono (ha : μa' ≪ μa) (hb : μb ≪ μb') (h : QuasiMeasurePreserving f μa μb) :
    QuasiMeasurePreserving f μa' μb' 
goal: MeasureTheory.Measure.QuasiMeasurePreserving f μa' μb'

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.comp
code: protected theorem comp {g : β → γ} {f : α → β} (hg : QuasiMeasurePreserving g μb μc)
    (hf : QuasiMeasurePreserving f μa μb) : QuasiMeasurePreserving (g ∘ f) μa μc 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (g ∘ f) μa μc

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.iterate
code: protected theorem iterate {f : α → α} (hf : QuasiMeasurePreserving f μa μa) :
    ∀ n, QuasiMeasurePreserving f^[n] μa μa
  
goal: MeasureTheory.Measure.QuasiMeasurePreserving f^[n] μa μa

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.aemeasurable
code: protected theorem aemeasurable (hf : QuasiMeasurePreserving f μa μb) : AEMeasurable f μa 
goal: AEMeasurable f μa

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.ae_map_le
code: theorem ae_map_le (h : QuasiMeasurePreserving f μa μb) : ae (μa.map f) ≤ ae μb 
goal: MeasureTheory.ae (MeasureTheory.Measure.map f μa) ≤ MeasureTheory.ae μb

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.tendsto_ae
code: theorem tendsto_ae (h : QuasiMeasurePreserving f μa μb) : Tendsto f (ae μa) (ae μb) 
goal: Filter.Tendsto f (MeasureTheory.ae μa) (MeasureTheory.ae μb)

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.ae
code: theorem ae (h : QuasiMeasurePreserving f μa μb) {p : β → Prop} (hg : ∀ᵐ x ∂μb, p x) :
    ∀ᵐ x ∂μa, p (f x) 
goal: ∀ᵐ (x : α) ∂μa, p (f x)

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.ae_eq
code: theorem ae_eq (h : QuasiMeasurePreserving f μa μb) {g₁ g₂ : β → δ} (hg : g₁ =ᵐ[μb] g₂) :
    g₁ ∘ f =ᵐ[μa] g₂ ∘ f 
goal: g₁ ∘ f =ᵐ[μa] g₂ ∘ f

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.preimage_null
code: theorem preimage_null (h : QuasiMeasurePreserving f μa μb) {s : Set β} (hs : μb s = 0) :
    μa (f ⁻¹' s) = 0 
goal: μa (f ⁻¹' s) = 0

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.preimage_mono_ae
code: theorem preimage_mono_ae {s t : Set β} (hf : QuasiMeasurePreserving f μa μb) (h : s ≤ᵐ[μb] t) :
    f ⁻¹' s ≤ᵐ[μa] f ⁻¹' t 
goal: f ⁻¹' s ≤ᵐ[μa] f ⁻¹' t

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.preimage_ae_eq
code: theorem preimage_ae_eq {s t : Set β} (hf : QuasiMeasurePreserving f μa μb) (h : s =ᵐ[μb] t) :
    f ⁻¹' s =ᵐ[μa] f ⁻¹' t 
goal: f ⁻¹' s =ᵐ[μa] f ⁻¹' t

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.preimage_iterate_ae_eq
code: theorem preimage_iterate_ae_eq {s : Set α} {f : α → α} (hf : QuasiMeasurePreserving f μ μ) (k : ℕ)
    (hs : f ⁻¹' s =ᵐ[μ] s) : f^[k] ⁻¹' s =ᵐ[μ] s 
goal: f^[k] ⁻¹' s =ᵐ[μ] s

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.image_zpow_ae_eq
code: theorem image_zpow_ae_eq {s : Set α} {e : α ≃ α} (he : QuasiMeasurePreserving e μ μ)
    (he' : QuasiMeasurePreserving e.symm μ μ) (k : ℤ) (hs : e '' s =ᵐ[μ] s) :
    (⇑(e ^ k)) '' s =ᵐ[μ] s 
goal: ⇑(e ^ k) '' s =ᵐ[μ] s

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.limsup_preimage_iterate_ae_eq
code: theorem limsup_preimage_iterate_ae_eq {f : α → α} (hf : QuasiMeasurePreserving f μ μ)
    (hs : f ⁻¹' s =ᵐ[μ] s) : limsup (α := Set α) (fun n => (preimage f)^[n] s) atTop =ᵐ[μ] s 
goal: Filter.limsup (fun n => (Set.preimage f)^[n] s) Filter.atTop =ᵐ[μ] s

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.liminf_preimage_iterate_ae_eq
code: theorem liminf_preimage_iterate_ae_eq {f : α → α} (hf : QuasiMeasurePreserving f μ μ)
    (hs : f ⁻¹' s =ᵐ[μ] s) : liminf (α := Set α) (fun n => (preimage f)^[n] s) atTop =ᵐ[μ] s 
goal: Filter.liminf (fun n => (Set.preimage f)^[n] s) Filter.atTop =ᵐ[μ] s

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.exists_preimage_eq_of_preimage_ae
code: /-- By replacing a measurable set that is almost invariant with the `limsup` of its preimages, we
obtain a measurable set that is almost equal and strictly invariant.

(The `liminf` would work just as well.) -/
theorem exists_preimage_eq_of_preimage_ae {f : α → α} (h : QuasiMeasurePreserving f μ μ)
    (hs : MeasurableSet s) (hs' : f ⁻¹' s =ᵐ[μ] s) :
    ∃ t : Set α, MeasurableSet t ∧ t =ᵐ[μ] s ∧ f ⁻¹' t = t 
goal: ∃ t, MeasurableSet t ∧ t =ᵐ[μ] s ∧ f ⁻¹' t = t

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.smul_ae_eq_of_ae_eq
code: @[to_additive]
theorem smul_ae_eq_of_ae_eq {G α : Type*} [Group G] [MulAction G α] [MeasurableSpace α]
    {s t : Set α} {μ : Measure α} (g : G)
    (h_qmp : QuasiMeasurePreserving (g⁻¹ • · : α → α) μ μ)
    (h_ae_eq : s =ᵐ[μ] t) : (g • s : Set α) =ᵐ[μ] (g • t : Set α) 
goal: g • s =ᵐ[μ] g • t

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.vadd_ae_eq_of_ae_eq
code: @[to_additive]
theorem smul_ae_eq_of_ae_eq {G α : Type*} [Group G] [MulAction G α] [MeasurableSpace α]
    {s t : Set α} {μ : Measure α} (g : G)
    (h_qmp : QuasiMeasurePreserving (g⁻¹ • · : α → α) μ μ)
    (h_ae_eq : s =ᵐ[μ] t) : (g • s : Set α) =ᵐ[μ] (g • t : Set α) 
goal: g +ᵥ s =ᵐ[μ] g +ᵥ t

full_name: MeasureTheory.Measure.pairwise_aedisjoint_of_aedisjoint_forall_ne_one
code: @[to_additive]
theorem pairwise_aedisjoint_of_aedisjoint_forall_ne_one {G α : Type*} [Group G] [MulAction G α]
    [MeasurableSpace α] {μ : Measure α} {s : Set α}
    (h_ae_disjoint : ∀ g ≠ (1 : G), AEDisjoint μ (g • s) s)
    (h_qmp : ∀ g : G, QuasiMeasurePreserving (g • ·) μ μ) :
    Pairwise (AEDisjoint μ on fun g : G => g • s) 
goal: Pairwise (MeasureTheory.AEDisjoint μ on fun g => g • s)

full_name: MeasureTheory.Measure.pairwise_aedisjoint_of_aedisjoint_forall_ne_zero
code: @[to_additive]
theorem pairwise_aedisjoint_of_aedisjoint_forall_ne_one {G α : Type*} [Group G] [MulAction G α]
    [MeasurableSpace α] {μ : Measure α} {s : Set α}
    (h_ae_disjoint : ∀ g ≠ (1 : G), AEDisjoint μ (g • s) s)
    (h_qmp : ∀ g : G, QuasiMeasurePreserving (g • ·) μ μ) :
    Pairwise (AEDisjoint μ on fun g : G => g • s) 
goal: Pairwise (MeasureTheory.AEDisjoint μ on fun g => g +ᵥ s)

full_name: MeasureTheory.Measure.cofinite
code: /-- The filter of sets `s` such that `sᶜ` has finite measure. -/
def cofinite {m0 : MeasurableSpace α} (μ : Measure α) : Filter α 
goal: Filter α

full_name: MeasureTheory.Measure.mem_cofinite
code: theorem mem_cofinite : s ∈ μ.cofinite ↔ μ sᶜ < ∞ 
goal: s ∈ μ.cofinite ↔ μ sᶜ < ⊤

full_name: MeasureTheory.Measure.compl_mem_cofinite
code: theorem compl_mem_cofinite : sᶜ ∈ μ.cofinite ↔ μ s < ∞ 
goal: sᶜ ∈ μ.cofinite ↔ μ s < ⊤

full_name: MeasureTheory.Measure.eventually_cofinite
code: theorem eventually_cofinite {p : α → Prop} : (∀ᶠ x in μ.cofinite, p x) ↔ μ { x | ¬p x } < ∞ 
goal: (∀ᶠ (x : α) in μ.cofinite, p x) ↔ μ {x | ¬p x} < ⊤

full_name: MeasureTheory.Measure.cofinite.instIsMeasurablyGenerated
code: instance cofinite.instIsMeasurablyGenerated : IsMeasurablyGenerated μ.cofinite 
goal: μ.cofinite.IsMeasurablyGenerated

full_name: AEMeasurable.nullMeasurable
code: protected theorem _root_.AEMeasurable.nullMeasurable {f : α → β} (h : AEMeasurable f μ) :
    NullMeasurable f μ 
goal: MeasureTheory.NullMeasurable f μ

full_name: AEMeasurable.nullMeasurableSet_preimage
code: lemma _root_.AEMeasurable.nullMeasurableSet_preimage {f : α → β} {s : Set β}
    (hf : AEMeasurable f μ) (hs : MeasurableSet s) : NullMeasurableSet (f ⁻¹' s) μ 
goal: MeasureTheory.NullMeasurableSet (f ⁻¹' s) μ

full_name: MeasureTheory.NullMeasurableSet.preimage
code: /-- The preimage of a null measurable set under a (quasi) measure preserving map is a null
measurable set. -/
theorem NullMeasurableSet.preimage {ν : Measure β} {f : α → β} {t : Set β}
    (ht : NullMeasurableSet t ν) (hf : QuasiMeasurePreserving f μ ν) :
    NullMeasurableSet (f ⁻¹' t) μ 
goal: MeasureTheory.NullMeasurableSet (f ⁻¹' t) μ

full_name: MeasureTheory.NullMeasurableSet.mono_ac
code: theorem NullMeasurableSet.mono_ac (h : NullMeasurableSet s μ) (hle : ν ≪ μ) :
    NullMeasurableSet s ν 
goal: MeasureTheory.NullMeasurableSet s ν

full_name: MeasureTheory.NullMeasurableSet.mono
code: theorem NullMeasurableSet.mono (h : NullMeasurableSet s μ) (hle : ν ≤ μ) : NullMeasurableSet s ν 
goal: MeasureTheory.NullMeasurableSet s ν

full_name: MeasureTheory.AEDisjoint.preimage
code: theorem AEDisjoint.preimage {ν : Measure β} {f : α → β} {s t : Set β} (ht : AEDisjoint ν s t)
    (hf : QuasiMeasurePreserving f μ ν) : AEDisjoint μ (f ⁻¹' s) (f ⁻¹' t) 
goal: MeasureTheory.AEDisjoint μ (f ⁻¹' s) (f ⁻¹' t)

full_name: MeasureTheory.ae_eq_bot
code: @[simp]
theorem ae_eq_bot : ae μ = ⊥ ↔ μ = 0 
goal: MeasureTheory.ae μ = ⊥ ↔ μ = 0

full_name: MeasureTheory.ae_neBot
code: @[simp]
theorem ae_neBot : (ae μ).NeBot ↔ μ ≠ 0 
goal: (MeasureTheory.ae μ).NeBot ↔ μ ≠ 0

full_name: MeasureTheory.Measure.ae.neBot
code: instance Measure.ae.neBot [NeZero μ] : (ae μ).NeBot 
goal: (MeasureTheory.ae μ).NeBot

full_name: MeasureTheory.ae_zero
code: @[simp]
theorem ae_zero {_m0 : MeasurableSpace α} : ae (0 : Measure α) = ⊥ 
goal: MeasureTheory.ae 0 = ⊥

full_name: MeasureTheory.ae_mono
code: @[mono]
theorem ae_mono (h : μ ≤ ν) : ae μ ≤ ae ν 
goal: MeasureTheory.ae μ ≤ MeasureTheory.ae ν

full_name: MeasureTheory.mem_ae_map_iff
code: theorem mem_ae_map_iff {f : α → β} (hf : AEMeasurable f μ) {s : Set β} (hs : MeasurableSet s) :
    s ∈ ae (μ.map f) ↔ f ⁻¹' s ∈ ae μ 
goal: s ∈ MeasureTheory.ae (MeasureTheory.Measure.map f μ) ↔ f ⁻¹' s ∈ MeasureTheory.ae μ

full_name: MeasureTheory.mem_ae_of_mem_ae_map
code: theorem mem_ae_of_mem_ae_map {f : α → β} (hf : AEMeasurable f μ) {s : Set β}
    (hs : s ∈ ae (μ.map f)) : f ⁻¹' s ∈ ae μ 
goal: f ⁻¹' s ∈ MeasureTheory.ae μ

full_name: MeasureTheory.ae_map_iff
code: theorem ae_map_iff {f : α → β} (hf : AEMeasurable f μ) {p : β → Prop}
    (hp : MeasurableSet { x | p x }) : (∀ᵐ y ∂μ.map f, p y) ↔ ∀ᵐ x ∂μ, p (f x) 
goal: (∀ᵐ (y : β) ∂MeasureTheory.Measure.map f μ, p y) ↔ ∀ᵐ (x : α) ∂μ, p (f x)

full_name: MeasureTheory.ae_of_ae_map
code: theorem ae_of_ae_map {f : α → β} (hf : AEMeasurable f μ) {p : β → Prop} (h : ∀ᵐ y ∂μ.map f, p y) :
    ∀ᵐ x ∂μ, p (f x) 
goal: ∀ᵐ (x : α) ∂μ, p (f x)

full_name: MeasureTheory.ae_map_mem_range
code: theorem ae_map_mem_range {m0 : MeasurableSpace α} (f : α → β) (hf : MeasurableSet (range f))
    (μ : Measure α) : ∀ᵐ x ∂μ.map f, x ∈ range f 
goal: ∀ᵐ (x : β) ∂MeasureTheory.Measure.map f μ, x ∈ Set.range f

full_name: MeasureTheory.biSup_measure_Iic
code: theorem biSup_measure_Iic [Preorder α] {s : Set α} (hsc : s.Countable)
    (hst : ∀ x : α, ∃ y ∈ s, x ≤ y) (hdir : DirectedOn (· ≤ ·) s) :
    ⨆ x ∈ s, μ (Iic x) = μ univ 
goal: ⨆ x ∈ s, μ (Set.Iic x) = μ Set.univ

full_name: MeasureTheory.tendsto_measure_Ico_atTop
code: theorem tendsto_measure_Ico_atTop [SemilatticeSup α] [NoMaxOrder α]
    [(atTop : Filter α).IsCountablyGenerated] (μ : Measure α) (a : α) :
    Tendsto (fun x => μ (Ico a x)) atTop (𝓝 (μ (Ici a))) 
goal: Filter.Tendsto (fun x => μ (Set.Ico a x)) Filter.atTop (nhds (μ (Set.Ici a)))

full_name: MeasureTheory.tendsto_measure_Ioc_atBot
code: theorem tendsto_measure_Ioc_atBot [SemilatticeInf α] [NoMinOrder α]
    [(atBot : Filter α).IsCountablyGenerated] (μ : Measure α) (a : α) :
    Tendsto (fun x => μ (Ioc x a)) atBot (𝓝 (μ (Iic a))) 
goal: Filter.Tendsto (fun x => μ (Set.Ioc x a)) Filter.atBot (nhds (μ (Set.Iic a)))

full_name: MeasureTheory.tendsto_measure_Iic_atTop
code: theorem tendsto_measure_Iic_atTop [SemilatticeSup α] [(atTop : Filter α).IsCountablyGenerated]
    (μ : Measure α) : Tendsto (fun x => μ (Iic x)) atTop (𝓝 (μ univ)) 
goal: Filter.Tendsto (fun x => μ (Set.Iic x)) Filter.atTop (nhds (μ Set.univ))

full_name: MeasureTheory.tendsto_measure_Ici_atBot
code: theorem tendsto_measure_Ici_atBot [SemilatticeInf α] [h : (atBot : Filter α).IsCountablyGenerated]
    (μ : Measure α) : Tendsto (fun x => μ (Ici x)) atBot (𝓝 (μ univ)) 
goal: Filter.Tendsto (fun x => μ (Set.Ici x)) Filter.atBot (nhds (μ Set.univ))

full_name: MeasureTheory.Iio_ae_eq_Iic'
code: theorem Iio_ae_eq_Iic' (ha : μ {a} = 0) : Iio a =ᵐ[μ] Iic a 
goal: Set.Iio a =ᵐ[μ] Set.Iic a

full_name: MeasureTheory.Ioi_ae_eq_Ici'
code: theorem Ioi_ae_eq_Ici' (ha : μ {a} = 0) : Ioi a =ᵐ[μ] Ici a 
goal: Set.Ioi a =ᵐ[μ] Set.Ici a

full_name: MeasureTheory.Ioo_ae_eq_Ioc'
code: theorem Ioo_ae_eq_Ioc' (hb : μ {b} = 0) : 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' (ha : μ {a} = 0) : 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' (ha : μ {a} = 0) : 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' (ha : μ {a} = 0) (hb : μ {b} = 0) : 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' (hb : μ {b} = 0) : 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' (ha : μ {a} = 0) (hb : μ {b} = 0) : Ico a b =ᵐ[μ] Ioc a b 
goal: Set.Ico a b =ᵐ[μ] Set.Ioc a b

full_name: MeasurableEmbedding.map_apply
code: nonrec theorem map_apply (hf : MeasurableEmbedding f) (μ : Measure α) (s : Set β) :
    μ.map f s = μ (f ⁻¹' s) 
goal: (MeasureTheory.Measure.map f μ) s = μ (f ⁻¹' s)

full_name: MeasurableEmbedding.comap_add
code: lemma comap_add (hf : MeasurableEmbedding f) (μ ν : Measure β) :
    (μ + ν).comap f = μ.comap f + ν.comap f 
goal: MeasureTheory.Measure.comap f (μ + ν) = MeasureTheory.Measure.comap f μ + MeasureTheory.Measure.comap f ν

full_name: MeasurableEmbedding.absolutelyContinuous_map
code: lemma absolutelyContinuous_map (hf : MeasurableEmbedding f) (hμν : μ ≪ ν) :
    μ.map f ≪ ν.map f 
goal: (MeasureTheory.Measure.map f μ).AbsolutelyContinuous (MeasureTheory.Measure.map f ν)

full_name: MeasurableEquiv.map_apply
code: /-- If we map a measure along a measurable equivalence, we can compute the measure on all sets
  (not just the measurable ones). -/
protected theorem map_apply (f : α ≃ᵐ β) (s : Set β) : μ.map f s = μ (f ⁻¹' s) 
goal: (MeasureTheory.Measure.map (⇑f) μ) s = μ (⇑f ⁻¹' s)

full_name: MeasurableEquiv.comap_symm
code: lemma comap_symm (e : α ≃ᵐ β) : μ.comap e.symm = μ.map e 
goal: MeasureTheory.Measure.comap (⇑e.symm) μ = MeasureTheory.Measure.map (⇑e) μ

full_name: MeasurableEquiv.map_symm
code: lemma map_symm (e : β ≃ᵐ α) : μ.map e.symm = μ.comap e 
goal: MeasureTheory.Measure.map (⇑e.symm) μ = MeasureTheory.Measure.comap (⇑e) μ

full_name: MeasurableEquiv.map_symm_map
code: @[simp]
theorem map_symm_map (e : α ≃ᵐ β) : (μ.map e).map e.symm = μ 
goal: MeasureTheory.Measure.map (⇑e.symm) (MeasureTheory.Measure.map (⇑e) μ) = μ

full_name: MeasurableEquiv.map_map_symm
code: @[simp]
theorem map_map_symm (e : α ≃ᵐ β) : (ν.map e.symm).map e = ν 
goal: MeasureTheory.Measure.map (⇑e) (MeasureTheory.Measure.map (⇑e.symm) ν) = ν

full_name: MeasurableEquiv.map_measurableEquiv_injective
code: theorem map_measurableEquiv_injective (e : α ≃ᵐ β) : Injective (Measure.map e) 
goal: Function.Injective (MeasureTheory.Measure.map ⇑e)

full_name: MeasurableEquiv.map_apply_eq_iff_map_symm_apply_eq
code: theorem map_apply_eq_iff_map_symm_apply_eq (e : α ≃ᵐ β) : μ.map e = ν ↔ ν.map e.symm = μ 
goal: MeasureTheory.Measure.map (⇑e) μ = ν ↔ MeasureTheory.Measure.map (⇑e.symm) ν = μ

full_name: MeasurableEquiv.map_ae
code: theorem map_ae (f : α ≃ᵐ β) (μ : Measure α) : Filter.map f (ae μ) = ae (map f μ) 
goal: Filter.map (⇑f) (MeasureTheory.ae μ) = MeasureTheory.ae (MeasureTheory.Measure.map (⇑f) μ)

full_name: MeasurableEquiv.quasiMeasurePreserving_symm
code: theorem quasiMeasurePreserving_symm (μ : Measure α) (e : α ≃ᵐ β) :
    QuasiMeasurePreserving e.symm (map e μ) μ 
goal: MeasureTheory.Measure.QuasiMeasurePreserving (⇑e.symm) (MeasureTheory.Measure.map (⇑e) μ) μ

full_name: MeasureTheory.OuterMeasure.toMeasure_zero
code: theorem OuterMeasure.toMeasure_zero [MeasurableSpace α] :
    (0 : OuterMeasure α).toMeasure (le_top.trans OuterMeasure.zero_caratheodory.symm.le) = 0 
goal: MeasureTheory.OuterMeasure.toMeasure 0 ⋯ = 0