File: Mathlib/MeasureTheory/Measure/Restrict.lean

full_name: MeasureTheory.Measure.restrictₗ
code: /-- Restrict a measure `μ` to a set `s` as an `ℝ≥0∞`-linear map. -/
noncomputable def restrictₗ {m0 : MeasurableSpace α} (s : Set α) : Measure α →ₗ[ℝ≥0∞] Measure α 
goal: MeasureTheory.Measure α →ₗ[ℝ≥0∞] MeasureTheory.Measure α

full_name: MeasureTheory.Measure.restrict
code: /-- Restrict a measure `μ` to a set `s`. -/
noncomputable def restrict {_m0 : MeasurableSpace α} (μ : Measure α) (s : Set α) : Measure α 
goal: MeasureTheory.Measure α

full_name: MeasureTheory.Measure.restrictₗ_apply
code: @[simp]
theorem restrictₗ_apply {_m0 : MeasurableSpace α} (s : Set α) (μ : Measure α) :
    restrictₗ s μ = μ.restrict s 
goal: (MeasureTheory.Measure.restrictₗ s) μ = μ.restrict s

full_name: MeasureTheory.Measure.restrict_toOuterMeasure_eq_toOuterMeasure_restrict
code: /-- This lemma shows that `restrict` and `toOuterMeasure` commute. Note that the LHS has a
restrict on measures and the RHS has a restrict on outer measures. -/
theorem restrict_toOuterMeasure_eq_toOuterMeasure_restrict (h : MeasurableSet s) :
    (μ.restrict s).toOuterMeasure = OuterMeasure.restrict s μ.toOuterMeasure 
goal: (μ.restrict s).toOuterMeasure = (MeasureTheory.OuterMeasure.restrict s) μ.toOuterMeasure

full_name: MeasureTheory.Measure.restrict_apply₀
code: theorem restrict_apply₀ (ht : NullMeasurableSet t (μ.restrict s)) : μ.restrict s t = μ (t ∩ s) 
goal: (μ.restrict s) t = μ (t ∩ s)

full_name: MeasureTheory.Measure.restrict_apply
code: /-- If `t` is a measurable set, then the measure of `t` with respect to the restriction of
  the measure to `s` equals the outer measure of `t ∩ s`. An alternate version requiring that `s`
  be measurable instead of `t` exists as `Measure.restrict_apply'`. -/
@[simp]
theorem restrict_apply (ht : MeasurableSet t) : μ.restrict s t = μ (t ∩ s) 
goal: (μ.restrict s) t = μ (t ∩ s)

full_name: MeasureTheory.Measure.restrict_mono'
code: /-- Restriction of a measure to a subset is monotone both in set and in measure. -/
theorem restrict_mono' {_m0 : MeasurableSpace α} ⦃s s' : Set α⦄ ⦃μ ν : Measure α⦄ (hs : s ≤ᵐ[μ] s')
    (hμν : μ ≤ ν) : μ.restrict s ≤ ν.restrict s' 
goal: μ.restrict s ≤ ν.restrict s'

full_name: MeasureTheory.Measure.restrict_mono
code: /-- Restriction of a measure to a subset is monotone both in set and in measure. -/
@[mono]
theorem restrict_mono {_m0 : MeasurableSpace α} ⦃s s' : Set α⦄ (hs : s ⊆ s') ⦃μ ν : Measure α⦄
    (hμν : μ ≤ ν) : μ.restrict s ≤ ν.restrict s' 
goal: μ.restrict s ≤ ν.restrict s'

full_name: MeasureTheory.Measure.restrict_mono_ae
code: theorem restrict_mono_ae (h : s ≤ᵐ[μ] t) : μ.restrict s ≤ μ.restrict t 
goal: μ.restrict s ≤ μ.restrict t

full_name: MeasureTheory.Measure.restrict_congr_set
code: theorem restrict_congr_set (h : s =ᵐ[μ] t) : μ.restrict s = μ.restrict t 
goal: μ.restrict s = μ.restrict t

full_name: MeasureTheory.Measure.restrict_apply'
code: /-- If `s` is a measurable set, then the outer measure of `t` with respect to the restriction of
the measure to `s` equals the outer measure of `t ∩ s`. This is an alternate version of
`Measure.restrict_apply`, requiring that `s` is measurable instead of `t`. -/
@[simp]
theorem restrict_apply' (hs : MeasurableSet s) : μ.restrict s t = μ (t ∩ s) 
goal: (μ.restrict s) t = μ (t ∩ s)

full_name: MeasureTheory.Measure.restrict_apply₀'
code: theorem restrict_apply₀' (hs : NullMeasurableSet s μ) : μ.restrict s t = μ (t ∩ s) 
goal: (μ.restrict s) t = μ (t ∩ s)

full_name: MeasureTheory.Measure.restrict_le_self
code: theorem restrict_le_self : μ.restrict s ≤ μ 
goal: μ.restrict s ≤ μ

full_name: MeasureTheory.Measure.restrict_eq_self
code: theorem restrict_eq_self (h : s ⊆ t) : μ.restrict t s = μ s 
goal: (μ.restrict t) s = μ s

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

full_name: MeasureTheory.Measure.restrict_apply_univ
code: theorem restrict_apply_univ (s : Set α) : μ.restrict s univ = μ s 
goal: (μ.restrict s) Set.univ = μ s

full_name: MeasureTheory.Measure.le_restrict_apply
code: theorem le_restrict_apply (s t : Set α) : μ (t ∩ s) ≤ μ.restrict s t 
goal: μ (t ∩ s) ≤ (μ.restrict s) t

full_name: MeasureTheory.Measure.restrict_apply_le
code: theorem restrict_apply_le (s t : Set α) : μ.restrict s t ≤ μ t 
goal: (μ.restrict s) t ≤ μ t

full_name: MeasureTheory.Measure.restrict_apply_superset
code: theorem restrict_apply_superset (h : s ⊆ t) : μ.restrict s t = μ s 
goal: (μ.restrict s) t = μ s

full_name: MeasureTheory.Measure.restrict_add
code: @[simp]
theorem restrict_add {_m0 : MeasurableSpace α} (μ ν : Measure α) (s : Set α) :
    (μ + ν).restrict s = μ.restrict s + ν.restrict s 
goal: (μ + ν).restrict s = μ.restrict s + ν.restrict s

full_name: MeasureTheory.Measure.restrict_zero
code: @[simp]
theorem restrict_zero {_m0 : MeasurableSpace α} (s : Set α) : (0 : Measure α).restrict s = 0 
goal: MeasureTheory.Measure.restrict 0 s = 0

full_name: MeasureTheory.Measure.restrict_smul
code: @[simp]
theorem restrict_smul {_m0 : MeasurableSpace α} (c : ℝ≥0∞) (μ : Measure α) (s : Set α) :
    (c • μ).restrict s = c • μ.restrict s 
goal: (c • μ).restrict s = c • μ.restrict s

full_name: MeasureTheory.Measure.restrict_restrict₀
code: theorem restrict_restrict₀ (hs : NullMeasurableSet s (μ.restrict t)) :
    (μ.restrict t).restrict s = μ.restrict (s ∩ t) 
goal: (μ.restrict t).restrict s = μ.restrict (s ∩ t)

