File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

full_name: MeasurableSpace
code: /-- A measurable space is a space equipped with a σ-algebra. -/
@[class] structure MeasurableSpace (α : Type*) where
  /-- Predicate saying that a given set is measurable. Use `MeasurableSet` in the root namespace
  instead. -/
  MeasurableSet' : Set α → Prop
  /-- The empty set is a measurable set. Use `MeasurableSet.empty` instead. -/
  measurableSet_empty : MeasurableSet' ∅
  /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' sᶜ
  /-- The union of a sequence of measurable sets is a measurable set. Use a more general
  `MeasurableSet.iUnion` instead. -/
  measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
goal: Type u_7

full_name: MeasurableSpace.measurableSet_iUnion
code: /-- A measurable space is a space equipped with a σ-algebra. -/
@[class] structure MeasurableSpace (α : Type*) where
  /-- Predicate saying that a given set is measurable. Use `MeasurableSet` in the root namespace
  instead. -/
  MeasurableSet' : Set α → Prop
  /-- The empty set is a measurable set. Use `MeasurableSet.empty` instead. -/
  measurableSet_empty : MeasurableSet' ∅
  /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' sᶜ
  /-- The union of a sequence of measurable sets is a measurable set. Use a more general
  `MeasurableSet.iUnion` instead. -/
  measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
goal: (∀ (i : ℕ), self.MeasurableSet' (f i)) → self.MeasurableSet' (⋃ i, f i)

full_name: MeasurableSpace.measurableSet_compl
code: /-- A measurable space is a space equipped with a σ-algebra. -/
@[class] structure MeasurableSpace (α : Type*) where
  /-- Predicate saying that a given set is measurable. Use `MeasurableSet` in the root namespace
  instead. -/
  MeasurableSet' : Set α → Prop
  /-- The empty set is a measurable set. Use `MeasurableSet.empty` instead. -/
  measurableSet_empty : MeasurableSet' ∅
  /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' sᶜ
  /-- The union of a sequence of measurable sets is a measurable set. Use a more general
  `MeasurableSet.iUnion` instead. -/
  measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
goal: self.MeasurableSet' s → self.MeasurableSet' sᶜ

full_name: MeasurableSpace.MeasurableSet'
code: /-- A measurable space is a space equipped with a σ-algebra. -/
@[class] structure MeasurableSpace (α : Type*) where
  /-- Predicate saying that a given set is measurable. Use `MeasurableSet` in the root namespace
  instead. -/
  MeasurableSet' : Set α → Prop
  /-- The empty set is a measurable set. Use `MeasurableSet.empty` instead. -/
  measurableSet_empty : MeasurableSet' ∅
  /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' sᶜ
  /-- The union of a sequence of measurable sets is a measurable set. Use a more general
  `MeasurableSet.iUnion` instead. -/
  measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
goal: Set α → Prop

full_name: MeasurableSpace.measurableSet_empty
code: /-- A measurable space is a space equipped with a σ-algebra. -/
@[class] structure MeasurableSpace (α : Type*) where
  /-- Predicate saying that a given set is measurable. Use `MeasurableSet` in the root namespace
  instead. -/
  MeasurableSet' : Set α → Prop
  /-- The empty set is a measurable set. Use `MeasurableSet.empty` instead. -/
  measurableSet_empty : MeasurableSet' ∅
  /-- The complement of a measurable set is a measurable set. Use `MeasurableSet.compl` instead. -/
  measurableSet_compl : ∀ s, MeasurableSet' s → MeasurableSet' sᶜ
  /-- The union of a sequence of measurable sets is a measurable set. Use a more general
  `MeasurableSet.iUnion` instead. -/
  measurableSet_iUnion : ∀ f : ℕ → Set α, (∀ i, MeasurableSet' (f i)) → MeasurableSet' (⋃ i, f i)
goal: self.MeasurableSet' ∅

full_name: instMeasurableSpaceOrderDual
code: instance [h : MeasurableSpace α] : MeasurableSpace αᵒᵈ 
goal: MeasurableSpace αᵒᵈ

full_name: MeasurableSet
code: /-- `MeasurableSet s` means that `s` is measurable (in the ambient measure space on `α`) -/
def MeasurableSet [MeasurableSpace α] (s : Set α) : Prop 
goal: Prop

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_MeasurableSpace_Defs___macroRules_MeasureTheory_termMeasurableSet[_]_1»
code: /-- Notation for `MeasurableSet` with respect to a non-standard σ-algebra. -/
scoped notation "MeasurableSet[" m "]" => @MeasurableSet _ m
goal: Lean.Macro

full_name: MeasurableSet.empty
code: @[simp, measurability]
theorem MeasurableSet.empty [MeasurableSpace α] : MeasurableSet (∅ : Set α) 
goal: MeasurableSet ∅

full_name: MeasurableSet.compl
code: @[measurability]
protected theorem MeasurableSet.compl : MeasurableSet s → MeasurableSet sᶜ 
goal: MeasurableSet s → MeasurableSet sᶜ

full_name: MeasurableSet.of_compl
code: protected theorem MeasurableSet.of_compl (h : MeasurableSet sᶜ) : MeasurableSet s 
goal: MeasurableSet s

full_name: MeasurableSet.compl_iff
code: @[simp]
theorem MeasurableSet.compl_iff : MeasurableSet sᶜ ↔ MeasurableSet s 
goal: MeasurableSet sᶜ ↔ MeasurableSet s

full_name: MeasurableSet.univ
code: @[simp, measurability]
protected theorem MeasurableSet.univ : MeasurableSet (univ : Set α) 
goal: MeasurableSet Set.univ

full_name: Subsingleton.measurableSet
code: @[nontriviality, measurability]
theorem Subsingleton.measurableSet [Subsingleton α] {s : Set α} : MeasurableSet s 
goal: MeasurableSet s

full_name: MeasurableSet.congr
code: theorem MeasurableSet.congr {s t : Set α} (hs : MeasurableSet s) (h : s = t) : MeasurableSet t 
goal: MeasurableSet t

full_name: MeasurableSet.iUnion
code: @[measurability]
protected theorem MeasurableSet.iUnion [Countable ι] ⦃f : ι → Set α⦄
    (h : ∀ b, MeasurableSet (f b)) : MeasurableSet (⋃ b, f b) 
goal: MeasurableSet (⋃ b, f b)

full_name: MeasurableSet.biUnion
code: protected theorem MeasurableSet.biUnion {f : β → Set α} {s : Set β} (hs : s.Countable)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) 
goal: MeasurableSet (⋃ b ∈ s, f b)

full_name: Set.Finite.measurableSet_biUnion
code: theorem Set.Finite.measurableSet_biUnion {f : β → Set α} {s : Set β} (hs : s.Finite)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) 
goal: MeasurableSet (⋃ b ∈ s, f b)

