File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

full_name: MeasureTheory.extend
code: /-- We can trivially extend a function defined on a subclass of objects (with codomain `ℝ≥0∞`)
  to all objects by defining it to be `∞` on the objects not in the class. -/
def extend (s : α) : ℝ≥0∞ 
goal: ℝ≥0∞

full_name: MeasureTheory.extend_eq
code: theorem extend_eq {s : α} (h : P s) : extend m s = m s h 
goal: MeasureTheory.extend m s = m s h

full_name: MeasureTheory.extend_eq_top
code: theorem extend_eq_top {s : α} (h : ¬P s) : extend m s = ∞ 
goal: MeasureTheory.extend m s = ⊤

full_name: MeasureTheory.smul_extend
code: theorem smul_extend {R} [Zero R] [SMulWithZero R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞]
    [NoZeroSMulDivisors R ℝ≥0∞] {c : R} (hc : c ≠ 0) :
    c • extend m = extend fun s h => c • m s h 
goal: c • MeasureTheory.extend m = MeasureTheory.extend fun s h => c • m s h

full_name: MeasureTheory.le_extend
code: theorem le_extend {s : α} (h : P s) : m s h ≤ extend m s 
goal: m s h ≤ MeasureTheory.extend m s

full_name: MeasureTheory.extend_congr
code: theorem extend_congr {β : Type*} {Pb : β → Prop} {mb : ∀ s : β, Pb s → ℝ≥0∞} {sa : α} {sb : β}
    (hP : P sa ↔ Pb sb) (hm : ∀ (ha : P sa) (hb : Pb sb), m sa ha = mb sb hb) :
    extend m sa = extend mb sb 
goal: MeasureTheory.extend m sa = MeasureTheory.extend mb sb

full_name: MeasureTheory.extend_top
code: @[simp]
theorem extend_top {α : Type*} {P : α → Prop} : extend (fun _ _ => ∞ : ∀ s : α, P s → ℝ≥0∞) = ⊤ 
goal: (MeasureTheory.extend fun x x => ⊤) = ⊤

full_name: MeasureTheory.extend_empty
code: theorem extend_empty : extend m ∅ = 0 
goal: MeasureTheory.extend m ∅ = 0

