File: Mathlib/MeasureTheory/PiSystem.lean

full_name: IsPiSystem
code: /-- A π-system is a collection of subsets of `α` that is closed under binary intersection of
  non-disjoint sets. Usually it is also required that the collection is nonempty, but we don't do
  that here. -/
def IsPiSystem {α} (C : Set (Set α)) : Prop 
goal: Prop

full_name: MeasurableSpace.isPiSystem_measurableSet
code: theorem isPiSystem_measurableSet {α : Type*} [MeasurableSpace α] :
    IsPiSystem { s : Set α | MeasurableSet s } 
goal: IsPiSystem {s | MeasurableSet s}

full_name: IsPiSystem.singleton
code: theorem IsPiSystem.singleton {α} (S : Set α) : IsPiSystem ({S} : Set (Set α)) 
goal: IsPiSystem {S}

full_name: IsPiSystem.insert_empty
code: theorem IsPiSystem.insert_empty {α} {S : Set (Set α)} (h_pi : IsPiSystem S) :
    IsPiSystem (insert ∅ S) 
goal: IsPiSystem (insert ∅ S)

full_name: IsPiSystem.insert_univ
code: theorem IsPiSystem.insert_univ {α} {S : Set (Set α)} (h_pi : IsPiSystem S) :
    IsPiSystem (insert Set.univ S) 
goal: IsPiSystem (insert Set.univ S)

full_name: IsPiSystem.comap
code: theorem IsPiSystem.comap {α β} {S : Set (Set β)} (h_pi : IsPiSystem S) (f : α → β) :
    IsPiSystem { s : Set α | ∃ t ∈ S, f ⁻¹' t = s } 
goal: IsPiSystem {s | ∃ t ∈ S, f ⁻¹' t = s}

full_name: isPiSystem_iUnion_of_directed_le
code: theorem isPiSystem_iUnion_of_directed_le {α ι} (p : ι → Set (Set α))
    (hp_pi : ∀ n, IsPiSystem (p n)) (hp_directed : Directed (· ≤ ·) p) :
    IsPiSystem (⋃ n, p n) 
goal: IsPiSystem (⋃ n, p n)

full_name: isPiSystem_iUnion_of_monotone
code: theorem isPiSystem_iUnion_of_monotone {α ι} [SemilatticeSup ι] (p : ι → Set (Set α))
    (hp_pi : ∀ n, IsPiSystem (p n)) (hp_mono : Monotone p) : IsPiSystem (⋃ n, p n) 
goal: IsPiSystem (⋃ n, p n)

full_name: isPiSystem_image_Iio
code: theorem isPiSystem_image_Iio (s : Set α) : IsPiSystem (Iio '' s) 
goal: IsPiSystem (Set.Iio '' s)

full_name: isPiSystem_Iio
code: theorem isPiSystem_Iio : IsPiSystem (range Iio : Set (Set α)) 
goal: IsPiSystem (Set.range Set.Iio)

full_name: isPiSystem_image_Ioi
code: theorem isPiSystem_image_Ioi (s : Set α) : IsPiSystem (Ioi '' s) 
goal: IsPiSystem (Set.Ioi '' s)

full_name: isPiSystem_Ioi
code: theorem isPiSystem_Ioi : IsPiSystem (range Ioi : Set (Set α)) 
goal: IsPiSystem (Set.range Set.Ioi)

full_name: isPiSystem_image_Iic
code: theorem isPiSystem_image_Iic (s : Set α) : IsPiSystem (Iic '' s) 
goal: IsPiSystem (Set.Iic '' s)

full_name: isPiSystem_Iic
code: theorem isPiSystem_Iic : IsPiSystem (range Iic : Set (Set α)) 
goal: IsPiSystem (Set.range Set.Iic)

full_name: isPiSystem_image_Ici
code: theorem isPiSystem_image_Ici (s : Set α) : IsPiSystem (Ici '' s) 
goal: IsPiSystem (Set.Ici '' s)

full_name: isPiSystem_Ici
code: theorem isPiSystem_Ici : IsPiSystem (range Ici : Set (Set α)) 
goal: IsPiSystem (Set.range Set.Ici)

full_name: isPiSystem_Ixx_mem
code: theorem isPiSystem_Ixx_mem {Ixx : α → α → Set α} {p : α → α → Prop}
    (Hne : ∀ {a b}, (Ixx a b).Nonempty → p a b)
    (Hi : ∀ {a₁ b₁ a₂ b₂}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)) (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), p l u ∧ Ixx l u = S } 