full_name: Finset.measurableSet_biUnion
code: theorem Finset.measurableSet_biUnion {f : β → Set α} (s : Finset β)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋃ b ∈ s, f b) 
goal: MeasurableSet (⋃ b ∈ s, f b)

full_name: MeasurableSet.sUnion
code: protected theorem MeasurableSet.sUnion {s : Set (Set α)} (hs : s.Countable)
    (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋃₀ s) 
goal: MeasurableSet (⋃₀ s)

full_name: Set.Finite.measurableSet_sUnion
code: theorem Set.Finite.measurableSet_sUnion {s : Set (Set α)} (hs : s.Finite)
    (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋃₀ s) 
goal: MeasurableSet (⋃₀ s)

full_name: MeasurableSet.iInter
code: @[measurability]
theorem MeasurableSet.iInter [Countable ι] {f : ι → Set α} (h : ∀ b, MeasurableSet (f b)) :
    MeasurableSet (⋂ b, f b) 
goal: MeasurableSet (⋂ b, f b)

full_name: MeasurableSet.biInter
code: theorem MeasurableSet.biInter {f : β → Set α} {s : Set β} (hs : s.Countable)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) 
goal: MeasurableSet (⋂ b ∈ s, f b)

full_name: Set.Finite.measurableSet_biInter
code: theorem Set.Finite.measurableSet_biInter {f : β → Set α} {s : Set β} (hs : s.Finite)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) 
goal: MeasurableSet (⋂ b ∈ s, f b)

full_name: Finset.measurableSet_biInter
code: theorem Finset.measurableSet_biInter {f : β → Set α} (s : Finset β)
    (h : ∀ b ∈ s, MeasurableSet (f b)) : MeasurableSet (⋂ b ∈ s, f b) 
goal: MeasurableSet (⋂ b ∈ s, f b)

full_name: MeasurableSet.sInter
code: theorem MeasurableSet.sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, MeasurableSet t) :
    MeasurableSet (⋂₀ s) 