full_name: MeasureTheory.Measure.restrict_restrict
code: @[simp]
theorem restrict_restrict (hs : MeasurableSet s) : (μ.restrict t).restrict s = μ.restrict (s ∩ t) 
goal: (μ.restrict t).restrict s = μ.restrict (s ∩ t)

full_name: MeasureTheory.Measure.restrict_restrict_of_subset
code: theorem restrict_restrict_of_subset (h : s ⊆ t) : (μ.restrict t).restrict s = μ.restrict s 
goal: (μ.restrict t).restrict s = μ.restrict s

full_name: MeasureTheory.Measure.restrict_restrict₀'
code: theorem restrict_restrict₀' (ht : NullMeasurableSet t μ) :
    (μ.restrict t).restrict s = μ.restrict (s ∩ t) 
goal: (μ.restrict t).restrict s = μ.restrict (s ∩ t)

full_name: MeasureTheory.Measure.restrict_restrict'
code: theorem restrict_restrict' (ht : MeasurableSet t) :
    (μ.restrict t).restrict s = μ.restrict (s ∩ t) 
goal: (μ.restrict t).restrict s = μ.restrict (s ∩ t)

full_name: MeasureTheory.Measure.restrict_comm
code: theorem restrict_comm (hs : MeasurableSet s) :
    (μ.restrict t).restrict s = (μ.restrict s).restrict t 
goal: (μ.restrict t).restrict s = (μ.restrict s).restrict t

full_name: MeasureTheory.Measure.restrict_apply_eq_zero
code: theorem restrict_apply_eq_zero (ht : MeasurableSet t) : μ.restrict s t = 0 ↔ μ (t ∩ s) = 0 
goal: (μ.restrict s) t = 0 ↔ μ (t ∩ s) = 0

full_name: MeasureTheory.Measure.measure_inter_eq_zero_of_restrict
code: theorem measure_inter_eq_zero_of_restrict (h : μ.restrict s t = 0) : μ (t ∩ s) = 0 
goal: μ (t ∩ s) = 0

full_name: MeasureTheory.Measure.restrict_apply_eq_zero'
code: theorem restrict_apply_eq_zero' (hs : MeasurableSet s) : μ.restrict s t = 0 ↔ μ (t ∩ s) = 0 
goal: (μ.restrict s) t = 0 ↔ μ (t ∩ s) = 0

full_name: MeasureTheory.Measure.restrict_eq_zero
code: @[simp]
theorem restrict_eq_zero : μ.restrict s = 0 ↔ μ s = 0 
goal: μ.restrict s = 0 ↔ μ s = 0

full_name: MeasureTheory.Measure.restrict.neZero
code: /-- If `μ s ≠ 0`, then `μ.restrict s ≠ 0`, in terms of `NeZero` instances. -/
instance restrict.neZero [NeZero (μ s)] : NeZero (μ.restrict s) 
goal: NeZero (μ.restrict s)

full_name: MeasureTheory.Measure.restrict_zero_set
code: theorem restrict_zero_set {s : Set α} (h : μ s = 0) : μ.restrict s = 0 
goal: μ.restrict s = 0

full_name: MeasureTheory.Measure.restrict_empty
code: @[simp]
theorem restrict_empty : μ.restrict ∅ = 0 
goal: μ.restrict ∅ = 0

full_name: MeasureTheory.Measure.restrict_univ
code: @[simp]
theorem restrict_univ : μ.restrict univ = μ 
goal: μ.restrict Set.univ = μ

full_name: MeasureTheory.Measure.restrict_inter_add_diff₀
code: theorem restrict_inter_add_diff₀ (s : Set α) (ht : NullMeasurableSet t μ) :
    μ.restrict (s ∩ t) + μ.restrict (s \ t) = μ.restrict s 
goal: μ.restrict (s ∩ t) + μ.restrict (s \ t) = μ.restrict s

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

full_name: MeasureTheory.Measure.restrict_union_add_inter₀
code: theorem restrict_union_add_inter₀ (s : Set α) (ht : NullMeasurableSet t μ) :
    μ.restrict (s ∪ t) + μ.restrict (s ∩ t) = μ.restrict s + μ.restrict t 
goal: μ.restrict (s ∪ t) + μ.restrict (s ∩ t) = μ.restrict s + μ.restrict t

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

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

full_name: MeasureTheory.Measure.restrict_union₀
code: theorem restrict_union₀ (h : AEDisjoint μ s t) (ht : NullMeasurableSet t μ) :
    μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t 
goal: μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t

full_name: MeasureTheory.Measure.restrict_union
code: theorem restrict_union (h : Disjoint s t) (ht : MeasurableSet t) :
    μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t 
goal: μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t

full_name: MeasureTheory.Measure.restrict_union'
code: theorem restrict_union' (h : Disjoint s t) (hs : MeasurableSet s) :
    μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t 
goal: μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t

full_name: MeasureTheory.Measure.restrict_add_restrict_compl
code: @[simp]
theorem restrict_add_restrict_compl (hs : MeasurableSet s) :
    μ.restrict s + μ.restrict sᶜ = μ 
goal: μ.restrict s + μ.restrict sᶜ = μ

full_name: MeasureTheory.Measure.restrict_compl_add_restrict
code: @[simp]
theorem restrict_compl_add_restrict (hs : MeasurableSet s) : μ.restrict sᶜ + μ.restrict s = μ 
goal: μ.restrict sᶜ + μ.restrict s = μ