full_name: MeasureTheory.extend_iUnion_nat
code: theorem extend_iUnion_nat {f : ℕ → Set α} (hm : ∀ i, P (f i))
    (mU : m (⋃ i, f i) (PU hm) = ∑' i, m (f i) (hm i)) :
    extend m (⋃ i, f i) = ∑' i, extend m (f i) 
goal: MeasureTheory.extend m (⋃ i, f i) = ∑' (i : ℕ), MeasureTheory.extend m (f i)

full_name: MeasureTheory.extend_iUnion_le_tsum_nat'
code: theorem extend_iUnion_le_tsum_nat' (s : ℕ → Set α) :
    extend m (⋃ i, s i) ≤ ∑' i, extend m (s i) 
goal: MeasureTheory.extend m (⋃ i, s i) ≤ ∑' (i : ℕ), MeasureTheory.extend m (s i)

full_name: MeasureTheory.extend_mono'
code: theorem extend_mono' ⦃s₁ s₂ : Set α⦄ (h₁ : P s₁) (hs : s₁ ⊆ s₂) : extend m s₁ ≤ extend m s₂ 
goal: MeasureTheory.extend m s₁ ≤ MeasureTheory.extend m s₂

full_name: MeasureTheory.extend_iUnion
code: theorem extend_iUnion {β} [Countable β] {f : β → Set α} (hd : Pairwise (Disjoint on f))
    (hm : ∀ i, P (f i)) : extend m (⋃ i, f i) = ∑' i, extend m (f i) 
goal: MeasureTheory.extend m (⋃ i, f i) = ∑' (i : β), MeasureTheory.extend m (f i)

full_name: MeasureTheory.extend_union
code: theorem extend_union {s₁ s₂ : Set α} (hd : Disjoint s₁ s₂) (h₁ : P s₁) (h₂ : P s₂) :
    extend m (s₁ ∪ s₂) = extend m s₁ + extend m s₂ 
goal: MeasureTheory.extend m (s₁ ∪ s₂) = MeasureTheory.extend m s₁ + MeasureTheory.extend m s₂

full_name: MeasureTheory.inducedOuterMeasure
code: /-- Given an arbitrary function on a subset of sets, we can define the outer measure corresponding
  to it (this is the unique maximal outer measure that is at most `m` on the domain of `m`). -/
def inducedOuterMeasure : OuterMeasure α 
goal: MeasureTheory.OuterMeasure α

full_name: MeasureTheory.le_inducedOuterMeasure
code: theorem le_inducedOuterMeasure {μ : OuterMeasure α} :
    μ ≤ inducedOuterMeasure m P0 m0 ↔ ∀ (s) (hs : P s), μ s ≤ m s hs 
goal: μ ≤ MeasureTheory.inducedOuterMeasure m P0 m0 ↔ ∀ (s : Set α) (hs : P s), μ s ≤ m s hs

full_name: MeasureTheory.inducedOuterMeasure_union_of_false_of_nonempty_inter
code: /-- If `P u` is `False` for any set `u` that has nonempty intersection both with `s` and `t`, then
`μ (s ∪ t) = μ s + μ t`, where `μ = inducedOuterMeasure m P0 m0`.

E.g., if `α` is an (e)metric space and `P u = diam u < r`, then this lemma implies that
`μ (s ∪ t) = μ s + μ t` on any two sets such that `r ≤ edist x y` for all `x ∈ s` and `y ∈ t`. -/
theorem inducedOuterMeasure_union_of_false_of_nonempty_inter {s t : Set α}
    (h : ∀ u, (s ∩ u).Nonempty → (t ∩ u).Nonempty → ¬P u) :
    inducedOuterMeasure m P0 m0 (s ∪ t) =
      inducedOuterMeasure m P0 m0 s + inducedOuterMeasure m P0 m0 t 
goal: (MeasureTheory.inducedOuterMeasure m P0 m0) (s ∪ t) =
  (MeasureTheory.inducedOuterMeasure m P0 m0) s + (MeasureTheory.inducedOuterMeasure m P0 m0) t

full_name: MeasureTheory.inducedOuterMeasure_eq_extend'
code: theorem inducedOuterMeasure_eq_extend' {s : Set α} (hs : P s) :
    inducedOuterMeasure m P0 m0 s = extend m s 
goal: (MeasureTheory.inducedOuterMeasure m P0 m0) s = MeasureTheory.extend m s

full_name: MeasureTheory.inducedOuterMeasure_eq'
code: theorem inducedOuterMeasure_eq' {s : Set α} (hs : P s) : inducedOuterMeasure m P0 m0 s = m s hs 
goal: (MeasureTheory.inducedOuterMeasure m P0 m0) s = m s hs

full_name: MeasureTheory.inducedOuterMeasure_eq_iInf
code: theorem inducedOuterMeasure_eq_iInf (s : Set α) :
    inducedOuterMeasure m P0 m0 s = ⨅ (t : Set α) (ht : P t) (_ : s ⊆ t), m t ht 
goal: (MeasureTheory.inducedOuterMeasure m P0 m0) s = ⨅ t, ⨅ (ht : P t), ⨅ (_ : s ⊆ t), m t ht

full_name: MeasureTheory.inducedOuterMeasure_preimage
code: theorem inducedOuterMeasure_preimage (f : α ≃ α) (Pm : ∀ s : Set α, P (f ⁻¹' s) ↔ P s)
    (mm : ∀ (s : Set α) (hs : P s), m (f ⁻¹' s) ((Pm _).mpr hs) = m s hs) {A : Set α} :
    inducedOuterMeasure m P0 m0 (f ⁻¹' A) = inducedOuterMeasure m P0 m0 A 
goal: (MeasureTheory.inducedOuterMeasure m P0 m0) (⇑f ⁻¹' A) = (MeasureTheory.inducedOuterMeasure m P0 m0) A

full_name: MeasureTheory.inducedOuterMeasure_exists_set
code: theorem inducedOuterMeasure_exists_set {s : Set α} (hs : inducedOuterMeasure m P0 m0 s ≠ ∞)
    {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∃ t : Set α,
      P t ∧ s ⊆ t ∧ inducedOuterMeasure m P0 m0 t ≤ inducedOuterMeasure m P0 m0 s + ε 
goal: ∃ t, P t ∧ s ⊆ t ∧ (MeasureTheory.inducedOuterMeasure m P0 m0) t ≤ (MeasureTheory.inducedOuterMeasure m P0 m0) s + ε

full_name: MeasureTheory.inducedOuterMeasure_caratheodory
code: /-- To test whether `s` is Carathéodory-measurable we only need to check the sets `t` for which
  `P t` holds. See `ofFunction_caratheodory` for another way to show the Carathéodory-measurability
  of `s`.
-/
theorem inducedOuterMeasure_caratheodory (s : Set α) :
    MeasurableSet[(inducedOuterMeasure m P0 m0).caratheodory] s ↔
      ∀ t : Set α,
        P t →
          inducedOuterMeasure m P0 m0 (t ∩ s) + inducedOuterMeasure m P0 m0 (t \ s) ≤
            inducedOuterMeasure m P0 m0 t 
goal: MeasurableSet s ↔
  ∀ (t : Set α),
    P t →
      (MeasureTheory.inducedOuterMeasure m P0 m0) (t ∩ s) + (MeasureTheory.inducedOuterMeasure m P0 m0) (t \ s) ≤
        (MeasureTheory.inducedOuterMeasure m P0 m0) t

full_name: MeasureTheory.extend_mono
code: theorem extend_mono {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (hs : s₁ ⊆ s₂) :
    extend m s₁ ≤ extend m s₂ 
goal: MeasureTheory.extend m s₁ ≤ MeasureTheory.extend m s₂

full_name: MeasureTheory.extend_iUnion_le_tsum_nat
code: theorem extend_iUnion_le_tsum_nat : ∀ s : ℕ → Set α,
    extend m (⋃ i, s i) ≤ ∑' i, extend m (s i) 
goal: MeasureTheory.extend m (⋃ i, s i) ≤ ∑' (i : ℕ), MeasureTheory.extend m (s i)

full_name: MeasureTheory.inducedOuterMeasure_eq_extend
code: theorem inducedOuterMeasure_eq_extend {s : Set α} (hs : MeasurableSet s) :
    inducedOuterMeasure m MeasurableSet.empty m0 s = extend m s 
goal: (MeasureTheory.inducedOuterMeasure m ⋯ m0) s = MeasureTheory.extend m s

full_name: MeasureTheory.inducedOuterMeasure_eq
code: theorem inducedOuterMeasure_eq {s : Set α} (hs : MeasurableSet s) :
    inducedOuterMeasure m MeasurableSet.empty m0 s = m s hs 
goal: (MeasureTheory.inducedOuterMeasure m ⋯ m0) s = m s hs

full_name: MeasureTheory.OuterMeasure.trim
code: /-- Given an outer measure `m` we can forget its value on non-measurable sets, and then consider
  `m.trim`, the unique maximal outer measure less than that function. -/
def trim : OuterMeasure α 
goal: MeasureTheory.OuterMeasure α

full_name: MeasureTheory.OuterMeasure.le_trim_iff
code: theorem le_trim_iff {m₁ m₂ : OuterMeasure α} :
    m₁ ≤ m₂.trim ↔ ∀ s, MeasurableSet s → m₁ s ≤ m₂ s 
goal: m₁ ≤ m₂.trim ↔ ∀ (s : Set α), MeasurableSet s → m₁ s ≤ m₂ s

full_name: MeasureTheory.OuterMeasure.le_trim
code: theorem le_trim : m ≤ m.trim 
goal: m ≤ m.trim

full_name: MeasureTheory.OuterMeasure.trim_eq
code: @[simp] -- Porting note: added `simp`
theorem trim_eq {s : Set α} (hs : MeasurableSet s) : m.trim s = m s 
goal: m.trim s = m s

full_name: MeasureTheory.OuterMeasure.trim_congr
code: theorem trim_congr {m₁ m₂ : OuterMeasure α} (H : ∀ {s : Set α}, MeasurableSet s → m₁ s = m₂ s) :
    m₁.trim = m₂.trim 
goal: m₁.trim = m₂.trim

full_name: MeasureTheory.OuterMeasure.trim_mono
code: @[mono]
theorem trim_mono : Monotone (trim : OuterMeasure α → OuterMeasure α) 
goal: Monotone MeasureTheory.OuterMeasure.trim

full_name: MeasureTheory.OuterMeasure.trim_anti_measurableSpace
code: /-- `OuterMeasure.trim` is antitone in the σ-algebra. -/
theorem trim_anti_measurableSpace (m : OuterMeasure α) {m0 m1 : MeasurableSpace α}
    (h : m0 ≤ m1) : @trim _ m1 m ≤ @trim _ m0 m 
goal: m.trim ≤ m.trim

full_name: MeasureTheory.OuterMeasure.trim_le_trim_iff
code: theorem trim_le_trim_iff {m₁ m₂ : OuterMeasure α} :
    m₁.trim ≤ m₂.trim ↔ ∀ s, MeasurableSet s → m₁ s ≤ m₂ s 
goal: m₁.trim ≤ m₂.trim ↔ ∀ (s : Set α), MeasurableSet s → m₁ s ≤ m₂ s

full_name: MeasureTheory.OuterMeasure.trim_eq_trim_iff
code: theorem trim_eq_trim_iff {m₁ m₂ : OuterMeasure α} :
    m₁.trim = m₂.trim ↔ ∀ s, MeasurableSet s → m₁ s = m₂ s 
goal: m₁.trim = m₂.trim ↔ ∀ (s : Set α), MeasurableSet s → m₁ s = m₂ s

full_name: MeasureTheory.OuterMeasure.trim_eq_iInf
code: theorem trim_eq_iInf (s : Set α) : m.trim s = ⨅ (t) (_ : s ⊆ t) (_ : MeasurableSet t), m t 
goal: m.trim s = ⨅ t, ⨅ (_ : s ⊆ t), ⨅ (_ : MeasurableSet t), m t

full_name: MeasureTheory.OuterMeasure.trim_eq_iInf'
code: theorem trim_eq_iInf' (s : Set α) : m.trim s = ⨅ t : { t // s ⊆ t ∧ MeasurableSet t }, m t 
goal: m.trim s = ⨅ t, m ↑t

full_name: MeasureTheory.OuterMeasure.trim_trim
code: theorem trim_trim (m : OuterMeasure α) : m.trim.trim = m.trim 
goal: m.trim.trim = m.trim

full_name: MeasureTheory.OuterMeasure.trim_top
code: @[simp]
theorem trim_top : (⊤ : OuterMeasure α).trim = ⊤ 
goal: ⊤.trim = ⊤

full_name: MeasureTheory.OuterMeasure.trim_zero
code: @[simp]
theorem trim_zero : (0 : OuterMeasure α).trim = 0 
goal: MeasureTheory.OuterMeasure.trim 0 = 0

full_name: MeasureTheory.OuterMeasure.trim_sum_ge
code: theorem trim_sum_ge {ι} (m : ι → OuterMeasure α) : (sum fun i => (m i).trim) ≤ (sum m).trim 
goal: (MeasureTheory.OuterMeasure.sum fun i => (m i).trim) ≤ (MeasureTheory.OuterMeasure.sum m).trim

full_name: MeasureTheory.OuterMeasure.exists_measurable_superset_eq_trim
code: theorem exists_measurable_superset_eq_trim (m : OuterMeasure α) (s : Set α) :
    ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = m.trim s 
goal: ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = m.trim s

full_name: MeasureTheory.OuterMeasure.exists_measurable_superset_of_trim_eq_zero
code: theorem exists_measurable_superset_of_trim_eq_zero {m : OuterMeasure α} {s : Set α}
    (h : m.trim s = 0) : ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = 0 
goal: ∃ t, s ⊆ t ∧ MeasurableSet t ∧ m t = 0

full_name: MeasureTheory.OuterMeasure.exists_measurable_superset_forall_eq_trim
code: /-- If `μ i` is a countable family of outer measures, then for every set `s` there exists
a measurable set `t ⊇ s` such that `μ i t = (μ i).trim s` for all `i`. -/
theorem exists_measurable_superset_forall_eq_trim {ι} [Countable ι] (μ : ι → OuterMeasure α)
    (s : Set α) : ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ i, μ i t = (μ i).trim s 
goal: ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), (μ i) t = (μ i).trim s

full_name: MeasureTheory.OuterMeasure.trim_binop
code: /-- If `m₁ s = op (m₂ s) (m₃ s)` for all `s`, then the same is true for `m₁.trim`, `m₂.trim`,
and `m₃ s`. -/
theorem trim_binop {m₁ m₂ m₃ : OuterMeasure α} {op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞}
    (h : ∀ s, m₁ s = op (m₂ s) (m₃ s)) (s : Set α) : m₁.trim s = op (m₂.trim s) (m₃.trim s) 
goal: m₁.trim s = op (m₂.trim s) (m₃.trim s)

full_name: MeasureTheory.OuterMeasure.trim_op
code: /-- If `m₁ s = op (m₂ s)` for all `s`, then the same is true for `m₁.trim` and `m₂.trim`. -/
theorem trim_op {m₁ m₂ : OuterMeasure α} {op : ℝ≥0∞ → ℝ≥0∞} (h : ∀ s, m₁ s = op (m₂ s))
    (s : Set α) : m₁.trim s = op (m₂.trim s) 
goal: m₁.trim s = op (m₂.trim s)

full_name: MeasureTheory.OuterMeasure.trim_add
code: /-- `trim` is additive. -/
theorem trim_add (m₁ m₂ : OuterMeasure α) : (m₁ + m₂).trim = m₁.trim + m₂.trim 
goal: (m₁ + m₂).trim = m₁.trim + m₂.trim

full_name: MeasureTheory.OuterMeasure.trim_smul
code: /-- `trim` respects scalar multiplication. -/
theorem trim_smul {R : Type*} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (c : R)
    (m : OuterMeasure α) : (c • m).trim = c • m.trim 
goal: (c • m).trim = c • m.trim

full_name: MeasureTheory.OuterMeasure.trim_sup
code: /-- `trim` sends the supremum of two outer measures to the supremum of the trimmed measures. -/
theorem trim_sup (m₁ m₂ : OuterMeasure α) : (m₁ ⊔ m₂).trim = m₁.trim ⊔ m₂.trim 
goal: (m₁ ⊔ m₂).trim = m₁.trim ⊔ m₂.trim

full_name: MeasureTheory.OuterMeasure.trim_iSup
code: /-- `trim` sends the supremum of a countable family of outer measures to the supremum
of the trimmed measures. -/
theorem trim_iSup {ι} [Countable ι] (μ : ι → OuterMeasure α) :
    trim (⨆ i, μ i) = ⨆ i, trim (μ i) 
goal: (⨆ i, μ i).trim = ⨆ i, (μ i).trim

full_name: MeasureTheory.OuterMeasure.restrict_trim
code: /-- The trimmed property of a measure μ states that `μ.toOuterMeasure.trim = μ.toOuterMeasure`.
This theorem shows that a restricted trimmed outer measure is a trimmed outer measure. -/
theorem restrict_trim {μ : OuterMeasure α} {s : Set α} (hs : MeasurableSet s) :
    (restrict s μ).trim = restrict s μ.trim 
goal: ((MeasureTheory.OuterMeasure.restrict s) μ).trim = (MeasureTheory.OuterMeasure.restrict s) μ.trim