goal: MeasurableSet (⋂₀ s)

full_name: Set.Finite.measurableSet_sInter
code: theorem Set.Finite.measurableSet_sInter {s : Set (Set α)} (hs : s.Finite)
    (h : ∀ t ∈ s, MeasurableSet t) : MeasurableSet (⋂₀ s) 
goal: MeasurableSet (⋂₀ s)

full_name: MeasurableSet.union
code: @[simp, measurability]
protected theorem MeasurableSet.union {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∪ s₂) 
goal: MeasurableSet (s₁ ∪ s₂)

full_name: MeasurableSet.inter
code: @[simp, measurability]
protected theorem MeasurableSet.inter {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∩ s₂) 
goal: MeasurableSet (s₁ ∩ s₂)

full_name: MeasurableSet.diff
code: @[simp, measurability]
protected theorem MeasurableSet.diff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ \ s₂) 
goal: MeasurableSet (s₁ \ s₂)

full_name: MeasurableSet.himp
code: @[simp, measurability]
protected lemma MeasurableSet.himp {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) :
    MeasurableSet (s₁ ⇨ s₂) 
goal: MeasurableSet (s₁ ⇨ s₂)

full_name: MeasurableSet.symmDiff
code: @[simp, measurability]
protected theorem MeasurableSet.symmDiff {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ∆ s₂) 
goal: MeasurableSet (symmDiff s₁ s₂)

full_name: MeasurableSet.bihimp
code: @[simp, measurability]
protected lemma MeasurableSet.bihimp {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) : MeasurableSet (s₁ ⇔ s₂) 
goal: MeasurableSet (bihimp s₁ s₂)

full_name: MeasurableSet.ite
code: @[simp, measurability]
protected theorem MeasurableSet.ite {t s₁ s₂ : Set α} (ht : MeasurableSet t)
    (h₁ : MeasurableSet s₁) (h₂ : MeasurableSet s₂) : MeasurableSet (t.ite s₁ s₂) 
goal: MeasurableSet (t.ite s₁ s₂)

full_name: MeasurableSet.ite'
code: theorem MeasurableSet.ite' {s t : Set α} {p : Prop} (hs : p → MeasurableSet s)
    (ht : ¬p → MeasurableSet t) : MeasurableSet (ite p s t) 
goal: MeasurableSet (if p then s else t)

full_name: MeasurableSet.cond
code: @[simp, measurability]
protected theorem MeasurableSet.cond {s₁ s₂ : Set α} (h₁ : MeasurableSet s₁)
    (h₂ : MeasurableSet s₂) {i : Bool} : MeasurableSet (cond i s₁ s₂) 
goal: MeasurableSet (bif i then s₁ else s₂)

full_name: MeasurableSet.disjointed
code: @[simp, measurability]
protected theorem MeasurableSet.disjointed {f : ℕ → Set α} (h : ∀ i, MeasurableSet (f i)) (n) :
    MeasurableSet (disjointed f n) 
goal: MeasurableSet (disjointed f n)

full_name: MeasurableSet.const
code: protected theorem MeasurableSet.const (p : Prop) : MeasurableSet { _a : α | p } 
goal: MeasurableSet {_a | p}