full_name: MeasureTheory.Measure.restrict_union_le
code: theorem restrict_union_le (s s' : Set α) : μ.restrict (s ∪ s') ≤ μ.restrict s + μ.restrict s' 
goal: μ.restrict (s ∪ s') ≤ μ.restrict s + μ.restrict s'

full_name: MeasureTheory.Measure.restrict_iUnion_apply_ae
code: theorem restrict_iUnion_apply_ae [Countable ι] {s : ι → Set α} (hd : Pairwise (AEDisjoint μ on s))
    (hm : ∀ i, NullMeasurableSet (s i) μ) {t : Set α} (ht : MeasurableSet t) :
    μ.restrict (⋃ i, s i) t = ∑' i, μ.restrict (s i) t 
goal: (μ.restrict (⋃ i, s i)) t = ∑' (i : ι), (μ.restrict (s i)) t

full_name: MeasureTheory.Measure.restrict_iUnion_apply
code: theorem restrict_iUnion_apply [Countable ι] {s : ι → Set α} (hd : Pairwise (Disjoint on s))
    (hm : ∀ i, MeasurableSet (s i)) {t : Set α} (ht : MeasurableSet t) :
    μ.restrict (⋃ i, s i) t = ∑' i, μ.restrict (s i) t 
goal: (μ.restrict (⋃ i, s i)) t = ∑' (i : ι), (μ.restrict (s i)) t

full_name: MeasureTheory.Measure.restrict_iUnion_apply_eq_iSup
code: theorem restrict_iUnion_apply_eq_iSup [Countable ι] {s : ι → Set α} (hd : Directed (· ⊆ ·) s)
    {t : Set α} (ht : MeasurableSet t) : μ.restrict (⋃ i, s i) t = ⨆ i, μ.restrict (s i) t 
goal: (μ.restrict (⋃ i, s i)) t = ⨆ i, (μ.restrict (s i)) t

full_name: MeasureTheory.Measure.restrict_map
code: /-- The restriction of the pushforward measure is the pushforward of the restriction. For a version
assuming only `AEMeasurable`, see `restrict_map_of_aemeasurable`. -/
theorem restrict_map {f : α → β} (hf : Measurable f) {s : Set β} (hs : MeasurableSet s) :
    (μ.map f).restrict s = (μ.restrict <| f ⁻¹' s).map f 
goal: (MeasureTheory.Measure.map f μ).restrict s = MeasureTheory.Measure.map f (μ.restrict (f ⁻¹' s))

full_name: MeasureTheory.Measure.restrict_toMeasurable
code: theorem restrict_toMeasurable (h : μ s ≠ ∞) : μ.restrict (toMeasurable μ s) = μ.restrict s 
goal: μ.restrict (MeasureTheory.toMeasurable μ s) = μ.restrict s

full_name: MeasureTheory.Measure.restrict_eq_self_of_ae_mem
code: theorem restrict_eq_self_of_ae_mem {_m0 : MeasurableSpace α} ⦃s : Set α⦄ ⦃μ : Measure α⦄
    (hs : ∀ᵐ x ∂μ, x ∈ s) : μ.restrict s = μ 
goal: μ.restrict s = μ

full_name: MeasureTheory.Measure.restrict_congr_meas
code: theorem restrict_congr_meas (hs : MeasurableSet s) :
    μ.restrict s = ν.restrict s ↔ ∀ t ⊆ s, MeasurableSet t → μ t = ν t 
goal: μ.restrict s = ν.restrict s ↔ ∀ t ⊆ s, MeasurableSet t → μ t = ν t

full_name: MeasureTheory.Measure.restrict_congr_mono
code: theorem restrict_congr_mono (hs : s ⊆ t) (h : μ.restrict t = ν.restrict t) :
    μ.restrict s = ν.restrict s 
goal: μ.restrict s = ν.restrict s

full_name: MeasureTheory.Measure.restrict_union_congr
code: /-- If two measures agree on all measurable subsets of `s` and `t`, then they agree on all
measurable subsets of `s ∪ t`. -/
theorem restrict_union_congr :
    μ.restrict (s ∪ t) = ν.restrict (s ∪ t) ↔
      μ.restrict s = ν.restrict s ∧ μ.restrict t = ν.restrict t 
goal: μ.restrict (s ∪ t) = ν.restrict (s ∪ t) ↔ μ.restrict s = ν.restrict s ∧ μ.restrict t = ν.restrict t

full_name: MeasureTheory.Measure.restrict_finset_biUnion_congr
code: theorem restrict_finset_biUnion_congr {s : Finset ι} {t : ι → Set α} :
    μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔
      ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i) 
goal: μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔ ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i)

full_name: MeasureTheory.Measure.restrict_iUnion_congr
code: theorem restrict_iUnion_congr [Countable ι] {s : ι → Set α} :
    μ.restrict (⋃ i, s i) = ν.restrict (⋃ i, s i) ↔ ∀ i, μ.restrict (s i) = ν.restrict (s i) 
goal: μ.restrict (⋃ i, s i) = ν.restrict (⋃ i, s i) ↔ ∀ (i : ι), μ.restrict (s i) = ν.restrict (s i)

full_name: MeasureTheory.Measure.restrict_biUnion_congr
code: theorem restrict_biUnion_congr {s : Set ι} {t : ι → Set α} (hc : s.Countable) :
    μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔
      ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i) 
goal: μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔ ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i)

full_name: MeasureTheory.Measure.restrict_sUnion_congr
code: theorem restrict_sUnion_congr {S : Set (Set α)} (hc : S.Countable) :
    μ.restrict (⋃₀ S) = ν.restrict (⋃₀ S) ↔ ∀ s ∈ S, μ.restrict s = ν.restrict s 
goal: μ.restrict (⋃₀ S) = ν.restrict (⋃₀ S) ↔ ∀ s ∈ S, μ.restrict s = ν.restrict s

full_name: MeasureTheory.Measure.restrict_sInf_eq_sInf_restrict
code: /-- This lemma shows that `Inf` and `restrict` commute for measures. -/
theorem restrict_sInf_eq_sInf_restrict {m0 : MeasurableSpace α} {m : Set (Measure α)}
    (hm : m.Nonempty) (ht : MeasurableSet t) :
    (sInf m).restrict t = sInf ((fun μ : Measure α => μ.restrict t) '' m) 
goal: (sInf m).restrict t = sInf ((fun μ => μ.restrict t) '' m)

full_name: MeasureTheory.Measure.exists_mem_of_measure_ne_zero_of_ae
code: theorem exists_mem_of_measure_ne_zero_of_ae (hs : μ s ≠ 0) {p : α → Prop}
    (hp : ∀ᵐ x ∂μ.restrict s, p x) : ∃ x, x ∈ s ∧ p x 
goal: ∃ x ∈ s, p x

full_name: MeasureTheory.Measure.ext_iff_of_iUnion_eq_univ
code: /-- Two measures are equal if they have equal restrictions on a spanning collection of sets
  (formulated using `Union`). -/
theorem ext_iff_of_iUnion_eq_univ [Countable ι] {s : ι → Set α} (hs : ⋃ i, s i = univ) :
    μ = ν ↔ ∀ i, μ.restrict (s i) = ν.restrict (s i) 
goal: μ = ν ↔ ∀ (i : ι), μ.restrict (s i) = ν.restrict (s i)

full_name: MeasureTheory.Measure.ext_iff_of_biUnion_eq_univ
code: /-- Two measures are equal if they have equal restrictions on a spanning collection of sets
  (formulated using `biUnion`). -/
theorem ext_iff_of_biUnion_eq_univ {S : Set ι} {s : ι → Set α} (hc : S.Countable)
    (hs : ⋃ i ∈ S, s i = univ) : μ = ν ↔ ∀ i ∈ S, μ.restrict (s i) = ν.restrict (s i) 
goal: μ = ν ↔ ∀ i ∈ S, μ.restrict (s i) = ν.restrict (s i)

full_name: MeasureTheory.Measure.ext_iff_of_sUnion_eq_univ
code: /-- Two measures are equal if they have equal restrictions on a spanning collection of sets
  (formulated using `sUnion`). -/
theorem ext_iff_of_sUnion_eq_univ {S : Set (Set α)} (hc : S.Countable) (hs : ⋃₀ S = univ) :
    μ = ν ↔ ∀ s ∈ S, μ.restrict s = ν.restrict s 
goal: μ = ν ↔ ∀ s ∈ S, μ.restrict s = ν.restrict s

full_name: MeasureTheory.Measure.ext_of_generateFrom_of_cover
code: theorem ext_of_generateFrom_of_cover {S T : Set (Set α)} (h_gen : ‹_› = generateFrom S)
    (hc : T.Countable) (h_inter : IsPiSystem S) (hU : ⋃₀ T = univ) (htop : ∀ t ∈ T, μ t ≠ ∞)
    (ST_eq : ∀ t ∈ T, ∀ s ∈ S, μ (s ∩ t) = ν (s ∩ t)) (T_eq : ∀ t ∈ T, μ t = ν t) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_generateFrom_of_cover_subset