goal: IsPiSystem {S | ∃ l ∈ s, ∃ u ∈ t, p l u ∧ Ixx l u = S}

full_name: isPiSystem_Ixx
code: theorem isPiSystem_Ixx {Ixx : α → α → Set α} {p : α → α → Prop}
    (Hne : ∀ {a b}, (Ixx a b).Nonempty → p a b)
    (Hi : ∀ {a₁ b₁ a₂ b₂}, Ixx a₁ b₁ ∩ Ixx a₂ b₂ = Ixx (max a₁ a₂) (min b₁ b₂)) (f : ι → α)
    (g : ι' → α) : @IsPiSystem α { S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S } 
goal: IsPiSystem {S | ∃ i j, p (f i) (g j) ∧ Ixx (f i) (g j) = S}

full_name: isPiSystem_Ioo_mem
code: theorem isPiSystem_Ioo_mem (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ioo l u = S } 
goal: IsPiSystem {S | ∃ l ∈ s, ∃ u ∈ t, l < u ∧ Set.Ioo l u = S}

full_name: isPiSystem_Ioo
code: theorem isPiSystem_Ioo (f : ι → α) (g : ι' → α) :
    @IsPiSystem α { S | ∃ l u, f l < g u ∧ Ioo (f l) (g u) = S } 
goal: IsPiSystem {S | ∃ l u, f l < g u ∧ Set.Ioo (f l) (g u) = S}

full_name: isPiSystem_Ioc_mem
code: theorem isPiSystem_Ioc_mem (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ioc l u = S } 
goal: IsPiSystem {S | ∃ l ∈ s, ∃ u ∈ t, l < u ∧ Set.Ioc l u = S}

full_name: isPiSystem_Ioc
code: theorem isPiSystem_Ioc (f : ι → α) (g : ι' → α) :
    @IsPiSystem α { S | ∃ i j, f i < g j ∧ Ioc (f i) (g j) = S } 
goal: IsPiSystem {S | ∃ i j, f i < g j ∧ Set.Ioc (f i) (g j) = S}

full_name: isPiSystem_Ico_mem
code: theorem isPiSystem_Ico_mem (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l < u ∧ Ico l u = S } 
goal: IsPiSystem {S | ∃ l ∈ s, ∃ u ∈ t, l < u ∧ Set.Ico l u = S}

full_name: isPiSystem_Ico
code: theorem isPiSystem_Ico (f : ι → α) (g : ι' → α) :
    @IsPiSystem α { S | ∃ i j, f i < g j ∧ Ico (f i) (g j) = S } 
goal: IsPiSystem {S | ∃ i j, f i < g j ∧ Set.Ico (f i) (g j) = S}

full_name: isPiSystem_Icc_mem
code: theorem isPiSystem_Icc_mem (s t : Set α) :
    IsPiSystem { S | ∃ᵉ (l ∈ s) (u ∈ t), l ≤ u ∧ Icc l u = S } 
goal: IsPiSystem {S | ∃ l ∈ s, ∃ u ∈ t, l ≤ u ∧ Set.Icc l u = S}

full_name: isPiSystem_Icc
code: theorem isPiSystem_Icc (f : ι → α) (g : ι' → α) :
    @IsPiSystem α { S | ∃ i j, f i ≤ g j ∧ Icc (f i) (g j) = S } 
goal: IsPiSystem {S | ∃ i j, f i ≤ g j ∧ Set.Icc (f i) (g j) = S}

full_name: generatePiSystem.inter
code: /-- Given a collection `S` of subsets of `α`, then `generatePiSystem S` is the smallest
π-system containing `S`. -/
inductive generatePiSystem {α} (S : Set (Set α)) : Set (Set α)
  | base {s : Set α} (h_s : s ∈ S) : generatePiSystem S s
  | inter {s t : Set α} (h_s : generatePiSystem S s) (h_t : generatePiSystem S t)
    (h_nonempty : (s ∩ t).Nonempty) : generatePiSystem S (s ∩ t)
goal: generatePiSystem S (s ∩ t)

full_name: generatePiSystem.base
code: /-- Given a collection `S` of subsets of `α`, then `generatePiSystem S` is the smallest
π-system containing `S`. -/
inductive generatePiSystem {α} (S : Set (Set α)) : Set (Set α)
  | base {s : Set α} (h_s : s ∈ S) : generatePiSystem S s
  | inter {s t : Set α} (h_s : generatePiSystem S s) (h_t : generatePiSystem S t)
    (h_nonempty : (s ∩ t).Nonempty) : generatePiSystem S (s ∩ t)
goal: generatePiSystem S s

full_name: generatePiSystem
code: /-- Given a collection `S` of subsets of `α`, then `generatePiSystem S` is the smallest
π-system containing `S`. -/
inductive generatePiSystem {α} (S : Set (Set α)) : Set (Set α)
  | base {s : Set α} (h_s : s ∈ S) : generatePiSystem S s
  | inter {s t : Set α} (h_s : generatePiSystem S s) (h_t : generatePiSystem S t)
    (h_nonempty : (s ∩ t).Nonempty) : generatePiSystem S (s ∩ t)
goal: Set (Set α)

full_name: isPiSystem_generatePiSystem
code: theorem isPiSystem_generatePiSystem {α} (S : Set (Set α)) : IsPiSystem (generatePiSystem S) 
goal: IsPiSystem (generatePiSystem S)

full_name: subset_generatePiSystem_self
code: theorem subset_generatePiSystem_self {α} (S : Set (Set α)) : S ⊆ generatePiSystem S 
goal: S ⊆ generatePiSystem S

full_name: generatePiSystem_subset_self
code: theorem generatePiSystem_subset_self {α} {S : Set (Set α)} (h_S : IsPiSystem S) :
    generatePiSystem S ⊆ S 
goal: generatePiSystem S ⊆ S

full_name: generatePiSystem_eq
code: theorem generatePiSystem_eq {α} {S : Set (Set α)} (h_pi : IsPiSystem S) : generatePiSystem S = S 
goal: generatePiSystem S = S

full_name: generatePiSystem_mono
code: theorem generatePiSystem_mono {α} {S T : Set (Set α)} (hST : S ⊆ T) :
    generatePiSystem S ⊆ generatePiSystem T 
goal: generatePiSystem S ⊆ generatePiSystem T

full_name: generatePiSystem_measurableSet
code: theorem generatePiSystem_measurableSet {α} [M : MeasurableSpace α] {S : Set (Set α)}
    (h_meas_S : ∀ s ∈ S, MeasurableSet s) (t : Set α) (h_in_pi : t ∈ generatePiSystem S) :
    MeasurableSet t 
goal: MeasurableSet t

full_name: generateFrom_measurableSet_of_generatePiSystem
code: theorem generateFrom_measurableSet_of_generatePiSystem {α} {g : Set (Set α)} (t : Set α)
    (ht : t ∈ generatePiSystem g) : MeasurableSet[generateFrom g] t 
goal: MeasurableSet t

full_name: generateFrom_generatePiSystem_eq
code: theorem generateFrom_generatePiSystem_eq {α} {g : Set (Set α)} :
    generateFrom (generatePiSystem g) = generateFrom g 
goal: MeasurableSpace.generateFrom (generatePiSystem g) = MeasurableSpace.generateFrom g

full_name: mem_generatePiSystem_iUnion_elim
code: /-- Every element of the π-system generated by the union of a family of π-systems
is a finite intersection of elements from the π-systems.
For an indexed union version, see `mem_generatePiSystem_iUnion_elim'`. -/
theorem mem_generatePiSystem_iUnion_elim {α β} {g : β → Set (Set α)} (h_pi : ∀ b, IsPiSystem (g b))
    (t : Set α) (h_t : t ∈ generatePiSystem (⋃ b, g b)) :
    ∃ (T : Finset β) (f : β → Set α), (t = ⋂ b ∈ T, f b) ∧ ∀ b ∈ T, f b ∈ g b 
goal: ∃ T f, t = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b

full_name: mem_generatePiSystem_iUnion_elim'
code: /-- Every element of the π-system generated by an indexed union of a family of π-systems
is a finite intersection of elements from the π-systems.
For a total union version, see `mem_generatePiSystem_iUnion_elim`. -/
theorem mem_generatePiSystem_iUnion_elim' {α β} {g : β → Set (Set α)} {s : Set β}
    (h_pi : ∀ b ∈ s, IsPiSystem (g b)) (t : Set α) (h_t : t ∈ generatePiSystem (⋃ b ∈ s, g b)) :
    ∃ (T : Finset β) (f : β → Set α), ↑T ⊆ s ∧ (t = ⋂ b ∈ T, f b) ∧ ∀ b ∈ T, f b ∈ g b 
goal: ∃ T f, ↑T ⊆ s ∧ t = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b

full_name: piiUnionInter
code: /-- From a set of indices `S : Set ι` and a family of sets of sets `π : ι → Set (Set α)`,
define the set of sets that can be written as `⋂ x ∈ t, f x` for some finset `t ⊆ S` and sets
`f x ∈ π x`. If `π` is a family of π-systems, then it is a π-system. -/
def piiUnionInter (π : ι → Set (Set α)) (S : Set ι) : Set (Set α) 
goal: Set (Set α)

full_name: piiUnionInter_singleton
code: theorem piiUnionInter_singleton (π : ι → Set (Set α)) (i : ι) :
    piiUnionInter π {i} = π i ∪ {univ} 
goal: piiUnionInter π {i} = π i ∪ {Set.univ}

full_name: piiUnionInter_singleton_left
code: theorem piiUnionInter_singleton_left (s : ι → Set α) (S : Set ι) :
    piiUnionInter (fun i => ({s i} : Set (Set α))) S =
      { s' : Set α | ∃ (t : Finset ι) (_ : ↑t ⊆ S), s' = ⋂ i ∈ t, s i } 
goal: piiUnionInter (fun i => {s i}) S = {s' | ∃ t, ∃ (_ : ↑t ⊆ S), s' = ⋂ i ∈ t, s i}

full_name: generateFrom_piiUnionInter_singleton_left
code: theorem generateFrom_piiUnionInter_singleton_left (s : ι → Set α) (S : Set ι) :
    generateFrom (piiUnionInter (fun k => {s k}) S) = generateFrom { t | ∃ k ∈ S, s k = t } 
goal: MeasurableSpace.generateFrom (piiUnionInter (fun k => {s k}) S) = MeasurableSpace.generateFrom {t | ∃ k ∈ S, s k = t}

full_name: isPiSystem_piiUnionInter
code: /-- If `π` is a family of π-systems, then `piiUnionInter π S` is a π-system. -/
theorem isPiSystem_piiUnionInter (π : ι → Set (Set α)) (hpi : ∀ x, IsPiSystem (π x)) (S : Set ι) :
    IsPiSystem (piiUnionInter π S) 
goal: IsPiSystem (piiUnionInter π S)

full_name: piiUnionInter_mono_left
code: theorem piiUnionInter_mono_left {π π' : ι → Set (Set α)} (h_le : ∀ i, π i ⊆ π' i) (S : Set ι) :
    piiUnionInter π S ⊆ piiUnionInter π' S 
goal: piiUnionInter π S ⊆ piiUnionInter π' S

full_name: piiUnionInter_mono_right
code: theorem piiUnionInter_mono_right {π : ι → Set (Set α)} {S T : Set ι} (hST : S ⊆ T) :
    piiUnionInter π S ⊆ piiUnionInter π T 
goal: piiUnionInter π S ⊆ piiUnionInter π T

full_name: generateFrom_piiUnionInter_le
code: theorem generateFrom_piiUnionInter_le {m : MeasurableSpace α} (π : ι → Set (Set α))
    (h : ∀ n, generateFrom (π n) ≤ m) (S : Set ι) : generateFrom (piiUnionInter π S) ≤ m 
goal: MeasurableSpace.generateFrom (piiUnionInter π S) ≤ m

full_name: subset_piiUnionInter
code: theorem subset_piiUnionInter {π : ι → Set (Set α)} {S : Set ι} {i : ι} (his : i ∈ S) :
    π i ⊆ piiUnionInter π S 
goal: π i ⊆ piiUnionInter π S

full_name: mem_piiUnionInter_of_measurableSet
code: theorem mem_piiUnionInter_of_measurableSet (m : ι → MeasurableSpace α) {S : Set ι} {i : ι}
    (hiS : i ∈ S) (s : Set α) (hs : MeasurableSet[m i] s) :
    s ∈ piiUnionInter (fun n => { s | MeasurableSet[m n] s }) S 
goal: s ∈ piiUnionInter (fun n => {s | MeasurableSet s}) S

full_name: le_generateFrom_piiUnionInter
code: theorem le_generateFrom_piiUnionInter {π : ι → Set (Set α)} (S : Set ι) {x : ι} (hxS : x ∈ S) :
    generateFrom (π x) ≤ generateFrom (piiUnionInter π S) 
goal: MeasurableSpace.generateFrom (π x) ≤ MeasurableSpace.generateFrom (piiUnionInter π S)

full_name: measurableSet_iSup_of_mem_piiUnionInter
code: theorem measurableSet_iSup_of_mem_piiUnionInter (m : ι → MeasurableSpace α) (S : Set ι) (t : Set α)
    (ht : t ∈ piiUnionInter (fun n => { s | MeasurableSet[m n] s }) S) :
    MeasurableSet[⨆ i ∈ S, m i] t 
goal: MeasurableSet t

full_name: generateFrom_piiUnionInter_measurableSet
code: theorem generateFrom_piiUnionInter_measurableSet (m : ι → MeasurableSpace α) (S : Set ι) :
    generateFrom (piiUnionInter (fun n => { s | MeasurableSet[m n] s }) S) = ⨆ i ∈ S, m i 
goal: MeasurableSpace.generateFrom (piiUnionInter (fun n => {s | MeasurableSet s}) S) = ⨆ i ∈ S, m i

full_name: MeasurableSpace.DynkinSystem.has_iUnion_nat
code: /-- A Dynkin system is a collection of subsets of a type `α` that contains the empty set,
  is closed under complementation and under countable union of pairwise disjoint sets.
  The disjointness condition is the only difference with `σ`-algebras.

  The main purpose of Dynkin systems is to provide a powerful induction rule for σ-algebras
  generated by a collection of sets which is stable under intersection.

  A Dynkin system is also known as a "λ-system" or a "d-system".
-/
structure DynkinSystem (α : Type*) where
  /-- Predicate saying that a given set is contained in the Dynkin system. -/
  Has : Set α → Prop
  /-- A Dynkin system contains the empty set. -/
  has_empty : Has ∅
  /-- A Dynkin system is closed under complementation. -/
  has_compl : ∀ {a}, Has a → Has aᶜ
  /-- A Dynkin system is closed under countable union of pairwise disjoint sets. Use a more general
  `MeasurableSpace.DynkinSystem.has_iUnion` instead. -/
  has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ i, Has (f i)) → Has (⋃ i, f i)
goal: Pairwise (Disjoint on f) → (∀ (i : ℕ), self.Has (f i)) → self.Has (⋃ i, f i)

full_name: MeasurableSpace.DynkinSystem.has_empty
code: /-- A Dynkin system is a collection of subsets of a type `α` that contains the empty set,
  is closed under complementation and under countable union of pairwise disjoint sets.
  The disjointness condition is the only difference with `σ`-algebras.

  The main purpose of Dynkin systems is to provide a powerful induction rule for σ-algebras
  generated by a collection of sets which is stable under intersection.

  A Dynkin system is also known as a "λ-system" or a "d-system".
-/
structure DynkinSystem (α : Type*) where
  /-- Predicate saying that a given set is contained in the Dynkin system. -/
  Has : Set α → Prop
  /-- A Dynkin system contains the empty set. -/
  has_empty : Has ∅
  /-- A Dynkin system is closed under complementation. -/
  has_compl : ∀ {a}, Has a → Has aᶜ
  /-- A Dynkin system is closed under countable union of pairwise disjoint sets. Use a more general
  `MeasurableSpace.DynkinSystem.has_iUnion` instead. -/
  has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ i, Has (f i)) → Has (⋃ i, f i)
goal: self.Has ∅

full_name: MeasurableSpace.DynkinSystem.has_compl
code: /-- A Dynkin system is a collection of subsets of a type `α` that contains the empty set,
  is closed under complementation and under countable union of pairwise disjoint sets.
  The disjointness condition is the only difference with `σ`-algebras.

  The main purpose of Dynkin systems is to provide a powerful induction rule for σ-algebras
  generated by a collection of sets which is stable under intersection.

  A Dynkin system is also known as a "λ-system" or a "d-system".
-/
structure DynkinSystem (α : Type*) where
  /-- Predicate saying that a given set is contained in the Dynkin system. -/
  Has : Set α → Prop
  /-- A Dynkin system contains the empty set. -/
  has_empty : Has ∅
  /-- A Dynkin system is closed under complementation. -/
  has_compl : ∀ {a}, Has a → Has aᶜ
  /-- A Dynkin system is closed under countable union of pairwise disjoint sets. Use a more general
  `MeasurableSpace.DynkinSystem.has_iUnion` instead. -/
  has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ i, Has (f i)) → Has (⋃ i, f i)
goal: self.Has a → self.Has aᶜ

full_name: MeasurableSpace.DynkinSystem.Has
code: /-- A Dynkin system is a collection of subsets of a type `α` that contains the empty set,
  is closed under complementation and under countable union of pairwise disjoint sets.
  The disjointness condition is the only difference with `σ`-algebras.

  The main purpose of Dynkin systems is to provide a powerful induction rule for σ-algebras
  generated by a collection of sets which is stable under intersection.

  A Dynkin system is also known as a "λ-system" or a "d-system".
-/
structure DynkinSystem (α : Type*) where
  /-- Predicate saying that a given set is contained in the Dynkin system. -/
  Has : Set α → Prop
  /-- A Dynkin system contains the empty set. -/
  has_empty : Has ∅
  /-- A Dynkin system is closed under complementation. -/
  has_compl : ∀ {a}, Has a → Has aᶜ
  /-- A Dynkin system is closed under countable union of pairwise disjoint sets. Use a more general
  `MeasurableSpace.DynkinSystem.has_iUnion` instead. -/
  has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ i, Has (f i)) → Has (⋃ i, f i)
goal: Set α → Prop

full_name: MeasurableSpace.DynkinSystem
code: /-- A Dynkin system is a collection of subsets of a type `α` that contains the empty set,
  is closed under complementation and under countable union of pairwise disjoint sets.
  The disjointness condition is the only difference with `σ`-algebras.

  The main purpose of Dynkin systems is to provide a powerful induction rule for σ-algebras
  generated by a collection of sets which is stable under intersection.

  A Dynkin system is also known as a "λ-system" or a "d-system".
-/
structure DynkinSystem (α : Type*) where
  /-- Predicate saying that a given set is contained in the Dynkin system. -/
  Has : Set α → Prop
  /-- A Dynkin system contains the empty set. -/
  has_empty : Has ∅
  /-- A Dynkin system is closed under complementation. -/
  has_compl : ∀ {a}, Has a → Has aᶜ
  /-- A Dynkin system is closed under countable union of pairwise disjoint sets. Use a more general
  `MeasurableSpace.DynkinSystem.has_iUnion` instead. -/
  has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Disjoint on f) → (∀ i, Has (f i)) → Has (⋃ i, f i)
