File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

full_name: MeasurableSpace.CountablyGenerated
code: /-- We say a measurable space is countably generated
if it can be generated by a countable set of sets. -/
class CountablyGenerated (α : Type*) [m : MeasurableSpace α] : Prop where
  isCountablyGenerated : ∃ b : Set (Set α), b.Countable ∧ m = generateFrom b
goal: Prop

full_name: MeasurableSpace.CountablyGenerated.isCountablyGenerated
code: /-- We say a measurable space is countably generated
if it can be generated by a countable set of sets. -/
class CountablyGenerated (α : Type*) [m : MeasurableSpace α] : Prop where
  isCountablyGenerated : ∃ b : Set (Set α), b.Countable ∧ m = generateFrom b
goal: ∃ b, b.Countable ∧ m = MeasurableSpace.generateFrom b

full_name: MeasurableSpace.countableGeneratingSet
code: /-- A countable set of sets that generate the measurable space.
We insert `∅` to ensure it is nonempty. -/
def countableGeneratingSet (α : Type*) [MeasurableSpace α] [h : CountablyGenerated α] :
    Set (Set α) 
goal: Set (Set α)

full_name: MeasurableSpace.countable_countableGeneratingSet
code: lemma countable_countableGeneratingSet [MeasurableSpace α] [h : CountablyGenerated α] :
    Set.Countable (countableGeneratingSet α) 
goal: (MeasurableSpace.countableGeneratingSet α).Countable

full_name: MeasurableSpace.generateFrom_countableGeneratingSet
code: lemma generateFrom_countableGeneratingSet [m : MeasurableSpace α] [h : CountablyGenerated α] :
    generateFrom (countableGeneratingSet α) = m 
goal: MeasurableSpace.generateFrom (MeasurableSpace.countableGeneratingSet α) = m

full_name: MeasurableSpace.empty_mem_countableGeneratingSet
code: lemma empty_mem_countableGeneratingSet [MeasurableSpace α] [CountablyGenerated α] :
    ∅ ∈ countableGeneratingSet α 
goal: ∅ ∈ MeasurableSpace.countableGeneratingSet α

full_name: MeasurableSpace.nonempty_countableGeneratingSet
code: lemma nonempty_countableGeneratingSet [MeasurableSpace α] [CountablyGenerated α] :
    Set.Nonempty (countableGeneratingSet α) 
goal: (MeasurableSpace.countableGeneratingSet α).Nonempty

full_name: MeasurableSpace.measurableSet_countableGeneratingSet
code: lemma measurableSet_countableGeneratingSet [MeasurableSpace α] [CountablyGenerated α]
    {s : Set α} (hs : s ∈ countableGeneratingSet α) :
    MeasurableSet s 
goal: MeasurableSet s

full_name: MeasurableSpace.natGeneratingSequence
code: /-- A countable sequence of sets generating the measurable space. -/
def natGeneratingSequence (α : Type*) [MeasurableSpace α] [CountablyGenerated α] : ℕ → (Set α) 
goal: ℕ → Set α

full_name: MeasurableSpace.generateFrom_natGeneratingSequence
code: lemma generateFrom_natGeneratingSequence (α : Type*) [m : MeasurableSpace α]
    [CountablyGenerated α] : generateFrom (range (natGeneratingSequence _)) = m 
goal: MeasurableSpace.generateFrom (Set.range (MeasurableSpace.natGeneratingSequence α)) = m