code: /-- Two measures are equal if they are equal on the π-system generating the σ-algebra,
  and they are both finite on an increasing spanning sequence of sets in the π-system.
  This lemma is formulated using `sUnion`. -/
theorem ext_of_generateFrom_of_cover_subset {S T : Set (Set α)} (h_gen : ‹_› = generateFrom S)
    (h_inter : IsPiSystem S) (h_sub : T ⊆ S) (hc : T.Countable) (hU : ⋃₀ T = univ)
    (htop : ∀ s ∈ T, μ s ≠ ∞) (h_eq : ∀ s ∈ S, μ s = ν s) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.ext_of_generateFrom_of_iUnion
code: /-- Two measures are equal if they are equal on the π-system generating the σ-algebra,
  and they are both finite on an increasing spanning sequence of sets in the π-system.
  This lemma is formulated using `iUnion`.
  `FiniteSpanningSetsIn.ext` is a reformulation of this lemma. -/
theorem ext_of_generateFrom_of_iUnion (C : Set (Set α)) (B : ℕ → Set α) (hA : ‹_› = generateFrom C)
    (hC : IsPiSystem C) (h1B : ⋃ i, B i = univ) (h2B : ∀ i, B i ∈ C) (hμB : ∀ i, μ (B i) ≠ ∞)
    (h_eq : ∀ s ∈ C, μ s = ν s) : μ = ν 
goal: μ = ν

full_name: MeasureTheory.Measure.restrict_sum
code: @[simp]
theorem restrict_sum (μ : ι → Measure α) {s : Set α} (hs : MeasurableSet s) :
    (sum μ).restrict s = sum fun i => (μ i).restrict s 
goal: (MeasureTheory.Measure.sum μ).restrict s = MeasureTheory.Measure.sum fun i => (μ i).restrict s

full_name: MeasureTheory.Measure.restrict_sum_of_countable
code: @[simp]
theorem restrict_sum_of_countable [Countable ι] (μ : ι → Measure α) (s : Set α) :
    (sum μ).restrict s = sum fun i => (μ i).restrict s 
goal: (MeasureTheory.Measure.sum μ).restrict s = MeasureTheory.Measure.sum fun i => (μ i).restrict s

full_name: MeasureTheory.Measure.AbsolutelyContinuous.restrict
code: lemma AbsolutelyContinuous.restrict (h : μ ≪ ν) (s : Set α) : μ.restrict s ≪ ν.restrict s 
goal: μ.restrict s ≪ ν.restrict s

full_name: MeasureTheory.Measure.restrict_iUnion_ae
code: theorem restrict_iUnion_ae [Countable ι] {s : ι → Set α} (hd : Pairwise (AEDisjoint μ on s))
    (hm : ∀ i, NullMeasurableSet (s i) μ) : μ.restrict (⋃ i, s i) = sum fun i => μ.restrict (s i) 
goal: μ.restrict (⋃ i, s i) = MeasureTheory.Measure.sum fun i => μ.restrict (s i)

full_name: MeasureTheory.Measure.restrict_iUnion
code: theorem restrict_iUnion [Countable ι] {s : ι → Set α} (hd : Pairwise (Disjoint on s))
    (hm : ∀ i, MeasurableSet (s i)) : μ.restrict (⋃ i, s i) = sum fun i => μ.restrict (s i) 
goal: μ.restrict (⋃ i, s i) = MeasureTheory.Measure.sum fun i => μ.restrict (s i)

full_name: MeasureTheory.Measure.restrict_iUnion_le
code: theorem restrict_iUnion_le [Countable ι] {s : ι → Set α} :
    μ.restrict (⋃ i, s i) ≤ sum fun i => μ.restrict (s i) 
goal: μ.restrict (⋃ i, s i) ≤ MeasureTheory.Measure.sum fun i => μ.restrict (s i)

full_name: MeasureTheory.ae_restrict_iUnion_eq
code: @[simp]
theorem ae_restrict_iUnion_eq [Countable ι] (s : ι → Set α) :
    ae (μ.restrict (⋃ i, s i)) = ⨆ i, ae (μ.restrict (s i)) 
goal: MeasureTheory.ae (μ.restrict (⋃ i, s i)) = ⨆ i, MeasureTheory.ae (μ.restrict (s i))

full_name: MeasureTheory.ae_restrict_union_eq
code: @[simp]
theorem ae_restrict_union_eq (s t : Set α) :
    ae (μ.restrict (s ∪ t)) = ae (μ.restrict s) ⊔ ae (μ.restrict t) 
goal: MeasureTheory.ae (μ.restrict (s ∪ t)) = MeasureTheory.ae (μ.restrict s) ⊔ MeasureTheory.ae (μ.restrict t)

full_name: MeasureTheory.ae_restrict_biUnion_eq
code: theorem ae_restrict_biUnion_eq (s : ι → Set α) {t : Set ι} (ht : t.Countable) :
    ae (μ.restrict (⋃ i ∈ t, s i)) = ⨆ i ∈ t, ae (μ.restrict (s i)) 
goal: MeasureTheory.ae (μ.restrict (⋃ i ∈ t, s i)) = ⨆ i ∈ t, MeasureTheory.ae (μ.restrict (s i))

full_name: MeasureTheory.ae_restrict_biUnion_finset_eq
code: theorem ae_restrict_biUnion_finset_eq (s : ι → Set α) (t : Finset ι) :
    ae (μ.restrict (⋃ i ∈ t, s i)) = ⨆ i ∈ t, ae (μ.restrict (s i)) 
goal: MeasureTheory.ae (μ.restrict (⋃ i ∈ t, s i)) = ⨆ i ∈ t, MeasureTheory.ae (μ.restrict (s i))

full_name: MeasureTheory.ae_restrict_iUnion_iff
code: theorem ae_restrict_iUnion_iff [Countable ι] (s : ι → Set α) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (⋃ i, s i), p x) ↔ ∀ i, ∀ᵐ x ∂μ.restrict (s i), p x 
goal: (∀ᵐ (x : α) ∂μ.restrict (⋃ i, s i), p x) ↔ ∀ (i : ι), ∀ᵐ (x : α) ∂μ.restrict (s i), p x

full_name: MeasureTheory.ae_restrict_union_iff
code: theorem ae_restrict_union_iff (s t : Set α) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (s ∪ t), p x) ↔ (∀ᵐ x ∂μ.restrict s, p x) ∧ ∀ᵐ x ∂μ.restrict t, p x 
goal: (∀ᵐ (x : α) ∂μ.restrict (s ∪ t), p x) ↔ (∀ᵐ (x : α) ∂μ.restrict s, p x) ∧ ∀ᵐ (x : α) ∂μ.restrict t, p x

full_name: MeasureTheory.ae_restrict_biUnion_iff
code: theorem ae_restrict_biUnion_iff (s : ι → Set α) {t : Set ι} (ht : t.Countable) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (⋃ i ∈ t, s i), p x) ↔ ∀ i ∈ t, ∀ᵐ x ∂μ.restrict (s i), p x 
goal: (∀ᵐ (x : α) ∂μ.restrict (⋃ i ∈ t, s i), p x) ↔ ∀ i ∈ t, ∀ᵐ (x : α) ∂μ.restrict (s i), p x