goal: Type u_2

full_name: MeasurableSpace.DynkinSystem.ext
code: @[ext]
theorem ext : ∀ {d₁ d₂ : DynkinSystem α}, (∀ s : Set α, d₁.Has s ↔ d₂.Has s) → d₁ = d₂
  
goal: (∀ (s : Set α), d₁.Has s ↔ d₂.Has s) → d₁ = d₂

full_name: MeasurableSpace.DynkinSystem.has_compl_iff
code: theorem has_compl_iff {a} : d.Has aᶜ ↔ d.Has a 
goal: d.Has aᶜ ↔ d.Has a

full_name: MeasurableSpace.DynkinSystem.has_univ
code: theorem has_univ : d.Has univ 
goal: d.Has Set.univ

full_name: MeasurableSpace.DynkinSystem.has_iUnion
code: theorem has_iUnion {β} [Countable β] {f : β → Set α} (hd : Pairwise (Disjoint on f))
    (h : ∀ i, d.Has (f i)) : d.Has (⋃ i, f i) 
goal: d.Has (⋃ i, f i)

full_name: MeasurableSpace.DynkinSystem.has_union
code: theorem has_union {s₁ s₂ : Set α} (h₁ : d.Has s₁) (h₂ : d.Has s₂) (h : Disjoint s₁ s₂) :
    d.Has (s₁ ∪ s₂) 