full_name: nonempty_measurable_superset
code: /-- Every set has a measurable superset. Declare this as local instance as needed. -/
theorem nonempty_measurable_superset (s : Set α) : Nonempty { t // s ⊆ t ∧ MeasurableSet t } 
goal: Nonempty { t // s ⊆ t ∧ MeasurableSet t }

full_name: MeasurableSpace.measurableSet_injective
code: theorem MeasurableSpace.measurableSet_injective : Injective (@MeasurableSet α)
  
goal: Function.Injective (@MeasurableSet α)

full_name: MeasurableSpace.ext
code: @[ext]
theorem MeasurableSpace.ext {m₁ m₂ : MeasurableSpace α}
    (h : ∀ s : Set α, MeasurableSet[m₁] s ↔ MeasurableSet[m₂] s) : m₁ = m₂ 
goal: m₁ = m₂

full_name: MeasurableSpace.ext_iff
code: theorem MeasurableSpace.ext_iff {m₁ m₂ : MeasurableSpace α} :
    m₁ = m₂ ↔ ∀ s : Set α, MeasurableSet[m₁] s ↔ MeasurableSet[m₂] s 
goal: m₁ = m₂ ↔ ∀ (s : Set α), MeasurableSet s ↔ MeasurableSet s

full_name: MeasurableSingletonClass
code: /-- A typeclass mixin for `MeasurableSpace`s such that each singleton is measurable. -/
class MeasurableSingletonClass (α : Type*) [MeasurableSpace α] : Prop where
  /-- A singleton is a measurable set. -/
  measurableSet_singleton : ∀ x, MeasurableSet ({x} : Set α)
goal: Prop

full_name: MeasurableSingletonClass.measurableSet_singleton
code: /-- A typeclass mixin for `MeasurableSpace`s such that each singleton is measurable. -/
class MeasurableSingletonClass (α : Type*) [MeasurableSpace α] : Prop where
  /-- A singleton is a measurable set. -/
  measurableSet_singleton : ∀ x, MeasurableSet ({x} : Set α)
goal: MeasurableSet {x}

full_name: MeasurableSet.singleton
code: @[simp]
lemma MeasurableSet.singleton [MeasurableSpace α] [MeasurableSingletonClass α] (a : α) :
    MeasurableSet {a} 
goal: MeasurableSet {a}

full_name: measurableSet_eq
code: @[measurability]
theorem measurableSet_eq {a : α} : MeasurableSet { x | x = a } 
goal: MeasurableSet {x | x = a}

full_name: MeasurableSet.insert
code: @[measurability]
protected theorem MeasurableSet.insert {s : Set α} (hs : MeasurableSet s) (a : α) :
    MeasurableSet (insert a s) 
goal: MeasurableSet (insert a s)

full_name: measurableSet_insert
code: @[simp]
theorem measurableSet_insert {a : α} {s : Set α} : MeasurableSet (insert a s) ↔ MeasurableSet s 
goal: MeasurableSet (insert a s) ↔ MeasurableSet s

full_name: Set.Subsingleton.measurableSet
code: theorem Set.Subsingleton.measurableSet {s : Set α} (hs : s.Subsingleton) : MeasurableSet s 
goal: MeasurableSet s

full_name: Set.Finite.measurableSet
code: theorem Set.Finite.measurableSet {s : Set α} (hs : s.Finite) : MeasurableSet s 
goal: MeasurableSet s

full_name: Finset.measurableSet
code: @[measurability]
protected theorem Finset.measurableSet (s : Finset α) : MeasurableSet (↑s : Set α) 
goal: MeasurableSet ↑s

full_name: Set.Countable.measurableSet
code: theorem Set.Countable.measurableSet {s : Set α} (hs : s.Countable) : MeasurableSet s 
goal: MeasurableSet s

full_name: MeasurableSpace.copy
code: /-- Copy of a `MeasurableSpace` with a new `MeasurableSet` equal to the old one. Useful to fix
definitional equalities. -/
protected def copy (m : MeasurableSpace α) (p : Set α → Prop) (h : ∀ s, p s ↔ MeasurableSet[m] s) :
    MeasurableSpace α 
goal: MeasurableSpace α

full_name: MeasurableSpace.measurableSet_copy
code: lemma measurableSet_copy {m : MeasurableSpace α} {p : Set α → Prop}
    (h : ∀ s, p s ↔ MeasurableSet[m] s) {s} : MeasurableSet[.copy m p h] s ↔ p s 
goal: MeasurableSet s ↔ p s

full_name: MeasurableSpace.copy_eq
code: lemma copy_eq {m : MeasurableSpace α} {p : Set α → Prop} (h : ∀ s, p s ↔ MeasurableSet[m] s) :
    m.copy p h = m 
goal: m.copy p h = m

full_name: MeasurableSpace.instLE
code: instance : LE (MeasurableSpace α) 
goal: LE (MeasurableSpace α)

full_name: MeasurableSpace.le_def
code: theorem le_def {α} {a b : MeasurableSpace α} : a ≤ b ↔ a.MeasurableSet' ≤ b.MeasurableSet' 
goal: a ≤ b ↔ a.MeasurableSet' ≤ b.MeasurableSet'

full_name: MeasurableSpace.instPartialOrder
code: instance : PartialOrder (MeasurableSpace α) 
goal: PartialOrder (MeasurableSpace α)

full_name: MeasurableSpace.GenerateMeasurable.basic
code: /-- The smallest σ-algebra containing a collection `s` of basic sets -/
inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
  | protected basic : ∀ u ∈ s, GenerateMeasurable s u
  | protected empty : GenerateMeasurable s ∅
  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s tᶜ
  | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
      GenerateMeasurable s (⋃ i, f i)
goal: u ∈ s → MeasurableSpace.GenerateMeasurable s u

full_name: MeasurableSpace.GenerateMeasurable.compl
code: /-- The smallest σ-algebra containing a collection `s` of basic sets -/
inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
  | protected basic : ∀ u ∈ s, GenerateMeasurable s u
  | protected empty : GenerateMeasurable s ∅
  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s tᶜ
  | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
      GenerateMeasurable s (⋃ i, f i)
goal: MeasurableSpace.GenerateMeasurable s t → MeasurableSpace.GenerateMeasurable s tᶜ

full_name: MeasurableSpace.GenerateMeasurable.empty
code: /-- The smallest σ-algebra containing a collection `s` of basic sets -/
inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
  | protected basic : ∀ u ∈ s, GenerateMeasurable s u
  | protected empty : GenerateMeasurable s ∅
  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s tᶜ
  | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
      GenerateMeasurable s (⋃ i, f i)
goal: MeasurableSpace.GenerateMeasurable s ∅

full_name: MeasurableSpace.GenerateMeasurable.iUnion
code: /-- The smallest σ-algebra containing a collection `s` of basic sets -/
inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
  | protected basic : ∀ u ∈ s, GenerateMeasurable s u
  | protected empty : GenerateMeasurable s ∅
  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s tᶜ
  | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
      GenerateMeasurable s (⋃ i, f i)
goal: (∀ (n : ℕ), MeasurableSpace.GenerateMeasurable s (f n)) → MeasurableSpace.GenerateMeasurable s (⋃ i, f i)

full_name: MeasurableSpace.GenerateMeasurable
code: /-- The smallest σ-algebra containing a collection `s` of basic sets -/
inductive GenerateMeasurable (s : Set (Set α)) : Set α → Prop
  | protected basic : ∀ u ∈ s, GenerateMeasurable s u
  | protected empty : GenerateMeasurable s ∅
  | protected compl : ∀ t, GenerateMeasurable s t → GenerateMeasurable s tᶜ
  | protected iUnion : ∀ f : ℕ → Set α, (∀ n, GenerateMeasurable s (f n)) →
      GenerateMeasurable s (⋃ i, f i)
goal: Set α → Prop

full_name: MeasurableSpace.generateFrom
code: /-- Construct the smallest measure space containing a collection of basic sets -/
def generateFrom (s : Set (Set α)) : MeasurableSpace α 
goal: MeasurableSpace α

full_name: MeasurableSpace.measurableSet_generateFrom
code: theorem measurableSet_generateFrom {s : Set (Set α)} {t : Set α} (ht : t ∈ s) :
    MeasurableSet[generateFrom s] t 
goal: MeasurableSet t

full_name: MeasurableSpace.generateFrom_induction
code: @[elab_as_elim]
theorem generateFrom_induction (p : Set α → Prop) (C : Set (Set α)) (hC : ∀ t ∈ C, p t)
    (h_empty : p ∅) (h_compl : ∀ t, p t → p tᶜ)
    (h_Union : ∀ f : ℕ → Set α, (∀ n, p (f n)) → p (⋃ i, f i)) {s : Set α}
    (hs : MeasurableSet[generateFrom C] s) : p s 
goal: p s

full_name: MeasurableSpace.generateFrom_le
code: theorem generateFrom_le {s : Set (Set α)} {m : MeasurableSpace α}
    (h : ∀ t ∈ s, MeasurableSet[m] t) : generateFrom s ≤ m 
goal: MeasurableSpace.generateFrom s ≤ m

full_name: MeasurableSpace.generateFrom_le_iff
code: theorem generateFrom_le_iff {s : Set (Set α)} (m : MeasurableSpace α) :
    generateFrom s ≤ m ↔ s ⊆ { t | MeasurableSet[m] t } 
goal: MeasurableSpace.generateFrom s ≤ m ↔ s ⊆ {t | MeasurableSet t}

full_name: MeasurableSpace.generateFrom_measurableSet
code: @[simp]
theorem generateFrom_measurableSet [MeasurableSpace α] :
    generateFrom { s : Set α | MeasurableSet s } = ‹_› 
goal: MeasurableSpace.generateFrom {s | MeasurableSet s} = inst✝

full_name: MeasurableSpace.forall_generateFrom_mem_iff_mem_iff
code: theorem forall_generateFrom_mem_iff_mem_iff {S : Set (Set α)} {x y : α} :
    (∀ s, MeasurableSet[generateFrom S] s → (x ∈ s ↔ y ∈ s)) ↔ (∀ s ∈ S, x ∈ s ↔ y ∈ s) 
goal: (∀ (s : Set α), MeasurableSet s → (x ∈ s ↔ y ∈ s)) ↔ ∀ s ∈ S, x ∈ s ↔ y ∈ s

full_name: MeasurableSpace.mkOfClosure
code: /-- If `g` is a collection of subsets of `α` such that the `σ`-algebra generated from `g` contains
the same sets as `g`, then `g` was already a `σ`-algebra. -/
protected def mkOfClosure (g : Set (Set α)) (hg : { t | MeasurableSet[generateFrom g] t } = g) :
    MeasurableSpace α 
goal: MeasurableSpace α

full_name: MeasurableSpace.mkOfClosure_sets
code: theorem mkOfClosure_sets {s : Set (Set α)} {hs : { t | MeasurableSet[generateFrom s] t } = s} :
    MeasurableSpace.mkOfClosure s hs = generateFrom s 
goal: MeasurableSpace.mkOfClosure s hs = MeasurableSpace.generateFrom s

full_name: MeasurableSpace.giGenerateFrom
code: /-- We get a Galois insertion between `σ`-algebras on `α` and `Set (Set α)` by using `generate_from`
  on one side and the collection of measurable sets on the other side. -/
def giGenerateFrom : GaloisInsertion (@generateFrom α) fun m => { t | MeasurableSet[m] t } 
goal: GaloisInsertion MeasurableSpace.generateFrom fun m => {t | MeasurableSet t}

full_name: MeasurableSpace.instCompleteLattice
code: instance : CompleteLattice (MeasurableSpace α) 
goal: CompleteLattice (MeasurableSpace α)

full_name: MeasurableSpace.instInhabited
code: instance : Inhabited (MeasurableSpace α) 
goal: Inhabited (MeasurableSpace α)

full_name: MeasurableSpace.generateFrom_mono
code: @[mono]
theorem generateFrom_mono {s t : Set (Set α)} (h : s ⊆ t) : generateFrom s ≤ generateFrom t 
goal: MeasurableSpace.generateFrom s ≤ MeasurableSpace.generateFrom t

full_name: MeasurableSpace.generateFrom_sup_generateFrom
code: theorem generateFrom_sup_generateFrom {s t : Set (Set α)} :
    generateFrom s ⊔ generateFrom t = generateFrom (s ∪ t) 
goal: MeasurableSpace.generateFrom s ⊔ MeasurableSpace.generateFrom t = MeasurableSpace.generateFrom (s ∪ t)

full_name: MeasurableSpace.iSup_generateFrom
code: lemma iSup_generateFrom (s : ι → Set (Set α)) :
    ⨆ i, generateFrom (s i) = generateFrom (⋃ i, s i) 
goal: ⨆ i, MeasurableSpace.generateFrom (s i) = MeasurableSpace.generateFrom (⋃ i, s i)

full_name: MeasurableSpace.generateFrom_empty
code: @[simp]
lemma generateFrom_empty : generateFrom (∅ : Set (Set α)) = ⊥ 
goal: MeasurableSpace.generateFrom ∅ = ⊥

full_name: MeasurableSpace.generateFrom_singleton_empty
code: theorem generateFrom_singleton_empty : generateFrom {∅} = (⊥ : MeasurableSpace α) 
goal: MeasurableSpace.generateFrom {∅} = ⊥

full_name: MeasurableSpace.generateFrom_singleton_univ
code: theorem generateFrom_singleton_univ : generateFrom {Set.univ} = (⊥ : MeasurableSpace α) 
goal: MeasurableSpace.generateFrom {Set.univ} = ⊥

full_name: MeasurableSpace.generateFrom_insert_univ
code: @[simp]
theorem generateFrom_insert_univ (S : Set (Set α)) :
    generateFrom (insert Set.univ S) = generateFrom S 
goal: MeasurableSpace.generateFrom (insert Set.univ S) = MeasurableSpace.generateFrom S

full_name: MeasurableSpace.generateFrom_insert_empty
code: @[simp]
theorem generateFrom_insert_empty (S : Set (Set α)) :
    generateFrom (insert ∅ S) = generateFrom S 
goal: MeasurableSpace.generateFrom (insert ∅ S) = MeasurableSpace.generateFrom S

full_name: MeasurableSpace.measurableSet_bot_iff
code: theorem measurableSet_bot_iff {s : Set α} : MeasurableSet[⊥] s ↔ s = ∅ ∨ s = univ 
goal: MeasurableSet s ↔ s = ∅ ∨ s = Set.univ

full_name: MeasurableSpace.measurableSet_top
code: @[simp, measurability] theorem measurableSet_top {s : Set α} : MeasurableSet[⊤] s 
goal: MeasurableSet s

full_name: MeasurableSpace.measurableSet_inf
code: @[simp, nolint simpNF] -- Porting note (#11215): TODO: `simpNF` claims that
-- this lemma doesn't simplify LHS
theorem measurableSet_inf {m₁ m₂ : MeasurableSpace α} {s : Set α} :
    MeasurableSet[m₁ ⊓ m₂] s ↔ MeasurableSet[m₁] s ∧ MeasurableSet[m₂] s 
goal: MeasurableSet s ↔ MeasurableSet s ∧ MeasurableSet s

full_name: MeasurableSpace.measurableSet_sInf
code: @[simp]
theorem measurableSet_sInf {ms : Set (MeasurableSpace α)} {s : Set α} :
    MeasurableSet[sInf ms] s ↔ ∀ m ∈ ms, MeasurableSet[m] s 
goal: MeasurableSet s ↔ ∀ m ∈ ms, MeasurableSet s

full_name: MeasurableSpace.measurableSet_iInf
code: theorem measurableSet_iInf {ι} {m : ι → MeasurableSpace α} {s : Set α} :
    MeasurableSet[iInf m] s ↔ ∀ i, MeasurableSet[m i] s 
goal: MeasurableSet s ↔ ∀ (i : ι), MeasurableSet s

full_name: MeasurableSpace.measurableSet_sup
code: theorem measurableSet_sup {m₁ m₂ : MeasurableSpace α} {s : Set α} :
    MeasurableSet[m₁ ⊔ m₂] s ↔ GenerateMeasurable (MeasurableSet[m₁] ∪ MeasurableSet[m₂]) s 
goal: MeasurableSet s ↔ MeasurableSpace.GenerateMeasurable (MeasurableSet ∪ MeasurableSet) s

full_name: MeasurableSpace.measurableSet_sSup
code: theorem measurableSet_sSup {ms : Set (MeasurableSpace α)} {s : Set α} :
    MeasurableSet[sSup ms] s ↔
      GenerateMeasurable { s : Set α | ∃ m ∈ ms, MeasurableSet[m] s } s 
goal: MeasurableSet s ↔ MeasurableSpace.GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s

full_name: MeasurableSpace.measurableSet_iSup
code: theorem measurableSet_iSup {ι} {m : ι → MeasurableSpace α} {s : Set α} :
    MeasurableSet[iSup m] s ↔ GenerateMeasurable { s : Set α | ∃ i, MeasurableSet[m i] s } s 
goal: MeasurableSet s ↔ MeasurableSpace.GenerateMeasurable {s | ∃ i, MeasurableSet s} s

full_name: MeasurableSpace.measurableSpace_iSup_eq
code: theorem measurableSpace_iSup_eq (m : ι → MeasurableSpace α) :
    ⨆ n, m n = generateFrom { s | ∃ n, MeasurableSet[m n] s } 
goal: ⨆ n, m n = MeasurableSpace.generateFrom {s | ∃ n, MeasurableSet s}

full_name: MeasurableSpace.generateFrom_iUnion_measurableSet
code: theorem generateFrom_iUnion_measurableSet (m : ι → MeasurableSpace α) :
    generateFrom (⋃ n, { t | MeasurableSet[m n] t }) = ⨆ n, m n 
goal: MeasurableSpace.generateFrom (⋃ n, {t | MeasurableSet t}) = ⨆ n, m n

full_name: Measurable
code: /-- A function `f` between measurable spaces is measurable if the preimage of every
  measurable set is measurable. -/
@[fun_prop]
def Measurable [MeasurableSpace α] [MeasurableSpace β] (f : α → β) : Prop 
goal: Prop

full_name: MeasureTheory.«_aux_Mathlib_MeasureTheory_MeasurableSpace_Defs___macroRules_MeasureTheory_termMeasurable[_]_1»
code: /-- Notation for `Measurable` with respect to a non-standanrd σ-algebra in the domain. -/
scoped notation "Measurable[" m "]" => @Measurable _ _ m _
goal: Lean.Macro

full_name: measurable_id
code: @[measurability]
theorem measurable_id {_ : MeasurableSpace α} : Measurable (@id α) 
goal: ∀ {x : MeasurableSpace α}, Measurable id

full_name: measurable_id'
code: @[fun_prop, measurability]
theorem measurable_id' {_ : MeasurableSpace α} : Measurable fun a : α => a 
goal: ∀ {x : MeasurableSpace α}, Measurable fun a => a

full_name: Measurable.comp
code: protected theorem Measurable.comp {_ : MeasurableSpace α} {_ : MeasurableSpace β}
    {_ : MeasurableSpace γ} {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
    Measurable (g ∘ f) 
goal: ∀ {x : MeasurableSpace α} {x_1 : MeasurableSpace β} {x_2 : MeasurableSpace γ} {g : β → γ} {f : α → β},
  Measurable g → Measurable f → Measurable (g ∘ f)

full_name: Measurable.comp'
code: @[fun_prop, aesop safe 50 (rule_sets := [Measurable])]
protected theorem Measurable.comp' {_ : MeasurableSpace α} {_ : MeasurableSpace β}
    {_ : MeasurableSpace γ} {g : β → γ} {f : α → β} (hg : Measurable g) (hf : Measurable f) :
    Measurable (fun x => g (f x)) 
goal: ∀ {x : MeasurableSpace α} {x_1 : MeasurableSpace β} {x_2 : MeasurableSpace γ} {g : β → γ} {f : α → β},
  Measurable g → Measurable f → Measurable fun x => g (f x)

full_name: measurable_const
code: @[simp, fun_prop, measurability]
theorem measurable_const {_ : MeasurableSpace α} {_ : MeasurableSpace β} {a : α} :
    Measurable fun _ : β => a 
goal: ∀ {x : MeasurableSpace α} {x_1 : MeasurableSpace β} {a : α}, Measurable fun x => a

full_name: Measurable.le
code: theorem Measurable.le {α} {m m0 : MeasurableSpace α} {_ : MeasurableSpace β} (hm : m ≤ m0)
    {f : α → β} (hf : Measurable[m] f) : Measurable[m0] f 
goal: ∀ {x : MeasurableSpace β}, m ≤ m0 → ∀ {f : α → β}, Measurable f → Measurable f

full_name: DiscreteMeasurableSpace.forall_measurableSet
code: /-- A typeclass mixin for `MeasurableSpace`s such that all sets are measurable. -/
class DiscreteMeasurableSpace (α : Type*) [MeasurableSpace α] : Prop where
  /-- Do not use this. Use `measurableSet_discrete` instead. -/
  forall_measurableSet : ∀ s : Set α, MeasurableSet s
goal: MeasurableSet s

full_name: DiscreteMeasurableSpace
code: /-- A typeclass mixin for `MeasurableSpace`s such that all sets are measurable. -/
class DiscreteMeasurableSpace (α : Type*) [MeasurableSpace α] : Prop where
  /-- Do not use this. Use `measurableSet_discrete` instead. -/
  forall_measurableSet : ∀ s : Set α, MeasurableSet s
goal: Prop

full_name: instDiscreteMeasurableSpace
code: instance : @DiscreteMeasurableSpace α ⊤ 
goal: DiscreteMeasurableSpace α

full_name: MeasurableSingletonClass.toDiscreteMeasurableSpace
code: instance (priority := 100) MeasurableSingletonClass.toDiscreteMeasurableSpace [MeasurableSpace α]
    [MeasurableSingletonClass α] [Countable α] : DiscreteMeasurableSpace α 
goal: DiscreteMeasurableSpace α

full_name: measurableSet_discrete
code: @[measurability] lemma measurableSet_discrete (s : Set α) : MeasurableSet s 
goal: MeasurableSet s

full_name: measurable_discrete
code: @[measurability]
lemma measurable_discrete (f : α → β) : Measurable f 
goal: Measurable f

full_name: DiscreteMeasurableSpace.toMeasurableSingletonClass
code: /-- Warning: Creates a typeclass loop with `MeasurableSingletonClass.toDiscreteMeasurableSpace`.
To be monitored. -/
-- See note [lower instance priority]
instance (priority := 100) DiscreteMeasurableSpace.toMeasurableSingletonClass :
    MeasurableSingletonClass α 
goal: MeasurableSingletonClass α