full_name: MeasureTheory.ae_restrict_biUnion_finset_iff
code: @[simp]
theorem ae_restrict_biUnion_finset_iff (s : ι → Set α) (t : Finset ι) (p : α → Prop) :
    (∀ᵐ x ∂μ.restrict (⋃ i ∈ t, s i), p x) ↔ ∀ i ∈ t, ∀ᵐ x ∂μ.restrict (s i), p x 
goal: (∀ᵐ (x : α) ∂μ.restrict (⋃ i ∈ t, s i), p x) ↔ ∀ i ∈ t, ∀ᵐ (x : α) ∂μ.restrict (s i), p x

full_name: MeasureTheory.ae_eq_restrict_iUnion_iff
code: theorem ae_eq_restrict_iUnion_iff [Countable ι] (s : ι → Set α) (f g : α → δ) :
    f =ᵐ[μ.restrict (⋃ i, s i)] g ↔ ∀ i, f =ᵐ[μ.restrict (s i)] g 
goal: f =ᵐ[μ.restrict (⋃ i, s i)] g ↔ ∀ (i : ι), f =ᵐ[μ.restrict (s i)] g

full_name: MeasureTheory.ae_eq_restrict_biUnion_iff
code: theorem ae_eq_restrict_biUnion_iff (s : ι → Set α) {t : Set ι} (ht : t.Countable) (f g : α → δ) :
    f =ᵐ[μ.restrict (⋃ i ∈ t, s i)] g ↔ ∀ i ∈ t, f =ᵐ[μ.restrict (s i)] g 
goal: f =ᵐ[μ.restrict (⋃ i ∈ t, s i)] g ↔ ∀ i ∈ t, f =ᵐ[μ.restrict (s i)] g

full_name: MeasureTheory.ae_eq_restrict_biUnion_finset_iff
code: theorem ae_eq_restrict_biUnion_finset_iff (s : ι → Set α) (t : Finset ι) (f g : α → δ) :
    f =ᵐ[μ.restrict (⋃ i ∈ t, s i)] g ↔ ∀ i ∈ t, f =ᵐ[μ.restrict (s i)] g 
goal: f =ᵐ[μ.restrict (⋃ i ∈ t, s i)] g ↔ ∀ i ∈ t, f =ᵐ[μ.restrict (s i)] g

full_name: MeasureTheory.ae_restrict_uIoc_eq
code: theorem ae_restrict_uIoc_eq [LinearOrder α] (a b : α) :
    ae (μ.restrict (Ι a b)) = ae (μ.restrict (Ioc a b)) ⊔ ae (μ.restrict (Ioc b a)) 
goal: MeasureTheory.ae (μ.restrict (Ι a b)) =
  MeasureTheory.ae (μ.restrict (Set.Ioc a b)) ⊔ MeasureTheory.ae (μ.restrict (Set.Ioc b a))

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

full_name: MeasureTheory.ae_restrict_iff₀
code: theorem ae_restrict_iff₀ {p : α → Prop} (hp : NullMeasurableSet { x | p x } (μ.restrict s)) :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ x ∂μ, x ∈ s → p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x

full_name: MeasureTheory.ae_restrict_iff
code: theorem ae_restrict_iff {p : α → Prop} (hp : MeasurableSet { x | p x }) :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ x ∂μ, x ∈ s → p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x

full_name: MeasureTheory.ae_imp_of_ae_restrict
code: theorem ae_imp_of_ae_restrict {s : Set α} {p : α → Prop} (h : ∀ᵐ x ∂μ.restrict s, p x) :
    ∀ᵐ x ∂μ, x ∈ s → p x 
goal: ∀ᵐ (x : α) ∂μ, x ∈ s → p x

full_name: MeasureTheory.ae_restrict_iff'₀
code: theorem ae_restrict_iff'₀ {p : α → Prop} (hs : NullMeasurableSet s μ) :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ x ∂μ, x ∈ s → p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x

full_name: MeasureTheory.ae_restrict_iff'
code: theorem ae_restrict_iff' {p : α → Prop} (hs : MeasurableSet s) :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ x ∂μ, x ∈ s → p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ, x ∈ s → p x

full_name: Filter.EventuallyEq.restrict
code: theorem _root_.Filter.EventuallyEq.restrict {f g : α → δ} {s : Set α} (hfg : f =ᵐ[μ] g) :
    f =ᵐ[μ.restrict s] g 
goal: f =ᵐ[μ.restrict s] g

full_name: MeasureTheory.ae_restrict_mem₀
code: theorem ae_restrict_mem₀ (hs : NullMeasurableSet s μ) : ∀ᵐ x ∂μ.restrict s, x ∈ s 
goal: ∀ᵐ (x : α) ∂μ.restrict s, x ∈ s

full_name: MeasureTheory.ae_restrict_mem
code: theorem ae_restrict_mem (hs : MeasurableSet s) : ∀ᵐ x ∂μ.restrict s, x ∈ s 
goal: ∀ᵐ (x : α) ∂μ.restrict s, x ∈ s

full_name: MeasureTheory.ae_restrict_of_ae
code: theorem ae_restrict_of_ae {s : Set α} {p : α → Prop} (h : ∀ᵐ x ∂μ, p x) : ∀ᵐ x ∂μ.restrict s, p x 
goal: ∀ᵐ (x : α) ∂μ.restrict s, p x

full_name: MeasureTheory.ae_restrict_of_ae_restrict_of_subset
code: theorem ae_restrict_of_ae_restrict_of_subset {s t : Set α} {p : α → Prop} (hst : s ⊆ t)
    (h : ∀ᵐ x ∂μ.restrict t, p x) : ∀ᵐ x ∂μ.restrict s, p x 
goal: ∀ᵐ (x : α) ∂μ.restrict s, p x

full_name: MeasureTheory.ae_of_ae_restrict_of_ae_restrict_compl
code: theorem ae_of_ae_restrict_of_ae_restrict_compl (t : Set α) {p : α → Prop}
    (ht : ∀ᵐ x ∂μ.restrict t, p x) (htc : ∀ᵐ x ∂μ.restrict tᶜ, p x) : ∀ᵐ x ∂μ, p x 
goal: ∀ᵐ (x : α) ∂μ, p x