goal: d.Has (s₁ ∪ s₂)

full_name: MeasurableSpace.DynkinSystem.has_diff
code: theorem has_diff {s₁ s₂ : Set α} (h₁ : d.Has s₁) (h₂ : d.Has s₂) (h : s₂ ⊆ s₁) :
    d.Has (s₁ \ s₂) 
goal: d.Has (s₁ \ s₂)

full_name: MeasurableSpace.DynkinSystem.instLEDynkinSystem
code: instance instLEDynkinSystem : LE (DynkinSystem α) 
goal: LE (MeasurableSpace.DynkinSystem α)

full_name: MeasurableSpace.DynkinSystem.le_def
code: theorem le_def {α} {a b : DynkinSystem α} : a ≤ b ↔ a.Has ≤ b.Has 
goal: a ≤ b ↔ a.Has ≤ b.Has

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

full_name: MeasurableSpace.DynkinSystem.ofMeasurableSpace
code: /-- Every measurable space (σ-algebra) forms a Dynkin system -/
def ofMeasurableSpace (m : MeasurableSpace α) : DynkinSystem α 
goal: MeasurableSpace.DynkinSystem α

full_name: MeasurableSpace.DynkinSystem.ofMeasurableSpace_le_ofMeasurableSpace_iff
code: theorem ofMeasurableSpace_le_ofMeasurableSpace_iff {m₁ m₂ : MeasurableSpace α} :
    ofMeasurableSpace m₁ ≤ ofMeasurableSpace m₂ ↔ m₁ ≤ m₂ 