full_name: MeasurableSpace.measurableSet_natGeneratingSequence
code: lemma measurableSet_natGeneratingSequence [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    MeasurableSet (natGeneratingSequence α n) 
goal: MeasurableSet (MeasurableSpace.natGeneratingSequence α n)

full_name: MeasurableSpace.CountablyGenerated.comap
code: theorem CountablyGenerated.comap [m : MeasurableSpace β] [h : CountablyGenerated β] (f : α → β) :
    @CountablyGenerated α (.comap f m) 
goal: MeasurableSpace.CountablyGenerated α

full_name: MeasurableSpace.CountablyGenerated.sup
code: theorem CountablyGenerated.sup {m₁ m₂ : MeasurableSpace β} (h₁ : @CountablyGenerated β m₁)
    (h₂ : @CountablyGenerated β m₂) : @CountablyGenerated β (m₁ ⊔ m₂) 
goal: MeasurableSpace.CountablyGenerated β

full_name: MeasurableSpace.instCountablyGeneratedOfCountable
code: /-- Any measurable space structure on a countable space is countably generated. -/
instance (priority := 100) [MeasurableSpace α] [Countable α] : CountablyGenerated α 
goal: MeasurableSpace.CountablyGenerated α

full_name: MeasurableSpace.instCountablyGeneratedSubtype
code: instance [MeasurableSpace α] [CountablyGenerated α] {p : α → Prop} :
    CountablyGenerated { x // p x } 
goal: MeasurableSpace.CountablyGenerated { x // p x }

full_name: MeasurableSpace.instCountablyGeneratedProd
code: instance [MeasurableSpace α] [CountablyGenerated α] [MeasurableSpace β] [CountablyGenerated β] :
    CountablyGenerated (α × β) 
goal: MeasurableSpace.CountablyGenerated (α × β)

full_name: MeasurableSpace.SeparatesPoints.separates
code: /-- We say that a measurable space separates points if for any two distinct points,
there is a measurable set containing one but not the other. -/
class SeparatesPoints (α : Type*) [m : MeasurableSpace α] : Prop where
  separates : ∀ x y : α, (∀ s, MeasurableSet s → (x ∈ s → y ∈ s)) → x = y
goal: (∀ (s : Set α), MeasurableSet s → x ∈ s → y ∈ s) → x = y

full_name: MeasurableSpace.SeparatesPoints
code: /-- We say that a measurable space separates points if for any two distinct points,
there is a measurable set containing one but not the other. -/
class SeparatesPoints (α : Type*) [m : MeasurableSpace α] : Prop where
  separates : ∀ x y : α, (∀ s, MeasurableSet s → (x ∈ s → y ∈ s)) → x = y
goal: Prop

full_name: MeasurableSpace.separatesPoints_def
code: theorem separatesPoints_def [MeasurableSpace α] [hs : SeparatesPoints α] {x y : α}
    (h : ∀ s, MeasurableSet s → (x ∈ s → y ∈ s)) : x = y 
goal: x = y

full_name: MeasurableSpace.exists_measurableSet_of_ne
code: theorem exists_measurableSet_of_ne [MeasurableSpace α] [SeparatesPoints α] {x y : α}
    (h : x ≠ y) : ∃ s, MeasurableSet s ∧ x ∈ s ∧ y ∉ s 
goal: ∃ s, MeasurableSet s ∧ x ∈ s ∧ y ∉ s

full_name: MeasurableSpace.separatesPoints_iff
code: theorem separatesPoints_iff [MeasurableSpace α] : SeparatesPoints α ↔
    ∀ x y : α, (∀ s, MeasurableSet s → (x ∈ s ↔ y ∈ s)) → x = y 
goal: MeasurableSpace.SeparatesPoints α ↔ ∀ (x y : α), (∀ (s : Set α), MeasurableSet s → (x ∈ s ↔ y ∈ s)) → x = y

full_name: MeasurableSpace.separating_of_generateFrom
code: /-- If the measurable space generated by `S` separates points,
then this is witnessed by sets in `S`. -/
theorem separating_of_generateFrom (S : Set (Set α))
    [h : @SeparatesPoints α (generateFrom S)] :
    ∀ x y : α, (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y 
goal: (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y

full_name: MeasurableSpace.SeparatesPoints.mono
code: theorem SeparatesPoints.mono {m m' : MeasurableSpace α} [hsep : @SeparatesPoints _ m] (h : m ≤ m') :
    @SeparatesPoints _ m' 
goal: MeasurableSpace.SeparatesPoints α

full_name: MeasurableSpace.CountablySeparated.countably_separated
code: /-- We say that a measurable space is countably separated if there is a
countable sequence of measurable sets separating points. -/
class CountablySeparated (α : Type*) [MeasurableSpace α] : Prop where
  countably_separated : HasCountableSeparatingOn α MeasurableSet univ
goal: HasCountableSeparatingOn α MeasurableSet Set.univ

full_name: MeasurableSpace.CountablySeparated
code: /-- We say that a measurable space is countably separated if there is a
countable sequence of measurable sets separating points. -/
class CountablySeparated (α : Type*) [MeasurableSpace α] : Prop where
  countably_separated : HasCountableSeparatingOn α MeasurableSet univ
goal: Prop

full_name: MeasurableSpace.countablySeparated_of_hasCountableSeparatingOn
code: instance countablySeparated_of_hasCountableSeparatingOn [MeasurableSpace α]
    [h : HasCountableSeparatingOn α MeasurableSet univ] : CountablySeparated α 
goal: MeasurableSpace.CountablySeparated α

full_name: MeasurableSpace.hasCountableSeparatingOn_of_countablySeparated
code: instance hasCountableSeparatingOn_of_countablySeparated [MeasurableSpace α]
    [h : CountablySeparated α] : HasCountableSeparatingOn α MeasurableSet univ 
goal: HasCountableSeparatingOn α MeasurableSet Set.univ

full_name: MeasurableSpace.countablySeparated_def
code: theorem countablySeparated_def [MeasurableSpace α] :
    CountablySeparated α ↔ HasCountableSeparatingOn α MeasurableSet univ 
goal: MeasurableSpace.CountablySeparated α ↔ HasCountableSeparatingOn α MeasurableSet Set.univ

full_name: MeasurableSpace.CountablySeparated.mono
code: theorem CountablySeparated.mono {m m' : MeasurableSpace α} [hsep : @CountablySeparated _ m]
    (h : m ≤ m') : @CountablySeparated _ m' 
goal: MeasurableSpace.CountablySeparated α

full_name: MeasurableSpace.CountablySeparated.subtype_iff
code: theorem CountablySeparated.subtype_iff [MeasurableSpace α] {s : Set α} :
    CountablySeparated s ↔ HasCountableSeparatingOn α MeasurableSet s 
goal: MeasurableSpace.CountablySeparated ↑s ↔ HasCountableSeparatingOn α MeasurableSet s

full_name: MeasurableSpace.Subtype.separatesPoints
code: instance (priority := 100) Subtype.separatesPoints [MeasurableSpace α] [h : SeparatesPoints α]
    {s : Set α} : SeparatesPoints s 
goal: MeasurableSpace.SeparatesPoints ↑s

full_name: MeasurableSpace.Subtype.countablySeparated
code: instance (priority := 100) Subtype.countablySeparated [MeasurableSpace α]
    [h : CountablySeparated α] {s : Set α} : CountablySeparated s 
goal: MeasurableSpace.CountablySeparated ↑s

full_name: MeasurableSpace.separatesPoints_of_measurableSingletonClass
code: instance (priority := 100) separatesPoints_of_measurableSingletonClass [MeasurableSpace α]
    [MeasurableSingletonClass α] : SeparatesPoints α 
goal: MeasurableSpace.SeparatesPoints α

full_name: MeasurableSpace.hasCountableSeparatingOn_of_countablySeparated_subtype
code: instance hasCountableSeparatingOn_of_countablySeparated_subtype
    [MeasurableSpace α] {s : Set α} [h : CountablySeparated s] :
    HasCountableSeparatingOn _ MeasurableSet s 
goal: HasCountableSeparatingOn α MeasurableSet s

full_name: MeasurableSpace.countablySeparated_subtype_of_hasCountableSeparatingOn
code: instance countablySeparated_subtype_of_hasCountableSeparatingOn
    [MeasurableSpace α] {s : Set α} [h : HasCountableSeparatingOn _ MeasurableSet s] :
    CountablySeparated s 
goal: MeasurableSpace.CountablySeparated ↑s

full_name: MeasurableSpace.countablySeparated_of_separatesPoints
code: instance countablySeparated_of_separatesPoints [MeasurableSpace α]
    [h : CountablyGenerated α] [SeparatesPoints α] : CountablySeparated α 
goal: MeasurableSpace.CountablySeparated α

full_name: MeasurableSpace.exists_countablyGenerated_le_of_countablySeparated
code: /-- If a measurable space admits a countable separating family of measurable sets,
there is a countably generated coarser space which still separates points. -/
theorem exists_countablyGenerated_le_of_countablySeparated [m : MeasurableSpace α]
    [h : CountablySeparated α] :
    ∃ m' : MeasurableSpace α, @CountablyGenerated _ m' ∧ @SeparatesPoints _ m' ∧ m' ≤ m 
goal: ∃ m', MeasurableSpace.CountablyGenerated α ∧ MeasurableSpace.SeparatesPoints α ∧ m' ≤ m

full_name: MeasurableSpace.mapNatBool
code: /-- A map from a measurable space to the Cantor space `ℕ → Bool` induced by a countable
sequence of sets generating the measurable space. -/
noncomputable
def mapNatBool [MeasurableSpace α] [CountablyGenerated α] (x : α) (n : ℕ) :
    Bool 
goal: Bool

full_name: MeasurableSpace.measurable_mapNatBool
code: theorem measurable_mapNatBool [MeasurableSpace α] [CountablyGenerated α] :
    Measurable (mapNatBool α) 
goal: Measurable (MeasurableSpace.mapNatBool α)

full_name: MeasurableSpace.injective_mapNatBool
code: theorem injective_mapNatBool [MeasurableSpace α] [CountablyGenerated α]
    [SeparatesPoints α] : Injective (mapNatBool α) 
goal: Function.Injective (MeasurableSpace.mapNatBool α)

full_name: MeasurableSpace.measurableEquiv_nat_bool_of_countablyGenerated
code: /-- If a measurable space is countably generated and separates points, it is measure equivalent
to some subset of the Cantor space `ℕ → Bool` (equipped with the product sigma algebra).
Note: `s` need not be measurable, so this map need not be a `MeasurableEmbedding` to
the Cantor Space. -/
theorem measurableEquiv_nat_bool_of_countablyGenerated [MeasurableSpace α]
    [CountablyGenerated α] [SeparatesPoints α] :
    ∃ s : Set (ℕ → Bool), Nonempty (α ≃ᵐ s) 
goal: ∃ s, Nonempty (α ≃ᵐ ↑s)

full_name: MeasurableSpace.measurable_injection_nat_bool_of_countablySeparated
code: /-- If a measurable space admits a countable sequence of measurable sets separating points,
it admits a measurable injection into the Cantor space `ℕ → Bool`
(equipped with the product sigma algebra). -/
theorem measurable_injection_nat_bool_of_countablySeparated [MeasurableSpace α]
    [CountablySeparated α] : ∃ f : α → ℕ → Bool, Measurable f ∧ Injective f 
goal: ∃ f, Measurable f ∧ Function.Injective f

full_name: MeasurableSpace.measurableSingletonClass_of_countablySeparated
code: theorem measurableSingletonClass_of_countablySeparated
    [MeasurableSpace α] [CountablySeparated α] :
    MeasurableSingletonClass α 
goal: MeasurableSingletonClass α

full_name: MeasurableSpace.measurableSet_succ_memPartition
code: lemma measurableSet_succ_memPartition (t : ℕ → Set α) (n : ℕ) {s : Set α}
    (hs : s ∈ memPartition t n) :
    MeasurableSet[generateFrom (memPartition t (n + 1))] s 
goal: MeasurableSet s

full_name: MeasurableSpace.generateFrom_memPartition_le_succ
code: lemma generateFrom_memPartition_le_succ (t : ℕ → Set α) (n : ℕ) :
    generateFrom (memPartition t n) ≤ generateFrom (memPartition t (n + 1)) 
goal: MeasurableSpace.generateFrom (memPartition t n) ≤ MeasurableSpace.generateFrom (memPartition t (n + 1))

full_name: MeasurableSpace.measurableSet_generateFrom_memPartition_iff
code: lemma measurableSet_generateFrom_memPartition_iff (t : ℕ → Set α) (n : ℕ) (s : Set α) :
    MeasurableSet[generateFrom (memPartition t n)] s
      ↔ ∃ S : Finset (Set α), ↑S ⊆ memPartition t n ∧ s = ⋃₀ S 
goal: MeasurableSet s ↔ ∃ S, ↑S ⊆ memPartition t n ∧ s = ⋃₀ ↑S

full_name: MeasurableSpace.measurableSet_generateFrom_memPartition
code: lemma measurableSet_generateFrom_memPartition (t : ℕ → Set α) (n : ℕ) :
    MeasurableSet[generateFrom (memPartition t (n + 1))] (t n) 
goal: MeasurableSet (t n)

full_name: MeasurableSpace.generateFrom_iUnion_memPartition
code: lemma generateFrom_iUnion_memPartition (t : ℕ → Set α) :
    generateFrom (⋃ n, memPartition t n) = generateFrom (range t) 
goal: MeasurableSpace.generateFrom (⋃ n, memPartition t n) = MeasurableSpace.generateFrom (Set.range t)

full_name: MeasurableSpace.generateFrom_memPartition_le_range
code: lemma generateFrom_memPartition_le_range (t : ℕ → Set α) (n : ℕ) :
    generateFrom (memPartition t n) ≤ generateFrom (range t) 
goal: MeasurableSpace.generateFrom (memPartition t n) ≤ MeasurableSpace.generateFrom (Set.range t)

full_name: MeasurableSpace.generateFrom_iUnion_memPartition_le
code: lemma generateFrom_iUnion_memPartition_le [m : MeasurableSpace α] {t : ℕ → Set α}
    (ht : ∀ n, MeasurableSet (t n)) :
    generateFrom (⋃ n, memPartition t n) ≤ m 
goal: MeasurableSpace.generateFrom (⋃ n, memPartition t n) ≤ m

full_name: MeasurableSpace.generateFrom_memPartition_le
code: lemma generateFrom_memPartition_le [m : MeasurableSpace α] {t : ℕ → Set α}
    (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) :
    generateFrom (memPartition t n) ≤ m 
goal: MeasurableSpace.generateFrom (memPartition t n) ≤ m

full_name: MeasurableSpace.measurableSet_memPartition
code: lemma measurableSet_memPartition [MeasurableSpace α] {t : ℕ → Set α}
    (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) {s : Set α} (hs : s ∈ memPartition t n) :
    MeasurableSet s 
goal: MeasurableSet s

full_name: MeasurableSpace.measurableSet_memPartitionSet
code: lemma measurableSet_memPartitionSet [MeasurableSpace α] {t : ℕ → Set α}
    (ht : ∀ n, MeasurableSet (t n)) (n : ℕ) (a : α) :
    MeasurableSet (memPartitionSet t n a) 
goal: MeasurableSet (memPartitionSet t n a)

full_name: MeasurableSpace.countablePartition
code: /-- For each `n : ℕ`, `countablePartition α n` is a partition of the space in at most
`2^n` sets. Each partition is finer than the preceeding one. The measurable space generated by
the union of all those partitions is the measurable space on `α`. -/
def countablePartition (α : Type*) [MeasurableSpace α] [CountablyGenerated α] : ℕ → Set (Set α) 
goal: ℕ → Set (Set α)

full_name: MeasurableSpace.measurableSet_enumerateCountable_countableGeneratingSet
code: lemma measurableSet_enumerateCountable_countableGeneratingSet
    (α : Type*) [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    MeasurableSet (enumerateCountable (countable_countableGeneratingSet (α := α)) ∅ n) 
goal: MeasurableSet (Set.enumerateCountable ⋯ ∅ n)

full_name: MeasurableSpace.finite_countablePartition
code: lemma finite_countablePartition (α : Type*) [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    Set.Finite (countablePartition α n) 
goal: (MeasurableSpace.countablePartition α n).Finite

full_name: MeasurableSpace.instFinite_countablePartition
code: instance instFinite_countablePartition (n : ℕ) : Finite (countablePartition α n) 
goal: Finite ↑(MeasurableSpace.countablePartition α n)

full_name: MeasurableSpace.disjoint_countablePartition
code: lemma disjoint_countablePartition {n : ℕ} {s t : Set α}
    (hs : s ∈ countablePartition α n) (ht : t ∈ countablePartition α n) (hst : s ≠ t) :
    Disjoint s t 
goal: Disjoint s t

full_name: MeasurableSpace.sUnion_countablePartition
code: lemma sUnion_countablePartition (α : Type*) [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    ⋃₀ countablePartition α n = univ 
goal: ⋃₀ MeasurableSpace.countablePartition α n = Set.univ

full_name: MeasurableSpace.measurableSet_generateFrom_countablePartition_iff
code: lemma measurableSet_generateFrom_countablePartition_iff (n : ℕ) (s : Set α) :
    MeasurableSet[generateFrom (countablePartition α n)] s
      ↔ ∃ S : Finset (Set α), ↑S ⊆ countablePartition α n ∧ s = ⋃₀ S 
goal: MeasurableSet s ↔ ∃ S, ↑S ⊆ MeasurableSpace.countablePartition α n ∧ s = ⋃₀ ↑S

full_name: MeasurableSpace.measurableSet_succ_countablePartition
code: lemma measurableSet_succ_countablePartition (n : ℕ) {s : Set α} (hs : s ∈ countablePartition α n) :
    MeasurableSet[generateFrom (countablePartition α (n + 1))] s 
goal: MeasurableSet s

full_name: MeasurableSpace.generateFrom_countablePartition_le_succ
code: lemma generateFrom_countablePartition_le_succ (α : Type*) [MeasurableSpace α] [CountablyGenerated α]
    (n : ℕ) :
    generateFrom (countablePartition α n) ≤ generateFrom (countablePartition α (n + 1)) 
goal: MeasurableSpace.generateFrom (MeasurableSpace.countablePartition α n) ≤
  MeasurableSpace.generateFrom (MeasurableSpace.countablePartition α (n + 1))

full_name: MeasurableSpace.generateFrom_iUnion_countablePartition
code: lemma generateFrom_iUnion_countablePartition (α : Type*) [m : MeasurableSpace α]
    [CountablyGenerated α] :
    generateFrom (⋃ n, countablePartition α n) = m 
goal: MeasurableSpace.generateFrom (⋃ n, MeasurableSpace.countablePartition α n) = m

full_name: MeasurableSpace.generateFrom_countablePartition_le
code: lemma generateFrom_countablePartition_le (α : Type*) [m : MeasurableSpace α] [CountablyGenerated α]
    (n : ℕ) :
    generateFrom (countablePartition α n) ≤ m 
goal: MeasurableSpace.generateFrom (MeasurableSpace.countablePartition α n) ≤ m

full_name: MeasurableSpace.measurableSet_countablePartition
code: lemma measurableSet_countablePartition (n : ℕ) {s : Set α} (hs : s ∈ countablePartition α n) :
    MeasurableSet s 
goal: MeasurableSet s

full_name: MeasurableSpace.countablePartitionSet
code: /-- The set in `countablePartition α n` to which `a : α` belongs. -/
def countablePartitionSet (n : ℕ) (a : α) : Set α 
goal: Set α

full_name: MeasurableSpace.countablePartitionSet_mem
code: lemma countablePartitionSet_mem (n : ℕ) (a : α) :
    countablePartitionSet n a ∈ countablePartition α n 
goal: MeasurableSpace.countablePartitionSet n a ∈ MeasurableSpace.countablePartition α n

full_name: MeasurableSpace.mem_countablePartitionSet
code: lemma mem_countablePartitionSet (n : ℕ) (a : α) : a ∈ countablePartitionSet n a 
goal: a ∈ MeasurableSpace.countablePartitionSet n a

full_name: MeasurableSpace.countablePartitionSet_eq_iff
code: lemma countablePartitionSet_eq_iff {n : ℕ} (a : α) {s : Set α} (hs : s ∈ countablePartition α n) :
    countablePartitionSet n a = s ↔ a ∈ s 
goal: MeasurableSpace.countablePartitionSet n a = s ↔ a ∈ s

full_name: MeasurableSpace.countablePartitionSet_of_mem
code: lemma countablePartitionSet_of_mem {n : ℕ} {a : α} {s : Set α} (hs : s ∈ countablePartition α n)
    (ha : a ∈ s) :
    countablePartitionSet n a = s 
goal: MeasurableSpace.countablePartitionSet n a = s

full_name: MeasurableSpace.measurableSet_countablePartitionSet
code: lemma measurableSet_countablePartitionSet (n : ℕ) (a : α) :
    MeasurableSet (countablePartitionSet n a) 
goal: MeasurableSet (MeasurableSpace.countablePartitionSet n a)

full_name: MeasurableSpace.CountableOrCountablyGenerated.countableOrCountablyGenerated
code: /-- A class registering that either `α` is countable or `β` is a countably generated
measurable space. -/
class CountableOrCountablyGenerated (α β : Type*) [MeasurableSpace α] [MeasurableSpace β] : Prop :=
  countableOrCountablyGenerated : Countable α ∨ MeasurableSpace.CountablyGenerated β
goal: Countable α ∨ MeasurableSpace.CountablyGenerated β

full_name: MeasurableSpace.CountableOrCountablyGenerated
code: /-- A class registering that either `α` is countable or `β` is a countably generated
measurable space. -/
class CountableOrCountablyGenerated (α β : Type*) [MeasurableSpace α] [MeasurableSpace β] : Prop :=
  countableOrCountablyGenerated : Countable α ∨ MeasurableSpace.CountablyGenerated β
goal: Prop

full_name: MeasurableSpace.instCountableOrCountablyGeneratedOfCountable
code: instance instCountableOrCountablyGeneratedOfCountable [h1 : Countable α] :
    CountableOrCountablyGenerated α β 
goal: MeasurableSpace.CountableOrCountablyGenerated α β

full_name: MeasurableSpace.instCountableOrCountablyGeneratedOfCountablyGenerated
code: instance instCountableOrCountablyGeneratedOfCountablyGenerated
    [h : MeasurableSpace.CountablyGenerated β] :
    CountableOrCountablyGenerated α β 
goal: MeasurableSpace.CountableOrCountablyGenerated α β