full_name: MeasureTheory.mem_map_restrict_ae_iff
code: theorem mem_map_restrict_ae_iff {β} {s : Set α} {t : Set β} {f : α → β} (hs : MeasurableSet s) :
    t ∈ Filter.map f (ae (μ.restrict s)) ↔ μ ((f ⁻¹' t)ᶜ ∩ s) = 0 
goal: t ∈ Filter.map f (MeasureTheory.ae (μ.restrict s)) ↔ μ ((f ⁻¹' t)ᶜ ∩ s) = 0

full_name: MeasureTheory.ae_smul_measure
code: theorem ae_smul_measure {p : α → Prop} [Monoid R] [DistribMulAction R ℝ≥0∞]
    [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (h : ∀ᵐ x ∂μ, p x) (c : R) : ∀ᵐ x ∂c • μ, p x 
goal: ∀ᵐ (x : α) ∂c • μ, p x

full_name: MeasureTheory.ae_add_measure_iff
code: theorem ae_add_measure_iff {p : α → Prop} {ν} :
    (∀ᵐ x ∂μ + ν, p x) ↔ (∀ᵐ x ∂μ, p x) ∧ ∀ᵐ x ∂ν, p x 
goal: (∀ᵐ (x : α) ∂μ + ν, p x) ↔ (∀ᵐ (x : α) ∂μ, p x) ∧ ∀ᵐ (x : α) ∂ν, p x

full_name: MeasureTheory.ae_eq_comp'
code: theorem ae_eq_comp' {ν : Measure β} {f : α → β} {g g' : β → δ} (hf : AEMeasurable f μ)
    (h : g =ᵐ[ν] g') (h2 : μ.map f ≪ ν) : g ∘ f =ᵐ[μ] g' ∘ f 
goal: g ∘ f =ᵐ[μ] g' ∘ f

full_name: MeasureTheory.Measure.QuasiMeasurePreserving.ae_eq_comp
code: theorem Measure.QuasiMeasurePreserving.ae_eq_comp {ν : Measure β} {f : α → β} {g g' : β → δ}
    (hf : QuasiMeasurePreserving f μ ν) (h : g =ᵐ[ν] g') : g ∘ f =ᵐ[μ] g' ∘ f 
goal: g ∘ f =ᵐ[μ] g' ∘ f

full_name: MeasureTheory.ae_eq_comp
code: theorem ae_eq_comp {f : α → β} {g g' : β → δ} (hf : AEMeasurable f μ) (h : g =ᵐ[μ.map f] g') :
    g ∘ f =ᵐ[μ] g' ∘ f 
goal: g ∘ f =ᵐ[μ] g' ∘ f

full_name: MeasureTheory.div_ae_eq_one
code: @[to_additive]
theorem div_ae_eq_one {β} [Group β] (f g : α → β) : f / g =ᵐ[μ] 1 ↔ f =ᵐ[μ] g 
goal: f / g =ᵐ[μ] 1 ↔ f =ᵐ[μ] g

full_name: MeasureTheory.sub_ae_eq_zero
code: @[to_additive]
theorem div_ae_eq_one {β} [Group β] (f g : α → β) : f / g =ᵐ[μ] 1 ↔ f =ᵐ[μ] g 
goal: f - g =ᵐ[μ] 0 ↔ f =ᵐ[μ] g

full_name: MeasureTheory.one_le_div_ae
code: @[to_additive sub_nonneg_ae]
lemma one_le_div_ae {β : Type*} [Group β] [LE β]
    [CovariantClass β β (Function.swap (· * ·)) (· ≤ ·)] (f g : α → β) :
    1 ≤ᵐ[μ] g / f ↔ f ≤ᵐ[μ] g 
goal: 1 ≤ᵐ[μ] g / f ↔ f ≤ᵐ[μ] g

full_name: MeasureTheory.sub_nonneg_ae
code: @[to_additive sub_nonneg_ae]
lemma one_le_div_ae {β : Type*} [Group β] [LE β]
    [CovariantClass β β (Function.swap (· * ·)) (· ≤ ·)] (f g : α → β) :
    1 ≤ᵐ[μ] g / f ↔ f ≤ᵐ[μ] g 
goal: 0 ≤ᵐ[μ] g - f ↔ f ≤ᵐ[μ] g

full_name: MeasureTheory.le_ae_restrict
code: theorem le_ae_restrict : ae μ ⊓ 𝓟 s ≤ ae (μ.restrict s) 
goal: MeasureTheory.ae μ ⊓ 𝓟 s ≤ MeasureTheory.ae (μ.restrict s)

full_name: MeasureTheory.ae_restrict_eq
code: @[simp]
theorem ae_restrict_eq (hs : MeasurableSet s) : ae (μ.restrict s) = ae μ ⊓ 𝓟 s 
goal: MeasureTheory.ae (μ.restrict s) = MeasureTheory.ae μ ⊓ 𝓟 s

full_name: MeasureTheory.ae_restrict_eq_bot
code: theorem ae_restrict_eq_bot {s} : ae (μ.restrict s) = ⊥ ↔ μ s = 0 
goal: MeasureTheory.ae (μ.restrict s) = ⊥ ↔ μ s = 0

full_name: MeasureTheory.ae_restrict_neBot
code: theorem ae_restrict_neBot {s} : (ae <| μ.restrict s).NeBot ↔ μ s ≠ 0 
goal: (MeasureTheory.ae (μ.restrict s)).NeBot ↔ μ s ≠ 0

full_name: MeasureTheory.self_mem_ae_restrict
code: theorem self_mem_ae_restrict {s} (hs : MeasurableSet s) : s ∈ ae (μ.restrict s) 
goal: s ∈ MeasureTheory.ae (μ.restrict s)

full_name: MeasureTheory.ae_restrict_of_ae_eq_of_ae_restrict
code: /-- If two measurable sets are ae_eq then any proposition that is almost everywhere true on one
is almost everywhere true on the other -/
theorem ae_restrict_of_ae_eq_of_ae_restrict {s t} (hst : s =ᵐ[μ] t) {p : α → Prop} :
    (∀ᵐ x ∂μ.restrict s, p x) → ∀ᵐ x ∂μ.restrict t, p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) → ∀ᵐ (x : α) ∂μ.restrict t, p x

full_name: MeasureTheory.ae_restrict_congr_set
code: /-- If two measurable sets are ae_eq then any proposition that is almost everywhere true on one
is almost everywhere true on the other -/
theorem ae_restrict_congr_set {s t} (hst : s =ᵐ[μ] t) {p : α → Prop} :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ x ∂μ.restrict t, p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : α) ∂μ.restrict t, p x

full_name: MeasureTheory.measure_setOf_frequently_eq_zero
code: /-- A version of the **Borel-Cantelli lemma**: if `pᵢ` is a sequence of predicates such that
`∑ μ {x | pᵢ x}` is finite, then the measure of `x` such that `pᵢ x` holds frequently as `i → ∞` (or
equivalently, `pᵢ x` holds for infinitely many `i`) is equal to zero. -/
theorem measure_setOf_frequently_eq_zero {p : ℕ → α → Prop} (hp : ∑' i, μ { x | p i x } ≠ ∞) :
    μ { x | ∃ᶠ n in atTop, p n x } = 0 
goal: μ {x | ∃ᶠ (n : ℕ) in Filter.atTop, p n x} = 0

full_name: MeasureTheory.ae_eventually_not_mem
code: /-- A version of the **Borel-Cantelli lemma**: if `sᵢ` is a sequence of sets such that
`∑ μ sᵢ` exists, then for almost all `x`, `x` does not belong to almost all `sᵢ`. -/
theorem ae_eventually_not_mem {s : ℕ → Set α} (hs : (∑' i, μ (s i)) ≠ ∞) :
    ∀ᵐ x ∂μ, ∀ᶠ n in atTop, x ∉ s n 
goal: ∀ᵐ (x : α) ∂μ, ∀ᶠ (n : ℕ) in Filter.atTop, x ∉ s n

full_name: MeasureTheory.NullMeasurable.measure_preimage_eq_measure_restrict_preimage_of_ae_compl_eq_const
code: lemma NullMeasurable.measure_preimage_eq_measure_restrict_preimage_of_ae_compl_eq_const
    {β : Type*} [MeasurableSpace β] {b : β} {f : α → β} {s : Set α}
    (f_mble : NullMeasurable f (μ.restrict s)) (hs : f =ᵐ[Measure.restrict μ sᶜ] (fun _ ↦ b))
    {t : Set β} (t_mble : MeasurableSet t) (ht : b ∉ t) :
    μ (f ⁻¹' t) = μ.restrict s (f ⁻¹' t) 
goal: μ (f ⁻¹' t) = (μ.restrict s) (f ⁻¹' t)

full_name: MeasureTheory.Measure.MeasurableSet.nullMeasurableSet_subtype_coe
code: theorem MeasurableSet.nullMeasurableSet_subtype_coe {t : Set s} (hs : NullMeasurableSet s μ)
    (ht : MeasurableSet t) : NullMeasurableSet ((↑) '' t) μ 
goal: MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ

full_name: MeasureTheory.Measure.NullMeasurableSet.subtype_coe
code: theorem NullMeasurableSet.subtype_coe {t : Set s} (hs : NullMeasurableSet s μ)
    (ht : NullMeasurableSet t (μ.comap Subtype.val)) : NullMeasurableSet (((↑) : s → α) '' t) μ 
goal: MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ

full_name: MeasureTheory.Measure.measure_subtype_coe_le_comap
code: theorem measure_subtype_coe_le_comap (hs : NullMeasurableSet s μ) (t : Set s) :
    μ (((↑) : s → α) '' t) ≤ μ.comap Subtype.val t 
goal: μ (Subtype.val '' t) ≤ (MeasureTheory.Measure.comap Subtype.val μ) t

full_name: MeasureTheory.Measure.measure_subtype_coe_eq_zero_of_comap_eq_zero
code: theorem measure_subtype_coe_eq_zero_of_comap_eq_zero (hs : NullMeasurableSet s μ) {t : Set s}
    (ht : μ.comap Subtype.val t = 0) : μ (((↑) : s → α) '' t) = 0 
goal: μ (Subtype.val '' t) = 0

full_name: MeasureTheory.Measure.Subtype.measureSpace
code: /-- In a measure space, one can restrict the measure to a subtype to get a new measure space.
Not registered as an instance, as there are other natural choices such as the normalized restriction
for a probability measure, or the subspace measure when restricting to a vector subspace. Enable
locally if needed with `attribute [local instance] Measure.Subtype.measureSpace`. -/
noncomputable def Subtype.measureSpace : MeasureSpace (Subtype p) 
goal: MeasureTheory.MeasureSpace (Subtype p)

full_name: MeasureTheory.Measure.Subtype.volume_def
code: theorem Subtype.volume_def : (volume : Measure u) = volume.comap Subtype.val 
goal: MeasureTheory.volume = MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume

full_name: MeasureTheory.Measure.Subtype.volume_univ
code: theorem Subtype.volume_univ (hu : NullMeasurableSet u) : volume (univ : Set u) = volume u 
goal: MeasureTheory.volume Set.univ = MeasureTheory.volume u

full_name: MeasureTheory.Measure.volume_subtype_coe_le_volume
code: theorem volume_subtype_coe_le_volume (hu : NullMeasurableSet u) (t : Set u) :
    volume (((↑) : u → δ) '' t) ≤ volume t 
goal: MeasureTheory.volume (Subtype.val '' t) ≤ MeasureTheory.volume t

full_name: MeasureTheory.Measure.volume_subtype_coe_eq_zero_of_volume_eq_zero
code: theorem volume_subtype_coe_eq_zero_of_volume_eq_zero (hu : NullMeasurableSet u) {t : Set u}
    (ht : volume t = 0) : volume (((↑) : u → δ) '' t) = 0 
goal: MeasureTheory.volume (Subtype.val '' t) = 0

full_name: MeasurableEmbedding.map_comap
code: theorem map_comap (μ : Measure β) : (comap f μ).map f = μ.restrict (range f) 
goal: MeasureTheory.Measure.map f (MeasureTheory.Measure.comap f μ) = μ.restrict (Set.range f)

full_name: MeasurableEmbedding.comap_apply
code: theorem comap_apply (μ : Measure β) (s : Set α) : comap f μ s = μ (f '' s) 
goal: (MeasureTheory.Measure.comap f μ) s = μ (f '' s)

full_name: MeasurableEmbedding.comap_map
code: theorem comap_map (μ : Measure α) : (map f μ).comap f = μ 
goal: MeasureTheory.Measure.comap f (MeasureTheory.Measure.map f μ) = μ

full_name: MeasurableEmbedding.ae_map_iff
code: theorem ae_map_iff {p : β → Prop} {μ : Measure α} : (∀ᵐ x ∂μ.map f, p x) ↔ ∀ᵐ x ∂μ, p (f x) 
goal: (∀ᵐ (x : β) ∂MeasureTheory.Measure.map f μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p (f x)

full_name: MeasurableEmbedding.restrict_map
code: theorem restrict_map (μ : Measure α) (s : Set β) :
    (μ.map f).restrict s = (μ.restrict <| f ⁻¹' s).map f 
goal: (MeasureTheory.Measure.map f μ).restrict s = MeasureTheory.Measure.map f (μ.restrict (f ⁻¹' s))

full_name: MeasurableEmbedding.comap_preimage
code: protected theorem comap_preimage (μ : Measure β) (s : Set β) :
    μ.comap f (f ⁻¹' s) = μ (s ∩ range f) 
goal: (MeasureTheory.Measure.comap f μ) (f ⁻¹' s) = μ (s ∩ Set.range f)

full_name: MeasurableEmbedding.comap_restrict
code: lemma comap_restrict (μ : Measure β) (s : Set β) :
    (μ.restrict s).comap f = (μ.comap f).restrict (f ⁻¹' s) 
goal: MeasureTheory.Measure.comap f (μ.restrict s) = (MeasureTheory.Measure.comap f μ).restrict (f ⁻¹' s)

full_name: MeasurableEmbedding.restrict_comap
code: lemma restrict_comap (μ : Measure β) (s : Set α) :
    (μ.comap f).restrict s = (μ.restrict (f '' s)).comap f 
goal: (MeasureTheory.Measure.comap f μ).restrict s = MeasureTheory.Measure.comap f (μ.restrict (f '' s))

full_name: MeasurableEquiv.restrict_map
code: theorem _root_.MeasurableEquiv.restrict_map (e : α ≃ᵐ β) (μ : Measure α) (s : Set β) :
    (μ.map e).restrict s = (μ.restrict <| e ⁻¹' s).map e 
goal: (MeasureTheory.Measure.map (⇑e) μ).restrict s = MeasureTheory.Measure.map (⇑e) (μ.restrict (⇑e ⁻¹' s))

full_name: comap_subtype_coe_apply
code: theorem comap_subtype_coe_apply {_m0 : MeasurableSpace α} {s : Set α} (hs : MeasurableSet s)
    (μ : Measure α) (t : Set s) : comap (↑) μ t = μ ((↑) '' t) 
goal: (MeasureTheory.Measure.comap Subtype.val μ) t = μ (Subtype.val '' t)

full_name: map_comap_subtype_coe
code: theorem map_comap_subtype_coe {m0 : MeasurableSpace α} {s : Set α} (hs : MeasurableSet s)
    (μ : Measure α) : (comap (↑) μ).map ((↑) : s → α) = μ.restrict s 
goal: MeasureTheory.Measure.map Subtype.val (MeasureTheory.Measure.comap Subtype.val μ) = μ.restrict s

full_name: ae_restrict_iff_subtype
code: theorem ae_restrict_iff_subtype {m0 : MeasurableSpace α} {μ : Measure α} {s : Set α}
    (hs : MeasurableSet s) {p : α → Prop} :
    (∀ᵐ x ∂μ.restrict s, p x) ↔ ∀ᵐ (x : s) ∂comap ((↑) : s → α) μ, p x 
goal: (∀ᵐ (x : α) ∂μ.restrict s, p x) ↔ ∀ᵐ (x : ↑s) ∂MeasureTheory.Measure.comap Subtype.val μ, p ↑x

full_name: volume_set_coe_def
code: theorem volume_set_coe_def (s : Set α) : (volume : Measure s) = comap ((↑) : s → α) volume 
goal: MeasureTheory.volume = MeasureTheory.Measure.comap Subtype.val MeasureTheory.volume

full_name: MeasurableSet.map_coe_volume
code: theorem MeasurableSet.map_coe_volume {s : Set α} (hs : MeasurableSet s) :
    volume.map ((↑) : s → α) = restrict volume s 
goal: MeasureTheory.Measure.map Subtype.val MeasureTheory.volume = MeasureTheory.volume.restrict s

full_name: volume_image_subtype_coe
code: theorem volume_image_subtype_coe {s : Set α} (hs : MeasurableSet s) (t : Set s) :
    volume ((↑) '' t : Set α) = volume t 
goal: MeasureTheory.volume (Subtype.val '' t) = MeasureTheory.volume t

full_name: volume_preimage_coe
code: @[simp]
theorem volume_preimage_coe (hs : NullMeasurableSet s) (ht : MeasurableSet t) :
    volume (((↑) : s → α) ⁻¹' t) = volume (t ∩ s) 
goal: MeasureTheory.volume (Subtype.val ⁻¹' t) = MeasureTheory.volume (t ∩ s)

full_name: piecewise_ae_eq_restrict
code: theorem piecewise_ae_eq_restrict [DecidablePred (· ∈ s)] (hs : MeasurableSet s) :
    piecewise s f g =ᵐ[μ.restrict s] f 
goal: s.piecewise f g =ᵐ[μ.restrict s] f

full_name: piecewise_ae_eq_restrict_compl
code: theorem piecewise_ae_eq_restrict_compl [DecidablePred (· ∈ s)] (hs : MeasurableSet s) :
    piecewise s f g =ᵐ[μ.restrict sᶜ] g 
goal: s.piecewise f g =ᵐ[μ.restrict sᶜ] g

full_name: piecewise_ae_eq_of_ae_eq_set
code: theorem piecewise_ae_eq_of_ae_eq_set [DecidablePred (· ∈ s)] [DecidablePred (· ∈ t)]
    (hst : s =ᵐ[μ] t) : s.piecewise f g =ᵐ[μ] t.piecewise f g 
goal: s.piecewise f g =ᵐ[μ] t.piecewise f g

full_name: mem_map_indicator_ae_iff_mem_map_restrict_ae_of_zero_mem
code: theorem mem_map_indicator_ae_iff_mem_map_restrict_ae_of_zero_mem [Zero β] {t : Set β}
    (ht : (0 : β) ∈ t) (hs : MeasurableSet s) :
    t ∈ Filter.map (s.indicator f) (ae μ) ↔ t ∈ Filter.map f (ae <| μ.restrict s) 
goal: t ∈ Filter.map (s.indicator f) (MeasureTheory.ae μ) ↔ t ∈ Filter.map f (MeasureTheory.ae (μ.restrict s))

full_name: mem_map_indicator_ae_iff_of_zero_nmem
code: theorem mem_map_indicator_ae_iff_of_zero_nmem [Zero β] {t : Set β} (ht : (0 : β) ∉ t) :
    t ∈ Filter.map (s.indicator f) (ae μ) ↔ μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0 
goal: t ∈ Filter.map (s.indicator f) (MeasureTheory.ae μ) ↔ μ ((f ⁻¹' t)ᶜ ∪ sᶜ) = 0

full_name: map_restrict_ae_le_map_indicator_ae
code: theorem map_restrict_ae_le_map_indicator_ae [Zero β] (hs : MeasurableSet s) :
    Filter.map f (ae <| μ.restrict s) ≤ Filter.map (s.indicator f) (ae μ) 
goal: Filter.map f (MeasureTheory.ae (μ.restrict s)) ≤ Filter.map (s.indicator f) (MeasureTheory.ae μ)

full_name: indicator_ae_eq_restrict
code: theorem indicator_ae_eq_restrict (hs : MeasurableSet s) : indicator s f =ᵐ[μ.restrict s] f 
goal: s.indicator f =ᵐ[μ.restrict s] f

full_name: indicator_ae_eq_restrict_compl
code: theorem indicator_ae_eq_restrict_compl (hs : MeasurableSet s) :
    indicator s f =ᵐ[μ.restrict sᶜ] 0 
goal: s.indicator f =ᵐ[μ.restrict sᶜ] 0

full_name: indicator_ae_eq_of_restrict_compl_ae_eq_zero
code: theorem indicator_ae_eq_of_restrict_compl_ae_eq_zero (hs : MeasurableSet s)
    (hf : f =ᵐ[μ.restrict sᶜ] 0) : s.indicator f =ᵐ[μ] f 
goal: s.indicator f =ᵐ[μ] f

full_name: indicator_ae_eq_zero_of_restrict_ae_eq_zero
code: theorem indicator_ae_eq_zero_of_restrict_ae_eq_zero (hs : MeasurableSet s)
    (hf : f =ᵐ[μ.restrict s] 0) : s.indicator f =ᵐ[μ] 0 
goal: s.indicator f =ᵐ[μ] 0

full_name: indicator_ae_eq_of_ae_eq_set
code: theorem indicator_ae_eq_of_ae_eq_set (hst : s =ᵐ[μ] t) : s.indicator f =ᵐ[μ] t.indicator f 
goal: s.indicator f =ᵐ[μ] t.indicator f

full_name: indicator_meas_zero
code: theorem indicator_meas_zero (hs : μ s = 0) : indicator s f =ᵐ[μ] 0 
goal: s.indicator f =ᵐ[μ] 0

full_name: ae_eq_restrict_iff_indicator_ae_eq
code: theorem ae_eq_restrict_iff_indicator_ae_eq {g : α → β} (hs : MeasurableSet s) :
    f =ᵐ[μ.restrict s] g ↔ s.indicator f =ᵐ[μ] s.indicator g 
goal: f =ᵐ[μ.restrict s] g ↔ s.indicator f =ᵐ[μ] s.indicator g