goal: MeasurableSpace.DynkinSystem.ofMeasurableSpace m₁ ≤ MeasurableSpace.DynkinSystem.ofMeasurableSpace m₂ ↔ m₁ ≤ m₂

full_name: MeasurableSpace.DynkinSystem.GenerateHas.compl
code: /-- The least Dynkin system containing a collection of basic sets.
  This inductive type gives the underlying collection of sets. -/
inductive GenerateHas (s : Set (Set α)) : Set α → Prop
  | basic : ∀ t ∈ s, GenerateHas s t
  | empty : GenerateHas s ∅
  | compl : ∀ {a}, GenerateHas s a → GenerateHas s aᶜ
  | iUnion : ∀ {f : ℕ → Set α},
    Pairwise (Disjoint on f) → (∀ i, GenerateHas s (f i)) → GenerateHas s (⋃ i, f i)
goal: MeasurableSpace.DynkinSystem.GenerateHas s a → MeasurableSpace.DynkinSystem.GenerateHas s aᶜ

full_name: MeasurableSpace.DynkinSystem.GenerateHas
code: /-- The least Dynkin system containing a collection of basic sets.
  This inductive type gives the underlying collection of sets. -/
inductive GenerateHas (s : Set (Set α)) : Set α → Prop
  | basic : ∀ t ∈ s, GenerateHas s t
  | empty : GenerateHas s ∅
  | compl : ∀ {a}, GenerateHas s a → GenerateHas s aᶜ
  | iUnion : ∀ {f : ℕ → Set α},
    Pairwise (Disjoint on f) → (∀ i, GenerateHas s (f i)) → GenerateHas s (⋃ i, f i)
