File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

full_name: MeasurableSpace.map
code: /-- The forward image of a measurable space under a function. `map f m` contains the sets
  `s : Set β` whose preimage under `f` is measurable. -/
protected def map (f : α → β) (m : MeasurableSpace α) : MeasurableSpace β 
goal: MeasurableSpace β

full_name: MeasurableSpace.map_def
code: lemma map_def {s : Set β} : MeasurableSet[m.map f] s ↔ MeasurableSet[m] (f ⁻¹' s) 
goal: MeasurableSet s ↔ MeasurableSet (f ⁻¹' s)

full_name: MeasurableSpace.map_id
code: @[simp]
theorem map_id : m.map id = m 
goal: MeasurableSpace.map id m = m

full_name: MeasurableSpace.map_comp
code: @[simp]
theorem map_comp {f : α → β} {g : β → γ} : (m.map f).map g = m.map (g ∘ f) 
goal: MeasurableSpace.map g (MeasurableSpace.map f m) = MeasurableSpace.map (g ∘ f) m

full_name: MeasurableSpace.comap
code: /-- The reverse image of a measurable space under a function. `comap f m` contains the sets
  `s : Set α` such that `s` is the `f`-preimage of a measurable set in `β`. -/
protected def comap (f : α → β) (m : MeasurableSpace β) : MeasurableSpace α 
goal: MeasurableSpace α

full_name: MeasurableSpace.comap_eq_generateFrom
code: theorem comap_eq_generateFrom (m : MeasurableSpace β) (f : α → β) :
    m.comap f = generateFrom { t | ∃ s, MeasurableSet s ∧ f ⁻¹' s = t } 
goal: MeasurableSpace.comap f m = MeasurableSpace.generateFrom {t | ∃ s, MeasurableSet s ∧ f ⁻¹' s = t}

full_name: MeasurableSpace.comap_id
code: @[simp]
theorem comap_id : m.comap id = m 
goal: MeasurableSpace.comap id m = m

full_name: MeasurableSpace.comap_comp
code: @[simp]
theorem comap_comp {f : β → α} {g : γ → β} : (m.comap f).comap g = m.comap (f ∘ g) 
goal: MeasurableSpace.comap g (MeasurableSpace.comap f m) = MeasurableSpace.comap (f ∘ g) m

full_name: MeasurableSpace.comap_le_iff_le_map
code: theorem comap_le_iff_le_map {f : α → β} : m'.comap f ≤ m ↔ m' ≤ m.map f 
goal: MeasurableSpace.comap f m' ≤ m ↔ m' ≤ MeasurableSpace.map f m

full_name: MeasurableSpace.gc_comap_map
code: theorem gc_comap_map (f : α → β) :
    GaloisConnection (MeasurableSpace.comap f) (MeasurableSpace.map f) 
goal: GaloisConnection (MeasurableSpace.comap f) (MeasurableSpace.map f)

full_name: MeasurableSpace.map_mono
code: theorem map_mono (h : m₁ ≤ m₂) : m₁.map f ≤ m₂.map f 
goal: MeasurableSpace.map f m₁ ≤ MeasurableSpace.map f m₂

full_name: MeasurableSpace.monotone_map
code: theorem monotone_map : Monotone (MeasurableSpace.map f) 
goal: Monotone (MeasurableSpace.map f)

full_name: MeasurableSpace.comap_mono
code: theorem comap_mono (h : m₁ ≤ m₂) : m₁.comap g ≤ m₂.comap g 
goal: MeasurableSpace.comap g m₁ ≤ MeasurableSpace.comap g m₂

full_name: MeasurableSpace.monotone_comap
code: theorem monotone_comap : Monotone (MeasurableSpace.comap g) 
goal: Monotone (MeasurableSpace.comap g)

full_name: MeasurableSpace.comap_bot
code: @[simp]
theorem comap_bot : (⊥ : MeasurableSpace α).comap g = ⊥ 
goal: MeasurableSpace.comap g ⊥ = ⊥

full_name: MeasurableSpace.comap_sup
code: @[simp]
theorem comap_sup : (m₁ ⊔ m₂).comap g = m₁.comap g ⊔ m₂.comap g 
goal: MeasurableSpace.comap g (m₁ ⊔ m₂) = MeasurableSpace.comap g m₁ ⊔ MeasurableSpace.comap g m₂

full_name: MeasurableSpace.comap_iSup
code: @[simp]
theorem comap_iSup {m : ι → MeasurableSpace α} : (⨆ i, m i).comap g = ⨆ i, (m i).comap g 
goal: MeasurableSpace.comap g (⨆ i, m i) = ⨆ i, MeasurableSpace.comap g (m i)

full_name: MeasurableSpace.map_top
code: @[simp]
theorem map_top : (⊤ : MeasurableSpace α).map f = ⊤ 
goal: MeasurableSpace.map f ⊤ = ⊤

full_name: MeasurableSpace.map_inf
code: @[simp]
theorem map_inf : (m₁ ⊓ m₂).map f = m₁.map f ⊓ m₂.map f 
goal: MeasurableSpace.map f (m₁ ⊓ m₂) = MeasurableSpace.map f m₁ ⊓ MeasurableSpace.map f m₂

full_name: MeasurableSpace.map_iInf
code: @[simp]
theorem map_iInf {m : ι → MeasurableSpace α} : (⨅ i, m i).map f = ⨅ i, (m i).map f 
goal: MeasurableSpace.map f (⨅ i, m i) = ⨅ i, MeasurableSpace.map f (m i)

full_name: MeasurableSpace.comap_map_le
code: theorem comap_map_le : (m.map f).comap f ≤ m 
goal: MeasurableSpace.comap f (MeasurableSpace.map f m) ≤ m

full_name: MeasurableSpace.le_map_comap
code: theorem le_map_comap : m ≤ (m.comap g).map g 
goal: m ≤ MeasurableSpace.map g (MeasurableSpace.comap g m)

full_name: MeasurableSpace.map_const
code: @[simp] theorem map_const {m} (b : β) : MeasurableSpace.map (fun _a : α ↦ b) m = ⊤ 
goal: MeasurableSpace.map (fun _a => b) m = ⊤

full_name: MeasurableSpace.comap_const
code: @[simp] theorem comap_const {m} (b : β) : MeasurableSpace.comap (fun _a : α => b) m = ⊥ 
goal: MeasurableSpace.comap (fun _a => b) m = ⊥

full_name: MeasurableSpace.comap_generateFrom
code: theorem comap_generateFrom {f : α → β} {s : Set (Set β)} :
    (generateFrom s).comap f = generateFrom (preimage f '' s) 
goal: MeasurableSpace.comap f (MeasurableSpace.generateFrom s) = MeasurableSpace.generateFrom (Set.preimage f '' s)

full_name: measurable_iff_le_map
code: theorem measurable_iff_le_map {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β} :
    Measurable f ↔ m₂ ≤ m₁.map f 
goal: Measurable f ↔ m₂ ≤ MeasurableSpace.map f m₁

full_name: measurable_iff_comap_le
code: theorem measurable_iff_comap_le {m₁ : MeasurableSpace α} {m₂ : MeasurableSpace β} {f : α → β} :
    Measurable f ↔ m₂.comap f ≤ m₁ 
goal: Measurable f ↔ MeasurableSpace.comap f m₂ ≤ m₁

full_name: comap_measurable
code: theorem comap_measurable {m : MeasurableSpace β} (f : α → β) : Measurable[m.comap f] f 
goal: Measurable f

full_name: Measurable.mono
code: theorem Measurable.mono {ma ma' : MeasurableSpace α} {mb mb' : MeasurableSpace β} {f : α → β}
    (hf : @Measurable α β ma mb f) (ha : ma ≤ ma') (hb : mb' ≤ mb) : @Measurable α β ma' mb' f 
goal: Measurable f

full_name: measurable_id''
code: theorem measurable_id'' {m mα : MeasurableSpace α} (hm : m ≤ mα) : @Measurable α α mα m id 
goal: Measurable id

full_name: measurable_from_top
code: @[measurability]
theorem measurable_from_top [MeasurableSpace β] {f : α → β} : Measurable[⊤] f 
goal: Measurable f

full_name: measurable_generateFrom
code: theorem measurable_generateFrom [MeasurableSpace α] {s : Set (Set β)} {f : α → β}
    (h : ∀ t ∈ s, MeasurableSet (f ⁻¹' t)) : @Measurable _ _ _ (generateFrom s) f 
goal: Measurable f

full_name: Subsingleton.measurable
code: @[nontriviality, measurability]
theorem Subsingleton.measurable [Subsingleton α] : Measurable f 
goal: Measurable f

full_name: measurable_of_subsingleton_codomain
code: @[nontriviality, measurability]
theorem measurable_of_subsingleton_codomain [Subsingleton β] (f : α → β) : Measurable f 
goal: Measurable f

full_name: measurable_zero
code: @[to_additive (attr := measurability)]
theorem measurable_one [One α] : Measurable (1 : β → α) 
goal: Measurable 0

full_name: measurable_one
code: @[to_additive (attr := measurability)]
theorem measurable_one [One α] : Measurable (1 : β → α) 
goal: Measurable 1

full_name: measurable_of_empty
code: theorem measurable_of_empty [IsEmpty α] (f : α → β) : Measurable f 
goal: Measurable f

full_name: measurable_of_empty_codomain
code: theorem measurable_of_empty_codomain [IsEmpty β] (f : α → β) : Measurable f 
goal: Measurable f

full_name: measurable_const'
code: /-- A version of `measurable_const` that assumes `f x = f y` for all `x, y`. This version works
for functions between empty types. -/
theorem measurable_const' {f : β → α} (hf : ∀ x y, f x = f y) : Measurable f 
goal: Measurable f

full_name: measurable_natCast
code: @[measurability]
theorem measurable_natCast [NatCast α] (n : ℕ) : Measurable (n : β → α) 
goal: Measurable ↑n

full_name: measurable_intCast
code: @[measurability]
theorem measurable_intCast [IntCast α] (n : ℤ) : Measurable (n : β → α) 
goal: Measurable ↑n

full_name: measurable_of_countable
code: theorem measurable_of_countable [Countable α] [MeasurableSingletonClass α] (f : α → β) :
    Measurable f 
goal: Measurable f

full_name: measurable_of_finite
code: theorem measurable_of_finite [Finite α] [MeasurableSingletonClass α] (f : α → β) : Measurable f 
goal: Measurable f

full_name: Measurable.iterate
code: @[measurability]
theorem Measurable.iterate {f : α → α} (hf : Measurable f) : ∀ n, Measurable f^[n]
  
goal: Measurable f^[n]

full_name: measurableSet_preimage
code: @[measurability]
theorem measurableSet_preimage {t : Set β} (hf : Measurable f) (ht : MeasurableSet t) :
    MeasurableSet (f ⁻¹' t) 
goal: MeasurableSet (f ⁻¹' t)

full_name: MeasurableSet.preimage
code: protected theorem MeasurableSet.preimage {t : Set β} (ht : MeasurableSet t) (hf : Measurable f) :
    MeasurableSet (f ⁻¹' t) 
goal: MeasurableSet (f ⁻¹' t)

full_name: Measurable.piecewise
code: @[measurability]
protected theorem Measurable.piecewise {_ : DecidablePred (· ∈ s)} (hs : MeasurableSet s)
    (hf : Measurable f) (hg : Measurable g) : Measurable (piecewise s f g) 
goal: ∀ {x : DecidablePred fun x => x ∈ s}, MeasurableSet s → Measurable f → Measurable g → Measurable (s.piecewise f g)

full_name: Measurable.ite
code: /-- This is slightly different from `Measurable.piecewise`. It can be used to show
`Measurable (ite (x=0) 0 1)` by
`exact Measurable.ite (measurableSet_singleton 0) measurable_const measurable_const`,
but replacing `Measurable.ite` by `Measurable.piecewise` in that example proof does not work. -/
theorem Measurable.ite {p : α → Prop} {_ : DecidablePred p} (hp : MeasurableSet { a : α | p a })
    (hf : Measurable f) (hg : Measurable g) : Measurable fun x => ite (p x) (f x) (g x) 
goal: ∀ {x : DecidablePred p},
  MeasurableSet {a | p a} → Measurable f → Measurable g → Measurable fun x_1 => if p x_1 then f x_1 else g x_1

full_name: Measurable.indicator
code: @[measurability, fun_prop]
theorem Measurable.indicator [Zero β] (hf : Measurable f) (hs : MeasurableSet s) :
    Measurable (s.indicator f) 
goal: Measurable (s.indicator f)

full_name: measurable_indicator_const_iff
code: /-- The measurability of a set `A` is equivalent to the measurability of the indicator function
which takes a constant value `b ≠ 0` on a set `A` and `0` elsewhere. -/
lemma measurable_indicator_const_iff [Zero β] [MeasurableSingletonClass β] (b : β) [NeZero b] :
    Measurable (s.indicator (fun (_ : α) ↦ b)) ↔ MeasurableSet s 
goal: Measurable (s.indicator fun x => b) ↔ MeasurableSet s

full_name: measurableSet_mulSupport
code: @[to_additive (attr := measurability)]
theorem measurableSet_mulSupport [One β] [MeasurableSingletonClass β] (hf : Measurable f) :
    MeasurableSet (mulSupport f) 
goal: MeasurableSet (Function.mulSupport f)

full_name: measurableSet_support
code: @[to_additive (attr := measurability)]
theorem measurableSet_mulSupport [One β] [MeasurableSingletonClass β] (hf : Measurable f) :
    MeasurableSet (mulSupport f) 
goal: MeasurableSet (Function.support f)

full_name: Measurable.measurable_of_countable_ne
code: /-- If a function coincides with a measurable function outside of a countable set, it is
measurable. -/
theorem Measurable.measurable_of_countable_ne [MeasurableSingletonClass α] (hf : Measurable f)
    (h : Set.Countable { x | f x ≠ g x }) : Measurable g 
goal: Measurable g

full_name: measurable_to_countable
code: theorem measurable_to_countable [MeasurableSpace α] [Countable α] [MeasurableSpace β] {f : β → α}
    (h : ∀ y, MeasurableSet (f ⁻¹' {f y})) : Measurable f 
goal: Measurable f

full_name: measurable_to_countable'
code: theorem measurable_to_countable' [MeasurableSpace α] [Countable α] [MeasurableSpace β] {f : β → α}
    (h : ∀ x, MeasurableSet (f ⁻¹' {x})) : Measurable f 
goal: Measurable f

full_name: measurable_unit
code: @[measurability]
theorem measurable_unit [MeasurableSpace α] (f : Unit → α) : Measurable f 
goal: Measurable f

full_name: ULift.instMeasurableSpace
code: instance _root_.ULift.instMeasurableSpace : MeasurableSpace (ULift α) 
goal: MeasurableSpace (ULift.{u_6, u_1} α)

full_name: measurable_down
code: lemma measurable_down : Measurable (ULift.down : ULift α → α) 
goal: Measurable ULift.down

full_name: measurable_up
code: lemma measurable_up : Measurable (ULift.up : α → ULift α) 
goal: Measurable ULift.up

full_name: measurableSet_preimage_down
code: @[simp] lemma measurableSet_preimage_down {s : Set α} :
    MeasurableSet (ULift.down ⁻¹' s) ↔ MeasurableSet s 
goal: MeasurableSet (ULift.down ⁻¹' s) ↔ MeasurableSet s

full_name: measurableSet_preimage_up
code: @[simp] lemma measurableSet_preimage_up {s : Set (ULift α)} :
    MeasurableSet (ULift.up ⁻¹' s) ↔ MeasurableSet s 
goal: MeasurableSet (ULift.up ⁻¹' s) ↔ MeasurableSet s

full_name: measurable_from_nat
code: @[measurability]
theorem measurable_from_nat {f : ℕ → α} : Measurable f 
goal: Measurable f

full_name: measurable_to_nat
code: theorem measurable_to_nat {f : α → ℕ} : (∀ y, MeasurableSet (f ⁻¹' {f y})) → Measurable f 
goal: (∀ (y : α), MeasurableSet (f ⁻¹' {f y})) → Measurable f

full_name: measurable_to_bool
code: theorem measurable_to_bool {f : α → Bool} (h : MeasurableSet (f ⁻¹' {true})) : Measurable f 
goal: Measurable f

full_name: measurable_to_prop
code: theorem measurable_to_prop {f : α → Prop} (h : MeasurableSet (f ⁻¹' {True})) : Measurable f 
goal: Measurable f

full_name: measurable_findGreatest'
code: theorem measurable_findGreatest' {p : α → ℕ → Prop} [∀ x, DecidablePred (p x)] {N : ℕ}
    (hN : ∀ k ≤ N, MeasurableSet { x | Nat.findGreatest (p x) N = k }) :
    Measurable fun x => Nat.findGreatest (p x) N 
goal: Measurable fun x => Nat.findGreatest (p x) N

full_name: measurable_findGreatest
code: theorem measurable_findGreatest {p : α → ℕ → Prop} [∀ x, DecidablePred (p x)] {N}
    (hN : ∀ k ≤ N, MeasurableSet { x | p x k }) : Measurable fun x => Nat.findGreatest (p x) N 
goal: Measurable fun x => Nat.findGreatest (p x) N

full_name: measurable_find
code: theorem measurable_find {p : α → ℕ → Prop} [∀ x, DecidablePred (p x)] (hp : ∀ x, ∃ N, p x N)
    (hm : ∀ k, MeasurableSet { x | p x k }) : Measurable fun x => Nat.find (hp x) 
goal: Measurable fun x => Nat.find ⋯

full_name: Quot.instMeasurableSpace
code: instance Quot.instMeasurableSpace {α} {r : α → α → Prop} [m : MeasurableSpace α] :
    MeasurableSpace (Quot r) 
goal: MeasurableSpace (Quot r)

full_name: Quotient.instMeasurableSpace
code: instance Quotient.instMeasurableSpace {α} {s : Setoid α} [m : MeasurableSpace α] :
    MeasurableSpace (Quotient s) 
goal: MeasurableSpace (Quotient s)

full_name: QuotientGroup.measurableSpace
code: @[to_additive]
instance QuotientGroup.measurableSpace {G} [Group G] [MeasurableSpace G] (S : Subgroup G) :
    MeasurableSpace (G ⧸ S) 
goal: MeasurableSpace (G ⧸ S)

full_name: QuotientAddGroup.measurableSpace
code: @[to_additive]
instance QuotientGroup.measurableSpace {G} [Group G] [MeasurableSpace G] (S : Subgroup G) :
    MeasurableSpace (G ⧸ S) 
goal: MeasurableSpace (G ⧸ S)

full_name: measurableSet_quotient
code: theorem measurableSet_quotient {s : Setoid α} {t : Set (Quotient s)} :
    MeasurableSet t ↔ MeasurableSet (Quotient.mk'' ⁻¹' t) 
goal: MeasurableSet t ↔ MeasurableSet (Quotient.mk'' ⁻¹' t)

full_name: measurable_from_quotient
code: theorem measurable_from_quotient {s : Setoid α} {f : Quotient s → β} :
    Measurable f ↔ Measurable (f ∘ Quotient.mk'') 
goal: Measurable f ↔ Measurable (f ∘ Quotient.mk'')

full_name: measurable_quotient_mk'
code: @[measurability]
theorem measurable_quotient_mk' [s : Setoid α] : Measurable (Quotient.mk' : α → Quotient s) 
goal: Measurable Quotient.mk'

full_name: measurable_quotient_mk''
code: @[measurability]
theorem measurable_quotient_mk'' {s : Setoid α} : Measurable (Quotient.mk'' : α → Quotient s) 
goal: Measurable Quotient.mk''

full_name: measurable_quot_mk
code: @[measurability]
theorem measurable_quot_mk {r : α → α → Prop} : Measurable (Quot.mk r) 
goal: Measurable (Quot.mk r)

full_name: QuotientGroup.measurable_coe
code: @[to_additive (attr := measurability)]
theorem QuotientGroup.measurable_coe {G} [Group G] [MeasurableSpace G] {S : Subgroup G} :
    Measurable ((↑) : G → G ⧸ S) 
goal: Measurable QuotientGroup.mk

full_name: QuotientAddGroup.measurable_coe
code: @[to_additive (attr := measurability)]
theorem QuotientGroup.measurable_coe {G} [Group G] [MeasurableSpace G] {S : Subgroup G} :
    Measurable ((↑) : G → G ⧸ S) 
goal: Measurable QuotientAddGroup.mk

full_name: QuotientGroup.measurable_from_quotient
code: @[to_additive]
nonrec theorem QuotientGroup.measurable_from_quotient {G} [Group G] [MeasurableSpace G]
    {S : Subgroup G} {f : G ⧸ S → α} : Measurable f ↔ Measurable (f ∘ ((↑) : G → G ⧸ S)) 
goal: Measurable f ↔ Measurable (f ∘ QuotientGroup.mk)

full_name: QuotientAddGroup.measurable_from_quotient
code: @[to_additive]
nonrec theorem QuotientGroup.measurable_from_quotient {G} [Group G] [MeasurableSpace G]
    {S : Subgroup G} {f : G ⧸ S → α} : Measurable f ↔ Measurable (f ∘ ((↑) : G → G ⧸ S)) 
goal: Measurable f ↔ Measurable (f ∘ QuotientAddGroup.mk)

full_name: Subtype.instMeasurableSpace
code: instance Subtype.instMeasurableSpace {α} {p : α → Prop} [m : MeasurableSpace α] :
    MeasurableSpace (Subtype p) 
goal: MeasurableSpace (Subtype p)

full_name: measurable_subtype_coe
code: @[measurability]
theorem measurable_subtype_coe {p : α → Prop} : Measurable ((↑) : Subtype p → α) 
goal: Measurable Subtype.val

full_name: Subtype.instMeasurableSingletonClass
code: instance Subtype.instMeasurableSingletonClass {p : α → Prop} [MeasurableSingletonClass α] :
    MeasurableSingletonClass (Subtype p) 
goal: MeasurableSingletonClass (Subtype p)

full_name: MeasurableSet.of_subtype_image
code: theorem MeasurableSet.of_subtype_image {s : Set α} {t : Set s}
    (h : MeasurableSet (Subtype.val '' t)) : MeasurableSet t 
goal: MeasurableSet t

full_name: MeasurableSet.subtype_image
code: theorem MeasurableSet.subtype_image {s : Set α} {t : Set s} (hs : MeasurableSet s) :
    MeasurableSet t → MeasurableSet (((↑) : s → α) '' t) 
goal: MeasurableSet t → MeasurableSet (Subtype.val '' t)

full_name: Measurable.subtype_coe
code: @[measurability]
theorem Measurable.subtype_coe {p : β → Prop} {f : α → Subtype p} (hf : Measurable f) :
    Measurable fun a : α => (f a : β) 
goal: Measurable fun a => ↑(f a)

full_name: Measurable.subtype_mk
code: @[measurability]
theorem Measurable.subtype_mk {p : β → Prop} {f : α → β} (hf : Measurable f) {h : ∀ x, p (f x)} :
    Measurable fun x => (⟨f x, h x⟩ : Subtype p) 
goal: Measurable fun x => ⟨f x, ⋯⟩

full_name: Measurable.rangeFactorization
code: @[measurability]
protected theorem Measurable.rangeFactorization {f : α → β} (hf : Measurable f) :
    Measurable (rangeFactorization f) 
goal: Measurable (Set.rangeFactorization f)

full_name: Measurable.subtype_map
code: theorem Measurable.subtype_map {f : α → β} {p : α → Prop} {q : β → Prop} (hf : Measurable f)
    (hpq : ∀ x, p x → q (f x)) : Measurable (Subtype.map f hpq) 
goal: Measurable (Subtype.map f hpq)

full_name: measurable_inclusion
code: theorem measurable_inclusion {s t : Set α} (h : s ⊆ t) : Measurable (inclusion h) 
goal: Measurable (Set.inclusion h)

full_name: MeasurableSet.image_inclusion'
code: theorem MeasurableSet.image_inclusion' {s t : Set α} (h : s ⊆ t) {u : Set s}
    (hs : MeasurableSet (Subtype.val ⁻¹' s : Set t)) (hu : MeasurableSet u) :
    MeasurableSet (inclusion h '' u) 
goal: MeasurableSet (Set.inclusion h '' u)

full_name: MeasurableSet.image_inclusion
code: theorem MeasurableSet.image_inclusion {s t : Set α} (h : s ⊆ t) {u : Set s}
    (hs : MeasurableSet s) (hu : MeasurableSet u) :
    MeasurableSet (inclusion h '' u) 
goal: MeasurableSet (Set.inclusion h '' u)

full_name: MeasurableSet.of_union_cover
code: theorem MeasurableSet.of_union_cover {s t u : Set α} (hs : MeasurableSet s) (ht : MeasurableSet t)
    (h : univ ⊆ s ∪ t) (hsu : MeasurableSet (((↑) : s → α) ⁻¹' u))
    (htu : MeasurableSet (((↑) : t → α) ⁻¹' u)) : MeasurableSet u 
goal: MeasurableSet u

full_name: measurable_of_measurable_union_cover
code: theorem measurable_of_measurable_union_cover {f : α → β} (s t : Set α) (hs : MeasurableSet s)
    (ht : MeasurableSet t) (h : univ ⊆ s ∪ t) (hc : Measurable fun a : s => f a)
    (hd : Measurable fun a : t => f a) : Measurable f 
goal: Measurable f

full_name: measurable_of_restrict_of_restrict_compl
code: theorem measurable_of_restrict_of_restrict_compl {f : α → β} {s : Set α} (hs : MeasurableSet s)
    (h₁ : Measurable (s.restrict f)) (h₂ : Measurable (sᶜ.restrict f)) : Measurable f 
goal: Measurable f

full_name: Measurable.dite
code: theorem Measurable.dite [∀ x, Decidable (x ∈ s)] {f : s → β} (hf : Measurable f)
    {g : (sᶜ : Set α) → β} (hg : Measurable g) (hs : MeasurableSet s) :
    Measurable fun x => if hx : x ∈ s then f ⟨x, hx⟩ else g ⟨x, hx⟩ 
goal: Measurable fun x => if hx : x ∈ s then f ⟨x, hx⟩ else g ⟨x, hx⟩

full_name: measurable_of_measurable_on_compl_finite
code: theorem measurable_of_measurable_on_compl_finite [MeasurableSingletonClass α] {f : α → β}
    (s : Set α) (hs : s.Finite) (hf : Measurable (sᶜ.restrict f)) : Measurable f 
goal: Measurable f

full_name: measurable_of_measurable_on_compl_singleton
code: theorem measurable_of_measurable_on_compl_singleton [MeasurableSingletonClass α] {f : α → β} (a : α)
    (hf : Measurable ({ x | x ≠ a }.restrict f)) : Measurable f 
goal: Measurable f

full_name: measurableAtom
code: /-- The *measurable atom* of `x` is the intersection of all the measurable sets countaining `x`.
It is measurable when the space is countable (or more generally when the measurable space is
countably generated). -/
def measurableAtom (x : β) : Set β 
goal: Set β

full_name: mem_measurableAtom_self
code: @[simp] lemma mem_measurableAtom_self (x : β) : x ∈ measurableAtom x 
goal: x ∈ measurableAtom x

full_name: mem_of_mem_measurableAtom
code: lemma mem_of_mem_measurableAtom {x y : β} (h : y ∈ measurableAtom x) {s : Set β}
    (hs : MeasurableSet s) (hxs : x ∈ s) : y ∈ s 
goal: y ∈ s

full_name: measurableAtom_subset
code: lemma measurableAtom_subset {s : Set β} {x : β} (hs : MeasurableSet s) (hx : x ∈ s) :
    measurableAtom x ⊆ s 
goal: measurableAtom x ⊆ s

full_name: measurableAtom_of_measurableSingletonClass
code: @[simp] lemma measurableAtom_of_measurableSingletonClass [MeasurableSingletonClass β] (x : β) :
    measurableAtom x = {x} 
goal: measurableAtom x = {x}

full_name: MeasurableSet.measurableAtom_of_countable
code: lemma MeasurableSet.measurableAtom_of_countable [Countable β] (x : β) :
    MeasurableSet (measurableAtom x) 
goal: MeasurableSet (measurableAtom x)

full_name: MeasurableSpace.prod
code: /-- A `MeasurableSpace` structure on the product of two measurable spaces. -/
def MeasurableSpace.prod {α β} (m₁ : MeasurableSpace α) (m₂ : MeasurableSpace β) :
    MeasurableSpace (α × β) 
goal: MeasurableSpace (α × β)

full_name: Prod.instMeasurableSpace
code: instance Prod.instMeasurableSpace {α β} [m₁ : MeasurableSpace α] [m₂ : MeasurableSpace β] :
    MeasurableSpace (α × β) 
goal: MeasurableSpace (α × β)

full_name: measurable_fst
code: @[measurability]
theorem measurable_fst {_ : MeasurableSpace α} {_ : MeasurableSpace β} :
    Measurable (Prod.fst : α × β → α) 
goal: ∀ {x : MeasurableSpace α} {x_1 : MeasurableSpace β}, Measurable Prod.fst

full_name: measurable_snd
code: @[measurability]
theorem measurable_snd {_ : MeasurableSpace α} {_ : MeasurableSpace β} :
    Measurable (Prod.snd : α × β → β) 
goal: ∀ {x : MeasurableSpace α} {x_1 : MeasurableSpace β}, Measurable Prod.snd

full_name: Measurable.fst
code: @[fun_prop]
theorem Measurable.fst {f : α → β × γ} (hf : Measurable f) : Measurable fun a : α => (f a).1 
goal: Measurable fun a => (f a).1

full_name: Measurable.snd
code: @[fun_prop]
theorem Measurable.snd {f : α → β × γ} (hf : Measurable f) : Measurable fun a : α => (f a).2 
goal: Measurable fun a => (f a).2

full_name: Measurable.prod
code: @[measurability]
theorem Measurable.prod {f : α → β × γ} (hf₁ : Measurable fun a => (f a).1)
    (hf₂ : Measurable fun a => (f a).2) : Measurable f 
goal: Measurable f

full_name: Measurable.prod_mk
code: @[fun_prop]
theorem Measurable.prod_mk {β γ} {_ : MeasurableSpace β} {_ : MeasurableSpace γ} {f : α → β}
    {g : α → γ} (hf : Measurable f) (hg : Measurable g) : Measurable fun a : α => (f a, g a) 
goal: ∀ {x : MeasurableSpace β} {x_1 : MeasurableSpace γ} {f : α → β} {g : α → γ},
  Measurable f → Measurable g → Measurable fun a => (f a, g a)

full_name: Measurable.prod_map
code: theorem Measurable.prod_map [MeasurableSpace δ] {f : α → β} {g : γ → δ} (hf : Measurable f)
    (hg : Measurable g) : Measurable (Prod.map f g) 
goal: Measurable (Prod.map f g)

full_name: measurable_prod_mk_left
code: theorem measurable_prod_mk_left {x : α} : Measurable (@Prod.mk _ β x) 
goal: Measurable (Prod.mk x)

full_name: measurable_prod_mk_right
code: theorem measurable_prod_mk_right {y : β} : Measurable fun x : α => (x, y) 
goal: Measurable fun x => (x, y)

full_name: Measurable.of_uncurry_left
code: theorem Measurable.of_uncurry_left {f : α → β → γ} (hf : Measurable (uncurry f)) {x : α} :
    Measurable (f x) 
goal: Measurable (f x)

full_name: Measurable.of_uncurry_right
code: theorem Measurable.of_uncurry_right {f : α → β → γ} (hf : Measurable (uncurry f)) {y : β} :
    Measurable fun x => f x y 
goal: Measurable fun x => f x y

full_name: measurable_prod
code: theorem measurable_prod {f : α → β × γ} :
    Measurable f ↔ (Measurable fun a => (f a).1) ∧ Measurable fun a => (f a).2 
goal: Measurable f ↔ (Measurable fun a => (f a).1) ∧ Measurable fun a => (f a).2

full_name: measurable_swap
code: @[fun_prop, measurability]
theorem measurable_swap : Measurable (Prod.swap : α × β → β × α) 
goal: Measurable Prod.swap

full_name: measurable_swap_iff
code: theorem measurable_swap_iff {_ : MeasurableSpace γ} {f : α × β → γ} :
    Measurable (f ∘ Prod.swap) ↔ Measurable f 
goal: ∀ {x : MeasurableSpace γ} {f : α × β → γ}, Measurable (f ∘ Prod.swap) ↔ Measurable f

full_name: MeasurableSet.prod
code: @[measurability]
protected theorem MeasurableSet.prod {s : Set α} {t : Set β} (hs : MeasurableSet s)
    (ht : MeasurableSet t) : MeasurableSet (s ×ˢ t) 
goal: MeasurableSet (s ×ˢ t)

full_name: measurableSet_prod_of_nonempty
code: theorem measurableSet_prod_of_nonempty {s : Set α} {t : Set β} (h : (s ×ˢ t).Nonempty) :
    MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t 
goal: MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t

full_name: measurableSet_prod
code: theorem measurableSet_prod {s : Set α} {t : Set β} :
    MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t ∨ s = ∅ ∨ t = ∅ 
goal: MeasurableSet (s ×ˢ t) ↔ MeasurableSet s ∧ MeasurableSet t ∨ s = ∅ ∨ t = ∅

full_name: measurableSet_swap_iff
code: theorem measurableSet_swap_iff {s : Set (α × β)} :
    MeasurableSet (Prod.swap ⁻¹' s) ↔ MeasurableSet s 
goal: MeasurableSet (Prod.swap ⁻¹' s) ↔ MeasurableSet s

full_name: Prod.instMeasurableSingletonClass
code: instance Prod.instMeasurableSingletonClass
    [MeasurableSingletonClass α] [MeasurableSingletonClass β] :
    MeasurableSingletonClass (α × β) 
goal: MeasurableSingletonClass (α × β)

full_name: measurable_from_prod_countable'
code: theorem measurable_from_prod_countable' [Countable β]
    {_ : MeasurableSpace γ} {f : α × β → γ} (hf : ∀ y, Measurable fun x => f (x, y))
    (h'f : ∀ y y' x, y' ∈ measurableAtom y → f (x, y') = f (x, y)) :
    Measurable f 
goal: ∀ {x : MeasurableSpace γ} {f : α × β → γ},
  (∀ (y : β), Measurable fun x => f (x, y)) →
    (∀ (y y' : β) (x : α), y' ∈ measurableAtom y → f (x, y') = f (x, y)) → Measurable f

full_name: measurable_from_prod_countable
code: theorem measurable_from_prod_countable [Countable β] [MeasurableSingletonClass β]
    {_ : MeasurableSpace γ} {f : α × β → γ} (hf : ∀ y, Measurable fun x => f (x, y)) :
    Measurable f 
goal: ∀ {x : MeasurableSpace γ} {f : α × β → γ}, (∀ (y : β), Measurable fun x => f (x, y)) → Measurable f

full_name: Measurable.find
code: /-- A piecewise function on countably many pieces is measurable if all the data is measurable. -/
@[measurability]
theorem Measurable.find {_ : MeasurableSpace α} {f : ℕ → α → β} {p : ℕ → α → Prop}
    [∀ n, DecidablePred (p n)] (hf : ∀ n, Measurable (f n)) (hp : ∀ n, MeasurableSet { x | p n x })
    (h : ∀ x, ∃ n, p n x) : Measurable fun x => f (Nat.find (h x)) x 
goal: ∀ {x : MeasurableSpace α} {f : ℕ → α → β} {p : ℕ → α → Prop} [inst : (n : ℕ) → DecidablePred (p n)],
  (∀ (n : ℕ), Measurable (f n)) →
    (∀ (n : ℕ), MeasurableSet {x | p n x}) → ∀ (h : ∀ (x : α), ∃ n, p n x), Measurable fun x => f (Nat.find ⋯) x

full_name: measurable_iUnionLift
code: /-- Let `t i` be a countable covering of a set `T` by measurable sets. Let `f i : t i → β` be a
family of functions that agree on the intersections `t i ∩ t j`. Then the function
`Set.iUnionLift t f _ _ : T → β`, defined as `f i ⟨x, hx⟩` for `hx : x ∈ t i`, is measurable. -/
theorem measurable_iUnionLift [Countable ι] {t : ι → Set α} {f : ∀ i, t i → β}
    (htf : ∀ (i j) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
    {T : Set α} (hT : T ⊆ ⋃ i, t i) (htm : ∀ i, MeasurableSet (t i)) (hfm : ∀ i, Measurable (f i)) :
    Measurable (iUnionLift t f htf T hT) 
goal: Measurable (Set.iUnionLift t f htf T hT)

full_name: measurable_liftCover
code: /-- Let `t i` be a countable covering of `α` by measurable sets. Let `f i : t i → β` be a family of
functions that agree on the intersections `t i ∩ t j`. Then the function `Set.liftCover t f _ _`,
defined as `f i ⟨x, hx⟩` for `hx : x ∈ t i`, is measurable. -/
theorem measurable_liftCover [Countable ι] (t : ι → Set α) (htm : ∀ i, MeasurableSet (t i))
    (f : ∀ i, t i → β) (hfm : ∀ i, Measurable (f i))
    (hf : ∀ (i j) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
    (htU : ⋃ i, t i = univ) :
    Measurable (liftCover t f hf htU) 
goal: Measurable (Set.liftCover t f hf htU)

full_name: exists_measurable_piecewise
code: /-- Let `t i` be a nonempty countable family of measurable sets in `α`. Let `g i : α → β` be a
family of measurable functions such that `g i` agrees with `g j` on `t i ∩ t j`. Then there exists
a measurable function `f : α → β` that agrees with each `g i` on `t i`.

We only need the assumption `[Nonempty ι]` to prove `[Nonempty (α → β)]`. -/
theorem exists_measurable_piecewise {ι} [Countable ι] [Nonempty ι] (t : ι → Set α)
    (t_meas : ∀ n, MeasurableSet (t n)) (g : ι → α → β) (hg : ∀ n, Measurable (g n))
    (ht : Pairwise fun i j => EqOn (g i) (g j) (t i ∩ t j)) :
    ∃ f : α → β, Measurable f ∧ ∀ n, EqOn f (g n) (t n) 
goal: ∃ f, Measurable f ∧ ∀ (n : ι), Set.EqOn f (g n) (t n)

full_name: MeasurableSpace.pi
code: instance MeasurableSpace.pi [m : ∀ a, MeasurableSpace (π a)] : MeasurableSpace (∀ a, π a) 
goal: MeasurableSpace ((a : δ) → π a)

full_name: measurable_pi_iff
code: theorem measurable_pi_iff {g : α → ∀ a, π a} : Measurable g ↔ ∀ a, Measurable fun x => g x a 
goal: Measurable g ↔ ∀ (a : δ), Measurable fun x => g x a

full_name: measurable_pi_apply
code: @[fun_prop, aesop safe 100 apply (rule_sets := [Measurable])]
theorem measurable_pi_apply (a : δ) : Measurable fun f : ∀ a, π a => f a 
goal: Measurable fun f => f a

full_name: Measurable.eval
code: @[aesop safe 100 apply (rule_sets := [Measurable])]
theorem Measurable.eval {a : δ} {g : α → ∀ a, π a} (hg : Measurable g) :
    Measurable fun x => g x a 
goal: Measurable fun x => g x a

full_name: measurable_pi_lambda
code: @[fun_prop, aesop safe 100 apply (rule_sets := [Measurable])]
theorem measurable_pi_lambda (f : α → ∀ a, π a) (hf : ∀ a, Measurable fun c => f c a) :
    Measurable f 
goal: Measurable f

full_name: measurable_update'
code: /-- The function `(f, x) ↦ update f a x : (Π a, π a) × π a → Π a, π a` is measurable. -/
theorem measurable_update'  {a : δ} [DecidableEq δ] :
    Measurable (fun p : (∀ i, π i) × π a ↦ update p.1 a p.2) 
goal: Measurable fun p => Function.update p.1 a p.2

full_name: measurable_uniqueElim
code: theorem measurable_uniqueElim [Unique δ] [∀ i, MeasurableSpace (π i)] :
    Measurable (uniqueElim : π (default : δ) → ∀ i, π i) 
goal: Measurable uniqueElim

full_name: measurable_updateFinset
code: theorem measurable_updateFinset [DecidableEq δ] {s : Finset δ} {x : ∀ i, π i} :
    Measurable (updateFinset x s) 
goal: Measurable (Function.updateFinset x s)

full_name: measurable_update
code: /-- The function `update f a : π a → Π a, π a` is always measurable.
  This doesn't require `f` to be measurable.
  This should not be confused with the statement that `update f a x` is measurable. -/
@[measurability]
theorem measurable_update (f : ∀ a : δ, π a) {a : δ} [DecidableEq δ] : Measurable (update f a) 
goal: Measurable (Function.update f a)

full_name: measurable_update_left
code: theorem measurable_update_left {a : δ} [DecidableEq δ] {x : π a} :
    Measurable (update · a x) 
goal: Measurable fun x_1 => Function.update x_1 a x

full_name: measurable_eq_mp
code: theorem measurable_eq_mp {i i' : δ} (h : i = i') : Measurable (congr_arg π h).mp 
goal: Measurable ⋯.mp

full_name: Measurable.eq_mp
code: theorem Measurable.eq_mp {β} [MeasurableSpace β] {i i' : δ} (h : i = i') {f : β → π i}
    (hf : Measurable f) : Measurable fun x => (congr_arg π h).mp (f x) 
goal: Measurable fun x => ⋯.mp (f x)

full_name: measurable_piCongrLeft
code: theorem measurable_piCongrLeft (f : δ' ≃ δ) : Measurable (piCongrLeft π f) 
goal: Measurable ⇑(Equiv.piCongrLeft π f)

full_name: MeasurableSet.pi
code: @[measurability]
protected theorem MeasurableSet.pi {s : Set δ} {t : ∀ i : δ, Set (π i)} (hs : s.Countable)
    (ht : ∀ i ∈ s, MeasurableSet (t i)) : MeasurableSet (s.pi t) 
goal: MeasurableSet (s.pi t)

full_name: MeasurableSet.univ_pi
code: protected theorem MeasurableSet.univ_pi [Countable δ] {t : ∀ i : δ, Set (π i)}
    (ht : ∀ i, MeasurableSet (t i)) : MeasurableSet (pi univ t) 
goal: MeasurableSet (Set.univ.pi t)

full_name: measurableSet_pi_of_nonempty
code: theorem measurableSet_pi_of_nonempty {s : Set δ} {t : ∀ i, Set (π i)} (hs : s.Countable)
    (h : (pi s t).Nonempty) : MeasurableSet (pi s t) ↔ ∀ i ∈ s, MeasurableSet (t i) 
goal: MeasurableSet (s.pi t) ↔ ∀ i ∈ s, MeasurableSet (t i)

full_name: measurableSet_pi
code: theorem measurableSet_pi {s : Set δ} {t : ∀ i, Set (π i)} (hs : s.Countable) :
    MeasurableSet (pi s t) ↔ (∀ i ∈ s, MeasurableSet (t i)) ∨ pi s t = ∅ 
goal: MeasurableSet (s.pi t) ↔ (∀ i ∈ s, MeasurableSet (t i)) ∨ s.pi t = ∅

full_name: Pi.instMeasurableSingletonClass
code: instance Pi.instMeasurableSingletonClass [Countable δ] [∀ a, MeasurableSingletonClass (π a)] :
    MeasurableSingletonClass (∀ a, π a) 
goal: MeasurableSingletonClass ((a : δ) → π a)

full_name: measurable_piEquivPiSubtypeProd_symm
code: @[measurability]
theorem measurable_piEquivPiSubtypeProd_symm (p : δ → Prop) [DecidablePred p] :
    Measurable (Equiv.piEquivPiSubtypeProd p π).symm 
goal: Measurable ⇑(Equiv.piEquivPiSubtypeProd p π).symm

full_name: measurable_piEquivPiSubtypeProd
code: @[measurability]
theorem measurable_piEquivPiSubtypeProd (p : δ → Prop) [DecidablePred p] :
    Measurable (Equiv.piEquivPiSubtypeProd p π) 
goal: Measurable ⇑(Equiv.piEquivPiSubtypeProd p π)

full_name: TProd.instMeasurableSpace
code: instance TProd.instMeasurableSpace (π : δ → Type*) [∀ x, MeasurableSpace (π x)] :
    ∀ l : List δ, MeasurableSpace (List.TProd π l)
  
goal: MeasurableSpace (List.TProd π l)

full_name: measurable_tProd_mk
code: theorem measurable_tProd_mk (l : List δ) : Measurable (@TProd.mk δ π l) 
goal: Measurable (List.TProd.mk l)

full_name: measurable_tProd_elim
code: theorem measurable_tProd_elim [DecidableEq δ] :
    ∀ {l : List δ} {i : δ} (hi : i ∈ l), Measurable fun v : TProd π l => v.elim hi
  
goal: Measurable fun v => v.elim hi

full_name: measurable_tProd_elim'
code: theorem measurable_tProd_elim' [DecidableEq δ] {l : List δ} (h : ∀ i, i ∈ l) :
    Measurable (TProd.elim' h : TProd π l → ∀ i, π i) 
goal: Measurable (List.TProd.elim' h)

full_name: MeasurableSet.tProd
code: theorem MeasurableSet.tProd (l : List δ) {s : ∀ i, Set (π i)} (hs : ∀ i, MeasurableSet (s i)) :
    MeasurableSet (Set.tprod l s) 
goal: MeasurableSet (Set.tprod l s)

full_name: Sum.instMeasurableSpace
code: instance Sum.instMeasurableSpace {α β} [m₁ : MeasurableSpace α] [m₂ : MeasurableSpace β] :
    MeasurableSpace (α ⊕ β) 
goal: MeasurableSpace (α ⊕ β)

full_name: measurable_inl
code: @[measurability]
theorem measurable_inl [MeasurableSpace α] [MeasurableSpace β] : Measurable (@Sum.inl α β) 
goal: Measurable Sum.inl

full_name: measurable_inr
code: @[measurability]
theorem measurable_inr [MeasurableSpace α] [MeasurableSpace β] : Measurable (@Sum.inr α β) 
goal: Measurable Sum.inr

full_name: measurableSet_sum_iff
code: theorem measurableSet_sum_iff {s : Set (α ⊕ β)} :
    MeasurableSet s ↔ MeasurableSet (Sum.inl ⁻¹' s) ∧ MeasurableSet (Sum.inr ⁻¹' s) 
goal: MeasurableSet s ↔ MeasurableSet (Sum.inl ⁻¹' s) ∧ MeasurableSet (Sum.inr ⁻¹' s)

full_name: measurable_sum
code: theorem measurable_sum {_ : MeasurableSpace γ} {f : α ⊕ β → γ} (hl : Measurable (f ∘ Sum.inl))
    (hr : Measurable (f ∘ Sum.inr)) : Measurable f 
goal: ∀ {x : MeasurableSpace γ} {f : α ⊕ β → γ}, Measurable (f ∘ Sum.inl) → Measurable (f ∘ Sum.inr) → Measurable f

full_name: Measurable.sumElim
code: @[measurability]
theorem Measurable.sumElim {_ : MeasurableSpace γ} {f : α → γ} {g : β → γ} (hf : Measurable f)
    (hg : Measurable g) : Measurable (Sum.elim f g) 
goal: ∀ {x : MeasurableSpace γ} {f : α → γ} {g : β → γ}, Measurable f → Measurable g → Measurable (Sum.elim f g)

full_name: Measurable.sumMap
code: theorem Measurable.sumMap {_ : MeasurableSpace γ} {_ : MeasurableSpace δ} {f : α → β} {g : γ → δ}
    (hf : Measurable f) (hg : Measurable g) : Measurable (Sum.map f g) 
goal: ∀ {x : MeasurableSpace γ} {x_1 : MeasurableSpace δ} {f : α → β} {g : γ → δ},
  Measurable f → Measurable g → Measurable (Sum.map f g)

full_name: measurableSet_inl_image
code: @[simp] theorem measurableSet_inl_image {s : Set α} :
    MeasurableSet (Sum.inl '' s : Set (α ⊕ β)) ↔ MeasurableSet s 
goal: MeasurableSet (Sum.inl '' s) ↔ MeasurableSet s

full_name: measurableSet_inr_image
code: @[simp] theorem measurableSet_inr_image {s : Set β} :
    MeasurableSet (Sum.inr '' s : Set (α ⊕ β)) ↔ MeasurableSet s 
goal: MeasurableSet (Sum.inr '' s) ↔ MeasurableSet s

full_name: measurableSet_range_inl
code: theorem measurableSet_range_inl [MeasurableSpace α] :
    MeasurableSet (range Sum.inl : Set (α ⊕ β)) 
goal: MeasurableSet (Set.range Sum.inl)

full_name: measurableSet_range_inr
code: theorem measurableSet_range_inr [MeasurableSpace α] :
    MeasurableSet (range Sum.inr : Set (α ⊕ β)) 
goal: MeasurableSet (Set.range Sum.inr)

full_name: Sigma.instMeasurableSpace
code: instance Sigma.instMeasurableSpace {α} {β : α → Type*} [m : ∀ a, MeasurableSpace (β a)] :
    MeasurableSpace (Sigma β) 
goal: MeasurableSpace (Sigma β)

full_name: measurableSet_setOf
code: @[simp] theorem measurableSet_setOf : MeasurableSet {a | p a} ↔ Measurable p 
goal: MeasurableSet {a | p a} ↔ Measurable p

full_name: measurable_mem
code: @[simp] theorem measurable_mem : Measurable (· ∈ s) ↔ MeasurableSet s 
goal: (Measurable fun x => x ∈ s) ↔ MeasurableSet s

full_name: Measurable.not
code: lemma Measurable.not (hp : Measurable p) : Measurable (¬ p ·) 
goal: Measurable fun x => ¬p x

full_name: Measurable.and
code: lemma Measurable.and (hp : Measurable p) (hq : Measurable q) : Measurable fun a ↦ p a ∧ q a 
goal: Measurable fun a => p a ∧ q a

full_name: Measurable.or
code: lemma Measurable.or (hp : Measurable p) (hq : Measurable q) : Measurable fun a ↦ p a ∨ q a 
goal: Measurable fun a => p a ∨ q a

full_name: Measurable.imp
code: lemma Measurable.imp (hp : Measurable p) (hq : Measurable q) : Measurable fun a ↦ p a → q a 
goal: Measurable fun a => p a → q a

full_name: Measurable.iff
code: lemma Measurable.iff (hp : Measurable p) (hq : Measurable q) : Measurable fun a ↦ p a ↔ q a 
goal: Measurable fun a => p a ↔ q a

full_name: Measurable.forall
code: lemma Measurable.forall [Countable ι] {p : ι → α → Prop} (hp : ∀ i, Measurable (p i)) :
    Measurable fun a ↦ ∀ i, p i a 
goal: Measurable fun a => ∀ (i : ι), p i a

full_name: Measurable.exists
code: lemma Measurable.exists [Countable ι] {p : ι → α → Prop} (hp : ∀ i, Measurable (p i)) :
    Measurable fun a ↦ ∃ i, p i a 
goal: Measurable fun a => ∃ i, p i a

full_name: Set.instMeasurableSpace
code: /-- This instance is useful when talking about Bernoulli sequences of random variables or binomial
random graphs. -/
instance Set.instMeasurableSpace : MeasurableSpace (Set α) 
goal: MeasurableSpace (Set α)

full_name: Set.instMeasurableSingletonClass
code: instance Set.instMeasurableSingletonClass [Countable α] : MeasurableSingletonClass (Set α) 
goal: MeasurableSingletonClass (Set α)

full_name: measurable_set_iff
code: lemma measurable_set_iff : Measurable g ↔ ∀ a, Measurable fun x ↦ a ∈ g x 
goal: Measurable g ↔ ∀ (a : α), Measurable fun x => a ∈ g x

full_name: measurable_set_mem
code: @[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurable_set_mem (a : α) : Measurable fun s : Set α ↦ a ∈ s 
goal: Measurable fun s => a ∈ s

full_name: measurable_set_not_mem
code: @[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurable_set_not_mem (a : α) : Measurable fun s : Set α ↦ a ∉ s 
goal: Measurable fun s => a ∉ s

full_name: measurableSet_mem
code: @[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurableSet_mem (a : α) : MeasurableSet {s : Set α | a ∈ s} 
goal: MeasurableSet {s | a ∈ s}

full_name: measurableSet_not_mem
code: @[aesop safe 100 apply (rule_sets := [Measurable])]
lemma measurableSet_not_mem (a : α) : MeasurableSet {s : Set α | a ∉ s} 
goal: MeasurableSet {s | a ∉ s}

full_name: measurable_compl
code: lemma measurable_compl : Measurable ((·ᶜ) : Set α → Set α) 
goal: Measurable fun x => xᶜ

full_name: MeasurableSpace.generateFrom_singleton
code: /-- The sigma-algebra generated by a single set `s` is `{∅, s, sᶜ, univ}`. -/
@[simp] theorem generateFrom_singleton (s : Set α) :
    generateFrom {s} = MeasurableSpace.comap (· ∈ s) ⊤ 
goal: MeasurableSpace.generateFrom {s} = MeasurableSpace.comap (fun x => x ∈ s) ⊤

full_name: Filter.IsMeasurablyGenerated
code: /-- A filter `f` is measurably generates if each `s ∈ f` includes a measurable `t ∈ f`. -/
class IsMeasurablyGenerated (f : Filter α) : Prop where
  exists_measurable_subset : ∀ ⦃s⦄, s ∈ f → ∃ t ∈ f, MeasurableSet t ∧ t ⊆ s
goal: Prop

full_name: Filter.IsMeasurablyGenerated.exists_measurable_subset
code: /-- A filter `f` is measurably generates if each `s ∈ f` includes a measurable `t ∈ f`. -/
class IsMeasurablyGenerated (f : Filter α) : Prop where
  exists_measurable_subset : ∀ ⦃s⦄, s ∈ f → ∃ t ∈ f, MeasurableSet t ∧ t ⊆ s
goal: s ∈ f → ∃ t ∈ f, MeasurableSet t ∧ t ⊆ s

full_name: Filter.isMeasurablyGenerated_bot
code: instance isMeasurablyGenerated_bot : IsMeasurablyGenerated (⊥ : Filter α) 
goal: ⊥.IsMeasurablyGenerated

full_name: Filter.isMeasurablyGenerated_top
code: instance isMeasurablyGenerated_top : IsMeasurablyGenerated (⊤ : Filter α) 
goal: ⊤.IsMeasurablyGenerated

full_name: Filter.Eventually.exists_measurable_mem
code: theorem Eventually.exists_measurable_mem {f : Filter α} [IsMeasurablyGenerated f] {p : α → Prop}
    (h : ∀ᶠ x in f, p x) : ∃ s ∈ f, MeasurableSet s ∧ ∀ x ∈ s, p x 
goal: ∃ s ∈ f, MeasurableSet s ∧ ∀ x ∈ s, p x

full_name: Filter.Eventually.exists_measurable_mem_of_smallSets
code: theorem Eventually.exists_measurable_mem_of_smallSets {f : Filter α} [IsMeasurablyGenerated f]
    {p : Set α → Prop} (h : ∀ᶠ s in f.smallSets, p s) : ∃ s ∈ f, MeasurableSet s ∧ p s 
goal: ∃ s ∈ f, MeasurableSet s ∧ p s

full_name: Filter.inf_isMeasurablyGenerated
code: instance inf_isMeasurablyGenerated (f g : Filter α) [IsMeasurablyGenerated f]
    [IsMeasurablyGenerated g] : IsMeasurablyGenerated (f ⊓ g) 
goal: (f ⊓ g).IsMeasurablyGenerated

full_name: Filter.principal_isMeasurablyGenerated_iff
code: theorem principal_isMeasurablyGenerated_iff {s : Set α} :
    IsMeasurablyGenerated (𝓟 s) ↔ MeasurableSet s 
goal: (𝓟 s).IsMeasurablyGenerated ↔ MeasurableSet s

full_name: Filter.iInf_isMeasurablyGenerated
code: instance iInf_isMeasurablyGenerated {f : ι → Filter α} [∀ i, IsMeasurablyGenerated (f i)] :
    IsMeasurablyGenerated (⨅ i, f i) 
goal: (⨅ i, f i).IsMeasurablyGenerated

full_name: measurableSet_tendsto
code: /-- The set of points for which a sequence of measurable functions converges to a given value
is measurable. -/
@[measurability]
lemma measurableSet_tendsto {_ : MeasurableSpace β} [MeasurableSpace γ]
    [Countable δ] {l : Filter δ} [l.IsCountablyGenerated]
    (l' : Filter γ) [l'.IsCountablyGenerated] [hl' : l'.IsMeasurablyGenerated]
    {f : δ → β → γ} (hf : ∀ i, Measurable (f i)) :
    MeasurableSet { x | Tendsto (fun n ↦ f n x) l l' } 
goal: ∀ {x : MeasurableSpace β} [inst : MeasurableSpace γ] [inst_1 : Countable δ] {l : Filter δ}
  [inst_2 : l.IsCountablyGenerated] (l' : Filter γ) [inst_3 : l'.IsCountablyGenerated] [hl' : l'.IsMeasurablyGenerated]
  {f : δ → β → γ}, (∀ (i : δ), Measurable (f i)) → MeasurableSet {x | Filter.Tendsto (fun n => f n x) l l'}

full_name: IsCountablySpanning
code: /-- We say that a collection of sets is countably spanning if a countable subset spans the
whole type. This is a useful condition in various parts of measure theory. For example, it is
a needed condition to show that the product of two collections generate the product sigma algebra,
see `generateFrom_prod_eq`. -/
def IsCountablySpanning (C : Set (Set α)) : Prop 
goal: Prop

full_name: isCountablySpanning_measurableSet
code: theorem isCountablySpanning_measurableSet [MeasurableSpace α] :
    IsCountablySpanning { s : Set α | MeasurableSet s } 
goal: IsCountablySpanning {s | MeasurableSet s}

full_name: MeasurableSet.Subtype.instMembership
code: instance Subtype.instMembership : Membership α (Subtype (MeasurableSet : Set α → Prop)) 
goal: Membership α (Subtype MeasurableSet)

full_name: MeasurableSet.mem_coe
code: @[simp]
theorem mem_coe (a : α) (s : Subtype (MeasurableSet : Set α → Prop)) : a ∈ (s : Set α) ↔ a ∈ s 
goal: a ∈ ↑s ↔ a ∈ s

full_name: MeasurableSet.Subtype.instEmptyCollection
code: instance Subtype.instEmptyCollection : EmptyCollection (Subtype (MeasurableSet : Set α → Prop)) 
goal: EmptyCollection (Subtype MeasurableSet)

full_name: MeasurableSet.coe_empty
code: @[simp]
theorem coe_empty : ↑(∅ : Subtype (MeasurableSet : Set α → Prop)) = (∅ : Set α) 
goal: ↑∅ = ∅

full_name: MeasurableSet.Subtype.instInsert
code: instance Subtype.instInsert [MeasurableSingletonClass α] :
    Insert α (Subtype (MeasurableSet : Set α → Prop)) 
goal: Insert α (Subtype MeasurableSet)

full_name: MeasurableSet.coe_insert
code: @[simp]
theorem coe_insert [MeasurableSingletonClass α] (a : α)
    (s : Subtype (MeasurableSet : Set α → Prop)) :
    ↑(Insert.insert a s) = (Insert.insert a s : Set α) 
goal: ↑(insert a s) = insert a ↑s

full_name: MeasurableSet.Subtype.instSingleton
code: instance Subtype.instSingleton [MeasurableSingletonClass α] :
    Singleton α (Subtype (MeasurableSet : Set α → Prop)) 
goal: Singleton α (Subtype MeasurableSet)

full_name: MeasurableSet.coe_singleton
code: @[simp] theorem coe_singleton [MeasurableSingletonClass α] (a : α) :
    ↑({a} : Subtype (MeasurableSet : Set α → Prop)) = ({a} : Set α) 
goal: ↑{a} = {a}

full_name: MeasurableSet.Subtype.instLawfulSingleton
code: instance Subtype.instLawfulSingleton [MeasurableSingletonClass α] :
    LawfulSingleton α (Subtype (MeasurableSet : Set α → Prop)) 
goal: LawfulSingleton α (Subtype MeasurableSet)

full_name: MeasurableSet.Subtype.instHasCompl
code: instance Subtype.instHasCompl : HasCompl (Subtype (MeasurableSet : Set α → Prop)) 
goal: HasCompl (Subtype MeasurableSet)

full_name: MeasurableSet.coe_compl
code: @[simp]
theorem coe_compl (s : Subtype (MeasurableSet : Set α → Prop)) : ↑sᶜ = (sᶜ : Set α) 
goal: ↑sᶜ = (↑s)ᶜ

full_name: MeasurableSet.Subtype.instUnion
code: instance Subtype.instUnion : Union (Subtype (MeasurableSet : Set α → Prop)) 
goal: Union (Subtype MeasurableSet)

full_name: MeasurableSet.coe_union
code: @[simp]
theorem coe_union (s t : Subtype (MeasurableSet : Set α → Prop)) : ↑(s ∪ t) = (s ∪ t : Set α) 
goal: ↑(s ∪ t) = ↑s ∪ ↑t

full_name: MeasurableSet.Subtype.instSup
code: instance Subtype.instSup : Sup (Subtype (MeasurableSet : Set α → Prop)) 
goal: Sup (Subtype MeasurableSet)

full_name: MeasurableSet.sup_eq_union
code: @[simp]
protected theorem sup_eq_union (s t : {s : Set α // MeasurableSet s}) : s ⊔ t = s ∪ t 
goal: s ⊔ t = s ∪ t

full_name: MeasurableSet.Subtype.instInter
code: instance Subtype.instInter : Inter (Subtype (MeasurableSet : Set α → Prop)) 
goal: Inter (Subtype MeasurableSet)

full_name: MeasurableSet.coe_inter
code: @[simp]
theorem coe_inter (s t : Subtype (MeasurableSet : Set α → Prop)) : ↑(s ∩ t) = (s ∩ t : Set α) 
goal: ↑(s ∩ t) = ↑s ∩ ↑t

full_name: MeasurableSet.Subtype.instInf
code: instance Subtype.instInf : Inf (Subtype (MeasurableSet : Set α → Prop)) 
goal: Inf (Subtype MeasurableSet)

full_name: MeasurableSet.inf_eq_inter
code: @[simp]
protected theorem inf_eq_inter (s t : {s : Set α // MeasurableSet s}) : s ⊓ t = s ∩ t 
goal: s ⊓ t = s ∩ t

full_name: MeasurableSet.Subtype.instSDiff
code: instance Subtype.instSDiff : SDiff (Subtype (MeasurableSet : Set α → Prop)) 
goal: SDiff (Subtype MeasurableSet)

full_name: MeasurableSet.Subtype.instHImp
code: noncomputable instance Subtype.instHImp : HImp (Subtype (MeasurableSet : Set α → Prop)) 
goal: HImp (Subtype MeasurableSet)

full_name: MeasurableSet.coe_sdiff
code: @[simp]
theorem coe_sdiff (s t : Subtype (MeasurableSet : Set α → Prop)) : ↑(s \ t) = (s : Set α) \ t 
goal: ↑(s \ t) = ↑s \ ↑t

full_name: MeasurableSet.coe_himp
code: @[simp]
lemma coe_himp (s t : Subtype (MeasurableSet : Set α → Prop)) : ↑(s ⇨ t) = (s ⇨ t : Set α) 
goal: ↑(s ⇨ t) = ↑s ⇨ ↑t

full_name: MeasurableSet.Subtype.instBot
code: instance Subtype.instBot : Bot (Subtype (MeasurableSet : Set α → Prop)) 
goal: Bot (Subtype MeasurableSet)

full_name: MeasurableSet.coe_bot
code: @[simp]
theorem coe_bot : ↑(⊥ : Subtype (MeasurableSet : Set α → Prop)) = (⊥ : Set α) 
goal: ↑⊥ = ⊥

full_name: MeasurableSet.Subtype.instTop
code: instance Subtype.instTop : Top (Subtype (MeasurableSet : Set α → Prop)) 
goal: Top (Subtype MeasurableSet)

full_name: MeasurableSet.coe_top
code: @[simp]
theorem coe_top : ↑(⊤ : Subtype (MeasurableSet : Set α → Prop)) = (⊤ : Set α) 
goal: ↑⊤ = ⊤

full_name: MeasurableSet.Subtype.instBooleanAlgebra
code: noncomputable instance Subtype.instBooleanAlgebra :
    BooleanAlgebra (Subtype (MeasurableSet : Set α → Prop)) 
goal: BooleanAlgebra (Subtype MeasurableSet)

full_name: MeasurableSet.measurableSet_blimsup
code: @[measurability]
theorem measurableSet_blimsup {s : ℕ → Set α} {p : ℕ → Prop} (h : ∀ n, p n → MeasurableSet (s n)) :
    MeasurableSet <| blimsup s atTop p 
goal: MeasurableSet (Filter.blimsup s Filter.atTop p)

full_name: MeasurableSet.measurableSet_bliminf
code: @[measurability]
theorem measurableSet_bliminf {s : ℕ → Set α} {p : ℕ → Prop} (h : ∀ n, p n → MeasurableSet (s n)) :
    MeasurableSet <| Filter.bliminf s Filter.atTop p 
goal: MeasurableSet (Filter.bliminf s Filter.atTop p)

full_name: MeasurableSet.measurableSet_limsup
code: @[measurability]
theorem measurableSet_limsup {s : ℕ → Set α} (hs : ∀ n, MeasurableSet <| s n) :
    MeasurableSet <| Filter.limsup s Filter.atTop 
goal: MeasurableSet (Filter.limsup s Filter.atTop)

full_name: MeasurableSet.measurableSet_liminf
code: @[measurability]
theorem measurableSet_liminf {s : ℕ → Set α} (hs : ∀ n, MeasurableSet <| s n) :
    MeasurableSet <| Filter.liminf s Filter.atTop 
goal: MeasurableSet (Filter.liminf s Filter.atTop)