goal: Set α → Prop

full_name: MeasurableSpace.DynkinSystem.GenerateHas.empty
code: /-- The least Dynkin system containing a collection of basic sets.
  This inductive type gives the underlying collection of sets. -/
inductive GenerateHas (s : Set (Set α)) : Set α → Prop
  | basic : ∀ t ∈ s, GenerateHas s t
  | empty : GenerateHas s ∅
  | compl : ∀ {a}, GenerateHas s a → GenerateHas s aᶜ
  | iUnion : ∀ {f : ℕ → Set α},
    Pairwise (Disjoint on f) → (∀ i, GenerateHas s (f i)) → GenerateHas s (⋃ i, f i)
goal: MeasurableSpace.DynkinSystem.GenerateHas s ∅

full_name: MeasurableSpace.DynkinSystem.GenerateHas.iUnion
code: /-- The least Dynkin system containing a collection of basic sets.
  This inductive type gives the underlying collection of sets. -/
inductive GenerateHas (s : Set (Set α)) : Set α → Prop
  | basic : ∀ t ∈ s, GenerateHas s t
  | empty : GenerateHas s ∅
  | compl : ∀ {a}, GenerateHas s a → GenerateHas s aᶜ
  | iUnion : ∀ {f : ℕ → Set α},
    Pairwise (Disjoint on f) → (∀ i, GenerateHas s (f i)) → GenerateHas s (⋃ i, f i)
goal: Pairwise (Disjoint on f) →
  (∀ (i : ℕ), MeasurableSpace.DynkinSystem.GenerateHas s (f i)) → MeasurableSpace.DynkinSystem.GenerateHas s (⋃ i, f i)

full_name: MeasurableSpace.DynkinSystem.GenerateHas.basic
code: /-- The least Dynkin system containing a collection of basic sets.
  This inductive type gives the underlying collection of sets. -/
inductive GenerateHas (s : Set (Set α)) : Set α → Prop
  | basic : ∀ t ∈ s, GenerateHas s t
  | empty : GenerateHas s ∅
  | compl : ∀ {a}, GenerateHas s a → GenerateHas s aᶜ
  | iUnion : ∀ {f : ℕ → Set α},
    Pairwise (Disjoint on f) → (∀ i, GenerateHas s (f i)) → GenerateHas s (⋃ i, f i)
goal: t ∈ s → MeasurableSpace.DynkinSystem.GenerateHas s t

full_name: MeasurableSpace.DynkinSystem.generateHas_compl
code: theorem generateHas_compl {C : Set (Set α)} {s : Set α} : GenerateHas C sᶜ ↔ GenerateHas C s 
goal: MeasurableSpace.DynkinSystem.GenerateHas C sᶜ ↔ MeasurableSpace.DynkinSystem.GenerateHas C s

full_name: MeasurableSpace.DynkinSystem.generate
code: /-- The least Dynkin system containing a collection of basic sets. -/
def generate (s : Set (Set α)) : DynkinSystem α 
goal: MeasurableSpace.DynkinSystem α

full_name: MeasurableSpace.DynkinSystem.generateHas_def
code: theorem generateHas_def {C : Set (Set α)} : (generate C).Has = GenerateHas C 
goal: (MeasurableSpace.DynkinSystem.generate C).Has = MeasurableSpace.DynkinSystem.GenerateHas C

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

full_name: MeasurableSpace.DynkinSystem.toMeasurableSpace
code: /-- If a Dynkin system is closed under binary intersection, then it forms a `σ`-algebra. -/
def toMeasurableSpace (h_inter : ∀ s₁ s₂, d.Has s₁ → d.Has s₂ → d.Has (s₁ ∩ s₂)) :
    MeasurableSpace α 
goal: MeasurableSpace α

full_name: MeasurableSpace.DynkinSystem.ofMeasurableSpace_toMeasurableSpace
code: theorem ofMeasurableSpace_toMeasurableSpace
    (h_inter : ∀ s₁ s₂, d.Has s₁ → d.Has s₂ → d.Has (s₁ ∩ s₂)) :
    ofMeasurableSpace (d.toMeasurableSpace h_inter) = d 
goal: MeasurableSpace.DynkinSystem.ofMeasurableSpace (d.toMeasurableSpace h_inter) = d

full_name: MeasurableSpace.DynkinSystem.restrictOn
code: /-- If `s` is in a Dynkin system `d`, we can form the new Dynkin system `{s ∩ t | t ∈ d}`. -/
def restrictOn {s : Set α} (h : d.Has s) : DynkinSystem α 
goal: MeasurableSpace.DynkinSystem α

full_name: MeasurableSpace.DynkinSystem.generate_le
code: theorem generate_le {s : Set (Set α)} (h : ∀ t ∈ s, d.Has t) : generate s ≤ d 
goal: MeasurableSpace.DynkinSystem.generate s ≤ d

full_name: MeasurableSpace.DynkinSystem.generate_has_subset_generate_measurable
code: theorem generate_has_subset_generate_measurable {C : Set (Set α)} {s : Set α}
    (hs : (generate C).Has s) : MeasurableSet[generateFrom C] s 
goal: MeasurableSet s

full_name: MeasurableSpace.DynkinSystem.generate_inter
code: theorem generate_inter {s : Set (Set α)} (hs : IsPiSystem s) {t₁ t₂ : Set α}
    (ht₁ : (generate s).Has t₁) (ht₂ : (generate s).Has t₂) : (generate s).Has (t₁ ∩ t₂) 
goal: (MeasurableSpace.DynkinSystem.generate s).Has (t₁ ∩ t₂)

full_name: MeasurableSpace.DynkinSystem.generateFrom_eq
code: /-- **Dynkin's π-λ theorem**:
  Given a collection of sets closed under binary intersections, then the Dynkin system it
  generates is equal to the σ-algebra it generates.
  This result is known as the π-λ theorem.
  A collection of sets closed under binary intersection is called a π-system (often requiring
  additionally that it is non-empty, but we drop this condition in the formalization).
-/
theorem generateFrom_eq {s : Set (Set α)} (hs : IsPiSystem s) :
    generateFrom s = (generate s).toMeasurableSpace fun t₁ t₂ => generate_inter hs 
goal: MeasurableSpace.generateFrom s = (MeasurableSpace.DynkinSystem.generate s).toMeasurableSpace ⋯

full_name: MeasurableSpace.induction_on_inter
code: theorem induction_on_inter {C : Set α → Prop} {s : Set (Set α)} [m : MeasurableSpace α]
    (h_eq : m = generateFrom s) (h_inter : IsPiSystem s) (h_empty : C ∅) (h_basic : ∀ t ∈ s, C t)
    (h_compl : ∀ t, MeasurableSet t → C t → C tᶜ)
    (h_union :
      ∀ f : ℕ → Set α,
        Pairwise (Disjoint on f) → (∀ i, MeasurableSet (f i)) → (∀ i, C (f i)) → C (⋃ i, f i)) :
    ∀ ⦃t⦄, MeasurableSet t → C t 
goal: MeasurableSet t → C t